用Python代码实战AES和RSA：5分钟掌握加密核心差异

加密技术就像数字世界的锁与钥匙——但为什么有的锁用同一把钥匙开闭（AES），有的却需要两把不同的钥匙（RSA）？今天我们不谈枯燥的理论，直接动手写代码，让加密过程自己"说话"。

1. 环境准备与基础概念

在开始前，确保已安装Python 3.8+和 pycryptodome 库：

pip install pycryptodome

对称加密 就像保险箱的机械锁——加密解密用同一把钥匙（密钥）。它的典型代表是AES算法，处理速度快，适合加密大量数据。但问题在于：如何安全地把钥匙交给对方？

非对称加密 则像现代电子锁系统：公钥是任何人都能用的锁头，私钥是唯一能开锁的指纹。RSA是这类算法的代表，虽然速度慢，但彻底解决了密钥分发难题。

提示：实际系统中常组合使用两者——用RSA传递AES密钥，再用AES加密主体数据

2. AES对称加密实战

让我们实现一个完整的AES加密流程。注意观察：相同输入永远产生相同输出。

from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
import base64

# 密钥必须是16/24/32字节长度
key = b'this_is_a_test_key_32_bytes_long!'
data = "我是需要保护的敏感数据"

# 加密过程
cipher = AES.new(key, AES.MODE_CBC)  # 使用CBC模式
ct_bytes = cipher.encrypt(pad(data.encode(), AES.block_size))
iv = cipher.iv  # 初始化向量
encrypted = base64.b64encode(iv + ct_bytes).decode()

print(f"加密结果：{encrypted}")

# 解密过程
raw = base64.b64decode(encrypted)
iv, ct = raw[:16], raw[16:]  # 分离IV和密文
cipher = AES.new(key, AES.MODE_CBC, iv=iv)
pt = unpad(cipher.decrypt(ct), AES.block_size).decode()

print(f"解密结果：{pt}")

关键观察点：

• 每次运行加密结果相同（前提是IV固定）
• 加密解密使用完全相同的密钥
• 必须处理数据块大小对齐（使用pad/unpad）

AES典型参数对比 ：

参数类型	可选值	安全建议
密钥长度	128/192/256位	推荐256位
工作模式	ECB/CBC/CFB等	避免ECB模式
填充方案	PKCS7/ISO7816	使用标准PKCS7

3. RSA非对称加密实战

现在实现RSA加密，注意每次运行结果都不同：

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

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

# 加密函数
def rsa_encrypt(pub_key, message):
    cipher = PKCS1_OAEP.new(RSA.import_key(pub_key))
    return base64.b64encode(cipher.encrypt(message.encode()))

# 解密函数  
def rsa_decrypt(priv_key, ciphertext):
    cipher = PKCS1_OAEP.new(RSA.import_key(priv_key))
    return cipher.decrypt(base64.b64decode(ciphertext)).decode()

# 测试加密
message = "机密交易数据"
encrypted = rsa_encrypt(public_key, message)
print(f"加密结果：{encrypted.decode()}")

# 测试解密
decrypted = rsa_decrypt(private_key, encrypted)
print(f"解密结果：{decrypted}")

RSA的核心特点：

1. 公钥加密的数据只能用私钥解密
2. 每次加密结果不同（因随机填充机制）
3. 密钥对生成涉及大素数运算

RSA与AES性能对比测试 ：

import timeit

# 测试AES速度
aes_time = timeit.timeit(
    lambda: cipher.encrypt(pad(data.encode(), AES.block_size)),
    setup='from __main__ import cipher, data, AES, pad',
    number=1000
)

# 测试RSA速度
rsa_time = timeit.timeit(
    lambda: rsa_encrypt(public_key, message),
    setup='from __main__ import rsa_encrypt, public_key, message, RSA, PKCS1_OAEP',
    number=100
)

print(f"AES 1000次加密耗时：{aes_time:.3f}秒")
print(f"RSA 100次加密耗时：{rsa_time:.3f}秒")

典型输出结果：

• AES：约0.2秒/千次
• RSA：约1.5秒/百次

4. 混合加密系统实战

结合两者优势的典型方案：

def hybrid_encrypt(rsa_pub_key, data):
    # 生成随机AES密钥
    aes_key = get_random_bytes(32)  # AES-256
    
    # 用AES加密数据
    cipher = AES.new(aes_key, AES.MODE_GCM)
    ct, tag = cipher.encrypt_and_digest(data.encode())
    
    # 用RSA加密AES密钥
    rsa_cipher = PKCS1_OAEP.new(RSA.import_key(rsa_pub_key))
    enc_key = rsa_cipher.encrypt(aes_key)
    
    return {
        'ciphertext': base64.b64encode(ct).decode(),
        'tag': base64.b64encode(tag).decode(),
        'nonce': base64.b64encode(cipher.nonce).decode(),
        'encrypted_key': base64.b64encode(enc_key).decode()
    }

def hybrid_decrypt(rsa_priv_key, encrypted_data):
    # RSA解密AES密钥
    rsa_cipher = PKCS1_OAEP.new(RSA.import_key(rsa_priv_key))
    aes_key = rsa_cipher.decrypt(base64.b64decode(encrypted_data['encrypted_key']))
    
    # AES解密数据
    cipher = AES.new(aes_key, AES.MODE_GCM, 
                    nonce=base64.b64decode(encrypted_data['nonce']))
    pt = cipher.decrypt_and_verify(
        base64.b64decode(encrypted_data['ciphertext']),
        base64.b64decode(encrypted_data['tag'])
    )
    
    return pt.decode()

这种架构的典型应用场景包括：

• HTTPS/SSL协议
• 加密文件传输系统
• 安全即时通讯工具

5. 关键差异与选型指南

通过实际代码测试，我们可以总结出核心差异：

密钥管理 ：

• AES：单密钥，需安全通道传输
• RSA：密钥对，公钥可公开分发

性能对比 ：

指标	AES-256	RSA-2048
加密速度	~500MB/s	~0.1MB/s
适合场景	大数据量	小数据量

安全特性 ：

• AES：依赖密钥保密性
• RSA：依赖大整数分解难度

重要提示：实际应用中永远不要自己实现加密算法，应使用经过验证的库（如Python的cryptography）

在金融级应用中，我通常会这样选择：

1. 用户密码存储：AES加密+盐值哈希
2. API通信：RSA交换密钥+AES加密数据
3. 数字签名：RSA私钥签名+公钥验证