RSA 加密百科完全指南

← 返回指南列表

RSA 加密百科完全指南

RSA(Rivest-Shamir-Adleman,1977)是世界上使用最广泛的非对称加密算法。它基于大整数分解问题的数学困难性——将两个大质数相乘很容易,但从乘积反推回原始质因数极其困难。

RSA 的核心应用:

  • 数据加密:用公钥加密,私钥解密
  • 数字签名:用私钥签名,公钥验证
  • 密钥交换:在不安全信道上协商对称密钥
  • 证书体系:PKI、TLS/SSL 证书核心

一、RSA 数学基础

1.1 核心数学问题

RSA 安全性依赖:

问题 描述
大整数分解 给定 n = p × q(两个大质数),求 p 和 q
离散对数 给定 g、p、h = g^x mod p,求 x
RSA 问题 给定 n、e、c = m^e mod n,求 m

猜想:大整数分解问题不存在多项式时间算法,因此 RSA 对于足够大的密钥(2048 位及以上)是安全的。

1.2 欧拉定理

RSA 的数学基础是欧拉定理:

CODE
如果 gcd(a, n) = 1,那么 a^φ(n) ≡ 1 (mod n)

其中 φ(n) 是欧拉函数,表示 1 ~ n 中与 n 互质的整数个数。

当 n = p × q(p、q 为不同质数):
    φ(n) = φ(p) × φ(q) = (p-1) × (q-1)

推论:a^(k × φ(n) + 1) ≡ a (mod n)
      即 a^(φ(n)) ≡ 1 mod n 的任何整数次幂在模 n 下都恒等于 1

RSA 的本质:寻找 e 和 d 使得

CODE
e × d ≡ 1 (mod φ(n))

那么对于任意消息 m (0 < m < n):
    m^(e × d) ≡ m (mod φ(n)+1) ≡ m (mod n)

即:(m^e mod n)^d mod n = m

1.3 快速模幂(Modular Exponentiation)

计算 a^b mod n 不能直接计算 a^b(天文数字),需用快速算法:

PYTHON
def mod_pow(a, b, n):
    """模幂运算:计算 a^b mod n (平方乘方法, O(log b))"""
    result = 1
    a = a % n
    while b > 0:
        if b % 2 == 1:
            result = (result * a) % n
        b = b // 2
        a = (a * a) % n
    return result

Python 内置支持:pow(a, b, n) 已高度优化。

1.4 扩展欧几里得算法

求 e 在模 φ(n) 下的乘法逆元 d:

