现代密码学实战：Python实现3种经典密码（凯撒、维吉尼亚、RSA）

引言：当Python遇见密码学

想象一下，你正在给朋友发送一条秘密消息，希望只有他能读懂。这种需求自古就有——从凯撒大帝用位移密码传递军令，到二战时期图灵破解Enigma机拯救无数生命，密码学始终在历史舞台上扮演关键角色。今天，任何使用HTTPS协议的网站、每次手机指纹解锁、每笔加密货币交易，背后都闪烁着密码学的智慧光芒。

本文将带你用Python亲手实现三类标志性密码：凯撒密码（单表替换）、维吉尼亚密码（多表替换）和RSA算法（非对称加密）。不同于理论教材的抽象描述，我们将通过可运行的代码直观展示：

• 如何用5行Python实现凯撒加密
• 为什么维吉尼亚密码能抵抗频率分析
• RSA算法中欧拉定理如何保障安全
• 古典密码在现代计算设备面前的脆弱性

# 预告：凯撒密码的Python实现预览 def caesar_encrypt(text, shift): return ''.join( chr((ord(char) - 97 + shift) % 26 + 97) if char.islower() else char for char in text.lower() )

1. 凯撒密码：单表替换的古典智慧

1.1 算法原理与实现

凯撒密码作为最古老的加密方法之一，其核心思想是字母表位移。将明文字母按固定位数替换为字母表中后续字母（超出Z则循环回到A）。例如位移3时：

• A → D
• B → E
• X → A
• Z → C

完整Python实现：

def caesar_cipher(text, shift, mode='encrypt'): result = [] for char in text: if char.isalpha(): base = ord('a') if char.islower() else ord('A') offset = (ord(char) - base + shift) % 26 if mode == 'decrypt': offset = (ord(char) - base - shift) % 26 result.append(chr(base + offset)) else: result.append(char) return ''.join(result) # 使用示例 plaintext = "Attack at dawn!" shift = 5 ciphertext = caesar_cipher(plaintext, shift) print(f"加密结果: {ciphertext}") # 输出: Fyyfhp fy ifbs!

1.2 安全性分析与破解演示

凯撒密码的致命弱点在于仅有26种可能的密钥。现代计算机可在毫秒级完成暴力破解：

def caesar_brute_force(ciphertext): for shift in range(26): print(f"Shift {shift}: {caesar_cipher(ciphertext, shift, 'decrypt')}") # 破解示例 caesar_brute_force("Fyyfhp fy ifbs!")

典型攻击方式对比表：

密码学第一课：柯克霍夫原则指出，密码系统安全性应仅依赖于密钥的保密，而非算法的保密。这正是凯撒密码被淘汰的根本原因。

2. 维吉尼亚密码：多表替换的进阶方案

2.1 多表替换机制解析

维吉尼亚密码通过引入密钥词实现动态位移，例如密钥"KEY"：

• 第1字母位移K(10)
• 第2字母位移E(4)
• 第3字母位移Y(24)
• 第4字母循环回K(10)

