从DES算法详解到Python实现：深入理解对称加密基石-育师

1. 项目概述：为什么我们今天还要聊DES？

如果你刚接触密码学，或者正在学习网络安全、数据安全相关的课程，DES（Data Encryption Standard，数据加密标准）这个名字大概率是你绕不开的第一个“大BOSS”。它诞生于上世纪70年代，由IBM设计，并在1977年被正式采纳为美国联邦信息处理标准。在长达二十多年的时间里，它几乎是全球商业和金融领域数据加密的代名词，是密码学从古典走向现代的一个里程碑。但今天，随便一个技术论坛都会告诉你：DES已经不安全了，别用了，快换成AES。那么，一个已经被“淘汰”的算法，为什么还值得我们花时间“详解”呢？

我的看法是，理解DES，是理解现代对称加密的基石。它就像一个经典的建筑模型，虽然今天我们已经用更坚固的钢材和混凝土盖摩天大楼，但学习这个模型，能让你透彻理解地基怎么打、承重墙如何设计、梁柱如何连接。DES首次系统性地将复杂的数学理论（如置换、代换、混淆、扩散）工程化，形成了一套清晰、可硬件实现、可软件模拟的加密流程。今天广泛使用的AES（高级加密标准），其设计思想（如多轮迭代、S盒代换）都能在DES中找到影子。更重要的是，DES的“不安全”本身就是一个绝佳的学习案例——它如何被设计，又如何在算力增长下被攻破，这背后是密码分析学的发展史，能让你深刻体会到“安全是一个动态过程，而非静态结果”这一核心安全观。

所以，这篇内容不是一份“考古报告”，而是一份“解剖学指南”。我将带你从零开始，亲手用Python实现一遍DES的加密和解密全过程。在这个过程中，我会拆解每一个步骤背后的数学原理和设计意图，分享我在实现过程中踩过的坑和调试技巧。无论你是学生、开发者，还是对密码学感兴趣的安全爱好者，通过这次“手搓DES”的旅程，你收获的将不仅仅是一个过时的算法代码，而是一套理解所有分组密码的思维框架。准备好了吗？我们开始。

2. DES算法核心原理与设计思想拆解

在动手写代码之前，我们必须先搞清楚DES到底在干什么。它不是一个黑盒子，而是一台精密的、由多个齿轮（运算）咬合而成的机器。理解每个齿轮的作用，是后续调试和深入学习的根本。

2.1 核心框架：Feistel网络结构

DES采用了一种称为Feistel网络的结构。这是它最精妙的设计之一，也是其影响深远的原因。简单来说，Feistel结构将一个加密过程，分解为多轮（DES是16轮）完全相同的操作。每一轮的操作都只处理一半的数据，并且加密和解密可以使用几乎相同的算法流程，这极大地简化了硬件和软件的实现。

我们来打个比方：假设你有一张珍贵的双面照片，想把它锁进保险箱。Feistel结构的做法不是把整张照片一次性处理，而是：

把照片撕成左半张（L0）和右半张（R0）。
第一轮：把右半张（R0）拿出来，用密钥加工一下，得到一个“加工后的右半张”。然后把这个“加工后的右半张”和左半张（L0）进行一个特殊的混合操作（通常是异或XOR），得到一个新的左半张（L1）。而原来的右半张（R0）直接变成新的右半张（R1）。
后续每一轮都重复这个操作：新的左半张是上一轮的右半张，新的右半张是上一轮的左半张和“加工后的上一轮右半张”的混合结果。
经过多轮之后，最后再把左、右半张交换一下位置，拼接起来，就得到了密文。

这个结构的神奇之处在于，解密过程几乎是加密的逆过程，只需要把子密钥的使用顺序倒过来即可。这意味着在硬件设计时，加密和解密电路可以大量复用，节省成本。DES的16轮迭代，正是基于此结构。

2.2 核心运算：从64位到64位的奇幻旅程

DES处理的是64位（8字节）的明文分组，输出64位的密文分组。使用的密钥名义上是64位，但其中8位是奇偶校验位（用于检测密钥在传输或存储中是否出错），实际参与加密运算的只有56位。整个加密过程可以概括为三个大阶段：初始置换（IP）、16轮Feistel迭代、最终置换（IP⁻¹）。

