[原创] KCTF 2026 第五题：申时·忆海倒带 Writeup-CTF对抗-看雪安全社区

## 0x00. 结论

最终 Key：

```text
323C47184B0D3C44254B445842552F365C362C1144424B0D3C4416433B0DD6B12A0D3D95FA65B5E0ADE5E11B
```

该 Key 是 88 个十六进制字符，程序解析后得到 44 字节数据。
## 0x01. 样本信息

题面给的是 Windows 控制台程序，输入 Key 后出现 `verify success.` 即通过。

基础识别：

```bash
$ file cm/cm.exe
cm/cm.exe: PE32 executable (console) Intel 80386, for MS Windows

$ shasum -a 1 cm/cm.exe
d1c8124c5964af1531c6e311328854a05ca40bca  cm/cm.exe

$ rabin2 -I cm/cm.exe
arch     x86
baddr    0x400000
bintype  pe
bits     32
lang     msvc
dbg_file E:\kanxue\KCTF\2026\rsa_tf-20260802\Release\ca_tf6.pdb
```

工具主要用：

- `rabin2`：看 PE 基本信息、字符串、导入表。
- `ida`：做交叉引用和反汇编。
- `python3`：复刻校验逻辑、反解 Key。

## 0x02. 定位主逻辑

先扫字符串：
 ![](upload/attach/202608/987777_6TNG3B2RVGAGKN2.webp)
`admin123`、`password` 这类字符串是诱饵。直接查“成功”字符串(`verify success.`)的引用：
 ![](upload/attach/202608/987777_K77K6G9UD4BS7SA.webp)
输入点也在 `main`，所以从 `main` 反汇编往下看即可。
## 0x03. 输入格式和前置校验

`main` 里先用 `gets_s` 读入字符串，然后调用 `fcn.00402100`：
 ![](upload/attach/202608/987777_UPFA9CJ7VAFKJ3V.webp)

```
0x00403f75  lea eax, [var_858h]
0x00403f7b  push 0x3e8
0x00403f80  push eax
0x00403f81  call gets_s

0x00404031  lea eax, [var_8cch]     ; 输入字符串
0x00404037  lea ecx, [var_89ch]     ; 解析后的大整数
0x0040403d  push 0x10
0x0040403f  push eax
0x00404040  call fcn.00402100
```

`fcn.00402100` 的作用是按 16 进制解析字符串：循环处理每个字符，每次先把当前值乘以 `0x10`，再加当前 nibble。

后面有长度检查：

```
0x00404055  mov eax, dword [var_89ch]
0x0040405d  lea edx, [eax*8]
...
0x00404092  cmp edx, 0x58
0x00404095  jne fail
```

`var_89ch` 是 32-bit limb 数量，`var_89ch * 8 == 0x58`，即输入解析后为 11 个 DWORD，也就是 44 字节。因此原始 Key 长度应为：

```text
44 bytes * 2 hex chars = 88 hex chars
```

随后程序把这 11 个 DWORD 按大端字节序展开成 44 字节数组 `B`。关键逻辑在 `0x4040c0` 附近：

```
0x004040c0  push edi
0x004040c7  call fcn.00402a70
0x004040d2  movzx ecx, byte [eax + 3]
0x004040d6  mov byte [B + i], cl
0x004040dd  movzx ecx, byte [eax + 2]
0x004040e8  movzx ecx, byte [eax + 1]
0x004040ec  mov al, byte [eax]
```

也就是从高 limb 到低 limb，每个 DWORD 按 `[b3, b2, b1, b0]` 输出。

## 0x04. 两个前置约束
44 字节数组 `B` 先过两个约束。

第一个是 XOR：

```
0x004041bc  cmp al, 0x8f
0x004041be  jne fail
```

约束为：

```python
reduce(xor, B) == 0x8f
```

第二个是滚动 checksum：

```
0x00404218  mov edx, sum
0x00404226  and ecx, 0x7f
0x00404229  inc ecx
0x0040422a  movzx eax, byte [ptr]
0x0040422d  imul ecx, eax
0x00404230  add edx, ecx
...
0x0040425f  mov eax, 0xbeff
0x00404264  cmp word [sum], ax
```

约束为：

```python
sumv = 0
for b in B:
    sumv += ((sumv & 0x7f) + 1) * b

(sumv & 0xffff) == 0xbeff
```

## 0x05. 最终比较不是直接比较输入

继续往下看，程序并不是直接把 `B` 和目标字符串比较。

先调用：

```
0x00404271  lea edx, [var_820h]
0x00404277  lea ecx, [var_92ch]
0x0040427d  call fcn.00403500
```

