rsa加密算法Python代码

备案号:蜀ICP备2026035467号-3|网址:www.xservx.com

⚡ rsa加密算法Python代码|基础认知

RSA加密算法是一种非对称加密算法,由Ron Rivest、Adi Shamir和Leonard Adleman于1977年提出,是目前应用最广泛的公钥加密技术之一。其核心安全性基于大整数分解的困难性——将两个大素数相乘容易,而将乘积分解回原素数在计算上不可行(当素数足够大时)。

在Python开发中,RSA加密算法常用于: HTTPS/TLS握手、数字证书签发、API接口签名验证、敏感数据加密存储、区块链交易签名、安全通信协议(如SSH密钥交换)等场景。尤其在Web后端与前端数据交互中,RSA加密算法常作为轻量级加密方案,保护传输过程中的密码、Token、JSON敏感字段等。

与对称加密(如AES)相比,RSA加密算法优势在于密钥分发简单(公钥可公开),无需预先共享密钥;劣势是计算开销大、加密速度慢,通常仅用于加密短数据(如对称密钥),再用对称加密处理大量数据——形成“混合加密系统”。

现代系统中,RSA加密算法默认推荐密钥长度为2048位(对应约617位十进制数),1024位已不安全;4096位适用于高安全场景(如根CA证书),但性能下降约4倍。选择密钥长度需权衡安全与性能。

〔为什么选择Python实现RSA?〕

  • 标准库丰富:Python内置hashlib、hmac等模块,配合第三方库(如pycryptodome、cryptography)可高效实现RSA
  • 生态完善:Django、FastAPI等Web框架提供开箱即用的RSA签名/验签支持
  • 调试友好:动态语言便于快速验证密钥生成、加解密流程,适合教学与原型开发
  • 跨平台兼容:同一套RSA代码可在Linux/Windows/macOS无缝运行

📌 提示:生产环境务必使用成熟库,切勿自行实现RSA核心数学逻辑(如模幂运算),避免侧信道攻击风险。

⚙️ rsa加密算法Python代码|数学原理详解

RSA加密算法基于数论中的三个核心定理:

  1. 欧拉定理:若a与n互质,则a^φ(n) ≡ 1 (mod n),其中φ(n)为欧拉函数
  2. 费马小定理:当p为素数,a^(p-1) ≡ 1 (mod p)
  3. 模逆元存在条件:整数e与φ(n)互质时,存在唯一d满足e·d ≡ 1 (mod φ(n))

基于此,RSA加密算法密钥生成步骤如下:

  1. 随机选取两个大素数p和q(建议≥1024位)
  2. 计算n = p × q(模数),φ(n) = (p-1)(q-1)
  3. 选择整数e(公钥指数),满足1 < e < φ(n)且gcd(e, φ(n)) = 1(常用e=65537=2^16+1)
  4. 计算e关于φ(n)的模逆元d(私钥指数),即d ≡ e⁻¹ (mod φ(n))
  5. 公钥 = (e, n),私钥 = (d, n)

加密过程:明文M(需满足0 ≤ M < n),密文C = M^e mod n

解密过程:M = C^d mod n

〔关键数学特性验证〕

以小素数示例:p=61, q=53 → n=3233, φ(n)=60×52=3120

取e=17(与3120互质),用扩展欧几里得算法求d:

17×d ≡ 1 (mod 3120) → d=2753(因17×2753=46801=15×3120+1)

验证:M=123 → C=123^17 mod 3233 = 855

M=855^2753 mod 3233 = 123 ✓

# 用Python验证小规模RSA def mod_pow(base, exp, mod): result = 1 base = base % mod while exp > 0: if exp % 2 == 1: result = (result * base) % mod exp = exp >> 1 base = (base * base) % mod return result # 示例参数 p, q = 61, 53 n = p * q phi = (p - 1) * (q - 1) e = 17 # 计算模逆元d(使用扩展欧几里得算法) def extended_gcd(a, b): 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 d = extended_gcd(e, phi)[1] % phi print("d = ", d) # 输出:2753 # 加解密验证 M = 123 C = mod_pow(M, e, n) M_dec = mod_pow(C, d, n) print("加密:", C, "解密:", M_dec) # 输出:855 123

实际应用中,p和q需为大素数(≥1024位),直接计算模幂会溢出,需使用“模重复平方法”优化,上述代码已实现该优化逻辑。

⚡ rsa加密算法Python代码|标准库实现指南

