从DES算法入手，深入理解对称加密原理与Feistel网络实现

1. 项目概述：从“过时”的DES谈起

最近在整理一些老项目的代码，又翻出了DES加解密的实现。说实话，现在提DES，很多刚入行的朋友可能会觉得有点“古董”了——毕竟AES都出来二十多年了，各种更安全的算法层出不穷。但恰恰是这种“过时”的技术，反而成了理解现代密码学的一块绝佳敲门砖。我见过不少开发者，一上来就想搞懂AES-GCM或者椭圆曲线，结果被里面层层叠叠的概念绕晕。而DES算法结构清晰，流程经典，把它的加解密流程、Feistel网络、密钥编排这些核心机制吃透了，再去看其他对称加密算法，会有一种豁然开朗的感觉。

这个项目标题“DES数据加解密(附代码示例)”，目标很明确：不是要你用DES去保护什么绝密数据，而是通过亲手实现一遍这个算法，把书本上那些“置换”、“S盒”、“轮函数”的抽象概念，变成屏幕上实实在在运行的代码。这对于学生理解密码学原理，或者对于需要维护遗留系统的开发者来说，都极具价值。毕竟，你永远不知道哪个角落的老系统还在用DES做简单的数据混淆。接下来，我会带你从原理到实现，完整地走一遍DES的加解密流程，并附上清晰、可运行的C语言代码示例，让你不仅能看懂，更能自己动手写出来。

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

2.1 对称加密与Feistel网络结构

DES是一种典型的对称分组加密算法。所谓“对称”，就是加密和解密使用同一把密钥。而“分组”意味着它并不是一个字节一个字节地处理数据，而是将明文数据切割成固定大小的块（DES是64位），然后对这个块进行一系列复杂的变换。DES最精妙的设计之一，就是采用了Feistel网络结构。这个结构是密码学史上的一个天才设计，它有一个近乎完美的特性：加密和解密过程可以使用完全相同的算法逻辑，仅仅是子密钥的使用顺序相反。这极大地简化了硬件和软件的实现。

Feistel结构怎么工作呢？想象一下，你把一个64位的明文块，像切蛋糕一样对半切开，得到左半部分（L0）和右半部分（R0），各32位。然后，进行多轮（DES是16轮）的迭代操作。在每一轮中，右半部分（Ri-1）会原封不动地变成下一轮的左半部分（Li）。同时，右半部分（Ri-1）会经过一个叫轮函数F的复杂处理，处理过程中会用到当前轮的一个48位的子密钥（Ki）。这个被处理后的结果，再与左半部分（Li-1）进行异或（XOR）操作，得到的结果成为下一轮的右半部分（Ri）。用公式表示就是： Li = Ri-1 Ri = Li-1 XOR F(Ri-1, Ki)

看到这里你可能会问，那解密时密钥顺序怎么反？正是因为Feistel结构的对称性，如果你把密文块同样切成L16和R16（加密16轮后的结果），然后倒着使用子密钥序列（从K16到K1），按照完全相同的算法再跑16轮，神奇的事情就发生了：你最终会得到最初的L0和R0，也就是明文。这个设计让加解密硬件可以复用同一套电路，只是密钥调度模块不同，在当年极大地节省了成本。

2.2 DES算法的核心组件解析

理解了Feistel框架，我们再来看看里面最关键的“零件”——轮函数F。它可以说是DES安全性的核心，主要由四个步骤构成：

1. 扩展置换（E盒）：将32位的右半部分输入，通过一个固定的查表（E位选择表），扩展成48位。这个操作有两个目的：一是让数据长度与子密钥匹配（都是48位），以便进行异或；二是产生扩散效应，让输入的一位能影响到下一轮的多个输出位。

2. 与子密钥异或：将扩展后的48位数据，与当前轮的48位子密钥Ki进行按位异或操作。这是将密钥引入加密过程的唯一环节，是整个算法保密性的关键。

