[原创]第八题：亥子合辰·塔影迷楼解题writeup-CTF对抗-看雪安全社区

[原创]第八题：亥子合辰·塔影迷楼解题writeup

发表于: 2026-8-22 10:17 45

[原创]第八题：亥子合辰·塔影迷楼解题writeup

wx_平淡无奇

2026-8-22 10:17

# 第八题「亥子合辰·塔影迷楼」逆向 Writeup

> kctf2026_CrackMe08.exe，Windows x86-64，16 字节输入，输出 `correct` 即通关。

flag：`kanxue@2o26o8!@#`

---

## 0x00 拿到题目

文件是个 PE32+（x86-64 console），5 个 section，一共 27136 字节。题目提示里塞了一堆意象：摩斯密码、16 层加密、16 个节点散落的钥匙、斐波那契、"子时通天塔"。我一开始没往深了想，先跑起来看行为。直接跑、随便输点东西，打印 `fault`。字符串里能直接搜到 `correct` 和 `fault` 两个分支，说明校验逻辑集中在一个地方，找到它基本就找到了核心。后面慢慢发现，提示里那些"16""斐波那契"其实对应的是 16 位 base-94 输入、16 组轮密钥、两个 20 轮的 Feistel 阶梯，还有那个模数 2^127-39 的来源——不过这都是把题拆完了才反应过来，刚开始完全没头绪。

## 0x01 自解密壳

`file` 出来就是个普通 PE，跑起来也能正常打印 `fault`，看起来人畜无害。但拿原文件跟脱壳后的镜像做逐字节 diff 时发现，整个 `.text` 后半段全在变：

```
RVA 0x1800 - 0x6672（约 20KB）  只有这一段不一样
```

`.text`（RVA 0x1000，vsize 0x5672）前面只留了 0x800 字节明文桩，后面 20KB 全是密文。明文桩里没几样东西：`0x1000` 是 exit，`0x1070` 是个 FNV 哈希，`0x1220` 是 syscall 号解析器，真正的入口 `0x1400012c0` 里塞着解密循环。入口先拿一个 16 字节 key 做 XOR（64 字节一轮，尾巴按字节 XOR `0x5a`），把 `0x1800` 那段解出来；解出来的又是一层 XMM 密码的解密器，负责把 `0x1d10` 往后 0x4962 字节全解开。两层套娃，手撸太累，干脆让程序自己解，我用 Unicorn 仿真到解密完成再 dump。

这一步踩了个挺深的坑。壳不走正常 CRT，`printf`/`scanf` 全换成了直接 syscall，号还不是写死的：`0x140001220` 先用 `GetModuleHandleA`+`GetProcAddress` 拿 ntdll 函数地址，再扫序言里的 `0f 05` 把号抠出来，就是 Hell's Gate 那套。我最早在 Unicorn 里只 hook 了 `GetProcAddress`，让它对每个 `Nt*` 函数名都返回同一个桩，结果这个解析器扫出来的号全是一个值——写和读的 syscall 号都被当成同一个，读输入时返回 0 字节，程序判定输入非法直接 `exit`，然后卡在一个死循环里出不来。折腾半天才搞明白：得把 `0x140001220` 这条链整段 hook 掉，按函数名直接给号（`NtWriteFile`→8、`NtReadFile`→6、`NtQuerySystemTime`→0x33、`NtQueryInformationProcess`→0x19、`NtTerminateProcess`→0x2c），再单独拦 `syscall` 指令分派——读输入就塞 16 字节进缓冲、查进程信息就返回"没被调试"、查时间清零。跑到校验函数入口 `0x140004380` 时把 `.text` 整段 dump 成 `decrypted.exe`（sha256 `1a1f305d00e521c71942b36fd6f1e03346f974f8548ffb98d4559e52886647e9`）。后面所有静态分析都基于这份镜像。

脱壳脚本就是附录 C 的 `dump_decrypted.py`。

## 0x02 定位核心函数

解密后的镜像里，`correct`/`fault` 两个字符串的交叉引用都指向同一个函数 `FUN_140004380`，校验逻辑全在这。反汇编存成 `func4380.asm`，三千多行。读下来整体是这么个流程：读 16 字节输入，先求和校验是不是 `0x500`（1280），过一遍 base-94 解码得到一个约 105 位的大整数 S，再把 S 塞进一个五次多项式输出 128 位结果，后面跟着两个 20 轮的 Feistel 阶梯，最后跟目标逐字比较，全等才 `correct`。

这套东西全在栈上做 128 位大数运算，寄存器里全是 `adc`、`setb`、`cmovb` 的进位链，纯肉眼硬啃不现实，所以下一步直接上动态仿真，把它当黑盒来拆。

