Java 中的 Blowfish 实现答案

【问题标题】：Blowfish Implementation in JavaJava 中的 Blowfish 实现
【发布时间】：2018-08-25 09:35:40
【问题描述】：

我正在用 Java 构建 Blowfish 密码算法。我使用 these 测试向量来查看它是否有效，我发现最糟糕的可能事情 - 它适用于某些输入，而不适用于其他输入。

我使用Blowfish paper 作为指南来创建我的实现。下面是它的相关部分。

public class Blowfish {
    // Binary Digits of Pi
    // ...
    private static final int N = 16;
    private final long S[][] = new long[4][256];
    private final long P[] = new long[N + 2];

密钥扩展

布鲁斯说：

(1) 首先用固定字符串按顺序初始化 P 数组，然后初始化四个 S 盒。该字符串由 pi 的十六进制数字组成（减去开头的 3）

 public void keyExpansion(String key) {
        System.arraycopy(p, 0, P, 0, N + 2);
        for (int i = 0; i < 4; i++) {
            System.arraycopy(s[i], 0, S[i], 0, 256);
        }

我意识到这不是真的可读，但小写的p[] 和s[][] 包含固定值（pi 的十六进制数字），大写的P[] 和S[][] 是Blowfish 对象的属性，它们将会改变.

布鲁斯说：

(2) XOR P1 与密钥的前 32 位，XOR P2 与密钥的后 32 位，依此类推，用于密钥的所有位（可能直到 P14）。反复循环遍历关键位，直到整个 P-array 已与关键位异或。

for (int i = 0; i < N + 2; i++) {
    int begin = (i * 8) % key.length();
    int end = ((i + 1) * 8) % key.length();
    String keySubstring;
    if (begin < end) {
        keySubstring = key.substring(begin, end);
    } else {
        keySubstring = key.substring(begin) + key.substring(0, end);
    }
    long keyChunk = Long.parseLong(keySubstring, 16);
    P[i] ^= keyChunk;
}

由于密钥的长度不同（最多 56 个字节），我想出了最简单的方法来传递它是作为一个字符串。也许我应该使用 BigInteger？

布鲁斯说：

(3) 使用 Blowfish 算法加密全零字符串，使用步骤 (1) 和 (2) 中描述的子键。

(4) 将 P1 和 P2 替换为步骤 (3) 的输出。

(5) 使用 Blowfish 算法加密步骤 (3) 的输出修改子键。

(6) 将 P3 和 P4 替换为步骤 (5) 的输出。

(7) 继续该过程，替换 P 数组的所有条目，并且然后按顺序排列所有四个 S-box，输出不断变化的 Blowfish 算法。

long e = 0;
for (int i = 0; i < N + 2; i += 2) {
    e = encrypt(e);
    long eL = trim(e >>> 32);
    long eR = trim(e);
    P[i] = eL;
    P[i + 1] = eR;
}

for (int i = 0; i < 4; i++) {
    for (int j = 0; j < 256; j += 2) {
        e = encrypt(e);
        long eL = trim(e >>> 32);
        long eR = trim(e);
        S[i][j] = eL;
        S[i][j + 1] = eR;
    }
}

现在是提及我的帮助函数 trim 的好时机，它删除了更高的 32 位。

private static long trim(long value) {
    return value & 0xFFFFFFFFL;
}

加密

布鲁斯说：

Blowfish 是一个由 16 轮组成的 Feistel 网络。输入是一个 64 位数据元素 x。

将 x 分成两半 32 位：xL、xR

对于 i = 1 到 16：

xL = xL XOR Pi

xR = F(xL) XOR xR

交换 xL 和 xR

下一个

交换 xL 和 xR（撤消上次交换。）

xR = xR XOR P17

xL = xL XOR P18

重新组合 xL 和 xR

public long encrypt(long plaintext) {
        long xL = trim(plaintext >>> 32);
        long xR = trim(plaintext);

        for (int i = 0; i < N; i++) {
            xL = xL ^ P[i];
            xR = F(xL) ^ xR;
            //swap
            xL = xL + xR;
            xR = xL - xR;
            xL = xL - xR;
        }
        //swap
        xL = xL + xR;
        xR = xL - xR;
        xL = xL - xR;

        //final step
        xR = xR ^ P[N];
        xL = xL ^ P[N + 1];

        return (xL << 32) | xR;
    }
}

测试

我只是针对上述测试向量运行此代码，如下所示：

