[原创] 看雪·2026 KCTF 第七题：戌时·暗能潜流-CTF对抗-看雪安全社区

[原创] 看雪·2026 KCTF 第七题：戌时·暗能潜流

发表于: 2026-8-21 11:04 1265

[原创] 看雪·2026 KCTF 第七题：戌时·暗能潜流

mb_mgodlfyn 活跃值

2026-8-21 11:04

1265

一道完完全全出给AI的题，不会真的有人自己脑洞出来吧（）初版题目给的条件甚至太模糊，出题人后续更新了题目说明。

5.6 Sol 还是比 5.5 强太多了，但甲也太厚了，前几天甚至打个hello都会触发外置审查；在夹缝中摇奖偶然摇出一个能跑的对话，题目丢上去10分钟速出结果
<a href="elink@aecK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0K9r3q4@1k6%4m8@1i4K6u0W2j5$3!0E0i4K6u0r3M7$3S2S2M7X3g2Q4x3V1j5$3j5e0R3%4j5U0M7^5x3q4)9J5k6o6u0T1y4K6S2Q4x3X3b7^5x3$3g2S2i4K6u0V1j5e0j5K6z5q4)9J5k6o6k6U0k6U0p5K6x3h3g2S2z5o6W2W2k6R3`.`.">00aK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0K9r3q4@1k6%4m8@1i4K6u0W2j5$3!0E0i4K6u0r3M7$3S2S2M7X3g2Q4x3V1j5$3j5e0R3%4j5U0M7^5x3q4)9J5k6o6u0T1y4K6S2Q4x3X3b7^5x3$3g2S2i4K6u0V1j5e0j5K6z5q4)9J5k6o6k6U0k6U0p5K6x3h3g2S2z5o6W2W2k6R3`.`.</a>

5.5 反复兜圈子，耗时2个多小时+9轮对话，在 5.6 Sol 出了结果之后很快跟着给了答案（虽然我关了记忆，但很难不怀疑是跨会话偷了答案）
<a href="elink@38dK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0K9r3q4@1k6%4m8@1i4K6u0W2j5$3!0E0i4K6u0r3M7$3S2S2M7X3g2Q4x3V1j5$3j5e0R3%4j5X3t1%4j5W2)9J5k6o6q4U0y4o6c8Q4x3X3b7^5x3$3g2S2i4K6u0V1z5o6V1K6k6q4)9J5k6r3y4U0x3e0t1%4j5U0b7@1j5K6R3@1z5b7`.`.">7c9K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0K9r3q4@1k6%4m8@1i4K6u0W2j5$3!0E0i4K6u0r3M7$3S2S2M7X3g2Q4x3V1j5$3j5e0R3%4j5X3t1%4j5W2)9J5k6o6q4U0y4o6c8Q4x3X3b7^5x3$3g2S2i4K6u0V1z5o6V1K6k6q4)9J5k6r3y4U0x3e0t1%4j5U0b7@1j5K6R3@1z5b7`.`.</a>

（不得不说 OpenAI 给 Cyper 护栏加的位置很精准，前面几道题 5.6 Sol 始终拒答，5.5 畅通无阻但几乎没有任何实质性进展；贴一个第六题 GPT 5.5 的发疯记录，555K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6U0K9r3q4@1k6%4m8@1i4K6u0W2j5$3!0E0i4K6u0r3M7$3S2S2M7X3g2Q4x3V1j5$3j5e0R3%4j5X3t1%4j5W2)9J5k6o6q4U0y4o6c8Q4x3X3b7^5x3$3g2S2i4K6u0V1z5o6V1K6k6q4)9J5k6r3y4U0x3e0t1%4j5U0b7@1j5K6R3@1z5b7`.`. ，想让它自助的希望破灭后（有十几个失败对话就不贴了），我改成人工为主，以人的思路一步步引导它解混淆（它特别喜欢约束求解、暴力枚举、模拟执行、上网搜答案作弊，而且网页对话(p.s.本地Codex额度用完了)似乎有系统提示词要求它每一小步都停下来回复对话，很难像本地一样一个长任务设定目标后一直跑；另外一定要给它能自我验证的方式，到后半程才想起来给它一个 qemu，效率提升很多）；最后终于整出了一个看似脱完混淆的python算法（也不知道对不对），但是它不会反解 …… 感觉 5.6 Sol 的能力应该是够的（Claude Opus 5应该也行，但我没有A÷的订阅），可惜它不给做）