## 0x03 用 Unicorn 搭仿真环境

程序会调一堆 Windows API（`GetStdHandle`、`VirtualProtect`、`GetThreadContext`、`NtQueryInformationProcess` 这些），还带反调试（读线程上下文、检查 debug 标志）。Linux 上跑不起真机，就用 Unicorn 把整个 PE 仿真起来：映射 image base `0x140000000` 和各 section，IAT 里那 8 个 API 全部指到一段假地址，hook 里按名字返回假值；`syscall` 指令（`0f 05`）单独 hook 掉；求和校验那条分支直接在 `0x140004402` 强制 `jmp` 过去，省得去改内存。

这个 harness 就是附录 D 的 `solve.py`，核心是个 `F(inp)`，喂 16 字节进去返回 6 个输出字。有了它就能黑盒观察输入到输出的映射，后面逆向每个子步骤都是拿它当 oracle 对拍——猜一个结构，跑一遍，看对不对得上。

## 0x04 认出模数 2^127 - 39

大数乘法那段最扎眼的是常数 `0x4e`（78）反复出现，跟在乘法后面做"乘 78 再加低位"的约简。反汇编里到处都是：

```
140004d5a:  b8 4e 00 00 00     mov    eax,0x4e
140004d77:  b8 4e 00 00 00     mov    eax,0x4e
140004dbc:  4c 6b c8 4e        imul   r9,rax,0x4e
140004de3:  4d 8d 41 4e        lea    r8,[r9+0x4e]
140004e86:  4c 8d 6a 4e        lea    r13,[rdx+0x4e]
```

78 = 2×39，这暗示模数形如 `2^127 - k`，因为 `2^128 ≡ 2k (mod 2^127 - k)`，当 k=39 时 `2^128 ≡ 78`，正好就是那个反复出现的约简因子。于是先猜模数 `m = 2^127 - 39`。验证不费事：从仿真器里取一轮的乘法结果 P 和两个乘数 A、B，算 `D = A*B - P`，看 D 能不能被 `2^127-39` 整除。整除，而且查了下 `2^127-39` 是个素数。就坐实了——所有 128 位"乘法"其实都是 `mod (2^127-39)` 的模乘。

## 0x05 还原 Feistel 轮函数

阶梯部分反复出现 `ror 0x2f`、`ror 0x33`，还有 `0x9e3779b97f4a7c15`——黄金比例 φ 的倒数，TEA/XTEA 系常用。反汇编里：

```
140005b2b:  49 c1 ce 2f        ror    r14,0x2f
140005bca:  49 c1 ce 33        ror    r14,0x33
140005bd7:  48 b8 15 7c 4a 7f b9  movabs rax,0x9e3779b97f4a7c15
```

我第一反应是 XXTEA，毕竟这常数太标志性了。照着 XXTEA 的结构套了半天对不上，才回头老老实实逐轮对拍寄存器。拍下来单轮函数长这样：

```
G(x, c):
    B = (x << 64) | c
    P = (M * B) mod m          # M 是固定 128 位乘数
    X = ror64(P_hi, 0x2f) ^ c ^ P_lo
    return ror64(X, 0x33) ^ SBOX(X)
```

SBOX 是按字节查表，256 字节，但不是置换。我直接在 `0x140004ee9` 那里把 `rbp+0x60` 的 256 字节抓出来，开头长这样：

```
4e d8 35 17 2d 8e 91 6b ab 65 30 f2 8a de da 18
6f 5c f0 9e 60 89 81 62 90 46 fd 61 3d aa 94 9f
...
```

`M = 0x4d8a9e9343d415cb83a0a488ec8523fe`。整个阶梯是个标准两分支 Feistel，20 轮，每轮：

```
L' = G(L, c_i) ^ R
R' = G(L', c_i ^ golden) ^ L
```

轮密钥 `c_i = K_parity(i) ^ keys[i]`，偶数轮用 `K_even=0x553d3c5ef6ee11ff`、奇数轮用 `K_odd=0x4aeee52b5738eb8f`。两个阶梯的 keys 我直接从栈上 dump：阶梯 1 的 20 个 qword 在 `rbp+0x160`，阶梯 2 的在 `rbp+0x200`，写进 `feistel.py` 就是 `keys1`/`keys2`。这里有个容易漏的细节——第二个阶梯的奇偶性反过来了，反汇编里阶梯 1 用 `cmove`、阶梯 2 用 `cmovne` 选 K，不仔细看就把两个阶梯当成一模一样的了。

Feistel 的好处是可逆，反演只要把轮倒过来跑：

