2026 工业互联网安全大赛 · 全国预选赛题解系列密码学方向 crypto-5

同一个 nonce 用了两次, AES-128-GCM 就塌了

|----------------------------------------------------------------------------------------------------------------------------------------------------------------------|
| > **导读:**这道题来自 2026 工业互联网安全大赛全国预选赛,编号 crypto-5,考点是一道经典密码学漏洞------AES-128-GCM 的 nonce 重用。你不需要学过密码学,文中所有概念都从零讲起;跟着四步走完,你会亲眼看到业界最主流的认证加密算法,如何被一个小小的工程失误整个击穿。预计阅读 12 分钟。 |

01|题目讲了一个什么故事

先做点铺垫。CTF(Capture The Flag,夺旗赛)是安全圈最常见的竞赛形式:选手从题目给出的现场材料里找线索、做分析,最终挖出一串形如 flag{...} 的字符串提交得分,这串字符串就叫 flag。2026 工业互联网安全大赛全国预选赛的这道 crypto-5,模拟的正是一个非常真实的工业场景。

某工厂的遥测上行链路以 VHF 无线电为主用通道,遥测网关(型号 NRWF-TELEM-GW,固件 3.8.2)负责把温度、油位、开关量等遥测数据封装成定长帧向上发送。这些数据既要防偷看、又要防篡改,链路的机密性与完整性由 AES-128-GCM 提供------它是目前业界最主流的认证加密算法,从网页浏览到内网专线,到处都有它的身影。

某次运维巡检,工程师发现网关的上行帧计数器出现异常跳变 。出于谨慎,团队从调试口镜像出一段上行帧日志,连同链路台账、许可封存文件一并打包给出。题目要求只有一句话:恢复当前有效的许可凭据。

到手的材料是三份 JSON 文件:gcm_capture.json 是上行帧日志;telemetry_policy.json 是链路台账,记录着 HKDF 参数和各通道状态;sealed_license.json 是各通道的许可封存文件,里面存着 iv、ct、tag 三样东西。题目还公开了完整解题脚本 exp.py,下文我们对照着它来讲。

02|三分钟搞懂 AES-GCM 和 nonce

AES 是对称加密算法 :加密和解密使用同一把密钥。但光有密钥还不够,每次加密还需要一个公开的辅助值,叫 nonce (number once,一次性数字)。它在安全模型里的使命只有一条:在同一把密钥下,永远不要重复。

GCM 模式干两件事。其一,加密 :用密钥和 nonce 派生一串密钥流,与明文逐字节异或得到密文,本质上是流式加密(AES-CTR)。其二,认证:用主密钥派生出的认证子密钥 H,对附加认证数据 AAD 和密文 C 做 GHASH 运算,再与 nonce 的加密结果叠加,生成认证标签 tag。接收方先验 tag,对不上就整帧丢弃------这就是"认证加密"防篡改的原理。

那么 nonce 重用会发生什么?两件致命的事同时发生。第一件在加密侧 :密钥流由"密钥+nonce"唯一决定,nonce 相同,两帧的密钥流就一模一样。两段密文互相异或,密钥流直接抵消,剩下的就是两段明文的异或值------不用密钥,攻击者也能拿到两段明文之间的关系。第二件在认证侧,也是本题的核心:tag 的计算式里含有一个未知数 H。平时 H 深藏在密钥里取不出来,可一旦同一个 nonce 下出现了多帧数据,tag 与 tag 之间就构成了关于 H 的代数方程组------把方程解出来,H 就暴露了。有了 H,伪造合法 tag、篡改报文都不再需要密钥。

这类攻击在文献里有个吓人的名字:forbidden attack (被禁止的攻击)。名字很直白------规范早就明令禁止 nonce 重用,但规范拦不住固件写错。这道题里,异常跳变的帧计数器,恰好让不同帧用上了同一个 nonce。

03|第一步:从日志里找出撞车的 nonce

exp.py 的第一段在做一件朴素的事:把 gcm_capture.json 里的帧记录按 ch_id(通道号)分组,再按 nonce 聚类。每帧记录的关键字段如下表。

表 1 |帧日志关键字段速查

