1. 项目概述：从零理解RSA的“魔法”

如果你对“加密”这个词的印象还停留在谍战片里复杂的密码本，那RSA算法可能会颠覆你的认知。它是一套基于数学难题的“非对称加密”系统，简单来说，就是加密和解密用的不是同一把钥匙。这听起来有点反直觉，但正是这个特性，让它成为了现代互联网安全的基石，从你登录网站时看到的那个小锁图标（HTTPS），到数字签名、软件授权，背后都有RSA的身影。

网上很多教程一上来就扔出一堆数学公式，什么欧拉函数、模逆元，直接把初学者劝退。这篇内容的目标不同：我们不追求数学上的极致严谨，而是用“人话”和可运行的代码，帮你直观理解RSA的核心思想，并亲手实现一个能跑起来的、虽然简单但原理正确的RSA加密解密程序。适合所有对密码学感兴趣，但被复杂理论吓到的朋友，无论你是前端、后端还是学生，都能跟着一步步做出来，真正搞懂“公钥加密，私钥解密”到底是怎么玩的。

2. RSA核心原理的“白话”拆解

在动手写代码之前，我们必须先在心里建立起RSA的运作模型。你可以把它想象成一个特制的、带有两个钥匙孔的密码盒。

2.1 非对称加密：一把锁，两把钥匙

传统的对称加密（比如你用同一个密码压缩文件）好比是一把挂锁，开锁和关锁用的是同一把钥匙。这带来了一个致命问题：如何安全地把钥匙交给对方？如果钥匙在传递途中被截获，整个加密就形同虚设。

RSA的聪明之处在于，它造了一把结构奇特的锁。这把锁配有两把完全不同的钥匙：一把叫公钥，可以公开给任何人；另一把叫私钥，必须由主人严格保密。

• 公钥：它的作用就像是一个只能锁上，不能打开的锁头。任何人拿到这个锁头（公钥），都可以把信息“锁”进盒子里。
• 私钥：这是唯一能打开那个被公钥锁住的盒子的钥匙，由信息接收者自己保管。

这样一来，通信流程就安全了：我想给你发密信，就先用你公开在网上的“锁头”（你的公钥）把信锁好寄给你。路上即使被截获，别人也没有你的“私钥”来开锁。只有你本人能用私钥打开阅读。这个过程完美解决了密钥分发的难题。

2.2 背后的数学“魔法”：大数分解难题

RSA的安全性不依赖于复杂的机关，而是基于一个简单的数学事实：将两个大的质数相乘非常容易，但想要将这个巨大的乘积重新分解回原来的两个质数，在现有计算能力下极其困难。

这就是RSA的基石——大整数分解的困难性。我们整个密钥生成过程，就是围绕着一对精心挑选的大质数p和q来进行的。

1. 计算n = p * q。这个n会作为公钥和私钥的一部分公开出去。
2. 攻击者即使知道了n，想倒推出p和q也几乎不可能（只要p和q足够大，比如都是1024位以上的质数）。

整个RSA的密钥生成、加密、解密公式，都是在这个数学基础上搭建起来的。我们不需要深究每一个公式的数学证明，但需要理解每个步骤的目的。

2.3 密钥生成：一步步打造我们的“锁和钥匙”

这是RSA最核心的步骤，我们来一步步拆解：

第一步：选择两个不相等的质数p和q这是安全性的源头。在实际应用中，p和q必须是随机生成且长度很长（如1024位）的质数。为了演示，我们选小的：p=61,q=53。

第二步：计算模数nn = p * q = 61 * 53 = 3233这个n就是那个公开的、难以分解的大数。它的长度（这里3233是4位数）决定了密钥的强度。n会同时出现在公钥和私钥中。

第三步：计算欧拉函数φ(n)欧拉函数φ(n)表示在小于n的正整数中，与n互质（最大公约数为1）的数的个数。对于两个质数相乘的情况，有一个简单公式：φ(n) = (p-1) * (q-1)所以，φ(3233) = (61-1) * (53-1) = 60 * 52 = 3120这个φ(n)是后续计算的关键，但它必须被严格保密，因为知道它就能轻易推算出私钥。

