[原创]第六题：酉时·书院迷局 Writeup-CTF对抗-看雪安全社区

# 第六题：酉时·书院迷局 Writeup

## 1. 输入与整体结构

应用要求输入严格为 100 个小写十六进制字符，Java 层将其解码成 50 字节后调用静态 JNI 函数：

```java
byte[] input = hexDecode(text);
if (input != null && input.length == 50
        && nativeProcessInput(input) == 1) {
    // success
}
```

JNI 入口使用三次 `vld2` 对 50 字节做奇偶解交织，得到两个 25 字节序列：

```text
even[i] = input[2*i]
odd[i]  = input[2*i+1]
```

后续逻辑分成两条通道：

```text
even25 -> 可逆字节变换 -> local25 -> 全局状态、S-box、轮密钥、seed
odd25  -> ARX/XOF -> 早期字节门、46 位稀疏门、最终校验
```

两条通道通过一个 8 位 seed 和一个 16 字节块比较闭环。

## 2. 初始化代码与密钥

动态库没有 `JNI_OnLoad`，JNI 函数以完整符号名静态导出。`.init_array` 中只有一个初始化函数，主要读取 `/proc/self/status` 的 `TracerPid` 并更新反调试状态。它不参与 flag 的数学计算。

Java 层的密钥函数会读取自身 APK，解析 ELF 节表，定位 96 字节的 `.kctfguard` 节并结合 CRC、节偏移和节大小生成 32 字节数据。还原该流程得到：

```text
eab0aaacd8c35c932ba824ccc628a5c5
ce95063e603d010060000000c34224ac
```

JNI 中再与固定向量异或，实际参与 native 运算的 16 字节密钥为：

```text
870573e5f5c63d52862dbd05ab3d9494
```

库中还有一段运行时自解密数据。还原解密状态机后得到 32 字节隐藏目标：

```text
9f73be24a1dd6c96b90723bba7cdfdc9
fd521311dd1b172572014429f93dd77c
```

## 3. 去混淆语义

native 校验大量使用长函数和手写位运算隐藏简单语义。先独立验证这些基础函数：

```text
sub_E818(a, b, noise) = a XOR b
sub_EE90(a, b)        = a + b mod 2^32
sub_F004(a, b)        = a - b mod 2^32
sub_6374(a, b, noise) = a XOR b  (64 位)
sub_6614(a, b)        = a + b mod 2^64
sub_EB6C(a, noise)    = low8(a)  （低字节语义）
sub_12448(a, noise)   = a
```

多处连续 30 层的结构：

```c
carry = 2 * (x & y);
sum   = x ^ y;
```

只是普通加法器，整体直接替换成 `x + y`。

`sub_E9F4` 是 AES 逆 MixColumns。它前面经常出现一段展开的正向 MixColumns，因此：

```text
InvMixColumns(MixColumns(x)) = x
```

这些成对结构可以全部删除。

另一个反复出现的 32 位散列为：

```python
def mix32(x):
    x = (0x045d9f3b * x) & 0xffffffff
    x ^= x >> 16
    x = (0x119de1f3 * x) & 0xffffffff
    return (x ^ (x >> 15)) & 0xffffffff
```

SIMD 代码同时计算两个 `mix32`。在多数调用点，保存的低散列字节随后又与合并值异或，二者相消。完成这些替换后，3116 条 odd 终检指令可以缩减成少量字节运算、一个四轮字函数和一个 46 位稀疏布尔门。

## 4. Odd 通道的 XOF

XOF 输入是：

```text
odd25 || 5a5a5a5a5a5a5a
```

将 32 字节按小端序解释成四个 64 位字 `a,b,c,d`。每轮先计算：

```python
p = (ror64(a, 8) + b) ^ round
b = rol64(b, 3) ^ p

q = (ror64(c, 8) + d) ^ (round + 4)
d = rol64(d, 3) ^ q

a = p ^ d
c = q ^ b
```

