1
签名：s = H(m)^d mod n
2
验证：H(m) = s^e mod n
3

4
其中：
5
- d 是私钥指数
6
- e 是公钥指数（通常为 65537）
7
- n 是模数（两个大素数的乘积）

1
# Python: RSA-PSS 签名（推荐方式）
2
from cryptography.hazmat.primitives.asymmetric import rsa, padding
3
from cryptography.hazmat.primitives import hashes
4

5
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
6
message = b"Important document"
7

8
# 签名
9
signature = private_key.sign(
10
    message,
11
    padding.PSS(
12
        mgf=padding.MGF1(hashes.SHA256()),
13
        salt_length=padding.PSS.MAX_LENGTH
14
    ),
15
    hashes.SHA256()
16
)
17

18
# 验证
19
public_key = private_key.public_key()
20
public_key.verify(signature, message, padding.PSS(
21
    mgf=padding.MGF1(hashes.SHA256()),
22
    salt_length=padding.PSS.MAX_LENGTH
23
), hashes.SHA256())

1
// Go: RSA-PSS 签名
2
privateKey, _ := rsa.GenerateKey(rand.Reader, 2048)
3
hashed := sha256.Sum256([]byte("Important document"))
4
sig, _ := rsa.SignPSS(rand.Reader, privateKey, crypto.SHA256, hashed[:], nil)
5
err := rsa.VerifyPSS(&privateKey.PublicKey, crypto.SHA256, hashed[:], sig, nil)

1
输入：私钥 d，消息 m
2
1. 计算哈希 e = H(m)
3
2. 生成随机数 k（1 ≤ k ≤ n-1）
4
3. 计算曲线点 (x₁, y₁) = k · G
5
4. 计算 r = x₁ mod n（若 r = 0 则重新选 k）
6
5. 计算 s = k⁻¹(e + r·d) mod n（若 s = 0 则重新选 k）
7
6. 输出签名 (r, s)

1
输入：公钥 Q，消息 m，签名 (r, s)
2
1. 验证 r, s ∈ [1, n-1]
3
2. 计算哈希 e = H(m)
4
3. 计算 w = s⁻¹ mod n
5
4. 计算 u₁ = e·w mod n，u₂ = r·w mod n
6
5. 计算曲线点 (x₁, y₁) = u₁·G + u₂·Q
7
6. 验证 r ≡ x₁ mod n

1
签名1：(r, s₁)，其中 s₁ = k⁻¹(e₁ + r·d) mod n
2
签名2：(r, s₂)，其中 s₂ = k⁻¹(e₂ + r·d) mod n
3

4
k 相同 → r 相同，所以：
5
k = (e₁ - e₂) / (s₁ - s₂) mod n
6
d = (s₁·k - e₁) / r mod n    ← 私钥恢复！

1
# 演示：k 值重复导致私钥泄露
2
def recover_private_key(e1, e2, s1, s2, r, n):
3
    """从两个使用相同 k 的签名中恢复私钥"""
4
    k = ((e1 - e2) * pow(s1 - s2, -1, n)) % n
5
    d = ((s1 * k - e1) * pow(r, -1, n)) % n
6
    return d

1
k = HMAC_DRBG(private_key, message_hash)
2

3
同一消息 + 同一私钥 → 同一 k → 同一签名

1
# Python: 确定性 ECDSA 签名（RFC 6979）
2
from cryptography.hazmat.primitives.asymmetric.ec import (
3
    generate_private_key, ECDSA, SECP256R1
4
)
5
from cryptography.hazmat.primitives import hashes
6

7
private_key = generate_private_key(SECP256R1())
8
message = b"Important document"
9
# cryptography 库默认使用确定性 k（RFC 6979）
10
signature = private_key.sign(message, ECDSA(hashes.SHA256()))
11
public_key = private_key.public_key()
12
public_key.verify(signature, message, ECDSA(hashes.SHA256()))

1
// Java: ECDSA 签名
2
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC");
3
kpg.initialize(256); // secp256r1
4
KeyPair kp = kpg.generateKeyPair();
5

6
Signature sig = Signature.getInstance("SHA256withECDSA");
7
sig.initSign(kp.getPrivate());
8
sig.update("Important document".getBytes());
9
byte[] signature = sig.sign();
10