```
for i in reversed(range(20)):
    Lp = G(L, c_i ^ golden) ^ R
    R  = G(Lp, c_i) ^ L
    L  = Lp
```

这部分写成 `feistel.py`（附录 A），正反都过了 roundtrip 验证。

## 0x06 逆推出阶梯输入 T

反演两个阶梯，就得到"能让输出匹配目标"的阶梯输入：

```
T = 0x4be831b0ad3a2d361489375bba3fb8de
```

其中 r11 是高 64 位 `0x4be831b0ad3a2d36`，r10 是低 64 位 `0x1489375bba3fb8de`。字节序是在 `0x140005900` 处确认的，那里有 `mov r9,r11` 和 `mov r12,r10`，r11 是高 64 位、r10 是低 64 位。目标那 6 个字是 `.tgt` 段里躺着的 6 个 64 位大数，反演就是拿这 6 个目标当阶梯输出，把轮倒着跑一遍得到输入。具体过程我把正反两个方向的实现都写进了 `feistel.py`，对着 `solve.py` 的 `F()` 反复对拍才确认没搞反。

## 0x07 预处理是五次多项式

从 base-94 解码出来的 S，经过一段 Horner 求值，输出 128 位。这段我把 Horner 循环里反复 load 的那五个 128 位常数 dump 出来，预处理就是：

```
P(S) = S^5 + C1*S^4 + C2*S^3 + C3*S^2 + C4*S + C5  (mod m)
```

系数：

```
C1 = 0x21b3bde1acf9adfa471fb28461a53bb5
C2 = 0x191a3870ad3d941105f15a9c38aae874
C3 = 0x40c190e211322caa2f01797348f02c97
C4 = 0x1df732140b8a3ef758fd09bde0058a37
C5 = 0x3f0cb8512c6f88e47e5f164fb478aab5
```

这里踩了全程最坑的一个坑。我一开始用测试输入 `0x50`×16 去对拍，dump 出来的 S 只有低 64 位 `0xec3fb8af41531605`，拿它算 `P(S)` 跟仿真器死活对不上。排查了半天才发现：S 的高 13 位还在 `r15` 寄存器里没写进内存——`mov [rbp+0x7d8], r15` 这条写内存的指令在我的 dump 点（`0x140004ee9`）之后才执行。补全高 64 位后：

```
S_full = 47 * (94^16 - 1)/93 = 0xed048f469eec3fb8af41531605
P(S_full) = 0xcfe76e7f9f9568e8140229e9b40ed1f   # 与仿真器 r11:r10 完全一致
```

多项式方向这才确认无误。

## 0x08 解五次方程

剩下就是解 `P(S) ≡ T (mod m)`，一个 GF(2^127-39) 上的五次方程。用 sympy 在有限域上分解：

```
P(x) - T = (x - S) * (两个不可约二次因式)
```

只有一个线性因子，所以根唯一：

```
S = 29524214495202137505193489633964
  = 0x174a5e1d4cf4f146e72f70092ac
```

代回去验证 `P(S) == T` 成立。求根脚本是附录 B 的 `solve_poly.py`。

## 0x09 base-94 解码还原 flag

S 是按 base-94、低位在右拼出来的：`S = Σ (byte_i - 33) * 94^(15-i)`。倒过来把 S 逐次 `mod 94` 取位，得到 16 个数字：

```
[74, 64, 77, 87, 84, 68, 31, 17, 78, 17, 21, 78, 23, 0, 31, 2]
```

每个加 33 转回字符：

```
kanxue@2o26o8!@#
```

前缀 `kanxue@` 一看就对——看雪 KCTF 的题。求和 1280，正好过 `0x500` 那关。

## 0x0A 收尾验证

把 `kanxue@2o26o8!@#` 喂回 `solve.py` 的 `F()`，6 个输出字全部命中目标：

```
b8fd0694401d3d03  c14db1c20dd97a8  aca5240a53fb78a6
9a2789b6de31c2dc  6cd601b3049aa32c  bc1e5ebe1e4ec0d4
```

到这题就完了。回头看整个逆推路径挺顺的：先把 Feistel 逆掉拿到目标输入 T，再解五次多项式拿到 S，最后 base-94 解码出 flag。难的是中间那些认模数、还原轮函数、抓 S 高 64 位的细节，每一步都得跟仿真器对拍才敢往下走。

## 0x0B 所用工具与环境

系统 Linux（Kali），Python 3.13。

- Ghidra——静态反编译，`FUN_140004380` 那三千多行主要靠它读。
- `unicorn` 2.1.2——x86-64 仿真，脱壳 dump 和校验 oracle 都靠它。
- `capstone` 5.0.6——反汇编，抠解密桩、确认字节序时用。
- `sympy` 1.14.0——在 GF(2^127-39) 上做因式分解求根。