轮函数可逆。由轮后状态恢复轮前状态：

```python
p = a ^ d
q = c ^ b

old_b = ror64(b ^ p, 3)
old_a = rol64((p ^ round) - old_b, 8)

old_d = ror64(d ^ q, 3)
old_c = rol64((q ^ (round + 4)) - old_d, 8)
```

随机测试满足：

```text
inverse_round(forward_round(state)) == state
```

XOF 每次输出当前的四个 64 位字，然后更新：

```python
a = a + c
b = b ^ d
c = ror64(c, 47)
d = ror64(d, 11)
```

校验要求 `XOF[80:96]` 等于隐藏目标的前 16 字节。它对应第三个输出块的 `c,d`，所以可以直接固定初始 XOF 状态中的两个字：

```text
c = rol64(LE64(hidden[0:8]), 30) = 492f9ce7e59b3768
d = rol64(LE64(hidden[8:16]), 22) = 69eec8c1ee727f73
```

### 4.1 第一个 8 字节门

第一组八轮混淆完全消去后，每轮只剩：

```python
v35  = hidden[(3 + 5*i) & 15] ^ xof[i]
v41  = v35 ^ key[(9 + 7*i) & 15]
v221 = (v16 + 45*i + seed + v41) & 0xff
v223 = rol8(v16 + hidden[(i + 11) & 15], i + 1)
out[i] = v223 ^ v221
v16 = ((i + 90 + xof[(i + 3) & 7]) & 0xff) ^ out[i]
```

目标为：

```text
out = fd521311dd1b1725
```

外层标量门只允许两组参数：

```text
seed = 57, v490 = 921bca06
seed = d7, v490 = 129b4a86
```

对八个字节方程直接逆算，每个 seed 都只剩一个 `a`：

```text
seed 57 -> a = debe2ec22b6c0cce
seed d7 -> a = 58b67a47304291c1
```

### 4.2 四轮字函数

后续代码多次调用 4328 字节的 `sub_F32C`。将内部 MixColumns 对、SIMD 低字节相消和进位网络删除后，它只是四个短轮。每轮从四个 32 位参数取不同字节，进行：

```text
字节选择 -> 一次 8 位减法 -> 8 位循环移位
32 位条件选择 -> 32 位加法 -> 32 位循环移位
```

四轮结束后再做一次正向 MixColumns 和一个循环移位。简化实现与原 ARM64 函数使用随机参数逐组对拍，结果完全一致。

用它还原第二组八轮后，正确分支要求：

```text
seed = d7
v490 = 129b4a86
```

## 5. 46 位稀疏布尔门

阶段二开始前先计算一个固定 64 位量：

```text
X = 996bd2f8c1b7dd80
```

两个看似复杂的 `sub_10800` 调用恒返回 0，因此最终 46 位 mux：

```c
(v530 & ~v524) | (v524 & v546)
```

中的 `v524=0`，整体直接化为 `v530`。

右侧目标由固定 seed words、`sub_F020(1)`、`sub_F020(2)` 和恒零状态混合组成：

```text
T = 16eff8c39c23
```

真正约束为：

```text
sub_5A38(b, X, ...) & 0x3fffffffffff == T
```

逐位做数据依赖分析后，46 个输出位各自只依赖 `b` 的 2 到 5 位。例如：

```text
Y[0]  <- B[3], B[5], B[8], B[19], B[29]
Y[28] <- B[4], B[33]
Y[44] <- B[17], B[20], B[49]
```

因此不需要建立 64 位大位向量约束。对每个输出位的局部输入枚举真值表，任何不能产生目标位的赋值都写成一条阻断子句：

```python
for j in range(46):
    S = support[j]
    for assignment in range(1 << len(S)):
        if gate_bit(j, assignment) != target_bit(j):
            cnf.add(blocking_clause(S, assignment))
```

最终只有 669 条局部 CNF 子句。固定 `B[0:4]` 将全集分成 16 个互斥 cube，各 cube 独立枚举 SAT 模型。每个模型立即代入 XOF 逆函数，使用最强且便宜的 padding 条件筛选：

