C语言实战：手把手教你实现DES加密算法（附完整源码解析）

最近几年，身边不少刚开始接触系统编程和网络安全的朋友，都跟我提过同一个困惑：那些听起来高大上的加密算法，比如DES、AES，原理看起来复杂，真要自己动手实现一遍，是不是难如登天？尤其是用C语言这种“贴近硬件”的语言，会不会到处都是指针和位运算的“坑”？其实，我的亲身经历告诉我，恰恰相反。从零开始实现一个经典的加密算法，是理解计算机底层数据操作和密码学思想的绝佳路径。DES（Data Encryption Standard）虽然如今在安全性上已显不足，但其结构清晰、设计精巧，堪称对称加密算法的“活化石”。今天，我就把自己当年啃下DES实现的过程，结合完整的、可运行的C语言源码，一步步拆解给你看。我们不只追求“跑通代码”，更要弄懂每一行代码背后的“为什么”。无论你是C语言初学者想挑战一个综合性项目，还是对加密原理好奇的爱好者，这篇文章都将带你穿越迷雾，亲手搭建起属于你自己的DES加密引擎。

1. 理解DES：不只是56位密钥的往事

在动手写代码之前，我们得先搞清楚DES到底在干什么。很多人一提到DES，第一反应就是“56位密钥，16轮加密，已经不安全了”。这话没错，但如果我们只停留在这个结论，就错过了DES最精妙的部分。DES诞生于上世纪70年代，它的设计目标是在当时的硬件条件下，实现足够强度的加密，同时保证加解密效率。它的核心是一种称为Feistel网络的结构。

提示：Feistel结构是理解许多对称加密算法的钥匙。它的巧妙之处在于，加密和解密可以使用几乎相同的结构，只是子密钥的使用顺序相反，这极大地简化了硬件和软件的实现。

简单来说，Feistel结构把要加密的数据块（DES是64位）一分为二，变成左半部分（L）和右半部分（R）。每一轮的操作可以概括为：

L(i) = R(i-1)
R(i) = L(i-1) XOR F(R(i-1), K(i))

这里的F就是轮函数，K(i)是第i轮的子密钥。XOR（异或）操作是关键，因为它具有一个非常好的性质：(A XOR B) XOR B = A。这意味着，只要轮函数F本身不要求可逆（事实上DES的F函数就不可逆），我们依然能通过相同的结构进行解密。

为了让你对DES的整体流程有个直观印象，我把它简化成了下面几个核心阶段：

阶段	输入	操作	输出/目的
1. 初始置换 (IP)	64位明文	按固定表重新排列比特位	打乱原始明文的顺序
2. 16轮Feistel迭代	置换后的64位数据	每轮使用不同的48位子密钥，经过轮函数F处理	实现数据的混淆和扩散
3. 末置换 (IP⁻¹)	16轮后的64位数据	初始置换的逆操作	得到最终的64位密文
4. 密钥调度	56位有效密钥	经过置换、左移、压缩置换生成16个子密钥	为每一轮提供不同的密钥材料

你看，整个框架并不复杂。真正的“魔鬼”藏在细节里：那些固定的置换表、神秘的S盒，以及精确的位操作。接下来，我们就从最基础的准备工作开始，搭建我们的C语言项目。

2. 搭建战场：C语言项目准备与位操作精要

用C语言实现DES，本质上是一场“位操作”的盛宴。我们很少直接处理整数本身的大小，而是关心它的每一个二进制位（bit）如何移动、如何组合。因此，选择合适的数据类型和建立清晰的位操作观念至关重要。

我强烈建议你单独创建一个头文件，比如des.h，来存放所有的常量定义和函数声明。这样主程序文件会显得非常清爽。首先，我们需要定义DES算法中那些规模庞大的常量表。没错，DES是“表驱动”的，算法本身逻辑简单，但依赖于一系列预先定义好的置换表。这里以初始置换IP表为例：

// des.h
#ifndef DES_H
#define DES_H

#include <stdint.h>

// 初始置换IP表 (64位 -> 64位)
static const int IP[64] = {
    58, 50, 42, 34, 26, 18, 10, 2,
    60, 52, 44, 36, 28, 20, 12, 4,
    62, 54, 46, 38, 30, 22, 14, 6,
    64, 56, 48, 40, 32, 24, 16, 8,
    57, 49, 41, 33, 25, 17, 9,  1,
    59, 51, 43, 35, 27, 19, 11, 3,
    61, 53, 45, 37, 29, 21, 13, 5,
    63, 55, 47, 39, 31, 23, 15, 7
};

// 后续还会在这里添加逆初始置换IP^-1表、扩展置换E表、P置换表、8个S盒等

