在网络安全和密码学的世界中，寻找一种既高效又可靠的加密算法一直是开发者们的核心诉求。今天，我们将深入探讨一种经典的对称加密算法——Blowfish。作为一名开发者，你可能在处理遗留系统或嵌入式设备的加密需求时遇到过它。虽然 AES 现在更为通用，但 Blowfish 凭借其极快的速度和专利免费的特性，依然在许多特定场景下拥有强大的生命力。
在这篇文章中，我们将一起探索 Blowfish 的核心原理，拆解它的加密流程，并通过实际的 Java 代码示例来看看它是如何在应用程序中工作的。无论你是为了维护旧代码，还是出于对密码学纯粹的兴趣，这篇文章都会为你提供详尽的指导。
为什么选择 Blowfish？
在深入代码之前，我们先来了解一下为什么 Bruce Schneier 在 1993 年设计这个算法，以及它为什么至今仍被提及。Blowfish 的设计初衷是替代 DES（Data Encryption Standard）。与 DES 相比，Blowfish 的显著优势在于：
- 速度极快：在 32 位处理器上，Blowfish 的加密速度比 DES 快得多。
- 密钥灵活性：它支持可变长度的密钥，从 32 位到 448 位不等，这使得它能够适应不同安全级别的需求。
- 无专利限制：这是一种完全免费的算法，任何人都可以在任何国家使用，无需支付版税。
- 至今未被攻破：尽管已经问世多年，针对完整 16 轮 Blowfish 算法的有效密码分析攻击依然非常罕见（除了针对弱密钥的攻击）。
Blowfish 的核心参数
在编写代码之前，我们需要熟悉它的基本数据结构。Blowfish 是一个64位块密码（Block Cipher），这意味着它每次处理 64 位（8 字节）的数据块。如果你要加密更长的数据，需要配合某种“模式”来操作，但我们今天主要关注核心算法本身。
它的核心组件包括：
- P数组：包含 18 个 32 位子密钥。
- S盒：包含 4 个替换盒，每个盒有 256 个 32 位条目。
- 轮数：16 轮加密运算。
深入算法原理
让我们像拆解精密仪器一样，一步步看看 Blowfish 是如何运作的。整个过程分为密钥扩展和数据加密两个主要阶段。
#### 第一步：子密钥与 S 盒的初始化
Blowfish 的强大之处在于它的密钥扩展过程。我们并不直接使用用户输入的密钥，而是利用它来生成复杂的子密钥。
- 初始化 P 数组和 S 盒：首先，我们需要用固定的数字（具体来说，是十六进制表示的圆周率 π 的数字）来填充 P 数组和 4 个 S 盒。这是算法的“种子”状态。
例如，P 数组的初始部分是这样的：
P[0] = 0x243f6a88
P[1] = 0x85a308d3
...
P[17] = 0x8979fb1b
- 混合用户密钥：接下来，我们将用户提供的密钥（Key）与 P 数组进行异或（XOR）运算。
假设用户密钥是 K（32位到448位）。我们将 K 分成 32 位的一块块。
P[0] = P[0] XOR K的第1个32位
P[1] = P[1] XOR K的第2个32位
...
如果 K 的长度不够，我们会循环使用 K；如果 K 很长，我们就多 XOR 几次。直到所有 18 个 P 值都被修改过。
- 加密自身的初始化：这是 Blowfish 最酷的部分。为了生成最终的子密钥，算法使用上述生成的 P 数组和 S 盒，对一个全零的 64 位块进行 Blowfish 加密。然后用加密的结果替换 P[0] 和 P[1]。接着，用这个新的状态再次加密全零块，结果替换 P[2] 和 P[3]。这个过程一直重复，直到 P 数组的所有 18 个元素和 4 个 S 盒的所有 1024 个元素都被最终生成的加密数据所更新。
这个过程非常耗时，大约需要 521 次加密循环。但这正是 Blowfish 安全的关键——这极大地增加了暴力破解的难度（攻击者每尝试一个新密钥，都必须进行这 521 次复杂的初始化）。
#### 第二步：加密函数
一旦 P 数组和 S 盒准备好，我们就可以加密数据了。输入是一个 64 位的数据块，我们将其分为左半部分（L，32位）和右半部分（R，32位）。
16 轮循环（The 16 Rounds）：
for i = 0 to 15:
L = L XOR P[i]
R = F(L) XOR R
交换 L 和 R
这里的 F 函数是算法的核心心脏。它将一个 32 位的数据拆分成 4 个字节（a, b, c, d），分别作为 4 个 S 盒的索引，取值后进行加法和异或运算：
F(x) = ((S1[a] + S2[b]) XOR S3[c]) + S4[d]
后处理：
在 16 轮循环结束后，我们再次交换 L 和 R（抵消最后一次循环的交换），然后进行最后一步操作：
L = L XOR P[16]
R = R XOR P[17]
最后将 R 和 L 重新组合成 64 位密文。解密过程完全相同，只是 P 数组的使用顺序是反过来的（从 P[17] 到 P[0]）。
Java 实战示例
理论听起来很复杂，但用代码实现起来其实很有逻辑性。让我们用 Java 来构建一个简化版的 Blowfish 加密演示。为了便于理解，我们重点展示核心的 F 函数和加密循环。
#### 示例 1：定义核心常量和 F 函数
首先，我们需要定义数据结构。请注意，完整的 S 盒数据量很大（4096 个十六进制字符），为了节省篇幅，这里省略了大部分数据，但在实际运行中，你需要完整填充它们。
import java.util.*;
public class BlowfishDemo {
// P数组和S盒的初始值（通常使用预定义的十六进制字符串）
// 为了代码简洁，这里仅展示逻辑框架
static long[] P = new long[18];
static long[][] S = new long[4][256];
// 初始化方法：加载PI数字并混合密钥
public static void initialize(byte[] key) {
// 1. 加载初始P和S盒（省略具体加载代码，通常来自静态数组）
// loadInitialValues();
// 2. 用用户密钥更新P数组
int keyIndex = 0;
for (int i = 0; i < 18; i++) {
long data32 = 0;
// 将密钥的4个字节拼凑成一个32位long
for (int j = 0; j < 4; j++) {
data32 = (data32 <= key.length) keyIndex = 0; // 循环密钥
}
P[i] = P[i] ^ data32;
}
// 3. 更新S盒（省略复杂的自加密过程）
// updateSBoxes();
}
// 核心F函数
public static long FFunction(long x) {
// 将x拆分为4个8位部分作为索引
int a = (int) ((x >>> 24) & 0xff);
int b = (int) ((x >>> 16) & 0xff);
int c = (int) ((x >>> 8) & 0xff);
int d = (int) (x & 0xff);
// ((S1[a] + S2[b]) XOR S3[c]) + S4[d]
long sum1 = (S[0][a] + S[1][b]);
long xorVal = sum1 ^ S[2][c];
long result = xorVal + S[3][d];
return result;
}
}
#### 示例 2：加密过程的具体实现
接下来，我们看看如何利用上面的 F 函数来完成一次完整的块加密。这是 Blowfish 算法的主体逻辑。
public static long encryptBlock(long plaintext) {
long left = (plaintext >>> 32) & 0xffffffffL;
long right = plaintext & 0xffffffffL;
// 进行16轮加密
for (int i = 0; i < 16; i++) {
left = left ^ P[i]; // 与子密钥异或
// 将左半部分通过F函数，结果与右半部分异或
long fVal = FFunction(left);
right = right ^ fVal;
// 交换左右部分 (为了下一轮)
long temp = left;
left = right;
right = temp;
}
// 最后一次取消交换
long temp = left;
left = right;
right = temp;
// 后处理：异或最后两个子密钥
right = right ^ P[17];
left = left ^ P[16];
// 重新组合成64位
return (left << 32) | (right & 0xffffffffL);
}
#### 示例 3：结合 Java 内置库的实际应用
虽然自己实现算法有助于理解，但在生产环境中，我们通常使用经过验证的库。Java 的 javax.crypto 包内置了 Blowfish 支持。这是最安全、最高效的做法。下面是一个完整的工具类示例，展示了如何加密和解密字符串。
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.util.Base64;
import java.nio.charset.StandardCharsets;
public class BlowfishUtil {
// 定义加密算法模式
// Blowfish使用ECB模式（简化演示，实际生产建议用CBC或CTR）
// 以及PKCS5Padding填充模式
private static final String ALGORITHM = "Blowfish";
private static final String MODE = "Blowfish/ECB/PKCS5Padding";
private static final String CHARSET = "UTF-8";
/**
* 加密字符串
* @param plaintext 明文
* @param keyStr 密钥字符串（会被截断或填充以适应要求）
* @return Base64编码的密文
*/
public static String encrypt(String plaintext, String keyStr) {
try {
// 创建密钥。 Blowfish 密钥可以是 32 到 448 位
SecretKey secretKey = new SecretKeySpec(keyStr.getBytes(CHARSET), ALGORITHM);
Cipher cipher = Cipher.getInstance(MODE);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] encryptedBytes = cipher.doFinal(plaintext.getBytes(CHARSET));
// 使用Base64编码将字节数组转为字符串，方便传输
return Base64.getEncoder().encodeToString(encryptedBytes);
} catch (Exception e) {
throw new RuntimeException("加密失败", e);
}
}
/**
* 解密字符串
* @param ciphertext Base64编码的密文
* @param keyStr 密钥字符串
* @return 解密后的明文
*/
public static String decrypt(String ciphertext, String keyStr) {
try {
SecretKey secretKey = new SecretKeySpec(keyStr.getBytes(CHARSET), ALGORITHM);
Cipher cipher = Cipher.getInstance(MODE);
cipher.init(Cipher.DECRYPT_MODE, secretKey);
// 先Base64解码回字节数组
byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(ciphertext));
return new String(decryptedBytes, CHARSET);
} catch (Exception e) {
throw new RuntimeException("解密失败: " + e.getMessage(), e);
}
}
// 测试我们的加密工具
public static void main(String[] args) {
String originalText = "Hello, this is a secret message!";
String myKey = "MySecretKey123";
System.out.println("原始文本: " + originalText);
String encrypted = encrypt(originalText, myKey);
System.out.println("加密后: " + encrypted);
String decrypted = decrypt(encrypted, myKey);
System.out.println("解密后: " + decrypted);
}
}
常见问题与最佳实践
在实际开发中，你可能会遇到以下问题。这里有一些经验之谈，希望能帮你避坑。
- 密钥管理是重中之重：
不要把密钥硬编码在代码里。想象一下，如果你的反编译了你的 App，密钥暴露了，那么所有的加密都形同虚设。使用环境变量或安全的密钥管理服务。
- ECB 模式的陷阱：
在上面的例子中，为了简单，我使用了 ECB 模式。你一定要知道，ECB 模式是不安全的。如果你用 ECB 模式加密一张图片（比如企鹅的图片），加密后的图片轮廓依然清晰可见，因为相同的块会产生相同的密文。在实际项目中，请务必使用 CBC、CTR 或 GCM 等带有初始化向量（IV）的模式，这样即使明文相同，密文也会不同。
- 填充异常：
如果你尝试解密一个被篡改过的数据，或者使用了错误的密钥，通常会抛出 BadPaddingException。这并不总是代表填充错误，往往意味着密钥不对或数据损坏。处理这个异常时要小心，不要向攻击者暴露过多的错误信息。
- 性能考量：
Blowfish 的初始化很慢（这是它的安全特性），但加密速度极快。因此，它非常适合那些“建立连接后进行大量数据传输”的场景（如 VPN 链接）。如果你只是偶尔加密一个小字段，频繁更换密钥可能会带来性能开销，这时你可能需要考虑其他轻量级算法或保持连接复用。
结语：Blowfish 的现实意义
随着现代硬件的发展，AES-NI 指令集让 AES 算法在硬件层面如虎添翼，Blowfish 在纯速度上的优势已经不如从前。此外，Blowfish 的 64 位块大小在处理海量数据（如数 TB 的硬盘加密）时，容易受到所谓的“生日攻击”。因此，对于新项目，特别是涉及大量数据加密的场景，我们通常推荐使用 AES 或 Bruce Schneier 后来设计的 Twofish 算法。
然而，理解 Blowfish 依然极具价值。它的设计思想清晰，结构优美，是学习分组密码和 Feistel 网络的最佳教材。而且，在许多资源受限的嵌入式系统中，你依然能看到它的身影。
现在，你已经掌握了 Blowfish 的工作原理以及如何在 Java 中使用它。下一步，我建议你尝试修改上面的 Java 代码，将其从 ECB 模式改为 CBC 模式，亲自体验一下初始化向量（IV）是如何提升加密安全性的。祝你编码愉快！