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

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

发表于: 2026-8-20 14:56 24

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

星野安全

2026-8-20 14:56

## Summary

题目只给四组明密文样例和"密钥 121"，要求还原加密流程并解出 FLAG。密文是一套
**逐字符 nibble 加常数 + 定长块模板**的编码：低 nibble `+4`、高 nibble `+5`，
三个字符按"低位在前 / 高位在前 / 低位在前"的之字形（即密钥 `1-2-1`）写进 12 个 hex 的块模板。
真正的坑在于**整条明文在分块前先被整体逆序**。

## Solution

### Step 1：定长分块与"常量位"

先看长度：`TLU`(3) → 12 hex，`Hello`(5) / `abcd!`(5) / `2026`(4) 全都 → 24 hex。
唯一自洽的读法是 **12 hex 一块、每块吃 3 个字符**，明文补齐到 3 的倍数。
FLAG 共 144 hex = 12 块 = 34 个字符 + 2 个 padding。

把不含 padding 的块（4 个样例首块 + FLAG 前 11 块，共 15 个）按 nibble 位对齐，
发现 **索引 1/4/9 恒为 `4`、索引 6/7/11 恒为 `5`**，15/15 无例外：

```
idx :  0    1    2    3    4    5    6    7    8    9   10   11
      d0   '4'  d1   d2   '4'  d3   '5'  '5'  d4   '4'  d5   '5'
```

剩下 6 个数据 nibble = 24 bit，正好和 3 个字节等宽。另外
`FLAG[blk7] == 2026[blk0]` 逐字节相同，说明**块之间完全独立**，没有链式或块计数器。

### Step 2：用值域基数拆出高/低 nibble

这一步是突破口。统计 15 个块里每个数据位取到多少种不同值：

| 位 | idx2 | idx3 | idx10 | idx0 | idx5 | idx8 |
|---|---|---|---|---|---|---|
| 不同值个数 | 5 | 5 | 6 | 11 | 9 | 8 |
| 取值范围 | `7..C` | `7..C` | `7..C` | 全域 | 全域 | 全域 |

可打印 ASCII 的高 nibble 只有 `2..7`（6 种），低 nibble 有 16 种。
所以 **idx2/3/10 一定各是某个高 nibble 的函数，idx0/5/8 是低 nibble 的函数**——
而且 `2..7` 恰好平移 5 就是 `7..C`，直接给出 `HI(x) = (x>>4) + 5`。

回头看那六个"常量"：`4 = 0 + 4`、`5 = 0 + 5`，正是 **`LO(0)` 和 `HI(0)`——
padding 字节 `0x00` 自己的编码**。它们从来不是分隔符。于是低 nibble 的规则也定了：
`LO(x) = (x & 0xF) + 4`。

### Step 3：明文整体逆序，与密钥 121 的作用

按上面直接套样例会处处矛盾：`Hello` 首块若当成 `"Hel"`，同一个高 nibble `6`
会同时要求映射到两个不同值。改为**整条明文先逆序**后全部自洽——
`Hello` 首块实际是 `"oll"`，`2026` 首块是 `"620"`。

**密钥 121 = 块内三个字符 cell 的朝向模式**，即迷宫的之字形回折：

| 数字 | cell | 朝向 |
|---|---|---|
| **1** | 第 1 个 | 低位在前 `LO '4' HI` |
| **2** | 第 2 个 | 高位在前 `HI '4' LO`（迷宫"转身"） |
| **1** | 第 3 个 | 低位在前 `LO '4' HI` |

因此三元组 `(a,b,c)` 在块中的发射顺序是 **a、c、b**：`2` 这一步跨过中间字符，
走回头路才把它补上。两个加法常数同样出自密钥——低 nibble 用 `1+2+1 = 4`，高 nibble 用 `4+1 = 5`。

块尾 nibble `5` 表示整块，`3` 表示该块含 padding；`2233` / `2235` 分别是
2 个和 1 个 padding 的固定前缀。完整求解：

```python
#!/usr/bin/env python3
"""看雪 2026 KCTF 第七题 HexMaze —— 从题目数据直接算出 flag"""

FLAG_HEX = ("14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A8"
            "4B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB4055"
            "54B522332235A4B3")

SAMPLES = {
    "TLU":   "94AA48550495",
    "Hello": "34BB405504B5223594B94C53",
    "2026":  "A48844556485223322356483",
    "abcd!": "547B475584B5223564BB4553",
}

H = "0123456789ABCDEF"
LO = lambda x: ((x & 0x0F) + 4) % 16              # 低 nibble +4  (1+2+1)
HI = lambda x: ((x >> 4)   + 5) % 16              # 高 nibble +5  (1+2+1+1)
cell     = lambda x: H[LO(x)] + "4" + H[HI(x)]    # 朝向 1：低位在前
cell_rev = lambda x: H[HI(x)] + "4" + H[LO(x)]    # 朝向 2：高位在前

def encrypt(msg):
    R = msg[::-1]                                 # ① 整条明文先逆序
    out = []
    for i in range(0, len(R), 3):                 # ② 每 3 字符一块
        g = [ord(c) for c in R[i:i + 3]]
        if len(g) == 3:                           # ③ 朝向 1-2-1，发射顺序 a, c, b
            a, b, c = g
            out.append(cell(a) + cell_rev(c) + "55" + cell(b) + "5")
        elif len(g) == 2:                         # 末块含 1 个 padding
            x, y = g
            out.append("2235" + cell(x) + cell_rev(y) + "53")
        else:                                     # 末块含 2 个 padding
            out.append("2233" + "2235" + cell(g[0]) + "3")
    return "".join(out)

def decrypt(hx):
    msg = []
    for b in range(0, len(hx), 12):
        n = [int(c, 16) for c in hx[b:b + 12]]
        ch = lambda hi, lo: chr((((n[hi] - 5) % 16) << 4) | ((n[lo] - 4) % 16))
        if   hx[b:b + 4] == "2233": msg.append(ch(10, 8))
        elif hx[b:b + 4] == "2235": msg.append(ch(6, 4) + ch(7, 9))
        else:                       msg.append(ch(2, 0) + ch(10, 8) + ch(3, 5))
    return "".join(msg)[::-1]                     # 还原逆序

for p, c in SAMPLES.items():                      # 四个样例逐字符校验
    assert encrypt(p) == c, p
    assert decrypt(c) == p, p

flag = decrypt(FLAG_HEX)
assert encrypt(flag) == FLAG_HEX                  # 重加密自洽
print(flag)
```

运行输出：

```
$ python solve.py
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

逆序串为 `}!rets4M_0tpyrC_f7cK_6202_u1T{galf`，翻转即得 FLAG（`Kc7f` 是 `KCTF` 的 leet 写法）。

## 验证

- 四个样例双向校验：`encrypt` 逐字符重现题目密文（含 padding 块），`decrypt` 还原原文
- FLAG 解出后重新加密，与题目给出的 144 个 hex **完全一致**
- `x -> (LO(x), HI(x))` 在全部 256 个字节上单射，解密结果唯一
- 明文长度被强制为 34：末块前缀是 `2233` 且 idx1 为 `2`，只能是 2-padding 模板
- 2400 组随机明文（长度 1~40，覆盖整块 / 1 padding / 2 padding 三种块尾）往返 fuzz，零失败

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

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

最后于 2026-8-20 15:06 被星野安全编辑，原因：

上传的附件：