〔pycryptodome库实现RSA加解密〕

pycryptodome是Python最流行的加密库(Django默认后端),支持RSA全流程操作。

生成RSA密钥对

from Crypto.PublicKey import RSA from Crypto.Random import get_random_bytes # 生成2048位RSA密钥对 key = RSA.generate(2048) # 导出私钥(PEM格式) private_key = key.export_key() with open("private.pem", "wb") as f: f.write(private_key) # 导出公钥(PEM格式) public_key = key.publickey().export_key() with open("public.pem", "wb") as f: f.write(public_key)

生成的PEM文件结构如下:

-----BEGIN RSA PRIVATE KEY----- MIIEowIBAAKCAQEA0Z3VS5JJcds3xfn/ygWyF8PbnGy... -----END RSA PRIVATE KEY----- -----BEGIN PUBLIC KEY----- MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA... -----END PUBLIC KEY-----

使用公钥加密

from Crypto.PublicKey import RSA from Crypto.Cipher import PKCS1_OAEP # 加载公钥 with open("public.pem", "rb") as f: public_key = RSA.import_key(f.read()) # 创建加密器 cipher_rsa = PKCS1_OAEP.new(public_key) # 加密消息(需分块,因RSA有长度限制) message = "Hello RSA!".encode() ciphertext = cipher_rsa.encrypt(message) print("密文(Base64):", ciphertext.hex())

⚠️ RSA加密最大明文长度 = (密钥位数/8) - 2(OAEP填充)
2048位密钥最多加密245字节,超长数据需分块或结合对称加密。

使用私钥解密

from Crypto.PublicKey import RSA from Crypto.Cipher import PKCS1_OAEP # 加载私钥 with open("private.pem", "rb") as f: private_key = RSA.import_key(f.read()) # 创建解密器 cipher_rsa = PKCS1_OAEP.new(private_key) # 解密 plaintext = cipher_rsa.decrypt(bytes.fromhex(ciphertext.hex())) print("明文:", plaintext.decode()) # 输出:Hello RSA!

⚡ rsa加密算法Python代码|数字签名实现

RSA数字签名是验证数据完整性和来源真实性的核心机制,流程如下:

  1. 发送方计算消息摘要(如SHA-256)
  2. 用私钥加密摘要 → 得到签名
  3. 发送方将原文+签名一并发送
  4. 接收方用公钥解密签名 → 得到摘要A
  5. 接收方计算原文摘要 → 得到摘要B
  6. 比较摘要A与B是否一致

使用私钥生成签名

from Crypto.PublicKey import RSA from Crypto.Signature import pkcs1_15 from Crypto.Hash import SHA256 # 加载私钥 with open("private.pem", "rb") as f: private_key = RSA.import_key(f.read()) # 准备消息 message = "转账100元至账户8888".encode() h = SHA256.new(message) # 生成签名 signature = pkcs1_15.new(private_key).sign(h) print("签名(Hex):", signature.hex())

使用公钥验证签名

from Crypto.PublicKey import RSA from Crypto.Signature import pkcs1_15 from Crypto.Hash import SHA256 # 加载公钥 with open("public.pem", "rb") as f: public_key = RSA.import_key(f.read()) # 接收方计算摘要 h = SHA256.new(message) try: pkcs1_15.new(public_key).verify(h, signature) print("✓ 签名有效:数据未被篡改") except (ValueError, TypeError): print("✗ 签名无效:数据可能被篡改")

📌 安全要点:签名前必须哈希原文!直接对原始数据签名易受选择密文攻击(如 forgery via multiplication)。

⚡ rsa加密算法Python代码|安全实践与常见陷阱

〔必须规避的安全风险〕

① 低指数攻击(Håstad Broadcast Attack)

当相同消息被多个接收方加密(e=3),攻击者可利用中国剩余定理恢复明文。

✅ 解决方案:使用OAEP填充(PKCS1_OAEP而非PKCS1_v1_5);e≥65537

② 时序攻击(Timing Attack)

私钥解密过程若未恒定时间执行,可能泄露密钥信息(如模幂运算分支差异)。

✅ 解决方案:使用pycryptodome等成熟库(已修复侧信道漏洞);避免自实现

③ 填充预言攻击(Bleichenbacher Attack)

PKCS#1 v1.5填充的解密错误信息泄露,可逐步恢复明文(1998年著名攻击)。

✅ 解决方案:禁用v1.5填充;强制使用OAEP(PKCS1_OAEP)