// 函数声明
void des_encrypt(uint64_t *data, uint64_t key);
void des_decrypt(uint64_t *data, uint64_t key);
void generate_subkeys(uint64_t key, uint64_t subkeys[16]);
uint64_t feistel_function(uint32_t half_block, uint64_t subkey);

#endif

这里我们使用了uint64_t（定义在stdint.h中）来确保我们有一个精确的64位无符号整数类型，这对于跨平台兼容性很重要。接下来，在主文件main.c里，我们首先要解决一个核心问题：如何根据上面的置换表，对一个64位数据的特定位进行操作？

C语言没有直接操作“第n位”的语法，但我们可以通过移位和掩码来实现。我写了一个辅助函数，它是我实现DES过程中最常用的工具之一：

// 获取一个64位数据中某一位的值（1或0），位序从1开始（最左边为第1位）
static int get_bit(uint64_t data, int pos) {
    // 注意：DES标准中位序通常从1开始，且最左边是最高位(MSB)。
    // 我们这里将数据视为pos=1是最高位，pos=64是最低位。
    return (data >> (64 - pos)) & 1UL;
}

// 设置一个64位数据中某一位的值
static uint64_t set_bit(uint64_t data, int pos, int value) {
    uint64_t mask = 1ULL << (64 - pos);
    if (value) {
        return data | mask;
    } else {
        return data & ~mask;
    }
}

有了这两个“瑞士军刀”，实现置换函数就变得直观了。比如初始置换函数initial_permutation：

uint64_t initial_permutation(uint64_t data) {
    uint64_t result = 0;
    for (int i = 0; i < 64; i++) {
        int bit_value = get_bit(data, IP[i]);
        result = set_bit(result, i + 1, bit_value); // i+1因为输出位序也从1开始
    }
    return result;
}

这个过程就像按照一张新的座位表（IP表），把原来64个座位上的人（比特位）重新安排到新座位上。虽然用循环看起来效率不高，但对于学习和理解算法完全足够，而且代码清晰度极高。在实际动手时，你可能会发现很多教程使用庞大的switch语句或查找表来优化，但我建议初学者先用这种最直观的方式实现第一版，确保逻辑正确，性能优化是后面的事。

3. 核心引擎：轮函数F与神秘的S盒

如果说Feistel结构是DES的骨架，那么轮函数F就是它的心脏。这个函数接收32位的右半部分数据和一个48位的子密钥，输出一个32位的结果。它的工作流程是标准化的，可以分为三步：扩展、混合、压缩。

第一步：扩展置换（E） 将32位的输入扩展到48位，目的是为了与48位的子密钥进行异或操作，同时让输入的一位能影响后续S盒的多位输出（实现所谓的“扩散”）。扩展规则很简单，主要是重复某些比特位。实现方式和之前的置换类似，只是表不同。

第二步：与子密钥异或 将扩展后的48位结果与当前轮次的48位子密钥进行按位异或（XOR）。这是引入密钥材料的关键步骤。

第三步：S盒替换 这是DES算法中唯一非线性的部分，也是其安全性的核心所在。S盒是一个6位输入、4位输出的查找表。DES共有8个不同的S盒，每个S盒将6位输入映射为4位输出。具体过程是：

1. 将异或后的48位数据分成8组，每组6位。
2. 每一组6位输入到对应的S盒（S1到S8）。
3. 6位输入中，头尾两位组成一个2位数，决定S盒的行号（0-3）；中间四位组成一个4位数，决定S盒的列号（0-15）。
4. 查找S盒对应行列的值（0-15），输出为一个4位二进制数。

S盒的设计充满了智慧，它必须满足严格的密码学特性，比如避免线性关系、输出位不能太依赖于输入位等。在代码中，我们需要完整定义这8个S盒。这里以第一个S盒为例：

// S盒1 (S1)
static 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}
};

实现S盒查找的函数需要仔细处理位运算：

static uint32_t sbox_lookup(uint64_t input_48bit) {
    uint32_t output_32bit = 0;
    for (int i = 0; i < 8; i++) {
        // 提取6位输入
        int six_bits = (input_48bit >> (42 - i * 6)) & 0x3F; // 每次取6位，从最高位开始
        // 计算行和列
        int row = ((six_bits & 0x20) >> 4) | (six_bits & 0x01); // 取头尾两位
        int col = (six_bits >> 1) & 0x0F; // 取中间四位
        // 查找S盒
        int sbox_value;
        switch (i) {
            case 0: sbox_value = S1[row][col]; break;
            case 1: sbox_value = S2[row][col]; break;
            // ... 补充S3到S8
            default: sbox_value = 0;
        }
        // 将4位输出拼接到结果中
        output_32bit |= (sbox_value & 0x0F) << (28 - i * 4);
    }
    return output_32bit;
}