四个脚本各干一件事：`dump_decrypted.py` 脱壳，`solve.py` 当 oracle，`feistel.py` 是算法正反实现，`solve_poly.py` 求根。完整代码见附录 A–D。

---

## 附录 A：feistel.py（核心算法）

```python
MASK = (1<<64)-1
M = (0x4d8a9e9343d415cb << 64) | 0x83a0a488ec8523fe
m = (1<<127) - 39
golden = 0x9e3779b97f4a7c15
K_even = 0x553d3c5ef6ee11ff
K_odd  = 0x4aeee52b5738eb8f

keys1 = [int(x,16) for x in '454ab6cf8f0fe386 0715664a40e9f5f5 9306305b57fba9a1 e98c2c52e5ebb7db fb3fd083f20738c3 ccb6f8a75c3fde1b 2131dd38af5d4e80 a08b202d0096f0cd d910717024bb4898 08e30f948a63f886 3f28976422a1b7ea 509fd4dac702028b 4ed3c0879a56c01f 5c804f2b54da01e2 b04119cd47a9c4e0 ef0de2ad3c4820ed 9e75101fa5267b0a a384473bb6e5fdd3 2d2fb4022ad6e75c c5e6b576cdfde33a'.split()]
keys2 = [int(x,16) for x in '2ed2623056d887ca e92dca64a141d5cd 1d02ff225704d8b1 0b0d6805938ef7ae 0a01b809b4db4979 278f6d0b94b2807a aa84f0fe9065c8c1 7e12bb8870263861 3d83911ea614bcc9 bb029af798e7fdb8 77987d613901bf2c 1f361c6f01079151 81be53204377a779 b6c2ea68e2d1cb8e 8b0092e801b74adf 4f2aa76b3dca3cc6 1e15d17b38674c35 0bd225cefa215284 7c9333ccbee8e7c8 751956b3089db2bc'.split()]

sbox = bytes.fromhex('4ed835172d8e916bab6530f28adeda186f5cf09e608981629046fd613daa949f88e22fc430b64f4fde66b80ade4067d76d6551e656e1e540232e61488b476f4c9996650cfff1f87593c03fd152ae048c388dcbf88159a1104c80a10331e6195cd8be465021e378d8f386d0c7fb358fac7974d4426b84f57e49d5266688b37841182b9230bd9500caedf4df297b70e3d98ac1baa1795b5a8da5927489c7a402ba08db3e554db27324da17ac9c1ba512e1d1151e090e57da9e74ded1365352d4e966536e03cd266e1bcb2d5776460932554c37cc9f00faddcd2e92fe3d0e71ac89dc183d87d5fa40efa98c65da9d7dc32fc092638af4e673fc81a5ad390563c349')

def ror64(x, n):
    n &= 63
    return ((x >> n) | (x << (64-n))) & MASK

def SBOX(x):
    r = 0
    for i in range(8):
        b = (x >> (8*i)) & 0xff
        r |= sbox[b] << (8*i)
    return r

def G(x, c):
    B = (x << 64) | c
    P = (M * B) % m
    P_hi = P >> 64
    P_lo = P & MASK
    X = ror64(P_hi, 0x2f) ^ c ^ P_lo
    return ror64(X, 0x33) ^ SBOX(X)

def ladder(L, R, keys, ke, ko):
    for i in range(20):
        c = (ke if (i & 1) == 0 else ko) ^ keys[i]
        Lp = G(L, c) ^ R
        Rp = G(Lp, c ^ golden) ^ L
        L, R = Lp, Rp
    return L, R

def inv_ladder(L_out, R_out, keys, ke, ko):
    L, R = L_out, R_out
    for i in range(19, -1, -1):
        c = (ke if (i & 1) == 0 else ko) ^ keys[i]
        Lp = G(L, c ^ golden) ^ R
        R = G(Lp, c) ^ L
        L = Lp
    return L, R
```

注意：阶梯 1 用 `ladder(L, R, keys1, K_even, K_odd)`，阶梯 2 奇偶颠倒，用 `ladder(L, R, keys2, K_odd, K_even)`。

## 附录 B：求根（solve_poly.py）

