同一个 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 规范,你会比大多数人理解得更透。下一篇题解见------如果这篇文章帮到了你,欢迎点个"在看",转发给同样在备赛的朋友。