第四步：P置换 最后，将S盒输出的32位结果再经过一个固定的P置换，打乱顺序，得到轮函数的最终32位输出。至此，轮函数F就完成了。它融合了数据的扩展、密钥的混合、非线性的S盒变换和最终的置换，是单轮加密中所有“魔法”发生的地方。

4. 密钥调度：从一把钥匙到十六把轮钥

DES的有效密钥长度是56位，但用户输入通常是64位（8字节），其中每字节的第8位用作奇偶校验位。密钥调度的任务就是把这56位有效密钥，加工生成16个48位的子密钥，供每一轮使用。这个过程同样是标准化的，包含以下几个步骤：

1. 选择置换PC-1：从64位输入密钥中，忽略校验位，选出56位有效密钥，并进行一次置换。
2. 分割与循环左移：将56位分成两个28位的半部分，称为C0和D0。在每一轮（i从1到16），C(i-1)和D(i-1)会进行循环左移，移位数根据轮数而定（通常是1或2位），得到C(i)和D(i)。

   注意：移位数表是固定的，第1、2、9、16轮左移1位，其余轮次左移2位。

3. 选择置换PC-2：将每一轮移位后的C(i)和D(i)合并成56位，再经过PC-2置换，压缩并选出48位，这就是该轮的子密钥K(i)。

密钥调度的巧妙之处在于，由于循环左移的存在，每一轮用于生成子密钥的C、D部分都不同，从而确保了16个子密钥的差异性。而解密时，只需要逆序使用这16个子密钥即可，因为Feistel结构的对称性。

在C语言中实现密钥调度，我们需要定义PC-1、PC-2表和左移位数表。然后，我们可以用一个数组来存储16个子密钥：

void generate_subkeys(uint64_t key, uint64_t subkeys[16]) {
    // 1. 应用PC-1置换，得到56位有效密钥key_56
    uint64_t key_56 = permute(key, PC1, 64, 56); // 假设permute是一个通用置换函数

    // 2. 分割成C0和D0 (各28位)
    uint32_t C = (key_56 >> 28) & 0x0FFFFFFF;
    uint32_t D = key_56 & 0x0FFFFFFF;

    for (int round = 0; round < 16; round++) {
        // 3. 循环左移 (根据轮数查表得到移位数)
        int shift = shift_schedule[round];
        C = ((C << shift) | (C >> (28 - shift))) & 0x0FFFFFFF;
        D = ((D << shift) | (D >> (28 - shift))) & 0x0FFFFFFF;

        // 4. 合并C和D，应用PC-2置换，生成48位子密钥
        uint64_t CD_combined = ((uint64_t)C << 28) | D;
        subkeys[round] = permute(CD_combined, PC2, 56, 48);
    }
}

这里用到的permute函数，是之前initial_permutation的通用版本，可以处理任意输入输出位数的置换。实现它，会让你对位操作的理解更深一层。

5. 整体组装与调试：让DES引擎转起来

现在，我们有了所有的基础零件：置换函数、轮函数F、密钥调度。是时候把它们组装成完整的DES加密/解密函数了。根据Feistel网络，加密过程的主循环非常优雅：

void des_crypt(uint64_t *data, uint64_t key, int mode) { // mode: 1加密, 0解密
    // 生成16个子密钥
    uint64_t subkeys[16];
    generate_subkeys(key, subkeys);

    // 初始置换IP
    uint64_t permuted_data = initial_permutation(*data);

    // 分割成左右各32位
    uint32_t L = permuted_data >> 32;
    uint32_t R = permuted_data & 0xFFFFFFFF;

    // 16轮Feistel迭代
    for (int round = 0; round < 16; round++) {
        uint32_t prev_L = L;
        uint32_t prev_R = R;

        // 当前轮使用的子密钥索引
        int key_idx = (mode == 1) ? round : (15 - round); // 解密时子密钥逆序使用

        L = prev_R;
        // R = prev_L XOR F(prev_R, subkey)
        R = prev_L ^ feistel_function(prev_R, subkeys[key_idx]);
    }

    // 最后一轮后不需要交换，但标准DES在16轮后有一次交换
    // 注意：根据Feistel结构，16轮后是(R16, L16)，需要合并成(R16, L16)
    uint64_t combined = ((uint64_t)R << 32) | L;

    // 末置换IP^-1
    *data = final_permutation(combined);
}

代码写到这里，一个完整的DES算法框架就完成了。但先别急着庆祝，调试才是真正的开始。密码学算法的实现要求绝对的精确，一个比特的错误都会导致加解密失败。我建议你采用以下步骤来验证你的实现：

