4.2.1 模算术基本定理#

• 模运算：( a \equiv b \pmod n \Longleftrightarrow n \mid (a-b) )
• 乘法逆元：若 ( \gcd(a,n)=1 )，存在唯一 ( a^{-1} ) 使 ( a \cdot a^{-1} \equiv 1 \pmod n )
• 欧拉函数 ( \varphi(n) )：与 ( n ) 互素的正整数个数；( n=p q ) 则 ( \varphi(n) = (p-1)(q-1) )

4.2.2 费马小定理与欧拉定理#

• 费马小定理：若 ( p ) 素、( \gcd(a,p)=1 )，则 ( a^{p-1} \equiv 1 \pmod p )
• 欧拉定理：若 ( \gcd(a,n)=1 )，则 ( a^{\varphi(n)} \equiv 1 \pmod n )

RSA 正确性证明（核心一步）：

[ m^{ed} \equiv m^{k\varphi(n)+1} \equiv (m^{\varphi(n)})^k \cdot m \equiv 1^k \cdot m \equiv m \pmod n ]

4.2.3 扩展欧几里得算法#

1
def ext_gcd(a, b):
2
    if b == 0:
3
        return a, 1, 0
4
    g, x, y = ext_gcd(b, a % b)
5
    return g, y, x - (a // b) * y
6

7
def modinv(a, n):
8
    g, x, _ = ext_gcd(a % n, n)
9
    if g != 1:
10
        raise ValueError("not invertible")
11
    return x % n

时间复杂度 ( O(\log \min(a,b)) )。

4.2.4 中国剩余定理 (CRT)#

若 ( n_1, \dots, n_k ) 两两互素，( N = \prod n_i )，则方程组

[ \begin{cases} x \equiv a_1 \pmod{n_1} \ \vdots \ x \equiv a_k \pmod{n_k} \end{cases} ]

在 ( \mathbb{Z}_N ) 下有唯一解：

[ x \equiv \sum_{i=1}^k a_i \cdot M_i \cdot M_i^{-1} \pmod N, \quad M_i = N / n_i ]

工程应用：RSA-CRT 优化——分别在 ( \pmod p ) 和 ( \pmod q ) 下计算，总耗时约为一次 ( \pmod{pq} ) 计算的 1/4。

4.2.5 离散对数问题 (DLP)#

给定素数 ( p )、生成元 ( g )、( h = g^x \bmod p )，求 ( x ) 为 DLP。当前最好算法：

• 通用：Pollard Rho ( O(\sqrt{q}) )（( q ) 为群阶）
• 对素域：GNFS 子指数时间
• 对 ECC：已知最快 Pollard Rho，仍为 ( O(\sqrt{q}) ) → 256-bit ECC ≈ 3072-bit RSA 安全

4.4.1 分组密码 vs 流密码#

4.4.2 AES 算法内部结构#

AES-128 共 10 轮，每轮 4 个步骤：

1
State = 4×4 byte 矩阵
2
  │
3
 10 × (SubBytes → ShiftRows → MixColumns → AddRoundKey)
4
  │    (最后一轮无 MixColumns)
5
  ▼
6
Ciphertext

4.4.3 工作模式深度#

4.4.4 GCM 深入#

1
GCM(K, IV, P, A):
2
  J0  ← IV || 0^31 || 1    (12-byte IV 常见场景)
3
  C   ← CTR_K(J0+1, P)     (counter 从 J0+1 开始)
4
  H   ← AES_K(0^128)
5
  T   ← GHASH_H(A || 0* || C || 0* || len(A) || len(C))  ⊕ AES_K(J0)
6
  返回 (C, T)

其中 GHASH_H(X) 在 GF(( 2^{128} )) 上是：

[ Y_i = (Y_{i-1} \oplus X_i) \cdot H \pmod{x^{128}+x^7+x^2+x+1} ]

致命误用：同一密钥下重复使用相同 nonce，两段密文 C1 ⊕ C2 = P1 ⊕ P2，同时可恢复认证密钥 H（Forbidden Attack，Joux 2006）。工程补偿：使用 SIV / nonce-random-128bit 或定期轮换密钥。

4.4.5 常见误用全谱#

• ECB 加密头像 → 泄露结构
• CBC + 固定 IV → 相同明文 = 相同密文
• GCM 重用 nonce → 灾难级
• Padding Oracle（POODLE、Lucky13）→ 逐字节解密
• MAC-then-Encrypt（SSL 历史）→ 应改为 Encrypt-then-MAC 或 AEAD

4.4.6 Python AEAD 示例#

1
from cryptography.hazmat.primitives.ciphers.aead import AESGCM, ChaCha20Poly1305
2
import os
3

4
# AES-GCM
5
key = AESGCM.generate_key(bit_length=256)
6
aesgcm = AESGCM(key)
7
nonce = os.urandom(12)
8
ct = aesgcm.encrypt(nonce, b"plain", b"aad")
9
pt = aesgcm.decrypt(nonce, ct, b"aad")
10

11
# ChaCha20-Poly1305（无 AES-NI 时推荐）
12
key2 = ChaCha20Poly1305.generate_key()
13
chacha = ChaCha20Poly1305(key2)
14
nonce2 = os.urandom(12)
15
ct2 = chacha.encrypt(nonce2, b"plain", b"aad")
16
pt2 = chacha.decrypt(nonce2, ct2, b"aad")

4.4.7 Padding Oracle 攻击演示#

CBC 解密：( P_i = D_K(C_i) \oplus C_{i-1} )。若服务端对 padding 错误返回不同响应，攻击者逐字节改 C_{i-1} 直至最后一字节 padding 正确（0x01）→ 恢复 D_K(C_i) 最后一字节 → 逐位推完整 block。

1
def padding_oracle_decrypt_block(iv, block, oracle):
2
    intermediate = bytearray(16)
3
    for pad in range(1, 17):
4
        for guess in range(256):
5
            mod_iv = bytearray(16)
6
            for k in range(pad - 1):
7
                mod_iv[16 - 1 - k] = intermediate[16 - 1 - k] ^ pad
8
            mod_iv[16 - pad] = guess
9
            if oracle(bytes(mod_iv), block):
10
                if pad == 1 and guess == iv[15]:
11
                    continue
12
                intermediate[16 - pad] = guess ^ pad
13
                break
14
    return bytes(a ^ b for a, b in zip(intermediate, iv))

4.5.1 RSA 加解密推导#

• 选素数 ( p, q )，( n = pq )
• 选 ( e ) 与 ( \varphi(n) = (p-1)(q-1) ) 互素（常取 65537）
• ( d = e^{-1} \mod \varphi(n) )
• 加密：( c = m^e \bmod n )
• 解密：( m = c^d \bmod n )

密钥长度推荐：当前 ( n \geq 3072 \text{ bit} )（NIST SP 800-57，等效 128-bit 安全）；2030 年后建议 4096-bit。

4.5.2 RSA-OAEP 填充#

直接 RSA 是确定性的（相同明文→相同密文，易被选择密文攻击），工程上须使用 OAEP：

1
seed (k0 bit 随机)
2
  │
3
  ▼
4
maskedDB = DB ⊕ MGF(seed, k - k0)
5
maskedSeed = seed ⊕ MGF(maskedDB, k0)
6
EM = 0x00 || maskedSeed || maskedDB
7
m_int = OS2IP(EM)
8
c = m_int^e mod n

其中 MGF 基于 SHA 构造。OAEP 提供 IND-CCA2 安全。

4.5.3 RSA 经典攻击#

4.5.4 手写 RSA（教学用途）#

1
import secrets
2
from sympy import isprime, nextprime
3

4
def gen_prime(bits):
5
    while True:
6
        n = secrets.randbits(bits) | (1 << (bits - 1)) | 1
7
        if isprime(n):
8
            return n
9

10
def gen_rsa(bits=2048):
11
    p = gen_prime(bits // 2)
12
    q = gen_prime(bits // 2)
13
    n = p * q
14
    phi = (p - 1) * (q - 1)
15
    e = 65537
16
    d = pow(e, -1, phi)
17
    return (n, e), (n, d)
18

19
pub, priv = gen_rsa(2048)
20
m = int.from_bytes(b"hello", 'big')
21
c = pow(m, pub[1], pub[0])
22
m2 = pow(c, priv[1], priv[0])
23
print(m2.to_bytes(5, 'big'))

4.5.5 椭圆曲线密码（ECC）#

曲线方程（Weierstrass 形式）：

[ y^2 = x^3 + ax + b \quad \text{over } \mathbb{F}_p ]

曲线上的点与”无穷远点” ( \mathcal{O} ) 构成 Abel 群。

1
def point_mul(k, P, curve):
2
    R = None      # 表示无穷远
3
    Q = P
4
    while k > 0:
5
        if k & 1:
6
            R = point_add(R, Q, curve)
7
        Q = point_double(Q, curve)
8
        k >>= 1
9
    return R

4.5.6 Diffie-Hellman / ECDH#

1
公共参数：大素数 p、生成元 g
2
Alice: a 随机, A = g^a mod p
3
Bob:   b 随机, B = g^b mod p
4
Alice 收到 B → 计算 K = B^a mod p
5
Bob 收到 A   → 计算 K = A^b mod p

中间人攻击（MitM）：需要认证 → TLS 证书、SSH 指纹、QR 码比较。

前向安全：一次性临时密钥（DHE / ECDHE）→ 私钥泄露也不能解过去的流量。

Logjam 回顾：512-bit DH 可被数域筛预计算攻破；2015 后浏览器强制 ≥ 1024，2020 后强制 ≥ 2048，TLS 1.3 禁用 DH < 2048 并推荐 ECDHE。

4.5.7 手写 DH#

1
import secrets
2
p = int("0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1..."[:770], 16)  # RFC 3526 2048-bit
3
g = 2
4
a = secrets.randbelow(p - 2) + 2
5
A = pow(g, a, p)
6
b = secrets.randbelow(p - 2) + 2
7
B = pow(g, b, p)
8
K_A = pow(B, a, p)
9
K_B = pow(A, b, p)
10
assert K_A == K_B

4.5.8 数字签名算法#

4.5.9 ECDSA 随机数事故#

ECDSA：对消息 ( m ) 签名

[ s = k^{-1} (H(m) + r \cdot d) \bmod n, \quad r = (kG).x ]

若 ( k ) 被重用两次（不同消息 ( m_1 \neq m_2 )），则：

[ d = \frac{s_1 H(m_2) - s_2 H(m_1)}{r(s_2 - s_1)} \bmod n ]

真实事故：

• Sony PS3：固件签名 k 恒为常数 → 私钥被 fail0verflow 泄露
• Android Wallet 2013：SecureRandom bug → 大量比特币被窃
• TinyBTC 等 IoT 设备的熵源不足

防御：Ed25519 / 确定性 ECDSA（RFC 6979）。

4.6.1 安全性质#

• 抗原像：给定 h(x)，难以找 x
• 抗第二原像：给定 x，难以找 x’ 使 h(x’)=h(x)
• 抗碰撞：难以找两个 x ≠ y 使 h(x)=h(y)（生日界 ( 2^{n/2} )）

4.6.2 主流算法#

4.6.3 Merkle-Damgård 构造#

1
Message → Padding → 分块 M_1, M_2, ..., M_t
2
                           │
3
IV → f(IV, M_1) = H_1 → f(H_1, M_2) = H_2 → ... → H_t
4
                                                  │
5
                                           附加长度 → Final Hash

其中压缩函数 ( f: {0,1}^n \times {0,1}^b \to {0,1}^n ) 是核心。

长度扩展攻击：给定 H(secret || m) 和 len(secret)，可计算 H(secret || m || pad || m2) 而无需 secret。受影响：MD5、SHA-1、SHA-2。不受影响：SHA-3、BLAKE2、HMAC。

4.6.4 Sponge 构造（SHA-3）#

1
absorb 阶段：
2
    S = 0
3
    for block in M:
4
        S[0:r] ^= block
5
        S = Keccak-f(S)
6

7
squeeze 阶段：
8
    out = S[0:r]
9
    while 需要更多:
10
        S = Keccak-f(S)
11
        out += S[0:r]

抗长度扩展（因 capacity c 部分不向外暴露）。

4.6.5 HMAC#

[ \text{HMAC}(K, m) = H\big( (K’ \oplus \text{opad}) ,|, H((K’ \oplus \text{ipad}) ,|, m) \big) ]

其中 ( K’ ) 是密钥的规整化（过长则先 hash 再 pad）。抗长度扩展、抗某些 H 内部弱点。

4.6.6 口令哈希（慢哈希）#

1
bcrypt / scrypt / Argon2  ← 推荐（加盐 + 迭代 + 内存硬）
2
PBKDF2-HMAC-SHA256        ← FIPS 合规但易被 GPU 加速
3
MD5 / SHA1 / SHA256       ← 裸 hash 用于口令 = 错误

推荐：Argon2id(password, salt, m=64MB, t=3, p=4)；bcrypt cost≥12；scrypt N=2^17。

为何内存硬：GPU 擅长 SIMD 但内存带宽相对有限；Argon2 要求大块内存访问，使攻击者无法利用成千上万 GPU 线程。

4.7.1 时序攻击#

1
# 不安全
2
if mac_received == hmac(key, msg):
3
    ...

比较字符串的 == 一旦遇到不匹配字节立即返回，攻击者可通过耗时差距逐字节猜 MAC。

修复：hmac.compare_digest（常量时间）。

1
import hmac as _hmac
2
if _hmac.compare_digest(mac_received, _hmac.new(key, msg, "sha256").digest()):
3
    ...

4.7.2 HMAC 抗攻击非形式化证明#

假设底层哈希 H 是 PRF（或接近）；HMAC 的两次嵌套（inner + outer）等价于 NMAC，而 NMAC 在压缩函数为 PRF 的情况下是可证明安全的 MAC（Bellare, 1996）。

4.8.1 证书链#

1
  根 CA (离线) ──签发──▶ 中间 CA ──签发──▶ 服务器证书
2
                                              │
3
                                     浏览器/OS 信任根 CA

• X.509 证书字段：Subject、Issuer、Public Key、SAN、Extensions
• 吊销：CRL（列表）/ OCSP（在线查询）/ OCSP Stapling
• CAA DNS 记录：限制哪家 CA 可签发本域证书
• CT（Certificate Transparency）：强制公开所有证书

4.8.2 Signal 端到端加密#

1
身份密钥 IK + 签名预共享密钥 SPK + 一次性预共享密钥 OPK
2
→ X3DH 协商根密钥
3
→ Double Ratchet 每条消息演进
4
→ 前向安全 + 后向安全

• X3DH：Alice 用 Bob 的 IK/SPK/OPK 做 4 次 DH → 合并为共享密钥
• Double Ratchet：DH Ratchet（每次换公钥）+ Chain Key Ratchet（KDF 链，每条消息推进）

4.8.3 TLS 1.3 密码套件#

1
TLS_AES_128_GCM_SHA256
2
TLS_AES_256_GCM_SHA384
3
TLS_CHACHA20_POLY1305_SHA256
4
TLS_AES_128_CCM_SHA256      (嵌入式)

注意此时套件只表示 对称算法 + 哈希，不再涵盖密钥交换（交换算法写在 supported_groups 扩展里）。

4.8.4 JWT 常见坑#

• alg: none 绕过（服务端未校验 alg）
• RS256 → HS256 混淆（服务端接受两种算法；攻击者用公钥当 HMAC 密钥）
• kid 注入（SQL / 路径遍历）
• jku / x5u 外连攻击者 JWKS
• 弱 secret（secret、123456）被 hashcat 秒破

4.8.5 HKDF 手写#

1
import hashlib, hmac
2

3
def hkdf_extract(salt: bytes, ikm: bytes, hash_name='sha256') -> bytes:
4
    if salt is None:
5
        salt = b'\x00' * hashlib.new(hash_name).digest_size
6
    return hmac.new(salt, ikm, hash_name).digest()
7

8
def hkdf_expand(prk: bytes, info: bytes, length: int, hash_name='sha256') -> bytes:
9
    hash_len = hashlib.new(hash_name).digest_size
10
    blocks = (length + hash_len - 1) // hash_len
11
    okm, t = b'', b''
12
    for i in range(1, blocks + 1):
13
        t = hmac.new(prk, t + info + bytes([i]), hash_name).digest()
14
        okm += t
15
    return okm[:length]

4.9.1 量子威胁#

• Shor 算法（1994）：多项式时间解整数分解与离散对数 → RSA/DH/ECC 全崩
• Grover 算法：把对称加密暴力搜索从 ( 2^n ) 降到 ( 2^{n/2} ) → AES-128 → 约 64-bit 强度；推荐 AES-256

4.9.2 NIST PQC 选中算法（FIPS 203/204/205, 2024）#

4.9.3 Kyber (ML-KEM) 核心#

基于 Module-LWE 困难问题：给定均匀 ( A )、短向量 ( s, e )，( t = A s + e )；已知 ( (A, t) ) 难以恢复 ( s )。

1
KeyGen:
2
    A ← random 3×3 polynomial matrix over R_q
3
    (s, e) ← small
4
    t = A s + e
5
    pk = (A, t), sk = s
6

7
Encaps(pk):
8
    m ← random 256-bit
9
    r, e1, e2 ← small
10
    u = A^T r + e1
11
    v = t^T r + e2 + ⌈q/2⌋ · Decode(m)
12
    return c=(u,v), K = H(m)
13

14
Decaps(sk, c):
15
    w = v - s^T u      # ≈ ⌈q/2⌋ · Decode(m) + small noise
16
    m' = Round(w)
17
    return K = H(m')

其中 ( R_q = \mathbb{Z}_q[X]/(X^{256}+1) )，( q = 3329 )。

4.9.4 工程部署#

• Chrome 116+ (2023)：TLS 中混合 X25519+Kyber768
• Cloudflare, Google：内部 RPC 已普遍启用 PQC
• OpenSSH 9.0+ (2022)：默认启用 sntrup761x25519-sha512@openssh.com 混合 KEM
• 签名尚未大规模部署，因尺寸较大（Dilithium5 签名 4627 B）

4.10.1 Heartbleed（已在 Ch02 详述）#

OpenSSL heartbeat 越界读——提醒 机密性依赖内存安全；后续 OpenBSD fork LibreSSL。

4.10.2 ROBOT (CVE-2017-6168 等)#

Bleichenbacher 1998 攻击的变体，现代 TLS 服务器实现对 RSA-PKCS#1 v1.5 填充错误响应差异仍然存在。攻击者构造选定密文，基于响应差异逐比特恢复会话密钥。修复：TLS 1.3 废弃 RSA 密钥交换。

4.10.3 DUHK (2017)#

Fortinet FortiOS 使用固定种子初始化 ANSI X9.31 RNG → VPN 会话密钥可被离线恢复。提醒：硬编码 RNG 种子 = 灾难。

4.10.4 Curveball (CVE-2020-0601)#

Windows crypt32.dll 在验证 ECC 签名时允许攻击者指定”生成元”而不校验 → 能伪造任意 CA 的签名。修复：强制生成元为曲线标准点。

4.10.5 Debian OpenSSL PRNG 缺陷 (2006-2008)#

Debian 维护者在审计时误删 MD_Update 调用 → 只有 PID 作为熵源 → 全球大量 SSH 密钥可枚举（约 32768 个）。教训：密码学代码不要随便”清理”。

参考答案要点#

1. 一般情形用 CRT：m^ed ≡ m (mod p) 和 m^ed ≡ m (mod q) 合并。
2. ( \varphi(n) = 96 \cdot 88 = 8448 )，( d = 7^{-1} \bmod 8448 ) 用扩欧。
3. m = iroot(c, 3)[0] （gmpy2.iroot）。
4. 会让两段密文 C1⊕C2 = P1⊕P2，且可恢复 GHASH 认证密钥 H。
5. TOTP = HOTP(K, ⌊T/30⌋)，HOTP 基于 HMAC-SHA1 + 动态截断。
6. Argon2 内存硬 → GPU 的高并发 ALU 优势失效；PBKDF2 可 GPU 高并发加速 1000x+。
7. k 由 H(prefix || m) 确定，不依赖 RNG → 不会因弱 RNG 重用 k；侧信道上减少一个泄露源。
8. 构造多项式 ( f(x) = (m_{high} + x)^3 - c ) 在 ( \bmod n ) 下解小根。
9. Derive-Secret(Handshake Secret, "c hs traffic", ClientHello..ServerHello) 得 CHTS；Derive-Secret(Master Secret, "c ap traffic", ClientHello..server Finished) 得 CATS。

4.14.1 零知识证明 (ZKP) 基础#

三性质：

• 完备性：诚实证明者可让诚实验证者确信真命题。
• 可靠性：作弊证明者无法以高概率让验证者相信假命题。
• 零知识性：验证者除了命题为真外学不到额外信息。

Schnorr 离散对数零知识证明（交互式）：

1
Prover 知道 x 使 y = g^x
2
  1. Prover: 选 r 随机，计算 t = g^r，发 t
3
  2. Verifier: 选挑战 c 随机
4
  3. Prover: s = r + c·x  (mod q)，发 s
5
  4. Verifier: 校验 g^s == t · y^c

Fiat-Shamir 启发式：把挑战 ( c ) 换成 ( c = H(g, y, t) ) 即可非交互化。

4.14.2 zk-SNARK / zk-STARK 对比#

4.14.3 同态加密#

• 部分同态（Paillier：加法）
• 近似同态（BFV / BGV / CKKS）
• 全同态（FHE，Gentry 2009）
• 开源库：Microsoft SEAL、OpenFHE、Zama TFHE-rs
• 典型应用：隐私 ML 推理、密文数据库查询

Paillier 加法同态 直观：

[ E(m_1) \cdot E(m_2) = E(m_1 + m_2), \quad E(m)^k = E(k m) ]

4.16.1 时序攻击#

• RSA：exp 过程中根据 d 每一位是否为 1 执行乘法 → 耗时差
• 对比：AES T-table 实现中数组访问命中不同缓存行 → CacheAttack

4.16.2 功耗分析#

• SPA (Simple Power Analysis)：单次曲线即区分 “乘” vs “平方”
• DPA (Differential Power Analysis)：统计分析，需要成千次测量

4.16.3 故障注入#

• 电压毛刺 / 时钟毛刺 → 让 CPU 跳过一条指令
• 经典：BellcoreAttack，在 RSA-CRT 中注入错误使 ( s_p ) 错误 → 恢复 ( p )

4.16.4 缓存侧信道#

• Flush+Reload：清 cache → 等受害者访问 → 重加载观察耗时
• Prime+Probe：填 cache → 受害者访问 → 重测
• 应用：KAISER / KPTI 防御 Meltdown 类攻击；RSA/AES 常数时间实现

4.16.5 防护#

• 常数时间算法（openssl 的 BN_consttime、libsodium）
• 硬件 HSM / SE（Secure Element）
• 随机化 masking、shuffling
• 指令级：crc32、aesenc 的常数时间硬件支持

4.17.1 熵源#

• 硬件：RDRAND、RDSEED（Intel）、ARMv8 RNDR、TPM RNG
• 软件：中断计时、输入事件、磁盘延迟
• Linux：getrandom(2) → /dev/urandom（2.6 后合并熵池，现代正确实践）

4.17.2 CSPRNG 构造#

• HMAC-DRBG / Hash-DRBG / CTR-DRBG（NIST SP 800-90A）
• ChaCha20-DRBG（Linux 5.17+）

4.17.3 事故教训#

• 已提 DUHK、Debian OpenSSL、Android SecureRandom
• CVE-2023-20900 VMware CSP RNG 默认种子 → 虚机镜像批量使用同一种子 → TLS 密钥可碰撞

4.18.1 SM4 Python 示例#

1
from gmssl import sm4
2
crypt_sm4 = sm4.CryptSM4()
3
key = b'0123456789ABCDEF'
4
crypt_sm4.set_key(key, sm4.SM4_ENCRYPT)
5
data = crypt_sm4.crypt_ecb(b'hello world12345')

生产不要用 ECB，改用 CBC / GCM 模式。

4.19.1 文件/数据库加密#

• 字段级：AES-256-GCM，每条记录独立 nonce + AAD=表名/列名
• 全盘：LUKS2 + Argon2id；BitLocker + TPM；FileVault
• KMS：AWS KMS / GCP Cloud KMS / HashiCorp Vault Transit
• 包裹密钥 (DEK + KEK)：数据用 DEK 加密，DEK 用 KEK（由 KMS 管理）加密

4.19.2 传输加密#

• Web：TLS 1.3（或强制 TLS 1.2 with PFS cipher suites）
• VPN：WireGuard > OpenVPN/IKEv2
• gRPC：mTLS + SPIFFE ID
• Kafka / Redis：支持 SASL_SSL 或 TLS over TCP

4.19.3 密钥管理#

• 切勿把密钥硬编码进代码
• 生产：KMS / HSM / Vault
• 开发：环境变量 + dotenv，注意不提交到 Git
• 轮换：定期 + 异常时强制；需要支持过渡期双密钥验证

4.19.4 密码学库选择#

历史经典 CVE 速查（密码学相关）#

教材#

• Jean-Philippe Aumasson，《Serious Cryptography》
• Ferguson, Schneier, Kohno，《Cryptography Engineering》
• Katz, Lindell，《Introduction to Modern Cryptography (3rd Ed.)》
• Dan Boneh, Victor Shoup，《A Graduate Course in Applied Cryptography》（免费在线）
• Handbook of Applied Cryptography（HAC，免费 PDF）

在线课程#

• Dan Boneh，Cryptography I / II（Coursera / Stanford）
• CryptoHack：https://cryptohack.org/
• Cryptopals Challenges：https://cryptopals.com/

标准 / 规范#

• NIST SP 800-57 Part 1 Rev. 5 - Key Management
• NIST FIPS 203 (ML-KEM), 204 (ML-DSA), 205 (SLH-DSA)
• RFC 5869 (HKDF), RFC 8446 (TLS 1.3), RFC 8439 (ChaCha20-Poly1305)
• RFC 6979 (Deterministic ECDSA)
• ISO/IEC 11770 - Key Management

论文 / 博客#

• Aviram et al., DROWN: Breaking TLS Using SSLv2, USENIX Security 2016
• Adrian et al., Imperfect Forward Secrecy (Logjam), CCS 2015
• Bernstein, Curve25519: new Diffie-Hellman speed records, PKC 2006
• Biryukov, Dinu, Khovratovich, Argon2, PHC winner 2015
• Real-World Cryptography（Wong, Manning 2021）
• Cryptography Dispatches（Filippo Valsorda newsletter）