PYTHON
def extended_gcd(a, b):
    """扩展欧几里得算法:返回 gcd(a, b) 和 x, y 使得 a*x + b*y = gcd"""
    if a == 0:
        return b, 0, 1
    gcd, x1, y1 = extended_gcd(b % a, a)
    x = y1 - (b // a) * x1
    y = x1
    return gcd, x, y

def mod_inverse(e, phi):
    """求模逆元:e * d ≡ 1 (mod phi)"""
    gcd, x, _ = extended_gcd(e % phi, phi)
    if gcd != 1:
        raise ValueError("e 和 phi 不互质,逆元不存在")
    return (x % phi + phi) % phi

# 验证
e, phi = 7, 160
d = mod_inverse(e, phi)
print(f"{e} × {d} mod {phi} = {(e * d) % phi}")
# 7 × 23 mod 160 = 1 ✓

二、RSA 密钥生成

2.1 完整流程

CODE
步骤 1:选择两个不相等的大质数 p 和 q
         p = 61, q = 53(仅作示例,实际至少 2048 位)

步骤 2:计算 n = p × q
         n = 61 × 53 = 3233

步骤 3:计算 φ(n) = (p-1) × (q-1)
         φ(n) = 60 × 52 = 3120

步骤 4:选择整数 e,使得 1 < e < φ(n) 且 gcd(e, φ(n)) = 1
         e = 17(必须与 3120 互质)

步骤 5:计算 d = e^(-1) mod φ(n)(e 的模逆元)
         使用扩展欧几里得:
         17 × d ≡ 1 (mod 3120)
         d = 2753

公钥 (n, e) = (3233, 17)
私钥 (n, d) = (3233, 2753)

2.2 质数生成算法

实际系统中的 RSA 质数生成流程:

  1. 生成随机奇数
  2. Miller-Rabin 素性测试(概率性测试)
  3. 多次测试通过后认为是质数
PYTHON
import random

def miller_rabin(n, k=20):
    """Miller-Rabin 素性测试,k 为测试轮数(决定错误概率 4^(-k))"""
    if n < 2:
        return False
    if n == 2 or n == 3:
        return True
    if n % 2 == 0:
        return False
    
    # 写 n-1 = 2^r × d(d 是奇数)
    r, d = 0, n - 1
    while d % 2 == 0:
        r += 1
        d //= 2
    
    # 进行 k 轮测试
    for _ in range(k):
        a = random.randrange(2, n - 1)
        x = pow(a, d, n)
        if x == 1 or x == n - 1:
            continue
        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False
    return True

def generate_prime(bits=1024):
    """生成指定位数的大质数"""
    while True:
        n = random.getrandbits(bits)
        n |= (1 << bits - 1) | 1  # 确保最高位和最低位为 1
        if miller_rabin(n):
            return n

测试轮数与错误概率:

测试轮数 k 错误概率 (4^(-k)) 用途
5 1/1024 ≈ 0.1% 快速测试
10 ≈ 10^(-6) 普通使用
20 ≈ 10^(-12) 安全使用
40 ≈ 10^(-24) 高安全场景

2.3 Python 完整密钥生成

PYTHON
def generate_rsa_keypair(bits=2048):
    """生成 RSA 密钥对
    
    返回 (n, e, d, p, q)
    """
    p = generate_prime(bits // 2)
    q = generate_prime(bits // 2)
    while q == p:
        q = generate_prime(bits // 2)
    
    n = p * q
    phi = (p - 1) * (q - 1)
    
    # 选择 e(常用 65537 = 0x10001,含 2 个 1 位,效率高)
    e = 65537
    from math import gcd
    while gcd(e, phi) != 1:
        e += 2
    
    # 计算 d = e^(-1) mod phi
    d = mod_inverse(e, phi)
    
    return n, e, d, p, q

# 生成 2048 位 RSA 密钥
n, e, d, p, q = generate_rsa_keypair(2048)
print(f"n (十进制位数): {len(str(n))} 位")
print(f"e = {e}")
print(f"d = {d}")

常用的 e 值:65537(0x10001)—— 包含 2 个 1 位,模幂计算效率高,且广泛使用。


三、RSA 加密与解密

3.1 加密操作(使用公钥 n, e)

CODE
加密:c = m^e mod n

约束:m 必须是整数,且 0 < m < n

3.2 解密操作(使用私钥 n, d)

CODE
解密:m = c^d mod n

3.3 正确性证明

CODE
c^d mod n = (m^e)^d mod n
           = m^(e × d) mod n
           = m^(k × φ(n) + 1) mod n   (因为 e × d ≡ 1 mod φ(n))
           = m × (m^φ(n))^k mod n
           = m × 1^k mod n             (根据欧拉定理)
           = m mod n
           = m                           (因为 m < n)

3.4 手动计算示例(小密钥)

CODE
参数:p=61, q=53, n=3233, φ(n)=3120, e=17, d=2753

加密消息 m = 65(字母 'A'):
    c = 65^17 mod 3233
      = 2790

解密 c = 2790:
    m = 2790^2753 mod 3233
      = 65 ✓

3.5 Python 实现(教育用途)

PYTHON
def rsa_encrypt(message, n, e):
    """RSA 加密:将消息转为整数后计算 m^e mod n"""
    if isinstance(message, str):
        # 将字符串转成大整数(字节序 big-endian)
        m = int.from_bytes(message.encode(), 'big')
    else:
        m = message
    
    if m >= n:
        raise ValueError("消息太大,必须小于 n")
    
    return pow(m, e, n)

def rsa_decrypt(ciphertext, n, d):
    """RSA 解密:c^d mod n"""
    m = pow(ciphertext, d, n)
    
    # 将整数转回字节
    byte_length = (m.bit_length() + 7) // 8
    return m.to_bytes(byte_length, 'big').decode()

# 使用上面的小密钥测试
n, e, d = 3233, 17, 2753
c = rsa_encrypt(65, n, e)
print(f"加密: 65 → {c}")
m = pow(c, d, n)
print(f"解密: {c} → {m}")
# 加密: 65 → 2790
# 解密: 2790 → 65

# 字符串加密(仅教育用途,实际应用用填充)
msg = "Hi"
c = rsa_encrypt(msg, n, e)
print(f"原文: {msg}, 密文: {c}")
# 解密
decrypted = rsa_decrypt(c, n, d)
print(f"解密: {decrypted}")

3.6 RSA 解密的加速技巧(CRT)

实际 RSA 解密用中国剩余定理(CRT)加速,速度提高约 4 倍:

PYTHON
def rsa_decrypt_crt(c, p, q, d, n):
    """使用 CRT 加速解密
    
    m = c^d mod n
    等价于:
        m1 = c^d mod p
        m2 = c^d mod q
        然后用 CRT 合并
    """
    d_p = d % (p - 1)
    d_q = d % (q - 1)
    q_inv = mod_inverse(q, p)
    
    m1 = pow(c, d_p, p)
    m2 = pow(c, d_q, q)
    
    h = (q_inv * (m1 - m2)) % p
    m = (m2 + h * q) % n
    return m

3.7 使用标准库(PyCryptodome)

PYTHON
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import base64

# 生成 2048 位 RSA 密钥
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()

print(f"私钥:\n{private_key.decode()}")
print(f"\n公钥:\n{public_key.decode()}")

# OAEP 填充加密
public_key_obj = RSA.import_key(public_key)
cipher = PKCS1_OAEP.new(public_key_obj)
message = b"Hello, RSA!"
encrypted = cipher.encrypt(message)
print(f"\n加密 (Base64): {base64.b64encode(encrypted).decode()}")

# 解密
private_key_obj = RSA.import_key(private_key)
cipher = PKCS1_OAEP.new(private_key_obj)
decrypted = cipher.decrypt(encrypted)
print(f"解密: {decrypted.decode()}")

四、RSA 填充(Padding)

4.1 为什么需要填充?

问题:

  1. 数学安全性:RSA 有同态性质,攻击者可利用关系伪造密文
  2. 小块明文:如果明文 m 很小,m^e 可能小于 n,可直接开 e 次方根解密
  3. 确定性:相同明文总是产生相同密文

解决方案:填充——在加密前将明文嵌入结构化格式。

4.2 PKCS#1 v1.5 填充(传统)

CODE
消息长度 k 字节(RSA 密钥长度):
    0x00 | 0x02 | PS (非零随机字节) | 0x00 | 消息 M
    
    PS 长度 = k - 3 - len(M)

加密前的结构:
    [0x00] [0x02] [随机字节 至少 8 个] [0x00] [明文]

解密时检查结构是否合法。

优点:简单,兼容性好

缺点:存在Bleichenbacher 攻击(可通过错误信息差分恢复明文)

4.3 OAEP 填充(推荐)

Optimal Asymmetric Encryption Padding——基于 Feistel 网络和哈希函数的概率填充方案。

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

简化流程:

CODE
输入:消息 M
生成:随机种子 r
输出:EM = 0x00 || (r XOR H(X)) || (X XOR G(r))
其中 X = 0x00...0x01 || M,G 和 H 是基于哈希函数的扩展器

优点:

  • ✅ 可证明安全(在随机预言机模型下)
  • ✅ 抗选择密文攻击(CCA)
  • ✅ 是当前推荐方案

Python 使用:

PYTHON
from Crypto.Cipher import PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA256

key = RSA.generate(2048)
# 用 SHA-256 的 OAEP
cipher = PKCS1_OAEP.new(key.publickey(), hashAlgo=SHA256)
ciphertext = cipher.encrypt(b"Hello, OAEP!")

# 解密
cipher2 = PKCS1_OAEP.new(key, hashAlgo=SHA256)
plaintext = cipher2.decrypt(ciphertext)
print(plaintext)

4.4 填充错误案例(CTF 常见)

PYTHON
# 错误:无填充的裸 RSA(极不安全)
def insecure_rsa_encrypt(m, n, e):
    return pow(m, e, n)

# 如果 m 很小,c = m^e(未到模 n),可直接开 e 次方!
m = 42  # 小消息
n = 143  # 小 n(仅示例)
e = 3
c = pow(m, e, n)  # 42^3 = 74088 mod 143 = 可能很小
print(f"c = {c}")
print(f"e 次方根 ≈ {int(c ** (1/e))}")  # 42 ✓ 直接解密!

五、RSA 数字签名

5.1 签名原理

RSA 签名是加密的逆操作:

CODE
签名(私钥操作):s = m^d mod n(实际是对哈希后的值签名)
验证(公钥操作):m' = s^e mod n,如果 m' = H(m) 则有效

等价表述:
    签名: s = H(m)^d mod n
    验证: s^e mod n == H(m)

其中 H 是安全哈希函数(SHA-256、SHA-3 等)

直觉:只有持有私钥的人才能产生有效签名,但任何人都可以用公钥验证。

5.2 RSA-PKCS#1 v1.5 签名

PYTHON
from Crypto.Signature import pkcs1_15
from Crypto.Hash import SHA256
from Crypto.PublicKey import RSA

# 生成密钥
key = RSA.generate(2048)

# 签名(私钥)
message = b"Important document"
h = SHA256.new(message)
signature = pkcs1_15.new(key).sign(h)

# 验证(公钥)
h = SHA256.new(message)
try:
    pkcs1_15.new(key.publickey()).verify(h, signature)
    print("签名有效")
except (ValueError, TypeError):
    print("签名无效")

5.3 RSA-PSS(Probabilistic Signature Scheme,推荐)

RSA-PSS 是更现代的签名方案,引入了随机性:

PYTHON
from Crypto.Signature import pss
from Crypto.Hash import SHA256

key = RSA.generate(2048)
message = b"Important document"

# 签名
h = SHA256.new(message)
signature = pss.new(key).sign(h)

# 验证
h = SHA256.new(message)
try:
    pss.new(key.publickey()).verify(h, signature)
    print("PSS 签名有效")
except (ValueError, TypeError):
    print("PSS 签名无效")

PSS 优点:

  • ✅ 可证明安全
  • ✅ 引入随机性(相同消息每次签名不同)
  • ✅ 是当前推荐的签名方案

5.4 不签名消息本身,签名哈希值

为什么必须签名哈希值,而不是消息本身?

  1. 长度限制:RSA 只能签小于 n 的数,消息通常需要分块(而哈希结果是固定长度)
  2. 效率:签名 256 位哈希值比签名整个消息快得多
  3. 安全性:如果 RSA 直接签名任意消息,存在各种攻击

正确流程:

CODE
消息 → SHA-256 → 256 位哈希值 → RSA 签名 → (RSA-2048 位签名)

六、RSA 密钥长度与安全性

6.1 密钥长度建议

密钥长度 安全性评估 实际可破时间 适用场景
512 位 ❌ 极易破解 几小时 仅教育用途
1024 位 ⚠️ 已不安全 数月 旧系统兼容
2048 位 ✅ 当前安全 理论数千年 通用推荐
3072 位 ✅ 长期安全 不可行 高安全需求
4096 位 ✅ 极长期安全 不可行 政府/军事/金融

6.2 NIST 标准建议

年份 最低推荐密钥长度
2011-2030 2048 位
2031+ 3072 位

6.3 RSA 主要攻击方法

已知攻击方式:

攻击 说明 适用条件
因数分解攻击 从 n 求 p、q 密钥过小(< 1024 位)
共模攻击 相同 n 不同 e 的多组密文 n 被重用
低加密指数攻击 e 很小(e=3)且 m < n^(1/e) 不使用填充
Wiener 攻击 d < n^(0.25) 时攻击 选择过小的 d
Bleichenbacher 攻击 PKCS#1 v1.5 填充的选择密文攻击 错误信息泄露
ROCA 漏洞 受影响库(Infineon)生成的弱密钥 特定硬件/固件
侧信道攻击 功耗/时间/电磁泄露 物理访问

6.4 共模攻击演示(CTF 经典题)

PYTHON
# 场景:同一 n 不同 e 加密同一消息
# c1 = m^e1 mod n
# c2 = m^e2 mod n
# 已知: c1, c2, e1, e2, n → 求 m

def common_modulus_attack(c1, c2, e1, e2, n):
    """共模攻击"""
    from math import gcd
    # 扩展欧几里得找 a, b 使得 a*e1 + b*e2 = 1
    _, a, b = extended_gcd(e1, e2)
    
    # 确保正指数
    if a < 0:
        c1 = mod_inverse(c1, n)
        a = -a
    if b < 0:
        c2 = mod_inverse(c2, n)
        b = -b
    
    # m = (c1^a * c2^b) mod n
    m = (pow(c1, a, n) * pow(c2, b, n)) % n
    return m

# 示例
n = 3233
e1, e2 = 17, 7
m = 65

c1 = pow(m, e1, n)
c2 = pow(m, e2, n)

recovered = common_modulus_attack(c1, c2, e1, e2, n)
print(f"原始消息: {m}, 恢复消息: {recovered}")  # 65 ✓

6.5 Wiener 攻击(d 过小)

PYTHON
# 当 d < n^(0.25) 时,可通过连分数展开恢复 d
def wiener_attack(e, n):
    """简化版 Wiener 攻击思路
    找到 e/n 的连分数展开的收敛 p_i/q_i
    如果 q_i 接近 d,则恢复出私钥
    """
    # 实际实现需要连分数展开算法
    pass

教训:绝对不要手动选小的 d。使用标准的密钥生成器,让它自动生成大的 d。


七、RSA 在实际系统中的应用

7.1 TLS/SSL 握手

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

TLS 1.2 RSA 密钥交换流程:

  1. 客户端验证服务器证书(含 RSA 公钥)
  2. 客户端生成 48 字节随机数(Pre-Master Secret)
  3. 客户端用服务器 RSA 公钥加密后发送
  4. 服务器用 RSA 私钥解密得到 Pre-Master Secret
  5. 双方用 PRF 从 PM 派生会话密钥
  6. 后续通信使用 AES-GCM 等对称加密

问题:没有前向保密(Forward Secrecy)——如果私钥泄露,所有历史流量可解密

TLS 1.3:已淘汰 RSA 密钥交换,改用 ECDHE

7.2 SSH 使用 RSA

BASH
# 生成 4096 位 RSA SSH 密钥
ssh-keygen -t rsa -b 4096 -C "user@host"

# 公钥在 authorized_keys 中
# 用户用私钥登录(实际上是签名挑战-响应协议)

SSH 认证流程:

  1. 客户端说:我想用 id_rsa.pub 登录
  2. 服务器用公钥加密 256 位随机数,发送给客户端
  3. 客户端用私钥解密,得到随机数
  4. 客户端用随机数和会话密钥生成响应签名发回
  5. 服务器验证通过 → 登录成功

7.3 文件签名与验证(GPG 风格)

BASH
# RSA 签名文件
openssl dgst -sha256 -sign private_key.pem -out file.sig file.txt

# 验证签名
openssl dgst -sha256 -verify public_key.pem -signature file.sig file.txt

7.4 OpenSSL RSA 操作速查

BASH
# 生成 2048 位 RSA 私钥
openssl genrsa -out private_key.pem 2048

# 从私钥导出公钥
openssl rsa -in private_key.pem -pubout -out public_key.pem

# 用公钥加密文件
openssl pkeyutl -encrypt -in msg.txt -inkey public_key.pem -pubin -out msg.enc

# 用私钥解密
openssl pkeyutl -decrypt -in msg.enc -inkey private_key.pem -out msg.dec

# 生成带口令保护的私钥
openssl genrsa -aes256 -out encrypted_key.pem 2048

# 查看私钥内容
openssl rsa -in private_key.pem -text -noout | head -20

# 签名文件
openssl dgst -sha256 -sign private_key.pem -out sig.bin file.txt

# 验证签名
openssl dgst -sha256 -verify public_key.pem -signature sig.bin file.txt

八、RSA 常见陷阱与最佳实践

8.1 ❌ 不要做的事

错误做法 问题
裸 RSA 不加填充 数学攻击(小消息、同态等)
e = 3(太小的指数) 如果 m^3 < n,直接开立方根
相同 n 多个密钥 共模攻击
手动选择小的 d Wiener 攻击
用相同密钥加密签名 数学关系泄露
512/1024 位密钥 因数分解已可行
加密整个大文件 RSA 很慢,应该用 RSA+AES 混合加密

8.2 ✅ 最佳实践

建议 说明
OAEP 填充加密 2048+ 位密钥,SHA-256 哈希
PSS 填充签名 2048+ 位密钥,SHA-256 哈希
密钥长度 >= 2048 位 长期安全建议 3072+ 位
e = 65537 标准值,无需更改
用标准库 PyCryptodome / cryptography / OpenSSL
混合加密 RSA + AES-GCM(用 RSA 加密 AES 密钥)
HSM 存储私钥 硬件安全模块保护密钥
密钥轮换 定期更换密钥

8.3 混合加密(实际系统标准做法)

PYTHON
from Crypto.PublicKey import RSA
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.Random import get_random_bytes
import base64

def hybrid_encrypt(message, recipient_public_key):
    """RSA+AES 混合加密
    
    1. 生成随机 AES 密钥
    2. 用 RSA 公钥加密 AES 密钥
    3. 用 AES-GCM 加密消息
    """
    # 生成 256 位 AES 密钥
    session_key = get_random_bytes(32)
    
    # 用接收方 RSA 公钥加密会话密钥
    rsa_key = RSA.import_key(recipient_public_key)
    cipher_rsa = PKCS1_OAEP.new(rsa_key)
    enc_session_key = cipher_rsa.encrypt(session_key)
    
    # 用 AES-GCM 加密消息
    cipher_aes = AES.new(session_key, AES.MODE_GCM)
    ciphertext, tag = cipher_aes.encrypt_and_digest(message)
    
    # 返回加密的密钥 + nonce + tag + 密文
    return enc_session_key, cipher_aes.nonce, tag, ciphertext

def hybrid_decrypt(enc_session_key, nonce, tag, ciphertext, recipient_private_key):
    """解密混合加密内容"""
    # 用 RSA 私钥解密 AES 密钥
    rsa_key = RSA.import_key(recipient_private_key)
    cipher_rsa = PKCS1_OAEP.new(rsa_key)
    session_key = cipher_rsa.decrypt(enc_session_key)
    
    # 用 AES-GCM 解密消息
    cipher_aes = AES.new(session_key, AES.MODE_GCM, nonce)
    return cipher_aes.decrypt_and_verify(ciphertext, tag)

# 演示
key = RSA.generate(2048)
message = b"Large message: " + b"A" * 10000  # 大数据

enc_sk, nonce, tag, ctext = hybrid_encrypt(message, key.publickey().export_key())
plaintext = hybrid_decrypt(enc_sk, nonce, tag, ctext, key.export_key())

print(f"原始消息长度: {len(message)} 字节")
print(f"解密成功: {plaintext == message}")

九、RSA 量子威胁

9.1 Shor 算法

Peter Shor (1994) 证明量子计算机可以在多项式时间内分解大整数:

CODE
经典计算机: O(e^(c × (ln n)^(1/3) × (ln ln n)^(2/3)))  次指数时间
量子计算机: O((ln n)^3)                                多项式时间!

影响:足够大的量子计算机可破解 RSA-2048、RSA-4096

9.2 当前状态

  • 现有量子计算机:约 1000 量子比特,但错误率高,无法进行有用的 Shor 计算
  • 破解 RSA-2048 所需:约 2000 万完美量子比特(或约 2000 万逻辑量子比特,考虑纠错)
  • NIST 估计:2030 年前可能出现实用的 Shor 算法量子计算机

9.3 防御方案

方案 说明 状态
增加密钥长度 RSA-8192 等 短期缓解
后量子密码学 (PQC) 格密码、多变量多项式、哈希基 NIST 已标准化(Kyber、Dilithium 等)
混合方案 RSA + PQC 同时使用 TLS 1.3 已引入 X25519 + Kyber768

过渡建议:

  • 不要恐慌,但开始规划迁移
  • 对于需要保护 10+ 年的数据,考虑 PQC
  • TLS 1.3 + OpenSSL 3.2 已支持 Kyber

十、Python cryptography 库用法(推荐)

PYTHON
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.backends import default_backend

# 生成私钥
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048,
    backend=default_backend()
)

# 导出私钥(PEM 格式)
private_pem = private_key.private_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PrivateFormat.PKCS8,
    encryption_algorithm=serialization.NoEncryption()
)

# 导出公钥
public_key = private_key.public_key()
public_pem = public_key.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

# OAEP 加密
message = b"Hello, cryptography!"
ciphertext = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# 解密
plaintext = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

print(f"解密成功: {plaintext == message}")

# PSS 签名
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# 验证签名
try:
    public_key.verify(
        signature,
        message,
        padding.PSS(
            mgf=padding.MGF1(hashes.SHA256()),
            salt_length=padding.PSS.MAX_LENGTH
        ),
        hashes.SHA256()
    )
    print("签名验证通过")
except Exception as e:
    print(f"签名验证失败: {e}")

总结

RSA 是非对称加密的基础和事实标准,核心要点:

  1. 数学基础:大整数分解的困难性 + 欧拉定理
  2. 密钥生成:选大质数 p、q,计算 n = p×q,选 e,求 d = e^(-1) mod φ(n)
  3. 加密:c = m^e mod n(用公钥)
  4. 解密:m = c^d mod n(用私钥)
  5. 签名:s = H(m)^d mod n(用私钥)
  6. 验证:s^e mod n == H(m)(用公钥)
  7. 填充必须:OAEP(加密)/ PSS(签名),不要用 PKCS#1 v1.5
  8. 密钥长度:至少 2048 位,长期安全建议 3072+ 位
  9. 量子威胁:Shor 算法可破解,需关注后量子密码学
  10. 实际使用:总是用经过审计的库(PyCryptodome/cryptography/OpenSSL),不要自己实现

RSA 在系统中的典型角色:用 RSA 交换/保护 AES 密钥,用 AES 加密实际数据(混合加密)。