1. 使用标准测试向量：NIST或其他密码学标准机构会提供标准的明文、密钥和密文对照表。这是最权威的验证方法。找一组测试数据，比如：
   • 明文：0x0123456789ABCDEF
   • 密钥：0x133457799BBCDFF1
   • 密文：0x85E813540F0AB405 (加密结果) 用你的程序加密明文，看结果是否匹配。
2. 验证可逆性：这是最基本的测试。对一个随机数据加密，然后立即解密，看是否能恢复原数据。
3. 分模块测试：
   • 单独测试initial_permutation和final_permutation，看它们是否互逆。
   • 给定一个简单的输入，手动计算一轮feistel_function的结果，与程序输出对比。
   • 打印出16个子密钥，与已知正确的密钥调度结果对比。

调试过程中，一个十六进制查看器和二进制转换工具是你的好朋友。我经常写一些小函数来打印数据的二进制形式：

void print_binary(uint64_t num, int bits) {
    for (int i = bits - 1; i >= 0; i--) {
        printf("%d", (num >> i) & 1);
        if (i % 8 == 0) printf(" ");
    }
    printf("\n");
}

当你的程序终于能正确通过标准测试向量时，那种成就感是无与伦比的。你不仅实现了一个算法，更亲手走完了从规范到代码的完整工程路径。你会发现，原来课本上那些复杂的图示和公式，最终都可以转化为如此确定性的、一步步执行的代码逻辑。

6. 超越实现：从DES到现代加密的思考

当你成功运行了自己的DES实现后，我们不妨再往前走一步，思考一些更深层次的问题。DES的设计是20世纪70年代思维的结晶，它的局限性恰恰是后来加密算法发展的方向。

首先，关于安全性。 DES的56位密钥在今天确实太短了。暴力破解56位密钥空间，对现代计算资源已非难事。为此，人们曾提出过“三重DES”（3DES），即用两个或三个密钥对数据加密三次，将有效安全性提升到112位或168位。但3DES速度慢，且块大小仍是64位，在某些模式下可能存在风险。这直接催生了AES（高级加密标准）的诞生。AES的块大小是128位，密钥长度支持128、192、256位，其结构不再是Feistel网络，而是称为SPN（代换-置换网络），每一轮的操作包括字节代换、行移位、列混合和轮密钥加，设计更加简洁高效。

其次，关于工作模式。 我们实现的只是DES的ECB（电子密码本）模式，即每个64位块独立加密。这有一个致命缺点：相同的明文块会生成相同的密文块，不能隐藏数据模式。在实际应用中，我们更需要CBC（密码块链接）、CTR（计数器）等模式。例如CBC模式，它在加密前先将当前明文块与前一个密文块进行异或，这样相同的明文块在不同位置也会被加密成不同的密文块，安全性大大增强。

// 一个简化的CBC模式加密伪代码思路
uint64_t iv = INITIAL_VECTOR; // 初始化向量
uint64_t prev_cipher = iv;
for (int i = 0; i < num_blocks; i++) {
    uint64_t plain_block = plaintext[i];
    plain_block ^= prev_cipher; // 与前一个密文块异或
    des_encrypt(&plain_block, key); // 加密
    ciphertext[i] = plain_block;
    prev_cipher = plain_block;
}

最后，是关于实践的建议。 学习并实现DES，绝对不是为了在真实项目中使用它。它的教育意义远大于实用意义。通过这个项目，你至少收获了以下几点：

• 对位操作的熟练掌握：这是底层系统编程的基石。
• 对算法标准的精确实现能力：学会如何阅读RFC或标准文档，并将其转化为无歧义的代码。
• 对对称加密核心概念的理解：混淆、扩散、Feistel结构、S盒、密钥调度，这些概念在AES等其他算法中依然存在。
• 调试复杂逻辑的耐心：密码学代码的调试，锻炼的是你严谨和细致的能力。

我自己的代码仓库里，至今还保留着第一次成功实现DES的那个版本。它代码冗长，效率不高，但注释详尽，每一步都记录着当时的思考。后来即使我用更优雅的方式重写了它，那个最初的版本依然是我最珍视的。因为它证明了一件重要的事：再复杂的系统，也可以被分解、被理解、被构建。希望你的DES实现之旅，也能带给你同样的信心和乐趣。如果你在实现过程中卡在了某个S盒的查找上，或者发现末置换后结果总差那么一位，别灰心，那正是你离真正理解它最近的时候。去检查你的位序定义，去手动计算一个中间值，解决问题的过程，就是知识内化的过程。