```text
inverse_state(a,b,c,d)[25:32] == 5a5a5a5a5a5a5a
```

在 cube 7 的第 6849 个模型得到唯一命中：

```text
b     = 9eb09ed6e443b907
odd25 = 7ae31b94d256f80c41b7298e63a5df104bc8723d960fe458ad
```

完整 XOF 状态为：

```text
a = 58b67a47304291c1
b = 9eb09ed6e443b907
c = 492f9ce7e59b3768
d = 69eec8c1ee727f73
```

将 `odd25`、`seed=d7` 放回原始 3116 条 ARM64 指令执行，五个最终 gate 均为 0，函数返回 1。

## 6. Even 通道

even 通道首先执行一个可逆字节置换和链式状态变换。正向过程为：

```python
state = key[7] ^ 0xc3
for i in range(25):
    mixed = (state + 49*i + key[(1 + 7*i) & 15]) & 0xff
    rotated = rol8(mixed, i)
    local[i] = ((even[perm[i]] - rotated) & 0xff) ^ key[(3 + 5*i) & 15]
    state = ((local[i] + rotated) & 0xff) ^ ((90 + 35*i) & 0xff)
```

所以逆变换为：

```python
even[perm[i]] = ((local[i] ^ key[(3 + 5*i) & 15]) + rotated) & 0xff
```

后续全部在 `local25` 上分析。

### 6.1 固定字段与状态机

前置条件给出：

```text
word0 = 00000002
byte4 = 01
word5 = 05bd2d83
```

S-box 初始化使用 `word9` 驱动 xorshift32。由前三个 S-box 自检字节反解得到唯一值：

```text
word9 = e57305c7
```

最终的小配置域直接枚举得到：

```text
byte21  = 06
tail24  = 371342
rotate  = 7
```

### 6.2 TEA/LCG 状态

代码使用标准 TEA 常量：

```text
delta = 9e3779b9
```

轮密钥由 32 位 LCG 生成：

```python
seed = seed * 1664525 + 1013904223  (mod 2^32)
```

共有三组 16 轮 KAT：

```text
00000001 00000002 -> 7cf2c5a2 1410ee09
deadbeef cafebabe -> c094c7f3 5c08eeea
12345678 9abcdef0 -> 18cf95e0 8c30c302
```

这里只有一个 32 位未知量，且每个候选的前向计算极快。使用 CUDA 让每个线程测试一个 seed，先用第一组 KAT 筛选，命中后在 CPU 验证另外两组。RTX 4060 Laptop 上全域扫描约 0.2 秒，得到：

```text
schedule_seed = 5b28455b
```

全局 selector 的低字节为 `0x8c`，所以：

```text
word17 = schedule_seed XOR 8c8c8c8c
       = d7a4c9d7
```

最终 local state 为：

```text
0200000001832dbd05c70573e5b979379ed7c9a4d706421337
```

逆回原 even share：

```text
even25 = a77a78ff6a94367d1b4eb43faa8de2b30400bd533de8553443
```

状态机完整正向验证结果：

```text
initial checks = true
S-box check    = true
3 组 TEA KAT   = true
final config   = true
seed fold      = d7
```

even 生成的 expected block 与 odd checksum/key 生成的 actual block 均为：

```text
d6ced48b4a6f314d11f654f72956c20e
```

## 7. 合并

按原输入布局交织两个 share：

```python
flag_bytes = bytes(x for pair in zip(even25, odd25) for x in pair)
flag = flag_bytes.hex()
```

最终 flag 为：

```text
a77a7ae3781bff946ad2945636f87d0c1b414eb7b4293f8eaa638da5e2dfb310044b00c8bd72533d3d96e80f55e4345843ad
```

登录后可查看完整内容

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

上传的附件：

brute_even_cuda.py （1.50kb，4次下载）
solve.py （10.28kb，4次下载）