数字签名完全指南

← 返回指南列表

数字签名完全指南

数字签名(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. 关键安全原则

  1. 保护私钥:永远不要暴露私钥,使用 HSM/KMS
  2. 随机性:确保 k(ECDSA/DSA)不可预测(RFC 6979)
  3. 哈希安全:使用 SHA-256 及以上,不要 MD5/SHA-1
  4. 填充模式:RSA 用 PSS,不要用 PKCS#1 v1.5 做新系统
  5. 时间绑定:签名包含时间戳/有效期,防重放
  6. 密钥轮换:定期生成新密钥对
  7. 监控量子威胁:关注后量子密码学的部署时间线

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