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 的数学基础是欧拉定理:
如果 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 使得
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(天文数字),需用快速算法:
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:
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 完整流程
步骤 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 质数生成流程:
- 生成随机奇数
- Miller-Rabin 素性测试(概率性测试)
- 多次测试通过后认为是质数
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 完整密钥生成
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)
加密:c = m^e mod n
约束:m 必须是整数,且 0 < m < n
3.2 解密操作(使用私钥 n, d)
解密:m = c^d mod n
3.3 正确性证明
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 手动计算示例(小密钥)
参数: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 实现(教育用途)
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 倍:
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)
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 为什么需要填充?
问题:
- 数学安全性:RSA 有同态性质,攻击者可利用关系伪造密文
- 小块明文:如果明文 m 很小,
m^e可能小于 n,可直接开 e 次方根解密 - 确定性:相同明文总是产生相同密文
解决方案:填充——在加密前将明文嵌入结构化格式。
4.2 PKCS#1 v1.5 填充(传统)
消息长度 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 网络和哈希函数的概率填充方案。
简化流程:
输入:消息 M
生成:随机种子 r
输出:EM = 0x00 || (r XOR H(X)) || (X XOR G(r))
其中 X = 0x00...0x01 || M,G 和 H 是基于哈希函数的扩展器
优点:
- ✅ 可证明安全(在随机预言机模型下)
- ✅ 抗选择密文攻击(CCA)
- ✅ 是当前推荐方案
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 常见)
# 错误:无填充的裸 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 签名是加密的逆操作:
签名(私钥操作):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 签名
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 是更现代的签名方案,引入了随机性:
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 不签名消息本身,签名哈希值
为什么必须签名哈希值,而不是消息本身?
- 长度限制:RSA 只能签小于 n 的数,消息通常需要分块(而哈希结果是固定长度)
- 效率:签名 256 位哈希值比签名整个消息快得多
- 安全性:如果 RSA 直接签名任意消息,存在各种攻击
正确流程:
消息 → 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 经典题)
# 场景:同一 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 过小)
# 当 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 握手
TLS 1.2 RSA 密钥交换流程:
- 客户端验证服务器证书(含 RSA 公钥)
- 客户端生成 48 字节随机数(Pre-Master Secret)
- 客户端用服务器 RSA 公钥加密后发送
- 服务器用 RSA 私钥解密得到 Pre-Master Secret
- 双方用 PRF 从 PM 派生会话密钥
- 后续通信使用 AES-GCM 等对称加密
问题:没有前向保密(Forward Secrecy)——如果私钥泄露,所有历史流量可解密
TLS 1.3:已淘汰 RSA 密钥交换,改用 ECDHE
7.2 SSH 使用 RSA
# 生成 4096 位 RSA SSH 密钥
ssh-keygen -t rsa -b 4096 -C "user@host"
# 公钥在 authorized_keys 中
# 用户用私钥登录(实际上是签名挑战-响应协议)
SSH 认证流程:
- 客户端说:我想用 id_rsa.pub 登录
- 服务器用公钥加密 256 位随机数,发送给客户端
- 客户端用私钥解密,得到随机数
- 客户端用随机数和会话密钥生成响应签名发回
- 服务器验证通过 → 登录成功
7.3 文件签名与验证(GPG 风格)
# 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 操作速查
# 生成 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 混合加密(实际系统标准做法)
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) 证明量子计算机可以在多项式时间内分解大整数:
经典计算机: 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 库用法(推荐)
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 是非对称加密的基础和事实标准,核心要点:
- 数学基础:大整数分解的困难性 + 欧拉定理
- 密钥生成:选大质数 p、q,计算 n = p×q,选 e,求 d = e^(-1) mod φ(n)
- 加密:c = m^e mod n(用公钥)
- 解密:m = c^d mod n(用私钥)
- 签名:s = H(m)^d mod n(用私钥)
- 验证:s^e mod n == H(m)(用公钥)
- 填充必须:OAEP(加密)/ PSS(签名),不要用 PKCS#1 v1.5
- 密钥长度:至少 2048 位,长期安全建议 3072+ 位
- 量子威胁:Shor 算法可破解,需关注后量子密码学
- 实际使用:总是用经过审计的库(PyCryptodome/cryptography/OpenSSL),不要自己实现
RSA 在系统中的典型角色:用 RSA 交换/保护 AES 密钥,用 AES 加密实际数据(混合加密)。