```python
m = (1<<127) - 39
C1 = 0x21b3bde1acf9adfa471fb28461a53bb5
C2 = 0x191a3870ad3d941105f15a9c38aae874
C3 = 0x40c190e211322caa2f01797348f02c97
C4 = 0x1df732140b8a3ef758fd09bde0058a37
C5 = 0x3f0cb8512c6f88e47e5f164fb478aab5
T = (0x4be831b0ad3a2d36 << 64) | 0x1489375bba3fb8de

import sympy as sp
x = sp.symbols('x')
poly = (x**5 + C1*x**4 + C2*x**3 + C3*x**2 + C4*x + (C5 - T) % m)
fac = sp.factor(poly, modulus=m)
print(fac)
# (x - 29524214495202137505193489633964) * (两个二次不可约因式)

S = 29524214495202137505193489633964
digits = []
for i in range(16):
    digits.append(S % 94); S //= 94
flag = bytes(d + 33 for d in digits[::-1])
print(flag)   # b'kanxue@2o26o8!@#'
```

## 附录 C：dump_decrypted.py（脱壳脚本）

```python
#!/usr/bin/env python3
# 把自解密的 CrackMe08 跑起来，解完 dump 出 decrypted.exe
import struct
from unicorn import *
from unicorn.x86_const import *

IMAGE_BASE = 0x140000000
STACK_BASE = 0x141000000
STACK_SIZE = 0x400000
GS_BASE    = 0x142000000
HOOK_BASE  = 0x143000000
NtdllMod   = 0x144000000
SENTINEL   = 0x143FF0000

# 8 个 IAT 项 -> 假地址
FAKE = {
    'GetStdHandle':       HOOK_BASE + 0x000,
    'GetCurrentProcess':  HOOK_BASE + 0x100,
    'FlushInstructionCache': HOOK_BASE + 0x200,
    'VirtualProtect':     HOOK_BASE + 0x300,
    'GetModuleHandleA':   HOOK_BASE + 0x400,
    'GetProcAddress':     HOOK_BASE + 0x500,
    'GetCurrentThread':   HOOK_BASE + 0x600,
    'GetThreadContext':   HOOK_BASE + 0x700,
}
FAKE_NtQueryInfo = NtdllMod + 0x1400
IAT = {
    0x140007000: 'GetStdHandle',
    0x140007008: 'GetCurrentProcess',
    0x140007010: 'FlushInstructionCache',
    0x140007018: 'VirtualProtect',
    0x140007020: 'GetModuleHandleA',
    0x140007028: 'GetProcAddress',
    0x140007030: 'GetCurrentThread',
    0x140007038: 'GetThreadContext',
}
# (va, vsize, raw)  来自原文件 section 表
SECTIONS = [
    (0x1000, 0x5672, 0x400),
    (0x7000, 0x6e2,  0x5c00),
    (0x8000, 0x24,   0x6400),
    (0x9000, 0x1bc,  0x6600),
    (0xa000, 0x70,   0x6800),
]

def load_original(uc):
    data = open('kctf2026_CrackMe08.exe', 'rb').read()   # <-- 原始加密文件
    uc.mem_map(IMAGE_BASE, 0xb000)
    uc.mem_write(IMAGE_BASE, data[:0x400])
    for va, vsize, raw in SECTIONS:
        uc.mem_write(IMAGE_BASE + va, data[raw:raw+vsize])
    for a, n in IAT.items():
        uc.mem_write(a, struct.pack('<Q', FAKE[n]))
    uc.mem_map(STACK_BASE, STACK_SIZE)
    uc.mem_map(GS_BASE, 0x1000)
    uc.mem_write(GS_BASE + 0x60, struct.pack('<Q', 0))   # PEB 假指针
    uc.mem_map(HOOK_BASE, 0x10000)
    uc.mem_map(NtdllMod, 0x2000)
    # 桩: mov eax,0x19; syscall; ret
    uc.mem_write(FAKE_NtQueryInfo, bytes([0xb8, 0x19, 0, 0, 0, 0x0f, 0x05, 0xc3]))
    uc.mem_map(SENTINEL & ~0xfff, 0x1000)

def read_str(uc, addr):
    try:
        b = uc.mem_read(addr, 64)
    except UcError:
        return ''
    return b.split(b'\x00')[0].decode('latin1')

# 五个直接 syscall 的假号（只要互不相同，hook 里能区分就行）
SYS = {
    'NtWriteFile':               8,
    'NtReadFile':                6,
    'NtTerminateProcess':        0x2c,
    'NtQuerySystemTime':         0x33,
    'NtQueryInformationProcess': 0x19,
}

def hook_code(uc, address, size, user):
    # rdtsc -> 返回 0
    try:
        if uc.mem_read(address, 2) == b'\x0f\x31':
            uc.reg_write(UC_X86_REG_RAX, 0)
            uc.reg_write(UC_X86_REG_RDX, 0)
            uc.reg_write(UC_X86_REG_RIP, address + 2)
            return
    except Exception:
        pass
    # syscall 号解析器 0x140001220：直接按函数名给号，绕过 Hell's Gate 扫 ntdll
    if address == 0x140001220:
        name = read_str(uc, uc.reg_read(UC_X86_REG_RCX))
        num = SYS.get(name, -1)
        uc.reg_write(UC_X86_REG_RAX, num)
        ret = struct.unpack('<Q', uc.mem_read(uc.reg_read(UC_X86_REG_RSP), 8))[0]
        uc.reg_write(UC_X86_REG_RIP, ret)
        uc.reg_write(UC_X86_REG_RSP, uc.reg_read(UC_X86_REG_RSP) + 8)
        return
    # 假 API：按名字返回假值，然后 ret
    if address in FAKE.values():
        name = [k for k, v in FAKE.items() if v == address][0]
        if name == 'GetModuleHandleA':
            rc = uc.reg_read(UC_X86_REG_RCX)
            uc.reg_write(UC_X86_REG_RAX, IMAGE_BASE if rc == 0 else NtdllMod)
        elif name == 'GetProcAddress':
            uc.reg_write(UC_X86_REG_RAX, FAKE_NtQueryInfo)
        elif name == 'GetCurrentProcess':
            uc.reg_write(UC_X86_REG_RAX, 0x1234)
        elif name == 'GetCurrentThread':
            uc.reg_write(UC_X86_REG_RAX, 0x5678)
        elif name == 'GetThreadContext':
            ctx = uc.reg_read(UC_X86_REG_RDX)
            uc.mem_write(ctx, b'\x00' * 0x300)
            uc.mem_write(ctx + 0x30, struct.pack('<I', 0x100010))
            uc.reg_write(UC_X86_REG_RAX, 1)
        else:
            uc.reg_write(UC_X86_REG_RAX, 1)   # GetStdHandle/VirtualProtect/FlushInstructionCache
        ret = struct.unpack('<Q', uc.mem_read(uc.reg_read(UC_X86_REG_RSP), 8))[0]
        uc.reg_write(UC_X86_REG_RIP, ret)
        uc.reg_write(UC_X86_REG_RSP, uc.reg_read(UC_X86_REG_RSP) + 8)
        return
    if address == SENTINEL:
        uc.emu_stop()
        return
    # 跑到校验函数入口 = 说明解密全完成了，dump
    if address == 0x140004380 and not user['done']:
        user['done'] = True
        text = uc.mem_read(IMAGE_BASE + 0x1000, 0x5672)
        # 拼回一个完整 PE：读原文件，替换 .text 段
        orig = bytearray(open('kctf2026_CrackMe08.exe', 'rb').read())
        orig[0x400:0x400 + 0x5672] = text
        open('/tmp/decrypted.exe', 'wb').write(bytes(orig))
        print('[+] 已 dump 到 /tmp/decrypted.exe，.text 长度 0x%x' % len(text))
        uc.emu_stop()
        return

def hook_syscall(uc, user):
    eax = uc.reg_read(UC_X86_REG_RAX) & 0xffffffff
    rsp = uc.reg_read(UC_X86_REG_RSP)
    if eax == 6:                          # NtReadFile：往输入缓冲写 16 字节
        buf = struct.unpack('<Q', uc.mem_read(rsp + 0x30, 8))[0]
        iosb = struct.unpack('<Q', uc.mem_read(rsp + 0x28, 8))[0]
        uc.mem_write(buf, user['input'])
        uc.mem_write(iosb, struct.pack('<I', 0))        # Status = 成功
        uc.mem_write(iosb + 8, struct.pack('<Q', len(user['input'])))  # 读到的字节数
    elif eax == 0x19:                     # NtQueryInformationProcess：返回"未被调试"
        r8 = uc.reg_read(UC_X86_REG_R8)
        try:
            uc.mem_write(r8, b'\x00' * 8)
        except UcError:
            uc.mem_map(r8 & ~0xfff, 0x1000)
            uc.mem_write(r8, b'\x00' * 8)
    elif eax == 0x33:                     # NtQuerySystemTime：时间戳清零
        r10 = uc.reg_read(UC_X86_REG_R10)
        try:
            uc.mem_write(r10, b'\x00' * 8)
        except UcError:
            uc.mem_map(r10 & ~0xfff, 0x1000)
            uc.mem_write(r10, b'\x00' * 8)
    # eax==8 是 NtWriteFile，eax==0x2c 是 NtTerminateProcess，都只置成功即可
    uc.reg_write(UC_X86_REG_RAX, 0)

def hook_mem_unmapped(uc, access, address, size, value, user):
    # 任何未映射的读写都自动补映射，避免启动流程的零星访问打断 dump
    page = address & ~0xfff
    try:
        uc.mem_map(page, 0x1000)
    except UcError:
        pass
    return True

def main():
    uc = Uc(UC_ARCH_X86, UC_MODE_64)
    load_original(uc)
    user = {'done': False, 'input': b'\x50' * 16}   # 16 字节输入，求和正好 0x500
    uc.hook_add(UC_HOOK_CODE, hook_code, user_data=user)
    uc.hook_add(UC_HOOK_INSN, hook_syscall, user, 1, 0, UC_X86_INS_SYSCALL)
    uc.hook_add(UC_HOOK_MEM_UNMAPPED, hook_mem_unmapped, user_data=user)
    # 准备一个假输入区（16 字节），万一起动流程提前读输入
    ia = 0x145000000
    uc.mem_map(ia & ~0xfff, 0x1000)
    uc.mem_write(ia, user['input'])
    rsp = STACK_BASE + 0x3F0000
    uc.mem_write(rsp, struct.pack('<Q', SENTINEL))   # 返回地址哨兵
    uc.reg_write(UC_X86_REG_RSP, rsp)
    uc.reg_write(UC_X86_REG_GS_BASE, GS_BASE)
    try:
        uc.emu_start(0x1400012c0, 0, timeout=0, count=0)   # 从入口桩开始
    except UcError as e:
        print('[!] 仿真结束:', e)
    if not user['done']:
        print('[!] 没跑到 0x140004380，可能卡在某处，检查 hook')

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

## 附录 D：solve.py（仿真 oracle）

```python
#!/usr/bin/env python3
import struct, sys
from unicorn import *
from unicorn.x86_const import *
import unicorn.x86_const as X86

