[原创]第七题「戌时·暗能潜流」解析-CTF对抗-看雪安全社区

[原创]第七题「戌时·暗能潜流」解析

发表于: 2026-8-21 14:22 23

[原创]第七题「戌时·暗能潜流」解析

教教我吧~

2026-8-21 14:22

## 目录

1. [题目回顾](#一题目回顾)
2. [第 0 步：把题面信息翻译成"技术约束"](#二第-0-步把题面信息翻译成技术约束)
3. [第 1 步：确定分组结构](#三第-1-步确定分组结构)
4. [第 2 步：找出块内的"固定位"](#四第-2-步找出块内的固定位)
5. [第 3 步：定位高半字节（第一次突破）](#五第-3-步定位高半字节第一次突破)
6. [第 4 步：踩坑记录——"长度相关扰动"的错误假设](#六第-4-步踩坑记录长度相关扰动的错误假设)
7. [第 5 步：明文整体反转（真正的突破口）](#七第-5-步明文整体反转真正的突破口)
8. [第 6 步：低半字节全部归位](#八第-6-步低半字节全部归位)
9. [第 7 步：尾块 = "摘要扰动"](#九第-7-步尾块--摘要扰动)
10. [算法完整规范](#十算法完整规范)
11. [算法原理剖析：它到底在做什么](#十一算法原理剖析它到底在做什么)
12. [逆向解密详细教程](#十二逆向解密详细教程)
13. [实例演算](#十三实例演算)
14. [完整参考实现](#十四完整参考实现)
15. [关于"密钥 121"](#十五关于密钥-121)
16. [方法论总结](#十六方法论总结)

---

## 一、题目回顾

```
HexMaze 使用固定算法对 ASCII 字符串进行变换。

算法仅包含：
- 字节编码；
- 十六进制位运算；
- 模16循环偏移；
- 固定位置重排；
- 固定摘要扰动。

不包含：
- 随机数；
- 随机 IV；
- 外部状态。

相同输入和密钥一定产生唯一输出。

提示：摘要扰动过程只与输入长度有关。

已提供4组已知明文/密文，请分析变换规律并恢复 FLAG。

HexMaze
密钥: 121

TLU   -> 94AA48550495
Hello -> 34BB405504B5223594B94C53
2026  -> A48844556485223322356483
abcd! -> 547B475584B5223564BB4553

FLAG:
14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B5
74BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
```

（FLAG 密文实际是一整行，共 **144** 个十六进制字符，此处为排版折行。）

---

## 二、第 0 步：把题面信息翻译成"技术约束"

做密码分析题，第一件事不是看数据，是把自然语言描述翻译成可利用的数学约束。逐条拆：

| 题面表述                                 | 技术含义                                                     | 对分析的价值                                      |
| ---------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------- |
| 固定算法 / 无随机数 / 无 IV / 无外部状态 | **确定性函数** `C = E(P)`                                    | 相同明文片段必产生相同密文片段 → 可以做"片段比对" |
| 字节编码                                 | 明文字符先被拆/映射成某种中间表示                            | 密文长度 ÷ 明文长度 会暴露膨胀率                  |
| 十六进制位运算                           | 操作粒度是 **nibble（4 bit / 1 个十六进制字符）**，不是 byte | 分析单位应该是"十六进制位"，不是"字节"            |
| 模16循环偏移                             | `(x + k) mod 16`                                             | 数据位与明文位之间是**加法常量差**关系            |
| 固定位置重排                             | 一个**固定置换** `P`                                         | 明文位与密文位是一一对应的，只是位置乱了          |
| 固定摘要扰动                             | 一个附加的、非主体的扰动步骤                                 | 大概率只影响"边角"，不影响主体                    |
| **摘要扰动只与输入长度有关**             | 扰动 ≠ 明文内容的函数                                        | **这是最重要的提示**：主体变换与长度无关          |

关键推论：

> **"模16循环偏移 + 固定位置重排"意味着：密文的每一个十六进制位，都等于某一个明文半字节加上一个固定常数。**
>
> 形式化：存在置换 `π` 和常量数组 `k`，使得 `C[i] = (P[π(i)] + k[i]) mod 16`。

这个模型极强——它把破解降级成了"求一个置换 + 一组常量"，可以纯靠**列比对**解出来，不需要爆破。

---

## 三、第 1 步：确定分组结构

### 3.1 长度关系

```
明文长度  密文长度  比值
   3         12      4.00
   5         24      4.80
   4         24      6.00
   5         24      4.80
```

比值不固定 → **存在填充（padding）**。

反过来推：如果"每个字符固定产出 4 个十六进制位"，那么

```
n=3 → 12 位 = 3 字符   （3 → 3，不填充）
n=4 → 24 位 = 6 字符   （4 → 6，填 2）
n=5 → 24 位 = 6 字符   （5 → 6，填 1）
```

即：**明文按 3 字符对齐填充，每 3 字符产出 12 个十六进制位**。这是唯一自洽的解释。

FLAG 密文 144 位 ÷ 12 = **12 块**，对应填充后 36 个字符。

### 3.2 用"片段比对"验证块边界（决定性证据）

因为算法是确定性的，如果分块独立（类似 ECB），那么相同的 3 字符块在任何位置都会产生相同的 12 位密文。于是去 FLAG 里搜已知密文的 12 位块：

```python
FLAG.find("A48844556485")   # 2026 密文的第 0 块
# → 84
84 % 12 == 0    # ✅ 正好落在块边界上
```

**这一条命中同时证明了三件事：**

1. 块长确实是 12 个十六进制位；
2. 块边界从偏移 0 开始，`12` 对齐；
3. 块与块之间**互相独立**（无链式反馈、无位置相关偏移）——否则同一段明文在第 0 块和第 7 块不可能产生相同密文。

第 3 点尤其宝贵：它直接排除了 CBC 式链接和"随位置递增的偏移"，让每块可以单独求解。

把 FLAG 切成 12 块：

```
 0  14CC46555475
 1  94BC475584C5
 2  848A43551495
 3  448C445584C5
 4  D4C9475564C5
 5  34A84B55A4B5
 6  74BA4355F495
 7  A48844556485   ← 与 "2026" 的第 0 块完全相同
 8  648C495534A5
 9  548C4F5584A5
10  B4BB405554B5
11  22332235A4B3   ← 形态明显异常
```

块 11 长得和别人完全不一样（`2233`、`2235` 这种规整的低值），先记下，后面处理。

---

## 四、第 2 步：找出块内的"固定位"

把 4 组已知明文的**第一块**（都是完整的 3 字符块）按位摊开：

| 明文块 | pos0 | 1     | 2    | 3    | 4     | 5    | 6     | 7     | 8    | 9     | 10   | 11    |
| ------ | ---- | ----- | ---- | ---- | ----- | ---- | ----- | ----- | ---- | ----- | ---- | ----- |
| `TLU`  | 9    | **4** | A    | A    | **4** | 8    | **5** | **5** | 0    | **4** | 9    | **5** |
| `Hel`  | 3    | **4** | B    | B    | **4** | 0    | **5** | **5** | 0    | **4** | B    | **5** |
| `202`  | A    | **4** | 8    | 8    | **4** | 4    | **5** | **5** | 6    | **4** | 8    | **5** |
| `abc`  | 5    | **4** | 7    | B    | **4** | 7    | **5** | **5** | 8    | **4** | B    | **5** |

**pos 1 / 4 / 9 恒为 `4`；pos 6 / 7 / 11 恒为 `5`。**

再拿 FLAG 的 11 个正常块交叉验证 —— 全部符合。**6 个固定位，6 个数据位**。

数据位是 `{0, 2, 3, 5, 8, 10}`，正好 6 个，而 3 个 ASCII 字符 = 6 个半字节。**一一对应，信息量刚好守恒**，验证了"膨胀率 = 每半字节 1 个十六进制位 + 1 个标记位"的模型。

> **这一步的关键推理**：为什么这 6 个位是"结构性常量"而不是巧合？
> 因为如果它们承载明文数据，4 组差异极大的明文（`TLU` / `Hel` / `202` / `abc`，高半字节分别是 5,4,5 / 4,6,6 / 3,3,3 / 6,6,6）不可能全都撞成同一个值。
> 而 `4` 出现 3 次、`5` 出现 3 次的 **3:3 结构**，强烈暗示它们是"高半字节标记"和"低半字节标记"——即"字节编码"这一步的产物。

---

## 五、第 3 步：定位高半字节（第一次突破）

### 5.1 利用 ASCII 的"窄值域"特性

可打印 ASCII 字符（0x20–0x7E）的**高半字节只能是 2..7**，只有 6 种取值；而低半字节 0..F 全都可能。

所以：**承载高半字节的密文位，其取值必然被压缩在一个宽度 ≤ 6 的连续窗口内**（模 16 意义下）。

统计 FLAG 的 11 个正常块，每个数据位的取值集合：

| 数据位 | FLAG 11 块中的取值集合  | 不同值个数 | 窗口宽度      | 判定           |
| ------ | ----------------------- | ---------- | ------------- | -------------- |
| pos0   | `1,9,8,4,D,3,7,A,6,5,B` | **11**     | 散布全域      | 低半字节       |
| pos2   | `8,A,B,C`               | 4          | **5**（8..C） | **高半字节** ✅ |
| pos3   | `8,9,A,B,C`             | 5          | **5**（8..C） | **高半字节** ✅ |
| pos5   | `0,3,4,6,7,9,B,F`       | 8          | 散布全域      | 低半字节       |
| pos8   | `1,3,5,6,8,A,F`         | 7          | 散布全域      | 低半字节       |
| pos10  | `7,8,9,A,B,C`           | 6          | **6**（7..C） | **高半字节** ✅ |

> 这是一个非常好用的通用技巧：**当明文是可打印 ASCII 时，高半字节的熵远低于低半字节。只需统计每一列的取值分布，就能把"高位列"和"低位列"分开，完全不需要已知明文。**

结论：`pos2 / pos3 / pos10` 承载 3 个高半字节；`pos0 / pos5 / pos8` 承载 3 个低半字节。

### 5.2 求偏移常量

窗口都落在 `8..C`，而高半字节值域是 `2..7`，差值 = **+5**。用已知明文核对：

- `pos3`：`TLU`→A、`Hel`→B、`202`→8、`abc`→B
  减 5 得 `5, 6, 3, 6` = 各块**第 3 个字符**的高半字节 `hi('U')=5, hi('l')=6, hi('2')=3, hi('c')=6` ✅ **4/4 全中**
- `pos10`：`9, B, 8, B` 减 5 得 `4, 6, 3, 6` = 各块**第 2 个字符**的高半字节 `hi('L')=4, hi('e')=6, hi('0')=3, hi('b')=6` ✅ **4/4 全中**
- `pos2`：`A, B, 8, 7` 减 5 得 `5, 6, 3, 2`，期待等于**第 1 个字符**的高半字节 `hi('T')=5, hi('H')=4, hi('2')=3, hi('a')=6`
  → `TLU` ✅、`202` ✅、`Hel` ❌(6≠4)、`abc` ❌(2≠6)

**卡住了。** 两组对、两组错。

---

## 六、第 4 步：踩坑记录——"长度相关扰动"的错误假设

这里我先走了一段弯路，值得完整记下来，因为它是这类题最典型的思维陷阱。

**当时的（错误）推理链：**

- 对的两组是 `TLU`(len 3) 和 `202`(来自 len 4)，错的两组是 `Hel` 和 `abc`（都来自 **len 5**）。
- 题面说"摘要扰动只与输入长度有关" → 看起来完美吻合：**长度不同 → 扰动不同 → 某些位被额外加了一个长度相关的量**。
- 于是假设 `pos2 = hi(c0) + 5 + d(L)`。

**这个假设是怎么被证伪的：**

`Hello` 和 `abcd!` **长度都是 5**，扰动必然相同。可实测：

- `Hel`：需要 `pos2 - hi('H') = B - 4 = 7`
- `abc`：需要 `pos2 - hi('a') = 7 - 6 = 1`

同一长度却要求两个不同的扰动量 → **假设直接矛盾，证伪**。

同样的方法把 `pos0`、`pos8` 也试了一遍，全都在"同长度双样本"上自相矛盾。

> **教训（很重要）**：
> 当一个"合理的解释"能覆盖部分样本时，人会本能地给它打补丁（加一个自由参数）来解释剩下的。
> 正确做法是找一组**能同时约束该参数**的样本去证伪它。
> 这里 `Hello` / `abcd!` 同为长度 5，就是天然的"对照组"。**只要有两个同长度样本，任何'只与长度有关'的自由参数都会被立刻锁死。**
>
> 另一个反证同样致命：如果 `pos0 = hi(c0) + 常量`，那 FLAG 11 个块的 `pos0` 值必须落进 6 个格子里；但实测 `pos0` 有 **11 个互不相同的值**——鸽笼原理直接排除。这也提示 `pos0` 根本不是高半字节列。

排除了扰动之后，矛盾就必须从**结构**上解释：既然 `pos2 / pos3 / pos10` 是三个高半字节，而 `pos3 / pos10` 都能对上、只有 `pos2` 对不上，那问题只可能出在**"哪个字符是 c0"** 上——也就是**顺序**。

---

## 七、第 5 步：明文整体反转（真正的突破口）

### 7.1 从尾块拿到的暗示

回头看那些"异常"的第 2 块：

```
Hello → 第2块 223594B94C53
2026  → 第2块 223322356483
abcd! → 第2块 223564BB4553
FLAG  → 第12块 22332235A4B3
```

规整的低值 `2233`/`2235` 出现在**块的开头**，而"看起来像真实数据"的部分在**块的末尾**。如果填充字符是加在明文尾部的，填充产物本该出现在块尾。它出现在块首 → **顺序被翻转了**。

### 7.2 验证反转假设

设 `R = S[::-1]`（明文整体反转），再按 3 字符分块：

| 原文    | 反转 R  | 第 0 块 |
| ------- | ------- | ------- |
| `TLU`   | `ULT`   | `ULT`   |
| `Hello` | `olleH` | `oll`   |
| `2026`  | `6202`  | `620`   |
| `abcd!` | `!dcba` | `!dc`   |

重新核对 `pos2 = hi(c0) + 5`：

| 块    | c0       | hi(c0) | +5   | 实测 pos2 |      |
| ----- | -------- | ------ | ---- | --------- | ---- |
| `ULT` | `U`=0x55 | 5      | A    | A         | ✅    |
| `oll` | `o`=0x6F | 6      | B    | B         | ✅    |
| `620` | `6`=0x36 | 3      | 8    | 8         | ✅    |
| `!dc` | `!`=0x21 | 2      | 7    | 7         | ✅    |

**4/4 全中！** 顺带 `pos3`、`pos10` 在新顺序下依然成立：

| 块    | hi(c1)+5    | 实测 pos10 | hi(c2)+5    | 实测 pos3 |
| ----- | ----------- | ---------- | ----------- | --------- |
| `ULT` | hi(`L`)+5=9 | 9 ✅        | hi(`T`)+5=A | A ✅       |
| `oll` | hi(`l`)+5=B | B ✅        | hi(`l`)+5=B | B ✅       |
| `620` | hi(`2`)+5=8 | 8 ✅        | hi(`0`)+5=8 | 8 ✅       |
| `!dc` | hi(`d`)+5=B | B ✅        | hi(`c`)+5=B | B ✅       |

之前"对了两组"是因为 `TLU`→`ULT` 和 `202`→`620` 恰好高半字节相同或对称（`T`/`U` 同为 5，`2`/`0`/`6` 同为 3），属于**假阳性巧合**。

> **教训**：`202`、`TLU` 这种字符高位高度重复的样本，会掩盖顺序错误。
> 做已知明文分析时，**优先信任字符差异大的样本**（这里是 `Hello` / `abcd!`），它们的信息量更高、更容易暴露结构错误。

---

## 八、第 6 步：低半字节全部归位

顺序修正后，把 `pos0 / pos5 / pos8` 与反转块的 3 个低半字节对齐求差：

| 块    | lo(c0) | pos0 | 差    | lo(c1) | pos8 | 差    | lo(c2) | pos5 | 差    |
| ----- | ------ | ---- | ----- | ------ | ---- | ----- | ------ | ---- | ----- |
| `ULT` | 5      | 9    | **4** | C      | 0    | **4** | 4      | 8    | **4** |
| `oll` | F      | 3    | **4** | C      | 0    | **4** | C      | 0    | **4** |
| `!dc` | 1      | 5    | **4** | 4      | 8    | **4** | 3      | 7    | **4** |
| `620` | 6      | A    | **4** | 2      | 6    | **4** | 0      | 4    | **4** |

**12/12 全部等于 4**，无一例外，且与输入长度完全无关。

至此主体变换彻底还原：**高半字节 +5，低半字节 +4，全都是模 16。没有任何长度相关的扰动。**

---

## 九、第 7 步：尾块 = "摘要扰动"

正常块搞定后，只剩"不足 3 字符"的尾块。它就是题面说的**固定摘要扰动**——形态只由"剩余字符个数"（即输入长度 mod 3）决定，与内容无关，完美对应提示"**摘要扰动过程只与输入长度有关**"。

### 9.1 余 2 个字符

样本（反转后剩下的 2 个字符）：

```
"eH" → 2235 | 94B | 94C | 53      （来自 Hello，R="olleH"，剩 R[3..4]="eH"）
"ba" → 2235 | 64B | B45 | 53      （来自 abcd!，R="!dcba"，剩 R[3..4]="ba"）
```

逐段对照（`a` = 第 1 个剩余字符，`b` = 第 2 个）：

| 段      | `eH` 实测 | `ba` 实测 | 规律                                     |
| ------- | --------- | --------- | ---------------------------------------- |
| [0:4]   | `2235`    | `2235`    | 固定头（余 2 的标志）                    |
| [4]     | 9         | 6         | `lo(a)+4`：lo(`e`)=5→9 ✅ / lo(`b`)=2→6 ✅ |
| [5]     | 4         | 4         | 固定标记 `4`                             |
| [6]     | B         | B         | `hi(a)+5`：hi(`e`)=6→B ✅ / hi(`b`)=6→B ✅ |
| [7]     | 9         | B         | `hi(b)+5`：hi(`H`)=4→9 ✅ / hi(`a`)=6→B ✅ |
| [8]     | 4         | 4         | 固定标记 `4`                             |
| [9]     | C         | 5         | `lo(b)+4`：lo(`H`)=8→C ✅ / lo(`a`)=1→5 ✅ |
| [10:12] | `53`      | `53`      | 固定尾                                   |

注意第 2 个字符的 `hi` / `lo` 顺序是**反的**（先 hi 后 lo），与正常块中 `c2` 的排布风格一致——这正是"固定位置重排"的延续。

### 9.2 余 1 个字符

```
"2" → 2233 | 2235 | 6 4 8 3      （来自 2026，R="6202"，剩 R[3]="2"）
FLAG → 2233 | 2235 | A 4 B 3
```

| 段                 | 含义                                              |
| ------------------ | ------------------------------------------------- |
| [0:8] = `22332235` | 固定头（余 1 的标志，可理解为"两个填充位"的编码） |
| [8]                | `lo(c)+4`：lo(`2`)=2→6 ✅                          |
| [9]                | 固定标记 `4`                                      |
| [10]               | `hi(c)+5`：hi(`2`)=3→8 ✅                          |
| [11]               | 固定尾 `3`                                        |

对 FLAG 尾块 `22332235A4B3` 应用此规则：

```
lo = A - 4 = 6
hi = B - 5 = 6
char = 0x66 = 'f'
```

**FLAG 的第一个字符是 `f`** —— 因为反转后的最后一块，对应的正是原文的开头。符合 `flag{...}` 预期。

### 9.3 余 0 个字符

`TLU` 长度 3，正好整除，**不产生尾块**（密文只有 12 位）。所以填充只在需要时添加。

---

## 十、算法完整规范

### 10.1 加密

```
输入：ASCII 字符串 S
输出：大写十六进制字符串 C

Step 1  反转          R = S[::-1]
Step 2  分块          R 按 3 字符一组切分，得到 m = floor(len(R)/3) 个完整块，
                      余数 r = len(R) mod 3 ∈ {0,1,2}
Step 3  主体变换      每个完整块 (c0,c1,c2) → 12 个十六进制位（见下表）
Step 4  摘要扰动      按 r 追加尾块（r=0 时不追加）
Step 5  拼接输出
```

#### 完整块映射表（核心）

记 `hi(c) = c >> 4`，`lo(c) = c & 0xF`，全部运算模 16：

| 密文位   | 0          | 1    | 2          | 3          | 4    | 5          | 6    | 7    | 8          | 9    | 10         | 11   |
| -------- | ---------- | ---- | ---------- | ---------- | ---- | ---------- | ---- | ---- | ---------- | ---- | ---------- | ---- |
| **内容** | `lo(c0)+4` | `4`  | `hi(c0)+5` | `hi(c2)+5` | `4`  | `lo(c2)+4` | `5`  | `5`  | `lo(c1)+4` | `4`  | `hi(c1)+5` | `5`  |

用一句话记：

> **c0 的低位在最前，c0 的高位紧随；c2 的高低位分居 3、5 号位；c1 的高低位被挤到 8、10 号位；`4` 和 `5` 各三个当填充标记。**

#### 尾块规则

| 余数 r            | 尾块（12 位）                                                |
| ----------------- | ------------------------------------------------------------ |
| 0                 | *（无尾块）*                                                 |
| 1，剩余字符 `c`   | `2233` `2235` + `[lo(c)+4]` `4` `[hi(c)+5]` `3`              |
| 2，剩余字符 `a,b` | `2235` + `[lo(a)+4]` `4` `[hi(a)+5]` + `[hi(b)+5]` `4` `[lo(b)+4]` + `53` |

### 10.2 逐位速查（解密方向）

| 已知密文位 | 还原出             |
| ---------- | ------------------ |
| pos2 − 5   | c0 的高半字节      |
| pos0 − 4   | c0 的低半字节      |
| pos10 − 5  | c1 的高半字节      |
| pos8 − 4   | c1 的低半字节      |
| pos3 − 5   | c2 的高半字节      |
| pos5 − 4   | c2 的低半字节      |
| pos1,4,9   | 恒为 `4`（校验用） |
| pos6,7,11  | 恒为 `5`（校验用） |

---

## 十一、算法原理剖析：它到底在做什么

现在回头把还原出的规则，映射回题面声称的 5 个步骤，就能看清设计者的意图。

### 11.1 「字节编码」——nibble 展开 + 打标记

每个字符被拆成 2 个半字节，各自扩展成 1 个"带标记的字节"：

```
字符 c  ──┬──►  低半字节 lo(c)  ──►  编码为   0x4_ 类字节，写作  '4' + [(lo(c)+4) mod 16]
          └──►  高半字节 hi(c)  ──►  编码为   0x5_ 类字节，写作  '5' + [(hi(c)+5) mod 16]
```

- 标记 `4` = "我是低半字节"
- 标记 `5` = "我是高半字节"

这就解释了为什么密文里恰好有 3 个 `4` 和 3 个 `5`：3 个字符 × (1 低 + 1 高)。膨胀率 = 1 字符 → 2 字节 → **4 个十六进制字符**，与观测完全一致。

### 11.2 「十六进制位运算 + 模16循环偏移」——常量加法

```
低半字节：v = (lo(c) + 4) mod 16
高半字节：v = (hi(c) + 5) mod 16
```

这就是"模 16 循环偏移"的全部内容——**两个常量，4 和 5，与位置、长度、内容都无关**。

值得注意的是：偏移量和标记值相同（低位标记 `4` / 偏移 `4`，高位标记 `5` / 偏移 `5`）。所以整个编码可以更优雅地写成：

```
lo(c) → 字节  0x40 + ((lo(c) + 4) mod 16)   即 "4X"
hi(c) → 字节  0x50 + ((hi(c) + 5) mod 16)   即 "5X"
```

**这是它伪装成"哈希/密文"的关键**：偏移让 `hi` 从 `2..7` 搬到 `7..C`，于是密文里到处是 `A`、`B`、`C` 这类高位字符，看起来"很随机"，实际上熵一点没增加。

### 11.3 「固定位置重排」——一个 12 元置换

编码后，一个块的原始 12 位序列（按字符顺序、每字符先低后高）是：

```
索引:   0    1    2    3    4    5    6    7    8    9   10   11
内容:  '4'  L0  '5'  H0  '4'  L1  '5'  H1  '4'  L2  '5'  H2
        └─ c0 ─┘      └─ c0 ─┘  └─ c1 ─┘   └─ c1 ─┘ └─ c2 ─┘  └─ c2 ─┘
（记 L_i = (lo(c_i)+4) mod 16, H_i = (hi(c_i)+5) mod 16）
```

观测到的输出是：

```
输出:   L0  '4'  H0  H2  '4'  L2  '5'  '5'  L1  '4'  H1  '5'
```

于是置换 `P`（输出位置 → 取自输入索引）为：

```
P = [1, 0, 3, 11, 4, 9, 2, 6, 5, 8, 7, 10]
```

验证：`{1,0,3,11,4,9,2,6,5,8,7,10}` 恰好是 `0..11` 的一个排列 ✅ —— **模型自洽**。

> 说明：因为 3 个 `4` 之间、3 个 `5` 之间可以互换，这个置换的具体写法不唯一（有 3!×3! = 36 种等价写法），但**数据位的映射是唯一确定的**，不影响解密。

再叠加 Step 1 的**整串反转**——这是"重排"的第二层，也是本题最大的迷惑点：它让密文块顺序与明文块顺序相反，破坏了人眼最依赖的"从左到右"直觉。

### 11.4 「固定摘要扰动」——长度指纹

尾块中的 `2233` / `2235` / `53` / `3` 这些魔数，作用是：

1. **编码填充量**：解密方靠 `2233` 前缀区分"余 1"，靠 `2235` 前缀区分"余 2"，从而恢复真实长度；
2. **形态伪装**：让尾块看起来和正常块完全不同，制造"这里有个校验和/摘要"的错觉。

它**只与 `len(S) mod 3` 有关**，与明文内容无关——完全对应题面提示。所谓"摘要"其实一个哈希都没有，就是个长度指纹。

### 11.5 安全性评价

| 性质              | 实际情况                                                  |
| ----------------- | --------------------------------------------------------- |
| 混淆（confusion） | **无**。每个密文位只依赖 1 个明文半字节                   |
| 扩散（diffusion） | **无**。改 1 个明文字符只影响 4 个密文位                  |
| 密钥参与          | **无**（见第十五节）                                      |
| 本质              | **单表代换 + 固定置换**，等价于凯撒密码的 nibble 版       |
| 已知明文攻击      | **1 组样本即可完全破解**（本题给 4 组是为了容错）         |
| 唯密文攻击        | 也可行：靠 ASCII 高半字节的窄值域即可定位高位列并求出偏移 |

**核心弱点**：`C[i] = (P[π(i)] + k[i]) mod 16` —— 这是一个**逐位仿射映射**，没有任何非线性、没有轮函数、没有密钥调度。整个密码可以用一张 12 行的查表完全描述。

---

## 十二、逆向解密详细教程

假设你手上只有密文，下面是**从零开始的完整操作流程**。

### 步骤 1：确认密文长度是 12 的倍数

```
len(C) % 12 == 0
```

不是的话，说明分块假设错了，回头重新推膨胀率。

FLAG：`144 % 12 = 0` ✅ → 12 块。

### 步骤 2：切块，识别尾块

```python
blocks = [C[i:i+12] for i in range(0, len(C), 12)]
```

看**最后一块**：

- 以 `22332235` 开头 → 尾块，含 **1** 个真实字符（注意：它是 `2233` + `2235` 两段拼接，所以前 4 位是 `2233` 不是 `2235`）
- 以 `2235` 开头 → 尾块，含 **2** 个真实字符
- 都不是 → 无尾块，全是完整块

> 不会误判正常块：正常块 pos1 恒为 `4`，而两种尾块前缀的第 2 位都是 `2`。

FLAG 最后一块 `22332235A4B3` → `22332235` 开头 → 尾块，1 个字符。
所以：前 11 块 × 3 + 1 = **34 个字符**。

### 步骤 3：校验固定位（自检）

对每个**完整块**检查：

```
blk[1] == blk[4] == blk[9] == '4'
blk[6] == blk[7] == blk[11] == '5'
```

任何一块不满足 → 说明块边界错位或密文抄错，立刻停下排查。这是免费的纠错机制，一定要用。

### 步骤 4：解每个完整块

```
c0 = ((blk[2] - 5) mod 16) << 4  |  ((blk[0] - 4) mod 16)
c1 = ((blk[10] - 5) mod 16) << 4 |  ((blk[8] - 4) mod 16)
c2 = ((blk[3] - 5) mod 16) << 4  |  ((blk[5] - 4) mod 16)
```

**记忆口诀**：

- **高位减 5，低位减 4**
- 取位顺序 c0 →`(2, 0)`，c1 →`(10, 8)`，c2 →`(3, 5)`

### 步骤 5：解尾块

**含 1 个字符**（`22332235....`）：

```
lo = (blk[8]  - 4) mod 16
hi = (blk[10] - 5) mod 16
c  = chr(hi<<4 | lo)
```

**含 2 个字符**（`2235........`）：

```
a: lo = (blk[4] - 4) mod 16,  hi = (blk[6] - 5) mod 16
b: hi = (blk[7] - 5) mod 16,  lo = (blk[9] - 4) mod 16
```

⚠️ 注意 `b` 的 hi/lo 位置顺序与 `a` 相反，这是最容易写错的地方。

### 步骤 6：拼接后**反转**

```python
R = "".join(每块解出的字符)     # 这是反转态
S = R[::-1]                     # 这才是明文
```

⚠️ **不要忘记最后这一步反转** —— 这是本题最大的坑。

### 步骤 7：回验（必做）

用还原的算法把 `S` 重新加密，比对是否与原密文**逐位相同**。不做这一步，永远不能确定答案对不对。

```python
assert encrypt(S) == C
```

---

## 十三、实例演算

> **本章是自包含的。** 前面十二章讲的是"规律是怎么推出来的"，本章只讲"知道规律后怎么算"。
> 只看这一章，不回头翻任何其他章节，也能独立完成加密和解密的全部手工计算。所有需要用到的规则、对照表、字符编码都在 13.0 里给全。

---

### 13.0 开始之前：本章自带的全部规则

#### (1) 术语与符号

| 符号           | 含义                                             | 举例                             |
| -------------- | ------------------------------------------------ | -------------------------------- |
| `c`            | 一个 ASCII 字符                                  | `'H'`                            |
| `hi(c)`        | 该字符 ASCII 码的**高**半字节（十六进制第 1 位） | `'H'=0x48` → `hi=4`              |
| `lo(c)`        | 该字符 ASCII 码的**低**半字节（十六进制第 2 位） | `'H'=0x48` → `lo=8`              |
| `R`            | 明文**整体反转**后的字符串                       | `Hello` → `olleH`                |
| `blk` / `d[i]` | 一个 12 位的密文块 / 它的第 i 位（i 从 0 数起）  | `blk="14CC46555475"`, `d[2]='C'` |
| `r`            | `len(R) mod 3`，即最后剩几个字符不够凑一块       | `len("olleH")=5`, `r=2`          |

**一句话记住拆分方法**：把字符写成两位十六进制，**左边那位是 hi，右边那位是 lo**。

#### (2) 本章用到的全部字符 ASCII 速查表

| 字符 | 十六进制 | hi   | lo   |      | 字符 | 十六进制 | hi   | lo   |
| ---- | -------- | ---- | ---- | ---- | ---- | -------- | ---- | ---- |
| `!`  | 0x21     | 2    | 1    |      | `T`  | 0x54     | 5    | 4    |
| `0`  | 0x30     | 3    | 0    |      | `U`  | 0x55     | 5    | 5    |
| `1`  | 0x31     | 3    | 1    |      | `_`  | 0x5F     | 5    | F    |
| `2`  | 0x32     | 3    | 2    |      | `a`  | 0x61     | 6    | 1    |
| `4`  | 0x34     | 3    | 4    |      | `b`  | 0x62     | 6    | 2    |
| `6`  | 0x36     | 3    | 6    |      | `c`  | 0x63     | 6    | 3    |
| `7`  | 0x37     | 3    | 7    |      | `d`  | 0x64     | 6    | 4    |
| `C`  | 0x43     | 4    | 3    |      | `e`  | 0x65     | 6    | 5    |
| `H`  | 0x48     | 4    | 8    |      | `f`  | 0x66     | 6    | 6    |
| `K`  | 0x4B     | 4    | B    |      | `g`  | 0x67     | 6    | 7    |
| `L`  | 0x4C     | 4    | C    |      | `l`  | 0x6C     | 6    | C    |
| `M`  | 0x4D     | 4    | D    |      | `o`  | 0x6F     | 6    | F    |
|      |          |      |      |      | `p`  | 0x70     | 7    | 0    |
| `{`  | 0x7B     | 7    | B    |      | `r`  | 0x72     | 7    | 2    |
| `}`  | 0x7D     | 7    | D    |      | `s`  | 0x73     | 7    | 3    |
|      |          |      |      |      | `t`  | 0x74     | 7    | 4    |
|      |          |      |      |      | `u`  | 0x75     | 7    | 5    |
|      |          |      |      |      | `y`  | 0x79     | 7    | 9    |

#### (3) 模 16 加减速查表（**最容易出错的地方，建议直接查表**）

全部运算在模 16 下进行：**加法超过 F 就减 16；减法出现负数就加 16。**

**加密方向 —— 低半字节 `+4`：**

| 原值      | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9    | A    | B    | **C** | **D** | **E** | **F** |
| --------- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ----- | ----- | ----- | ----- |
| **+4 后** | 4    | 5    | 6    | 7    | 8    | 9    | A    | B    | C    | D    | E    | F    | **0** | **1** | **2** | **3** |

> 加粗的 4 列是**回绕**发生的地方：`C+4=0x10`，超出一位，只保留 `0`。

**加密方向 —— 高半字节 `+5`：**

| 原值      | 2    | 3    | 4    | 5    | 6    | 7    |
| --------- | ---- | ---- | ---- | ---- | ---- | ---- |
| **+5 后** | 7    | 8    | 9    | A    | B    | C    |

> 可打印 ASCII 的 hi 只可能是 `2..7`，所以加 5 后必落在 `7..C`，**永远不会回绕**。
> 反过来说：**解密时如果某个"高位列"的值不在 `7..C` 内，说明你取错位置了。**

**解密方向 —— 低半字节 `−4`：**

| 密文位    | **0** | **1** | **2** | **3** | 4    | 5    | 6    | 7    | 8    | 9    | A    | B    | C    | D    | E    | F    |
| --------- | ----- | ----- | ----- | ----- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
| **−4 后** | **C** | **D** | **E** | **F** | 0    | 1    | 2    | 3    | 4    | 5    | 6    | 7    | 8    | 9    | A    | B    |

> 加粗的 4 列是**必须 +16 回绕**的情况。例：`1 − 4 = −3`，`−3 + 16 = D`。
> ⚠️ 直接写成 `3` 是本题最高频的错误，会让整个 flag 全错。

**解密方向 —— 高半字节 `−5`：**

| 密文位    | 7    | 8    | 9    | A    | B    | C    |
| --------- | ---- | ---- | ---- | ---- | ---- | ---- |
| **−5 后** | 2    | 3    | 4    | 5    | 6    | 7    |

#### (4) 完整块模板（3 个字符 → 12 个十六进制位）

设一块的三个字符为 `c0, c1, c2`（**按 R 中的顺序**，即已经反转过的顺序）：

```
位号:   0        1     2        3        4     5        6     7     8        9     10       11
内容: lo(c0)+4   4   hi(c0)+5  hi(c2)+5   4  lo(c2)+4   5     5  lo(c1)+4   4   hi(c1)+5   5
      └─ c0 低   标记  └─ c0 高  └─ c2 高  标记 └─ c2 低  标记  标记 └─ c1 低  标记 └─ c1 高  标记
```

**背下这两条就够了：**

- **固定位**：位 1、4、9 恒为 `4`；位 6、7、11 恒为 `5`。（共 6 个，解密时用来自检）
- **数据位取法**：`c0 → (2, 0)`，`c1 → (10, 8)`，`c2 → (3, 5)`。**每对里前一个是 hi（减 5），后一个是 lo（减 4）。**

> 注意 `c1` 和 `c2` 的位置是**交叉错开**的（c2 在前、c1 在后），这是"固定位置重排"造成的，不是笔误。

#### (5) 尾块模板（剩 1 或 2 个字符时追加，也是 12 位）

| 情况              | 尾块 12 位构成                                               | 前缀特征（解密时靠它识别） |
| ----------------- | ------------------------------------------------------------ | -------------------------- |
| `r=0`             | **不产生尾块**                                               | 密文最后一块的位 1 是 `4`  |
| `r=1`，剩 `c`     | `2` `2` `3` `3` `2` `2` `3` `5` · `lo(c)+4` · `4` · `hi(c)+5` · `3` | 以 `22332235` 开头         |
| `r=2`，剩 `a` `b` | `2` `2` `3` `5` · `lo(a)+4` · `4` · `hi(a)+5` · `hi(b)+5` · `4` · `lo(b)+4` · `5` `3` | 以 `2235` 开头             |

**尾块数据位速查：**

| 情况  | 字符           | hi 在第几位（减 5） | lo 在第几位（减 4） |
| ----- | -------------- | ------------------- | ------------------- |
| `r=1` | `c`            | 10                  | 8                   |
| `r=2` | `a`（第 1 个） | 6                   | 4                   |
| `r=2` | `b`（第 2 个） | 7                   | 9                   |

> ⚠️ 两个坑：
> ① `r=2` 时，`a` 是"先 lo 后 hi"，`b` 是"先 hi 后 lo"，**顺序相反**，写反了必错。
> ② `r=1` 的尾块虽然名义上是 `2233` + `2235` 两段拼接，但**实际是以 `2233` 开头的**，判别时不能只写"以 2235 开头"。

#### (6) 总流程图

```
加密：  明文 S ──反转──► R ──每3字符切块──► [完整块…] + [余 r 个字符]
                                              │              │
                                       套用模板(4)      套用模板(5)
                                              └──────┬───────┘
                                                  顺序拼接 ──► 密文 C

解密：  密文 C ──每12位切块──► [块…] ──看最后一块前缀──► 完整块用(4)解 / 尾块用(5)解
                                                              │
                                              顺序拼接得到 R ──反转──► 明文 S
```

---

### 13.1 加密例 1：`Hello`（`r=2`，完整覆盖两种块）

#### Step 1 反转

```
S = H e l l o
R = o l l e H          ← 整个字符串倒过来写
```

`len(R) = 5`

#### Step 2 分块

```
5 = 3 × 1 + 2
```

```
R  =  o  l  l  |  e  H
      └─完整块─┘  └─余 2─┘
```

- 完整块 1 个：`"oll"` → `c0='o'`, `c1='l'`, `c2='l'`
- 余数 `r = 2`，剩余字符 `a='e'`, `b='H'`

#### Step 3 拆半字节（查 13.0 表 (2)）

| 变量 | 字符 | 十六进制 | hi    | lo    |
| ---- | ---- | -------- | ----- | ----- |
| `c0` | `o`  | 0x6F     | **6** | **F** |
| `c1` | `l`  | 0x6C     | **6** | **C** |
| `c2` | `l`  | 0x6C     | **6** | **C** |

#### Step 4 逐位填完整块（严格按模板 (4) 的 12 行走一遍）

| 位号 | 模板内容   | 代入  | 加法过程                        | 结果  |
| ---- | ---------- | ----- | ------------------------------- | ----- |
| 0    | `lo(c0)+4` | `F+4` | `15+4=19`，`19−16=3` ← **回绕** | **3** |
| 1    | 固定标记   | —     | —                               | **4** |
| 2    | `hi(c0)+5` | `6+5` | `=11`                           | **B** |
| 3    | `hi(c2)+5` | `6+5` | `=11`                           | **B** |
| 4    | 固定标记   | —     | —                               | **4** |
| 5    | `lo(c2)+4` | `C+4` | `12+4=16`，`16−16=0` ← **回绕** | **0** |
| 6    | 固定标记   | —     | —                               | **5** |
| 7    | 固定标记   | —     | —                               | **5** |
| 8    | `lo(c1)+4` | `C+4` | `12+4=16`，`16−16=0` ← **回绕** | **0** |
| 9    | 固定标记   | —     | —                               | **4** |
| 10   | `hi(c1)+5` | `6+5` | `=11`                           | **B** |
| 11   | 固定标记   | —     | —                               | **5** |

按位号 0→11 顺序读出：

```
3 4 B B 4 0 5 5 0 4 B 5   →   "34BB405504B5"
```

#### Step 5 填尾块（`r=2`，按模板 (5)）

`a = 'e' = 0x65` → hi=6, lo=5
`b = 'H' = 0x48` → hi=4, lo=8

| 位号  | 模板内容  | 代入     | 结果        |
| ----- | --------- | -------- | ----------- |
| 0–3   | 固定头    | —        | **2 2 3 5** |
| 4     | `lo(a)+4` | `5+4=9`  | **9**       |
| 5     | 固定标记  | —        | **4**       |
| 6     | `hi(a)+5` | `6+5=11` | **B**       |
| 7     | `hi(b)+5` | `4+5=9`  | **9**       |
| 8     | 固定标记  | —        | **4**       |
| 9     | `lo(b)+4` | `8+4=12` | **C**       |
| 10–11 | 固定尾    | —        | **5 3**     |

```
2 2 3 5 9 4 B 9 4 C 5 3   →   "223594B94C53"
```

#### Step 6 拼接

```
"34BB405504B5" + "223594B94C53" = "34BB405504B5223594B94C53"
```

与题面给出的 `Hello -> 34BB405504B5223594B94C53` **逐位一致** ✅

---

### 13.2 加密例 2：`2026`（`r=1`）

#### Step 1–2 反转与分块

```
S = 2 0 2 6
R = 6 2 0 2          len=4，4 = 3×1 + 1
R = 6  2  0  |  2
    └完整块┘   └余1┘
```

`c0='6'`, `c1='2'`, `c2='0'`；剩余字符 `c='2'`。

#### Step 3 拆半字节

| 变量 | 字符 | 十六进制 | hi    | lo    |
| ---- | ---- | -------- | ----- | ----- |
| `c0` | `6`  | 0x36     | **3** | **6** |
| `c1` | `2`  | 0x32     | **3** | **2** |
| `c2` | `0`  | 0x30     | **3** | **0** |

#### Step 4 完整块

| 位号 | 模板       | 代入     | 结果  |
| ---- | ---------- | -------- | ----- |
| 0    | `lo(c0)+4` | `6+4=10` | **A** |
| 1    | 标记       | —        | **4** |
| 2    | `hi(c0)+5` | `3+5=8`  | **8** |
| 3    | `hi(c2)+5` | `3+5=8`  | **8** |
| 4    | 标记       | —        | **4** |
| 5    | `lo(c2)+4` | `0+4=4`  | **4** |
| 6    | 标记       | —        | **5** |
| 7    | 标记       | —        | **5** |
| 8    | `lo(c1)+4` | `2+4=6`  | **6** |
| 9    | 标记       | —        | **4** |
| 10   | `hi(c1)+5` | `3+5=8`  | **8** |
| 11   | 标记       | —        | **5** |

```
A 4 8 8 4 4 5 5 6 4 8 5   →   "A48844556485"
```

#### Step 5 尾块（`r=1`）

`c = '2' = 0x32` → hi=3, lo=2

| 位号 | 模板      | 代入    | 结果                |
| ---- | --------- | ------- | ------------------- |
| 0–7  | 固定头    | —       | **2 2 3 3 2 2 3 5** |
| 8    | `lo(c)+4` | `2+4=6` | **6**               |
| 9    | 标记      | —       | **4**               |
| 10   | `hi(c)+5` | `3+5=8` | **8**               |
| 11   | 固定尾    | —       | **3**               |

```
"22332235" + "6" + "4" + "8" + "3" = "223322356483"
```

#### Step 6 拼接

```
"A48844556485" + "223322356483" = "A48844556485223322356483"
```

与题面 `2026 -> A48844556485223322356483` **一致** ✅

---

### 13.3 加密例 3：`TLU`（`r=0`，无尾块）

```
S = T L U        R = U L T        len=3，3 = 3×1 + 0  →  r=0，不产生尾块
c0='U'=0x55 (hi=5, lo=5)
c1='L'=0x4C (hi=4, lo=C)
c2='T'=0x54 (hi=5, lo=4)
```

| 位号 | 模板       | 代入                  | 结果  |
| ---- | ---------- | --------------------- | ----- |
| 0    | `lo(c0)+4` | `5+4=9`               | **9** |
| 1    | 标记       | —                     | **4** |
| 2    | `hi(c0)+5` | `5+5=10`              | **A** |
| 3    | `hi(c2)+5` | `5+5=10`              | **A** |
| 4    | 标记       | —                     | **4** |
| 5    | `lo(c2)+4` | `4+4=8`               | **8** |
| 6    | 标记       | —                     | **5** |
| 7    | 标记       | —                     | **5** |
| 8    | `lo(c1)+4` | `C+4=16→0` ← **回绕** | **0** |
| 9    | 标记       | —                     | **4** |
| 10   | `hi(c1)+5` | `4+5=9`               | **9** |
| 11   | 标记       | —                     | **5** |

```
9 4 A A 4 8 5 5 0 4 9 5   →   "94AA48550495"
```

与题面 `TLU -> 94AA48550495` **一致** ✅ 密文只有 12 位，印证了 `r=0` 时确实不追加尾块。

---

### 13.4 解密例 1：单个完整块 `14CC46555475`

#### Step 1 摊开成位号表

```
位号:  0   1   2   3   4   5   6   7   8   9   10  11
值:    1   4   C   C   4   6   5   5   5   4   7   5
```

#### Step 2 固定位自检（**必做，免费的纠错**）

| 检查项  | 要求 | 实测 | 结果 |
| ------- | ---- | ---- | ---- |
| `d[1]`  | `4`  | 4    | ✅    |
| `d[4]`  | `4`  | 4    | ✅    |
| `d[9]`  | `4`  | 4    | ✅    |
| `d[6]`  | `5`  | 5    | ✅    |
| `d[7]`  | `5`  | 5    | ✅    |
| `d[11]` | `5`  | 5    | ✅    |

6/6 通过 → 这是一个结构正确的完整块，可以继续。
（若有任何一项不符，说明**块边界切错了**或**密文抄错了**，应立即停下排查，而不是硬算下去。）

#### Step 3 解 `c0`（取位 2 和位 0）

```
hi(c0) = d[2] − 5 = C − 5 = 12 − 5 = 7
lo(c0) = d[0] − 4 = 1 − 4 = −3   ← 负数！必须回绕
                              −3 + 16 = 13 = D
c0 = 0x7D = '}'
```

#### Step 4 解 `c1`（取位 10 和位 8）

```
hi(c1) = d[10] − 5 = 7 − 5 = 2
lo(c1) = d[8]  − 4 = 5 − 4 = 1
c1 = 0x21 = '!'
```

#### Step 5 解 `c2`（取位 3 和位 5）

```
hi(c2) = d[3] − 5 = C − 5 = 7
lo(c2) = d[5] − 4 = 6 − 4 = 2
c2 = 0x72 = 'r'
```

#### 结果

```
本块 = "}!r"
```

因为整串明文是反转态，这 3 个字符对应**原文最末尾 3 个字符的倒序** → 原文以 `r!}` 结尾。对于一个 `flag{...}` 格式的 flag，结尾是 `}`，完全合理 ✅

> **本例最大的坑**：`d[0] − 4 = 1 − 4`。
> 很多人算成 `−3` 后直接取绝对值当成 `3`，得到 `0x73 = 's'`，于是 flag 结尾变成 `s!r`，整题全错。
> **凡是减法结果为负，一律 `+16`。** 查 13.0 表 (3) 的"解密方向 −4"那一行也可以直接得到 `1 → D`。

---

### 13.5 解密例 2：尾块（`r=1`）`22332235A4B3`

#### Step 1 摊开 + 识别类型

```
位号:  0  1  2  3  4  5  6  7   8   9  10  11
值:    2  2  3  3  2  2  3  5   A   4   B   3
       └───── 22332235 ─────┘  └── 数据区 ──┘
```

前 8 位是 `22332235` → 查 13.0 表 (5)：**这是 `r=1` 的尾块，只含 1 个真实字符**。

> **为什么不会和完整块搞混？** 完整块的位 1 恒为 `4`，而这里位 1 是 `2`，天然互斥。

#### Step 2 取数据位（`r=1` 时：hi 在位 10，lo 在位 8）

```
lo(c) = d[8]  − 4 = A − 4 = 10 − 4 = 6
hi(c) = d[10] − 5 = B − 5 = 11 − 5 = 6
```

#### Step 3 合成字符

```
c = (hi << 4) | lo = (6 << 4) | 6 = 0x66 = 'f'
```

#### 结果

反转态的**最后**一个字符 = 原文的**第一个**字符 → **flag 以 `f` 开头** ✅

---

### 13.6 解密例 3：尾块（`r=2`）`223594B94C53`

#### Step 1 摊开 + 识别类型

```
位号:  0  1  2  3  4  5  6  7  8  9  10 11
值:    2  2  3  5  9  4  B  9  4  C  5  3
       └─2235─┘  └──── 数据区 ────┘ └53┘
```

前 4 位是 `2235`（且**不是** `22332235`）→ **`r=2` 的尾块，含 2 个真实字符**。

#### Step 2 解第 1 个字符 `a`（lo 在位 4，hi 在位 6）

```
lo(a) = d[4] − 4 = 9 − 4 = 5
hi(a) = d[6] − 5 = B − 5 = 6
a = 0x65 = 'e'
```

#### Step 3 解第 2 个字符 `b`（**hi 在位 7，lo 在位 9 —— 顺序与 a 相反**）

```
hi(b) = d[7] − 5 = 9 − 5 = 4
lo(b) = d[9] − 4 = C − 4 = 8
b = 0x48 = 'H'
```

#### 结果

```
本尾块 = "eH"
```

这正是 13.1 中 `Hello` 反转后 `R="olleH"` 的最后两个字符 ✅ 加解密闭环。

---

### 13.7 FLAG 全量解密（12 块逐块演算）

FLAG 密文（144 位，实际为一整行）：

```
14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C5
34A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5
B4BB405554B522332235A4B3
```

#### Step 1 长度校验与切块

```
144 ÷ 12 = 12   →   整除 ✅，共 12 块
```

| #    | 密文块         |
| ---- | -------------- |
| 0    | `14CC46555475` |
| 1    | `94BC475584C5` |
| 2    | `848A43551495` |
| 3    | `448C445584C5` |
| 4    | `D4C9475564C5` |
| 5    | `34A84B55A4B5` |
| 6    | `74BA4355F495` |
| 7    | `A48844556485` |
| 8    | `648C495534A5` |
| 9    | `548C4F5584A5` |
| 10   | `B4BB405554B5` |
| 11   | `22332235A4B3` |

#### Step 2 判定尾块

看**最后一块** `22332235A4B3`：以 `22332235` 开头 → `r=1` 的尾块，含 **1** 个字符。
前 11 块位 1 全是 `4`，均为完整块。

```
明文长度 = 11 × 3 + 1 = 34 个字符
```

#### Step 3 逐块解算（前 11 块用 13.4 的方法，第 11 块用 13.5 的方法）

下表把每块的三次"取位—减法—合成"全部展开。**减法列中标 `+16` 的即发生了回绕。**

| #    | 密文块         | `c0`：`d[2]−5` / `d[0]−4`       | `c1`：`d[10]−5` / `d[8]−4`                      | `c2`：`d[3]−5` / `d[5]−4`       | 明文  |
| ---- | -------------- | ------------------------------- | ----------------------------------------------- | ------------------------------- | ----- |
| 0    | `14CC46555475` | `C−5=7` / `1−4+16=D` → 0x7D `}` | `7−5=2` / `5−4=1` → 0x21 `!`                    | `C−5=7` / `6−4=2` → 0x72 `r`    | `}!r` |
| 1    | `94BC475584C5` | `B−5=6` / `9−4=5` → 0x65 `e`    | `C−5=7` / `8−4=4` → 0x74 `t`                    | `C−5=7` / `7−4=3` → 0x73 `s`    | `ets` |
| 2    | `848A43551495` | `8−5=3` / `8−4=4` → 0x34 `4`    | `9−5=4` / `1−4+16=D` → 0x4D `M`                 | `A−5=5` / `3−4+16=F` → 0x5F `_` | `4M_` |
| 3    | `448C445584C5` | `8−5=3` / `4−4=0` → 0x30 `0`    | `C−5=7` / `8−4=4` → 0x74 `t`                    | `C−5=7` / `4−4=0` → 0x70 `p`    | `0tp` |
| 4    | `D4C9475564C5` | `C−5=7` / `D−4=9` → 0x79 `y`    | `C−5=7` / `6−4=2` → 0x72 `r`                    | `9−5=4` / `7−4=3` → 0x43 `C`    | `yrC` |
| 5    | `34A84B55A4B5` | `A−5=5` / `3−4+16=F` → 0x5F `_` | `B−5=6` / `A−4=6` → 0x66 `f`                    | `8−5=3` / `B−4=7` → 0x37 `7`    | `_f7` |
| 6    | `74BA4355F495` | `B−5=6` / `7−4=3` → 0x63 `c`    | `9−5=4` / `F−4=B` → 0x4B `K`                    | `A−5=5` / `3−4+16=F` → 0x5F `_` | `cK_` |
| 7    | `A48844556485` | `8−5=3` / `A−4=6` → 0x36 `6`    | `8−5=3` / `6−4=2` → 0x32 `2`                    | `8−5=3` / `4−4=0` → 0x30 `0`    | `620` |
| 8    | `648C495534A5` | `8−5=3` / `6−4=2` → 0x32 `2`    | `A−5=5` / `3−4+16=F` → 0x5F `_`                 | `C−5=7` / `9−4=5` → 0x75 `u`    | `2_u` |
| 9    | `548C4F5584A5` | `8−5=3` / `5−4=1` → 0x31 `1`    | `A−5=5` / `8−4=4` → 0x54 `T`                    | `C−5=7` / `F−4=B` → 0x7B `{`    | `1T{` |
| 10   | `B4BB405554B5` | `B−5=6` / `B−4=7` → 0x67 `g`    | `B−5=6` / `5−4=1` → 0x61 `a`                    | `B−5=6` / `0−4+16=C` → 0x6C `l` | `gal` |
| 11   | `22332235A4B3` | *（尾块，规则不同）*            | `d[10]−5 = B−5=6` / `d[8]−4 = A−4=6` → 0x66 `f` | *（无）*                        | `f`   |

> 全表共出现 **6 次负数回绕**（块 0、2、5、6、8、10 各一次）。这 6 处是全题最容易翻车的地方，逐一核对过再往下走。

#### Step 4 顺序拼接，得到反转态 `R`

```
块0  }!r
块1  ets
块2  4M_
块3  0tp
块4  yrC
块5  _f7
块6  cK_
块7  620
块8  2_u
块9  1T{
块10 gal
块11 f
```

```
R = "}!r" + "ets" + "4M_" + "0tp" + "yrC" + "_f7" + "cK_" + "620" + "2_u" + "1T{" + "gal" + "f"
  = "}!rets4M_0tpyrC_f7cK_6202_u1T{galf"
```

#### Step 5 **整体反转**（最关键、最容易漏的一步）

```
R = } ! r e t s 4 M _ 0 t p y r C _ f 7 c K _ 6 2 0 2 _ u 1 T { g a l f
                                    ↓ 从后往前读 ↓
S = 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 ! }
```

```
明文 S = flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

#### Step 6 长度校验

```
len("flag{T1u_2026_Kc7f_Crypt0_M4ster!}") = 34
Step 2 预测值 = 11 × 3 + 1 = 34        ✅ 吻合
```

#### Step 7 回验（**必做，不回验的答案不算答案**）

把还原出的明文重新加密一遍，与原密文逐位比对：

```
encrypt("flag{T1u_2026_Kc7f_Crypt0_M4ster!}")
= 14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C5
  34A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5
  B4BB405554B522332235A4B3
```

与题面 FLAG 密文 **144 位逐位相同** ✅

**语义自检**：flag 内容是 leetspeak —— `T1u` + `2026` + `Kc7f`（KCTF，`t`→`7`）+ `Crypt0`（`o`→`0`）+ `M4ster`（`a`→`4`）。各段均为可读的英文单词/年份变形，语义自洽，进一步佐证结果正确。

---

### 13.8 本章易错点清单（动手前过一遍）

| #    | 易错点                                 | 后果                                       | 规避方法                                     |
| ---- | -------------------------------------- | ------------------------------------------ | -------------------------------------------- |
| 1    | **忘记最后的整体反转**                 | 得到 `}!rets4M_...` 这种倒序串             | 加密第一步反转、解密最后一步反转，两头都别漏 |
| 2    | **减法出负数没 `+16`**                 | 单个字符错，如 `}`→`s`                     | 查 13.0 表 (3) 的解密行，或牢记"负了就加 16" |
| 3    | **加法超 F 没 `−16`**                  | 加密结果对不上，如 `C+4` 写成 `10`         | `C/D/E/F` 加 4 必回绕，见表 (3)              |
| 4    | **`c1` 和 `c2` 的取位记反**            | 每块中间两个字符互换                       | 口诀：`c0→(2,0)`，`c1→(10,8)`，`c2→(3,5)`    |
| 5    | **`r=2` 尾块中 `b` 的 hi/lo 顺序写反** | 末尾 1 个字符错                            | `a` 是"先 lo 后 hi"，`b` 是"先 hi 后 lo"     |
| 6    | **尾块判别只写"以 `2235` 开头"**       | `r=1` 的尾块被当成完整块，自检断言失败     | `r=1` 实际以 **`2233`** 开头，两种前缀都要判 |
| 7    | **跳过固定位自检**                     | 块边界错位却毫无察觉，一路算到底才发现全错 | 每个完整块先查 6 个固定位，1 秒钟的事        |
| 8    | **不做回验**                           | 自以为对了                                 | `encrypt(解出的明文) == 原密文`，逐位比对    |

---

## 十四、完整参考实现

保存为 `hexmaze.py`：

```python
# -*- coding: utf-8 -*-
"""
HexMaze 加解密完整实现（KCTF 第 7 题）

算法要点：
  1. 明文整体反转
  2. 反转后按 3 字符分块
  3. 每块 12 个十六进制位：高半字节 +5、低半字节 +4（模 16），并按固定置换重排
  4. 不足 3 字符的尾块用"摘要扰动"格式（形态只与长度 mod 3 有关）
"""

HI_OFF = 5   # 高半字节偏移
LO_OFF = 4   # 低半字节偏移

# ---------------- 完整块 ----------------

def _enc_block(s3):
    """3 个字符 -> 12 个十六进制字符"""
    c0, c1, c2 = (ord(c) for c in s3)
    d = [0] * 12
    d[0]  = (c0 & 0xF) + LO_OFF      # lo(c0)
    d[1]  = 4                        # 标记
    d[2]  = (c0 >> 4)  + HI_OFF      # hi(c0)
    d[3]  = (c2 >> 4)  + HI_OFF      # hi(c2)
    d[4]  = 4                        # 标记
    d[5]  = (c2 & 0xF) + LO_OFF      # lo(c2)
    d[6]  = 5                        # 标记
    d[7]  = 5                        # 标记
    d[8]  = (c1 & 0xF) + LO_OFF      # lo(c1)
    d[9]  = 4                        # 标记
    d[10] = (c1 >> 4)  + HI_OFF      # hi(c1)
    d[11] = 5                        # 标记
    return "".join("%X" % (x % 16) for x in d)

def _dec_block(blk):
    """12 个十六进制字符 -> 3 个字符"""
    d = [int(x, 16) for x in blk]
    # 固定位自检
    assert d[1] == d[4] == d[9] == 4,  "标记位 4 校验失败: " + blk
    assert d[6] == d[7] == d[11] == 5, "标记位 5 校验失败: " + blk
    c0 = (((d[2]  - HI_OFF) % 16) << 4) | ((d[0] - LO_OFF) % 16)
    c1 = (((d[10] - HI_OFF) % 16) << 4) | ((d[8] - LO_OFF) % 16)
    c2 = (((d[3]  - HI_OFF) % 16) << 4) | ((d[5] - LO_OFF) % 16)
    return chr(c0) + chr(c1) + chr(c2)

# ---------------- 尾块（摘要扰动） ----------------

def _enc_tail(rem):
    """剩余 1~2 个字符 -> 12 个十六进制字符"""
    h = lambda v: "%X" % (v % 16)
    if len(rem) == 1:
        c = ord(rem[0])
        return "22332235" + h((c & 0xF) + LO_OFF) + "4" + h((c >> 4) + HI_OFF) + "3"
    a, b = ord(rem[0]), ord(rem[1])
    return ("2235"
            + h((a & 0xF) + LO_OFF) + "4" + h((a >> 4) + HI_OFF)
            + h((b >> 4) + HI_OFF)  + "4" + h((b & 0xF) + LO_OFF)
            + "53")

def _dec_tail(blk):
    """12 个十六进制字符 -> 1~2 个字符"""
    d = [int(x, 16) for x in blk]
    if blk.startswith("22332235"):                 # 余 1
        return chr((((d[10] - HI_OFF) % 16) << 4) | ((d[8] - LO_OFF) % 16))
    if blk.startswith("2235"):                     # 余 2
        a = (((d[6] - HI_OFF) % 16) << 4) | ((d[4] - LO_OFF) % 16)
        b = (((d[7] - HI_OFF) % 16) << 4) | ((d[9] - LO_OFF) % 16)
        return chr(a) + chr(b)
    raise ValueError("无法识别的尾块: " + blk)

# ---------------- 对外接口 ----------------

def encrypt(s):
    r = s[::-1]                                    # Step 1 反转
    n = len(r) - len(r) % 3
    out = "".join(_enc_block(r[i:i+3]) for i in range(0, n, 3))
    if len(r) % 3:                                 # Step 4 摘要扰动
        out += _enc_tail(r[n:])
    return out

def _is_tail(blk):
    """尾块判据：余 1 -> 22332235 开头；余 2 -> 2235 开头。
    正常块 pos1 恒为 '4'，而两种前缀第 2 位都是 '2'，天然互斥，不会误判。"""
    return blk.startswith("22332235") or blk.startswith("2235")

def decrypt(c):
    assert len(c) % 12 == 0, "密文长度必须是 12 的倍数"
    blocks = [c[i:i+12] for i in range(0, len(c), 12)]
    tail = ""
    if blocks and _is_tail(blocks[-1]):
        tail = _dec_tail(blocks.pop())
    r = "".join(_dec_block(b) for b in blocks) + tail
    return r[::-1]                                 # Step 7 反转回来

# ---------------- 自测 ----------------

if __name__ == "__main__":
    FLAG_CT = ("14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C5"
               "34A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5"
               "B4BB405554B522332235A4B3")

samples = [
        ("TLU",   "94AA48550495"),
        ("Hello", "34BB405504B5223594B94C53"),
        ("2026",  "A48844556485223322356483"),
        ("abcd!", "547B475584B5223564BB4553"),
    ]
    for p, ct in samples:
        assert encrypt(p) == ct, p
        assert decrypt(ct) == p, p
        print("[OK] %-6s -> %s" % (p, ct))

flag = decrypt(FLAG_CT)
    print("\nFLAG =", flag)
    print("长度 =", len(flag))
    assert encrypt(flag) == FLAG_CT, "回验失败"
    print("回验通过：重新加密与题面密文逐位一致 ✅")
```

**运行输出：**

```
[OK] TLU    -> 94AA48550495
[OK] Hello  -> 34BB405504B5223594B94C53
[OK] 2026   -> A48844556485223322356483
[OK] abcd!  -> 547B475584B5223564BB4553

FLAG = flag{T1u_2026_Kc7f_Crypt0_M4ster!}
长度 = 34
回验通过：重新加密与题面密文逐位一致 ✅
```

> ⚠️ **实现踩坑**：尾块判据不能只写 `startswith("2235")`。
> **余 1 的尾块是 `2233` + `2235` 拼接，实际以 `2233` 开头**（例如 `2026` 的尾块 `223322356483`），只判 `2235` 会漏掉它，导致该块被当成正常块送进 `_dec_block`，触发标记位断言失败。
> 正确判据要同时覆盖 `22332235`（余 1）和 `2235`（余 2）两种前缀。
>
> 反过来问：正常块会不会被误判成尾块？不会 —— 正常块的 pos1 恒为 `4`，而两种尾块前缀的第 2 位都是 `2`，天然互斥。这个判据是安全的。

---

## 十五、关于"密钥 121"

题面给了"密钥: 121"，但**还原出的算法里没有任何一处用到它**。

判据很硬：上面的实现在**完全不引用 121** 的前提下，已经能把 4 组已知样本 + FLAG 全部双向精确复现（144 位逐位相同）。如果密钥真的参与了运算，必然存在至少一个无法用固定常量解释的位——但一个都没有。

几种可能：

1. **纯干扰项**，用来诱导选手去猜"密钥流 / XOR key"，浪费时间；
2. 仅作为**题面标签**存在，未进入变换过程；
3. 常量 `4` 和 `5` 或许与 `121` 存在某种硬编码派生关系（例如 `1+2+1=4`，`4+1=5`），但**仅凭现有数据无法验证**——因为只有一个密钥值的样本，任何"派生公式"都是不可证伪的。

处理这类信息的正确姿势：**先假设它无关，用数据说话；只有当模型出现无法用常量解释的残差时，才回头引入密钥变量。** 本题残差为零，所以密钥无关的结论是充分的。

---

## 十六、方法论总结

这道题的通用解题套路，可以复用到绝大多数"自制古典/位级密码"的已知明文分析：

### ① 先做"长度会计"

`len(密文) vs len(明文)` 的比值决定了膨胀率和分组边界。比值不整齐就一定有填充，反推填充规则往往能直接定出块大小。

### ② 用确定性做"片段比对"

题面明说"无随机数/无 IV" → 相同明文片段必产生相同密文片段。拿已知密文块去目标密文里搜，命中即同时确认**块长、块对齐、块间独立性**三件事。本题 `A48844556485` 在 FLAG 偏移 84 处命中，一击定三事。

### ③ 按列统计，先分离"常量位"和"数据位"

把所有块按位对齐成矩阵，逐列看取值集合。恒定列 = 结构性标记（送你免费的完整性校验）；变化列 = 载荷。

### ④ 利用明文空间的先验（本题最强的武器）

可打印 ASCII 的**高半字节只有 2..7 六种取值**。统计每列的取值宽度：

- 宽度 ≤ 6 → 高半字节列
- 散布全域 → 低半字节列

**这一步甚至不需要已知明文**，纯唯密文就能做。

### ⑤ 求偏移：列值集合的窗口位置直接给出常量

高位列窗口落在 `8..C`，明文值域 `2..7`，差 5 → 偏移就是 `+5`。不用爆破。

### ⑥ 遇到"部分样本对、部分错"，先怀疑**结构**，别急着加参数

- 加自由参数（"这是长度相关扰动"）是最诱人的陷阱；
- 找**同长度对照组**去证伪它（本题 `Hello` / `abcd!` 同为 5）；
- 用**鸽笼原理**做快速排除（FLAG 的 `pos0` 有 11 个不同值，装不进 6 个高半字节格子）；
- 结构错误的常见来源就三个：**顺序（正/逆）、对齐（偏移几位）、分组（块多大）**。本题是顺序。

### ⑦ 优先信任"字符差异大"的样本

`202`、`TLU` 这种高半字节重复的样本容易产生假阳性（顺序错了也能对上）。`Hello`、`abcd!` 信息量大，是真正的试金石。

### ⑧ 最后一定要回验

把还原的明文重新加密，逐位比对。**不回验的答案不算答案。**

---

**最终答案**

```
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

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

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

收藏・0

点赞・4

打赏