---
以上是人

（分隔线）

以下是AI

---

# HexMaze 解题报告 （by GPT 5.6 Sol，来自上面的对话）

## 题目概述

题目给出了一个名为 `HexMaze` 的确定性加密程序，并明确说明：

- 明文按 ASCII 字节处理；
- 算法只包含字节编码、十六进制位运算、模 16 循环偏移、固定位置重排和固定摘要扰动；
- 不使用随机数、随机 IV 或外部状态；
- 相同输入和相同密钥下，密文唯一确定；
- 所有样例和 FLAG 均使用密钥 `121`；
- 摘要扰动只与输入长度有关；
- FLAG 格式为 `flag{...}`，内容均为可打印 ASCII。

已知样例：

```text
HexMaze 密钥: 121

TLU
-> 94AA48550495

Hello
-> 34BB405504B5223594B94C53

2026
-> A48844556485223322356483

abcd!
-> 547B475584B5223564BB4553
```

FLAG 密文：

```text
14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
```

目标是根据已知明密文恢复完整算法，并解释密钥 `121` 中每一位数字的具体作用。

---

## 一、观察密文长度

先统计样例的输入和输出长度。

| 明文 | 明文长度 | 密文字节数 |
|---|---:|---:|
| `TLU` | 3 | 6 |
| `Hello` | 5 | 12 |
| `2026` | 4 | 12 |
| `abcd!` | 5 | 12 |

可以发现，密文总是按照 **6 字节一组**输出。

进一步观察：

- 3 字节明文对应 1 个 6-byte 块；
- 4、5 字节明文都对应 2 个 6-byte 块。

因此可以猜测：

> 每 3 个明文字节经过处理后，对应一个固定长度为 6 字节的密文块。

也就是：

```text
3 byte plaintext
        ↓
6 byte ciphertext
```

对于不足 3 字节的尾部，则仍然补成一个完整的 6 字节输出块。

---

## 二、寻找 6 字节块中的固定结构

以完整 3 字节样例 `TLU` 为例：

```text
TLU -> 94 AA 48 55 04 95
```

再观察其他完整块：

```text
Hello:
34 BB 40 55 04 B5

abcd!:
54 7B 47 55 84 B5
```

可以看到一个明显规律：

```text
?4 ?? 4? 55 ?4 ?5
```

也就是说，一个完整 6 字节块可以表示成：

```text
[a,4] [b,c] [4,d] [5,5] [e,4] [f,5]
```

其中固定的半字节为：

```text
低半字节 4
高半字节 4
55
低半字节 4
低半字节 5
```

真正变化、也就是承载数据的半字节只有：

```text
a b c d e f
```

所以从一个完整 6-byte 块中提取有效数据的方法为：

```text
byte0.high
byte1.high
byte1.low
byte2.low
byte4.high
byte5.high
```

共得到 6 个十六进制半字节，恰好组成 3 个字节。

---

## 三、分析尾块与长度摘要

题目提示：

> 摘要扰动过程只与输入长度有关。

这与尾块的现象完全吻合。

### 余 1 字节

观察：

```text
2026
-> A48844556485 223322356483
```

前 3 个字符形成一个完整块：

```text
A4 88 44 55 64 85
```

最后只剩 1 个字符，对应尾块：

```text
22 33 22 35 64 83
```

其结构为：

```text
22 33 22 35 ?4 ?3
```

只有最后两个高半字节携带实际数据。

---

### 余 2 字节

观察 `Hello`：

```text
Hello
-> 34BB405504B5 223594B94C53
```

尾部结构为：

```text
22 35 ?4 ?? 4? 53
```

因此尾块的固定形式只取决于：

```text
len(plaintext) mod 3
```

这正是题目所说的“固定摘要扰动只与输入长度有关”。

---

## 四、确定 FLAG 长度

FLAG 密文长度为 144 个十六进制字符：

