HMAC 消息认证码完全指南
HMAC(Keyed-Hash Message Authentication Code,带密钥的哈希消息认证码,RFC 2104)是最广泛使用的消息认证方案。它通过将密钥与哈希函数结合,为消息提供完整性和真实性保证,但不提供机密性。
HMAC 的三个核心功能:
- 完整性(Integrity):消息在传输中未被修改
- 真实性(Authenticity):消息确实来自持有密钥的一方
- 不可否认性有限:需双方共享密钥,因此非绝对
一、HMAC 原理
1.1 问题:为什么不直接用 H(key || message)?
直接拼接的问题:
PYTHON
import hashlib
# ❌ 错误方式(受长度扩展攻击)
key = b"secret"
message = b"transfer $1000 to Alice"
mac = hashlib.sha256(key + message).hexdigest()
# 攻击者可以:
# 1. 将原始消息视为 key || msg_1
# 2. 继续追加 new_message: key || msg_1 || pad || new_message
# 3. 用已知 hash 作为 IV 继续哈希
# 4. 伪造出 key || msg_1 || pad || new_message 的有效 MAC!
因此需要更安全的构造。
1.2 HMAC 的正式定义(RFC 2104)
CODE
HMAC(K, m) = H( (K XOR opad) || H( (K XOR ipad) || m ) )
其中:
H = 密码学哈希函数 (SHA-256, SHA-512, SHA-3 等)
K = 密钥
m = 消息
ipad = 0x36 重复 B 次 (inner padding)
opad = 0x5C 重复 B 次 (outer padding)
B = 哈希函数块大小 (字节)
对于 SHA-1/SHA-256: B = 64
对于 SHA-512: B = 128
对于 SHA3-256: B = 136
密钥处理:
如果 len(K) > B: 先 H(K),得到长度 = 哈希输出长度
如果 len(K) < B: 右侧补 0 到 B 字节
为什么选择 0x36 和 0x5C?
CODE
二进制:
0x36 = 0011 0110
0x5C = 0101 1100
两个字节的 Hamming 距离 = 4(4 位不同)
XOR 后 = 0x6A = 0110 1010
设计目标: 让内部和外部的密钥有显著差异
从而防止两类哈希输出之间的关系被利用
1.3 HMAC 结构图示
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
1.4 Python 实现(从原理出发)
PYTHON
import hashlib
def hmac_sha256(key, message):
"""HMAC-SHA256 的原理实现(仅用于学习)"""
block_size = 64 # SHA-256 块大小
# 1. 密钥预处理
if len(key) > block_size:
key = hashlib.sha256(key).digest() # 缩短
if len(key) < block_size:
key = key + b'\x00' * (block_size - len(key)) # 补 0
# 2. 生成内/外层 key
ipad = bytes([0x36]) * block_size
opad = bytes([0x5C]) * block_size
inner_key = bytes(a ^ b for a, b in zip(key, ipad))
outer_key = bytes(a ^ b for a, b in zip(key, opad))
# 3. 内层哈希: H(inner_key || message)
inner_hash = hashlib.sha256(inner_key + message).digest()
# 4. 外层哈希: H(outer_key || inner_hash)
final_hash = hashlib.sha256(outer_key + inner_hash).hexdigest()
return final_hash
# 测试
key = b"my_secret_key"
msg = b"Hello, HMAC!"
result1 = hmac_sha256(key, msg)
print(f"自定义实现: {result1}")
# 与标准库对比
import hmac
result2 = hmac.new(key, msg, hashlib.sha256).hexdigest()
print(f"标准库: {result2}")
print(f"相同? {result1 == result2}") # True
1.5 使用标准库(推荐)
PYTHON
import hmac
import hashlib
# 方式 1: one-shot
key = b"my_key"
message = b"important data"
mac = hmac.new(key, message, hashlib.sha256).hexdigest()
# 方式 2: 增量更新(大消息)
h = hmac.new(key, digestmod=hashlib.sha256)
h.update(b"part1")
h.update(b"part2")
h.update(b"part3")
mac = h.hexdigest()
# 方式 3: 使用 compare_digest(防时序攻击!)
received_mac = "some_hex_string"
expected_mac = hmac.new(key, message, hashlib.sha256).digest()
received_bytes = bytes.fromhex(received_mac)
# ✅ 正确:常量时间比较
if hmac.compare_digest(expected_mac, received_bytes):
print("MAC 验证通过")
else:
print("MAC 验证失败")
# ❌ 错误:普通比较(时序攻击)
# if expected_mac == received_bytes:
重要安全点:hmac.compare_digest 使用常量时间比较,无论匹配程度如何耗时都相同,防止时序攻击(攻击者通过比较时间逐字节猜出正确值)。
二、HMAC 的安全性分析
2.1 安全归约证明
HMAC 的安全性已被严格证明:如果 H 是抗碰撞哈希函数,则 HMAC 是安全的 PRF(伪随机函数)。
| 攻击模型 | HMAC 的安全性 |
|---|---|
| 选择消息攻击 (CMA) | ✅ 可证明安全 |
| 存在性伪造 | ❌ 不可行 |
| 长度扩展攻击 | ✅ 免疫(双重哈希结构) |
| 密钥恢复 | ❌ 不可行(除非暴力搜索密钥空间) |
2.2 为什么 HMAC 免疫长度扩展攻击?
CODE
H(key || m) 可被长度扩展攻击:
因为攻击者可以从哈希输出继续追加新消息
HMAC(K, m) = H( (K XOR opad) || H( (K XOR ipad) || m ) )
内层哈希 = H( (K XOR ipad) || m ) -- 攻击者不知道 K
外层哈希 = H( (K XOR opad) || inner_hash )
攻击者:
1. 无法构造内层(不知道 K XOR ipad)
2. 也无法从外层继续(不知道 K XOR opad)
3. 即使知道内层输出,外层需要重新从密钥开始
→ 长度扩展攻击对 HMAC 无效
2.3 历史上的攻击
| 攻击 | 发表年份 | 影响 |
|---|---|---|
| HMAC-MD5 部分密钥恢复 | 2007 | 需 2^100 计算量,理论意义 |
| HMAC-SHA1 差分分析 | 2009 | 需 2^154 计算量,不可行 |
| HMAC-SHA-256 分析 | 无实际攻击 | 目前无有效攻击 |
| HMAC-SHA3 分析 | 无已知攻击 | 新一代 |
结论:HMAC 与哈希函数的安全性紧密相关。只要哈希函数仍然安全,HMAC 就安全。
2.4 常见错误用法
| 错误做法 | 问题 |
|---|---|
| 密钥太短 | key < 16 字节 → 暴力搜索可能 |
| 密钥作为哈希输入 | hash(key + msg) → 长度扩展攻击 |
| 不用常量时间比较 | == 比较 → 时序攻击 |
| MD5 作为 H | HMAC-MD5 仍理论可用,但建议升级 |
| 重复使用密钥 | 不同协议/系统用相同 key → 跨协议攻击 |
| 密钥硬编码 | 泄露风险 |
| 无时间戳/序列号 | 重放攻击(replay attack) |
三、HMAC 的实际应用
3.1 API 认证(REST API 签名)
PYTHON
"""标准 REST API HMAC 认证流程
客户端:
1. 构造签名基串 (canonical string)
2. HMAC-SHA256(key, 签名串) = signature
3. 发送: Authorization: HMAC-SHA256 key_id:signature:timestamp
服务器:
1. 用 key_id 查找密钥
2. 检查 timestamp 在允许范围(防止重放)
3. 按相同规则重算 signature
4. 用 hmac.compare_digest 比较
"""
import hmac
import hashlib
import time
import base64
def client_sign_request(api_key, secret, method, path, body=b""):
"""客户端签名"""
timestamp = str(int(time.time()))
signing_string = f"{method}\n{path}\n{timestamp}\n".encode() + body
signature = hmac.new(
secret.encode(),
signing_string,
hashlib.sha256
).hexdigest()
return {
"Authorization": f"HMAC-SHA256 {api_key}:{signature}:{timestamp}"
}
def server_verify_request(auth_header, method, path, body=b"",
key_lookup=lambda kid: "stored_secret"):
"""服务器验证"""
# 解析 header
parts = auth_header.split(" ")
if len(parts) != 2 or parts[0] != "HMAC-SHA256":
return False
key_id, signature, timestamp = parts[1].split(":")
# 1. 检查时间窗口(± 5 分钟)
if abs(int(time.time()) - int(timestamp)) > 300:
return False
# 2. 查找密钥
secret = key_lookup(key_id)
# 3. 重算签名
signing_string = f"{method}\n{path}\n{timestamp}\n".encode() + body
expected = hmac.new(secret.encode(), signing_string, hashlib.sha256).digest()
received = bytes.fromhex(signature)
# 4. 常量时间比较
return hmac.compare_digest(expected, received)
3.2 JSON Web Token (JWT)
PYTHON
"""
JWT 结构: header.payload.signature
其中 signature = HMAC-SHA256(key, base64url(header) || "." || base64url(payload))
实际实现请用 pyjwt 等经过审计的库,不要自己写!
"""
import json
import base64
import hmac
import hashlib
def create_jwt(payload, secret):
"""❌ 仅用于学习!生产环境请用 PyJWT"""
header = {"alg": "HS256", "typ": "JWT"}
# Base64URL 编码
def b64url_encode(data):
return base64.urlsafe_b64encode(data).rstrip(b"=").decode()
header_b64 = b64url_encode(json.dumps(header, separators=(",", ":")).encode())
payload_b64 = b64url_encode(json.dumps(payload, separators=(",", ":")).encode())
signing_input = f"{header_b64}.{payload_b64}".encode()
# HMAC-SHA256 签名
signature = hmac.new(secret.encode(), signing_input, hashlib.sha256).digest()
signature_b64 = b64url_encode(signature)
return f"{header_b64}.{payload_b64}.{signature_b64}"
def verify_jwt(token, secret):
"""❌ 仅用于学习!生产环境请用 PyJWT"""
parts = token.split(".")
if len(parts) != 3:
return False
header_b64, payload_b64, signature_b64 = parts
# 验证签名
signing_input = f"{header_b64}.{payload_b64}".encode()
expected = hmac.new(secret.encode(), signing_input, hashlib.sha256).digest()
def b64url_decode(s):
padding = 4 - (len(s) % 4)
if padding != 4:
s += "=" * padding
return base64.urlsafe_b64decode(s)
received = b64url_decode(signature_b64)
if not hmac.compare_digest(expected, received):
return False
# 解析 payload
payload = json.loads(b64url_decode(payload_b64))
return payload
# 测试
token = create_jwt({"user": "alice", "role": "admin"}, "my_jwt_secret")
print(f"JWT: {token[:50]}...")
result = verify_jwt(token, "my_jwt_secret")
print(f"验证通过: {result}")
JWT 关键安全点:
- 永远不要让
alg: none通过验证 - 检查
exp(过期时间)、nbf(生效时间) - 密钥强度建议 ≥ 256 位
- 考虑轮换密钥(key rotation)
3.3 HOTP 和 TOTP(一次性密码)
HOTP(HMAC-based One-Time Password, RFC 4226):
CODE
HOTP(K, C) = Truncate(HMAC-SHA-1(K, C))
其中:
K = 共享密钥
C = 计数器 (8 字节大端)
Truncate = 取 31 位无符号整数 mod 10^D
D = 位数 (通常 6)
TOTP(Time-based One-Time Password, RFC 6238):
CODE
TOTP(K) = HOTP(K, T), 其中 T = floor(unix_time / 30)
即: 每 30 秒变化一次的 6 位数字
Google Authenticator / Microsoft Authenticator 基于此
PYTHON
import hmac
import hashlib
import time
import struct
import base64
def hotp(key, counter, digits=6):
"""HOTP 实现(RFC 4226)"""
counter_bytes = struct.pack(">Q", counter) # 8 字节大端
hmac_result = hmac.new(key, counter_bytes, hashlib.sha1).digest()
# Truncate 操作(动态截断)
offset = hmac_result[-1] & 0x0F # 取最后字节低 4 位
binary = (
(hmac_result[offset] & 0x7F) << 24 |
(hmac_result[offset + 1] & 0xFF) << 16 |
(hmac_result[offset + 2] & 0xFF) << 8 |
(hmac_result[offset + 3] & 0xFF)
)
return binary % (10 ** digits)
def totp(key, time_step=30, digits=6):
"""TOTP 实现(RFC 6238)"""
current_time = int(time.time())
counter = current_time // time_step
return hotp(key, counter, digits)
# 测试(Google Authenticator 使用 Base32 编码密钥)
key = base64.b32decode("GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ") # 示例密钥
code = totp(key)
print(f"当前 TOTP: {code:06d}") # 形如 123456
3.4 Webhook 签名验证
PYTHON
"""
Stripe / GitHub / Slack 等 Webhook 都使用 HMAC 签名验证
Stripe 示例:
Header: Stripe-Signature: t=timestamp,v1=signature
签名串 = timestamp + "." + request_body
signature = HMAC-SHA256(webhook_secret, 签名串)
"""
import hmac
import hashlib
import time
def verify_stripe_webhook(payload, sig_header, secret, tolerance=300):
"""验证 Stripe Webhook 签名"""
# 解析 header
items = dict(item.split("=") for item in sig_header.split(","))
timestamp = int(items["t"])
received_sig = items["v1"]
# 1. 检查时间窗口
if abs(int(time.time()) - timestamp) > tolerance:
return False
# 2. 重算签名
signing_input = f"{timestamp}.{payload}".encode()
expected = hmac.new(
secret.encode(),
signing_input,
hashlib.sha256
).hexdigest()
# 3. 常量时间比较
return hmac.compare_digest(expected, received_sig)
3.5 TLS 1.2 PRF(伪随机函数)
CODE
TLS 1.2 PRF(secret, label, seed) = P_hash(secret, label || seed)
其中 P_hash(secret, seed) 是基于 HMAC 的扩展函数:
A(0) = seed
A(1) = HMAC_hash(secret, A(0))
A(2) = HMAC_hash(secret, A(1))
...
P_hash = HMAC_hash(secret, A(1) || seed) ||
HMAC_hash(secret, A(2) || seed) ||
HMAC_hash(secret, A(3) || seed) ||
... (直到需要的字节数)
四、HMAC 性能与变种
4.1 不同哈希函数比较
| HMAC 变种 | 块大小 B | 密钥建议 | 输出 | 速度 | 状态 |
|---|---|---|---|---|---|
| HMAC-MD5 | 64 | 16+ 字节 | 128 位 | 最快 | ⚠️ 仅兼容 |
| HMAC-SHA1 | 64 | 20+ 字节 | 160 位 | 快 | ⚠️ 建议升级 |
| HMAC-SHA256 | 64 | 32+ 字节 | 256 位 | 中 | ✅ 推荐 |
| HMAC-SHA512 | 128 | 64+ 字节 | 512 位 | 中(64 位) | ✅ 高安全 |
| HMAC-SHA3-256 | 136 | 32+ 字节 | 256 位 | 中慢 | ✅ 新一代 |
| BLAKE2b-MAC | 128 | 任意 | 可变 | 最快 | ✅ 高性能 |
4.2 HMAC-SHA-512 vs HMAC-SHA-256
CODE
在 64 位 CPU 上:
SHA-512 使用 64 位字操作 → 实际上比 SHA-256 更快
HMAC-SHA-512(密钥长) 但安全性更高
建议:
通用 → HMAC-SHA256
高安全 / 64 位平台 → HMAC-SHA512
新协议 → HMAC-SHA3-256 或 BLAKE2-MAC
4.3 BLAKE2(更快的替代方案)
PYTHON
# BLAKE2 内置了密钥模式(不需要 HMAC 结构)
import hashlib
key = b"my_secret_key_32_bytes__________"
message = b"data"
# 直接用 key 参数(BLAKE2 设计时就考虑了 MAC)
mac = hashlib.blake2b(message, key=key, digest_size=32).hexdigest()
print(f"BLAKE2b-MAC: {mac}")
# 与 HMAC 安全性等价,但速度更快
4.4 Poly1305(用于 ChaCha20-Poly1305)
CODE
TLS 1.3 / SSH / WireGuard 使用:
ChaCha20-Poly1305 = 流密码 + Poly1305 MAC
Poly1305 不是基于哈希的 MAC(不是 HMAC)
而是基于多项式求值的 MAC
在 C 中实现约 2x 快于 AES-128-GCM(无 AES-NI 时)
五、HMAC 最佳实践清单
5.1 ✅ 密钥管理
PYTHON
# ✅ 生成强密钥
import os
key = os.urandom(32) # 256 位密钥(HMAC-SHA256 推荐)
# ✅ 使用密钥派生函数从口令派生密钥
from hashlib import pbkdf2_hmac
password = "user_password"
salt = os.urandom(16)
derived_key = pbkdf2_hmac("sha256", password.encode(), salt, 100000)
# ❌ 不要用短密钥或固定密钥
# key = b"123456" # 太短
# key = b"hardcoded_key" # 硬编码风险
5.2 ✅ 认证流程
PYTHON
import hmac
import hashlib
def verify_message(message, received_mac, key):
"""正确的验证流程"""
# 1. 验证时间戳/序列号(防重放)
# ...
# 2. 计算期望 MAC(字节,不是 hex 字符串)
expected_mac = hmac.new(key, message, hashlib.sha256).digest()
# 3. 常量时间比较
if not hmac.compare_digest(expected_mac, bytes.fromhex(received_mac)):
return False
return True
5.3 ✅ 防重放攻击
CODE
方案 1: 时间戳
客户端: 包含 timestamp
服务器: 拒绝超过 5 分钟窗口的请求
方案 2: 序列号 (nonce)
客户端: 递增序列号
服务器: 维护已使用的序列号,拒绝重复
方案 3: Challenge-Response
服务器: 发送随机 challenge
客户端: 用 HMAC(key, challenge || data) 签名
服务器: 验证
方案 4: 单次使用 token
服务器: 签发带过期时间的 token
客户端: 在请求中包含 token
5.4 ✅ 算法选择
CODE
推荐(当前标准):
HMAC-SHA256 通用首选
HMAC-SHA512 64 位平台 / 高安全需求
推荐(新系统):
HMAC-SHA3-256 新一代
BLAKE2b-MAC 高性能
接受(仅遗留):
HMAC-SHA1 仍安全但应升级
HMAC-MD5 理论上仍安全但不推荐新用途
不要:
自制 MAC 方案
简单的 hash(key + msg) 或 hash(msg + key)
5.5 ✅ 正确使用 HMAC 的代码模式
PYTHON
# ✅ 推荐模式 1:直接使用标准库
import hmac, hashlib
mac = hmac.new(key, msg, hashlib.sha256).hexdigest()
# ✅ 推荐模式 2:增量更新(大文件/流式数据)
h = hmac.new(key, digestmod=hashlib.sha256)
for chunk in iter(lambda: f.read(4096), b""):
h.update(chunk)
mac = h.hexdigest()
# ✅ 推荐模式 3:验证时
expected = hmac.new(key, msg, hashlib.sha256).digest()
if hmac.compare_digest(expected, received):
# 通过
pass
5.6 ❌ 常见陷阱
PYTHON
# ❌ 陷阱 1: 普通字符串比较
if mac == expected_mac: # 时序攻击风险
pass
# ❌ 陷阱 2: 太短的密钥
key = b"short" # 5 字节 < 16 字节推荐长度
# ❌ 陷阱 3: 将 key 放在哈希外
import hashlib
mac = hashlib.sha256(key + msg).hexdigest() # 长度扩展攻击!
# ❌ 陷阱 4: 只签名不防重放
# (无时间戳/序列号)
# ❌ 陷阱 5: 重用 key
# 多个协议/系统用相同 key
# ❌ 陷阱 6: 忽略认证而只做加密
# AES-CBC 加密但不验证 = Padding Oracle 攻击
六、HMAC vs 其他认证方案
6.1 对比
| 方案 | 对称/非对称 | 密钥 | 典型用途 |
|---|---|---|---|
| HMAC | 对称 | 共享密钥 | API 认证、JWT、Webhook、TLS |
| CBC-MAC | 对称 | 共享密钥 | 旧标准(金融、EMV) |
| CMAC | 对称 | 共享密钥 | 分组密码 MAC(AES-CMAC) |
| Poly1305 | 对称 | 临时密钥 | ChaCha20-Poly1305 认证 |
| GMAC | 对称 | 临时密钥 | AES-GCM 中的认证部分 |
| DSA/ECDSA | 非对称 | 公/私钥对 | 数字签名、证书 |
| RSA-PSS | 非对称 | 公/私钥对 | 数字签名、证书 |
| Ed25519 | 非对称 | 公/私钥对 | 现代签名标准 |
6.2 选择指南
CODE
你需要:
两方共享密钥 → HMAC(简单、快速、小输出)
公钥验证(任何人都可以验证)→ ECDSA/Ed25519/RSA
流密码/高性能 → Poly1305(配合 ChaCha20)
与分组密码绑定 → CMAC/GMAC
七、HMAC 常用工具速查
7.1 命令行
BASH
# OpenSSL
echo -n "message" | openssl dgst -sha256 -mac HMAC -macopt hexkey:6b6579
# 或者用 Python 一行命令
python3 -c "import hmac,hashlib;print(hmac.new(b'key',b'message',hashlib.sha256).hexdigest())"
# sha256sum + bash (不够安全的模式)
echo -n "keymessage" | sha256sum # ❌ 这不是 HMAC!
7.2 OpenSSL HMAC
BASH
# HMAC-SHA256
openssl dgst -sha256 -hmac "mykey" file.txt
# HMAC-SHA512
openssl dgst -sha512 -hmac "mykey" file.txt
# 十六进制 key
openssl dgst -sha256 -mac HMAC -macopt hexkey:deadbeef file.txt
# 支持的列表
openssl dgst -list | head -20
7.3 Python 标准库速查
PYTHON
import hmac, hashlib
# 生成 key
key = b"32_byte_secret_for_hmac_sha256__"
# HMAC-SHA256
h = hmac.new(key, b"message", hashlib.sha256)
h.hexdigest() # 十六进制
h.digest() # 字节
# HMAC-SHA512
h = hmac.new(key, b"message", hashlib.sha512)
# HMAC-SHA3-256
h = hmac.new(key, b"message", hashlib.sha3_256)
# 增量更新(流式)
h = hmac.new(key, digestmod=hashlib.sha256)
h.update(b"part1")
h.update(b"part2")
h.update(b"part3")
print(h.hexdigest())
# 安全比较
hmac.compare_digest(b"abc", b"abc") # True(常量时间)
# 注意: compare_digest 要求两个参数长度相同
# 攻击者仍可通过时间推断长度(但不是内容)
八、HMAC 在 TLS/SSL 中的角色
CODE
TLS 1.2 握手完成后:
主密钥 Master Secret
↓ PRF (基于 HMAC-SHA256 的伪随机函数)
会话密钥 Session Keys
├── 客户端写密钥 (AES)
├── 服务器写密钥 (AES)
├── 客户端写 IV
├── 服务器写 IV
├── 客户端 MAC 密钥 (HMAC)
└── 服务器 MAC 密钥 (HMAC)
TLS 1.3 简化:
主密钥 → HKDF (基于 HMAC 的 KDF)
↓
多个派生密钥 (用 AEAD 如 AES-GCM 替代 HMAC)
HKDF (RFC 5869) = HKDF-Extract + HKDF-Expand
HKDF-Extract = HMAC-Hash(salt, IKM)
HKDF-Expand(PRK, info, L) = T1 || T2 || ... || Tn
其中 T1 = HMAC-Hash(PRK, info || 0x01)
T2 = HMAC-Hash(PRK, T1 || info || 0x02)
...
总结
HMAC 是最可靠、最广泛使用的消息认证方案:
核心要点
- 公式:
HMAC(K, m) = H((K XOR opad) || H((K XOR ipad) || m)) - 安全: 只要哈希函数安全,HMAC 就安全(已证明)
- 免疫长度扩展攻击: 双重哈希结构天然防御
- 常量时间比较: 必须使用
hmac.compare_digest(防时序攻击) - 密钥足够长: ≥ 16 字节,推荐 32 字节(与哈希输出长度匹配)
典型应用
- API 认证(REST/Webhook 签名)
- JWT / JWS(HS256/HS384/HS512 算法)
- TOTP/HOTP(Google Authenticator、2FA)
- TLS/SSL(PRF、HKDF、历史上的 CBC+HMAC)
- 文件完整性(带密钥的校验和)
- Cookie 签名(Session 验证)
使用清单
✅ 用标准库 hmac / hashlib,不要自己实现
✅ 选择 HMAC-SHA256 或更强的哈希
✅ 密钥 ≥ 32 字节(256 位),来自 CSPRNG
✅ 验证用 hmac.compare_digest(常量时间)
✅ 防止重放攻击(时间戳 / 序列号 / challenge)
✅ 为不同用途使用不同密钥(密钥分离原则)
❌ 不要使用 hash(key || msg) 或 hash(msg || key)
❌ 不要在没有认证的情况下使用加密(加密 ≠ 认证)
❌ 不要硬编码密钥,使用密钥管理系统(KMS/HSM)