字段 含义
ch_id 通道编号,标明该帧属于哪条会话
nonce 本帧使用的随机数,由 frame_ctr 与 dev_epoch 拼接而成
aad 附加认证数据,不加密、但参与 tag 计算
ciphertext 与 tag 密文与认证标签,nonce 重用的证据链就藏在其中

台账里写的 nonce 构造方式 frame_ctr || dev_epoch,意思是把帧计数器和设备纪元两个数值拼接。计数器异常跳变,落到数据上的表现非常具体:不同帧复用了同一个 nonce。聚类之后,每条通道都能找到一组 3 帧以上的撞车数据。

为什么至少要 3 帧?一条 tag 关系式对应一个关于 H 的多次多项式方程,单个方程的解并不唯一;两个方程放在一起求最大公因式,根才能收敛到唯一的一个。3 帧恰好提供两条独立关系式------这是解出 H 的最低配置。

表 2 |解题路线总览

步骤 做什么 结果
1 解析帧日志,按通道聚类,找出复用同一 nonce 的帧组 各通道的撞车帧组
2 forbidden attack:构造多项式方程并求最大公因式 各通道认证子密钥 H
3 HKDF-SHA256 以 H 为输入派生封存密钥 每通道 32 字节密钥
4 AES-256-CTR 解封载荷,HMAC 校验通过 ch1 当前有效凭据(flag)

04|第二步:forbidden attack 解出认证子密钥 H

回到 GCM 的标签公式:tag = E_K(J0) XOR GHASH_H(AAD, C) 。其中 E_K(J0) 是用主密钥加密 nonce 得到的中间值;GHASH_H 是以 H 为变量的多项式运算------把数据按 16 字节切块,逐块乘上 H 的不同次幂再叠加。tag 里藏着 H 的高次幂结构,这正是它能被解出来的原因。

在同一个 nonce 下取两帧 a、b,各写一条公式再相减:E_K(J0) 只由密钥和 nonce 决定,两帧完全相同,一减就消掉了。剩下的部分整理成一个多项式方程,求解链条如下------

|--------------------------------------------------------------------------------------------------------------------------------------------------|
| 同 nonce 两帧: tag_a XOR tag_b = S_a(H) XOR S_b(H) 整理成方程: Q(H) = 0 (系数在 GF(2^128) 上) 两条方程求 gcd:gcd(Q1, Q2) = g1*H + g0 解出: H = g0 / g1,再用三帧数据回验一致 |

方程的系数都活在一个叫 GF(2^128) 的有限域里。名字唬人,本质朴素:把 128 个比特当成一个数,加法就是异或,乘法做完要按固定多项式 x^128 + x^7 + x^2 + x + 1 取模。exp.py 里的 gf_mul、gf_inv、p_gcd 三个函数,分别负责域乘法、求逆、多项式最大公约数,纯标准库手写,不依赖任何第三方密码库。

两个多项式做完 gcd 得到一次式 g1*H + g0 = 0,于是 H = g0 / g1 ,认证子密钥就此落网。脚本还做了一步自校验:用求出的 H 重算三帧的 GHASH 值,各帧的 tag XOR GHASH 必须得到同一个值------三帧一致,说明 H 正确无疑。

这里埋着题目最大的坑:每条通道使用独立的会话子密钥, H 必须按通道分别求解。把 ch1 解出的 H 拿去给 ch2 用,后面所有步骤都会失败。

05|第三、四步:派生密钥,解封许可

拿到 H 只是拆掉了第一道门,真正的目标在 sealed_license.json 里。密钥派生链条是:以 H 为输入密钥材料,用 HKDF-SHA256 派生封存密钥------salt 固定为字符串 NRWF-TELEM-LIC-v2,info 为通道号 ch1、ch2、ch3,输出长度 32 字节。HKDF 可以理解成一台榨汁机:把一段密钥材料,按需榨成指定长度、分布均匀的高质量子密钥。

接着用派生出的 32 字节密钥,以 AES-256-CTR 模式解密许可载荷;再计算 HMAC-SHA256(key, iv||ct) 取前 16 字节,与封存文件里的 tag 比对。校验通过,说明解封流程正确,明文中就会出现形如 flag{...} 的凭据。