```text
144 hex chars
= 72 bytes
```

每个密文块 6 字节，因此共有：

```text
72 / 6 = 12 blocks
```

观察最后一个块：

```text
22 33 22 35 A4 B3
```

形式与 `2026` 的余 1 字节尾块一致：

```text
22 33 22 35 ?4 ?3
```

所以 FLAG 长度满足：

```text
len(flag) mod 3 = 1
```

前 11 个块各自对应 3 字节，最后一个块对应 1 字节：

```text
11 × 3 + 1 = 34
```

因此 FLAG 总长度为：

```text
34 bytes
```

---

## 五、从样例提取真正的数据

去掉每个 6-byte 块中的固定骨架，只保留有效半字节。

### `TLU`

密文：

```text
94 AA 48 55 04 95
```

提取：

```text
9 A A 8 0 9
```

组成：

```text
9A A8 09
```

---

### `Hello`

提取得到：

```text
3B B0 0B 9B 9C
```

---

### `2026`

得到：

```text
A8 84 68 68
```

---

### `abcd!`

得到：

```text
57 B7 8B 6B B5
```

于是数据层为：

```text
TLU    -> 9A A8 09
Hello  -> 3B B0 0B 9B 9C
2026   -> A8 84 68 68
abcd!  -> 57 B7 8B 6B B5
```

接下来需要研究这些字节与 ASCII 明文之间的关系。

---

## 六、分析密钥 `121`

把一个 ASCII 字节写成两个十六进制半字节：

```text
byte = (H, L)
```

其中：

```text
H = 高 4 bit
L = 低 4 bit
```

通过对四组样例逐字节比较，可以还原出密钥 `121` 对应的三周期操作。

---

### 密钥数字 `1`

当当前位置对应密钥数字 `1` 时：

1. 交换高、低半字节；
2. 第一个半字节加 `4`；
3. 第二个半字节加 `5`；
4. 所有运算均模 16。

即：

```text
(H, L)
-> (L, H)
-> ((L + 4) mod 16, (H + 5) mod 16)
```

公式写作：

```text
key = 1:
(H,L) -> (L+4, H+5) mod 16
```

---

### 密钥数字 `2`

当当前位置对应密钥数字 `2` 时，不交换半字节：

```text
(H,L)
-> ((H + 5) mod 16, (L + 4) mod 16)
```

即：

```text
key = 2:
(H,L) -> (H+5, L+4) mod 16
```

---

### 密钥 `121` 的完整周期

所以 `121` 实际代表：

```text
位置 0: key 1
位置 1: key 2
位置 2: key 1
位置 3: key 1
位置 4: key 2
位置 5: key 1
...
```

即周期：

```text
1, 2, 1, 1, 2, 1, ...
```

对应的实际操作为：

```text
1 -> swap + (+4,+5)
2 -> no swap + (+5,+4)
1 -> swap + (+4,+5)
```

需要注意的是：

> 密钥中的 `1` 和 `2` 并不是简单地表示“加 1”和“加 2”，而是用于选择两种固定的半字节变换模式。

这也是题目要求在 WP 中解释的重点。

---

## 七、逆向密钥变换

逆过程非常简单。

### 对应密钥 `1`

加密：

```text
(H,L) -> (L+4, H+5)
```

设密文字节半字节为：

```text
(a,b)
```

则：

```text
L = (a - 4) mod 16
H = (b - 5) mod 16
```

---

### 对应密钥 `2`

加密：

```text
(H,L) -> (H+5, L+4)
```

所以：

```text
H = (a - 5) mod 16
L = (b - 4) mod 16
```

---

## 八、逆变换样例

将上一步提取出的有效字节执行密钥逆变换。

得到：

```text
TLU    -> UTL
Hello  -> olleH
2026   -> 6022
abcd!  -> !cdba
```

这非常关键。

可以发现：

```text
TLU   -> UTL
```

并不是随机变化，而是固定的位置重排。

---

## 九、恢复 HexMaze 的位置重排

继续分析样例。

### `TLU`

只有 3 字节：

```text
TLU
```

变成：

```text
UTL
```

相当于：