# 错误用法(易受Bleichenbacher攻击) from Crypto.Cipher import PKCS1_v15 cipher = PKCS1_v15.new(public_key) # 不推荐! # 正确用法 from Crypto.Cipher import PKCS1_OAEP cipher = PKCS1_OAEP.new(public_key) # 推荐

④ 密钥长度不足

2023年NIST建议:RSA密钥≥2048位;2030年后需≥3072位

✅ 验证密钥长度:

with open("private.pem", "rb") as f: key = RSA.import_key(f.read()) print("密钥位数:", key.size_in_bits()) # 应≥2048

⑤ 硬编码密钥

将私钥写入源码或仓库是重大安全隐患!

✅ 正确做法:使用环境变量或密钥管理服务(如AWS KMS、HashiCorp Vault)

# 安全方式:从环境变量加载 import os from Crypto.PublicKey import RSA with open(os.environ["RSA_PRIVATE_KEY_PATH"], "rb") as f: private_key = RSA.import_key(f.read())

⚡ rsa加密算法Python代码|完整实战项目

〔API接口安全通信示例〕

场景:前端向后端发送敏感数据(如用户密码),使用RSA加密防止明文传输

后端(Python)生成RSA密钥对并提供公钥接口

from flask import Flask, jsonify from Crypto.PublicKey import RSA import json app = Flask(__name__) # 应用启动时生成密钥对(生产环境应持久化) key = RSA.generate(2048) with open("server_key.pem", "wb") as f: f.write(key.export_key()) # 公钥接口 @app.route("/api/public-key") def get_public_key(): public_key = key.publickey().export_key().decode() return jsonify({ "key": public_key, "expires": "2025-12-31" }) # 加密数据接收接口 @app.route("/api/login", methods=["POST"]) def login(): data = request.get_json() encrypted_password = bytes.fromhex(data["password"]) # 使用私钥解密 cipher_rsa = PKCS1_OAEP.new(key) password = cipher_rsa.decrypt(encrypted_password).decode() # 后续验证逻辑... return jsonify({"status": "success"})

前端(JavaScript)使用公钥加密

// 1. 获取公钥 async function fetchPublicKey() { const res = await fetch("/api/public-key"); const data = await res.json(); return data.key; } // 2. 加密密码 async function encryptPassword(password) { const publicKeyPem = await fetchPublicKey(); // 使用jsencrypt库 const encrypt = new JSEncrypt(); encrypt.setPublicKey(publicKeyPem); return encrypt.encrypt(password); } // 3. 提交登录 async function submitLogin(username, password) { const encryptedPass = await encryptPassword(password); const res = await fetch("/api/login", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ username, password: encryptedPass // Base64字符串 }) }); }

〔密钥轮换方案〕

为防止单点泄露,建议定期轮换密钥(如每月):

  1. 生成新密钥对,保留旧密钥用于解密历史数据
  2. 更新公钥接口,返回当前+历史公钥列表
  3. 前端自动使用最新公钥加密
  4. 服务端按密钥ID选择对应私钥解密
# 服务端解密逻辑(支持多密钥) def decrypt_with_key_id(encrypted_data, key_id): key_map = { "2024Q1": current_key, "2023Q4": old_key_1, "2023Q3": old_key_2 } key = key_map.get(key_id) if not key: raise Exception("Invalid key ID") cipher_rsa = PKCS1_OAEP.new(key) return cipher_rsa.decrypt(encrypted_data)

⚡ rsa加密算法Python代码|网友最关心的10个问题

〔1. RSA与AES如何配合使用?〕

RSA加密算法适合加密短数据(如密钥),AES适合加密长数据。典型流程:

  1. 客户端生成随机AES密钥(如256位)
  2. 用服务器公钥加密AES密钥 → 传输
  3. 客户端用AES密钥加密业务数据
  4. 服务端用私钥解密AES密钥 → 用AES解密数据

优势:兼顾安全性(非对称加密)与性能(对称加密)

〔2. 如何选择RSA密钥长度?〕

密钥长度安全等效AES适用场景性能对比(2048位=1)
1024位80位已淘汰(2010年后禁用)0.5
2048位112位通用场景(推荐)1
3072位128位高安全需求(2030前)3.2
4096位152位长期保密(如政府)7.1

〔3. Python中RSA库对比:cryptography vs pycryptodome〕

