Java DES算法轉Python3的坑

參考博客：https://www.cnblogs.com/Tommy-Yu/p/5867181.html

今天寫mock遇到一個比較坑的事情，Java加密的Python解不了密，具體看一下代碼：

Java代碼：

package com.vcredit.entrustdelegator.utils;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.SecureRandom;


public class Encrypt {

    /**
     * 解密報文
     *
     * @param value 密文
     * @param key   密鑰
     * @return 解密明文
     * @throws Exception 異常
     */
    public static String decrypt3DES(String value, String key) throws Exception {
        return new String(decrypt(hex2byte(value.getBytes()), key.getBytes()), StandardCharsets.UTF_8);
    }


    /**
     * 加密報文
     *
     * @param value 明文
     * @param key   密鑰
     * @return 加密報文
     * @throws Exception 異常
     */
    public static String encrypt3DES(String value, String key) throws Exception {
        return byte2hex(encrypt(value.getBytes(StandardCharsets.UTF_8), key.getBytes()));
    }

    private static byte[] hex2byte(byte[] buffer) {
        if (buffer.length % 2 != 0) {
            throw new IllegalArgumentException("長度不是偶數");
        } else {
            byte[] var1 = new byte[buffer.length / 2];

            for (int var2 = 0; var2 < buffer.length; var2 += 2) {
                String var3 = new String(buffer, var2, 2);
                var1[var2 / 2] = (byte) Integer.parseInt(var3, 16);
            }

            return var1;
        }
    }

    private static String byte2hex(byte[] buffer) {
        StringBuilder var1 = new StringBuilder();
        for (byte aBuffer : buffer) {
            String var2;
            if ((var2 = Integer.toHexString(aBuffer & 255)).length() == 1) {
                var1.append("0").append(var2);
            } else {
                var1.append(var2);
            }
        }
        return var1.toString().toUpperCase();
    }

    private static byte[] encrypt(byte[] src, byte[] key) throws Exception {
        SecureRandom var2 = new SecureRandom();
        DESKeySpec key1 = new DESKeySpec(key);
        SecretKey key2 = SecretKeyFactory.getInstance("DES").generateSecret(key1);
        Cipher var3;
        (var3 = Cipher.getInstance("DES")).init(1, key2, var2);
        return var3.doFinal(src);
    }

    private static byte[] decrypt(byte[] src, byte[] key) throws Exception {
        SecureRandom var2 = new SecureRandom();
        DESKeySpec key1 = new DESKeySpec(key);
        SecretKey key2 = SecretKeyFactory.getInstance("DES").generateSecret(key1);
        Cipher var3;
        (var3 = Cipher.getInstance("DES")).init(2, key2, var2);
        return var3.doFinal(src);
    }
}

坑一：3DES

從上面的代碼看解密函數是decrypt3DES，“3DES”讓人以為是DES3算法，其實Java中的3DES對應的是“DESede”，於是利用Python的DES3算法解密，結果解不出來。這里其實用的還是DES算法。

坑二：DES

上面代碼寫的是getInstance("DES")，沒有指明具體是什么算法，按照默認的來了，Java默認算法應該是DES/ECB/PKCS5Padding，Python我也用默認的了，還好默認的算法和Java一樣，不過這里編碼的時候最好明確指出，避免歧義。

坑三：Java的DES對key沒有檢查（參考的博客中有說明，寫的很給力，很到位，一針見血）

如果key大於8位，則默認截取前8位用來加密！不報錯！

但是Python中會報錯，所以一開始用DES算法，看到報錯了就覺得是算法用錯了，然后用DES3算法，坑啊。

最后還是用DES算法，密碼截取前8位，然后解密成功了！

對應Python代碼：

from Crypto.Cipher import DES
import binascii

def des_decode(data, key):
    """aes解密
    :param key:
    :param data:
    """
    cipher = DES.new(key)
    result2 = binascii.a2b_hex(data)  # 十六進制還原成二進制
    decrypted = cipher.decrypt(result2)
    print(decrypted)
    return decrypted.rstrip(b'\0')  # 解密完成后將加密時添加的多余字符'\0'刪除


def aes_encrypt(data, key):
    """des加密函數，如果data不是16的倍數【加密文本data必須為16的倍數！】，那就補足為16的倍數
    :param key:
    :param data:
    """
    cipher = DES.new(key)
    block_size = DES.block_size
    # 判斷data是不是16的倍數，如果不是用b'\0'補足
    if len(data) % block_size != 0:
        add = block_size - (len(data) % block_size)
    else:
        add = 0
    data += b'\x03' * add
    encrypted = cipher.encrypt(data)  # des加密
    result = binascii.b2a_hex(encrypted)  # b2a_hex encode  將二進制轉換成16進制
    return result