```text
ABC -> CAB
```

即一个 3-byte 块内部进行右循环 1 位。

---

### `Hello`

从字符串右侧每 3 字节分组：

```text
He | llo
```

先处理最右侧：

```text
llo -> oll
```

剩余开头 2 字节：

```text
He -> eH
```

并且输出顺序是从右向左：

```text
oll + eH
= olleH
```

与解出的中间结果完全一致。

---

### `abcd!`

从右侧分组：

```text
ab | cd!
```

处理：

```text
cd! -> !cd
ab  -> ba
```

从右向左拼接：

```text
!cd + ba
= !cdba
```

完全吻合。

---

### `2026`

分组：

```text
2 | 026
```

处理完整块：

```text
026 -> 602
```

再处理单字节：

```text
2 -> 2
```

最后：

```text
6022
```

同样吻合。

---

## 十、位置重排算法总结

加密时：

1. 从明文字符串最右端开始；
2. 每次取 3 字节；
3. 对每个 3-byte 块执行右循环 1 位：

```text
ABC -> CAB
```

4. 如果最左边剩 2 字节：

```text
AB -> BA
```

5. 如果只剩 1 字节：

```text
A -> A
```

6. 按照“右侧块到左侧块”的顺序输出。

因此它本质上是：

```text
右侧分块
+
块顺序反转
+
块内循环移位
```

这也解释了 `HexMaze` 中 “Maze” 的含义：数据位置被进行了固定迷宫式重排。

---

## 十一、解密 FLAG

FLAG 密文：

```text
14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
```

首先按照前面总结出的固定骨架提取有效半字节。

然后依次按照密钥周期：

```text
1 2 1 1 2 1 ...
```

执行逆半字节变换。

得到 HexMaze 位置重排后的中间结果：

```text
}r!est4_M0ptyCr_7fc_K6022u_1{Tglaf
```

---

## 十二、逆位置重排

将中间字符串按照 3 字节分组：

```text
}r!
est
4_M
0pt
yCr
_7f
c_K
602
2u_
1{T
gla
f
```

完整块在加密时为：

```text
ABC -> CAB
```

因此解密时执行左循环 1 位：

```text
CAB -> ABC
```

逐块得到：

```text
}r! -> r!}
est -> ste
4_M -> _M4
0pt -> pt0
yCr -> Cry
_7f -> 7f_
c_K -> _Kc
602 -> 026
2u_ -> u_2
1{T -> {T1
gla -> lag
```

由于加密过程中块顺序发生了反转，因此解密时需要再次反转块顺序。

最后剩余的单字节：

```text
f
```

放回最前方。

最终得到：

```text
f
+ lag
+ {T1
+ u_2
+ 026
+ _Kc
+ 7f_
+ Cry
+ pt0
+ _M4
+ ste
+ r!}
```

拼接：

```text
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

---

## 十三、最终 FLAG

```text
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

---

## 十四、完整解密脚本