IMAGE_BASE=0x140000000; STACK_BASE=0x141000000; STACK_SIZE=0x400000
GS_BASE=0x142000000; HOOK_BASE=0x143000000; NtdllMod=0x144000000; SENTINEL=0x143FF0000
FAKE={'GetStdHandle':HOOK_BASE+0x0,'GetCurrentProcess':HOOK_BASE+0x100,'FlushInstructionCache':HOOK_BASE+0x200,'VirtualProtect':HOOK_BASE+0x300,'GetModuleHandleA':HOOK_BASE+0x400,'GetProcAddress':HOOK_BASE+0x500,'GetCurrentThread':HOOK_BASE+0x600,'GetThreadContext':HOOK_BASE+0x700}
FAKE_NtQueryInfo=NtdllMod+0x1400
IAT={0x140007000:'GetStdHandle',0x140007008:'GetCurrentProcess',0x140007010:'FlushInstructionCache',0x140007018:'VirtualProtect',0x140007020:'GetModuleHandleA',0x140007028:'GetProcAddress',0x140007030:'GetCurrentThread',0x140007038:'GetThreadContext'}
SECTIONS=[(0x1000,0x5672,0x400),(0x7000,0x6e2,0x5c00),(0x8000,0x24,0x6400),(0x9000,0x1bc,0x6600),(0xa000,0x70,0x6800)]

