[原创]KCTF 2026 - 第九题：丑寅同墟·星海抉择分析-CTF对抗-看雪安全社区

## 题目概述

附件提供了一个字符级语言模型 `ICTFForCausalLM` 及其权重。模型接受长度不超过 16 个字符的字符串，预测一个输出字符。目标是从模型代码与权重中恢复隐藏的 flag。

## 模型结构

`model_def.py` 中模型结构如下：

```
dense : Linear(16 -> 21) + bias
act   : ReLU
lm_head: Linear(21 -> 64) + bias
```

输入 `x` 是长度为 16 的 one-hot 编码字符 id 向量（每个位置取 0~62 的字符 id，不足 16 位补 0）。输出 64 类 logits，其中：
- id 62 = `<success>`
- id 63 = `<fail>`

```python
class ICTFForCausalLM(PreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        self.dense = nn.Linear(config.max_position_embeddings, config.hidden_size, bias=True)
        self.act = nn.ReLU()
        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=True)
```

## 权重分析

加载权重后各张量形状为：

```
dense.weight   (21, 16)
dense.bias     (21,)
lm_head.weight (64, 21)
lm_head.bias   (64,)
```

关键观察在 `lm_head`：

- 除 id 62 外，`lm_head.weight` 全部为 0。
- id 62 (`<success>`) 的权重为 `[1.0, -1e10, -1e10, ..., -1e10]`，bias = `-376131.2`。
- id 63 (`<fail>`) 的权重全 0，bias = `0.4`。
- 其余类 bias = `-10000`。

因此对任意输入，其他类的 logit 恒为 `-10000`，几乎不可能胜出。最终结果只在 `<success>` 与 `<fail>` 之间竞争。

令隐藏层输出为 `h = ReLU(W·x + b)`，h 维度 21：

```
logit_success = h[0] - 1e10 * (h[1] + h[2] + ... + h[20]) - 376131.2
logit_fail    = 0.4
```

要让模型输出 `<success>`：

1. 由于 `-1e10` 惩罚极大，必须满足 `h[1..20] = 0`（否则 logit 趋于负无穷）。因为权重与字符 id 均为整数，pre-activation 为整数，ReLU 后的最小正值为 1，`1e10 * 1` 远大于任何可抵消量，所以必须严格为 0。
2. 同时需要 `h[0] - 376131.2 > 0.4`，即 `h[0] >= 376132`。

由 `h[0] = ReLU(W0·x + 311560)`（`dense.bias[0] = 311560`）得条件：

```
W0·x >= 64572        (神经元 0 需要足够大)
Wj·x + bj <= 0  (j = 1..20)   (其余神经元必须为 0)
```

## 求解 flag

把字符 id 当作 16 个整数变量 `x[0..15] ∈ [0, 62]`，上述条件全部是线性不等式，用整数线性规划（scipy `milp`）求解：

```python
import torch
import numpy as np
from scipy.optimize import milp, LinearConstraint, Bounds
from model_def import ICTFForCausalLM

model = ICTFForCausalLM.from_pretrained('./ictf_model')
W = model.dense.weight.detach().numpy()
b = model.dense.bias.detach().numpy()
W0, b0 = W[0], b[0]
Wrest, brest = W[1:], b[1:]

# 目标：使 W0.x 达到阈值 64572
c = -W0
A = Wrest
lc = LinearConstraint(A, -np.inf*np.ones(20), -brest)
res = milp(c, constraints=lc, bounds=Bounds(0, 62), integrality=np.ones(16))

x = np.round(res.x).astype(int)
print("x =", x)
print("W0.x =", W0 @ x)          # 64573
print("rest preact =", Wrest @ x + brest)  # 全部为 0
```

结果：

```
x = [15  1 10 16  2  0  2  6 12  7 15 10  1  6  6  6]
W0.x = 64573.0
rest preact = [0 ... 0]
```

将字符 id 映射回字符集 `"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"`：

```
15=f  1=1  10=a  16=g  2=2  0=0  2=2  6=6  12=c  7=7  15=f  10=a  1=1  6=6  6=6  6=6
```

得到 16 字符字符串：

```
f1ag2026c7fa1666
```

## 验证

```python
import torch
from model_def import ICTFForCausalLM, ICTFTokenizer

model = ICTFForCausalLM.from_pretrained('./ictf_model')
tok = ICTFTokenizer()

flag = 'f1ag2026c7fa1666'
t = tok.encode(flag, return_tensors='pt')
with torch.no_grad():
    lg = model(t)['logits'][0, -1]
    print(tok.id2char[int(torch.argmax(lg))])   # <success>
```

输出：

```
<success>
```

模型确认该输入预测为 `<success>`，即为正确答案。

## 注

由 AI 完成。

附件提供了一个字符级语言模型 ICTFForCausalLM 及其权重。模型接受长度不超过 16 个字符的字符串，预测一个输出字符。目标是从模型代码与权重中恢复隐藏的 flag。

model_def.py 中模型结构如下：

输入 x 是长度为 16 的 one-hot 编码字符 id 向量（每个位置取 0~62 的字符 id，不足 16 位补 0）。输出 64 类 logits，其中：

加载权重后各张量形状为：

关键观察在 lm_head：

因此对任意输入，其他类的 logit 恒为 -10000，几乎不可能胜出。最终结果只在 <success> 与 <fail> 之间竞争。

令隐藏层输出为 h = ReLU(W·x + b)，h 维度 21：

要让模型输出 <success>：

由 h[0] = ReLU(W0·x + 311560)（dense.bias[0] = 311560）得条件：

把字符 id 当作 16 个整数变量 x[0..15] ∈ [0, 62]，上述条件全部是线性不等式，用整数线性规划（scipy milp）求解：

结果：

将字符 id 映射回字符集 "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"：

得到 16 字符字符串：

输出：

模型确认该输入预测为 <success>，即为正确答案。

由 AI 完成。

dense : Linear(16 -> 21) + bias
act   : ReLU
lm_head: Linear(21 -> 64) + bias

class ICTFForCausalLM(PreTrainedModel):
    def __init__(self, config):
        super().__init__(config)
        self.dense = nn.Linear(config.max_position_embeddings, config.hidden_size, bias=True)
        self.act = nn.ReLU()
        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=True)

dense.weight   (21, 16)
dense.bias     (21,)
lm_head.weight (64, 21)
lm_head.bias   (64,)

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

[招生]科锐逆向工程师培训(2026年11月13日实地，远程教学同时开班, 第57期)

[原创]KCTF 2026 - 第九题：丑寅同墟·星海抉择 分析

[原创]KCTF 2026 - 第九题：丑寅同墟·星海抉择分析