最后按台账指向收尾:telemetry_policy.json 中 status 为 current 的通道是 ch1,取 ch1 解出的当前有效凭据提交------

|----------------------------------------------------|
| FLAG flag{GCM_N0nc3_R3u53_1s_F0rb1dd3n_26} |

完整脚本:

python 复制代码
import argparse
import glob
import hashlib
import hmac
import json
import os
import struct
import sys
import zipfile

ATTACH_DIR = r"C:\Users\attachments"
DEFAULT_ZIP_GLOB = "*crypto-5*.zip"

# GCM 有限域约简多项式: x^128 + x^7 + x^2 + x + 1
R = 0xE1000000000000000000000000000000
ONE = 1 << 127                        # GCM 域乘法单位元


# ------------------------- GF(2^128) 运算 -------------------------
def gf_mul(x, y):
    z, v = 0, y
    for i in range(128):
        if (x >> (127 - i)) & 1:
            z ^= v
        v = (v >> 1) ^ R if (v & 1) else (v >> 1)
    return z


def gf_pow(x, e):
    r = ONE                     # GCM 域乘法单位元是 0x80..00,不是整数 1
    while e:
        if e & 1:
            r = gf_mul(r, x)
        x = gf_mul(x, x)
        e >>= 1
    return r


def gf_inv(x):
    return gf_pow(x, (1 << 128) - 2)      # x^(2^128-2)


# --------------------- 多项式(系数为 GF(2^128) 元素,升幂) ---------------------
def p_trim(p):
    while len(p) > 1 and p[-1] == 0:
        p.pop()
    return p


def p_mod(a, b):
    a = a[:]
    db = len(b) - 1
    inv_lb = gf_inv(b[-1])
    while len(a) > 0 and len(a) - 1 >= db:
        if a[-1] != 0:
            f = gf_mul(a[-1], inv_lb)
            shift = len(a) - 1 - db
            for i in range(len(b)):
                a[shift + i] ^= gf_mul(f, b[i])
        a.pop()
    if not a:
        a = [0]
    return p_trim(a)


def p_gcd(a, b):
    a, b = p_trim(a[:]), p_trim(b[:])
    while not (len(b) == 1 and b[0] == 0):
        a, b = b, p_mod(a, b)
    return a


def p_eval(p, x):
    y = 0
    for c in reversed(p):
        y = gf_mul(y, x) ^ c
    return y


# ------------------------- GHASH / 攻击 -------------------------
def to_int(b):
    return int.from_bytes(b, "big")


def ghash_poly(aad, ct):
    """返回 S(H) 的多项式系数(升幂),其中 S=GHASH_H(AAD,C)。"""
    data = b""
    if aad:
        data += aad + b"\x00" * ((-len(aad)) % 16)
    if ct:
        data += ct + b"\x00" * ((-len(ct)) % 16)
    data += struct.pack(">QQ", len(aad) * 8, len(ct) * 8)
    blocks = [to_int(data[i:i + 16]) for i in range(0, len(data), 16)]
    m = len(blocks)
    coeffs = [0] * (m + 1)
    for i, blk in enumerate(blocks, start=1):
        coeffs[m - i + 1] ^= blk          # B_i 对应 H^(m-i+1)
    return coeffs


def build_Q(frame_a, frame_b):
    """构造关于 H 的多项式 Q(H) = S_a XOR S_b XOR tag_a XOR tag_b。"""
    a = to_int(bytes.fromhex(frame_a["aad"])), to_int(bytes.fromhex(frame_a["ciphertext"])), \
        to_int(bytes.fromhex(frame_a["tag"]))
    b = to_int(bytes.fromhex(frame_b["aad"])), to_int(bytes.fromhex(frame_b["ciphertext"])), \
        to_int(bytes.fromhex(frame_b["tag"]))
    sa = ghash_poly(bytes.fromhex(frame_a["aad"]), bytes.fromhex(frame_a["ciphertext"]))
    sb = ghash_poly(bytes.fromhex(frame_b["aad"]), bytes.fromhex(frame_b["ciphertext"]))
    n = max(len(sa), len(sb))
    q = [0] * n
    for i, v in enumerate(sa):
        q[i] ^= v
    for i, v in enumerate(sb):
        q[i] ^= v
    q[0] ^= (a[2] ^ b[2])
    return p_trim(q)