初始置换（IP）与最终置换（IP⁻¹）：这俩是“门卫”和“反向门卫”。IP在加密开始时，把输入的64位明文数据位按照一个固定的表重新排列一下顺序。IP⁻¹在加密结束时，把经过16轮折腾的数据再按另一个固定的表排列回来。它们本身不提供密码学强度（因为置换表是公开的），主要目的是为了打乱数据输入输出的顺序，方便早期硬件实现时数据加载到寄存器中。一个常见的误解是它们增加了安全性，其实不然，它们更像是一个格式转换的步骤。

16轮迭代的核心——轮函数F：这是DES安全性的心脏。每一轮中，轮函数F都会对输入的32位数据（即上一轮的右半部分R）进行一系列复杂的变换，然后与左半部分L进行异或。轮函数F内部又包含四个关键步骤：

扩展置换（E）：将32位的输入，通过重复某些位，扩展成48位。目的是为了与48位的子密钥进行匹配，同时让输入的一位能影响下一轮多个S盒的输入，实现“扩散”。
与子密钥异或（XOR）：将扩展后的48位数据，与本轮生成的48位子密钥进行按位异或运算。这是将密钥材料“混入”数据的关键一步。
S盒代换（S-Box Substitution）：这是DES中唯一非线性的步骤，是算法保密性的核心来源。它将异或后的48位数据，分成8组，每组6位。每一组6位输入，通过一个查找表（S盒），输出4位。8个S盒一共输出32位。S盒的设计非常精妙，它实现了“混淆”，使得输入和输出之间的关系极其复杂，难以用数学方程描述。
P盒置换（P）：将S盒输出的32位数据，再按照一个固定的置换表重新排列。目的是将S盒输出的比特位打散到不同的位置，使得经过多轮后，明文中的一个比特位能影响到密文中的许多比特位，进一步加强“扩散”效果。

子密钥生成：DES的56位主密钥，在每一轮都会生成一个不同的48位子密钥（Ki）。生成过程也涉及置换和循环左移。正是这16个不同的子密钥，确保了每一轮的运算都是独特的，增加了密码分析的难度。

注意：很多人初学时会纠结于IP、E、P这些置换表的具体数字。我的建议是，在理解其作用（打乱、扩展、压缩、混淆、扩散）后，实现时直接查标准表格即可，不必记忆。重点在于理解数据流是如何在这些盒子（Box）中流动和变化的。

3. 手把手实现DES加解密：从理论到代码

理解了原理，我们就用Python把它实现出来。我会分模块讲解，并提供完整的、可运行的代码片段。我们选择Python是因为它语法清晰，易于理解算法逻辑。在实际生产环境中，加密解密应使用经过严格审计的成熟库（如Python的pycryptodome），但自己实现一遍是无可替代的学习过程。

3.1 基础工具函数与常量定义

首先，我们需要定义DES算法中所有用到的固定置换表、S盒等常量。这些值在标准文档（如FIPS PUB 46-3）中是公开的。为了节省篇幅，我这里列出最关键的几个，完整的表你可以在任何标准的DES资料中找到。

# DES 常量定义 (部分示例，完整实现需补全所有表) # 初始置换IP表 (64位 -> 64位) IP = [58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, ... # 省略中间部分 15, 7, 62, 54, 46, 38, 30, 22] # 最终逆置换IP^-1表 IP_INV = [40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, ... # 省略 33, 1, 41, 9, 49, 17, 57, 25] # 扩展置换E表 (32位 -> 48位) E = [32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, ... # 省略 28, 29, 30, 31, 32, 1] # S盒 (8个，每个将6位输入映射为4位输出) # 每个S盒是一个4x16的矩阵 S_BOX = [ # S1 [ [14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7], [0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8], [4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0], [15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13] ], # S2 ... S8 省略，需补全 ] # P盒置换表 (32位 -> 32位) P = [16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10, ... # 省略 19, 13, 30, 6] # 子密钥生成相关的置换表 (PC-1, PC-2, 循环左移表等) PC1 = [57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18, ... # 省略 44, 36] # 从64位密钥中选出56位 PC2 = [14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10, 23, 19, 12, 4, ... # 省略 41, 52, 31, 37] # 从56位中压缩置换出48位子密钥 # 每轮循环左移的位数 SHIFT_SCHEDULE = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1]