def vigenere_cipher(text, key, mode='encrypt'): result = [] key_repeated = (key * (len(text) // len(key) + 1))[:len(text)] for i, char in enumerate(text): if char.isalpha(): key_char = key_repeated[i] shift = ord(key_char.lower()) - ord('a') base = ord('a') if char.islower() else ord('A') if mode == 'encrypt': offset = (ord(char) - base + shift) % 26 else: offset = (ord(char) - base - shift) % 26 result.append(chr(base + offset)) else: result.append(char) return ''.join(result) # 加密示例 print(vigenere_cipher("Hello World", "KEY")) # 输出: Rijvs Uyvjn

2.2 卡西斯基测试破解法

尽管维吉尼亚密码安全性显著提升，但仍有被破解的可能。1863年Friedrich Kasiski提出的方法：

1. 在密文中寻找重复的3个以上字母组合
2. 计算这些重复片段之间的距离
3. 距离的公约数很可能是密钥长度

def find_repeated_sequences(ciphertext, min_len=3): sequences = {} for i in range(len(ciphertext) - min_len + 1): seq = ciphertext[i:i+min_len] if seq.isalpha(): sequences.setdefault(seq, []).append(i) return {k: v for k, v in sequences.items() if len(v) > 1} # 示例：分析密文中重复序列 ciphertext = vigenere_cipher("The quick brown fox jumps over the lazy dog", "password") print(find_repeated_sequences(ciphertext))

3. RSA算法：非对称加密的数学之美

3.1 密钥生成与数论基础

RSA算法基于大数分解难题，密钥生成过程：

1. 选择两个大质数p和q（示例使用小质数便于演示）
2. 计算n = p * q
3. 计算欧拉函数φ(n) = (p-1)*(q-1)
4. 选择e使得1 < e < φ(n)且与φ(n)互质
5. 计算d ≡ e⁻¹ mod φ(n)

from math import gcd from random import randrange def generate_rsa_keys(p, q): n = p * q phi = (p-1) * (q-1) # 选择公钥e e = next(i for i in range(3, phi, 2) if gcd(i, phi) == 1) # 计算私钥d (模反元素) d = pow(e, -1, phi) return (e, n), (d, n) # 示例：生成密钥对 public_key, private_key = generate_rsa_keys(61, 53) print(f"公钥: {public_key}\n私钥: {private_key}")

3.2 加密解密实现

RSA加密本质是模幂运算：

• 加密: c ≡ mᵉ mod n
• 解密: m ≡ cᵈ mod n

def rsa_encrypt(message, public_key): e, n = public_key return [pow(ord(char), e, n) for char in message] def rsa_decrypt(ciphertext, private_key): d, n = private_key return ''.join(chr(pow(num, d, n)) for num in ciphertext) # 使用示例 message = "HELLO" encrypted = rsa_encrypt(message, public_key) print(f"加密结果: {encrypted}") decrypted = rsa_decrypt(encrypted, private_key) print(f"解密结果: {decrypted}")

3.3 实际应用中的关键问题

真实场景中的RSA需要考虑：

1. 填充方案：直接加密小整数会导致安全问题，需使用OAEP等填充方案
2. 密钥长度：现代推荐使用至少2048位密钥
3. 性能优化：使用中国剩余定理(CRT)加速解密

# 使用PKCS1_OAEP填充的完整示例 from Crypto.Cipher import PKCS1_OAEP from Crypto.PublicKey import RSA # 生成2048位密钥 key = RSA.generate(2048) public_key = key.publickey() # 加密解密 cipher = PKCS1_OAEP.new(public_key) encrypted = cipher.encrypt(b"Secret Message") print(f"加密长度: {len(encrypted)} bytes") cipher = PKCS1_OAEP.new(key) decrypted = cipher.decrypt(encrypted) print(f"解密结果: {decrypted.decode()}")

4. 密码算法的实战对比与演进思考

4.1 性能测试对比

我们在相同环境测试三种算法的性能（处理1MB数据）：

注：实际应用中RSA通常用于密钥交换，配合AES等对称算法使用

4.2 密码学发展前沿

当前密码学正面临量子计算的挑战：

1. Shor算法：可在多项式时间内破解RSA和ECC
2. Grover算法：将对称密钥的安全强度减半
3. 抗量子密码：基于格密码(Lattice)、哈希签名等新体系

# 示例：基于格的NTRU加密算法 from ntru import Ntru # 参数设置 N = 503 # 安全参数 p = 3 # 小模数 q = 2048 # 大模数 # 密钥生成 ntru = Ntru(N, p, q) public_key = ntru.get_public_key() private_key = ntru # 加密解密 message = "Hello".encode() ciphertext = ntru.encrypt(message, public_key) plaintext = ntru.decrypt(ciphertext) print(f"NTRU解密结果: {plaintext.decode()}")

结语：从历史到未来的密码之旅

在完成这三个密码的实现后，我深刻体会到密码学中"安全性"与"实用性"的永恒博弈。凯撒密码的简洁之美令人赞叹，但在现代计算面前不堪一击；RSA的数学精巧性让人着迷，却又面临量子计算的威胁。这或许正是密码学的魅力所在——它永远在攻击与防御的动态平衡中演进。

当你在浏览器地址栏看到那个小锁图标时，不妨想想背后是两千多年的密码学发展史。从羊皮纸上的字母位移，到数论中的模幂运算，人类对通信安全的追求从未停止。而作为开发者，理解这些基础原理不仅能帮助我们构建更安全的系统，更是在数字时代生存的必备技能。