1. 从一次数据泄露事件说起：为什么今天还要理解DES？
几年前，我参与处理过一个内部系统的数据泄露事件。调查发现，一个遗留的财务系统，其核心的敏感数据（如交易流水号、金额）在存储时，使用了某种“加密”。但当安全团队拿到密文和密钥后，几乎瞬间就还原出了明文。问题就出在这个加密算法上——它使用的正是我们今天要详细拆解的DES（Data Encryption Standard，数据加密标准）。这个案例让我深刻体会到，理解一个算法的“过时”之处，远比盲目使用它更重要。DES虽然已不再是现代高安全场景的首选，但它作为现代密码学的基石之一，其精巧的设计思想、清晰的步骤流程，是理解对称加密、分组密码乃至密码分析的绝佳教材。无论是为了维护遗留系统、进行安全审计，还是为了打好密码学基础，搞懂DES的具体步骤都至关重要。
网络上关于DES的讨论依然活跃，从“DES/ECB/NoPadding的C语言实现”到“轻量级分组加密算法”，都说明了它在教育和特定嵌入式场景中的生命力。本文将彻底抛开复杂的数学外衣，用最直白的语言、清晰的图示（文字描述）和类比，带你一步步“手动”走完DES加密的全过程。你会发现，它不是一个黑盒，而是一台设计精良、环环相扣的机械密码机。我们不仅要学会操作这台机器，更要明白它每个齿轮转动的意义，以及为什么今天我们需要更强大的机器来替代它。
2. DES算法全景：一台64位的分组密码机械
在深入齿轮之前，我们先看看这台机器的全貌。DES是一种对称分组密码。所谓“对称”，意味着加密和解密使用同一把钥匙。所谓“分组”，是指它不像流密码那样逐比特处理，而是把数据切成固定大小的块进行处理，DES的分组大小是64位。它的密钥长度原本也是64位，但其中8位用于奇偶校验（确保密钥在传输存储中没出错），实际起作用的只有56位。正是这56位的密钥长度，成为了DES最终被淘汰的根本原因之一。
DES的核心流程可以概括为两大步：初始置换与Feistel网络结构，以及最后的逆置换。整个过程就像一条精密的流水线：
- 明文（64位）进入流水线。
- 经过一个固定的“打乱座位”操作（初始置换IP）。
- 被拆分成左、右两半（各32位），送入核心车间——进行16轮完全相同的加工（Feistel轮函数）。每一轮加工都需要从主密钥中生成的一把子钥匙（48位）来驱动。
- 16轮结束后，左、右半部分交换并合并。
- 最后经过一个“还原座位”操作（逆置换IP⁻¹），输出最终的64位密文。
解密过程与加密完全相同，唯一区别是子密钥的使用顺序相反：加密时使用 K1, K2, …, K16，解密时则使用 K16, K15, …, K1。这种对称性得益于Feistel网络结构的巧妙设计。
这里就引出了第一个关键点：Feistel结构。这是DES能实现加密解密同构（结构一样）的核心。每一轮中，数据的右半部分（R）直接变成下一轮的左半部分（L’）。同时，右半部分（R）会经过一个轮函数F的处理，处理结果再与左半部分（L）进行异或（XOR）操作，得到的结果成为下一轮的右半部分（R’）。用公式表示就是：
L' = R R' = L ⊕ F(R, K)其中，⊕ 表示异或操作，K是当前轮的子密钥。这个结构的精妙之处在于，无论轮函数F本身是否可逆（事实上DES的F函数是不可逆的），整个加密过程都是可逆的，这极大地简化了硬件实现。
3. 密钥编排：从56位主密钥生成16把轮子钥匙
驱动16轮加工的核心燃料就是子密钥。生成它们的过程称为“密钥编排”（Key Schedule）。这个过程是确定性的，但非常关键。
3.1 初始准备：置换选择1（PC-1）
首先，输入的64位密钥（用户提供）需要被“瘦身”和“打乱”。我们通过一个叫做“置换选择1”（PC-1）的固定表格来完成。这个表格有56个位置，它做了两件事：
- 丢弃奇偶校验位：忽略原64位密钥中每字节的第8位（即校验位）。
- 重新排列：将剩下的56位有效密钥比特，按照PC-1表的规定，放入一个新的56位序列中。
这个56位的序列被平均分成两部分：前28位称为C0（左半部分），后28位称为D0（右半部分）。至此，主密钥完成了初始化。
3.2 循环左移与子密钥生成
接下来，我们要进行16轮操作来生成16个子密钥。在每一轮i（i从1到16）中：
- 循环左移：分别对C(i-1)和D(i-1)进行循环左移。注意，移位数不是固定的！这是密钥编排中的一个重要细节：
- 第1, 2, 9, 16轮：左移1位。
- 其他轮次（3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15）：左移2位。 这个变长移位增加了密钥编排的复杂性。移位后得到新的Ci和Di。
- 合并与压缩置换：将Ci和Di合并成一个56位的中间结果。然后，通过另一个固定表格“置换选择2”（PC-2）进行处理。PC-2是一个48位的表格，它会从56位中间结果中有选择地挑出48位，并调整它们的顺序，最终生成本轮所需的48位子密钥Ki。
注意：PC-2不仅打乱了顺序，还丢弃了8位。这8位信息在每一轮的子密钥生成中都丢失了，所以不能从单个子密钥反推主密钥，这增加了密码强度。
3.3 一个重要的实操心得
在编程实现DES时，密钥编排部分最容易出错的地方就是循环左移的位数。很多人会忽略第1、2、9、16轮只移1位这个规则，统一移2位，这样生成的子密钥全是错的，导致最终加解密失败。我的建议是，将移位规则预先定义成一个数组：int shift_schedule[16] = {1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};，然后在循环中按表查询，这样既清晰又不易出错。
4. 核心中的核心：轮函数F的完全拆解
这是DES算法最精妙、最复杂也最核心的部分。轮函数F接受两个输入：32位的右半部分数据（R）和48位的本轮子密钥（K）。它输出一个32位的结果，用于与左半部分进行异或。F函数可以分解为四个清晰的子步骤：扩展置换、密钥混合、S盒替换和P盒置换。
4.1 扩展置换（E盒）
输入是32位的R，输出需要48位，以便与48位的子密钥进行混合。如何将32位变成48位？DES采用了一个非常聪明（现在看来也有些规律性）的方法：重复某些比特。
扩展置换表（E盒）定义了48个位置，每个位置对应输入32位中的某一个比特。它的排列规则使得输入的32位被“拉伸”了。具体来说，它将32位数据分成8个4位的小块，然后将每个4位小块扩展成6位。扩展的方法是：将小块的首位前置到前一个小块的末位，将小块的末位后置到后一个小块的首位。对于最左边和最右边的小块，则从另一侧“环绕”取位。
例如，假设一个4位小块是[b1, b2, b3, b4]，扩展后可能变成[b4(前一块的), b1, b2, b3, b4, b1(后一块的)]。这样，原来每个块内部的4个比特，加上从邻居那里“借来”的2个比特，就构成了6位。8个块总共就是48位。这个操作有两个目的：一是产生与子密钥等长的数据以便进行异或；二是让数据的一位能影响下一轮S盒替换中的两个位置（因为被重复使用了），这被称为雪崩效应，是密码算法的一个重要特性。
4.2 密钥混合
这一步非常简单直接：将上一步得到的48位扩展结果，与本轮48位的子密钥Ki，进行逐比特的异或（XOR）操作。异或的规则是“相同为0，不同为1”。这一步将密钥信息彻底“搅拌”到了数据中。输出结果仍然是48位。
4.3 S盒替换：非线性的灵魂
如果DES只有线性操作（如置换、异或），那么它将非常脆弱，可以用线性代数的方法轻松破解。S盒（Substitution-box，替换盒）的引入，为DES注入了至关重要的非线性特性。这是DES安全性的核心所在。
经过密钥混合后的48位数据，被平均分成8组，每组6位。每一组6位输入，对应一个独立的S盒（S1到S8）。每个S盒都是一个预先定义好的、固定的4行16列的查找表。
S盒的工作机制如下：
- 对于一个6位输入，如
b1 b2 b3 b4 b5 b6。 - 取首尾两位
b1 b6组成一个2位二进制数（范围0-3），这决定了行号。 - 取中间四位
b2 b3 b4 b5组成一个4位二进制数（范围0-15），这决定了列号。 - 在对应的S盒表中，查找该行该列交叉点的数字（范围0-15，即一个4位二进制数）。
- 这个4位二进制数就是该S盒的输出。
这样，每个6位输入被“压缩”并替换成了一个4位输出。8个S盒总共输出32位。S盒的设计是密码学家的智慧结晶，它必须满足严格的密码学特性，如非线性、差分均匀性等，以抵抗各种密码分析攻击。S盒的具体内容是一个公开的固定表格，在实现时必须严格对照，不能有丝毫差错。
4.4 P盒置换
S盒输出的32位结果，最后还要经过一个固定的P盒置换。这个置换表定义了32个位置，将输入的32位比特重新排列顺序。它的目的是将单个S盒的输出比特扩散到下一轮多个不同的S盒输入中去。这样，经过多轮迭代后，明文和密钥的每一位都会影响到密文的每一位，实现了强大的扩散效果。
至此，轮函数F的32位输出就计算完毕了。这个输出与原始的左半部分32位（L）进行异或，产生新的右半部分（R’），而旧的右半部分（R）直接成为新的左半部分（L’），完成一轮Feistel操作。
5. 初始置换与逆置换：首尾的固定洗牌
在Feistel网络开始前和结束后，DES还安排了两次固定的置换操作。
5.1 初始置换（IP）
明文分组（64位）首先进入初始置换IP。这是一个固定的、公开的置换表，有64个位置。它根据表格，将输入明文的第58位放到输出的第1位，将第50位放到输出的第2位，以此类推。这个操作本身不提供任何密码学安全性，因为它没有引入密钥，而且是固定的。它的历史原因主要是为了适应早期硬件（特别是芯片）的布线方便。从密码学角度看，它可以被忽略，因为攻击者知道这个固定变换，可以轻易地将其抵消。
5.2 逆置换（IP⁻¹）
在16轮Feistel网络结束后，我们会得到一个64位的中间结果。注意，此时按照Feistel结构的规则，最后一轮输出后，左（L16）和右（R16）两部分需要先交换，得到（R16, L16），然后再合并成64位。这个合并后的结果，再经过逆置换IP⁻¹的处理，才得到最终的密文。
逆置换IP⁻¹是初始置换IP的逆操作。也就是说，IP⁻¹(IP(X)) = X。它的作用就是将数据比特的顺序还原到最初（相对于IP而言）的顺序。同样，它也不提供密码学安全性。
5.3 一个容易混淆的坑
在编程实现时，很多人会忘记在最后一轮后交换左右两部分。标准的Feistel结构在最后一轮后是不交换的，但DES标准特别规定在第16轮后需要交换左右部分，然后再进行逆置换。如果忘记这一步，解密过程将无法得到正确明文。我建议在代码中明确写出交换步骤，或者将交换逻辑整合进循环的边界条件中，并添加清晰的注释。
6. DES的工作模式与填充：如何加密任意长度的数据？
我们上面讨论的，是DES如何加密一个64位的数据块。这被称为ECB（Electronic Codebook，电子密码本）模式。在这种模式下，每个64位的明文块都独立地用同一个密钥加密。这带来一个严重问题：相同的明文块会产生相同的密文块。对于非随机的数据（比如一张图片或一段有结构的文本），在ECB模式下，密文中会保留明文的模式，安全性很差。
为了解决这个问题，我们需要工作模式和填充。
6.1 常见的分组密码工作模式
- CBC（Cipher Block Chaining，密码分组链接）：这是最常用的模式之一。它引入了一个初始化向量（IV）。加密时，第一个明文块先与IV异或，然后再用DES加密。后续的每个明文块，在加密前都要先与前一个密文块异或。这样，即使明文相同，加密后的密文也不同，破坏了明文模式。解密过程则是逆向操作。
- CFB（Cipher Feedback，密码反馈） & OFB（Output Feedback，输出反馈）：这两种模式能将分组密码转换为一种自同步的流密码，适用于数据需要逐位处理或传输错误有容忍度的场景。
- CTR（Counter，计数器）：同样产生密钥流，它使用一个计数器（每次加密递增）加密后与明文异或。它具有并行计算的优点。
6.2 填充（Padding）
由于数据长度不总是64位的整数倍，我们需要在加密前对最后一个不完整的数据块进行填充。常见的填充方案有PKCS#5/PKCS#7。例如，如果最后一个块缺3个字节，就填充3个值为0x03的字节。解密后，需要根据最后一个字节的值移除填充。
6.3 关于“DES/ECB/NoPadding”
这正是网络热词中提到的。这表示：
- 使用DES算法。
- 使用ECB工作模式（通常不推荐，除非加密完全随机的数据）。
- 使用NoPadding，即不填充。这意味着待加密数据的长度必须是8字节（64位）的整数倍，否则会出错。这种组合通常只在加密特定格式的、长度固定的数据时使用，比如加密一个已知长度的密钥或令牌。
7. 为什么DES被淘汰？从3DES到AES
尽管DES设计精妙，但它最大的硬伤在于56位的密钥长度。在DES诞生的1970年代，56位密钥（2^56种可能）被认为是安全的。但随着计算能力的指数级增长，暴力破解（穷举所有密钥）成为可能。1998年，电子前沿基金会（EFF）制造的“深蓝”机器在56小时内破解了DES密钥，宣判了DES的“死刑”。
为了延长DES的生命周期，出现了3DES（Triple DES）。顾名思义，它用DES对数据块处理三次。通常有两种方式：
- EDE（Encrypt-Decrypt-Encrypt）：使用两个或三个密钥（K1, K2, K3）。
Ciphertext = E_K3(D_K2(E_K1(Plaintext)))。当K1=K2=K3时，就退化成了普通的DES，提供了向后兼容性。 - 3DES将有效密钥长度提升到了112位或168位，安全性大大增强，但代价是速度变慢为DES的1/3。
最终，在2001年，美国国家标准与技术研究院（NIST）选择了AES（Advanced Encryption Standard，高级加密标准）作为DES的替代者。AES（通常是AES-128， AES-192， AES-256）具有更长的密钥（128/192/256位）、更快的软件实现速度、以及同样优秀甚至更优的安全设计。如今，AES已成为全球对称加密的事实标准。
8. 动手实践：用Python“白盒”实现DES加密
理解了所有步骤，最好的巩固方式就是动手实现一个简化版（用于教育目的）。这里我们用Python来模拟DES的核心流程，重点关注Feistel结构和轮函数，省略IP/IP⁻¹等固定置换的细节，并假设输入是8字节的块。
首先，我们需要一些辅助函数：
def string_to_bit_array(text): """将字符串转换为比特列表（0/1列表）""" array = [] for char in text: # 获取字符的ASCII码，转换为8位二进制字符串，然后拆成比特 bin_val = bin(ord(char))[2:].zfill(8) array.extend([int(bit) for bit in bin_val]) return array def bit_array_to_string(array): """将比特列表转换回字符串""" chars = [] for i in range(0, len(array), 8): byte = array[i:i+8] # 将8位比特列表转换为整数，再转换为字符 chars.append(chr(int(''.join(str(b) for b in byte), 2))) return ''.join(chars) def xor(list1, list2): """对两个等长的比特列表进行异或操作""" return [a ^ b for a, b in zip(list1, list2)] def shift_left(bits_list, n): """循环左移比特列表""" return bits_list[n:] + bits_list[:n]接下来，我们模拟密钥编排。为了简化，我们用一个固定的“置换”来模拟PC-1和PC-2，并生成16轮子密钥。在实际完整实现中，你需要严格按照标准表格操作。
def generate_subkeys(key_bits): """ 简化版的子密钥生成。 假设输入的key_bits已经是56位有效密钥比特（去掉了校验位）。 实际标准中，需要从64位通过PC-1得到56位。 """ subkeys = [] # 假设C0和D0各28位，直接拆分 C = key_bits[:28] D = key_bits[28:] # 移位表，对应16轮每轮的左移位数 shift_table = [1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1] for round_num in range(16): # 循环左移 shift = shift_table[round_num] C = shift_left(C, shift) D = shift_left(D, shift) # 合并C和D（56位），然后模拟PC-2压缩置换为48位 # 这里我们简单地从56位中每隔一定间隔取48位，实际应查表 combined = C + D # 一个非常简化的“压缩”，仅用于演示。真实PC-2是固定的48位选择表。 subkey = combined[4:52:1] # 这不是真实的PC-2！只是一个占位。 # 确保子密钥是48位 subkey = subkey[:48] subkeys.append(subkey) return subkeys现在，实现核心的轮函数F。我们同样简化S盒和P盒，用固定操作模拟其非线性特性。
def f_function(right_bits, subkey): """ 简化版的轮函数F。 输入：32位右半部分（列表），48位子密钥（列表） 输出：32位结果（列表） """ # 1. 扩展置换 (32 -> 48)。简化：重复一些位。 # 真实E盒有固定扩展表。这里我们简单地将32位复制并重组为48位。 # 例如：将右半部分每4位一组，扩展成6位，通过重复首尾位。 expanded = [] for i in range(0, 32, 4): chunk = right_bits[i:i+4] # 模拟扩展：前一块的最后一位，当前块，后一块的第一位 # 为简化，我们假设边界环绕。这里用当前块的首位和末位来模拟重复。 expanded.append(chunk[-1]) # 模拟前一块的末位 expanded.extend(chunk) expanded.append(chunk[0]) # 模拟后一块的首位 expanded = expanded[:48] # 确保是48位 # 2. 密钥混合：与子密钥异或 mixed = xor(expanded, subkey) # 3. S盒替换 (48 -> 32)。简化：将48位分成8组6位，每组通过一个简单非线性函数变成4位。 # 真实S盒是8个不同的6->4查找表。这里我们用取模和异或模拟非线性。 sbox_output = [] for i in range(0, 48, 6): chunk = mixed[i:i+6] # 一个极其简化的“S盒”：将6位视为数字，进行一些位操作得到4位。 # 例如：将前3位和后3位异或，然后取模16得到0-15的数，再转成4位二进制。 num1 = int(''.join(str(b) for b in chunk[:3]), 2) num2 = int(''.join(str(b) for b in chunk[3:]), 2) sbox_val = (num1 ^ num2) % 16 # 得到一个0-15的值 sbox_bits = [int(b) for b in bin(sbox_val)[2:].zfill(4)] sbox_output.extend(sbox_bits) # 4. P盒置换 (32位重排)。简化：我们简单地将列表反转作为“置换”。 # 真实P盒有固定置换表。 pbox_output = sbox_output[::-1] # 反转，这只是一个演示用的置换 return pbox_output[:32] # 确保返回32位最后，组装完整的DES加密轮次（简化版，忽略IP/IP⁻¹）：
def des_encrypt_block(plaintext_bits, subkeys): """ 对一个64位数据块进行DES加密（简化版，无IP/IP⁻¹）。 输入：64位明文比特列表，16个48位子密钥列表。 输出：64位密文比特列表。 """ # 假设输入已经是64位 # 1. 初始拆分 L = plaintext_bits[:32] R = plaintext_bits[32:] # 2. 16轮Feistel网络 for i in range(16): L_next = R[:] # 新的左半部分是旧的右半部分 # 新的右半部分是旧的左半部分与F函数结果的异或 f_result = f_function(R, subkeys[i]) R_next = xor(L, f_result) L, R = L_next, R_next # 为下一轮更新 # 3. 最后一轮后交换（标准DES要求） L, R = R, L # 4. 合并输出（简化，未做逆置换） ciphertext_bits = L + R return ciphertext_bits # 演示用法 if __name__ == "__main__": # 示例：加密字符串 "ABCDEFGH" (8字节，64位) plaintext = "ABCDEFGH" # 一个示例的56位密钥（实际DES密钥是64位，含8位校验） # 这里我们用简单的字符串“8bytekey”并转换，仅用于演示 key = "8bytekey" # 8字节，64位。我们假装后8位是校验位，实际只用前56位。 key_bits = string_to_bit_array(key)[:56] # 简化：直接取前56位作为有效密钥 print(f"明文: {plaintext}") print(f"明文比特长度: {len(string_to_bit_array(plaintext))}") # 生成子密钥 subkeys = generate_subkeys(key_bits) print(f"生成了 {len(subkeys)} 个子密钥，每个长度 {len(subkeys[0])} 位") # 加密 plaintext_bits = string_to_bit_array(plaintext) cipher_bits = des_encrypt_block(plaintext_bits, subkeys) # 将密文比特转换回字节（可能不是可打印字符） cipher_text = bit_array_to_string(cipher_bits) print(f"加密后的密文（可能不可见）: {repr(cipher_text)}") print(f"密文十六进制表示: {cipher_text.encode().hex()}")这个实现是高度简化的，省略了所有固定的置换表（IP, IP⁻¹, PC-1, PC-2, E, P）和真实的S盒。它的目的是帮助你理解DES的数据流和Feistel结构，而不是一个可用的加密库。绝对不要将其用于真正的数据加密！对于生产环境，请使用经过严格审计的密码学库，如Python的cryptography库，它提供了安全的AES等算法实现。
通过这个“白盒”实现，你可以清晰地看到数据是如何在一轮轮中与密钥混合，并最终变得面目全非的。理解这个过程，是理解所有现代分组密码设计思想的钥匙。DES作为密码学史上的里程碑，其价值不仅在于它曾保护了数十年的数据安全，更在于它为后来者铺平了道路，其设计中的精华与教训，至今仍在启迪着密码学的设计。