接下来，我们需要一些基础工具函数来处理比特位。DES的所有操作都是基于比特位的，所以我们需要在字节（byte）和比特位列表（list of bits）之间进行转换。

def text_to_bits(text, encoding='utf-8'): """将文本字符串转换为比特位列表（0/1列表）。""" bits = [] for byte in text.encode(encoding): # 将每个字节转换为8位二进制，高位在前 bits.extend([(byte >> i) & 1 for i in range(7, -1, -1)]) return bits def bits_to_text(bits, encoding='utf-8'): """将比特位列表转换回文本字符串。""" bytes_list = [] # 每8位组成一个字节 for i in range(0, len(bits), 8): byte = 0 chunk = bits[i:i+8] if len(chunk) < 8: # 不足8位，填充0（根据实际情况，DES要求分组填充，这里简单处理） chunk = chunk + [0] * (8 - len(chunk)) for j, bit in enumerate(chunk): byte |= (bit << (7 - j)) bytes_list.append(byte) return bytes(bytes_list).decode(encoding, errors='ignore') def bits_to_hex(bits): """将比特位列表转换为十六进制字符串，方便查看。""" hex_str = '' for i in range(0, len(bits), 8): byte = 0 chunk = bits[i:i+8] for j, bit in enumerate(chunk): byte |= (bit << (7 - j)) hex_str += f'{byte:02x}'.upper() return hex_str def hex_to_bits(hex_str): """将十六进制字符串转换为比特位列表。""" bits = [] for i in range(0, len(hex_str), 2): byte = int(hex_str[i:i+2], 16) bits.extend([(byte >> i) & 1 for i in range(7, -1, -1)]) return bits def permute(bits, permutation_table): """根据给定的置换表，对比特位列表进行置换。这是DES中最基础的操作。""" return [bits[i - 1] for i in permutation_table] # 注意：标准表中位置从1开始计数

实操心得：在实现permute函数时，要特别注意置换表的下标。标准文档中的位置索引通常从1开始，而Python列表索引从0开始。所以bits[i - 1]是正确写法。这是初学者最容易出错的地方之一，会导致整个加密结果完全错误。

3.2 子密钥生成模块详解

DES的16轮迭代，每一轮都需要一个独特的48位子密钥。这些子密钥都来源于最初的56位有效密钥。

def generate_subkeys(key_bits): """从64位密钥（含8位奇偶校验）生成16个48位子密钥。""" # 1. 使用PC-1置换，从64位中选取56位有效密钥位，并忽略校验位 key_56 = permute(key_bits, PC1) # 2. 将56位分成左右两部分，各28位 left = key_56[:28] right = key_56[28:] subkeys = [] # 3. 进行16轮，生成16个子密钥 for round_num in range(16): # 3.1 根据轮次表，对左右两部分进行循环左移 shift = SHIFT_SCHEDULE[round_num] left = left[shift:] + left[:shift] right = right[shift:] + right[:shift] # 3.2 将移动后的左右两部分合并成56位 combined = left + right # 3.3 使用PC-2置换，从56位中压缩选择出48位子密钥 subkey = permute(combined, PC2) subkeys.append(subkey) return subkeys

为什么需要循环左移？循环左移的目的是让每一轮用于生成子密钥的比特位组合都不同。通过简单的位移操作，就能让密钥材料在每一轮都发生微妙的变化，从而产生出16个看似相关但又不同的子密钥，增加了密码分析的复杂度。位移表[1,1,2,2,...]的设计是经过密码学家分析的，旨在达到良好的扩散效果。

3.3 核心轮函数F的实现

轮函数F是DES算法安全性的灵魂，它接收32位的右半部分输入（R）和48位的子密钥（K），输出32位的结果。