def load(uc):
    data=open('/tmp/decrypted.exe','rb').read()
    uc.mem_map(IMAGE_BASE,0xb000); uc.mem_write(IMAGE_BASE,data[:0x400])
    for va,vsize,raw in SECTIONS: uc.mem_write(IMAGE_BASE+va,data[raw:raw+vsize])
    for a,n in IAT.items(): uc.mem_write(a,struct.pack('<Q',FAKE[n]))
    uc.mem_map(STACK_BASE,STACK_SIZE)
    uc.mem_map(GS_BASE,0x1000); uc.mem_write(GS_BASE+0x60,struct.pack('<Q',0))
    uc.mem_map(HOOK_BASE,0x10000)
    uc.mem_map(NtdllMod,0x2000); uc.mem_write(FAKE_NtQueryInfo,bytes([0xb8,0x19,0,0,0,0x0f,0x05,0xc3]))
    uc.mem_map(SENTINEL&~0xfff,0x1000)

def hook_code(uc,address,size,user):
    try:
        if uc.mem_read(address,2)==b'\x0f\x31':
            uc.reg_write(UC_X86_REG_RAX,0); uc.reg_write(UC_X86_REG_RDX,0); uc.reg_write(UC_X86_REG_RIP,address+2); return
    except: pass
    if address==0x140004402:
        # bypass sum check WITHOUT modifying memory: force jump to 0x140004411
        uc.reg_write(UC_X86_REG_RIP, 0x140004411); return
    if address in FAKE.values():
        name=[k for k,v in FAKE.items() if v==address][0]
        if name=='GetModuleHandleA':
            rc=uc.reg_read(UC_X86_REG_RCX); uc.reg_write(UC_X86_REG_RAX, IMAGE_BASE if rc==0 else NtdllMod)
        elif name=='GetProcAddress': uc.reg_write(UC_X86_REG_RAX, FAKE_NtQueryInfo)
        elif name=='GetCurrentProcess': uc.reg_write(UC_X86_REG_RAX,0x1234)
        elif name=='GetCurrentThread': uc.reg_write(UC_X86_REG_RAX,0x5678)
        elif name=='GetThreadContext':
            ctx=uc.reg_read(UC_X86_REG_RDX); uc.mem_write(ctx,b'\x00'*0x300); uc.mem_write(ctx+0x30,struct.pack('<I',0x100010)); uc.reg_write(UC_X86_REG_RAX,1)
        else: uc.reg_write(UC_X86_REG_RAX,1)
        retaddr=struct.unpack('<Q',uc.mem_read(uc.reg_read(UC_X86_REG_RSP),8))[0]
        uc.reg_write(UC_X86_REG_RIP,retaddr); uc.reg_write(UC_X86_REG_RSP,uc.reg_read(UC_X86_REG_RSP)+8); return
    if address==SENTINEL: uc.emu_stop(); return
    if address==0x140004c05:
        rbp=uc.reg_read(UC_X86_REG_RBP)
        X=struct.unpack('<Q',uc.mem_read(rbp+0x540,8))[0]
        Y=struct.unpack('<Q',uc.mem_read(rbp+0x548,8))[0]
        user['X']=X; user['Y']=Y
        user['FNV12']=struct.unpack('<Q',uc.mem_read(rbp-0x30,8))[0]
        user['FNV13']=struct.unpack('<Q',uc.mem_read(rbp-0x38,8))[0]
        return
    if address==0x14000660e:
        user['final']=True
        r={}
        for reg in ['r12','r10','rbx','r14','rdi','r9','rbp','rsp']:
            r[reg]=uc.reg_read(getattr(X86,'UC_X86_REG_'+reg.upper()))
        user['final_regs']=r
        rbp=r['rbp']; rsp=r['rsp']
        user['targets']=[struct.unpack('<Q',uc.mem_read(rbp+0x38,8))[0],struct.unpack('<Q',uc.mem_read(rbp+0x40,8))[0],struct.unpack('<Q',uc.mem_read(rbp+0x48,8))[0],struct.unpack('<Q',uc.mem_read(rbp+0x50,8))[0],struct.unpack('<Q',uc.mem_read(rbp+0x58,8))[0],struct.unpack('<Q',uc.mem_read(rsp+0x60,8))[0]]
        return

