接口API中的敏感數據基於AES進行安全加密后返回

許久沒有寫博客了，有些惶恐地打開這個再熟悉不過的編輯器。

場景：要對一個涉及到敏感數據（賬號、密碼）的接口進行加密后返回

由於之前沒有相關的經驗，所以先在網上搜羅了一陣，這篇博客不錯https://www.cnblogs.com/codeon/p/6123863.html給了我一些思路和啟發。

先來介紹兩個模糊不清，容易搞混的概念。

• Base64編碼，看名字就可以知道這是一種編碼方式，編碼方式有很多ASCII、Unicode、UTF-8等，Base64編碼會把3字節的二進制數據編碼為4字節的文本數據，長度增加為原來的4/3。一定要強調一下Base64不是安全領域下的加密解密算法，雖然有時候經常看到有些博客上和變換工具上講base64加密解密。其實base64只能算是一個編碼算法，對數據內容進行編碼來適合傳輸。雖然base64編碼過后原文也變成不能看到的字符格式，但是這種方式很初級，很簡單。具體了解各個編碼的場景可以參照這篇博客，https://blog.csdn.net/charleslei/article/details/50993861。
• MD5摘要算法，這是一種散列函數，提取數據的特征，輸出是不可逆的散列值，用於代表某信息A而又不暴露信息A的內容,一般用於數字簽名場景中。

加密方式的確定：最后我的接口中的敏感明文信息通過AES進行加密，最后將密文返回給客戶端。

網上的一些AES加解密示例中，很多在AES解密步驟時會出現javax.crypto.BadPaddingException: Given final block not properly padded問題，而且很多答案都說的似是而非，經過我的調試和修正后，以下代碼可以正常的完成AES/DES的加解密操作。

 

package com.test.utils;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

/**
 * @Author: LeeChao
 * @Date: 2018/7/5
 * @Describe: 加密工具類
 * @Modified By:
 */
public class EncryptUtil {

    public static final Logger LOGGER = LogManager.getLogger(EncryptUtil.class);

    // 此處使用AES-128-CBC加密模式，key需要為16位。
    private static final String AES_ENCRYPT_MODE = "AES/CBC/PKCS5Padding";

    // 16固定的偏移向量
    private static final String IV_PARAMETER = "1234567890abcdef";

    private final static String DES_ENCRYPT_MODE = "DES";