`var_858h` 是原始输入字符串缓冲区，`var_820h = var_858h + 0x38`。也就是说 `fcn.00403500` 读取的是输入字符串从偏移 `0x38` 开始的部分，即最后 32 个 hex 字符。

这 32 个 hex 字符对应 `B` 的最后 16 字节。

`fcn.00403500` 内部做了一次 RSA 风格的模幂：

```text
C = pow(M, e, N)
```

其中：

- `M`：Key 最后 16 字节解析出的整数。
- `e`：`0x10001`。
- `N`：128-bit 模数。
- `C`：模幂结果，再转回字节，覆盖 `B[28:44]`。

覆盖位置由 `0x40437f` 到 `0x4043d0` 的拷贝逻辑确认，目标地址等价于：

```text
B + 0x1c
```

所以最终比较用的数组是：

```text
B[0:28] + pow(B[28:44], e, N).to_bytes(16, "big")
```

## 0x06. 替换表反推前 28 字节和 RSA 密文

最终比较前，还有一层查表：

```
0x004044f8  mov esi, i
0x00404504  movsx eax, byte [B + i]
0x0040450c  dec eax
0x0040450e  call fcn.00404870
0x00404513  mov al, byte [eax]
0x00404515  mov byte [mapped + i], al

0x00404550  mov eax, 0x416380 ; "Welcome to KCTF2026! Come and give it a try."
0x00404555  cmp mapped, target
```

`fcn.00404870` 是容器索引函数。对应到数据上，查表关系可以写成：

```python
mapped_byte = byte_at(0x4263b0 + dword_at(0x4163b0 + (B[i] - 1) * 4))
```

对目标串 `"Welcome to KCTF2026! Come and give it a try."` 做反向查表，可以得到最终比较前需要的 44 字节：

```text
323C47184B0D3C44254B445842552F365C362C1144424B0D3C441643
0F4439374E3C44372544164425151D1B
```

注意分成两段看：

- 前 28 字节是真正的 `B[0:28]`。
- 后 16 字节是 RSA 后的 `C`，不是 Key 原始尾部。

因此已知：

```text
B[0:28] = 323C47184B0D3C44254B445842552F365C362C1144424B0D3C441643
C       = 0F4439374E3C44372544164425151D1B
```

## 0x07. 提取 RSA 参数

`fcn.00403500` 里手工构造了两个大整数容器。数据不是顺序摆放，而是 `data[perm[i]]`。

模数容器：

```text
data = 0x436018
perm = 0x42e018
len  = 4
```

取出 4 个 32-bit limb：

```text
0x5dd67371, 0xd6519c94, 0xec693f3e, 0x8c91cb79
```

小端 limb 合成整数：

```text
N = 0x8c91cb79ec693f3ed6519c945dd67371
```

指数容器：

```text
data = 0x430018
perm = 0x434018
len  = 1
```

得到：

```text
e = 0x10001
```

分解 `N` 得到两个 64-bit 素数：

```text
p = 0xbe28ef96c8318203
q = 0xbd3d59fac7cc547b
```

这里我用的是本地 Python 写的 ECM/Pollard 组合脚本。这个模数只有 128 bit，分解成本很低。

计算私钥指数：

```python
phi = (p - 1) * (q - 1)
d = pow(e, -1, phi)
```

得到：

```text
d = 0x721a022d849de5cc5ad9bbb701f9fb65
```

解 RSA：

```python
C = 0x0F4439374E3C44372544164425151D1B
M = pow(C, d, N)
```

得到 Key 的最后 16 字节：

```text
M = 3B0DD6B12A0D3D95FA65B5E0ADE5E11B
```

## 0x08. 拼出 Key 并验证

拼接：

```text
B[0:28] = 323C47184B0D3C44254B445842552F365C362C1144424B0D3C441643
B[28:]  = 3B0DD6B12A0D3D95FA65B5E0ADE5E11B
```

最终 Key：

```text
323C47184B0D3C44254B445842552F365C362C1144424B0D3C4416433B0DD6B12A0D3D95FA65B5E0ADE5E11B
```

等价静态验证结果：

```text
len(B) = 44
xor(B) = 0x8f
checksum(B) & 0xffff = 0xbeff
pow(B[28:44], 0x10001, N) = 0F4439374E3C44372544164425151D1B
mapped result = Welcome to KCTF2026! Come and give it a try.
```

check答案：
 ![](upload/attach/202608/987777_P2GQDFGFCBAJP4T.webp)

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

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