def hook_syscall(uc,user):
    eax=uc.reg_read(UC_X86_REG_RAX)&0xffffffff; r8=uc.reg_read(UC_X86_REG_R8)
    if eax==0x19: uc.mem_write(r8,b'\x00'*8)
    uc.reg_write(UC_X86_REG_RAX,0)

def run(inp):
    uc=Uc(UC_ARCH_X86,UC_MODE_64); load(uc); user={'final':False}
    uc.hook_add(UC_HOOK_CODE,hook_code,user_data=user)
    uc.hook_add(UC_HOOK_INSN,hook_syscall,None,1,0,UC_X86_INS_SYSCALL)
    ia=0x145000000; uc.mem_map(ia&~0xfff,0x1000); uc.mem_write(ia,inp)
    rsp=STACK_BASE+0x3F0000; uc.mem_write(rsp,struct.pack('<Q',SENTINEL))
    uc.reg_write(UC_X86_REG_RSP,rsp); uc.reg_write(UC_X86_REG_RCX,ia); uc.reg_write(UC_X86_REG_GS_BASE,GS_BASE)
    try: uc.emu_start(0x140004380,0,timeout=0,count=0)
    except UcError as e: pass
    return user

def F(inp):
    u=run(inp)
    r=u['final_regs']
    return [r['r12'],r['r10'],r['rbx'],r['r14'],r['rdi'],r['r9']], u

if __name__=='__main__':
    u=run(bytes(16))
    print('X=%016x Y=%016x'%(u['X'],u['Y']))
    print('FNV12=%016x FNV13=%016x'%(u['FNV12'],u['FNV13']))
    print('targets:', [hex(x) for x in u['targets']])
    out,u=F(bytes([0x50]*16))
    print('F(0x50..):', [hex(x) for x in out])
```

回复或点赞可查看完整内容

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

上传的附件：