    /**
     * AES加密
     *
     * @param aesKey  加密用的Key 可以用26個字母和數字組成,
     * @param content
     * @return
     * @throws Exception
     */
    public static String aesEncrypt(String aesKey, String content) {
        // 初始化返回結果
        String result = null;
        try {
            Cipher cipher = Cipher.getInstance(AES_ENCRYPT_MODE);
            byte[] raw = aesKey.getBytes();
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            // 使用CBC模式，需要一個向量iv，可增加加密算法的強度
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes());
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);
            byte[] encrypted = cipher.doFinal(content.getBytes("utf-8"));
            // 此處使用BASE64做轉碼。
            result = new BASE64Encoder().encode(encrypted);
            // Base64加密后的換行符去掉
            result = result.replaceAll("\\r\\n", "").replaceAll("\r", "").replaceAll("\n", "");
        } catch (Exception e) {
            LOGGER.error("AES加密異常" + e);
        }
        return result;
    }

    /**
     * AES解密
     *
     * @param aesKey
     * @param content
     * @return
     * @throws Exception
     */
    public static String aesDecrypt(String aesKey, String content) {
        // 初始化返回結果
        String result = null;
        try {
            byte[] raw = aesKey.getBytes("ASCII");
            SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
            Cipher cipher = Cipher.getInstance(AES_ENCRYPT_MODE);
            IvParameterSpec iv = new IvParameterSpec(IV_PARAMETER.getBytes());
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);
            byte[] encrypted1 = new BASE64Decoder().decodeBuffer(content);//先用base64解密
            byte[] original = cipher.doFinal(encrypted1);
            result = new String(original, "utf-8");
        } catch (Exception e) {
            LOGGER.error("AES解密異常" + e);
        }
        return result;
    }

    /**
     * MD5散列為16位定長輸出
     *
     * @param sourceStr
     * @return
     */
    public static String MD5(String sourceStr) {
        String result16 = "";
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(sourceStr.getBytes());
            byte b[] = md.digest();
            int i;
            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; offset++) {
                i = b[offset];
                if (i < 0)
                    i += 256;
                if (i < 16)
                    buf.append("0");
                buf.append(Integer.toHexString(i));
            }
            // 32位截取為16位
            result16 = buf.toString().substring(8, 24);
        } catch (NoSuchAlgorithmException e) {
            LOGGER.error(e);
        }
        return result16;
    }

    /********************DES加密方式***********************/
    public static byte[] desEncrypt(byte[] src, byte[] key) throws Exception {
        // DES算法要求有一個可信任的隨機數源
        SecureRandom sr = new SecureRandom();
        // 從原始密匙數據創建DESKeySpec對象
        DESKeySpec dks = new DESKeySpec(key);
        // 創建一個密匙工廠，然后用它把DESKeySpec轉換成一個SecretKey對象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ENCRYPT_MODE);
        SecretKey securekey = keyFactory.generateSecret(dks);
        // Cipher對象實際完成加密操作
        Cipher cipher = Cipher.getInstance(DES_ENCRYPT_MODE);
        // 用密匙初始化Cipher對象
        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);
        // 正式執行加密操作
        return cipher.doFinal(src);
    }

    /**
     * @param password 密碼
     * @param key      加密字符串
     * @return
     */
    public final static String desEncrypt(String password, String key) {
        try {
            return byte2String(desEncrypt(password.getBytes(), key.getBytes()));
        } catch (Exception e) {
        }
        return null;
    }

    public static String byte2String(byte[] b) {
        String hs = "";
        String stmp = "";
        for (int n = 0; n < b.length; n++) {
            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
            if (stmp.length() == 1)
                hs = hs + "0" + stmp;
            else
                hs = hs + stmp;
        }
        return hs.toUpperCase();
    }

    /**
     * @param src 數據源
     * @param key 密鑰，長度必須是8的倍數
     * @return
     * @throws Exception
     */
    public static byte[] desDecrypt(byte[] src, byte[] key) throws Exception {
        // DES算法要求有一個可信任的隨機數源
        SecureRandom sr = new SecureRandom();
        // 從原始密匙數據創建一個DESKeySpec對象
        DESKeySpec dks = new DESKeySpec(key);
        // 創建一個密匙工廠，然后用它把DESKeySpec對象轉換成一個SecretKey對象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES_ENCRYPT_MODE);
        SecretKey securekey = keyFactory.generateSecret(dks);
        // Cipher對象實際完成解密操作
        Cipher cipher = Cipher.getInstance(DES_ENCRYPT_MODE);
        // 用密匙初始化Cipher對象
        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);

        // 正式執行解密操作
        return cipher.doFinal(src);
    }

    public final static String desDecrypt(String data, String key) {
        try {
            return new String(desDecrypt(String2byte(data.getBytes()), key.getBytes()));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public static byte[] String2byte(byte[] b) {
        if ((b.length % 2) != 0)
            throw new IllegalArgumentException("長度不是偶數");
        byte[] b2 = new byte[b.length / 2];
        for (int n = 0; n < b.length; n += 2) {
            String item = new String(b, n, 2);
            b2[n / 2] = (byte) Integer.parseInt(item, 16);
        }
        return b2;
    }

    private static String testDecryptAES(String authCode, String cipherText) {
        System.out.println("=====================AES解密=====================");
        String key = MD5(authCode);
        // md5散列出16位固定長度的秘鑰
        System.out.println("md5-16 :" + key);
        long encryptTime = System.currentTimeMillis();
        String deString = aesDecrypt(key, cipherText);
        long endTime = System.currentTimeMillis();
        System.out.println("解密耗時：" + (endTime - encryptTime) + "毫秒");
        System.out.println("解密后的字串是：" + deString);
        return deString;
    }

    public static void main(String[] args) throws Exception {

        System.out.println("=====================AES加密=====================");
        String key = MD5("8373964002824192");
        // md5散列出16位固定長度的秘鑰
        System.out.println("md5-16 :" + key);
        // 需要加密的字串
        String cSrc = "TestAESEncrypt";
        // 加密
        long lStart = System.currentTimeMillis();
        String enString = aesEncrypt(key, cSrc);
        System.out.println("加密后的字串是：" + enString);

        long lUseTime = System.currentTimeMillis() - lStart;
        System.out.println("加密耗時：" + lUseTime + "毫秒");
        // 解密
        lStart = System.currentTimeMillis();
        String DeString = aesDecrypt(key, enString);
        System.out.println("解密后的字串是：" + DeString);
        lUseTime = System.currentTimeMillis() - lStart;
        System.out.println("解密耗時：" + lUseTime + "毫秒");

        System.out.println("=====================DES加密=====================");
        String password = "test中英文雜七爛八混搭@123654{";
        String info = "TestDESEncrypt";
        long desStart = System.currentTimeMillis();
        String encryptString = desEncrypt(info, password);
        System.out.println("DES加密后的字符串" + encryptString);
        System.out.println("DES加密耗時" + (System.currentTimeMillis() - desStart) + "毫秒");

        desStart = System.currentTimeMillis();
        String desencryptString = desDecrypt(encryptString, password);
        System.out.println("DES解密后的字符串" + desencryptString);
        System.out.println("DES解密耗時" + (System.currentTimeMillis() - desStart) + "毫秒");
    }
}

代碼執行后的輸出：