Java实现DES加解密：从Feistel网络到S盒的完整实现与调试指南

1. 项目概述：为什么现在还要聊DES？

“Java实现DES加解密”，这个标题听起来有点“复古”，对吧？毕竟DES（Data Encryption Standard）作为上世纪70年代诞生的对称加密算法，密钥长度只有56位，在算力爆炸的今天，早已被AES（Advanced Encryption Standard）取代，不再被认为是安全的。那为什么我们还要花时间研究它呢？原因有几个，而且对Java开发者来说都挺实在的。

首先，理解DES是理解现代密码学的绝佳起点。DES的结构（Feistel网络）和核心概念（如S盒、P置换、轮函数）是许多后续加密算法的基础。搞懂了DES，再去学AES、SM4等算法，你会觉得豁然开朗，它们都是在解决DES暴露出的问题（密钥短、安全性不足）上做的演进。其次，遗留系统维护。虽然新系统不会用DES，但很多老旧的金融、政务或工业控制系统里，DES可能还在服役。作为开发者，你可能会遇到需要与这些系统进行数据交互的场景，这时候懂DES的实现和调试就至关重要了。最后，也是很多Java程序员绕不开的——面试。DES的加解密过程、ECB/CBC模式的区别、Padding的作用，这些都是经典的“八股文”考点，能清晰地说出DES的16轮加密流程，绝对能体现你的基本功。

所以，这篇内容不是教你用DES去加密你的新系统数据（千万别这么做！），而是带你从零开始，用Java亲手实现一遍DES加解密，深入其骨髓，理解每一个字节的变换。我们会从原理拆解到代码实现，再到各种模式和填充的实战，最后聊聊那些调试中真正会遇到的“坑”。无论你是为了面试准备，还是为了理解密码学，或者单纯想挑战一下自己，这篇内容都能给你带来实实在在的收获。

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

DES是一种分组加密算法，它以64位（8字节）为一个分组进行加解密，密钥名义上是64位，但实际有效长度是56位，另外8位用于奇偶校验。它的核心设计是Feistel网络结构，这种结构有一个 brilliant 的特性：加密和解密可以使用同一套逻辑，只是子密钥的使用顺序相反。这大大简化了硬件和软件的实现。

2.1 Feistel网络：DES的骨架

Feistel网络将输入的64位明文分成左右两半，各32位，记为L0和R0。然后进行多轮（DES是16轮）迭代。每一轮的操作可以概括为：

1. 将上一轮的右半部分（R_i-1）直接作为下一轮的左半部分（L_i）。
2. 将上一轮的右半部分（R_i-1）经过一个轮函数F处理，再与上一轮的左半部分（L_i-1）进行异或（XOR）操作，结果作为下一轮的右半部分（R_i）。

用公式表示就是：

L_i = R_{i-1} R_i = L_{i-1} XOR F(R_{i-1}, K_i)

其中，K_i是第i轮的子密钥。

这个结构的精妙之处在于，解密过程完全一样，只需要把子密钥的使用顺序倒过来（K16, K15, ..., K1）。因为 XOR 操作是可逆的，且F函数本身不需要是可逆的，这降低了对F函数设计的苛刻要求。

2.2 核心轮函数F：算法的灵魂

轮函数F是DES安全性的核心，它接受32位的右半部分输入和48位的子密钥，输出32位。其过程分为四步：

1. 扩展置换（E-box）：将32位的输入扩展为48位。这不是简单填充，而是通过重复某些位来实现的。目的是让输入的一位能影响下一轮多个S盒的运算，从而产生“雪崩效应”。
2. 与子密钥异或：将扩展后的48位数据与48位的子密钥进行按位异或。
3. S盒替换（S-box）：这是DES中最关键、最神秘的非线性部分。将异或后的48位数据分成8组，每组6位，送入8个不同的S盒（每个S盒是一个4行16列的查找表）。每个S盒将6位输入映射为4位输出。8个S盒总共输出32位。S盒的设计是保密的，它提供了算法的混淆特性，使得输入和输出之间的关系极其复杂。
4. P盒置换（P-box）：将S盒输出的32位数据按照一个固定的置换表（P盒）进行重新排列。这提供了算法的扩散特性，使得S盒输出的每一位影响下一轮多个位置。

