[原创]KCTF2026 第七题戌时·暗能潜流（AI）-CTF对抗-看雪安全社区

[原创]KCTF2026 第七题戌时·暗能潜流（AI）

发表于: 2026-8-21 10:52 783

[原创]KCTF2026 第七题戌时·暗能潜流（AI）

Ally Switch 活跃值

2026-8-21 10:52

783

> **FLAG：`flag{T1u_2026_Kc7f_Crypt0_M4ster!}`**

---

## 目录

- [〇、预备知识](#〇预备知识)
- [一、题目与已知条件](#一题目与已知条件)
- [二、突破口：输出长度规律](#二突破口输出长度规律)
- [三、对齐与差分：找出哪些位置装着明文](#三对齐与差分找出哪些位置装着明文)
- [四、判定运算类型：是加法，不是异或](#四判定运算类型是加法不是异或)
- [五、解出"谁来自谁"和"加了多少"](#五解出谁来自谁和加了多少)
- [六、块结构：从末尾往前，3 个字节一组](#六块结构从末尾往前3-个字节一组)
- [七、最后一块的特殊模板（含填充）](#七最后一块的特殊模板含填充)
- [八、解码 FLAG：逐块自检](#八解码-flag逐块自检)
- [九、完整求解器与最终验证](#九完整求解器与最终验证)
- [十、算法全貌总结与时间线](#十算法全貌总结与时间线)

---

## 〇、预备知识

**1. 半字节（nibble）**

一个字节有 8 个 bit，从中间切开，左右各 4 个 bit，每一半叫一个"半字节"。一个半字节恰好对应一位十六进制字符（0~F，也就是 0~15）。比如字节 `0x5C`：高半字节是 `5`，低半字节是 `C`。这道题所有操作都发生在半字节级别，所以后面我们把密文看成"一串半字节"而不是"一串字节"。

**2. mod 16（模 16）加减法**

半字节只能装 0~15，加减结果超出这个范围就"绕回来"：

- 加法绕回：`C + 4 = 12 + 4 = 16 → 16 − 16 = 0`
- 减法绕回：`3 − 5 = −2 → −2 + 16 = 14 = E`

记一个口诀就够了：**减出来是负数，就加 16**。

**3. 差分分析（本题最核心的一招）**

设想密文长这样：`密文 = 明文（打散重排）+ 一堆我们不知道的固定小常数`。

现在拿两条**长度相同**的明文，各自加密一次。因为长度相同，按题目提示"摘要扰动只与输入长度有关"，两条密文里混入的固定常数**完全一样**。于是两个式子相减，常数就消掉了：

```
密文A − 密文B = 明文A（重排后） − 明文B（重排后）
```

也就是说：**两条密文的差，就是两条明文的差换了个位置**。我们全程不需要知道常数是什么——它已经被减没了。这就是为什么必须挑同长度的一对样本（Hello 和 abcd!，都是 5 字符）。

**4. "多重集相同"是什么意思**

把一列数无视顺序、只统计"每个值出现几次"。比如 `E 7 3 9 8 4 E` 和 `E 4 9 8 3 E 7`，排序后都是 `3 4 7 8 9 E E`——每个值出现的次数一模一样，只是排列顺序不同。直觉说法：**同一批人换了座位，没有人多也没有人少**。在差分分析里，"差分值多重集相同"就是"只做了重排、没做混合"的铁证。

---

## 一、题目与已知条件

题目文件 `KCTF07_challenge-fix.txt`：

> HexMaze 使用固定算法对 ASCII 字符串进行变换。
>
> 算法仅包含：字节编码；十六进制位运算；模16循环偏移；固定位置重排；固定摘要扰动。
>
> 不包含：随机数；随机 IV；外部状态。相同输入和密钥一定产生唯一输出。
>
> 提示：**摘要扰动过程只与输入长度有关。**
>
> 已提供4组已知明文/密文，请分析变换规律并恢复 FLAG。
>
> 密钥: 121

已知对（明文先按 ASCII 转成字节，如 `TLU` → `54 4C 55`）：

| 明文 | 长度 | 密文（hex） | 密文半字节数 |
|---|---|---|---|
| `TLU` | 3 | `94AA48550495` | 12 |
| `Hello` | 5 | `34BB405504B5223594B94C53` | 24 |
| `2026` | 4 | `A48844556485223322356483` | 24 |
| `abcd!` | 5 | `547B475584B5223564BB4553` | 24 |
| FLAG | ? | `14CC...5A4B3`（共 144 位） | 144 |

只有 4 组样本、算法又有多层，正面硬猜是不行的。整体策略是：**利用"同长度样本做差能消掉未知常数"这一性质，把问题逐层剥开**。

---

## 二、突破口：输出长度规律

第一个脚本 `explore.py` 只做一件事：把数据解析出来、数长度。

```python
# -*- coding: utf-8 -*-
import re

data = open('KCTF07_challenge-fix.txt', encoding='utf-8-sig').read()
pairs = re.findall(r'(\w[\w!]*)\s*->\s*([0-9A-F]+)', data)
for p in pairs:
    print(p[0], len(p[0]), '->', p[1], 'hexlen', len(p[1]))

flag_line = re.findall(r'FLAG:\s*\n([0-9A-F]+)', data)
print('flag hex len:', len(flag_line[0]))
```

输出：

```
TLU 3 -> 94AA48550495 hexlen 12
Hello 5 -> 34BB405504B5223594B94C53 hexlen 24
2026 4 -> A48844556485223322356483 hexlen 24
abcd! 5 -> 547B475584B5223564BB4553 hexlen 24
flag hex len: 144
```

数一数就得到第一条硬规律：

```
输出的半字节数 = 4 × （明文长度填充到 3 的倍数后的字节数）
```

逐条核对：

- `TLU`：3 字节，不用填充 → 3 × 4 = 12 ✓
- `2026`：4 字节，填充到 6 → 6 × 4 = 24 ✓
- `Hello` / `abcd!`：5 字节，填充到 6 → 24 ✓
- FLAG：144 ÷ 4 = 36 → 明文长度是 34、35 或 36（后文会确定为 **34**）

翻译成人话：**明文先在末尾填充到 3 的倍数那么长，然后每个输入字节固定产出 2 个输出字节**。填充里没有随机量（题目声明没有随机 IV），所以填充字节要么是固定值、要么只跟长度有关——这正好对应提示里的"摘要扰动只与输入长度有关"。

---

## 三、对齐与差分：找出哪些位置装着明文

第二个脚本 `explore2.py` 把密文拆成半字节序列，重点观察**同长度的 Hello 与 abcd!**：

```python
# -*- coding: utf-8 -*-
s = {
 'TLU':   (bytes(map(ord,'TLU')),   '94AA48550495'),
 'Hello': (bytes(map(ord,'Hello')), '34BB405504B5223594B94C53'),
 '2026':  (bytes(map(ord,'2026')),  'A48844556485223322356483'),
 'abcd!': (bytes(map(ord,'abcd!')), '547B475584B5223564BB4553'),
}

def nibbles(x):                    # hex 串 -> 半字节列表
    return [int(c, 16) for c in x]

def innibs(bs):                    # 字节串 -> 半字节列表
    r = []
    for b in bs:
        r += [b >> 4, b & 0xF]     # 高半字节、低半字节
    return r

H = nibbles(s['Hello'][1]); hi = innibs(s['Hello'][0])
A = nibbles(s['abcd!'][1]); ai = innibs(s['abcd!'][0])
Y = nibbles(s['2026'][1])
T = nibbles(s['TLU'][1])

print('H ', H); print('A ', A); print('Y ', Y); print('T ', T)
print('H!=A 输出差分位:', [i for i in range(24) if H[i] != A[i]])
print('H vs A 输入差分位:', [i for i in range(10) if hi[i] != ai[i]])
print('H==A 但 Y 不同的位:', [i for i in range(24) if H[i] == A[i] and Y[i] != H[i]])
```

### 3.1 输入侧对齐

Hello 和 abcd! 都是 5 字节，把它们的 10 个输入半字节上下对齐（暂不管填充）：

```
            b0       b1       b2       b3       b4
半字节位:   0    1   2    3   4    5   6    7   8    9
Hello:      4    8   6    5   6    C   6    C   6    F      ('H' 'e' 'l' 'l' 'o')
abcd!:      6    1   6    2   6    3   6    4   2    1      ('a' 'b' 'c' 'd' '!')
            ✗    ✗   ✓    ✗   ✓    ✗   ✓    ✗   ✗    ✗      （✗=不同，✓=相同）
```

不同的位置是 `{0,1,3,5,7,8,9}`，共 **7 个**。

> 为什么 5 个字节全不同，半字节却只有 7 个位置不同？因为 'e','l','l' 和 'a','b','c' 的高半字节恰好都是 6（小写字母 0x61~0x6F 的高半字节都是 6），所以第 2、4、6 位"撞车"了。这是 ASCII 的巧合，不是规律。

### 3.2 输出侧对齐

再把两条 24 位的密文上下对齐：

```
输出位:  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
Hello:   3  4  B  B  4  0  5  5  0  4  B  5  2  2  3  5  9  4  B  9  4  C  5  3
abcd!:   5  4  7  B  4  7  5  5  8  4  B  5  2  2  3  5  6  4  B  B  4  5  5  3
         ✗     ✗        ✗                 ✗                          ✗        ✗  ✗
```

不同的位置是 `{0,2,5,8,16,19,21}`，也是 **7 个**。

### 3.3 三个结论

1. **输入 7 处不同、输出恰好也是 7 处不同**。如果存在"混合"（一个输出位由多个输入位合成），差分的个数一般会变多或变少，很难恰好对齐。这强烈暗示：**每个输出位来自唯一的一个输入位，整体只是一次"换座位"+逐位运算**。
2. 24 个输出位里只有 7~12 个装着明文数据，其余是**固定标记和长度摘要**（就是题目说的"固定摘要扰动"）。
3. Hello 与 abcd! 相同、但 2026（长度 4）不同的位是 `{3,10,15,17,18,20,22}`——这些位置受长度影响，是摘要的落点。解题时要么避开它们，要么单独确定。

---

## 四、判定运算类型：是加法，不是异或

现在回答一个关键问题：输出位和它对应的输入位之间，到底是 `+常数`、`^常数`，还是别的什么？方法：**把上一节两边的差分值都算出来，看哪一种运算的账能对上**。

### 4.1 输入差分：`E 7 3 9 8 4 E` 是怎么算出来的

在输入侧的 7 个差分位上，逐位做 **Hello 减 abcd!（mod 16，减出负数就 +16）**：

| 差分位 | 0 | 1 | 3 | 5 | 7 | 8 | 9 |
|---|---|---|---|---|---|---|---|
| Hello 输入 | 4 | 8 | 5 | C | C | 6 | F |
| abcd! 输入 | 6 | 1 | 2 | 3 | 4 | 2 | 1 |
| 相减过程 | 4−6=−2 → **E** | 8−1=**7** | 5−2=**3** | 12−3=**9** | 12−4=**8** | 6−2=**4** | 15−1=14 → **E** |

得到输入差分序列：`E 7 3 9 8 4 E`（按位 0,1,3,5,7,8,9 的顺序）。

### 4.2 输出差分：`E 4 9 8 3 E 7` 是怎么算出来的

同样地，在输出侧的 7 个差分位上逐位相减：

| 差分位 | 0 | 2 | 5 | 8 | 16 | 19 | 21 |
|---|---|---|---|---|---|---|---|
| Hello 输出 | 3 | B | 0 | 0 | 9 | 9 | C |
| abcd! 输出 | 5 | 7 | 7 | 8 | 6 | B | 5 |
| 相减过程 | 3−5=−2 → **E** | 11−7=**4** | 0−7=−7 → **9** | 0−8=−8 → **8** | 9−6=**3** | 9−11=−2 → **E** | 12−5=**7** |

得到输出差分序列：`E 4 9 8 3 E 7`（按位 0,2,5,8,16,19,21 的顺序）。

### 4.3 对账：两组数是"同一批人换了座位"

把两组差分各自排序：

```
输入差分  E 7 3 9 8 4 E   → 排序 →  3 4 7 8 9 E E
输出差分  E 4 9 8 3 E 7   → 排序 →  3 4 7 8 9 E E
```

**完全一致**（两个 E、以及 3、4、7、8、9 各一个，一个不多一个不少）。

这就是"加法 + 纯重排"的铁证，逻辑如下：假设 `密文[q] = 明文[σ(q)] + K_q`（第 q 个输出位来自某个输入位 σ(q)，加上一个固定小常数 K_q）。对两条同长度密文相减时，K_q 在两式中相同，被消掉：

```
密文A[q] − 密文B[q] = 明文A[σ(q)] − 明文B[σ(q)]
```

也就是说，**每个输出位上的差分，就等于某个输入位上的差分原样搬过来**。所以差分值只能是"换位置"，不可能变多、变少或变成新值——和观测完全吻合。

### 4.4 反面验证：异或和混合为什么被排除

**试一试异或（XOR）**：如果运算是 `密文[q] = 明文[σ(q)] ^ K_q`，那么两条密文的 XOR 差分也应该等于输入的 XOR 差分搬家。算出来看：

| | 第1个差分位 | 第2个 | 第3个 | 第4个 | 第5个 | 第6个 | 第7个 |
|---|---|---|---|---|---|---|---|
| 输出 XOR 差分（位 0,2,5,8,16,19,21） | 6 | C | 7 | 8 | F | 2 | 9 |
| 输入 XOR 差分（位 0,1,3,5,7,8,9） | 2 | 9 | 7 | F | 8 | 4 | E |

排序对比：输出是 `{2,6,7,8,9,C,F}`，输入是 `{2,4,7,8,9,E,F}`——输出里有 `6`、`C` 而输入里没有，输入里有 `4`、`E` 而输出里没有。**账对不上，异或模型出局。**

**试一试混合（扩散）**：如果某个输出位 = 两个输入位相加（比如 `明文[a] + 明文[b] + K`），那么做差时两个差分也会相加，例如 `E + 7 = 5`、`3 + 9 = C`，会凭空造出输入里不存在的差分值；而且"7 个输入差分对应 7 个输出差分"这种一一对应的关系根本无法成立。出局。

**结论**：变换就是 `out[q] = in[σ(q)] + K_q (mod 16)`——一次位置置换 + 每位一个小加数。剩下的活儿就是把 σ（谁来自谁）和 K（加多少）解出来。

---

## 五、解出"谁来自谁"和"加了多少"

### 5.1 用差分值配对，先定大部分"座位"

差分值就像防伪码：输出位上的某个差分值，必然来自输入里差分值相同的那一位。逐个值查账（一个值只在输入/输出各出现一次的，直接配对）：

| 差分值 | 输入中的位置 | 输出中的位置 | 配对结论 |
|---|---|---|---|
| 3 | 位 3 | 位 16 | 输出位16 ← 输入位3 |
| 4 | 位 8 | 位 2 | 输出位2 ← 输入位8 |
| 7 | 位 1 | 位 21 | 输出位21 ← 输入位1 |
| 8 | 位 7 | 位 8 | 输出位8 ← 输入位7 |
| 9 | 位 5 | 位 5 | 输出位5 ← 输入位5 |
| E | 位 0 **和** 位 9 | 位 0 **和** 位 19 | 有两个 E，暂时分不清谁对谁 |

**E 的歧义怎么解决？** 两种配法都满足差分，但算出的 K 不同。把两种都算出来，再用**另外两个样本（TLU、2026）当裁判**：

- 配法 A：输出位0 ← 输入位9（即 'o' 的**低**半字节 F）。K₀ = 3 − F = 4。拿 2026 检验：2026 的末字符是 '6'，低半字节 6，6 + 4 = A，正是 2026 密文的第 1 个半字节 ✓；拿 TLU 检验：末字符 'U' 低半字节 5，5 + 4 = 9，正是 TLU 密文的第 1 个半字节 ✓。
- 配法 B：输出位0 ← 输入位0（'H' 的**高**半字节 4）。K₀ = 3 − 4 = F。拿 2026 检验：首字符 '2' 高半字节 3，3 + F = 2 ✗（实际是 A）——淘汰。

所以输出位 0 ← 输入位 9，输出位 19 ← 输入位 0。

另外还有 5 个"隐形"数据位：Hello 和 abcd! 的输入在第 2、4、6 位恰好相同（都是 6），加上两个填充位——差分法看不见它们去哪了。它们的去向同样靠 TLU / 2026 交叉检验定位（方法同上：假设某输出来自某输入，用四个样本逐一验证 `输出 = 输入 + K` 是否处处成立）。

### 5.2 K 值总表

先把记号说清楚。填充后的输入共 12 个半字节，编号 `in0..in11`；`b0..b4` 是明文的 5 个字节，`in2k / in2k+1` 是第 k 个字节的高/低半字节。以 Hello 为例：

```
           b0='H'     b1='e'     b2='l'     b3='l'     b4='o'     填充
编号:       in0  in1   in2  in3   in4  in5   in6  in7   in8  in9   in10 in11
数值:        4    8     6    5     6    C     6    C     6    F     0    0
```

每个输出位的来源与加数 K（`K = 输出 − 来源输入`，Hello、abcd! 双向验证一致）：

| 输出位 | 来源 | K | Hello 验证 | abcd! 验证 |
|---|---|---|---|---|
| 0  | in9  = b4.低（末字符低半字节） | +4 | F+4=3 ✓ | 1+4=5 ✓ |
| 2  | in8  = b4.高 | +5 | 6+5=B ✓ | 2+5=7 ✓ |
| 3  | in4  = b2.高 | +5 | 6+5=B ✓ | 6+5=B ✓ |
| 5  | in5  = b2.低 | +4 | C+4=0 ✓ | 3+4=7 ✓ |
| 8  | in7  = b3.低 | +4 | C+4=0 ✓ | 4+4=8 ✓ |
| 10 | in6  = b3.高 | +5 | 6+5=B ✓ | 6+5=B ✓ |
| 16 | in3  = b1.低 | +4 | 5+4=9 ✓ | 2+4=6 ✓ |
| 18 | in2  = b1.高 | +5 | 6+5=B ✓ | 6+5=B ✓ |
| 19 | in0  = b0.高（首字符高半字节） | +5 | 4+5=9 ✓ | 6+5=B ✓ |
| 21 | in1  = b0.低 | +4 | 8+4=C ✓ | 1+4=5 ✓ |
| 20 | in10 = 填充.高 | +4 | 0+4=4 ✓ | 0+4=4 ✓ |
| 22 | in11 = 填充.低 | +5 | 0+5=5 ✓ | 0+5=5 ✓ |

从表里读出两个漂亮规律：

1. **加数只有两个值：来源是低半字节 → +4；来源是高半字节 → +5**（这就是全部"密钥流"，题目里的"模16循环偏移"落到实处就是它）。
2. **填充字节 = 0x00**（输出位 20：4 − 4 = 0；输出位 22：5 − 5 = 0，两个样本一致）。

其余输出位（1、4、6、7、9、11、12、13、14、15、17、23）是固定标记（4、5、2、3 之类），不随明文变化。

---

## 六、块结构：从末尾往前，3 个字节一组

### 6.1 换一种记法，规律自己浮现

把 5.2 表里的 `b4、b3、b2……` 换成"距末尾第几个字符"（记 e1 = 最后一个字符，e2 = 倒数第二，以此类推）：

```
Hello（长 5，填充 1 字节）:
[ H ][ e ][ l ][ l ][ o ][ 00 ]
从末尾往前数:  e1='o'  e2='l'  e3='l'  e4='e'  e5='H'  e6=填充
```

于是输出的前 12 位（6 字节）：

| 输出位 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 内容 | e1.低+4 | **4** | e1.高+5 | e3.高+5 | **4** | e3.低+4 | **5** | **5** | e2.低+4 | **4** | e2.高+5 | **5** |

这就是**普通块模板 T1**：从末尾往前每 3 个字符为一块（e1, e2, e3），产出 6 个输出字节；6 个数据半字节按 `e1低, e1高, e3高, e3低, e2低, e2高` 的次序散布，中间穿插固定标记 `4,4,5,5,4,5`。

### 6.2 用 TLU 把模板完整走一遍

TLU 恰好 3 个字符、一块、无填充，是验证模板的完美样本。`T=0x54, L=0x4C, U=0x55`，从后往前 e1='U', e2='L', e3='T'。逐位计算 `94 AA 48 55 04 95` 的 12 个半字节：

```
输出:    9  4 | A  A | 4  8 | 5  5 | 0  4 | 9  5
来源:   e1低+4 固定 e1高+5 e3高+5 固定 e3低+4 固定 固定 e2低+4 固定 e2高+5 固定
计算:    5+4=9      5+5=A   5+5=A        4+4=8            C+4=0      4+5=9
```

12 个位置全部吻合。再用 Hello 的第一块（末 3 字符 'l','l','o'）复核：e1='o'(高6低F)：位0 = F+4 = 3、位2 = 6+5 = B；e3='l'(高6低C)：位3 = 6+5 = B、位5 = C+4 = 0；e2='l'：位8 = C+4 = 0、位10 = 6+5 = B——正好是 `34 BB 40 55 04 B5`。四个样本的第一块全部如此。

第三个脚本 `solve.py` 把这个模板写成代码自检：

```python
# -*- coding: utf-8 -*-
samples = {
 'TLU':   (b'TLU',   bytes.fromhex('94AA48550495')),
 'Hello': (b'Hello', bytes.fromhex('34BB405504B5223594B94C53')),
 '2026':  (b'2026',  bytes.fromhex('A48844556485223322356483')),
 'abcd!': (b'abcd!', bytes.fromhex('547B475584B5223564BB4553')),
}

def nibs(bs):
    r = []
    for b in bs:
        r += [b >> 4, b & 0xF]
    return r

def T1_dec(ch):                       # 普通块模板 T1 解码 + 标记自检
    ok = (ch[1], ch[4], ch[6], ch[7], ch[9], ch[11]) == (4, 4, 5, 5, 4, 5)
    w = ((ch[2]-5) & 0xF) << 4 | ((ch[0]-4) & 0xF)     # e1（距末尾第1字符）
    u = ((ch[3]-5) & 0xF) << 4 | ((ch[5]-4) & 0xF)     # e3
    v = ((ch[10]-5) & 0xF) << 4 | ((ch[8]-4) & 0xF)    # e2
    return (u, v, w), ok

for name, (pt, ct) in samples.items():
    L, cn = len(pt), nibs(ct)
    ch = cn[:12]                                        # 第一块
    (u, v, w), ok = T1_dec(ch)
    print(name, 'L=%d 块0标记自检=%s (e3,e2,e1)=(%s,%s,%s) 期望=%s'
          % (L, ok, hex(u), hex(v), hex(w),
             [hex(pt[i]) for i in (L-3, L-2, L-1)]))
```

输出（4 组样本的第一块全部通过）：

```
TLU L=3 块0标记自检=True  (e3,e2,e1)=(0x54,0x4c,0x55)  期望=['0x54', '0x4c', '0x55']
Hello L=5 块0标记自检=True  (e3,e2,e1)=(0x6c,0x6c,0x6f)  期望=['0x6c', '0x6c', '0x6f']
2026 L=4 块0标记自检=True  (e3,e2,e1)=(0x30,0x32,0x36)  期望=['0x30', '0x32', '0x36']
abcd! L=5 块0标记自检=True  (e3,e2,e1)=(0x63,0x64,0x21)  期望=['0x63', '0x64', '0x21']
```

> 分析过程中的一个弯路：曾把输出第 7 位误当成随长度变化的摘要位（2026 的一些位确实随长度变化），细查后发现第 7 位恒为 5，真正随长度变化的只有末块里的个别字段（见下节）。

---

## 七、最后一块的特殊模板（含填充）

除最后一块外，**所有块都用 T1**——这一点由 FLAG 直接证实：FLAG 的 12 块里，前 11 块的第 1/4/6/7/9/11 相对位全部等于 `(4,4,5,5,4,5)`。

**最后一块（包含填充字节）用特殊模板**，按填充字节数分三种情况（题目说的"摘要扰动只与输入长度有关"就藏在这里）。

### 7.1 零填充（长度恰是 3 的倍数）

就是 TLU 的情况：整串恰好一块，直接用 T1，没有特殊之处。

### 7.2 一填充（长度 ≡ 2 mod 3，如 Hello / abcd!）

最后一块的内容是 `(P[1], P[0], 填充)`——P[0] 是首字符、P[1] 是第二个字符。模板（相对位 0~11）：

```
相对位:  0  1  2  3   4        5  6        7        8      9        10     11
内容:    2  2  3  5   P1.低+4  4  P1.高+5  P0.高+5  0+4    P0.低+4  0+5    3
```

拿 Hello 的最后 6 字节 `22 35 94 B9 4C 53` 逐位验证（P1='e'=0x65，P0='H'=0x48）：

```
2 2 | 3 5 | 9 4 | B 9 | 4 C | 5 3
固定  固定  e低5+4=9,固定4  e高6+5=B, H高4+5=9  0+4=4, H低8+4=C   0+5=5, 固定3
```

全对。abcd!（P1='b'，P0='a'）同样全对。

### 7.3 两填充（长度 ≡ 1 mod 3，如 2026 和 FLAG）

最后一块的内容是 `(P[0], 填充, 填充)`——只剩首字符一个真实字节。模板：

```
相对位:  0  1  2  3  4  5  6  7    8        9  10       11
内容:    2  2  3  3  2  2  3  0+5  P0.低+4  4  P0.高+5  3
                        └────┬────┘
                     长度摘要字段（不随明文变）
```

注意两个细节：

- 第 4、6 位是**长度摘要字段**：在 2026 和 FLAG 上都等于 `(2,3)`，与明文内容无关。
- 第 8、10 位装的是**首字符 P[0]，但高低半字节互换放置**：第 8 位 = P0.低+4，第 10 位 = P0.高+5。

**为什么要"互换"？——解题中最曲折的一步，值得复盘。** 2026 的最后 6 字节是 `22 33 22 35 64 83`，其中第 8、10 位是 `6` 和 `8`。按"正向"编码首字符 '2'（0x32，高 3 低 2）应该得到 `(3+4, 2+5) = (7,7)`，和实际的 `(6,8)` 对不上，一度卡住。后来试着把高低互换：`(2+4, 3+5) = (6,8)`——完全吻合。再拿这条规则反推 FLAG 的末块（第 8、10 位是 `A` 和 `B`）：`(A−4, B−5) = (6,6) = 'f'`。而前面 11 块已经解出 `lag{T1u_...`，首字符 `f` 正好拼成 `flag{`——两个样本同时闭环，规则坐实。

### 7.4 顺带确定 FLAG 的长度

FLAG 末块 `22 33 22 35 A4 B3` 与 2026 末块 `22 33 22 35 64 83` 的**前 4 字节完全相同**，即两者的长度摘要字段一致 → FLAG 与 2026 同属"两填充"类 → **FLAG 明文长度 = 34**（一举排除 35/36 的可能性）。

---

## 八、解码 FLAG：逐块自检

第四个脚本 `decode_flag.py` 对 FLAG 的 12 块逐块解码。每块有 6 个标记位做自检——套错模板会立刻暴露，所以这个解码是"带验尸的"，不是碰运气：

```python
# -*- coding: utf-8 -*-
flag_hex = ('14CC4655547594BC475584C5848A43551495448C445584C5D4C94755'
            '64C534A84B55A4B574BA4355F495A48844556485648C495534A5548C'
            '4F5584A5B4BB405554B522332235A4B3')

cn = [int(c, 16) for c in flag_hex]
chunks = [cn[i:i+12] for i in range(0, len(cn), 12)]

def T1_dec(ch):
    w = ((ch[2]-5) & 0xF) << 4 | ((ch[0]-4) & 0xF)    # e1（距末尾第1字符）
    u = ((ch[3]-5) & 0xF) << 4 | ((ch[5]-4) & 0xF)    # e3
    v = ((ch[10]-5) & 0xF) << 4 | ((ch[8]-4) & 0xF)   # e2
    return u, v, w

es = {}                                    # es[i] = 距末尾第 i 个字符
for k, ch in enumerate(chunks[:11]):       # 前 11 块均为 T1
    u, v, w = T1_dec(ch)
    assert (ch[1], ch[4], ch[6], ch[7], ch[9], ch[11]) == (4, 4, 5, 5, 4, 5)
    es[3*k+3], es[3*k+2], es[3*k+1] = u, v, w

fch = chunks[11]                           # 末块：两填充特殊模板
assert fch[:7] == [2,2,3,3,2,2,3]          # 摘要字段与 2026 一致 → 长度 34
es[34] = ((fch[10]-5) & 0xF) << 4 | ((fch[8]-4) & 0xF)   # 首字符（互换编码）

flag = ''.join(chr(es[i]) for i in range(34, 0, -1))     # e34 → e1
print(flag)
```

逐块解码明细（12 块的标记自检全部通过）：

| 块 k | 密文 6 字节 | 解出 (u,v,w) 即 (e₃ₖ₊₃, e₃ₖ₊₂, e₃ₖ₊₁) | 覆盖的字符 |
|---|---|---|---|
| 0 | `14 CC 46 55 54 75` | `r` `!` `}` | e3,e2,e1（倒数 1~3） |
| 1 | `94 BC 47 55 84 C5` | `s` `t` `e` | e6,e5,e4 |
| 2 | `84 8A 43 55 14 95` | `_` `M` `4` | e9,e8,e7 |
| 3 | `44 8C 44 55 84 C5` | `p` `t` `0` | e12,e11,e10 |
| 4 | `D4 C9 47 55 64 C5` | `C` `r` `y` | e15,e14,e13 |
| 5 | `34 A8 4B 55 A4 B5` | `7` `f` `_` | e18,e17,e16 |
| 6 | `74 BA 43 55 F4 95` | `_` `K` `c` | e21,e20,e19 |
| 7 | `A4 88 44 55 64 85` | `0` `2` `6` | e24,e23,e22 |
| 8 | `64 8C 49 55 34 A5` | `u` `_` `2` | e27,e26,e25 |
| 9 | `54 8C 4F 55 84 A5` | `{` `T` `1` | e30,e29,e28 |
| 10 | `B4 BB 40 55 54 B5` | `l` `a` `g` | e33,e32,e31 |
| 11 | `22 33 22 35 A4 B3` | 首字符 `f`（两填充末块） | e34 |

**注意阅读顺序**：e1 是**最后**一个字符，所以拼明文要倒着来，从 e34 读到 e1：

```
e34→e1:  f l a g { T 1 u _ 2 0 2 6 _ K c 7 f _ C r y p t 0 _ M 4 s t e r ! }
```

明文里还有几处自我印证：`2026`（第 7 块）、`Crypt0_M4ster`（第 0~4 块）、`flag{...}` 的完整格式。

---

## 九、完整求解器与最终验证

最终脚本 `final.py` 实现完整的加/解密，对 **4 组样本 + FLAG 做精确往返验证**：

```python
# -*- coding: utf-8 -*-
# HexMaze 完整求解器：解码 + 精确重加密验证
flag_hex = ('14CC4655547594BC475584C5848A43551495448C445584C5D4C94755'
            '64C534A84B55A4B574BA4355F495A48844556485648C495534A5548C'
            '4F5584A5B4BB405554B522332235A4B3')

samples = {
 'TLU':   (b'TLU',   '94AA48550495'),
 'Hello': (b'Hello', '34BB405504B5223594B94C53'),
 '2026':  (b'2026',  'A48844556485223322356483'),
 'abcd!': (b'abcd!', '547B475584B5223564BB4553'),
}

# ---------- 普通块模板 T1：(u,v,w) = (e3,e2,e1)，低nibble+4 / 高nibble+5 ----------
def T1_enc(u, v, w):
    n = [(w & 0xF) + 4, 4, (w >> 4) + 5, (u >> 4) + 5, 4, (u & 0xF) + 4,
         5, 5, (v & 0xF) + 4, 4, (v >> 4) + 5, 5]
    return [x & 0xF for x in n]

def T1_dec(ch):
    ok = (ch[1], ch[4], ch[6], ch[7], ch[9], ch[11]) == (4, 4, 5, 5, 4, 5)
    w = ((ch[2]-5) & 0xF) << 4 | ((ch[0]-4) & 0xF)
    u = ((ch[3]-5) & 0xF) << 4 | ((ch[5]-4) & 0xF)
    v = ((ch[10]-5) & 0xF) << 4 | ((ch[8]-4) & 0xF)
    return (u, v, w), ok

# ---------- 末块（含填充）模板 ----------
def final_enc_1pad(P):                      # 块 = (P[1], P[0], 填充)
    u, v, w = P[1], P[0], 0
    n = [2, 2, 3, 5, (u & 0xF) + 4, 4, (u >> 4) + 5,
         (v >> 4) + 5, (w >> 4) + 4, (v & 0xF) + 4, (w & 0xF) + 5, 3]
    return [x & 0xF for x in n]

def final_dec_1pad(ch):
    ok = (ch[0], ch[1], ch[2], ch[3], ch[5], ch[11]) == (2, 2, 3, 5, 4, 3)
    u = ((ch[6]-5) & 0xF) << 4 | ((ch[4]-4) & 0xF)   # P[1]
    v = ((ch[7]-5) & 0xF) << 4 | ((ch[9]-4) & 0xF)   # P[0]
    return (u, v), ok

def final_enc_2pad(P):                      # 块 = (摘要, 填充, P[0]互换编码)
    n = [2, 2, 3, 3, 2, 2, 3,
         0 + 5, (P[0] & 0xF) + 4, 0 + 4, (P[0] >> 4) + 5, 3]
    return [x & 0xF for x in n]

def final_dec_2pad(ch):
    ok = (ch[0], ch[1], ch[2], ch[3], ch[4], ch[5], ch[6],
          ch[7], ch[9], ch[11]) == (2, 2, 3, 3, 2, 2, 3, 5, 4, 3)
    w = ((ch[10]-5) & 0xF) << 4 | ((ch[8]-4) & 0xF)  # P[0]
    return w, ok

# ---------- 加密 ----------
def encode(pt):
    L = len(pt)
    pads = (3 - L % 3) % 3
    P = pt + b'\x00' * pads
    out = []
    nblocks = (L + pads) // 3
    for k in range(nblocks):
        last = (k == nblocks - 1)
        if not last or pads == 0:
            e1 = P[L-1-3*k]
            e2 = P[L-2-3*k] if L-2-3*k >= 0 else 0
            e3 = P[L-3-3*k] if L-3-3*k >= 0 else 0
            out += T1_enc(e3, e2, e1)
        elif pads == 1:
            out += final_enc_1pad(P)
        else:
            out += final_enc_2pad(P)
    return ''.join('%X' % x for x in out)

# ---------- 解密 ----------
def decode(ct_hex, L):
    cn = [int(c, 16) for c in ct_hex]
    chunks = [cn[i:i+12] for i in range(0, len(cn), 12)]
    pads = (3 - L % 3) % 3
    es = {}
    for k, ch in enumerate(chunks):
        last = (k == len(chunks) - 1)
        if not last or pads == 0:
            (u, v, w), ok = T1_dec(ch)
            assert ok, 'chunk %d marker mismatch' % k
            es[3*k+3], es[3*k+2], es[3*k+1] = u, v, w
        elif pads == 1:
            (u, v), ok = final_dec_1pad(ch)
            assert ok
            es[3*k+1], es[3*k+2] = u, v
        else:
            w, ok = final_dec_2pad(ch)
            assert ok
            es[L] = w                      # 末块 w = 首字符 P[0] = e_L
    return es

# ---------- 验证 ----------
if __name__ == '__main__':
    print('=== 样本重加密 ===')
    for name, (pt, ct) in samples.items():
        enc = encode(pt)
        print('%-6s %s  %s' % (name, enc, 'MATCH' if enc == ct else 'DIFF'))

print()
    print('=== 解码 FLAG (L=34, 2 填充) ===')
    es = decode(flag_hex, 34)
    flag_pt = bytes(es[i] for i in range(34, 0, -1))   # e1 是最后一字符
    print('FLAG:', flag_pt.decode())
    re = encode(flag_pt)
    print('重加密 :', re)
    print('原密文 :', flag_hex)
    print('nibble 差异数:', sum(1 for a, b in zip(re, flag_hex) if a != b),
          '/', len(flag_hex))
```

实际运行输出：

```
=== 样本重加密 ===
TLU    94AA48550495  MATCH
Hello  34BB405504B5223594B94C53  MATCH
2026   A48844556485223322356483  MATCH
abcd!  547B475584B5223564BB4553  MATCH

=== 解码 FLAG (L=34, 2 填充) ===
FLAG: flag{T1u_2026_Kc7f_Crypt0_M4ster!}
重加密 : 14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
原密文 : 14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
nibble 差异数: 0 / 144
```

---

## 十、算法全貌总结

HexMaze 的完整流程：

```
输入 (L 字节 ASCII)
  │
  ├─ 1. 填充：末尾补 0x00 至 3 的倍数 n = ⌈L/3⌉×3
  │
  ├─ 2. 分块：从字符串末尾往前，每 3 字节一块（e1=最后字符，
  │        e_i = 距末尾第 i 个字符；填充字节排在所有真实字符之后）
  │
  ├─ 3. 逐块变换：半字节级加法（低 nibble +4、高 nibble +5，mod 16），
  │        按固定模板散布到 12 个输出 nibble，其余位置填固定标记
  │        （"固定位置重排" = 模板中的散布次序；
  │          "模16循环偏移"  = mod 16 的加法偏移）
  │     · 普通块（T1）：
  │       [e1.低+4, 4, e1.高+5, e3.高+5, 4, e3.低+4, 5, 5, e2.低+4, 4, e2.高+5, 5]
  │     · 末块按填充数取特殊模板，其中含只依赖长度的摘要字段
  │        （1 填充编码 P[1]、P[0]；2 填充编码首字符 P[0]，高低互换）
  │
  └─ 4. 输出：大写 hex 串（nibble 数 = 4n）
```

关于密钥 `121`：仅凭 4 组样本无法确定它如何派生出 +4/+5 这套加法流（可能是 121 的某种展开），但对解题没有影响——密钥流本身已经被完整恢复并验证。

**答案：**

```
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

登录后可查看完整内容

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

最后于 2026-8-21 11:00 被Ally Switch编辑，原因：

收藏・0

点赞・5

打赏