def f_function(right_bits, subkey): """DES的轮函数F。""" # 1. 扩展置换：将32位扩展到48位，以便与子密钥进行异或 expanded = permute(right_bits, E) # 2. 与子密钥异或：将密钥材料混入数据 xored = [expanded[i] ^ subkey[i] for i in range(48)] # 3. S盒代换：48位输入 -> 32位输出 (非线性核心) sbox_output = [] for i in range(8): # 8个S盒 # 取出6位输入 chunk = xored[i*6 : (i+1)*6] # 计算S盒的行和列索引 # 第一位和最后一位组成行号（二进制） row = (chunk[0] << 1) | chunk[5] # 中间四位组成列号（二进制） col = (chunk[1] << 3) | (chunk[2] << 2) | (chunk[3] << 1) | chunk[4] # 从对应的S盒中查找输出值（0-15） sbox_value = S_BOX[i][row][col] # 将输出值转换为4位二进制，添加到结果中 sbox_output.extend([(sbox_value >> j) & 1 for j in range(3, -1, -1)]) # 4. P盒置换：将S盒输出的32位打乱 output = permute(sbox_output, P) return output

注意事项：S盒代换是DES实现中最容易出错的环节。一是要确保你使用的S盒数据完全准确，一个数字错误就会导致加解密失败。二是索引计算要正确：6位输入b1b2b3b4b5b6，行号是b1b6（即第1位和第6位），列号是b2b3b4b5（中间4位）。很多开源实现在这里栽过跟头。

3.4 整合主加密与解密流程

有了子密钥生成和轮函数，我们就可以组装完整的DES加密流程了。解密流程与加密几乎完全相同，唯一的区别是子密钥的使用顺序相反（即第16轮子密钥用于第一轮解密，第15轮用于第二轮，以此类推）。这正是Feistel网络结构的优美之处。

def des_crypt(input_bits, subkeys, is_encrypt=True): """DES的核心加密/解密函数。 input_bits: 64位输入数据（明文或密文） subkeys: 16个48位子密钥列表 is_encrypt: True为加密，False为解密 """ # 1. 初始置换IP permuted = permute(input_bits, IP) # 2. 分成左右两部分，各32位 left = permuted[:32] right = permuted[32:] # 3. 16轮Feistel迭代 for round_num in range(16): # 决定使用第几个子密钥 if is_encrypt: subkey = subkeys[round_num] # 加密：K1, K2, ..., K16 else: subkey = subkeys[15 - round_num] # 解密：K16, K15, ..., K1 # 保存当前的右半部分，它将变成下一轮的左半部分 old_right = right[:] # 轮函数F处理右半部分，然后与左半部分异或，得到新的右半部分 f_result = f_function(old_right, subkey) new_right = [left[i] ^ f_result[i] for i in range(32)] # 更新左右部分 left = old_right right = new_right # 4. 16轮结束后，交换左右（Feistel网络的最后一步） combined = right + left # 5. 最终逆置换IP^-1 output_bits = permute(combined, IP_INV) return output_bits def des_encrypt(plaintext_bits, key_bits): """DES加密。""" subkeys = generate_subkeys(key_bits) # 确保输入是64位的倍数，这里简化处理，假设输入正好是64位 # 实际应用中需要对明文进行分组和填充（如PKCS#7） cipher_bits = des_crypt(plaintext_bits, subkeys, is_encrypt=True) return cipher_bits def des_decrypt(ciphertext_bits, key_bits): """DES解密。""" subkeys = generate_subkeys(key_bits) plain_bits = des_crypt(ciphertext_bits, subkeys, is_encrypt=False) return plain_bits

3.5 完整示例与测试

让我们用一个经典的测试向量来验证我们的实现。NIST（美国国家标准与技术研究院）等机构发布过标准的DES测试数据，用于验证实现的正确性。