2.3 子密钥生成：从主密钥派生

DES的56位有效主密钥，需要生成16个48位的子密钥（K1到K16）。过程如下：

1. 初始密钥置换（PC-1）：64位密钥（含校验位）经过PC-1置换，去掉8位校验位，并打乱顺序，得到56位数据，分成左右各28位的C0和D0。
2. 循环左移：对于每一轮i，C_i-1和D_i-1分别进行循环左移，左移的位数根据轮数而定（第1、2、9、16轮左移1位，其他轮左移2位）。
3. 压缩置换（PC-2）：将循环左移后合并的56位数据，经过PC-2置换，压缩并打乱顺序，输出48位的子密钥K_i。

注意：子密钥生成过程也是可逆的，知道了任何一轮的子密钥和移位规则，理论上可以反推主密钥，但这在不知道S盒和P盒具体内容的情况下极其困难。

理解了这些，我们就有了用Java实现DES的“图纸”。接下来，我们将把这些抽象的置换表和逻辑，转化为具体的Java代码和位操作。

3. 核心细节解析与Java实现要点

用Java实现DES，本质上是一场精细的“位操作”游戏。Java没有无符号类型，字节（byte）是8位有符号的（范围-128~127），而DES处理的是无符号的位。这是第一个需要小心处理的点。

3.1 数据表示与位操作工具

我们通常用byte[]数组来表示数据块（64位用8个byte）和密钥。但DES的置换、移位都是按位进行的。因此，我们需要一些工具方法来处理byte[]和bit之间的关系。

一个常见的技巧是，将byte[]转换为一个long类型（64位）的整数来处理。因为long在Java中是64位有符号整数，我们可以利用其位运算（<<,>>,&,|,^）的高效性。对于32位的数据块，则可以用int。但要注意，Java的>>是算术右移（符号位填充），而DES中我们需要的是逻辑右移（0填充）。所以我们需要使用>>>操作符。

我们将创建一些核心工具方法：

• long bytesToLong(byte[] data, int offset): 从byte[]指定位置读取8个字节并转换为long。
• byte[] longToBytes(long value): 将long转换回byte[]。
• int permute(long data, int[] permutationTable, int inputWidth): 通用的置换函数。它根据给定的置换表（表中数字表示原数据中第几位放到新数据的位置），对输入数据进行位重排。这是实现所有置换（IP, IP-1, E, P, PC-1, PC-2）的基础。
• int circularLeftShift(int value, int bits, int totalWidth): 循环左移函数，用于子密钥生成。

3.2 置换表的定义与使用

DES算法充斥着各种固定的置换表。在代码中，我们会将它们定义为static final int[]数组。例如：

// 初始置换IP private static final int[] IP = { 58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, // ... 省略后续56个数字 }; // 逆初始置换IP-1 private static final int[] IP_INV = { 40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31, // ... };

permute函数会读取这些表。例如，permute(data, IP, 64)表示对64位的data进行初始置换。置换表的数字范围是1到64，表示原数据位的位置。在实现时，我们通常将其转换为从0开始的索引，并注意位的顺序（最高位MSB通常是位63，最低位LSB是位0）。

3.3 S盒的实现：查表法的艺术

S盒是8个4x16的二维数组。每个S盒接收6位输入（b1b2b3b4b5b6）。其中，b1b6两位组成一个2位数（0-3），作为行号；b2b3b4b5四位组成一个4位数（0-15），作为列号。根据行列号在S盒表中查找，得到一个0-15的4位数作为输出。

在Java中，我们可以用三维数组int[8][4][16]或者八个独立的二维数组int[4][16]来存储S盒。使用查表法实现效率最高。

