[原创]第九题「丑寅同墟·星海抉择」解析-CTF对抗-看雪安全社区

[原创]第九题「丑寅同墟·星海抉择」解析

发表于: 2026-8-25 10:39 372

[原创]第九题「丑寅同墟·星海抉择」解析

教教我吧~

2026-8-25 10:39

372

| 项目       | 内容                                               |
| ---------- | -------------------------------------------------- |
| 比赛       | 看雪·2026 KCTF                                     |
| 题目       | 第九题：丑寅同墟·星海抉择                          |
| 题面模型名 | `ICTFForCausalLM`                                  |
| 类型       | Reverse / 模型权重逆向                             |
| 目标       | 找出使模型输出 `<success>` 的 16 字符输入，即 flag |
| Flag       | `f1ag2026c7fa1666`                                 |

本文只使用官方附件中的相对文件名，不涉及本机绝对路径、用户名或其他环境信息。

---

## 一、题面

附件给出一个字符级「语言模型」`ICTFForCausalLM` 及其权重。

- 输入：长度不超过 16 的字符串
- 输出：一个字符（实际是词表里的一个 token）
- 任务：分析代码与权重，找出藏在模型里的秘密，恢复 flag

配套文件：

| 文件                           | 作用               |
| ------------------------------ | ------------------ |
| `题目要求.txt`                 | 题面说明           |
| `model_def.py`                 | 分词器与模型定义   |
| `inference.py`                 | 加载权重并交互推理 |
| `ictf_model/config.json`       | 超参数             |
| `ictf_model/model.safetensors` | 权重               |

---

## 二、先看代码，不要被「Causal LM」带偏

`config.json`：

```json
{
  "architectures": ["ICTFForCausalLM"],
  "hidden_size": 21,
  "max_position_embeddings": 16,
  "model_type": "ictf_causal_lm",
  "vocab_size": 64
}
```

参数量极小：`16 → 21 → 64`，总共一千多个参数。真正的前向在 `model_def.py` 里只有几行：

```python
def forward(self, input_ids, **kwargs):
    x = input_ids.float()
    hidden_states = self.dense(x)      # Linear(16, 21)
    hidden_states = self.act(hidden_states)  # ReLU
    logits = self.lm_head(hidden_states)     # Linear(21, 64)
    logits = logits.unsqueeze(1)
    return {"logits": logits}
```

三个反常点：

1. **没有 embedding。** token id 被直接 `.float()` 当成数值特征，id 的大小本身参与运算。
2. **不是逐位置预测。** 16 维向量一次过完两层全连接，输出一个 64 维 logit。
3. **词表末尾有两个特殊 token。** 分词器把 id 62、63 标成 `<success>` / `<fail>`。

分词器字符集：

```text
0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
```

共 62 个字符，id 为 `0..61`。输入不足 16 时用 `pad_token_id = 0` 右填充——而 id 0 恰好是字符 `'0'`。因此「短字符串」和「后面带 0 的 16 字符」在数值上无法区分。后文求解时按满 16 维整数向量处理即可。

`inference.py` 取 `argmax`，打印对应字符。本题要的是让 argmax 落到 id 62。

---

## 三、把权重摊开

用 `safetensors`（或不装任何深度学习库，按文件头解析）读出四个张量：

| 张量             | 形状       | 含义               |
| ---------------- | ---------- | ------------------ |
| `dense.weight`   | `(21, 16)` | 第一层权重 \(W_d\) |
| `dense.bias`     | `(21,)`    | 第一层偏置 \(b_d\) |
| `lm_head.weight` | `(64, 21)` | 输出层权重 \(W_l\) |
| `lm_head.bias`   | `(64,)`    | 输出层偏置 \(b_l\) |

记输入 \(x \in \{0,\dots,61\}^{16}\)，前向为：

```text
h      = ReLU(W_d x + b_d)     # 21 维，分量均 ≥ 0
logits = W_l h + b_l           # 64 维
pred   = argmax(logits)
```

### 3.1 输出层几乎是死的

`lm_head` 一眼露馅：

| 输出 id | 权重（21 维）                 | bias            | 含义        |
| ------- | ----------------------------- | --------------- | ----------- |
| 0 – 61  | 全 0                          | `-10000`        | 普通字符    |
| **62**  | `[1, -1e10, -1e10, …, -1e10]` | `-376131.21875` | `<success>` |
| 63      | 全 0                          | `0.4`           | `<fail>`    |

普通字符和 `<fail>` 的 logit **不随输入变化**：恒为 `-10000` 和 `0.4`。唯一会动的是第 62 行：

```text
logit[62] = h[0] - 1e10 * (h[1] + h[2] + … + h[20]) - 376131.21875
logit[63] = 0.4
```

`<success>` 要胜过 `<fail>`，必须：

```text
logit[62] > 0.4
```

### 3.2 ReLU 把条件逼死