3. S盒替代（核心非线性变换）：这是DES算法中最关键、最神秘也最精妙的部分。经过异或的48位数据，被分成8组，每组6位，分别送入8个不同的S盒（Substitution-box，替换盒）。每个S盒是一个固定的4行16列的查找表。6位输入中，头尾两位组成行号（0-3），中间四位组成列号（0-15），根据行列坐标查表，输出一个4位的数。8个S盒总共输出32位。S盒是DES算法中唯一的非线性部件，正是它的存在，使得整个加密算法具备了强大的抗差分分析和线性分析的能力。它的设计细节曾经是保密的，也是密码学家们重点研究的对象。

4. P盒置换：将S盒输出的32位数据，再经过一个固定的置换表（P盒）打乱顺序。这一步进一步增加了混淆和扩散的效果。

经过这四步，轮函数F的输出就产生了。这个32位的输出再与左半部分异或，就完成了Feistel网络的一轮操作。如此重复16轮，再加上初始置换（IP）和最终置换（IP-1），就构成了完整的DES加密流程。

注意：很多人容易混淆“置换”和“代替”。在DES中，“置换”（Permutation，如IP、P盒）是重新排列比特的位置，比特本身的值（0或1）不变。“代替”（Substitution，如S盒）是根据输入值映射到一个完全不同的输出值，比特的值发生了变化。S盒的“代替”操作是引入非线性的核心。

3. 密钥编排：从56位密钥到16轮子密钥

DES的密钥输入是64位，但其中第8、16、24、...、64位（即每个字节的最后一位）是奇偶校验位，不参与实际加密，因此有效密钥长度是56位。这56位有效密钥需要被“编排”成16个48位的子密钥，供每一轮使用。这个过程同样是一系列置换和移位操作。

首先，一个称为“置换选择1”（PC-1）的固定置换，会从64位输入密钥中选出56位有效位，并分成两个28位的半部分，称为C0和D0。 然后，对于每一轮i（i从1到16），C(i-1)和D(i-1)分别进行循环左移。移位的位数是固定的，根据轮数不同，可能是1位或2位。具体规则是：在第1、2、9、16轮左移1位，其他轮左移2位。这个设计增加了密钥变化的复杂性。 移位后得到Ci和Di，将它们合并成一个56位的中间结果，再经过“置换选择2”（PC-2）的置换，从中选出48位，这就生成了该轮的子密钥Ki。

由于解密时子密钥使用顺序相反，你只需要在解密流程中，将子密钥数组从K16到K1倒序使用即可，密钥生成过程本身是完全一样的。这里有一个实操心得：在编程实现时，我通常选择预计算并存储这16个子密钥。无论是加密还是解密，都先调用同一个密钥生成函数，得到一个长度为16的子密钥数组。加密时按K1到K16的顺序使用，解密时则按K16到K1的顺序使用。这样代码逻辑最清晰，也避免了运行时重复计算。

4. 代码实现：手把手构建DES加解密引擎

理论讲得再多，不如一行代码来得实在。下面我将用C语言，分模块实现DES算法。我们会遵循模块化的思想，把初始置换、轮函数、密钥生成等部分写成独立的函数，最后组装起来。

4.1 基础数据类型与常量定义

DES是位操作密集型的算法，但C语言没有直接的“位块”类型。通常有两种处理方式：一是用64位无符号整数（如uint64_t），利用移位和掩码操作特定位；二是用字节数组（unsigned char[8]）。前者在64位系统上效率高，代码简洁；后者更直观，便于理解比特的排列和置换操作。为了教学清晰，我们采用字节数组的方式，并辅以详细的位操作注释。

首先，定义一些核心的置换表。这些表是DES标准定义的，你可以在任何标准文献中找到。为了节省篇幅，这里只列出关键表的名称，在完整代码中会补全：

• IP[64]: 初始置换表
• IP_INV[64]: 最终置换表（IP的逆置换）
• E[48]: 扩展置换表
• S_BOX[8][4][16]: 8个S盒的三维数组
• P[32]: P盒置换表
• PC1[56]: 置换选择1表
• PC2[48]: 置换选择2表
• SHIFT_SCHEDULE[16]: 每轮循环左移的位数表