def test_des(): """使用已知的测试向量验证DES实现是否正确。""" # 测试用例：明文、密钥、密文 (十六进制表示) # 这是一个广为人知的测试向量 plaintext_hex = "0123456789ABCDEF" key_hex = "133457799BBCDFF1" # 注意：密钥是64位，包含校验位 expected_cipher_hex = "85E813540F0AB405" # 预期的加密结果 # 转换为比特位列表 plain_bits = hex_to_bits(plaintext_hex) key_bits = hex_to_bits(key_hex) print(f"明文: {plaintext_hex}") print(f"密钥: {key_hex}") # 加密 cipher_bits = des_encrypt(plain_bits, key_bits) cipher_hex = bits_to_hex(cipher_bits) print(f"加密结果: {cipher_hex}") print(f"预期结果: {expected_cipher_hex}") print(f"加密是否正确: {cipher_hex == expected_cipher_hex}") # 解密 decrypted_bits = des_decrypt(cipher_bits, key_bits) decrypted_hex = bits_to_hex(decrypted_bits) print(f"解密结果: {decrypted_hex}") print(f"解密是否正确: {decrypted_hex == plaintext_hex}") if __name__ == "__main__": test_des()

运行这段代码，如果实现正确，你应该看到加密结果与85E813540F0AB405完全一致，并且解密后能恢复出原始明文0123456789ABCDEF。

4. DES的安全性分析：它为何被淘汰？

通过亲手实现，我们感受到了DES设计的精巧。但一个无法回避的问题是：它为什么不再安全了？这需要从密码分析学和计算能力的发展两个角度来看。

4.1 密钥长度过短：56位的致命伤

DES安全性的最大短板在于其56位的有效密钥长度。在1970年代设计时，56位密钥（2⁵⁶ ≈ 7.2×10¹⁶种可能）被认为是足够强大的，因为当时的计算能力无法在合理时间内穷举所有可能。

然而，根据摩尔定律，计算能力大约每18-24个月翻一番。到了90年代末，情况发生了根本变化：

1997年：RSA安全公司发起“DES挑战赛”，通过互联网分布式计算，用了96天破解了一个DES加密的消息。
1998年：电子前沿基金会（EFF）建造了一台名为“Deep Crack”的专用硬件，耗资约25万美元，在56小时内成功破解DES。
1999年：在更优化的分布式计算和硬件下，破解时间被缩短到22小时15分钟。

这清晰地表明，56位的密钥空间在当代计算能力面前已经显得过于局促。暴力穷举攻击（Brute-force Attack）在可接受的时间和成本内变得可行。作为对比，目前AES标准推荐的最小密钥长度是128位（2¹²⁸种可能），其搜索空间是DES的2⁷²倍，这是一个天文数字的差距。

4.2 算法本身的密码学分析

除了暴力破解，密码学家也对DES的算法结构进行了深入分析，发现了一些理论上的弱点，尽管这些弱点在实际攻击中不如密钥长度问题那么致命：

互补性：若明文P的补码为P‘，密钥K的补码为K’，则密文C的补码等于用K‘加密P’的结果。这一特性在某些选择明文攻击场景下可能减少一半的搜索工作量。
弱密钥和半弱密钥：由于DES子密钥生成算法的特性，存在极少数（已知4个）弱密钥和若干半弱密钥。使用这些密钥加密时，会导致加密函数自逆（即加密两次等于没加密）或成对出现安全性降低。不过，在随机生成密钥时，碰到它们的概率极低（约2⁻⁵⁵），实践中可以忽略。
线性密码分析和差分密码分析：这是两种强大的密码分析技术。DES的设计者其实已经知晓差分密码分析（该技术多年后才被公开），并在设计S盒时考虑了抵御这种攻击。事实上，DES对这两种攻击的抵抗能力在当时是超前的。但密钥太短，使得这些复杂的分析手段在暴力破解面前都显得“大材小用”了。

4.3 应对措施与演进：3DES

在AES诞生之前，为了延长DES的使用寿命，业界提出了三重DES。

3DES-EDE：这是最常用的模式。它使用两个或三个独立的密钥（K1, K2, K3），执行“加密-解密-加密”操作：Ciphertext = Encrypt_K1(Decrypt_K2(Encrypt_K3(Plaintext)))。
为什么是“加密-解密-加密”而不是三次加密？主要是为了兼容性。当K1=K2=K3时，3DES就退化成了单次DES，这有助于系统平滑过渡。同时，这种结构在某些情况下能抵御某些类型的攻击。
安全性：使用三个独立密钥的3DES（密钥长度168位，有效安全强度约112位）大大增加了暴力破解的难度。但它也有明显缺点：速度慢（是DES的三倍），并且仍然基于旧的DES算法块。