`h[j] ≥ 0`。`h[1]…h[20]` 前面挂着 `-1e10`：任何一个约束单元哪怕只激活一个很小的正数，`logit[62]` 都会掉到 `-1e10` 量级，不可能超过 `0.4`。

因此成功条件拆成两条：

**条件 A（可行性）** —— 第 1 到第 20 个隐藏单元必须被 ReLU 压成 0：

```text
W_d[j] · x + b_d[j]  ≤  0      (j = 1, 2, …, 20)
```

**条件 B（阈值）** —— 第 0 个单元必须够大。此时 `h[0] = W_d[0] · x + b_d[0]`（该值本身为正），代入：

```text
W_d[0] · x + 311558.71875 - 376131.21875  >  0.4
W_d[0] · x  >  64572.9
```

`W_d[0]` 与 \(x\) 都是整数，点积必为整数，故：

```text
W_d[0] · x  ≥  64573
```

整道题变成：**在 \(x_i \in \{0,\dots,61\}\) 上解 20 条线性不等式，并让一条整数线性函数达到 64573。**

---

## 四、第一层权重：口令反算出来的方程组

`dense.weight` 全部是整数。第 0 行数量级是几千（目标函数），其余 20 行落在 \(\pm 100\)（约束）。`dense.bias[1:]` 也全部是整数。

这是典型的出题构造：

1. 先选定 16 个字符的口令 \(x^\star\)
2. 随机（或指定）约束矩阵 \(A = W_d[1:21]\)
3. 令 \(b_d[j] = -A[j] \cdot x^\star\)，使正确口令上 **20 条约束全部取等**
4. 再把第 0 行和两个「难看」的 bias 配到刚好压过 `0.4`

因此可以先把条件 A **当成等式** 来解：

```text
A x  =  -b_d[1:]
```

`A` 是 \(20 \times 16\)、秩 16 的超定系统。最小二乘残差约为 \(0\)（数值上 \(10^{-12}\) 量级），说明方程组相容，存在唯一实数解。把解四舍五入：

```text
x = [15, 1, 10, 16, 2, 0, 2, 6, 12, 7, 15, 10, 1, 6, 6, 6]
```

全部落在 `0..61`。按字符集映射：

```text
id   15  1  10  16  2  0  2  6  12  7  15  10  1  6  6  6
char  f   1   a   g  2  0  2  6   c  7   f   a  1  6  6  6
```

得到候选口令：

```text
f1ag2026c7fa1666
```

代回检查：

| 量                    | 数值                    |
| --------------------- | ----------------------- |
| 20 条约束 \(A x + b\) | **精确为 0**            |
| \(W_d[0] \cdot x\)    | `64573`（刚好达到下界） |
| \(h[0]\)              | `376131.71875`          |
| `logit[62]`           | `0.5`                   |
| `logit[63]`           | `0.4`                   |
| argmax                | **62 `<success>`**      |

余量只有 `0.1`。这不是训练出来的边界，是手工把 `dense.bias[0] = 311558.71875` 和 `lm_head.bias[62] = -376131.21875` 配出来的。

---

## 五、唯一性

条件 A 写的是 `≤ 0` 而不是 `= 0`，所以只凭等式求解，逻辑上还不能说「多面体里没有别的整点」。需要把条件 B 一起加上。

在整数格 \(x_i \in \{0,\dots,61\}\) 上，对

```text
A x + b_d[1:]  ≤  0
W_d[0] · x     ≥  64573
```

做约束求解（任意整数线性求解器即可，例如 Z3）。搜索结果表明：**满足两条条件的整点只有上面这一组。**

直观原因：

- 等式子系统秩 16，正确口令是可行域的一个顶点
- 目标函数系数全是整数且 \(\gcd=1\)，目标值只能取整数
- 正确口令上目标值恰好等于门槛 64573，再挪一格要么违反某条约束，要么目标掉到门槛以下

改一个字符的对照：

| 输入                                 | 输出        | 原因                                 |
| ------------------------------------ | ----------- | ------------------------------------ |
| `f1ag2026c7fa1666`                   | `<success>` | 约束全 0，`logit[62]=0.5`            |
| `f1ag2026c7fa1665`                   | `<fail>`    | 多个约束单元被激活，`-1e10` 打穿     |
| `f1ag2026c7fa1667`                   | `<fail>`    | 约束被激活，且 \(h[0]\) 也掉到门槛下 |
| `hello`（右填成 `hello00000000000`） | `<fail>`    | 多条约束被激活                       |

---

## 六、完整权重（便于核对）

`dense.weight` 第 0 行与 bias：

```text
W_d[0] = [3012, 1679, 78, -1143, 1231, 5574, 2091, 1452,
          -3472, 1990, 17, 1987, 109, 3758, 1295, -492]
b_d[0] = 311558.71875
```

约束行 \(j=1..20\)（整数）：

