许久没有写博客了，有些惶恐地打开这个再熟悉不过的编辑器。

场景：要对一个涉及到敏感数据（账号、密码）的接口进行加密后返回

由于之前没有相关的经验，所以先在网上搜罗了一阵，这篇博客不错https://www.geek-share.com/detail/2692675760.html给了我一些思路和启发。

先来介绍两个模糊不清，容易搞混的概念。

• Base64编码，看名字就可以知道这是一种编码方式，编码方式有很多ASCII、Unicode、UTF-8等，Base64编码会把3字节的二进制数据编码为4字节的文本数据，长度增加为原来的4/3。一定要强调一下Base64不是安全领域下的加密解密算法，虽然有时候经常看到有些博客上和变换工具上讲base64加密解密。其实base64只能算是一个编码算法，对数据内容进行编码来适合传输。虽然base64编码过后原文也变成不能看到的字符格式，但是这种方式很初级，很简单。具体了解各个编码的场景可以参照这篇博客，https://www.geek-share.com/detail/2670084204.html。
• 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
 & 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) + "毫秒");
}
}

代码执行后的输出：