def recover_H(frames):
    """由三帧同 nonce 数据解出 GHASH 子密钥 H。返回 H(int)。"""
    q1 = build_Q(frames[0], frames[1])
    q2 = build_Q(frames[0], frames[2])
    g = p_gcd(q1, q2)
    if len(g) != 2:
        sys.exit("[!] H 的 gcd 结果非一次(deg=%d),需要更多同 nonce 帧" % (len(g) - 1))
    # g(H) = g1*H + g0 = 0  ->  H = g0 / g1
    H = gf_mul(g[0], gf_inv(g[1]))
    # 校验:三帧的 tag XOR S 必须一致(同一个 E_K(J0))
    def ekj0(f):
        s = 0
        for c in reversed(ghash_poly(bytes.fromhex(f["aad"]), bytes.fromhex(f["ciphertext"]))):
            s = gf_mul(s, H) ^ c
        return to_int(bytes.fromhex(f["tag"])) ^ s
    vals = {ekj0(f) for f in frames}
    assert len(vals) == 1, "H 校验失败(tag XOR S 不一致)"
    print("[+] 恢复 GHASH 子密钥 H = %032x(三帧校验一致)" % H)
    return H


def hkdf_sha256(ikm, salt, info, length):
    from cryptography.hazmat.primitives import hashes
    from cryptography.hazmat.primitives.kdf.hkdf import HKDF
    return HKDF(algorithm=hashes.SHA256(), length=length, salt=salt, info=info).derive(ikm)


def aes_ctr_decrypt(key, iv, ct):
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
    dec = Cipher(algorithms.AES(key), modes.CTR(iv)).decryptor()
    return dec.update(ct) + dec.finalize()


def main():
    ap = argparse.ArgumentParser(description="crypto-5 GCM nonce 重用 exp")
    ap.add_argument("--zip", default=DEFAULT_ZIP_GLOB)
    ap.add_argument("--capture", default=None)
    ap.add_argument("--license", default=None)
    ap.add_argument("--policy", default=None)
    args = ap.parse_args()

    if args.capture and args.license and args.policy:
        cap = json.load(open(args.capture, encoding="utf-8"))
        lic = json.load(open(args.license, encoding="utf-8"))
        pol = json.load(open(args.policy, encoding="utf-8"))
    else:
        zp = glob.glob(os.path.join(ATTACH_DIR, args.zip)) or \
            glob.glob(os.path.join(ATTACH_DIR, "**", args.zip), recursive=True)
        if not zp:
            sys.exit("[!] 找不到附件 zip")
        with zipfile.ZipFile(zp[0]) as z:
            data = {os.path.basename(n): z.read(n) for n in z.namelist()}
        cap = json.loads(data["gcm_capture.json"])
        lic = json.loads(data["sealed_license.json"])
        pol = json.loads(data["telemetry_policy.json"])
        print("[*] 从 %s 读取 capture / license / policy" % os.path.basename(zp[0]))

    seal = pol["license_sealing"]
    salt = seal["salt"].encode()
    key_len = int(seal["key_len"])

    # 按 ch_id 分组,找同 nonce 的帧(>=3 帧才能 gcd 出一次式)
    by_ch = {}
    for f in cap["frames"]:
        by_ch.setdefault(f["ch_id"], {}).setdefault(f["nonce"], []).append(f)
    nonce_groups = {}
    for ch, groups in by_ch.items():
        for nonce, fs in groups.items():
            if len(fs) >= 3:
                nonce_groups[ch] = fs
                print("[*] ch%d 发现 nonce 重用:%s(%d 帧)" % (ch, nonce, len(fs)))
                break

    lic_by_ch = {l["ch_id"]: l for l in lic["licenses"]}
    cur = next(c for c in pol["channels"] if c["status"] == "current")
    ch_id = cur["ch_id"]

    for ch in sorted(nonce_groups):
        H = recover_H(nonce_groups[ch])
        key = hkdf_sha256(H.to_bytes(16, "big"), salt, ("ch%d" % ch).encode(), key_len)
        l = lic_by_ch.get(ch)
        if not l:
            continue
        iv = bytes.fromhex(l["iv"])
        ct = bytes.fromhex(l["ct"])
        tag = bytes.fromhex(l["tag"])
        mac = hmac.new(key, iv + ct, hashlib.sha256).digest()[:16]
        ok = hmac.compare_digest(mac, tag)
        print("    ch%d 许可 %s HMAC 校验:%s" % (ch, l["ref"], "通过" if ok else "失败"))
        if not ok:
            continue
        pt = aes_ctr_decrypt(key, iv, ct)
        print("    明文:%r" % pt)
        if ch == ch_id:
            import re
            m = re.search(rb"flag\{[^}]*\}", pt)
            if m:
                print("\nFLAG: %s" % m.group().decode())
                return
    sys.exit("[!] 未从 current 通道解出 flag")