```text
 j |                         W_d[j]                          |  b_d[j]
---+---------------------------------------------------------+--------
 1 |  61  23 -13  90  58   0  47  62  -6 -89  67  41  13  64  -8 -71 | -3473
 2 | -58 -33 -90 -58  44-100  54  -7 100   9  43  -9  81  -3   2 -52 |   996
 3 | -37 -58  19   6 -92  76 -37  56 -20  29 -93 -27  80 -55 -17 -28 |  2471
 4 | -51  96 -81  12   9  31  21 -91  -6 -90  22 -15 -58  83 -37 -24 |  2221
 5 |  91  37  18 -14 -32  84  86 -70  48  77   3  44  65 100 -21  18 | -3293
 6 | -47  49 100 -72  10  42  42  67   9 -23  61  35  53  35 -35 -14 |  -879
 7 |  40 -85   4 -12  51  52 -36  -9 -95  68 -95  55 -70 100  22  39 |   304
 8 |  63  48  25 -69  69  87   5  65  14  52 -50  80 -45 -24  58 100 | -2018
 9 |  38  75 -33 -45  74 100 -50  99 -93 -42 -23 -52  45  14 -19 -57 |  2365
10 | -94  84 -38 -15 -57  84  70  50   2 -39 -17 -79   1   1  -8 -95 |  3525
11 | -68 -50  24 -89 -36   0  19  22  -1  86  89 -43 -35 -15  60 -74 |   870
12 | -73  18  93  92  12  -4 -28   8 -53  56  34  70  42  36 -99 -92 | -1419
13 | -92  -2  43  91  70 -16 -18  51 -87 -73 -28  45  63   1 -32  59 |   380
14 |  68 -35 -70  13  -5  89 -41 -35 -98  65 -82  68-100  54  -4 -18 |   988
15 |  79  77 -14 -31  11  20  71 -71 -98   6  20  29 -18  94  95  78 | -1404
16 |  39 -57  61 -73 -56  49  32  12  10  59 -58  31  52 -44  41   5 |   -31
17 |  91 -40  -9  18  20 -85 -68  26 -82 -24 -91  60  58  92 -74 -91 |   714
18 |  97 -12 -20 -64  45  44  79  59  96  80  58 -61  69 -40  55 -27 | -2790
19 | -78 -79  19  12 -13  87 -46  -5 -62  16  49 -25  69  92 -76  54 |   673
20 |  68  74 -54  30 -91  86  61  85 -20 -29  75-100 -41 -91  82  -4 | -1047
```

在 \(x^\star\) 上，上表每一行的点积都等于 \(-b_d[j]\)。

---

## 七、复现

### 7.1 不依赖 torch 的求解脚本

只需 `numpy`。`safetensors` 文件是「8 字节头长度 + JSON + 裸 float32」，也可以只用标准库解析。

```python
import json, struct
import numpy as np

def load_safetensors(path):
    with open(path, "rb") as f:
        n = struct.unpack("<Q", f.read(8))[0]
        hdr = json.loads(f.read(n))
        blob = f.read()
    out = {}
    for k, v in hdr.items():
        if k == "__metadata__":
            continue
        s, e = v["data_offsets"]
        out[k] = np.frombuffer(blob[s:e], dtype=np.float32).reshape(v["shape"])
    return out

W = load_safetensors("ictf_model/model.safetensors")
Wd, bd = W["dense.weight"], W["dense.bias"]
A, b = Wd[1:], bd[1:]

x = np.round(np.linalg.lstsq(A, -b, rcond=None)[0]).astype(int)
assert np.allclose(A @ x + b, 0)
assert Wd[0] @ x >= 64573

charset = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
flag = "".join(charset[i] for i in x)
print(flag)
```

运行后打印：

```text
f1ag2026c7fa1666
```

### 7.2 用官方推理脚本验证

在附件目录下（已按题目依赖安装 `torch` / `transformers`）：

```text
python inference.py
```

提示 `Enter your prompt:` 时输入 `f1ag2026c7fa1666`，应输出：

```text
<success>
```

等价的纯 numpy 前向（用于核对，不改官方脚本）：

```python
x = np.array([15, 1, 10, 16, 2, 0, 2, 6, 12, 7, 15, 10, 1, 6, 6, 6], dtype=np.float64)
h = np.maximum(0.0, Wd.astype(np.float64) @ x + bd.astype(np.float64))
logits = W["lm_head.weight"].astype(np.float64) @ h + W["lm_head.bias"].astype(np.float64)
assert int(np.argmax(logits)) == 62
```

---

## 八、小结

本题不是语言模型，而是一台硬编码的整数约束检查器：

1. `lm_head` 把 64 类输出砍成「恒失败 / 条件成功」两档
2. `-1e10` 强迫 20 个 ReLU 全部为 0，得到线性可行域
3. 两个非整数 bias 把成功门槛卡在唯一整点上
4. 对该超定系统做最小二乘（或任意整数求解器）即还原口令

```text
flag: f1ag2026c7fa1666
```

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

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

收藏・0

点赞・5

打赏