DES 加密算法实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * 生成16个48位的子密钥
 * @param keyBytes 64位原密钥，用字符数组存储其比特串
 * @return 子密钥数组，用二维字符数组表示
 */
private char[][] generateSubKeys(char[] keyBytes) {
    char[][] subKeys = new char[16][48];
    // 置换选择 1
    char[] c = ArrayUtil.disruptArray(keyBytes, DESConstants.replace1C);
    char[] d = ArrayUtil.disruptArray(keyBytes, DESConstants.replace1D);

    // 循环左移
    for (int i = 0; i < 16; i++) {
        c = ArrayUtil.leftShift(c, DESConstants.moveBit[i]);
        d = ArrayUtil.leftShift(d, DESConstants.moveBit[i]);
        
        // 将Ci和Di合并得到56位的中间数据
        char[] concatChars = ArrayUtil.concat(c, d);

        // 置换选择 2，得到48位的子密钥Ki
        char[] key = ArrayUtil.disruptArray(concatChars, DESConstants.replace2);
        subKeys[i] = key;
    }
    return subKeys;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

/**
 * DES核心加密函数
 * 包括扩展、替代、选择等操作
 * @param right R(i-1)
 * @param subKey Ki
 * @return result 运算结果
 */
private char[] coreEncrypt(char[] right, char[] subKey) {
    // 1. 选择运算 E
    char[] extendedRight = ArrayUtil.disruptArray(right, DESConstants.E);
	
    // 2. 将晋国选择运算E扩展得到的48位的数据与子密钥进行异或
    char[] xorResult = ArrayUtil.xor(extendedRight, subKey);

    // 3. 用替代函数组进行替代
    // 为便于处理，将上述1x48位的数据矩阵转换成8x6的数据矩阵
    char[][] twoDimensionArray = ArrayUtil.segmentDimension(xorResult, 8, 6);
    StringBuilder outputBuilder = new StringBuilder();
    // 根据替代规则进行替代
    for (int i = 0; i < twoDimensionArray.length; i++) {
        char[] rowBits = {twoDimensionArray[i][0], twoDimensionArray[i][5]};
        char[] columnBits =
        {
            twoDimensionArray[i][1], twoDimensionArray[i][2],
            twoDimensionArray[i][3], twoDimensionArray[i][4]
        };

        // 获取对应S盒的输出的坐标
        int rowIndex = Integer.parseInt(String.valueOf(rowBits), 2);
        int columnIndex = Integer.parseInt(String.valueOf(columnBits), 2);
		// 获取对应S盒的输出
        short output = DESConstants.SUBSTITUTE_BOX[i][rowIndex][columnIndex];
        outputBuilder.append(Integer.toBinaryString((output & 0x0f) + 0x10).substring(1));
    }
    char[] substitutedResult = outputBuilder.toString().toCharArray();
    // 4. 进行置换运算 P，返回28位的数据
    return ArrayUtil.disruptArray(substitutedResult, DESConstants.P);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

/**
 * 对外的加密接口，主要逻辑封装在encode方法中
 * @param plaintext 明文
 * @param key 密钥
 * @return encrypted text
 * @throws UnsupportedEncodingException caused by String.getBytes()
 */
public String encrypt(String plaintext, String key) throws UnsupportedEncodingException {
    // 获取明文及密钥对应的比特串，用字符数组存储
    char[] plaintextBytes = ArrayUtil.bytesToChars(
        plaintext.getBytes("UTF-8"));
    char[] keyBytes = ArrayUtil.bytesToChars(
        key.getBytes("UTF-8"));
	// 子密钥的生成
    char[][] subKeys = generateSubKeys(keyBytes);
    char[] result = encode(plaintextBytes, subKeys);
	// 使用Base64编码对不可见及非打印字符进行编码
    return Base64Util.encode(result);
}

/**
 * 主体加密逻辑
 * @param plaintextBytes 用字符数组存放的明文的比特串
 * @param subKeys 子密钥数组
 * @return encryption 64位加密结果
 */
private char[] encode(char[] plaintextBytes, char[][] subKeys) {
    // 初始置换 IP
    char[] chars = ArrayUtil.disruptArray(plaintextBytes, DESConstants.IP);

    // 将明文分成两半
    int length = chars.length;
    String binaryArrayStr = String.valueOf(chars);
    char[] left = binaryArrayStr.substring(0, length / 2).toCharArray();
    char[] right = binaryArrayStr.substring(length / 2).toCharArray();
    char[] coreEncrypted, xorResult;

    for (int i = 0; i < 16; i++) {
        // 调用核心加密函数，用子密钥Ki对R(i-1)进行加密，得到28位数据
        coreEncrypted = coreEncrypt(right, subKeys[i]);

        // L(i - 1)与f(R(i - 1), Ki)进行异或运算
        xorResult = String.valueOf(ArrayUtil.xor(left, coreEncrypted))
            .substring(16).toCharArray();

        left = right;
        right = xorResult;
    }
    char[] calResult = ArrayUtil.concat(right, left);
    // 逆初始置换
    return ArrayUtil.disruptArray(calResult, DESConstants.inverseIP);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

/**
 * 解密
 * @param encryptedText 加密数据
 * @param key  密钥
 * @return decrypted origin plaintext
 * @throws UnsupportedEncodingException caused by String.getBytes()
 */
@Override
public String decrypt(String encryptedText, String key) throws UnsupportedEncodingException {
    // 将已使用Base64编码的密文解码
    char[] encryptedTextBytes = Base64Util.decode(encryptedText);
    char[] keyBytes = ArrayUtil.bytesToChars(
        key.getBytes("UTF-8"));
	
    // 将通过密钥获取到的子密钥数组逆转
    char[][] inverseKeys = inverseSubKeys(generateSubKeys(keyBytes));
    // 解密
    char[] result = encode(encryptedTextBytes, inverseKeys);
    // 将比特串还原为字符串明文
    return ArrayUtil.segmentAndPrintChars("decrypt plaintext text", result);
}

/**
 * 将通过密钥获取到的子密钥数组逆转
 * @param subKeys 原子密钥数组
 * @return  翻转的子密钥数组
 */ 
private char[][] inverseSubKeys(char[][] subKeys) {
    char[][] inverseKeys = new char[subKeys.length][];

    for (int i = 0; i < subKeys.length; i++) {
        inverseKeys[i] = subKeys[subKeys.length - 1 - i];
    }
    return inverseKeys;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Test
public void testService() {
    String plaintext = "01234567", key = "12345678";
    CipherService cipherService = new DESCipherService();
    try {
        String encryptedText = cipherService.encrypt(plaintext, key);
        cipherService.decrypt(encryptedText,key);
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

/**
 * 明文填充，最后一组的最后8位表示填充长度
 */
private char[][] padPlaintext(String plaintext) {
    char[] plaintextBytes = ArrayUtil.bytesToChars(
        plaintext.getBytes());
    int length = plaintextBytes.length;
    int lastBlockBits = length % 64;
    // 现有块数
    int blockCount = length / 64;

    // 待伪随机填充位数
    int randPadCount = 64 - lastBlockBits - 8;
    char[] padded = new char[(blockCount + 1) * 64];
    System.arraycopy(plaintextBytes, 0, padded, 0, length);

    // 伪随机填充
    for (int i = length; i < padded.length - 8; i++) {
        padded[i] = new Random().nextBoolean() ? '1' : '0';
    }
    // 填充最后一个字节比特串
    char[] padCountVal = Integer.toBinaryString(
        (randPadCount & 0xff) + 0x0100).substring(1).toCharArray();
    System.arraycopy(padCountVal, 0, padded, padded.length - 8, 8);

    // 将填充完比特穿分组
    char[][] blocks = new char[blockCount + 1][64];
    for (int i = 0; i < blockCount + 1; i++) {
        System.arraycopy(padded, i * 64, blocks[i], 0, 64);
    }
    return blocks;
}

1
2
3
4
5

@Test
public void testPadPlaintext() {
    DESCipherService desCipherService = new DESCipherService(false);
    desCipherService.padPlaintext("password1");
}