```python
CIPHER = """
14CC4655547594BC475584C5848A43551495448C445584C5D4C9475564C534A84B55A4B574BA4355F495A48844556485648C495534A5548C4F5584A5B4BB405554B522332235A4B3
""".strip()

c = bytes.fromhex(CIPHER)

# FLAG 尾块的格式为：
#
# 22 33 22 35 ?4 ?3
#
# 与余 1 字节尾块一致，因此：
#
# len(flag) mod 3 == 1
#
# 密文一共有 12 个 6-byte 块：
#
# 11 * 3 + 1 = 34

blocks = len(c) // 6
n = (blocks - 1) * 3 + 1

def extract_core(c, n):
    """
    从 HexMaze 的固定 6-byte 输出骨架中，
    提取真正承载数据的半字节。
    """

q, r = divmod(n, 3)
    v = []

# 每个完整 3-byte 数据块对应：
    #
    # ?4 ?? 4? 55 ?4 ?5
    #
    # 有效 nibble 为：
    #
    # byte0.high
    # byte1.high
    # byte1.low
    # byte2.low
    # byte4.high
    # byte5.high

for k in range(q):
        b = c[k * 6:k * 6 + 6]

v += [
            b[0] >> 4,
            b[1] >> 4,
            b[1] & 0xF,
            b[2] & 0xF,
            b[4] >> 4,
            b[5] >> 4,
        ]

# 处理尾块

b = c[q * 6:q * 6 + 6]

if r == 1:

# 22 33 22 35 ?4 ?3

v += [
            b[4] >> 4,
            b[5] >> 4,
        ]

elif r == 2:

# 22 35 ?4 ?? 4? 53

v += [
            b[2] >> 4,
            b[3] >> 4,
            b[3] & 0xF,
            b[4] & 0xF,
        ]

return v

def undo_key(v):
    """
    逆转密钥 121 对 nibble 的变换。
    """

out = bytearray()

for i in range(0, len(v), 2):

pos = i // 2

a = v[i]
        b = v[i + 1]

# key 周期：
        #
        # 1 2 1 1 2 1 ...

if pos % 3 in (0, 2):

# key = 1
            #
            # encryption:
            #
            # (H,L) -> (L+4, H+5)

L = (a - 4) & 0xF
            H = (b - 5) & 0xF

else:

# key = 2
            #
            # encryption:
            #
            # (H,L) -> (H+5, L+4)

H = (a - 5) & 0xF
            L = (b - 4) & 0xF

out.append((H << 4) | L)

return bytes(out)

def undo_maze(s):
    """
    逆转固定位置重排。

加密中的完整块：
        ABC -> CAB

因此解密：
        CAB -> ABC

同时还需要反转块顺序。
    """

n = len(s)

q, r = divmod(n, 3)

chunks = []

p = 0

for _ in range(q):

x = s[p:p + 3]
        p += 3

# CAB -> ABC

chunks.append(x[1:] + x[:1])

# 处理最左侧不足 3 字节的部分

if r:

x = s[p:p + r]

if r == 2:

# BA -> AB

lead = x[1:] + x[:1]

else:

lead = x

else:

lead = b""

# 加密时从最右块向最左块输出，
    # 所以这里重新反转

return lead + b"".join(reversed(chunks))

core = extract_core(c, n)

maze = undo_key(core)

print("maze =", maze.decode())

flag = undo_maze(maze)

print("flag =", flag.decode())
```

运行结果：