最终，在1997年NIST发起征集更先进算法的活动，并在2001年正式宣布Rijndael算法成为高级加密标准，即AES。AES具有更长的密钥（128/192/256位）、更高效的计算性能（尤其利于软件实现）和经过更严格公开分析的设计，全面取代了DES和3DES。

5. 从DES到现代加密：经验、教训与最佳实践

自己实现一遍DES，除了学习算法，更能从中提炼出对现代密码学应用至关重要的经验和教训。

5.1 实现DES过程中的常见“坑”与调试技巧

即使理解了原理，实现时也难免出错。以下是我在实现和教学过程中总结的几个高频问题点：

比特序和字节序问题：这是最大的“坑”。DES标准文档描述的是比特位的操作，并且通常规定最高位（Most Significant Bit, MSB）为第1位。而我们在编程时，数据在内存或变量中是以字节为单位存储的，并且不同系统、不同函数对字节内比特的顺序（大端/小端）处理可能不同。在我们的实现中，text_to_bits函数明确规定了“高位在前”的顺序，并与置换表（下标从1开始）匹配。一旦顺序搞反，结果必然错误。
- 调试技巧：在关键步骤（如IP置换后、每轮F函数输入输出、最终结果）打印出比特位或十六进制中间值，与已知的、逐步的测试向量进行比对。网上可以找到一些展示DES中间轮次结果的详细例子。
S盒查找错误：S盒是二维表，行和列的索引计算必须严格按照标准。row = (bit1, bit6)，col = (bit2, bit3, bit4, bit5)。用错一位，整个加密链就断了。
- 调试技巧：单独编写一个S盒测试函数，输入一个6位分组，手动计算其行号和列号，然后对照标准S盒表检查输出值是否正确。
子密钥生成错误：PC-1、PC-2置换表，以及循环左移表SHIFT_SCHEDULE必须完全正确。一个常见的错误是忽略了密钥中的奇偶校验位，或者置换表数据录入错误。
- 调试技巧：单独测试generate_subkeys函数，对于一个给定的测试密钥，打印出每一轮生成的子密钥（十六进制形式），与标准值对比。
加解密不对应：如果加密结果正确但解密失败，99%的原因是子密钥使用顺序错了。牢记：解密时子密钥顺序反向。

实操心得：在编写密码学算法时，单元测试至关重要。不要试图一次性写完整个算法再测试。应该为每个核心函数（permute,generate_subkeys,f_function）都编写独立的测试，使用标准测试向量中的中间值进行验证。这能帮你快速定位问题模块。

5.2 DES留给我们的现代密码学启示

密钥长度是关键：DES的陨落最直接地告诉我们，对抗暴力破解，足够长的密钥空间是首要条件。今天，对于对称加密，128位是最低要求，256位用于更高安全层级。
算法必须公开并经过充分验证：DES的设计细节（除了S盒的设计准则曾一度保密）是公开的。正是这种公开，才吸引了全球密码学家几十年的分析，最终大家确认其结构是坚固的（除了密钥短）。这确立了“安全不依赖于算法的保密，而依赖于密钥的保密”这一柯克霍夫原则。现代密码算法如AES、SHA-3都是经过全球性公开竞赛和多年分析筛选出来的。
分组密码的工作模式：DES是分组密码，一次加密64位。如何用它对更长的消息加密？这就需要工作模式，如ECB、CBC、CFB、OFB、CTR等。ECB模式（直接对每个分组独立加密）是不安全的，因为它会暴露明文的模式。现代应用普遍推荐使用带随机初始化向量（IV）的CBC模式或CTR模式。理解DES后，再学习这些模式会容易得多。
不要自己发明加密算法，也不要自己实现用于生产的加密：这是最重要的实践准则。我们学习、实现DES是为了理解，但绝对不要在自己重要的项目中使用这段教学代码。生产环境必须使用久经考验的、经过严格审计的密码学库，如Python的cryptography库、pycryptodome，或系统的原生API。这些库经过了无数专家的审查、优化，并正确处理了诸如填充、工作模式、侧信道攻击防护等我们教学代码中完全忽略的复杂问题。