#include <stdio.h> #include <stdint.h> #include <string.h> // 示例：初始置换表 IP (64 -> 64) const int 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 }; // 示例：扩展置换表 E (32 -> 48) const int E[] = { 32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9, // ... 省略 28, 29, 30, 31, 32, 1 }; // S盒，以S1为例 const int S1[4][16] = { {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

4.2 核心工具函数：比特操作

由于我们使用字节数组，需要一个函数能从字节数组中根据置换表指定的位置，提取并组装出新的位序列。

/** * 通用置换函数 * @param src 源数据字节数组 * @param dst 目标数据字节数组 * @param table 置换表 * @param len 置换表的长度（也是输出数据的比特长度） * @param src_len 源数据的比特长度（用于计算源数组大小） */ void permute(const unsigned char *src, unsigned char *dst, const int *table, int len, int src_len_bits) { // 初始化目标数组为0 memset(dst, 0, (len + 7) / 8); // 计算需要的字节数 for (int i = 0; i < len; i++) { int pos = table[i] - 1; // 置换表通常从1开始计数，C数组从0开始 // 计算源字节和源位 int src_byte = pos / 8; int src_bit = 7 - (pos % 8); // 假设高位在前 // 计算目标字节和目标位 int dst_byte = i / 8; int dst_bit = 7 - (i % 8); // 获取源比特位 int bit_value = (src[src_byte] >> src_bit) & 0x01; // 设置目标比特位 if (bit_value) { dst[dst_byte] |= (1 << dst_bit); } } }

这个permute函数是DES实现的基石，IP、IP-1、E、P、PC1、PC2等所有置换操作都可以用它来完成。注意事项：置换表中位置编号通常是1-based（从1开始），而我们的数组索引是0-based，所以需要table[i] - 1。另外，比特的顺序（高位在前还是低位在前）需要统一，这里我们假设数据存储是最高位在字节的最左侧（即标准的大端序位表示），这在处理时需要特别注意移位操作的方向。

4.3 密钥生成模块实现

接下来实现密钥生成函数，输入8字节密钥，输出16个6字节的子密钥。

/** * 生成16轮子密钥 * @param key 8字节输入密钥 * @param subkeys 输出的16个子密钥，每个6字节 */ void generate_subkeys(const unsigned char key[8], unsigned char subkeys[16][6]) { unsigned char permuted_key[7] = {0}; // 56位 = 7字节 unsigned char C[4], D[4]; // 各28位，用4字节存储（多出4位不用） unsigned char CD[7]; // C和D合并 // 1. 经过PC-1置换，64位变56位 permute(key, permuted_key, PC1, 56, 64); // 将56位分成C0和D0 (各28位) // 假设permuted_key[0]的前4位是C0的一部分... 需要根据存储顺序仔细拆分 // 这里为清晰起见，简化表示拆分逻辑 memcpy(C, permuted_key, 3); // 粗略示意，实际需要按位操作 C[3] = permuted_key[3] & 0xF0; // 取高4位 memcpy(D, permuted_key + 3, 3); D[0] = (permuted_key[3] & 0x0F) << 4 | (permuted_key[4] >> 4); // 组合低4位和高4位 // ... 更精确的拆分需要细致的位操作 for (int i = 0; i < 16; i++) { // 2. 对C和D进行循环左移 left_shift_28bit(C, SHIFT_SCHEDULE[i]); left_shift_28bit(D, SHIFT_SCHEDULE[i]); // 3. 合并C和D成56位 combine_CD(C, D, CD); // 4. 经过PC-2置换，56位变48位，生成子密钥Ki permute(CD, subkeys[i], PC2, 48, 56); } } // 28位循环左移辅助函数 void left_shift_28bit(unsigned char data[4], int shifts) { // 将4字节数据看作一个28位的整体进行循环左移 // 实现略，涉及跨字节的位搬运 }

密钥生成是DES实现中位操作最繁琐的部分之一，因为56位、28位都不是完整的字节数，拆分、合并、移位都需要跨字节操作。实操心得：在调试这个模块时，最好的办法是找一个标准的测试向量（包括密钥和所有中间子密钥），然后每生成一个子密钥就打印出其十六进制值，与标准值比对。这样可以快速定位是PC-1置换错了，还是移位逻辑有问题，或者是PC-2置换不对。

4.4 轮函数F的实现

这是DES算法的“心脏”。

/** * 轮函数F * @param R 32位右半部分输入 (4字节) * @param subkey 48位子密钥 (6字节) * @param output 32位输出 (4字节) */ void f_function(const unsigned char R[4], const unsigned char subkey[6], unsigned char output[4]) { unsigned char expanded_R[6] = {0}; unsigned char xor_result[6] = {0}; unsigned char sbox_output[4] = {0}; // 1. 扩展置换 E: 32位 -> 48位 permute(R, expanded_R, E, 48, 32); // 2. 与子密钥异或 for (int i = 0; i < 6; i++) { xor_result[i] = expanded_R[i] ^ subkey[i]; } // 3. S盒替代: 48位 -> 32位 // 将xor_result的48位分成8组，每组6位 for (int i = 0; i < 8; i++) { int block = i * 6; // 每组6位在xor_result中的起始比特位置 // 提取这6位，计算行号和列号 // 假设高位在前，需要仔细计算字节和位偏移 int byte_idx = block / 8; int bit_offset = block % 8; int bits = 0; // 从xor_result中提取连续的6位到一个整数bits中（实现略） // ... int row = ((bits & 0x20) >> 4) | (bits & 0x01); // 取首尾两位 int col = (bits & 0x1E) >> 1; // 取中间四位 int sbox_value = S_BOX[i][row][col]; // 查表，得到4位值 // 将4位值填入sbox_output的相应位置 int output_byte = i / 2; // 每两个S盒输出填满一个字节 int output_bit_offset = (i % 2) ? 0 : 4; // 第一个S盒填高4位，第二个填低4位 sbox_output[output_byte] |= (sbox_value << output_bit_offset); } // 4. P盒置换 permute(sbox_output, output, P, 32, 32); }

S盒替代是轮函数中最容易出错的地方，难点在于如何从连续的48位数据流中准确地提取出8个不重叠的6位组。这需要非常小心的位掩码和移位操作。一个有效的调试技巧是：固定一个简单的输入R和子密钥，手动计算第一轮S盒的输入输出，然后用printf打印出程序每一步的中间变量（expanded_R，xor_result， 提取的每个6位组，查表得到的4位值），与手动计算的结果逐位比对。

4.5 加密与解密主函数

最后，我们将所有模块组装起来，实现加密和解密函数。得益于Feistel结构，它们几乎一模一样。

/** * DES加密单个64位分组 * @param plaintext 8字节明文 * @param key 8字节密钥 * @param ciphertext 8字节密文输出 */ void des_encrypt_block(const unsigned char plaintext[8], const unsigned char key[8], unsigned char ciphertext[8]) { unsigned char subkeys[16][6]; unsigned char ip_result[8] = {0}; unsigned char L[4], R[4], next_L[4], next_R[4]; unsigned char f_result[4]; // 1. 生成子密钥 generate_subkeys(key, subkeys); // 2. 初始置换 IP permute(plaintext, ip_result, IP, 64, 64); // 3. 拆分成L0和R0 memcpy(L, ip_result, 4); memcpy(R, ip_result + 4, 4); // 4. 16轮Feistel迭代 for (int i = 0; i < 16; i++) { memcpy(next_L, R, 4); // Li = Ri-1 // 计算 F(Ri-1, Ki) f_function(R, subkeys[i], f_result); // Ri = Li-1 XOR F(Ri-1, Ki) for (int j = 0; j < 4; j++) { next_R[j] = L[j] ^ f_result[j]; } // 为下一轮准备 memcpy(L, next_L, 4); memcpy(R, next_R, 4); } // 5. 最后交换 L16 和 R16 (Feistel最后一步) unsigned char final_block[8]; memcpy(final_block, R, 4); memcpy(final_block + 4, L, 4); // 6. 最终置换 IP-1 permute(final_block, ciphertext, IP_INV, 64, 64); } /** * DES解密单个64位分组 * @param ciphertext 8字节密文 * @param key 8字节密钥 * @param plaintext 8字节明文输出 */ void des_decrypt_block(const unsigned char ciphertext[8], const unsigned char key[8], unsigned char plaintext[8]) { // 解密过程与加密完全相同，只是子密钥使用顺序相反 unsigned char subkeys[16][6]; unsigned char ip_result[8] = {0}; unsigned char L[4], R[4], next_L[4], next_R[4]; unsigned char f_result[4]; generate_subkeys(key, subkeys); // 子密钥生成是一样的 permute(ciphertext, ip_result, IP, 64, 64); memcpy(L, ip_result, 4); memcpy(R, ip_result + 4, 4); // 关键区别：子密钥倒序使用 K16 -> K1 for (int i = 15; i >= 0; i--) { memcpy(next_L, R, 4); f_function(R, subkeys[i], f_result); for (int j = 0; j < 4; j++) { next_R[j] = L[j] ^ f_result[j]; } memcpy(L, next_L, 4); memcpy(R, next_R, 4); } unsigned char final_block[8]; memcpy(final_block, R, 4); memcpy(final_block + 4, L, 4); permute(final_block, plaintext, IP_INV, 64, 64); }

至此，一个完整的DES分组加解密核心就实现了。你可以写一个简单的main函数，用标准的测试向量（例如NIST发布的已知答案测试）来验证你的代码是否正确。例如，用全零的明文和全零的密钥，加密后的密文应该是一个特定的值。

5. 工作模式与填充：让DES处理任意长度数据

我们上面实现的是ECB（Electronic Codebook，电子密码本）模式下的单分组加解密。这是最基础的模式，但直接使用有严重的安全缺陷：相同的明文块会生成相同的密文块。这对于有规律的数据（如图像、结构化文本），会在密文中留下明显的模式，容易被攻击。

为了让DES能加密任意长度的数据，并且更安全，我们需要引入分组密码工作模式和填充方案。

5.1 常见的分组密码工作模式

1. CBC（Cipher Block Chaining，密码分组链接）：这是最常用、也推荐初学者使用的模式。它引入了一个初始化向量（IV）。加密时，第一个明文块先与IV异或，然后再用DES加密。后续的每个明文块，都先与前一个密文块异或，再进行加密。这样，即使明文相同，只要IV不同，或者前面的块不同，产生的密文就完全不同，完美解决了ECB的模式泄露问题。解密过程则是反向操作。

2. CFB（Cipher Feedback，密文反馈） & OFB（Output Feedback，输出反馈）：这两种模式可以将分组密码转换为流密码。它们适用于需要实时加密（如网络通信）或加密数据长度不是分组整数倍的场景。不过，它们对错误传播的特性不同，需要根据场景选择。

3. CTR（Counter，计数器）：另一种流密码模式。它通过加密一个递增的计数器来产生密钥流，然后与明文异或。它具有并行计算、随机访问等优点，在现代应用中也很常见。

对于DES，我强烈建议永远不要使用ECB模式。CBC模式是一个安全且易于理解的选择。在代码实现上，你只需要在des_encrypt_block和des_decrypt_block的基础上，加上异或和前一个密文块（或IV）的处理逻辑即可。

5.2 填充方案（Padding）

DES是64位（8字节）分组加密。如果你的明文长度不是8的整数倍怎么办？这就需要填充。最常用的填充方案是PKCS#7（也叫PKCS#5）。规则很简单：假设需要填充n个字节，那么每个填充字节的值都是n。 例如，一个13字节的数据，距离下一个8的倍数（16字节）还差3个字节，那么就填充3个字节，每个字节的值是0x03。 解密后，读取最后一个字节的值n，然后移除最后n个字节，就得到了原始数据。

注意事项：填充必须可逆且无歧义。如果明文长度恰好是8的倍数，按照PKCS#7规则，需要额外填充一个完整的8字节块，每个字节为0x08。这样解密时才能正确识别并移除填充。

6. 安全性讨论与常见问题排查

6.1 为什么DES被认为不安全？

DES的56位密钥长度是其最大的安全短板。早在1998年，电子前沿基金会（EFF）就用一台特制的机器“深蓝”（Deep Crack）在不到3天的时间里暴力破解了DES密钥。随着计算机算力的指数级增长，如今在云算力市场上，破解DES密钥已是分分钟的事情。因此，DES绝对不应用于任何新的、需要安全保护的系统。它的价值仅存在于教育、理解算法和兼容无法升级的绝对遗留系统。

6.2 3DES是什么？它安全吗？

为了延长DES的寿命，人们提出了3DES（Triple DES）。顾名思义，就是用DES算法对同一个数据块处理三次。通常有两种密钥使用方式：

• EDE（Encrypt-Decrypt-Encrypt）：Ciphertext = Encrypt(Decrypt(Encrypt(Plaintext, K1), K2), K3)。
• 当K1=K2=K3时，3DES退化为普通DES，保证了向后兼容性。
• 当K1、K2、K3互不相同时，有效密钥长度可达168位（但由于存在中间相遇攻击，实际安全强度约为112位）。

3DES比DES安全得多，但速度慢了三倍。目前，3DES在一些金融等传统领域仍有使用，但也被逐步淘汰（NIST已规定在2023年后禁用）。AES是更优的替代品。

6.3 代码调试与验证中的常见“坑”

在实现和调试DES代码时，以下几个地方最容易出错：

1. 比特序和字节序：这是最大的“坑”。DES标准文档描述的是比特序列，而我们用字节数组存储。你必须明确约定：在一个字节内，最高位（MSB）是第一位还是最后一位？我们的permute函数假设MSB是比特1（最左边）。如果你的测试向量来自其他实现（可能使用LSB优先），那么所有置换表都需要做镜像反转，或者调整位提取逻辑。强烈建议：找一个权威的、包含所有中间步骤的测试向量，从IP置换开始，一步步比对中间值。

2. S盒的输入输出：S盒的6位输入，如何准确提取行号和列号？公式row = (bit1 & 0x20) >> 4 | (bit6 & 0x01)和col = (bits & 0x1E) >> 1是基于特定的比特排列顺序的。如果你的比特提取顺序不同，这个公式就要调整。

3. 密钥生成的循环左移：对28位的C和D进行循环左移，需要实现跨字节的循环。例如，C是4个字节（32位），但只使用低28位。左移1位时，需要将第一个字节的最高位移到第二个字节的最低位，以此类推，并且第四个字节移出的位要循环到第一个字节。这里位操作非常容易出错。

4. 工作模式中的IV：使用CBC模式时，IV必须是随机的、不可预测的，并且每次加密都应更换。解密时需要使用相同的IV。一个常见的错误是使用固定的IV（比如全零），这会让CBC模式的安全性大打折扣。

为了帮助你排查，这里有一个常见问题速查表：

6.4 性能优化与生产环境考量

我们上面的实现是“教科书式”的，追求清晰易懂。在实际生产环境或对性能有要求的场景，可以进行大量优化：

• 使用查表法：将多个置换、S盒操作合并，预先计算并存储在大表中，用空间换时间。这是很多高速库的做法。
• 使用64位整型：现代CPU对64位操作有很好的支持。可以将8字节数据看作一个uint64_t，利用位掩码和移位一次性完成多位操作，效率远高于逐字节处理。
• 使用硬件指令：一些现代CPU（如Intel AES-NI指令集的扩展）提供了类似加密的加速指令。虽然DES没有直接指令，但位操作优化可以借鉴思路。
• 使用成熟的密码库：对于真实项目，绝对不要自己实现密码算法用于生产。应使用经过严格审计和广泛测试的库，如OpenSSL、Libsodium等。它们提供的DES/3DES接口既安全又高效。

最后，我想强调的是，亲手实现DES的最大收获，不是得到一个可用的加密工具，而是彻底理解了一个经典密码系统的内部构造。你理解了Feistel网络的美妙对称性，理解了S盒带来的非线性混淆，理解了密钥编排如何将一把短钥匙变成一串复杂的轮密钥。这份理解，是你学习AES、SM4等其他现代分组密码，甚至探究公钥密码学的基础。当你再看到“混淆”和“扩散”这些词时，脑子里浮现的不再是抽象的概念，而是具体的比特在置换表中跳跃、在S盒中被替换的生动画面。这，就是学习DES这个“老古董”在今天的最大价值。