cryptography:

  • 由PyCA维护,现代API设计,支持TLS 1.3
  • 默认使用安全默认值(如OAEP)
  • API更严格(如需显式指定盐长度)
  • 适合新项目,推荐用于生产环境
from cryptography.hazmat.primitives import serialization, hashes from cryptography.hazmat.primitives.asymmetric import rsa, padding # 生成密钥 private_key = rsa.generate_private_key( public_exponent=65537, key_size=2048 )

pycryptodome:

  • PyCrypto分支,兼容性好,Django默认后端
  • API更接近OpenSSL,学习曲线平缓
  • 支持更多旧算法(如PKCS1_v1_5)
  • 需注意安全配置(避免误用不安全填充)
# 生成密钥 from Crypto.PublicKey import RSA key = RSA.generate(2048)

〔4. RSA签名与哈希算法组合推荐〕

哈希算法签名强度推荐场景Python实现
SHA-256128位通用(默认推荐)SHA256.new(data)
SHA-384192位金融/政府系统SHA384.new(data)
SHA3-256128位抗量子计算(未来)SHA3_256.new(data)

〔5. 如何检测RSA密钥是否安全?〕

  • 密钥位数≥2048
  • 公钥指数e=65537(非1或3)
  • 私钥d > n^(0.3)(Wiener攻击防护)
  • p与q差值足够大(否则可被Fermat分解)
# 检查密钥安全性(示例) def check_rsa_safety(key): n, e, d = key.n, key.e, key.d if key.size_in_bits() < 2048: raise Exception("密钥长度不足") if e < 65537: raise Exception("公钥指数过小") if d < n ** 0.3: raise Exception("d可能受Wiener攻击") return True

〔6. RSA在区块链中的应用〕

以太坊使用ECDSA而非RSA,但部分联盟链(如Hyperledger)支持RSA签名:

  • 身份认证:节点用RSA私钥签名区块
  • 数据加密:用户用节点公钥加密交易
  • 密钥管理:CA用RSA签发节点证书

示例:用RSA生成以太坊地址(非标准,仅教学)

# 生成以太坊地址(需配合keccak256) from eth_utils import keccak from Crypto.PublicKey import RSA # 生成RSA密钥 key = RSA.generate(2048) private_key_bytes = key.export_key() # 提取私钥d(大整数) d = key.d # 生成以太坊地址 address = keccak(private_key_bytes)[-20:].hex() print("以太坊地址:0x", address)

〔7. 如何实现RSA密钥持久化?〕

生产环境应避免每次重启生成新密钥,需持久化存储:

# 保存密钥到数据库(Base64编码) import base64 # 保存 key = RSA.generate(2048) key_data = base64.b64encode(key.export_key()).decode() with open("db_key.txt", "w") as f: f.write(key_data) # 加载 with open("db_key.txt", "r") as f: key_data = f.read() key = RSA.import_key(base64.b64decode(key_data))

更安全方案:使用环境变量或密钥管理服务(KMS)

〔8. RSA性能优化技巧〕

  • 复用Cipher对象(避免重复初始化)
  • 使用PKCS1_OAEP而非PKCS1_v1_5(安全性优先)
  • 对长数据用对称加密(RSA仅加密密钥)
  • 预计算关键值(如d mod (p-1))
# 预计算优化(pycryptodome自动完成) from Crypto.Util.number import inverse from Crypto.PublicKey import RSA key = RSA.generate(2048) # pycryptodome已计算dP, dQ, qInv print("dP = d mod (p-1)", key.dP) print("qInv = q^-1 mod p", key.qInv)

〔9. RSA与量子计算威胁〕

Shor算法可在多项式时间内破解RSA,但需百万级量子比特(当前最先进仅千级)。

应对方案:

  1. 2030年前:继续使用2048/3072位RSA
  2. 2030年后:迁移到NTRU、CRYSTALS-Kyber等后量子密码
  3. 混合方案:RSA+Kyber(同时满足传统与量子安全)

中国《密码法》已规划后量子密码迁移路线图

〔10. 网友实战问题:Python RSA加密后结果不一致?〕

常见原因:OAEP填充含随机性(每次加密结果不同)

# 正确:每次加密结果不同(安全特性) for i in range(3): ct = cipher_rsa.encrypt("test".encode()) print("加密结果", i, ":", ct.hex()) # 输出示例(每次不同): # 加密结果0 : 0a3f2b...7c # 加密结果1 : 8d1e4c...2f # 加密结果2 : b9a07d...5e

✅ 这是设计特性!防止重放攻击,确保语义安全