11
sig.initVerify(kp.getPublic());
12
sig.update("Important document".getBytes());
13
boolean valid = sig.verify(signature);

1
1. 私钥扩展：hash(key) → (prefix, public_key_scalar)
2
2. 确定性 nonce：r = H(prefix || message)  ← 不需要随机数！
3
3. 签名计算：
4
   R = r · B（B 是基点）
5
   S = (r + H(R || A || message) · a) mod l
6
4. 输出签名 (R, S)，共 64 字节

1
# Python: Ed25519 签名（推荐）
2
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
3

4
private_key = Ed25519PrivateKey.generate()
5
message = b"Important document"
6
signature = private_key.sign(message)
7
public_key = private_key.public_key()
8
public_key.verify(signature, message)

1
// Go: Ed25519 签名
2
publicKey, privateKey, _ := ed25519.GenerateKey(nil)
3
message := []byte("Important document")
4
signature := ed25519.Sign(privateKey, message)
5
valid := ed25519.Verify(publicKey, message, signature)

1
// Java: Ed25519 签名（需要 Java 15+）
2
KeyPairGenerator kpg = KeyPairGenerator.getInstance("Ed25519");
3
KeyPair kp = kpg.generateKeyPair();
4
Signature sig = Signature.getInstance("Ed25519");
5
sig.initSign(kp.getPrivate());
6
sig.update("Important document".getBytes());
7
byte[] signature = sig.sign();

1
# 生成 Ed25519 SSH 密钥
2
ssh-keygen -t ed25519 -C "your@email.com"
3

4
# Git 使用 Ed25519 签名 commit
5
git config user.signingkey ssh-ed25519 AAAAC3NzaC1lZDI1NTE5...
6
git commit -S -m "signed commit"

1
# Python: 使用 Ed25519 签名 JWT
2
import json, base64
3
from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
4

5
private_key = Ed25519PrivateKey.generate()
6

7
def base64url(data: bytes) -> str:
8
    return base64.urlsafe_b64encode(data).rstrip(b'=').decode()
9

10
header = base64url(json.dumps({"alg": "EdDSA", "typ": "JWT"}).encode())
11
payload = base64url(json.dumps({"sub": "user123", "exp": 1735689600}).encode())
12
signing_input = f"{header}.{payload}".encode()
13
signature = private_key.sign(signing_input)
14
jwt_token = f"{header}.{payload}.{base64url(signature)}"

1
# ECDSA k 值重用攻击演示
2
def ecdsa_k_reuse_attack(e1, e2, s1, s2, r, n):
3
    """当两个 ECDSA 签名使用相同的 k 值时，恢复私钥"""
4
    k = ((e1 - e2) * pow(s1 - s2, -1, n)) % n
5
    d = ((s1 * k - e1) * pow(r, -1, n)) % n
6
    return d, k

1
# 不安全的比较（时序泄露）
2
def verify_unsafe(computed, received):
3
    return computed == received  # 逐字节比较，不等时立即返回
4

5
# 安全的比较（常数时间）
6
import hmac
7
def verify_safe(computed, received):
8
    return hmac.compare_digest(computed, received)  # 总是比较全部字节

1
正常：s = s_p · q · q_inv + s_q · p · p_inv  mod n
2
故障：s' = s_p' · q · q_inv + s_q · p · p_inv  mod n
3
gcd(s - s', n) = p  ← 因子分解！

1
from cryptography.hazmat.primitives.asymmetric import rsa, padding
2
from cryptography.hazmat.primitives import hashes
3

4
# 生成 RSA-2048 密钥对
5
private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048)
6
public_key = private_key.public_key()
7

8
message = b"Important document to sign"
9

10
# RSA-PSS 签名
11
signature = private_key.sign(
12
    message,
13
    padding.PSS(
14
        mgf=padding.MGF1(hashes.SHA256()),
15
        salt_length=padding.PSS.MAX_LENGTH
16
    ),
17
    hashes.SHA256()
18
)
19
print(f"签名长度: {len(signature)} bytes")
20
print(f"签名(hex): {signature.hex()[:40]}...")
21

22
# 验证签名
23
try:
24
    public_key.verify(signature, message,
25
        padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
26
        hashes.SHA256())
27
    print("验证: 通过 ")