第四步：选择公钥指数e公钥由(n, e)组成。e需要满足两个条件：

1. 1 < e < φ(n)
2. e和φ(n)必须互质（即最大公约数gcd(e, φ(n)) = 1）。 通常，为了计算效率，会选择一个较小的、常见的质数，比如65537(0x10001)。这个数只有两个比特位是1，在二进制下计算非常快。在我们的例子中，我们在1 < e < 3120且与3120互质的数里选一个，比如e = 17。

第五步：计算私钥指数d私钥由(n, d)组成。d是e对于φ(n)的模逆元。这意味着d需要满足：(e * d) % φ(n) = 1换句话说，d是这样一个数，e和d的乘积除以φ(n)后，余数为1。 计算d需要使用扩展欧几里得算法。对于e=17, φ(n)=3120，我们可以计算出d = 2753，因为(17 * 2753) % 3120 = 46801 % 3120 = 1。

至此，我们得到了：

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

注意：以上数字都非常小，仅用于教学演示。真正的RSA密钥，n是一个长达数百位十进制数的大整数，p和q的选取是随机的、长度相近的大质数，这是安全性的根本。自己实现时，绝对不要用这么小的质数用于真实加密。

3. 加密与解密的代码实现（Python版）

理解了原理，我们用Python把它实现出来。我们会先实现一个基础版本，确保每一步都清晰可见。

3.1 基础工具函数：最大公约数与模逆元

在实现核心功能前，我们需要两个数学助手。

def gcd(a, b): """计算最大公约数，用于判断两个数是否互质。""" while b != 0: a, b = b, a % b return a def modinv(e, phi): """使用扩展欧几里得算法计算模逆元 d，满足 (e*d) % phi == 1。""" # 这里我们使用简单的遍历法来寻找d，仅适用于教学和小数字。 # 在实际应用中，必须使用扩展欧几里得算法。 for d in range(3, phi): if (e * d) % phi == 1: return d raise ValueError(f"模逆元不存在 for e={e}, phi={phi}")

3.2 密钥生成函数

现在，我们把第二部分的理论步骤写成代码。

def generate_keypair(p, q): """生成RSA公钥和私钥。""" # 1. 计算n和phi n = p * q phi = (p-1) * (q-1) # 2. 选择公钥指数e，要求与phi互质 e = 17 # 常见选择，也可以从3, 5, 17, 257, 65537中选 while gcd(e, phi) != 1: e += 2 # 确保e是奇数，增加与phi互质的概率 # 3. 计算私钥指数d d = modinv(e, phi) # 公钥 (e, n), 私钥 (d, n) return ((e, n), (d, n)) # 使用我们例子中的质数 p = 61 q = 53 public_key, private_key = generate_keypair(p, q) print(f"公钥 (e, n): {public_key}") print(f"私钥 (d, n): {private_key}")

运行这段代码，你会得到和之前手工计算一致的结果：公钥: (17, 3233),私钥: (2753, 3233)。

3.3 加密函数：用公钥“上锁”

加密过程很简单：将明文（一个数字）用公钥(e, n)进行运算。 公式是：密文 = (明文 ^ e) % n在Python中，^是异或，不是幂运算。幂运算用**，但对于大数，直接计算(明文 ** e)会得到一个天文数字，效率极低且可能溢出。我们必须使用模幂运算，它可以在计算过程中不断取模，保持数值较小。

def encrypt(public_key, plaintext): """使用公钥加密一个整数。""" e, n = public_key # 使用pow函数进行模幂运算，第三个参数n表示取模 ciphertext = pow(plaintext, e, n) return ciphertext

3.4 解密函数：用私钥“开锁”

解密是加密的逆过程，使用私钥(d, n)。 公式是：明文 = (密文 ^ d) % n同样，我们使用模幂运算。

def decrypt(private_key, ciphertext): """使用私钥解密密文，返回整数明文。""" d, n = private_key plaintext = pow(ciphertext, d, n) return plaintext

3.5 完整流程演示

让我们用一个完整的例子串起来。注意，RSA算法本身是用于加密整数的。如果要加密文本，需要先将文本（如字符串）转换为整数。

