数字签名完全指南
数字签名(Digital Signature)是非对称密码学的核心应用之一。它通过私钥签名、公钥验证的方式,为数字消息提供类似于手写签名的不可伪造性、不可否认性和完整性保证。
数字签名 vs HMAC:
| 特性 | HMAC(对称) | 数字签名(非对称) |
|---|---|---|
| 密钥 | 共享密钥 | 公/私钥对 |
| 谁能验证 | 仅持有密钥的人 | 任何人(公钥公开) |
| 不可否认性 | ❌ (双方都可签名) | ✅ (只有私钥持有者能签名) |
| 速度 | 快(哈希级) | 慢(模幂/椭圆曲线运算) |
| 典型用途 | API 认证、JWT、Webhook | 证书、PDF/代码签名、区块链 |
一、数字签名的核心概念
1.1 数字签名的三大性质
CODE
1. 完整性 (Integrity)
消息在传输过程中未被修改
→ 签名与消息哈希绑定
2. 真实性 (Authenticity)
消息确实来自声称的发送者
→ 只有持有私钥的人才能产生有效签名
3. 不可否认性 (Non-repudiation)
发送者不能事后否认发送过该消息
→ 公钥公开,任何人可验证,私钥独有
1.2 通用签名流程
MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图
签名算法通用结构(哈希后签名):
CODE
签名: σ = Sign(private_key, H(m))
验证: Verify(public_key, H(m), σ) == True/False
为什么先哈希?
1. 非对称算法只能处理固定长度输入
RSA: m < n
ECDSA: 固定 256/384/512 位
2. 性能: 哈希比签名快得多
3. 安全: 防止某些代数攻击(如 RSA 可变性)
1.3 RSA-FDH(Full-Domain Hash)
最基础的 RSA 签名方案(教科书版本,仅用于学习):
CODE
签名: σ = h^d mod n (其中 h = H(m))
验证: σ^e mod n == h
问题:
1. 不使用填充 → 存在可变性攻击
2. 相同消息产生相同签名 → 无随机性
3. H(m) 必须小于 n
实际使用的 RSA 签名方案:
| 方案 | 标准 | 说明 | 状态 |
|---|---|---|---|
| RSA-PKCS#1 v1.5 | RFC 8017 | 确定性填充 | ⚠️ 仍广泛使用 |
| RSASSA-PSS | RFC 8017 | 概率性签名方案 | ✅ 推荐 |
二、RSA 签名(PKCS#1 v1.5 和 PSS)
2.1 RSA 密钥对
CODE
公钥: (n, e) - 公开
私钥: (n, d) - 保密,d = e^(-1) mod φ(n)
其中:
n = p × q (两个大质数的乘积)
e 通常 = 65537 (0x10001)
d = e^(-1) mod φ(n) = e^(-1) mod (p-1)(q-1)
2.2 RSA-PKCS#1 v1.5 签名(确定性)
CODE
签名:
1. 计算 EM = 0x00 || 0x01 || PS || 0x00 || T
其中 PS = 0xFF 重复,直到长度 = n - |T| - 3
T = ASN.1 编码的哈希算法标识 + 哈希值
2. σ = EM^d mod n
验证:
1. EM' = σ^e mod n
2. 检查 EM' 格式是否为: 0x00 || 0x01 || 0xFF* || 0x00 || T
3. 重新计算 T' = ASN.1(H(m))
4. 比较 T == T'
Python (PyCryptodome) 示例:
PYTHON
from Crypto.PublicKey import RSA
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
# 生成 2048 位 RSA 密钥
key = RSA.generate(2048)
private_key = key
public_key = key.publickey()
# 签名消息
message = b"Contract: sell 1000 shares at $50.00 signed by Alice"
h = SHA256.new(message)
signature = pkcs1_15.new(private_key).sign(h)
print(f"签名长度: {len(signature)} 字节 ({len(signature)*8} 位)")
# 验证签名
h = SHA256.new(message)
try:
pkcs1_15.new(public_key).verify(h, signature)
print("PKCS#1 v1.5 签名有效")
except (ValueError, TypeError):
print("签名无效")
PKCS#1 v1.5 的问题:
CODE
Bleichenbacher 攻击 (1998):
利用填充验证的错误信息差异
可构造伪造签名
Bleichenbacher'06 攻击:
针对签名验证的差分攻击
如果验证器只检查部分填充 → 可伪造签名
现实影响:
2014年: 多个 TLS 库被发现易受攻击
2017年: 某些 PDF 签名验证器被攻破
2.3 RSA-PSS(Probabilistic Signature Scheme,推荐)
RSA-PSS = RSA + PSS 填充(基于随机性的概率填充方案)
CODE
填充结构:
1. 生成随机 salt (16-32 字节)
2. M' = (0x00)*8 || H(m) || salt
3. H' = H(M') (消息哈希)
4. DB = PS || 0x01 || salt (PS = 0x00 填充)
5. dbMask = MGF(H', len(DB)) (MGF = 掩码生成函数)
6. maskedDB = DB XOR dbMask
7. EM = 0x00 || maskedDB || H' || 0xBC
签名: σ = EM^d mod n
特点:
✅ 可证明安全 (ROM 下)
✅ 每次签名不同(有随机性)
✅ 抗选择密文攻击
✅ 是当前 NIST 推荐方案
Python 示例:
PYTHON
from Crypto.PublicKey import RSA
from Crypto.Signature import pss
from Crypto.Hash import SHA256
# 生成密钥
key = RSA.generate(2048)
# PSS 签名
message = b"Important document"
h = SHA256.new(message)
signature = pss.new(key).sign(h)
print(f"PSS 签名 (每次不同): {signature.hex()[:40]}...")
# 第二次签名(结果不同,因为有随机 salt)
signature2 = pss.new(key).sign(h)
print(f"第二次签名: {signature2.hex()[:40]}...")
print(f"不同? {signature != signature2}") # True
# 验证
h = SHA256.new(message)
try:
pss.new(key.publickey()).verify(h, signature)
print("PSS 签名有效")
except (ValueError, TypeError):
print("签名无效")
使用 cryptography 库:
PYTHON
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import rsa, padding
# 生成私钥
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
# 序列化私钥(PEM 格式)
private_pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
# 序列化公钥
public_pem = private_key.public_key().public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
# 签名
message = b"Hello, Digital Signature!"
signature = private_key.sign(
message,
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)
# 验证
public_key = serialization.load_pem_public_key(public_pem)
try:
public_key.verify(
signature,
message,
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)
print("cryptography: PSS 签名有效")
except Exception as e:
print(f"签名无效: {e}")
三、DSA(Digital Signature Algorithm)
3.1 原理(基于离散对数问题)
CODE
公钥参数:
p = 大质数 (通常 2048 位)
q = 大质数 (通常 256 位), q | p-1
g = 1 < g < p, ord(g) = q 的生成元
私钥: x = 1 < x < q 的随机整数
公钥: y = g^x mod p
签名 (消息 m):
1. k = [1, q-1] 的随机整数(必须保密且唯一!)
2. r = (g^k mod p) mod q
3. s = (k^(-1) * (H(m) + x*r)) mod q
4. 签名 = (r, s)
验证 (消息 m, 签名 (r, s)):
1. 检查 0 < r < q, 0 < s < q
2. w = s^(-1) mod q
3. u1 = (H(m) * w) mod q
4. u2 = (r * w) mod q
5. v = ((g^u1 * y^u2) mod p) mod q
6. 如果 v == r → 签名有效
3.2 DSA 的关键问题
| 问题 | 说明 |
|---|---|
| k 的唯一性 | 同一 (x, k) 对不同消息签名 → 泄露 x |
| k 的随机性 | k 有偏 → 可恢复私钥(LLL 格基规约) |
| 性能 | 需要两次模幂运算(慢) |
| 长度 | 签名 = 2 × 256 位 = 512 位 |
| 标准 | 仅限 FIPS 186-4,建议升级到 ECDSA/Ed25519 |
k 重用攻击(经典!):
PYTHON
"""
如果同一 k 用于两个不同消息:
s1 = k^(-1) * (h1 + x*r) mod q
s2 = k^(-1) * (h2 + x*r) mod q
则:
s1 - s2 = k^(-1) * (h1 - h2) mod q
k = (h1 - h2) * (s1 - s2)^(-1) mod q
x = (s1*k - h1) * r^(-1) mod q
→ 私钥完全泄露!
"""
# 示例: 假设攻击者知道同一 k 被用于两个不同消息
# 这正是 PlayStation 3 被破解的原因(2010 年 fail0verflow 团队)
def recover_dsa_private_key(q, h1, h2, r, s1, s2):
"""从重用的 k 恢复 DSA 私钥 x"""
# k = (h1 - h2) / (s1 - s2) mod q
k = ((h1 - h2) * pow(s1 - s2, -1, q)) % q
# x = (s1*k - h1) / r mod q
x = ((s1 * k - h1) * pow(r, -1, q)) % q
return k, x
# 说明: 实际攻击中 ECDSA 同理,这是比特币/以太坊历史上多起钱包被盗的原因
3.3 Python 示例
PYTHON
from Crypto.PublicKey import DSA
from Crypto.Signature import DSS
from Crypto.Hash import SHA256
# 生成 DSA 密钥(2048 位)
key = DSA.generate(2048)
public_key = key.publickey()
# 签名
message = b"DSA signed message"
h = SHA256.new(message)
signer = DSS.new(key, 'fips-186-3')
signature = signer.sign(h)
# 验证
h = SHA256.new(message)
verifier = DSS.new(public_key, 'fips-186-3')
try:
verifier.verify(h, signature)
print("DSA 签名有效")
except ValueError:
print("DSA 签名无效")
四、ECDSA(椭圆曲线 DSA)
4.1 椭圆曲线基础
CODE
椭圆曲线方程(Weierstrass 形式):
y² = x³ + ax + b (mod p)
其中 a, b 定义曲线,p 是大质数(域大小)
曲线上的点: (x, y) 满足方程 + 无穷远点 O
运算:
点加: P + Q = R
倍点: 2P = P + P
标量乘: nP = P + P + ... + P (n 次)
困难问题(ECDLP - 椭圆曲线离散对数问题):
给定 P 和 Q = nP,求 n
经典算法复杂度: O(sqrt(n)) (Pollard rho)
量子算法复杂度: O(log n) (Shor)
4.2 常用曲线
| 曲线 | 位长 | 安全性(位) | 标准 | 用途 |
|---|---|---|---|---|
| secp256k1 | 256 | ~128 | de facto | Bitcoin / Ethereum |
| P-256 (secp256r1) | 256 | ~128 | NIST FIPS 186-4 | TLS / SSH / JWT |
| P-384 (secp384r1) | 384 | ~192 | NIST | 高安全 |
| P-521 (secp521r1) | 521 | ~256 | NIST | 最高安全 |
| Ed25519 | 255 | ~128 | RFC 8032 | 现代首选(见下一节) |
| secp256k1 特点 | a=0, b=7, p=2^256-2^32-977 |
4.3 ECDSA 签名算法
CODE
公钥参数:
曲线 E (定义 a, b, p, 基点 G, 阶 n)
私钥: d = [1, n-1] 的随机整数
公钥: Q = d * G (点乘)
签名 (消息 m):
1. k = [1, n-1] 的随机整数(必须保密且唯一!)
2. 计算 (x, y) = k * G
3. r = x mod n
4. s = (k^(-1) * (H(m) + d*r)) mod n
5. 签名 = (r, s)
验证 (消息 m, 签名 (r, s)):
1. 检查 0 < r < n, 0 < s < n
2. w = s^(-1) mod n
3. u1 = (H(m) * w) mod n
4. u2 = (r * w) mod n
5. (x, y) = u1*G + u2*Q
6. v = x mod n
7. 如果 v == r → 有效
与 DSA 的对应关系:
| DSA | ECDSA |
|---|---|
| 质数 p | 域大小 p |
| 子群阶 q | 曲线阶 n |
| 生成元 g | 基点 G |
| 私钥 x | 私钥 d |
| 公钥 y = g^x mod p | 公钥 Q = d*G |
| g^k mod p | k*G |
4.4 Python ECDSA 示例
PYTHON
# 使用 cryptography 库(推荐)
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
# 生成 P-256 密钥
private_key = ec.generate_private_key(ec.SECP256R1())
# 序列化
private_pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
# 签名
message = b"ECDSA signed message"
signature = private_key.sign(message, ec.ECDSA(hashes.SHA256()))
print(f"ECDSA 签名长度: {len(signature)} 字节 (DER 编码)")
# 验证
public_key = private_key.public_key()
try:
public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
print("ECDSA 签名有效")
except Exception as e:
print(f"签名无效: {e}")
# P-384 高安全性
private_key_384 = ec.generate_private_key(ec.SECP384R1())
sig_384 = private_key_384.sign(b"high security", ec.ECDSA(hashes.SHA384()))
public_key_384 = private_key_384.public_key()
public_key_384.verify(sig_384, b"high security", ec.ECDSA(hashes.SHA384()))
4.5 Bitcoin 的 secp256k1
PYTHON
# 使用 coincurve(优化的 secp256k1 库)
from coincurve import PrivateKey, PublicKey
import hashlib
# 生成私钥
priv = PrivateKey()
pub = priv.public_key
# Bitcoin 签名(Schnorr 或 ECDSA,取决于版本)
message = b"Bitcoin transaction data"
msg_hash = hashlib.sha256(hashlib.sha256(message).digest()).digest()
# 签名
signature = priv.sign(msg_hash)
print(f"secp256k1 签名: {signature.hex()}")
# 验证
assert pub.verify(signature, msg_hash)
print("secp256k1 签名有效")
4.6 ECDSA 安全性
| 攻击 | 说明 |
|---|---|
| k 重用 | 同一 k 用于不同消息 → 直接恢复私钥(历史多次发生) |
| k 有偏 | k 的高位有偏 → LLL 格基规约恢复私钥 |
| 弱随机数生成器 | Android SecureRandom 漏洞 → 2013 年比特币私钥泄露 |
| 侧信道攻击 | 功耗/时序泄露 → 恢复私钥 |
| 量子攻击 | Shor 算法可破解 (对所有基于离散对数的方案) |
防止 k 重用的方案:使用确定性 k(RFC 6979)
PYTHON
"""
RFC 6979: 确定性生成 ECDSA 中的 k
k = HMAC-SHA256(private_key, message_hash) mod n
→ 同一 (key, message) 对始终产生相同 k
→ 不同消息产生不同 k
→ 无需随机数生成器(避免 RNG 漏洞)
"""
# Python ecdsa 库自动使用 RFC 6979
from ecdsa import SigningKey, NIST256p
from ecdsa.util import sigencode_string
import hashlib
sk = SigningKey.generate(curve=NIST256p)
vk = sk.get_verifying_key()
message = b"test message"
# 自动使用 RFC 6979 生成确定性 k
signature = sk.sign(message, hashfunc=hashlib.sha256, sigencode=sigencode_string)
# 相同消息 + 相同密钥 = 相同签名(确定性)
signature2 = sk.sign(message, hashfunc=hashlib.sha256, sigencode=sigencode_string)
print(f"相同? {signature == signature2}") # True
# 验证
assert vk.verify(signature, message, hashfunc=hashlib.sha256)
print("RFC 6979 确定性 ECDSA 签名有效")
五、Ed25519(Edwards-curve Digital Signature Algorithm)
5.1 为什么是 Ed25519?
Ed25519(RFC 8032)是现代签名的事实标准,具有以下优势:
| 特性 | 说明 |
|---|---|
| 安全 | 无密钥相关攻击的历史记录 |
| 快速 | 无分支、无表查询,抗侧信道 |
| 小签名 | 64 字节签名 + 32 字节公钥 |
| 确定性 | 无需随机数(天然免疫 k 重用攻击) |
| 广泛支持 | OpenSSH 默认、TLS 1.3、Signal、WireGuard |
5.2 曲线参数
CODE
曲线: Twisted Edwards curve
-x² + y² = 1 + (-121665/121666)x²y² (mod p)
其中 p = 2^255 - 19
基点 B 的阶 l = 2^252 + 27742317777372353535851937790883648493
(即 252 位大质数)
5.3 签名算法
CODE
私钥: k = 32 字节随机数
公钥: A = a * B, 其中 a = SHA-512(k)[0:32] (经位调整)
签名 (消息 m):
1. r = SHA-512(SHA-512(k)[32:64] || m) (确定性)
2. R = r * B
3. h = SHA-512(enc(R) || enc(A) || m) mod l
4. s = (r + h * a) mod l
5. 签名 = (R, s) = 64 字节
验证 (消息 m, 签名 (R, s)):
1. h = SHA-512(enc(R) || enc(A) || m) mod l
2. 检查 s*B == R + h*A
核心创新:
CODE
1. 确定性 k (R = r*B 中的 r 由密钥和消息哈希生成)
→ 不需要随机数生成器
→ 天然免疫 k 重用攻击
2. 完整签名方程: sB = R + hA
→ 不存在 DSA/ECDSA 的 r = 0 问题
3. 双重小端编码设计 → 无分支实现
→ 抗定时攻击
→ 性能优秀
5.4 Python Ed25519 示例
PYTHON
# cryptography 库
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
Ed25519PrivateKey, Ed25519PublicKey
)
from cryptography.hazmat.primitives import serialization
# 生成密钥
private_key = Ed25519PrivateKey.generate()
public_key = private_key.public_key()
# 序列化
private_bytes = private_key.private_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PrivateFormat.Raw,
encryption_algorithm=serialization.NoEncryption()
)
public_bytes = public_key.public_bytes(
encoding=serialization.Encoding.Raw,
format=serialization.PublicFormat.Raw
)
print(f"私钥长度: {len(private_bytes)} 字节") # 32
print(f"公钥长度: {len(public_bytes)} 字节") # 32
# 签名
message = b"Hello, Ed25519!"
signature = private_key.sign(message)
print(f"签名长度: {len(signature)} 字节") # 64
# 验证
try:
public_key.verify(signature, message)
print("Ed25519 签名有效")
except Exception as e:
print(f"签名无效: {e}")
# 从字节加载
loaded_private = Ed25519PrivateKey.from_private_bytes(private_bytes)
loaded_public = Ed25519PublicKey.from_public_bytes(public_bytes)
signature2 = loaded_private.sign(message)
loaded_public.verify(signature2, message)
# SSH 格式(用于 SSH 配置)
ssh_pub = public_key.public_bytes(
encoding=serialization.Encoding.OpenSSH,
format=serialization.PublicFormat.OpenSSH
)
print(f"SSH 公钥: {ssh_pub.decode()}")
# ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA...
PyNaCl 库(libsodium 绑定):
PYTHON
import nacl.signing
import nacl.encoding
# 生成签名密钥对
signing_key = nacl.signing.SigningKey.generate()
verify_key = signing_key.verify_key
# 签名(自动附加消息)
signed = signing_key.sign(b"important message")
# signed.message + signed.signature
# 验证(会抛出异常如果无效)
try:
original = verify_key.verify(signed)
print(f"PyNaCl 验证成功: {original}")
except nacl.exceptions.BadSignatureError:
print("PyNaCl 验证失败")
5.5 Ed25519 的变体
| 变种 | 曲线 | 安全性 | 说明 |
|---|---|---|---|
| Ed25519 | Curve25519 (Edwards) | ~128 位 | 标准 |
| Ed448 | Curve448-Goldilocks | ~224 位 | 更高安全性 |
| Ed25519ph | Ed25519 | ~128 位 | 预哈希版(pre-hashed,用于大消息) |
| Ed25519ctx | Ed25519 | ~128 位 | 带上下文(domain separation) |
六、各种签名算法对比
| 算法 | 密钥长度 | 签名长度 | 签名速度 | 验证速度 | 安全性 | 推荐 |
|---|---|---|---|---|---|---|
| RSA-2048 PKCS#1 | 2048 位 (256 B) | 256 B | 慢 | 快 | ⚠️ | 兼容 |
| RSA-2048 PSS | 2048 位 | 256 B | 慢 | 快 | ✅ | 推荐 |
| RSA-4096 PSS | 4096 位 (512 B) | 512 B | 很慢 | 中 | ✅ | 高安全 |
| DSA-2048 | 2048 位 | 64 B | 慢 | 慢 | ⚠️ | 不推荐 |
| ECDSA P-256 | 256 位 (32 B) | ~70 B (DER) / 64 B (raw) | 中 | 中 | ✅ | 标准 |
| ECDSA P-384 | 384 位 (48 B) | ~100 B / 96 B | 慢 | 慢 | ✅ | 高安全 |
| secp256k1 | 256 位 (32 B) | 64 B | 中 | 中 | ✅ | 区块链 |
| Ed25519 | 256 位 (32 B) | 64 B | 快 | 快 | ✅ | 现代首选 |
| Ed448 | 448 位 (57 B) | 114 B | 中 | 中 | ✅ | 极高安全 |
七、签名在实际系统中的应用
7.1 X.509 证书(TLS/SSL)
CODE
证书结构 (简化):
1. 主体信息: 域名、组织、有效期
2. 主体公钥: 服务器 RSA/ECDSA/Ed25519 公钥
3. 签名算法: sha256WithRSAEncryption / ecdsa-with-SHA256 / Ed25519
4. 颁发者信息: CA 名称
5. CA 签名: 用 CA 私钥签名(TBS 部分)
证书链验证:
服务器证书 → 中级 CA → 根 CA → 信任锚
OpenSSL 命令:
BASH
# 查看证书信息
openssl x509 -in certificate.pem -text -noout
# 查看签名算法
openssl x509 -in certificate.pem -noout -text | grep "Signature Algorithm"
# 生成 CSR (Certificate Signing Request)
openssl req -new -key private.key -out request.csr
# 自签名证书(测试用)
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365
# Ed25519 证书(现代)
openssl genpkey -algorithm ed25519 -out ed25519.key
openssl req -new -key ed25519.key -out ed25519.csr
7.2 SSH 密钥
BASH
# 生成 Ed25519 SSH 密钥(推荐)
ssh-keygen -t ed25519 -C "user@host"
# 生成 RSA 4096 位密钥(兼容)
ssh-keygen -t rsa -b 4096
# 查看公钥指纹
ssh-keygen -lf ~/.ssh/id_ed25519.pub
# 验证签名(手动)
echo "test" | ssh-keygen -Y sign -f ~/.ssh/id_ed25519 -n file
7.3 JWT 中的签名算法
JSON
{
"alg": "RS256", // RSA-PKCS1-v1_5 + SHA-256
"typ": "JWT"
}
可选算法:
HS256 = HMAC-SHA256 (对称, 不是数字签名)
RS256 = RSA-PKCS#1 v1.5 + SHA-256
RS384 = RSA-PKCS#1 v1.5 + SHA-384
RS512 = RSA-PKCS#1 v1.5 + SHA-512
PS256 = RSA-PSS + SHA-256 (推荐)
ES256 = ECDSA P-256 + SHA-256
ES384 = ECDSA P-384 + SHA-384
EdDSA = Ed25519 (现代)
Python JWT 示例:
PYTHON
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization
import jwt # PyJWT
# 生成 RSA 密钥
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
public_key = private_key.public_key()
# 序列化
private_pem = private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
)
public_pem = public_key.public_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PublicFormat.SubjectPublicKeyInfo
)
# RS256 签名 (RSA PKCS#1 v1.5)
token = jwt.encode({"user": "alice"}, private_pem, algorithm="RS256")
print(f"JWT (RS256): {token[:60]}...")
# 验证
payload = jwt.decode(token, public_pem, algorithms=["RS256"])
print(f"Payload: {payload}")
# PS256 签名 (RSA-PSS, 推荐)
token_pss = jwt.encode({"user": "alice"}, private_pem, algorithm="PS256")
payload = jwt.decode(token_pss, public_pem, algorithms=["PS256"])
# Ed25519 (需要 PyJWT >= 2.4)
# from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
# ed_key = Ed25519PrivateKey.generate()
# token_eddsa = jwt.encode({"user": "alice"}, ed_key, algorithm="EdDSA")
7.4 PDF / 代码签名
BASH
# PDF 签名需要专用工具 (如 Adobe Acrobat, pdfbox)
# OpenSSL 代码签名 (signtool 等效)
openssl smime -sign -in file.txt -text -out signed.p7s \
-signer cert.pem -inkey private.key
# Authenticode (Windows .exe 签名)
signtool sign /f cert.pfx /p password /tr http://timestamp.digicert.com file.exe
# macOS 代码签名
codesign -s "Developer ID" app.app
7.5 Git 提交签名
BASH
# 配置签名密钥
git config --global user.signingkey <key_id>
# 签名提交
git commit -S -m "Signed commit"
# 签名标签
git tag -s v1.0 -m "Release 1.0"
# 验证签名
git verify-commit <commit_hash>
git verify-tag v1.0
# 查看带签名的提交
git log --show-signature
八、签名方案的常见攻击与防御
8.1 攻击类型
| 攻击 | 说明 | 防御 |
|---|---|---|
| 长度扩展 | 针对 H(key\ | msg) |
| k 重用 (ECDSA/DSA) | 同一 k 签不同消息 | RFC 6979 确定性 k |
| Bleichenbacher | PKCS#1 v1.5 填充 oracle | 用 PSS 替代 |
| 选择消息攻击 | 请求签名特定消息 | 签名前加上前缀/随机化 |
| 碰撞攻击 | 哈希碰撞 → 相同签名 | SHA-256 及以上 |
| 量子攻击 | Shor 算法 | 后量子算法 (CRYSTALS-Dilithium) |
| 弱 RNG | 随机数有偏 | 使用 CSPRNG(如 /dev/urandom) |
8.2 防御清单
CODE
✅ 选择正确算法:
RSA-2048+ PSS(兼容) 或 Ed25519(现代首选) 或 ECDSA P-256
✅ 使用安全哈希:
SHA-256 及以上(不要用 MD5、SHA-1)
✅ 保护私钥:
硬件安全模块 (HSM)
密钥管理系统 (KMS)
专用加密协处理器 (如 Apple Secure Enclave)
✅ 防止重放:
包含时间戳/序列号/challenge
✅ 正确验证:
常量时间比较
严格检查签名格式
验证时间戳和证书链
✅ 密钥轮换:
定期生成新密钥对
保留旧公钥用于验证历史签名
九、量子抗性签名
9.1 Shor 算法的威胁
CODE
经典计算 vs 量子计算:
大整数分解 (RSA): O(2^(n/2)) → O(n^3)
离散对数 (DSA/ECDSA): O(2^(n/2)) → O(n^3)
影响:
RSA-2048 → 2000 万逻辑量子比特可破
ECDSA-256 → 2500 万逻辑量子比特可破
Ed25519 → 同等可破
时间估计:
2030s: 可能出现可用的 Shor 算法量子计算机
过渡: NIST 已标准化后量子算法 (2024)
9.2 NIST 后量子签名标准(2024)
| 算法 | 类型 | 公钥 | 签名 | 安全性 |
|---|---|---|---|---|
| CRYSTALS-Dilithium | 格密码 | 1312 B | 2420 B | AES-128 |
| CRYSTALS-Dilithium 5 | 格密码 | 2592 B | 4627 B | AES-256 |
| FALCON | 格密码 (NTRU) | 897 B | 690 B | AES-128 |
| SPHINCS+ | 哈希基 | 32 B | ~8 KB | AES-128 |
应用:
CODE
TLS 1.3 已开始部署 X25519 + Kyber768 密钥协商
→ 密钥交换后量子化
签名的后量子化正在进行中:
OpenSSL 3.2+ 支持 Dilithium
Google/Mozilla 正在试验
9.3 混合签名方案
CODE
过渡方案:
传统签名 || 后量子签名
(例如: Ed25519 || Dilithium)
确保:
如果 Ed25519 被量子破解 → Dilithium 仍安全
如果 Dilithium 有缺陷 → Ed25519 仍安全
十、签名在 CTF 和密码学挑战中的应用
10.1 常见题目类型
| 题目类型 | 考察点 |
|---|---|
| RSA 共模攻击 | 相同 n, 不同 e |
| RSA 低加密指数 | e=3, m^e < n |
| ECDSA k 重用 | 同一 k 签不同消息 → 恢复私钥 |
| k 有偏攻击 | LLL 格基规约 |
| 伪造签名 | 利用填充/哈希漏洞 |
| 签名长度扩展 | 基于哈希的签名 |
| 盲签名 | Chaum 盲签名 |
| 环签名 | Monero 等隐私币 |
10.2 ECDSA k 重用攻击实战
PYTHON
"""
从两个使用相同 k 的 ECDSA 签名恢复私钥
已知:
曲线阶 n
消息哈希 h1, h2
签名 (r, s1), (r, s2) (r 相同 = k 相同的证据)
求: 私钥 d
"""
from ecdsa import NIST256p
def recover_ecdsa_private_key(n, h1, h2, r, s1, s2):
# k = (h1 - h2) / (s1 - s2) mod n
ds = (s1 - s2) % n
dh = (h1 - h2) % n
k = (dh * pow(ds, -1, n)) % n
# d = (s1*k - h1) / r mod n
d = ((s1 * k - h1) * pow(r, -1, n)) % n
return d, k
# 模拟攻击者场景
# 假设我们有两个用相同 k 签名的消息
from ecdsa import SigningKey, NIST256p
import hashlib
# 生成测试密钥对
sk = SigningKey.generate(curve=NIST256p)
vk = sk.get_verifying_key()
# 手动复用 k(模拟漏洞实现)
import random
curve = NIST256p
n = curve.order
d = sk.privkey.secret_multiplier
def sign_with_fixed_k(m, k):
"""漏洞实现: 使用固定 k"""
r = (k * curve.generator).x() % n
h = int(hashlib.sha256(m).hexdigest(), 16)
s = (pow(k, -1, n) * (h + d * r)) % n
return (r, s)
# 使用同一 k 签两个消息
k = random.randrange(1, n)
msg1 = b"message1"
msg2 = b"message2"
h1 = int(hashlib.sha256(msg1).hexdigest(), 16)
h2 = int(hashlib.sha256(msg2).hexdigest(), 16)
r, s1 = sign_with_fixed_k(msg1, k)
_, s2 = sign_with_fixed_k(msg2, k) # r 相同
# 攻击者视角: 已知 r, s1, s2, h1, h2 → 恢复 d
recovered_d, recovered_k = recover_ecdsa_private_key(n, h1, h2, r, s1, s2)
print(f"原始私钥 d: {d}")
print(f"恢复的私钥 d: {recovered_d}")
print(f"匹配? {d == recovered_d}") # True!
总结
数字签名是信任的数字基础,核心要点:
1. 算法选择
| 场景 | 推荐算法 | 理由 |
|---|---|---|
| 通用签名 | Ed25519 | 快速、安全、小签名 |
| 需要 FIPS 合规 | ECDSA P-256 或 RSA-2048 PSS | NIST 标准 |
| 区块链 | secp256k1 | Bitcoin/Ethereum 生态 |
| 高安全性 | Ed448 或 ECDSA P-384 | 量子前安全裕度 |
| 长期安全 (10+ 年) | Dilithium (后量子) | 抗量子攻击 |
| 兼容遗留系统 | RSA-2048 PKCS#1 v1.5 | 过渡方案 |
2. 关键安全原则
- 保护私钥:永远不要暴露私钥,使用 HSM/KMS
- 随机性:确保 k(ECDSA/DSA)不可预测(RFC 6979)
- 哈希安全:使用 SHA-256 及以上,不要 MD5/SHA-1
- 填充模式:RSA 用 PSS,不要用 PKCS#1 v1.5 做新系统
- 时间绑定:签名包含时间戳/有效期,防重放
- 密钥轮换:定期生成新密钥对
- 监控量子威胁:关注后量子密码学的部署时间线
3. 数字签名 vs 其他认证手段
CODE
机密性 完整性 真实性 不可否认性 多方验证
HMAC ❌ ✅ ✅ ❌ ❌ (需共享密钥)
RSA/ECDSA ❌* ✅ ✅ ✅ ✅ (公钥公开)
AES-GCM ✅ ✅ ✅ ❌ ❌ (需共享密钥)
* 可配合加密实现机密性
选择指南:
需要多方验证 → 数字签名
点对点认证 → HMAC (更简单快速)
需要加密 → AEAD (AES-GCM / ChaCha20-Poly1305)
混合使用 → 签名 + 加密 (先签名后加密)
4. 实战提示
CODE
命令行工具:
openssl pkeyutl -sign/-verify # RSA/ECDSA
ssh-keygen -Y sign/verify # SSH 签名
gpg --sign/--verify # OpenPGP
minisign/signify # 轻量签名
Python 库:
cryptography (推荐) - 现代 API, Ed25519 支持
PyCryptodome - RSA/DSA/ECDSA
PyJWT - JWT 签名
coincurve - 优化 secp256k1
JavaScript:
Web Crypto API (浏览器内置)
node:crypto (Node.js)
tweetnacl / libsodium.js