```text
maze = }r!est4_M0ptyCr_7fc_K6022u_1{Tglaf

flag = flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

---

## 十五、加密流程总结

整个 HexMaze 可以概括为四层。

### 第一层：ASCII 字节编码

```text
plaintext
-> ASCII bytes
```

---

### 第二层：固定位置重排

从字符串右侧按照 3 字节分块。

完整块：

```text
ABC -> CAB
```

两字节块：

```text
AB -> BA
```

单字节：

```text
A -> A
```

同时块顺序从右向左输出。

---

### 第三层：密钥 `121` 半字节变换

对每个字节拆分：

```text
(H,L)
```

按 `121` 周期处理。

`1`：

```text
(H,L)
-> (L+4, H+5) mod 16
```

`2`：

```text
(H,L)
-> (H+5, L+4) mod 16
```

因此：

```text
121
=
swap/+45
normal/+54
swap/+45
```

循环执行。

---

### 第四层：固定 6-byte 编码及长度扰动

每 3 个数据字节被嵌入固定骨架：

```text
?4 ?? 4? 55 ?4 ?5
```

不足 3 字节的尾部使用只与：

```text
len(plaintext) mod 3
```

有关的固定模板。

整个算法因此完全确定，不包含任何随机成分。

---

## 总结

本题最重要的突破点有三个：

1. 观察到密文以 6 字节为固定块，并存在大量固定半字节；
2. 去除固定骨架后，通过已知明文恢复 `121` 对高低 nibble 的周期性操作；
3. 逆掉 nibble 变换后得到 `UTL`、`olleH`、`6022`、`!cdba`，从而直接暴露出固定的 3-byte 分块位置重排。

最终成功恢复完整 FLAG：

```text
flag{T1u_2026_Kc7f_Crypt0_M4ster!}
```

登录后可查看完整内容

冰与火的战歌：Windows内核攻防实战高级班！从零到实战，融合AI与Windows内核攻防全技术栈，打造具备自动化能力的内核开发高手。

最后于 2026-8-21 11:18 被mb_mgodlfyn编辑，原因：

收藏・0

点赞・6

打赏

最新回复 (3)
初学者有毅力雪币： 190 活跃值： (1506) 能力值： ( LV3，RANK：26 ) 在线值：发帖 7 回帖 53 粉丝 1 关注私信	初学者有毅力 2 楼出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！ 2026-8-23 11:12 0
教教我吧~ 雪币： 1973 活跃值： (3604) 能力值： ( LV6，RANK：80 ) 在线值：发帖 12 回帖 63 粉丝 68 关注私信	教教我吧~ 1 3 楼初学者有毅力出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！虽然出题是AI，解题也是AI，但是并非所有AI都能做出来。这和之前“CTF出题是人，解题也是人，但是很多人做不出来”一样的道理，能防部分AI就是好题！ 2026-8-24 10:16 0
mb_mgodlfyn 雪币： 31146 活跃值： (16516) 能力值： ( LV15，RANK：2100 ) 在线值：发帖 58 回帖 61 粉丝 76 关注私信	mb_mgodlfyn 16 4 楼初学者有毅力出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！汽车取代马车的潮流不可逆转时，人要做的不是如何让马车跑的比汽车快，而是要学会如何驾驶汽车开到以往马车跑不到的远途。 AI显然永久的改变了安全行业，那么人只能去学习如何用好AI，做到以往难以完成的事。至于CTF，对出题人的要求变得更高了，至少，能被AI直接秒杀的题很难再被评为好题了。另外，对解题方，如何调动Harness与AI合理的协作，是与模型自身能力同等重要的；本次KCTF的第三、四、六三道难题成功坚持到了第二天，并不是随意丢给AI就能直接出结果的；甚至第三题以短小精悍的体积和精妙的算法主动误导AI，同时考察模型能力和人工介入，是一道很好的题最后于 2026-8-24 12:17 被mb_mgodlfyn编辑，原因： 2026-8-24 12:16 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复

mb_mgodlfyn

发帖

回帖

2100

RANK

关注

私信

他的文章

关于我们

联系我们

企业服务

看雪公众号

最新回复 (3)
初学者有毅力雪币： 190 活跃值： (1506) 能力值： ( LV3，RANK：26 ) 在线值：发帖 7 回帖 53 粉丝 1 关注私信	初学者有毅力 2 楼出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！ 2026-8-23 11:12 0
教教我吧~ 雪币： 1973 活跃值： (3604) 能力值： ( LV6，RANK：80 ) 在线值：发帖 12 回帖 63 粉丝 68 关注私信	教教我吧~ 1 3 楼初学者有毅力出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！虽然出题是AI，解题也是AI，但是并非所有AI都能做出来。这和之前“CTF出题是人，解题也是人，但是很多人做不出来”一样的道理，能防部分AI就是好题！ 2026-8-24 10:16 0
mb_mgodlfyn 雪币： 31146 活跃值： (16516) 能力值： ( LV15，RANK：2100 ) 在线值：发帖 58 回帖 61 粉丝 76 关注私信	mb_mgodlfyn 16 4 楼初学者有毅力出题也是AI ，解题也是AI，现在都成了AI对抗了，不知道CTF还有啥意义！汽车取代马车的潮流不可逆转时，人要做的不是如何让马车跑的比汽车快，而是要学会如何驾驶汽车开到以往马车跑不到的远途。 AI显然永久的改变了安全行业，那么人只能去学习如何用好AI，做到以往难以完成的事。至于CTF，对出题人的要求变得更高了，至少，能被AI直接秒杀的题很难再被评为好题了。另外，对解题方，如何调动Harness与AI合理的协作，是与模型自身能力同等重要的；本次KCTF的第三、四、六三道难题成功坚持到了第二天，并不是随意丢给AI就能直接出结果的；甚至第三题以短小精悍的体积和精妙的算法主动误导AI，同时考察模型能力和人工介入，是一道很好的题最后于 2026-8-24 12:17 被mb_mgodlfyn编辑，原因： 2026-8-24 12:16 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复