# 1. 生成密钥 p = 61 q = 53 public_key, private_key = generate_keypair(p, q) print(f"公钥: {public_key}") print(f"私钥: {private_key}") # 2. 我们的“明文”是一个数字。比如，字符‘A’的ASCII码是65。 plaintext_int = 65 print(f"\n原始明文（整数）: {plaintext_int}") # 3. 加密 ciphertext_int = encrypt(public_key, plaintext_int) print(f"加密后的密文（整数）: {ciphertext_int}") # 4. 解密 decrypted_int = decrypt(private_key, ciphertext_int) print(f"解密后的明文（整数）: {decrypted_int}") # 5. 验证 if plaintext_int == decrypted_int: print("\n✅ 加密解密成功！") else: print("\n❌ 解密失败！")

运行这段代码，你会看到密文是一个看起来随机的数字2790，而解密后又变回了65。魔法生效了！

实操心得：pow(a, b, c)是Python的内置函数，它高效地计算(a**b) % c，是实现RSA加密解密的利器。自己写循环做模幂运算不仅慢，而且容易出错。

4. 处理文本消息与常见问题

上面的例子只能加密一个很小的数字。现实中我们要加密的是句子、文件。这引出了RSA实际应用中的几个关键问题。

4.1 如何加密文本？——编码与分块

RSA的输入输出都是整数，并且这个整数必须小于模数n。所以加密文本需要两步：

1. 编码：将字符串（如“Hello”）转换为一个整数。简单的方法可以使用ASCII或UTF-8编码，将每个字符的码值拼接起来。更通用的做法是使用PKCS#1等填充标准，它不仅能编码，还能增加安全性。
2. 分块：如果文本很长，转换成的整数可能远超n。这时必须将长整数分割成多个小于n的“块”，然后对每一块分别进行RSA加密。

下面是一个极简的、不安全的演示，展示这个思想：

def text_to_int(text): """将文本转换为整数（演示用，非安全标准）。""" # 将每个字符的ASCII码转为两位数字符串，然后拼接 int_str = ''.join(f"{ord(c):03d}" for c in text) # 用3位确保如‘z’(122)也能表示 return int(int_str) def int_to_text(num): """将整数转换回文本（演示用，非安全标准）。""" num_str = str(num) # 将数字字符串按3位一组拆分，并转换回字符 # 注意：这里假设数字字符串长度是3的倍数，实际应用需更严谨处理 chars = [] for i in range(0, len(num_str), 3): code = int(num_str[i:i+3]) chars.append(chr(code)) return ''.join(chars) # 演示 message = "Hi" plain_int = text_to_int(message) # 会得到类似 072105 的整数 print(f"文本‘{message}’转换为整数: {plain_int}") # 检查是否小于n (3233) if plain_int < public_key[1]: cipher_int = encrypt(public_key, plain_int) decrypted_int = decrypt(private_key, cipher_int) decrypted_msg = int_to_text(decrypted_int) print(f"解密后的文本: {decrypted_msg}") else: print("明文整数太大，需要分块加密！")

对于长文本，你需要实现一个分块循环。但请注意，这种简单的ASCII拼接编码方式非常不安全且脆弱，极易受到攻击。在实际项目中，必须使用像PKCS#1_OAEP这样的标准填充方案，Python的cryptography库就提供了这些。

4.2 为什么我的RSA程序这么慢？

你可能已经发现，即使加密一个很小的数字，如果d很大（私钥指数通常都很大），pow(c, d, n)的计算量也不小。RSA的核心运算——大数模幂——是比较耗时的。这就是为什么RSA通常不用于直接加密大量数据（比如一个视频文件）。

实际的混合加密系统：

1. 发送方随机生成一个对称加密密钥（比如AES密钥）。对称加密（如AES）速度极快，适合加密大数据。
2. 发送方用接收方的RSA公钥，加密这个对称密钥。
3. 发送方用对称密钥加密实际的大数据（明文）。
4. 发送方将加密后的对称密钥和加密后的数据一起发送给接收方。
5. 接收方用自己的RSA私钥解密出对称密钥。
6. 接收方用解密出的对称密钥解密数据。

这样，RSA只用于加密一个很短的关键信息（对称密钥），发挥了其安全分发密钥的长处；而繁重的数据加密工作则由高效的对称加密算法完成。