28
except Exception as e:
29
    print(f"验证: 失败 — {e}")
30

31
# 篡改消息后验证
32
tampered = b"Tampered document to sign"
33
try:
34
    public_key.verify(signature, tampered,
35
        padding.PSS(mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH),
36
        hashes.SHA256())
37
except Exception:
38
    print("篡改后验证: 失败  — 检测到篡改")

1
签名长度: 256 bytes
2
签名(hex): 50bf2f3a939a87d32759e76256ab4f6d610e8ecd...
3
验证: 通过
4
篡改后验证: 失败  — 检测到篡改

1
from cryptography.hazmat.primitives.asymmetric import ec
2
from cryptography.hazmat.primitives import hashes
3

4
ecc_private = ec.generate_private_key(ec.SECP256R1())
5
ecc_public = ecc_private.public_key()
6

7
ecdsa_sig = ecc_private.sign(message, ec.ECDSA(hashes.SHA256()))
8
print(f"ECDSA 签名长度: {len(ecdsa_sig)} bytes")
9
print(f"签名(hex): {ecdsa_sig.hex()[:40]}...")
10

11
# 验证
12
try:
13
    ecc_public.verify(ecdsa_sig, message, ec.ECDSA(hashes.SHA256()))
14
    print("验证: 通过 ")
15
except Exception as e:
16
    print(f"验证: 失败 — {e}")
17

18
# 篡改检测
19
try:
20
    ecc_public.verify(ecdsa_sig, tampered, ec.ECDSA(hashes.SHA256()))
21
except Exception:
22
    print("篡改后验证: 失败  — 检测到篡改")

1
ECDSA 签名长度: 72 bytes
2
签名(hex): 3046022100ae7eb83486c33e9e3208627785b37d...
3
验证: 通过
4
篡改后验证: 失败  — 检测到篡改

1
from cryptography.hazmat.primitives.asymmetric import ed25519
2

3
ed_private = ed25519.Ed25519PrivateKey.generate()
4
ed_public = ed_private.public_key()
5

6
ed_sig = ed_private.sign(message)
7
print(f"Ed25519 签名长度: {len(ed_sig)} bytes (固定 64 bytes)")
8
print(f"签名(hex): {ed_sig.hex()[:40]}...")
9

10
# 验证
11
try:
12
    ed_public.verify(ed_sig, message)
13
    print("验证: 通过 ")
14
except Exception as e:
15
    print(f"验证: 失败 — {e}")
16

17
# 确定性签名：同一消息两次签名结果相同
18
ed_sig2 = ed_private.sign(message)
19
print(f"两次签名相同: {ed_sig == ed_sig2} (Ed25519 是确定性签名)")

1
Ed25519 签名长度: 64 bytes (固定 64 bytes)
2
签名(hex): d130e75f30fe1ca1cd4c601426042bcf5d175148...
3
验证: 通过
4
两次签名相同: True (Ed25519 是确定性签名)

1
ecdsa_sig2 = ecc_private.sign(message, ec.ECDSA(hashes.SHA256()))
2
print(f"ECDSA 两次签名相同: {ecdsa_sig == ecdsa_sig2}")

1
ECDSA 两次签名相同: False

1
import time
2

3
# 性能基准测试（100 次取平均）
4
for name, sign_func, verify_func in [
5
    ("RSA-PSS", rsa_sign, rsa_verify),
6
    ("ECDSA P-256", ecdsa_sign, ecdsa_verify),
7
    ("Ed25519", ed_sign, ed_verify),
8
]:
9
    start = time.perf_counter()
10
    for _ in range(100):
11
        sig = sign_func()
12
    sign_ms = (time.perf_counter() - start) * 10
13

14
    start = time.perf_counter()
15
    for _ in range(100):
16
        verify_func(sig)
17
    verify_ms = (time.perf_counter() - start) * 10
18

19
    print(f"{name:15s}: 签名 {sign_ms:.2f} ms, 验证 {verify_ms:.2f} ms")

1
RSA-PSS        : 签名 0.80 ms, 验证 0.04 ms, 签名长度 256 bytes
2
ECDSA P-256    : 签名 0.03 ms, 验证 0.10 ms, 签名长度 71 bytes
3
Ed25519        : 签名 0.04 ms, 验证 0.11 ms, 签名长度 64 bytes