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

[原创]第八题「亥子合辰·塔影迷楼」解析

发表于: 2026-8-21 14:48 37

[原创]第八题「亥子合辰·塔影迷楼」解析

教教我吧~

2026-8-21 14:48

## 目录

- [0. 结论速览](#0-结论速览)
- [1. 题目信息](#1-题目信息)
- [2. 第一眼：先看清这是个什么东西](#2-第一眼先看清这是个什么东西)
- [3. 预备知识：本题会用到的几个"零件"](#3-预备知识本题会用到的几个零件)
- [4. 第一层：入口处的自解密](#4-第一层入口处的自解密)
- [5. 第二层：拿"自己的代码"当密钥](#5-第二层拿自己的代码当密钥)
- [6. 第三层入口：两道障眼法](#6-第三层入口两道障眼法)
- [7. 核心校验函数总览](#7-核心校验函数总览)
- [8. 常量从哪来：splitmix64 填充 CONTEXT](#8-常量从哪来splitmix64-填充-context)
- [9. 反调试](#9-反调试)
- [10. 输入怎么变成一个数：base-94 解码](#10-输入怎么变成一个数base-94-解码)
- [11. 五次多项式](#11-五次多项式)
- [12. 两条 20 轮 Feistel 置换](#12-两条-20-轮-feistel-置换)
- [13. 求解思路：为什么能倒着算回去](#13-求解思路为什么能倒着算回去)
- [14. 完整脚本](#14-完整脚本)
- [15. 验证](#15-验证)
- [16. 小结与踩坑记录](#16-小结与踩坑记录)

---

## 0. 结论速览

程序要求输入 **16 个字符**，正确时输出 `correct`，否则输出 `fault`。

整个校验的数学本质是：

1. 把 16 个字符当成一个 **94 进制大整数**（每个字符减去 33，即以 `'!'` 为 0），得到 `acc`；
2. 把 `acc` 代入一个模 `p = 2¹²⁷ − 39` 的**五次多项式**，得到 `r`；
3. 把 `r` 的高低 64 位送进**两条 20 轮 Feistel 置换**；
4. 结果与程序内置的目标常量比对。

Feistel 置换是**双射（可逆）**，所以可以从目标常量倒推回 `r`；再在有限域 GF(p) 上给五次方程求根，就能拿到 `acc`；最后按 94 进制展开，就是 flag。

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

（字符和恰好 1280，正好满足程序里的另一个校验条件。）

---

## 1. 题目信息

| 项目      | 值                                                           |
| --------- | ------------------------------------------------------------ |
| 文件名    | `kctf2026_CrackMe08.exe`                                     |
| 大小      | 27,136 字节                                                  |
| 类型      | Windows x64 PE（控制台）                                     |
| ImageBase | `0x140000000`                                                |
| MD5       | `88c2ab23c7b77a560ce5bef6ecc4adc3`                           |
| SHA256    | `b0dae7a21b059805a35fc5490f84a607d00afb28ad6b5b9f9ebc31574c382ea1` |

用到的工具：

- **IDA Pro 9.x**（含 Hex-Rays 反编译器）——静态分析主力
- **Python 3.12**——写求解脚本，只用标准库，不需要装 sympy / gmpy

---

## 2. 第一眼：先看清这是个什么东西

拖进 IDA，先别急着看代码，先看几个全局特征。

### 2.1 节区表

```
.text    0x140001000 - 0x140007000   rx    代码
.idata   0x140007000 - 0x140007050   r     导入表
.rdata   0x140007050 - 0x140008000   r     只读数据
.data    0x140008000 - 0x140009000   rw    可写数据
.pdata   0x140009000 - 0x14000a000   r     异常表
.tgt     0x14000a000 - 0x14000b000   rw    ← 自定义节区，可疑
```

最后那个 `.tgt` 不是编译器生成的标准节区名，是作者自己加的。经验上，这种自定义节区里往往放着**参数和目标密文**。后面会看到，确实如此。

### 2.2 导入表

整个程序只导入了 8 个 API：

```
GetStdHandle          GetCurrentProcess     FlushInstructionCache
VirtualProtect        GetModuleHandleA      GetProcAddress
GetCurrentThread      GetThreadContext
```

信息量很大：

- **没有 `printf` / `scanf` / `ReadFile` / `WriteFile`**——但程序明显要读写控制台，说明 I/O 是用别的方式做的；
- `VirtualProtect` + `FlushInstructionCache` 是**自修改代码（SMC）的标志**：改内存属性 → 改代码 → 刷新指令缓存；
- `GetThreadContext` 常用来读**调试寄存器 Dr0–Dr7**，这是典型的**反调试**手段。

### 2.3 字符串

```
ntdll.dll
NtWriteFile          NtReadFile
NtTerminateProcess   NtQuerySystemTime
```

配合上面"没有文件 API"这一点，答案出来了：程序**自己解析 ntdll 里这些函数的系统调用号，然后直接 `syscall`**，绕过用户态 API。这既能反 Hook，也能让新手在下 API 断点时扑空。

### 2.4 函数列表

IDA 只识别出 12 个函数，其中有一个 `sub_140004411` 大小 8801 字节却被标为"叶子函数（不调用任何东西）"——这不合常理。

> **这是加密代码的典型征兆。** 一大片被加密的字节，IDA 会把它当成随机数据强行反汇编，识别出的"函数"边界和内容都是假的。看到这种情况，不要去读它，先去找解密它的代码。

---

## 3. 预备知识：本题会用到的几个"零件"

这一节把后面反复出现的概念先讲清楚，读代码时就不会卡住。

### 3.1 自解密（SMC）

程序运行时把自己的一段代码从密文改成明文，再跳进去执行。标准三步：

```c
VirtualProtect(addr, size, PAGE_EXECUTE_READWRITE, &old);  // 1. 让代码段可写
for (i = 0; i < size; i++) addr[i] ^= key;                  // 2. 解密
FlushInstructionCache(hProcess, addr, size);                // 3. 刷新 CPU 指令缓存
```

第 3 步是必须的：CPU 有独立的指令缓存，改了内存不刷新，CPU 可能还在执行旧指令。

**对逆向的意义**：静态看到的字节是密文，必须先在 IDA 里手工解密（patch），才能反编译。

### 3.2 FNV-1a 哈希

一个极简的字符串哈希，两行就能写完：

```python
h = 0xCBF29CE484222325          # 初始值（offset basis）
for c in data:
    h = ((h ^ c) * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF   # 异或再乘质数
```

本题里 `0x100000001B3`（FNV 质数）和 `0xCBF29CE484222325`（FNV 偏移量）出现了很多次，看到这两个常数基本就能认定是 FNV-1a。

### 3.3 splitmix64

一个很快的伪随机数生成器，核心是"雪崩函数"：

```python
def mix(z):
    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9
    z = (z ^ (z >> 27)) * 0x94D049BB133111EB
    return z ^ (z >> 31)
```

特征常数：`0x9E3779B97F4A7C15`（黄金分割率，常做步长）、`0xBF58476D1CE4E5B9`、`0x94D049BB133111EB`。

### 3.4 MurmurHash3 finalizer

```python
x ^= x >> 33
x *= 0xFF51AFD7ED558CCD
x ^= x >> 33
```

特征常数 `0xFF51AFD7ED558CCD`。本题第二层的密钥流用到它。

### 3.5 模 p 运算与"折叠归约"

本题的模数是 **p = 2¹²⁷ − 39**（一个 127 位的素数）。

两个 128 位数相乘会得到 256 位结果。要对 p 取模，程序用了一个巧妙的技巧：

因为 `2¹²⁸ ≡ 78 (mod p)`（78 = 2 × 39），所以

```
高 128 位 × 2¹²⁸ + 低 128 位  ≡  高 128 位 × 78 + 低 128 位  (mod p)
```

这样一次乘法就把 256 位压回 128 位左右，再做几次条件减法就规范化了。

**看代码时的识别特征**：反编译结果里反复出现 `78`（`0x4E`）、`0xFFFFFFFFFFFFFFD9`（即 −39）、`0x7FFFFFFFFFFFFFFF`，就是在做模 `2¹²⁷−39` 的运算。

在 Python 里我们不用管这些技巧，直接 `% P` 即可，结果完全一样。

### 3.6 Feistel 结构

密码学里构造**可逆**变换的经典方法。状态分成左右两半 `(A, B)`：

```
正向：  A' = B ^ F(A)          (F 可以是任意复杂的函数，甚至不可逆)
        B' = A
逆向：  A  = B'
        B  = A' ^ F(A) = A' ^ F(B')
```

**关键点：不管 `F` 多复杂多不可逆，整个结构永远可逆**——因为解密时 `F` 的输入是已知的。

这正是本题能被解开的突破口。

---

## 4. 第一层：入口处的自解密

入口函数 `start` 在 `0x1400012c0`。开头几行：

```asm
xor  ecx, ecx
call GetModuleHandleA          ; rax = 模块基址 0x140000000
mov  rbx, cs:dwSize            ; 长度
mov  rdi, cs:qword_14000A028   ; 偏移
add  rdi, rax                  ; 目标地址 = 基址 + 偏移
...
call VirtualProtect            ; 改成 PAGE_EXECUTE_READWRITE
```

读一下这两个全局变量（它们就在 `.tgt` 节区里）：

```
qword_14000A028 = 0x1800    ← RVA
dwSize (0x14000A020) = 0x510  ← 长度
```

再看解密循环，SSE 版本是 `xorps xmm1, xmm2`，其中 `xmm2` 加载自 `xmmword_1400070D0`：

```
0x1400070D0: 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A 5A
```

尾部处理用的是标量版 `*v7++ ^= 0x5A`。

**结论：第一层 = 地址 `0x140001800`，长度 `0x510`，逐字节 XOR `0x5A`。**

### 4.1 在 IDA 里动手解密

打开 IDA 的 Python 控制台（`Shift+F2` 或 File → Script command），执行：

```python
import ida_bytes, ida_funcs, ida_auto

s, n = 0x140001800, 0x510
data = bytes(b ^ 0x5A for b in ida_bytes.get_bytes(s, n))

# 先把 IDA 之前误判出来的假函数、假数据清掉
ea = s
while ea < s + n:
    f = ida_funcs.get_func(ea)
    if f:
        st, en = f.start_ea, f.end_ea
        ida_funcs.del_func(st)
        ea = max(ea + 1, en)
    else:
        ea += 1
ida_bytes.del_items(s, ida_bytes.DELIT_EXPAND, n)

ida_bytes.patch_bytes(s, data)          # 写入明文
ida_funcs.add_func(0x140001810)         # 手工建立函数
ida_funcs.add_func(0x1400018D0)
ida_auto.auto_wait()
print('done')
```

> **这里有个新手常踩的坑**：如果不先 `del_func` / `del_items`，IDA 会保留之前对密文的错误分析结果（错误的指令边界、错误的函数范围），patch 之后反编译出来还是乱码。**先清理，再写入，再建函数**。

解密后开头字节是 `48 89 5C 24 ...`（`mov [rsp+xx], rbx`），标准的 x64 函数序言——说明解对了。

### 4.2 `start` 的剩余逻辑

解密完之后，`start` 的流程很清晰：

```c
输出 "Input:"
读入一行（最多 63 字节），去掉结尾的 \r \n
if (长度 != 16) { 输出 "fault"; 退出; }

sub_140001070(buf);                     // 干扰项，见下

if (loc_1400018D0(buf) == 1)            // ← 真正的校验入口
    输出 "correct";
else
    输出 "fault";
```

注意每个分支最后都是 `sub_140001000(...)` 然后 `while(1);`——`sub_140001000` 就是通过 syscall 调 `NtTerminateProcess` 结束进程，后面的死循环只是编译器认为函数不返回而生成的填充。

> **实测提示**：如果你在调试器或脚本里运行它，进程结束前可能会短暂占满一个 CPU 核。用命令行测试时建议加超时，例如
> `printf 'xxxxxxxxxxxxxxxx\n' | timeout 8 ./kctf2026_CrackMe08.exe`

### 4.3 syscall 直call 机制

`sub_140001220(name)` 负责取系统调用号：

```c
mod  = GetModuleHandleA("ntdll.dll");
addr = GetProcAddress(mod, name);
// 在函数开头 64 字节内向后找 0F 05 (syscall 指令)
// 再从那里往回找 B8 (mov eax, imm32)
// 返回 imm32 —— 就是系统调用号
```

`sub_1400017B0` 则是通用 syscall 存根：

```asm
mov  r10, rdx          ; x64 syscall 约定：第 1 参数在 r10
mov  rdx, r8           ; 参数整体左移一位（第 1 个参数是调用号）
mov  r8,  r9
...                    ; 栈上参数依次搬运
mov  eax, ecx          ; eax = 系统调用号
syscall
retn
```

**对逆向的影响**：在 `NtReadFile` / `NtWriteFile` 上下 API 断点是无效的，程序根本不经过 ntdll 的那段代码。想断，就断 `0x1400017F2`（`syscall` 指令本身）。

### 4.4 `sub_140001070`：一个纯干扰项

这个函数长得吓人（十几层嵌套的 `__ROR8__` 和乘法），但仔细看：

```c
if ( FNV_ROR_hash(输入的 16 字节) == 0x1111111111111111 )
    qword_140008000 += 2 * qword_140008000 + 1;   // 修改一个全局变量
// 然后调 NtQuerySystemTime，把当前时间异或进那个全局变量
```

那个全局变量 `qword_140008000` **在后面的校验里从未被使用**。哈希撞上 `0x1111111111111111` 的概率是 2⁻⁶⁴，也永远不会发生。

**这是纯粹的时间浪费陷阱**——故意做得很显眼、很像"核心算法"，引诱你去分析它。

> **经验**：判断一段代码是不是干扰项，最快的办法是看它的**输出去了哪里**。如果计算结果没有流向最终的返回值/比较，那它就是噪音。用 IDA 的交叉引用（`X` 键）查一下写入的全局变量有没有被读取即可。

---

## 5. 第二层：拿"自己的代码"当密钥

`loc_1400018D0`（解密后是 `sub_1400018D0`）就是第二层解密器。反编译后核心是：

```c
mod = GetModuleHandleA(0);

// (1) 对第一层的明文代码算两个 FNV-1a，初始值不同
h1 = 0xCBF29CE484222325;
h2 = 0x9E3779B97F4A7C15;
for (i = 0; i < dwSize; i++) {          // dwSize = 0x510
    c  = *(BYTE*)(mod + 0x1800 + i);
    h1 = (h1 ^ c) * 0x100000001B3;
    h2 = (h2 ^ c) * 0x100000001B3;
}

// (2) 用 h1、h2 派生密钥流，解密第三层
base = mod + qword_14000A008;           // 0x1d10
size = dwSize_0;                        // 0x4962
VirtualProtect(base, size, PAGE_EXECUTE_READWRITE, &old);
for (j = 0; j < size; j++) {
    x = h1 ^ h2 ^ (0x9E3779B97F4A7C15 * j);
    x ^= x >> 33;
    base[j] ^= (0xFF51AFD7ED558CCD * x) >> 56;      // 取最高字节
}
FlushInstructionCache(...);

// (3) 调用解密后的代码
result = loc_140001D10(输入);

// (4) 再用同样的密钥流加密回去，并恢复内存属性
```

### 5.1 这个设计的厉害之处

**密钥不是硬编码的常数，而是"第一层代码本身的哈希"。**

这意味着：

- 你在第一层区域（`0x140001800`–`0x140001D10`）下**任何软件断点**（INT3，即 `0xCC`），都会改变那 0x510 字节的内容 → 哈希变了 → 密钥流全错 → 第三层解出来是垃圾 → 程序崩溃或直接判错。
- 你**修改**第一层的任何一条指令（比如想 patch 掉某个跳转），后果同上。

这叫**代码自校验（self-checksumming）**，是很常见的反调试/反篡改组合技。

> **应对办法**：用硬件断点（Dr 寄存器）代替软件断点——但本题的第三层又专门检查 Dr 寄存器（见第 9 节）。所以本题的正确姿势是**纯静态分析 + 离线复现算法**，这也是本文的做法。

### 5.2 在 IDA 里解开第三层

```python
import ida_bytes, ida_funcs, ida_auto

M64 = (1 << 64) - 1

# 第一层明文（上一步已经 patch 过了）
src = ida_bytes.get_bytes(0x140001800, 0x510)
h1, h2 = 0xCBF29CE484222325, 0x9E3779B97F4A7C15
for c in src:
    h1 = ((h1 ^ c) * 0x100000001B3) & M64
    h2 = ((h2 ^ c) * 0x100000001B3) & M64

s, n = 0x140001d10, 0x4962
data = bytearray(ida_bytes.get_bytes(s, n))
G = 0x9E3779B97F4A7C15
for j in range(n):
    x = (h1 ^ h2 ^ ((G * j) & M64)) & M64
    x ^= x >> 33
    data[j] ^= ((0xFF51AFD7ED558CCD * x) & M64) >> 56

# 同样：先清理，再写入
ea = s
while ea < s + n:
    f = ida_funcs.get_func(ea)
    if f:
        st, en = f.start_ea, f.end_ea
        ida_funcs.del_func(st)
        ea = max(ea + 1, en)
    else:
        ea += 1
ida_bytes.del_items(s, ida_bytes.DELIT_EXPAND, n)
ida_bytes.patch_bytes(s, bytes(data))

ida_funcs.add_func(0x140001d10)
ida_funcs.add_func(0x140004380)
ida_auto.auto_wait()
print('done')
```

解密后 `0x140001d10` 处是 `40 53 48 83 EC 20`（`push rbx; sub rsp, 20h`），又是标准函数序言，说明解对了。

---

## 6. 第三层入口：两道障眼法

`sub_140001D10` 很短，但埋了两个坑：

```c
__int64 sub_140001D10(unsigned int *a1)
{
    // 坑 1：假跳转表
    idx = ((a1[15] << 33) ^ (a1[0] * 0x9E3779B97F4A7C15)) & 7;
    v2  = ((func_t)funcs_140007100[idx])(a1);

// 坑 2：反着写的比较
    sum = 16 个字节相加;
    eax = 0;
    if ((sum & 0xFFFFFF) != (dword_14000A010 ^ 1))
        eax = v2;                    // cmovnz
    return eax & 1;
}
```

### 坑 1：跳转表全指向同一个地方

```python
[hex(get_qword(0x140007100 + 8*i)) for i in range(8)]
# ['0x140004380', '0x140004380', '0x140004380', '0x140004380',
#  '0x140004380', '0x140004380', '0x140004380', '0x140004380']
```

8 个表项**完全一样**。这个"根据输入选择处理函数"的复杂计算纯属演戏，无论 `idx` 算出什么，都是调 `sub_140004380`。

### 坑 2：`cmovnz`，条件是反的

`dword_14000A010 = 0x500`，所以比较的是 `0x500 ^ 1 = 0x501`。

```
如果 sum == 0x501 → eax 保持 0 → 直接判错
如果 sum != 0x501 → eax = 内层函数的返回值
```

而 `sub_140004380` 内部要求 `sum == 0x500`。两个条件放在一起：

- `sum` 必须等于 **0x500 = 1280**；
- 此时 `sum != 0x501` 自然成立，外层放行。

所以这个"额外条件"实际上什么都没约束，只是让你在看反编译结果时以为逻辑写反了，浪费时间去怀疑自己。

**记住一条：16 个字符的 ASCII 码之和必须是 1280。** 这在最后验证答案时是个很好的自检。

---

## 7. 核心校验函数总览

`sub_140004380`，大小 8946 字节，Hex-Rays 反编译出来 56,000 多个字符、400 多个局部变量。

**不要试图从头到尾逐行读它。** 正确的做法是先找骨架，再填细节。

按执行顺序，它分成 7 段：

| 段   | 作用                                                         |
| ---- | ------------------------------------------------------------ |
| ①    | 校验 16 字节之和 == `0x500`，不符直接返回 0                  |
| ②    | 对第三层明文代码算两个 FNV-1a → `v409`、`v410`               |
| ③    | 反调试检测，结果汇总成位掩码 `v11`                           |
| ④    | 用 splitmix64 变体填充 `CONTEXT` 结构的前 688 字节，**所有常量都从这里取** |
| ⑤    | 把输入按 94 进制解码成大整数 `acc`                           |
| ⑥    | 五次多项式：`r = f(acc) mod p`                               |
| ⑦    | 两条 20 轮 Feistel 置换，结果与目标常量比对                  |

段 ③ 的结果会喂进段 ④ 的随机数种子——**被调试 → 种子变 → 所有常量变 → 必然判错**。这是把反调试和算法绑死的经典做法，光把检测代码 nop 掉是没用的（种子还是错的），必须让检测**真的返回"没被调试"**。

好消息是：我们只做静态分析，直接令 `v11 = 0` 即可。

---

## 8. 常量从哪来：splitmix64 填充 CONTEXT

这是全题最关键的一环——**搞清楚这一段，所有常量就都能离线算出来。**

### 8.1 种子

```c
v410 = FNV1a(第三层明文, 初值 0xCBF29CE484222325);
v409 = FNV1a(第三层明文, 初值 0x9E3779B97F4A7C15);

s28 = v11 ^ v410 ^ (0x9E3779B97F4A7C15 * qword_14000A018);
s29 = v409 ^ (qword_14000A018 << 33) ^ 0xCBF29CE484222325;
```

其中 `qword_14000A018 = 0`（`.tgt` 里读出来的），`v11 = 0`（未被调试），所以：

```
s28 = v410
s29 = v409 ^ 0xCBF29CE484222325
```

实算结果：

```
v409 = 0x4aeee52b5738eb8f
v410 = 0x553d3c5ef6ee11ff
```

### 8.2 填充循环

```c
p = &Context.P1Home;        // CONTEXT 结构的起始地址
重复 43 次 {
    a  = s28 + 0x9E3779B97F4A7C15;
    b  = s29 + 0xBF58476D1CE4E5B9;      // 反编译显示为 "- 0x40A7B892E31B1A47"
    o1 = mix(a + 0x9E3779B97F4A7C15);   // mix = splitmix64 雪崩函数
    o2 = mix(b + 0x9E3779B97F4A7C15);
    *p++ = o1;
    *p++ = o2;
    s29  = o1 ^ b;                       // 两条链交叉耦合
    s28  = o2 ^ a;
}
```

43 轮 × 2 个 = **86 个 64 位数 = 688 字节**，正好覆盖 `CONTEXT` 结构的 `0x000`–`0x2B0`。

> **为什么用 CONTEXT 结构当缓冲区？**
> 一是省栈空间（`GetThreadContext` 本来就需要这块内存）；二是**迷惑分析者**——反编译器会把偏移显示成 `Context.Dr3`、`Context.Xmm5.High` 这种名字，让人误以为在读真实的寄存器值，实际上早就被伪随机数覆盖了。
>
> 遇到这种情况，把成员名换算成**数字偏移**来看，思路会清晰得多。

### 8.3 CONTEXT 各偏移被当成了什么

x64 的 `CONTEXT` 结构布局（本题相关部分）：

```
0x000  P1Home … P6Home
0x030  ContextFlags, MxCsr
0x038  段寄存器, EFlags
0x048  Dr0  0x050 Dr1  0x058 Dr2  0x060 Dr3  0x068 Dr6  0x070 Dr7
0x078  Rax … 0x0F8 Rip
0x100  FltSave 联合体
         0x100  Header[2]
         0x120  Legacy[8]
         0x1A0  Xmm0 … 0x290 Xmm15
0x300  VectorRegister[26] …
```

程序从填充好的这块内存里取走：

| CONTEXT 偏移    | 取出来当什么用                           |
| --------------- | ---------------------------------------- |
| `0x000`–`0x050` | 5 个 128 位数 → 多项式系数 `c₀..c₄`      |
| `0x050`–`0x060` | 1 个 128 位数 → Feistel 里的乘子 `dr`    |
| `0x060`–`0x160` | 256 字节 → 字节替换表 `S[256]`           |
| `0x160`–`0x200` | 20 个 64 位数 → 第 1 条 Feistel 的轮常量 |
| `0x200`–`0x2A0` | 20 个 64 位数 → 第 2 条 Feistel 的轮常量 |
| `0x2A0`–`0x2B0` | 16 字节 → 目标值的**异或掩码**           |

几点细节：

**(a) 128 位数的取法与"归约"**

```c
lo = *(QWORD*)(ctx + off);
hi = *(QWORD*)(ctx + off + 8);
v  = (hi << 64) | lo;
重复 4 次: if (v >= p) v -= p;        // 条件减法，把值压到 [0, p)
if (v == 0) v = 1;                    // 避免 0
```

**(b) S 盒的交错重排**

程序不是直接复制 256 字节，而是每 16 字节一组做了交错：

```python
for k in range(0, 256, 16):
    blk = ctx[0x60 + k : 0x60 + k + 16]
    for i in range(8):
        S[k + 2*i]     = blk[i]        # 低 8 字节
        S[k + 2*i + 1] = blk[8 + i]    # 高 8 字节
```

对应汇编里那一堆 `BYTE1(v52)` / `BYTE1(v53)` 交替赋值。

**(c) 目标值 = `.tgt` 里的常量 ⊕ 掩码**

```c
mask   = ctx[0x2A0 .. 0x2B0];                    // 16 字节
target1 = xmmword_140A050 ^ mask;                 // 第 1 条 Feistel 的目标
target2 = xmmword_140A040 ^ mask;                 // 第 2 条 Feistel 的目标
```

**这样设计的目的**：静态看 `.tgt` 里只是一堆随机字节，必须先完整复现 splitmix64 填充过程才能还原真正的目标值。这挡住了"直接从二进制里抠出目标密文"的偷懒路线。

### 8.4 一个容易搞错的地方：栈上的表

反编译结果里，轮常量表显示成两个数组 `v421[9]`（`_OWORD`）和 `v423[10]`，而循环却按 `qword` 读了 20 次——看起来"越界"了。

去查函数的栈帧布局（IDA 里按 `Ctrl+K`，或用脚本读）：

```
var_650  offset 0x260  ← v421 起点
var_5C0  offset 0x2f0
var_5B8  offset 0x2f8  ← v423 起点
var_518  offset 0x398
Context  offset 0x3a0
```

对照赋值语句 `v421[0] = Context.Legacy[4]`（`Legacy[4]` 在 CONTEXT 偏移 `0x160`）：

```
栈 0x260  ←  CONTEXT 0x160
栈 0x2f0  ←  CONTEXT 0x1F0
栈 0x2f8  ←  CONTEXT 0x1F8
栈 0x398  ←  CONTEXT 0x298
```

差值恒为 `0x100`——**这是一整块连续的 320 字节拷贝**，只是 Hex-Rays 把它拆成了好几个变量。所以：

- 第 1 条 Feistel 的表 = 栈 `0x260` 起的 20 个 qword = **CONTEXT `0x160`–`0x200`**
- 第 2 条 Feistel 的表 = 栈 `0x300` 起的 20 个 qword = **CONTEXT `0x200`–`0x2A0`**

正好首尾相接，没有任何越界。

> **教训**：Hex-Rays 对大块栈数组的变量划分经常是错的。凡是涉及数组边界的判断，**一定要回去看栈帧布局或汇编**，不能只信反编译出来的变量名。

---

## 9. 反调试

程序检测 5 类特征，结果按位存进 `v11`：

| 位    | 检测手段                                                     | 说明               |
| ----- | ------------------------------------------------------------ | ------------------ |
| bit 0 | `PEB->BeingDebugged`                                         | 最基础的调试器标志 |
| bit 1 | `[PEB + 0x68] & 0x70 == 0x70`                                | 见下方说明         |
| bit 2 | `GetThreadContext` 后检查 `Dr0`–`Dr3`、`Dr7`                 | **硬件断点检测**   |
| bit 3 | 直接 syscall 调 `NtQueryInformationProcess`，查 `ProcessDebugPort`(7) 和 `ProcessDebugFlags`(30) | 绕过用户态 Hook    |
| bit 5 | `rdtsc` 计时：遍历 0x4962 字节的耗时若超过 `0x2FAF080`（约 5000 万周期）则判定被单步 | 时间差检测         |

关于 bit 1：`and eax, 70h / cmp al, 70h` 是检测 `NtGlobalFlag` 的经典模式（被调试时会置上堆栈校验相关的三个标志位 `0x10|0x20|0x40`）。但 **`0x68` 是 32 位 PEB 里 `NtGlobalFlag` 的偏移**；在 x64 的 PEB 中，`0x68` 是 `ApiSetMap` 指针，`NtGlobalFlag` 在 `0xBC`。由于 `ApiSetMap` 指向的地址是页对齐的，低位为 0，这条检测在 64 位下实际上永远不会触发。

无论如何，这些标志的用途是一样的：

```c
s28 = v11 ^ v410 ^ ...;     // v11 直接进种子
```

**只要有一位被置上，后面所有常量就全变了**，结果必错。

正常运行（不调试）时 `v11 = 0`，我们在脚本里直接写死。

---

## 10. 输入怎么变成一个数：base-94 解码

```c
acc = 0;
for (j = 0; j < 16; j++) {
    acc = acc * 94;                     // 移位
    acc = acc + (input[j] - 33);        // 加上当前"数字"
    acc = acc mod p;                    // 归约
}
```

这就是标准的进制转换。翻译成数学式：

```
acc = Σ (input[i] − 33) × 94^(15−i)
```

**为什么是 94 和 33？** ASCII 可打印字符是 `0x21`（`!`，十进制 33）到 `0x7E`（`~`，126），共 **94** 个。所以这一步等价于：把 flag 看成 94 进制数，`'!'` 是数字 0，`'~'` 是数字 93。

**这给了我们两个重要信息**：

1. flag 一定由可打印字符组成；
2. `acc < 94¹⁶ ≈ 2¹⁰⁵`，而模数 `p ≈ 2¹²⁷`，**取模不会真的发生**——`acc` 就是那个大整数本身，没有信息损失。这一点对后面求根至关重要（如果发生了取模，会有多个解）。

---

## 11. 五次多项式

接下来是标准的**霍纳法则（Horner's method）**求多项式值：

```c
r = acc + c0;          r = r mod p;
r = r * acc + c1;      r = r mod p;
r = r * acc + c2;      r = r mod p;
r = r * acc + c3;      r = r mod p;
r = r * acc + c4;      r = r mod p;
```

展开就是：

```
r = acc⁵ + c₀·acc⁴ + c₁·acc³ + c₂·acc² + c₃·acc + c₄   (mod p)
```

脚本算出的系数：

```
c0 = 0x21b3bde1acf9adfa471fb28461a53bb5
c1 = 0x191a3870ad3d941105f15a9c38aae874
c2 = 0x40c190e211322caa2f01797348f02c97
c3 = 0x1df732140b8a3ef758fd09bde0058a37
c4 = 0x3f0cb8512c6f88e47e5f164fb478aab5
```

在反编译结果里，这五步会被展开成几百行的 128 位乘法、进位处理和条件减法，看起来极其吓人。**识别技巧**：找 `+ v411`、`+ v412`、`+ v413`、`+ v414`、`+ v415` 这几个加法点——它们之间夹着的一大坨就是一次"乘 `acc` 再取模"。看到这个"加常量 → 一大坨 → 加常量"的节奏，就知道是霍纳法则。

---

## 12. 两条 20 轮 Feistel 置换

`r` 算完后拆成高低两半：

```
A₀ = r >> 64      (高 64 位)
B₀ = r & 0xFFFF…  (低 64 位)
```

然后**同一个初值**分别送进两条 20 轮循环。

### 12.1 单轮结构

设 `K(i)` 是本轮密钥（下面说），`tbl[i]` 是本轮常量：

```
t₁ = tbl[i] ⊕ K(i)
x₁ = R(A, t₁)
C  = B ⊕ g(x₁)
t₂ = t₁ ⊕ 0x9E3779B97F4A7C15
x₂ = R(C, t₂)
B' = A ⊕ g(x₂)
A' = C
```

两个辅助函数：

```python
def R(h, t):
    """把 (h:t) 当成 128 位数，乘以 dr 再模 p，然后混合成 64 位"""
    v = ((h << 64) | t) 归约到 [0, p)
    m = v * dr mod p
    return (m & M64) ^ t ^ ror(m >> 64, 47)

def g(x):
    """字节替换 + 循环右移"""
    y = 0
    for i in range(8):
        y |= S[(x >> (8*i)) & 0xFF] << (8*i)      # 逐字节查 S 盒
    return y ^ ror(x, 51)
```

**轮密钥的选择**（两条链故意相反，这样即使初值相同，输出也完全不同）：

- 第 1 条：偶数轮用 `v410`，奇数轮用 `v409`
- 第 2 条：偶数轮用 `v409`，奇数轮用 `v410`

### 12.2 怎么看出这是 Feistel

反编译结果里，把噪音去掉后剩下的骨架是：

```c
v403 = v249 ^ (查表混合(v282) ^ __ROR8__(v282, 51));   // 新值 = 旧值 ⊕ F(...)
...
v249 = v407 ^ (查表混合(v312) ^ __ROR8__(v312, 51));
v407 = v403;
```

**关键特征：`新状态 = 另一半旧状态 ⊕ 某个复杂函数`。** 只要看到这个形式，不管那个"复杂函数"里面是乘法、S 盒还是别的什么，整个结构就是可逆的。

再确认 `v407` 恒等于 `A`：循环开始前 `v407 = A₀`，循环末尾 `v407 = v403 = A'`，下一轮开头 `A = v248 = v403`。两者始终相等，所以 `B' = A ⊕ g(x₂)` 成立。

### 12.3 逆向单轮

已知本轮结束后的 `(A', B')`，倒推轮开始前的 `(A, B)`：

```
C  = A'                    ← 直接得到
t₁ = tbl[i] ⊕ K(i)         ← 常量，已知
t₂ = t₁ ⊕ 0x9E37…          ← 已知
x₂ = R(C, t₂)              ← C 已知，能算
A  = B' ⊕ g(x₂)            ← 还原出 A
x₁ = R(A, t₁)              ← A 已还原，能算
B  = C ⊕ g(x₁)             ← 还原出 B
```

**顺序很重要**：必须先算 `A`（因为 `x₁` 需要 `A`），再算 `B`。

从第 19 轮倒着做到第 0 轮，就还原出了 `(A₀, B₀)`，也就是 `r`。

### 12.4 最终比较

```c
v416 = 第1条链的 B_final;   v403 = 第1条链的 A_final;
v390 = 第2条链的 B_final;   v401 = 第2条链的 A_final;

条件1: (v403 << 64 | v416) == (xmmword_140A050 ^ mask)
条件2: (v401 << 64 | v390) == (xmmword_140A040 ^ mask)
条件3: FNV1a(acc.lo, acc.hi, v416, v403, v390, v401) == (qword_140A030 ^ ctx[0x2A8])
条件4: FNV1a(v416, v403, v390, v401)                == (qword_140A060 ^ ctx[0x2A0])

return 条件1 && 条件2 && 条件3 && 条件4;
```

条件 3、4 只是额外的完整性校验，条件 1、2 才是我们要逆的。

**两条链给了我们两个独立的方程**，而它们应该反推出**同一个 `r`**——这是绝佳的自检机制：如果实现有任何一点错，两边算出来的 `r` 必然不同。

---

## 13. 求解思路：为什么能倒着算回去

先说说**不能**怎么做：

- ❌ **爆破 flag**：94¹⁶ ≈ 10³¹ 种组合，宇宙热寂也跑不完。
- ❌ **爆破 `acc`**：同上，2¹⁰⁵ 的空间。
- ❌ **符号执行 / SMT**：128 位乘法 + 20 轮 S 盒混合，约束求解器会直接卡死。

正确的路线是**沿着数据流反着走**：

```
目标常量（程序里写死的）
    ↓ Feistel 可逆，倒推 20 轮
r  = 0x4be831b0ad3a2d361489375bba3fb8de
    ↓ 解五次方程 f(x) − r ≡ 0 (mod p)
acc = 0x174a5e1d4cf4f146e72f70092ac
    ↓ 94 进制展开，每位加 33
flag = "kanxue@2o26o8!@#"
```

### 13.1 第一步：反推 `r`

按 12.3 节的逆运算，从两个目标值各倒推 20 轮：

```
第 1 条链反推：hi = 0x4be831b0ad3a2d36  lo = 0x1489375bba3fb8de
第 2 条链反推：hi = 0x4be831b0ad3a2d36  lo = 0x1489375bba3fb8de
```

**两条完全独立的链（不同的常量表、相反的轮密钥）反推出了完全相同的值**——实现无误。

```
r = 0x4be831b0ad3a2d361489375bba3fb8de
```

再正向跑一遍验证能得回目标值，双向都对上，这一步就可以放心了。

### 13.2 第二步：在有限域上解五次方程

现在要解：

```
x⁵ + c₀x⁴ + c₁x³ + c₂x² + c₃x + (c₄ − r) ≡ 0   (mod p)
```

一元五次方程没有求根公式，但**在有限域 GF(p) 上求根是有标准算法的**——Cantor–Zassenhaus 算法。原理只需要知道两点：

**(1) 找出所有一次因子**

费马小定理的多项式版本：`x^p − x` 恰好等于 GF(p) 中所有元素对应的一次式 `(x − a)` 的乘积。所以

```
g(x) = gcd(x^p − x, f(x))
```

就是 `f` 的**所有一次因子的乘积**，也就是所有根的信息。

计算 `x^p mod f(x)` 用**多项式快速幂**：`p` 是 127 位，只需约 127 次"多项式平方 + 取模"，而多项式次数始终小于 5，所以很快（毫秒级）。

**(2) 把因子劈开**

如果 `g` 的次数大于 1（有多个根），随机取 `a`，计算 `gcd((x+a)^((p−1)/2) − 1, g)`。因为半数元素是二次剩余、半数不是，这个 gcd 有约 1/2 的概率把 `g` 劈成两块，递归下去即可。

本题运气好，`g` 的次数直接就是 **1**——**五次方程在 GF(p) 上只有一个根**：

```
根 = 0x174a5e1d4cf4f146e72f70092ac
```

`0x174a5e1d4cf4f146e72f70092ac` ≈ 2¹⁰⁴，确实小于 94¹⁶，符合预期。

### 13.3 第三步：94 进制展开

```python
digits = []
v = root
for _ in range(16):
    digits.append(v % 94)
    v //= 94
digits.reverse()
flag = ''.join(chr(d + 33) for d in digits)
```

```
flag = 'kanxue@2o26o8!@#'
字符和 = 1280   ← 正好等于 0x500，第 6 节的条件自动满足
```

字符和这个独立的约束能对上，是答案正确的强力旁证。

---

## 14. 完整脚本

两个脚本都只用 Python 标准库。

### 14.1 [solve.py](solve.py)：脱壳 + 常量恢复 + Feistel 逆推

做四件事：

1. 自己解析 PE，把文件映射成内存镜像（不依赖 IDA，脚本可独立运行）；
2. 复现第一、二层解密；
3. 复现 splitmix64 填充，取出全部常量和目标值；
4. 双向 Feistel 验证，反推出 `r`，写进 `constants.txt`。

关键片段：

```python
P = (1 << 127) - 39
GOLD = 0x9E3779B97F4A7C15

def red(v):
    """模拟程序里的 4 次条件减法"""
    for _ in range(4):
        if v >= P:
            v -= P
    return v

def ror(x, n):
    return ((x >> n) | (x << (64 - n))) & M64

def sperm(x):                       # 逐字节查 S 盒
    r = 0
    for i in range(8):
        r |= sbox[(x >> (8 * i)) & 0xFF] << (8 * i)
    return r

def g(x):
    return sperm(x) ^ ror(x, 51)

def f_round(state_hi, t):
    v = red(((state_hi << 64) | t) % (1 << 128))
    m = (v * red(dr)) % P
    return (m & M64) ^ t ^ ror(m >> 64, 47)

def perm_fwd(A, B, tbl, even_key):          # 正向 20 轮
    odd_key = v409 if even_key == v410 else v410
    for i in range(20):
        key = even_key if (i & 1) == 0 else odd_key
        t1 = tbl[i] ^ key
        C  = B ^ g(f_round(A, t1))
        t2 = t1 ^ GOLD
        B  = A ^ g(f_round(C, t2))
        A  = C
    return A, B

def perm_inv(A, B, tbl, even_key):          # 逆向 20 轮
    odd_key = v409 if even_key == v410 else v410
    for i in reversed(range(20)):
        key = even_key if (i & 1) == 0 else odd_key
        t1 = tbl[i] ^ key
        t2 = t1 ^ GOLD
        C  = A
        A  = B ^ g(f_round(C, t2))          # 先还原 A
        B  = C ^ g(f_round(A, t1))          # 再还原 B
    return A, B
```

运行输出：

```
[*] L1 rva=0x1800 size=0x510  L3 rva=0x1d10 size=0x4962
[*] sum target = 0x500 (1280), qword_A018 = 0x0
[*] 第三层解密 OK
[*] v409=0x4aeee52b5738eb8f v410=0x553d3c5ef6ee11ff
[*] c0 = 0x21b3bde1acf9adfa471fb28461a53bb5
[*] c1 = 0x191a3870ad3d941105f15a9c38aae874
[*] c2 = 0x40c190e211322caa2f01797348f02c97
[*] c3 = 0x1df732140b8a3ef758fd09bde0058a37
[*] c4 = 0x3f0cb8512c6f88e47e5f164fb478aab5
[*] dr = 0x4d8a9e9343d415cb83a0a488ec8523fe
[*] target417 = 0x0c14db1c20dd97a8b8fd0694401d3d03
[*] target418 = 0x9a2789b6de31c2dcaca5240a53fb78a6
[*] 反推1: hi=0x4be831b0ad3a2d36 lo=0x1489375bba3fb8de
[*] 反推2: hi=0x4be831b0ad3a2d36 lo=0x1489375bba3fb8de
[*] r = 0x4be831b0ad3a2d361489375bba3fb8de   (< p: True)
[*] 正向校验1: True
[*] 正向校验2: True
```

### 14.2 [roots.py](roots.py)：有限域求根

手写 GF(p)[x] 的多项式乘法、取模、gcd、快速幂，再跑 Cantor–Zassenhaus。核心不到 20 行：

```python
# f(x) = x^5 + c0x^4 + c1x^3 + c2x^2 + c3x + (c4 - r)，系数按升幂存
f = [(coef[4] - r_val) % P, coef[3], coef[2], coef[1], coef[0], 1]

xp = ppow([0, 1], P, f)          # x^p mod f
h = xp + [0] * (2 - len(xp))
h[1] = (h[1] - 1) % P            # h = x^p - x
g = pgcd(trim(h), f)             # 所有一次因子的乘积
rs = roots(g)                    # 劈开取根
```

运行输出：

```
[*] p 是素数: True
[*] 线性因子乘积次数 = 1
[*] 根个数 = 1
    root = 0x174a5e1d4cf4f146e72f70092ac  < 94^16: True
    ==> flag 候选: 'kanxue@2o26o8!@#'   字符和 = 1280 (需要 1280)
```

---

## 15. 验证

```bash
$ printf 'kanxue@2o26o8!@#\n' | timeout 8 ./kctf2026_CrackMe08.exe
Input:correct

$ printf 'AAAAAAAAAAAAAAAA\n' | timeout 8 ./kctf2026_CrackMe08.exe
Input:fault
```

正确输入输出 `correct`，错误输入输出 `fault`。

（加 `timeout` 是因为程序在打印结果后有个死循环，见 4.2 节。）

---

## 16. 小结与踩坑记录

### 16.1 这道题的防护设计

| 层次 | 手段                                   | 目的                         |
| ---- | -------------------------------------- | ---------------------------- |
| 静态 | 三层自解密，密钥层层依赖               | 不脱壳看不到任何真实代码     |
| 静态 | 关键常量运行时用 splitmix64 生成       | 无法直接从二进制抠出目标密文 |
| 动态 | 代码自校验（哈希自身代码当密钥）       | 软件断点/patch 会破坏解密    |
| 动态 | 硬件断点检测（Dr 寄存器）              | 硬件断点也被封               |
| 动态 | 反调试结果混入密钥种子                 | 单纯 nop 掉检测无效          |
| 动态 | 直接 syscall                           | API 断点失效                 |
| 干扰 | 假跳转表、反向 `cmov`、无用的 FNV 陷阱 | 消耗分析时间                 |
| 算法 | 128 位模运算被展开成几百行             | 让反编译结果难以阅读         |

**但设计上留了一个致命弱点：核心变换用了 Feistel 结构，而 Feistel 是可逆的。** 一旦看穿这一点，整道题就从"不可能爆破"变成了"倒着算一遍"。

如果作者把 Feistel 换成一个真正的单向哈希（比如 SHA-256），这题就只能靠碰撞了——当然那样也就不成其为一道有解的 CTF 题。
<br>
### 16.2 总结实操经验

**1. 先看轮廓，再看细节。**
面对 5 万字符的反编译结果，逐行读是绝路。先用"这段的输出流向哪里"来筛选，把干扰代码整块跳过。本题真正有用的逻辑不超过 100 行。

**2. 认常数。**
`0x100000001B3` → FNV；`0x9E3779B9…` → 黄金分割率/splitmix；`0xFF51AFD7ED558CCD` → MurmurHash3；`0xBF58476D1CE4E5B9` → splitmix64。把常数丢进搜索引擎，经常能一秒钟定位算法。本题的 `78` 和 `−39` 则直接暴露了模数 `2¹²⁷−39`。

**3. IDA patch 之前先清理。**
`del_func` + `del_items` 再 `patch_bytes`，否则 IDA 会拿旧的错误分析结果反编译。

**4. 不要迷信反编译出来的变量名。**
`Context.Xmm5.High` 听起来像 XMM 寄存器，实际上是被伪随机数覆盖的普通内存。涉及数组边界时，回去查栈帧布局或读汇编。

**5. 尽量给自己造交叉验证。**
本题有三个天然的自检点：

- 两条 Feistel 链必须反推出同一个 `r`；
- 反推出的 `r` 正向跑回去必须等于目标值；
- 求出的 flag 字符和必须等于 1280。

三个都对上，基本可以确信答案正确——事实上在实机运行之前，就已经有很高把握了。

**6. 反调试写进算法时，别想着"绕过"，想着"复现"。**
本题里反调试的结果直接进了密钥种子。与其在调试器里和它斗，不如认清"正常运行时这些标志都是 0"，然后在离线脚本里写死 `v11 = 0`，把整个算法搬到 Python 里跑。

### 文件清单

| 文件                 | 说明                                               |
| -------------------- | -------------------------------------------------- |
| [solve.py](solve.py) | 脱壳、常量恢复、Feistel 逆推，输出 `constants.txt` |
| [roots.py](roots.py) | GF(p) 上求解五次方程，输出 flag                    |
| `constants.txt`      | 中间结果（`r` 与多项式系数）                       |

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

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

最后于 2026-8-21 14:52 被教教我吧~编辑，原因：修改

上传的附件：