4.3 常见错误与排查表

在实现和使用RSA时，你可能会遇到以下问题：

核心避坑指南：这个项目最大的价值在于理解原理，而不是造一个能用的轮子。密码学极其复杂，一个微小的实现失误（比如随机数生成质量差、填充方式不当）都可能导致整个系统被攻破。因此，“看懂”之后，请务必转向使用成熟的标准库。用from cryptography.hazmat.primitives.asymmetric import rsa, padding然后调用几行代码，比你写几百行自己实现的RSA要安全一万倍。

5. 从理解到应用：使用标准库

经过前面的折腾，你应该对RSA的里里外外有了感性认识。现在，是时候“站在巨人的肩膀上”了。我们来看看如何用Python的cryptography库，安全、正确地完成RSA加密解密。

5.1 安装与密钥生成

首先，安装这个行业标准的库：

pip install cryptography

然后，用几行代码生成一个2048位的RSA密钥对：

from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization # 生成私钥 private_key = rsa.generate_private_key( public_exponent=65537, # 标准公钥指数 key_size=2048, # 密钥长度，2048位是当前最低安全要求 ) # 从私钥导出公钥 public_key = private_key.public_key() # 将私钥以PEM格式保存到文件（务必保密！） pem_private = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption() # 生产环境应使用密码加密 ) with open('private_key.pem', 'wb') as f: f.write(pem_private) # 将公钥以PEM格式保存到文件 pem_public = public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ) with open('public_key.pem', 'wb') as f: f.write(pem_public) print("RSA密钥对已生成并保存。")

5.2 标准的加密与解密流程

现在，使用生成的密钥进行加密和解密。注意，这里使用了推荐的OAEP填充方案。

from cryptography.hazmat.primitives.asymmetric import padding from cryptography.hazmat.primitives import hashes # 待加密的消息，必须是字节串 message = b"This is a secret message that needs to be encrypted using RSA." # 使用公钥加密 # OAEP填充是当前推荐的标准，它比古老的PKCS#1 v1.5填充更安全。 ciphertext = public_key.encrypt( message, padding.OAEP( mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None ) ) print(f"密文 (十六进制): {ciphertext.hex()}") # 使用私钥解密 decrypted_message = private_key.decrypt( ciphertext, padding.OAEP( mgf=padding.MGF1(algorithm=hashes.SHA256()), algorithm=hashes.SHA256(), label=None ) ) print(f"解密后的明文: {decrypted_message.decode()}")

看到没？代码简洁，且背后是工业级的实现。加密时自动处理了填充和编码，解密时亦然。这才是你在真实项目中应该使用的方式。

5.3 数字签名与验证

RSA另一个重要用途是数字签名，用于验证消息的完整性和来源。原理是用私钥对消息的摘要进行“加密”（即签名），任何人可以用公钥“解密”（即验证）这个签名，并与重新计算的消息摘要对比。

from cryptography.hazmat.primitives.asymmetric import padding from cryptography.hazmat.primitives import hashes from cryptography.exceptions import InvalidSignature # 假设我们有一段重要的消息 message = b"Order #12345: Pay $100 to account XXX." # 1. 发送方用私钥进行签名 signature = private_key.sign( message, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) print(f"生成签名: {signature.hex()[:50]}...") # 2. 接收方用公钥验证签名 try: public_key.verify( signature, message, padding.PSS( mgf=padding.MGF1(hashes.SHA256()), salt_length=padding.PSS.MAX_LENGTH ), hashes.SHA256() ) print("✅ 签名验证成功！消息完整且来自私钥持有者。") except InvalidSignature: print("❌ 签名验证失败！消息可能被篡改或来源不可信。")

走到这一步，你已经从一个对RSA感到神秘的旁观者，变成了一个能清晰阐述其原理、能动手实现其核心流程、并懂得如何在实际中正确使用它的实践者。记住那个核心的比喻：公钥是只能锁的锁头，私钥是唯一的钥匙；记住它的安全基石是大数分解之难；更重要的是记住，理解原理是为了更好地使用工具，而非取代工具。在安全领域，使用经过千锤百炼的标准库，永远是第一选择。