if __name__ == "__main__":
    main()

|---------------------------------------------------------------------------------------------------------------------------------|
| 踩坑清单 一是 ch2、ch3 均为干扰项,HMAC 校验失败或状态不符,只有 ch1 的 current 凭据有效; 二是 H 必须按通道单独求,跨通道复用必然全盘失败; 三是同一 nonce 至少要 3 帧,多项式 gcd 才能收敛出唯一根。 |

06|这道题在提醒我们什么

crypto-5 不是架空的谜题,它压缩了工业现场真实存在的故障模式。遥测网关 7×24 小时连续运行,一旦断电重启、固件升级或计数器回绕处理不当,frame_ctr 完全可能退回旧值------nonce 重用就这样悄悄发生,而链路表面一切正常,只有审计日志里的计数器跳变会露出马脚。

密码学规范对此早有明文。NIST SP 800-38D 明确要求:同一密钥下,GCM 的 nonce 绝不允许重复;如果用随机方式生成 nonce,同一密钥加密的消息数量也必须设上限,因为随机值之间的碰撞概率会随消息数量上升。这并非杞人忧天------2016 年发表的《Nonce-Disrespecting Adversaries》一文,在对公网 TLS 流量的实测中抓到了数万次真实的 nonce 重复;工程界随后也推广了 AES-GCM-SIV 这类专门容忍 nonce 滥用的方案。

落到开发实践,至少有三条可以照做。其一 ,nonce 采用单调递增计数器并持久化存储,断电不回退;其二 ,定期轮换会话密钥,缩小同一 nonce 空间的使用范围;其三,把计数器跳变当成安全事件告警,而不是普通运维异常------这道题里,正是计数器异常跳变暴露了整条链路的裂缝。

给想入行安全的学习者一句建议:别背公式,把这道题的 exp.py 亲手跑一遍,再回头读 NIST 的 GCM 规范,你会比大多数人理解得更透。下一篇题解见------如果这篇文章帮到了你,欢迎点个"在看",转发给同样在备赛的朋友。

相关推荐
Rabitebla13 小时前
【Linux操作系统】 文件篇(一):文件描述符与 Linux 文件管理机制
linux·网络·c++·笔记·学习
Flynt14 小时前
Java4Shell 实测:EPYC 一跑就中招,关掉 Base64 硬件加速,1KB 解码慢 14 倍
java·安全·性能优化
manduic15 小时前
汽车座舱Buck选型实战:AWK6613 对比 SCT2432,参数逐项对齐(附选型清单)
网络·汽车
地平线开发者20 小时前
让 AI Agent 和 征程6 台架高效、稳定、安全地协作
算法·安全·自动驾驶
通信王6620 小时前
NBIOT NTN协议整理-TS36.211
网络
艾莉丝努力练剑20 小时前
【AI大模型接入SDK】C++的SessionManager 线程安全
java·开发语言·前端·c++·人工智能·学习·安全
国科安芯21 小时前
CAN FD一升到5Mbps就误码:位定时、终端与共模的现场排查顺序——ASM1042S2S在星载分布式总线中的FAE实践
分布式·安全·架构·canfd·dcdc·抗辐射·载荷
光电笑映1 天前
TCP 为什么可靠?从三次握手、滑动窗口到拥塞控制全面拆解(上)
运维·服务器·网络·udp
Vni1 天前
华三双核心交换机IRF堆叠
网络·交换机·堆叠·华三