  public void testBlowfish() {
        long key[] = {
            ...
        };
        long clear[] = {
            ...
        };
        long cipher[] = {
            ...
        };
        Blowfish b = new Blowfish();
        for (int i = 0; i < 34; i++) {
            b.keyExpansion(Long.toHexString(key[i]));
            long result = b.encrypt(clear[i]);
            if (result == cipher[i]) {
                System.out.println("Test " + i + " passed!");
            } else {
                System.out.println("Test " + i + " failed: ");
                System.out.println("\tKey:\t" + Long.toHexString(key[i]));
                System.out.println("\tClear:\t" + Long.toHexString(clear[i]));
                System.out.println("\tCipher:\t" + Long.toHexString(cipher[i]));
                System.out.println("\tResult:\t" + Long.toHexString(result));
            }
        }
    }

以下是测试结果：

Test 0 passed!
Test 1 passed!
Test 2 passed!
Test 3 passed!
Test 4 failed: 
    Key:    123456789abcdef
    Clear:  1111111111111111
    Cipher: 61f9c3802281b096
    Result: 65a2dfe88702a6bf
Test 5 passed!
Test 6 passed!
Test 7 passed!
Test 8 passed!
Test 9 failed: 
    Key:    131d9619dc1376e
    Clear:  5cd54ca83def57da
    Cipher: b1b8cc0b250f09a0
    Result: fbd7e706e563d21a
Test 10 failed: 
    Key:    7a1133e4a0b2686
    Clear:  248d43806f67172
    Cipher: 1730e5778bea1da4
    Result: 7d11a2563bbf76f1
Test 11 passed!
Test 12 failed: 
    Key:    4b915ba43feb5b6
    Clear:  42fd443059577fa2
    Cipher: 353882b109ce8f1a
    Result: d747d42ef2bc89c0
Test 13 failed: 
    Key:    113b970fd34f2ce
    Clear:  59b5e0851cf143a
    Cipher: 48f4d0884c379918
    Result: c559acf605825008
Test 14 failed: 
    Key:    170f175468fb5e6
    Clear:  756d8e0774761d2
    Cipher: 432193b78951fc98
    Result: 8761d08e81a796d
Test 15 passed!
Test 16 failed: 
    Key:    7a7137045da2a16
    Clear:  3bdd119049372802
    Cipher: 2eedda93ffd39c79
    Result: db47a054a5a0d496
Test 17 failed: 
    Key:    4689104c2fd3b2f
    Clear:  26955f6835af609a
    Cipher: d887e0393c2da6e3
    Result: 40f96e5f9f3affe1
Test 18 passed!
Test 19 passed!
Test 20 passed!
Test 21 failed: 
    Key:    25816164629b007
    Clear:  480d39006ee762f2
    Cipher: 7555ae39f59b87bd
    Result: a6cb030922383650
Test 22 passed!
Test 23 passed!
Test 24 passed!
Test 25 failed: 
    Key:    18310dc409b26d6
    Clear:  1d9d5c5018f728c2
    Cipher: d1abb290658bc778
    Result: d45634df2f8eb002
Test 26 passed!
Test 27 failed: 
    Key:    101010101010101
    Clear:  123456789abcdef
    Cipher: fa34ec4847b268b2
    Result: 30ce63f436ff5475
Test 28 passed!
Test 29 passed!
Test 30 passed!
Test 31 passed!
Test 32 failed: 
    Key:    123456789abcdef
    Clear:  0
    Cipher: 245946885754369a
    Result: 291c4bd096af70e5
Test 33 passed!

正如我所说，有些输入有效，有些则无效。而且我不知道为什么，这对我来说似乎是任意的，我拒绝生活在计算机可以做出任意决定的世界中。换句话说，错误在哪里？

【问题讨论】：

猜测：Long 已签名，因此可能存在问题。
另一个猜测：您在转换中丢失了前导零。将每次出现的Long.toHexString(x) 替换为String.format("%016x", x)。
尝试使用临时代码对交换进行编码。您使用的技巧可能会因溢出而失败……尽管乍一看，这可能不会发生。如果您提供完整的工作示例，您更有可能获得有用的答案。
我认为这不会发生，因为我使用的是 long 类型，其中只有下 32b 包含值，上半部分为零。如果在交换期间确实发生了溢出，它将位于第 32 位（而不是第 64 位，因此不是实际的溢出）。我复制了整个工作代码，但将其分成几部分以增加可读性。坏主意？

标签： java algorithm encryption blowfish

【解决方案1】：

正如建议的那样，我在转换中丢失了前导零。实现很好，但在测试行中

b.keyExpansion(Long.toHexString(key[i]));

导致错误。替换为

b.keyExpansion(String.format("%016x", key[i]));

工作。

现在看起来很明显，因为每个失败的测试至少有一个前导零。

编辑

出于某种原因，我假设每个密钥都将超过 8 个字节。为了让keyExpansion 用于短键，我改变了从键的读取，如下所示：

for (int i = 0; i < N + 2; i++) {
    StringBuilder keySubstring = new StringBuilder();
    for (int j = 0; j < 8; j++) {
        int index = (i * 8 + j) % key.length();
        keySubstring.append(key.charAt(index));
    }
    long keyChunk = Long.parseLong(keySubstring.toString(), 16);
    P[i] ^= keyChunk;
}

【讨论】：

这个键扩展现在是否也适用于测试向量中的可变长度键？