private static final int[][][] S_BOXES = { { // 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}, // ... 行2，行3 }, { // S2 // ... }, // ... S3 到 S8 }; private int sBoxSubstitution(int input48) { int output32 = 0; for (int i = 0; i < 8; i++) { // 从48位输入中提取6位 int sixBits = (input48 >>> (42 - i * 6)) & 0x3F; // 注意位提取的顺序 int row = ((sixBits & 0x20) >>> 4) | (sixBits & 0x01); // 取第1和第6位组成行 int col = (sixBits >>> 1) & 0x0F; // 取中间4位组成列 int fourBits = S_BOXES[i][row][col]; output32 = (output32 << 4) | fourBits; // 将4位输出合并到32位中 } return output32; }

实操心得：S盒的输入输出位顺序非常容易搞错。在从48位数据块中提取6位时，要清楚你的数据表示是高位在前（Big-endian）还是低位在前。上述代码假设我们处理的是一个标准的、高位在左的位串。调试时，最好用一组已知的测试向量（Test Vector）来验证S盒的输出是否正确。

4. 完整Java实现与核心流程解析

现在，我们把所有部件组装起来。我们将创建一个DESEngine类，它不直接处理工作模式（如CBC）和填充，只负责最核心的ECB模式下的加解密变换。

4.1 类结构与初始化

public class DESEngine { // 所有置换表、S盒、移位表等常量定义 private static final int[] IP = {...}; private static final int[] SHIFT_SCHEDULE = {1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1}; // 16轮每轮左移位数 // 加密/解密用的子密钥数组 private long[] subKeys = new long[16]; /** * 构造函数，根据密钥初始化16个子密钥 * @param key 8字节的DES密钥 */ public DESEngine(byte[] key) { if (key.length != 8) { throw new IllegalArgumentException("DES key must be exactly 8 bytes (64 bits) long."); } generateSubKeys(key); } private void generateSubKeys(byte[] key) { // 1. 将8字节密钥转换为64位long long key64 = bytesToLong(key, 0); // 2. 经过PC-1置换，得到56位数据（实际存储在64位long的高56位） long permutedKey56 = permute(key64, PC1, 64); // 3. 分成左右28位 int c = (int)(permutedKey56 >>> 28) & 0x0FFFFFFF; // 高28位 int d = (int)(permutedKey56 & 0x0FFFFFFF); // 低28位 // 4. 生成16轮子密钥 for (int i = 0; i < 16; i++) { // 循环左移 c = circularLeftShift28(c, SHIFT_SCHEDULE[i]); d = circularLeftShift28(d, SHIFT_SCHEDULE[i]); // 合并并通过PC-2置换生成48位子密钥 long combined56 = ((long) c << 28) | (d & 0x0FFFFFFFL); subKeys[i] = permute(combined56, PC2, 56); // 注意PC-2输入是56位 } } // ... 其他工具方法 (permute, circularLeftShift28, bytesToLong等) }

4.2 核心加密/解密单块过程

这是DES算法的核心循环，处理一个64位的分组。

/** * 加密或解密单个64位数据块 * @param block 8字节的输入数据块 * @param encrypt true为加密，false为解密 * @return 8字节的输出数据块 */ public byte[] processBlock(byte[] block, boolean encrypt) { if (block.length != 8) { throw new IllegalArgumentException("Input block must be exactly 8 bytes long."); } // 1. 初始置换IP long data = bytesToLong(block, 0); data = permute(data, IP, 64); // 2. 分成左右32位 int left = (int)(data >>> 32); int right = (int)(data & 0xFFFFFFFFL); // 3. 16轮Feistel迭代 for (int round = 0; round < 16; round++) { int roundKeyIndex = encrypt ? round : 15 - round; // 加密用K0-K15，解密用K15-K0 long subKey = subKeys[roundKeyIndex]; // 保存下一轮的左半部分 int nextLeft = right; // 计算轮函数 F(right, subKey) // a. 扩展置换E：32位 -> 48位 long expandedRight = permute(right & 0xFFFFFFFFL, E, 32); // b. 与子密钥异或 expandedRight ^= subKey; // c. S盒替换：48位 -> 32位 int substituted = sBoxSubstitution((int)expandedRight); // 注意类型转换，高16位为0 // d. P盒置换 int fResult = permute(substituted, P, 32); // 计算下一轮的右半部分：left XOR F(...) int nextRight = left ^ fResult; // 更新左右部分，准备下一轮 left = nextLeft; right = nextRight; } // 4. 最后一轮结束后，交换左右（Feistel网络的特性，16轮后需要交换） int temp = left; left = right; right = temp; // 5. 合并左右并执行逆初始置换IP-1 long preOutput = ((long)left << 32) | (right & 0xFFFFFFFFL); long output = permute(preOutput, IP_INV, 64); // 6. 转换回字节数组 return longToBytes(output); }

4.3 工作模式与填充的集成

单纯的DESEngine只能处理恰好8字节的数据。实际应用中，数据长度任意，且需要更强的安全性（避免ECB模式相同明文产生相同密文的缺陷）。因此我们需要在其上封装工作模式和填充方案。

常见的模式有ECB、CBC、CFB、OFB等。我们以最常用的CBC（密码分组链接）模式为例，并搭配PKCS5Padding填充。

import javax.crypto.*; import javax.crypto.spec.IvParameterSpec; // 我们自己的DESEngine类 public class DESUtil { private static final String TRANSFORMATION = "DES/CBC/PKCS5Padding"; // 使用JCE的表示法 /** * 使用CBC模式和PKCS5Padding进行加密 * @param data 明文数据 * @param key 8字节密钥 * @param iv 8字节初始化向量 * @return 密文数据 */ public static byte[] encryptCBC(byte[] data, byte[] key, byte[] iv) throws GeneralSecurityException { // 注意：实际生产环境应使用JCE（Java Cryptography Extension）的Cipher类。 // 此处为演示，我们基于自己的DESEngine模拟CBC逻辑。 if (key.length != 8 || iv.length != 8) { throw new IllegalArgumentException("Key and IV must be 8 bytes for DES."); } DESEngine engine = new DESEngine(key); // 1. 应用PKCS5Padding int paddingLen = 8 - (data.length % 8); byte[] paddedData = new byte[data.length + paddingLen]; System.arraycopy(data, 0, paddedData, 0, data.length); for (int i = data.length; i < paddedData.length; i++) { paddedData[i] = (byte) paddingLen; } // 2. CBC模式加密 byte[] ciphertext = new byte[paddedData.length]; byte[] previousBlock = iv; // 第一个块的前一个块是IV for (int i = 0; i < paddedData.length; i += 8) { // 当前明文块与上一个密文块（或IV）异或 byte[] blockToEncrypt = new byte[8]; for (int j = 0; j < 8; j++) { blockToEncrypt[j] = (byte)(paddedData[i + j] ^ previousBlock[j]); } // 加密异或后的块 byte[] encryptedBlock = engine.processBlock(blockToEncrypt, true); System.arraycopy(encryptedBlock, 0, ciphertext, i, 8); // 当前密文块作为下一轮的“前一个块” previousBlock = encryptedBlock; } return ciphertext; } // decryptCBC方法与之对称，过程相反：先解密，再异或。 }

重要提示：上述DESUtil是为了教学演示。在实际的Java项目中，绝对不应该自己实现密码学算法用于生产环境！应该使用Java标准库javax.crypto.Cipher，它经过严格测试和优化，并可能得到硬件加速。

// 正确的生产代码示例 Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding"); SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "DES"); IvParameterSpec ivSpec = new IvParameterSpec(ivBytes); cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec); byte[] ciphertext = cipher.doFinal(plaintextBytes);

自己实现DES的价值在于学习和理解，而不是替代标准库。

5. 常见问题、调试技巧与安全考量

即使理解了原理，在实现和调试DES时也会遇到各种问题。下面是一些常见坑点和排查思路。

5.1 字节序与位序混乱

这是最常出错的地方。DES标准文档中描述的位顺序（bit 1是最高位，bit 64是最低位）与我们在代码中处理byte[]和long时的内存顺序可能不一致。

• 症状：加密结果与标准测试向量对不上，或者加密后再解密无法还原。
• 排查：
  1. 使用标准测试向量（NIST或教科书上的例子）。输入固定的明文和密钥，得到确定的密文。这是调试的黄金标准。
  2. 检查置换函数：在permute函数中打印输入和输出的二进制表示，对照置换表手动计算几位，看是否匹配。确保你的置换表数字（1-64）正确转换成了基于0的索引，并且对应到了正确的位位置。
  3. 关注S盒的输入输出：确保从48位数据中提取6位给S盒时，行和列的拼接顺序与标准一致。

5.2 子密钥生成错误

如果子密钥错了，整个加解密过程都会失败。

• 症状：加密结果错误，且解密无法还原。
• 排查：
  1. 打印每一轮生成的子密钥（十六进制格式），与已知正确的子密钥序列对比。
  2. 重点检查PC-1和PC-2置换表是否正确，以及28位循环左移函数circularLeftShift28是否正确处理了溢出（第28位移到第1位）。

5.3 工作模式与填充问题

当集成模式和填充时，问题会变得更复杂。

• 症状：加密长数据正常，但解密时末尾出现乱码；或者解密时抛出BadPaddingException。
• 排查：
  1. 填充验证：在解密后，手动检查最后一个字节的值padLen，然后验证解密数据末尾的padLen个字节是否都等于padLen。如果不等于，说明解密过程或密钥有误。
  2. CBC模式的IV：确保加密和解密使用的初始化向量（IV）完全相同。IV不需要保密，但必须一致。通常将IV和密文一起存储或传输。
  3. 数据长度：确认加密前的数据在填充后是否是8字节的整数倍。

5.4 性能与安全警示

• 性能：纯Java实现的DES用于教学尚可，但性能远低于JCE原生实现或硬件加速。切勿在需要高性能的场景中使用自己的实现。
• 安全警示（务必阅读）：
  • DES已不安全：56位密钥可在短时间内被暴力破解。绝对不要在任何新的、对安全有要求的系统中使用DES。
  • 使用3DES或AES：如果需要兼容旧系统，考虑使用3DES（Triple DES），它通过三次DES操作将有效密钥长度提升到112或168位，但速度更慢。新系统一律使用AES-128/192/256。
  • ECB模式不安全：如上所述，ECB模式会导致相同明文块产生相同密文块，泄露数据模式。始终使用带随机IV的CBC模式，或者更好的GCM（认证加密）模式。
  • 密钥管理：密钥的存储、分发和轮换是比算法本身更大的挑战。考虑使用密钥管理系统（KMS）。

5.5 调试工具与技巧

1. 单元测试是王道：为你的DESEngine编写详尽的单元测试，覆盖标准测试向量、边界情况（全0、全1数据）、以及随机数据的加密-解密循环测试。
2. 分阶段调试：先单独测试permute、generateSubKeys、sBoxSubstitution等函数，确保每个部件正确，再组装测试整体流程。
3. 可视化与日志：在16轮加密的每一轮，打印出left、right、subKey的中间值（十六进制），与已知正确的中间结果对比。这是定位问题轮次的最快方法。
4. 对比JCE实现：用相同的密钥、IV、模式和明文，分别用你自己的实现和javax.crypto.Cipher进行加密，比较结果。如果不一致，就从初始置换IP开始，一步步对比中间状态。

实现一个可用的DES算法，就像完成一次精密的机械组装。每一个比特的移动都必须准确无误。这个过程会极大地加深你对对称加密、分组密码工作模式的理解。当你看到自己编写的代码成功通过标准测试向量时，那种成就感是无可替代的。但请始终记住，这个技能的终极价值在于“理解”而非“应用”，在真实的世界里，请把加密的重任交给那些久经沙场、千锤百炼的标准库和算法。