encryptMD2, encryptMD2ToString : MD2加密
encryptMD5, encryptMD5ToString : MD5加密
encryptMD5File, encryptMD5File2String : MD5加密文件
encryptSHA1, encryptSHA1ToString : SHA1加密
encryptSHA224, encryptSHA224ToString : SHA224加密
encryptSHA256, encryptSHA256ToString : SHA256加密
encryptSHA384, encryptSHA384ToString : SHA384加密
encryptSHA512, encryptSHA512ToString : SHA512加密
encryptHmacMD5, encryptHmacMD5ToString : HmacMD5加密
encryptHmacSHA1, encryptHmacSHA1ToString : HmacSHA1加密
encryptHmacSHA224, encryptHmacSHA224ToString : HmacSHA224加密
encryptHmacSHA256, encryptHmacSHA256ToString : HmacSHA256加密
encryptHmacSHA384, encryptHmacSHA384ToString : HmacSHA384加密
encryptHmacSHA512, encryptHmacSHA512ToString : HmacSHA512加密
encryptDES, encryptDES2HexString, encryptDES2Base64 : DES加密
decryptDES, decryptHexStringDES, decryptBase64DES : DES解密
encrypt3DES, encrypt3DES2HexString, encrypt3DES2Base64 : 3DES加密
decrypt3DES, decryptHexString3DES, decryptBase64_3DES : 3DES解密
encryptAES, encryptAES2HexString, encryptAES2Base64 : AES加密
decryptAES, decryptHexStringAES, decryptBase64AES : AES解密
public class EncryptUtils {
private EncryptUtils() {
throw new UnsupportedOperationException("u can't instantiate me...");
}
/*********************** 哈希加密相关 ***********************/
/**
* MD2加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptMD2ToString(String data) {
return encryptMD2ToString(data.getBytes());
}
/**
* MD2加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptMD2ToString(byte[] data) {
return bytes2HexString(encryptMD2(data));
}
/**
* MD2加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD2(byte[] data) {
return hashTemplate(data, "MD2");
}
/**
* MD5加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptMD5ToString(String data) {
return encryptMD5ToString(data.getBytes());
}
/**
* MD5加密
*
* @param data 明文字符串
* @param salt 盐
* @return 16进制加盐密文
*/
public static String encryptMD5ToString(String data, String salt) {
return bytes2HexString(encryptMD5((data + salt).getBytes()));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptMD5ToString(byte[] data) {
return bytes2HexString(encryptMD5(data));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @param salt 盐字节数组
* @return 16进制加盐密文
*/
public static String encryptMD5ToString(byte[] data, byte[] salt) {
if (data == null || salt == null) return null;
byte[] dataSalt = new byte[data.length + salt.length];
System.arraycopy(data, 0, dataSalt, 0, data.length);
System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
return bytes2HexString(encryptMD5(dataSalt));
}
/**
* MD5加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptMD5(byte[] data) {
return hashTemplate(data, "MD5");
}
/**
* MD5加密文件
*
* @param filePath 文件路径
* @return 文件的16进制密文
*/
public static String encryptMD5File2String(String filePath) {
File file = StringUtils.isSpace(filePath) ? null : new File(filePath);
return encryptMD5File2String(file);
}
/**
* MD5加密文件
*
* @param filePath 文件路径
* @return 文件的MD5校验码
*/
public static byte[] encryptMD5File(String filePath) {
File file = StringUtils.isSpace(filePath) ? null : new File(filePath);
return encryptMD5File(file);
}
/**
* MD5加密文件
*
* @param file 文件
* @return 文件的16进制密文
*/
public static String encryptMD5File2String(File file) {
return bytes2HexString(encryptMD5File(file));
}
/**
* MD5加密文件
*
* @param file 文件
* @return 文件的MD5校验码
*/
public static byte[] encryptMD5File(File file) {
if (file == null) return null;
FileInputStream fis = null;
DigestInputStream digestInputStream;
try {
fis = new FileInputStream(file);
MessageDigest md = MessageDigest.getInstance("MD5");
digestInputStream = new DigestInputStream(fis, md);
byte[] buffer = new byte[256 * 1024];
while (digestInputStream.read(buffer) > 0);
md = digestInputStream.getMessageDigest();
return md.digest();
} catch (NoSuchAlgorithmException | IOException e) {
e.printStackTrace();
return null;
} finally {
CloseUtils.closeIO(fis);
}
}
/**
* SHA1加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptSHA1ToString(String data) {
return encryptSHA1ToString(data.getBytes());
}
/**
* SHA1加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptSHA1ToString(byte[] data) {
return bytes2HexString(encryptSHA1(data));
}
/**
* SHA1加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA1(byte[] data) {
return hashTemplate(data, "SHA1");
}
/**
* SHA224加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptSHA224ToString(String data) {
return encryptSHA224ToString(data.getBytes());
}
/**
* SHA224加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptSHA224ToString(byte[] data) {
return bytes2HexString(encryptSHA224(data));
}
/**
* SHA224加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA224(byte[] data) {
return hashTemplate(data, "SHA224");
}
/**
* SHA256加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptSHA256ToString(String data) {
return encryptSHA256ToString(data.getBytes());
}
/**
* SHA256加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptSHA256ToString(byte[] data) {
return bytes2HexString(encryptSHA256(data));
}
/**
* SHA256加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA256(byte[] data) {
return hashTemplate(data, "SHA256");
}
/**
* SHA384加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptSHA384ToString(String data) {
return encryptSHA384ToString(data.getBytes());
}
/**
* SHA384加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptSHA384ToString(byte[] data) {
return bytes2HexString(encryptSHA384(data));
}
/**
* SHA384加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA384(byte[] data) {
return hashTemplate(data, "SHA384");
}
/**
* SHA512加密
*
* @param data 明文字符串
* @return 16进制密文
*/
public static String encryptSHA512ToString(String data) {
return encryptSHA512ToString(data.getBytes());
}
/**
* SHA512加密
*
* @param data 明文字节数组
* @return 16进制密文
*/
public static String encryptSHA512ToString(byte[] data) {
return bytes2HexString(encryptSHA512(data));
}
/**
* SHA512加密
*
* @param data 明文字节数组
* @return 密文字节数组
*/
public static byte[] encryptSHA512(byte[] data) {
return hashTemplate(data, "SHA512");
}
/**
* hash加密模板
*
* @param data 数据
* @param algorithm 加密算法
* @return 密文字节数组
*/
private static byte[] hashTemplate(byte[] data, String algorithm) {
if (data == null || data.length <= 0) return null;
try {
MessageDigest md = MessageDigest.getInstance(algorithm);
md.update(data);
return md.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
/**
* HmacMD5加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacMD5ToString(String data, String key) {
return encryptHmacMD5ToString(data.getBytes(), key.getBytes());
}
/**
* HmacMD5加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacMD5ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacMD5(data, key));
}
/**
* HmacMD5加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacMD5(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacMD5");
}
/**
* HmacSHA1加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA1ToString(String data, String key) {
return encryptHmacSHA1ToString(data.getBytes(), key.getBytes());
}
/**
* HmacSHA1加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA1ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacSHA1(data, key));
}
/**
* HmacSHA1加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacSHA1(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacSHA1");
}
/**
* HmacSHA224加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA224ToString(String data, String key) {
return encryptHmacSHA224ToString(data.getBytes(), key.getBytes());
}
/**
* HmacSHA224加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA224ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacSHA224(data, key));
}
/**
* HmacSHA224加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacSHA224(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacSHA224");
}
/**
* HmacSHA256加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA256ToString(String data, String key) {
return encryptHmacSHA256ToString(data.getBytes(), key.getBytes());
}
/**
* HmacSHA256加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA256ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacSHA256(data, key));
}
/**
* HmacSHA256加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacSHA256(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacSHA256");
}
/**
* HmacSHA384加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA384ToString(String data, String key) {
return encryptHmacSHA384ToString(data.getBytes(), key.getBytes());
}
/**
* HmacSHA384加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA384ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacSHA384(data, key));
}
/**
* HmacSHA384加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacSHA384(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacSHA384");
}
/**
* HmacSHA512加密
*
* @param data 明文字符串
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA512ToString(String data, String key) {
return encryptHmacSHA512ToString(data.getBytes(), key.getBytes());
}
/**
* HmacSHA512加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 16进制密文
*/
public static String encryptHmacSHA512ToString(byte[] data, byte[] key) {
return bytes2HexString(encryptHmacSHA512(data, key));
}
/**
* HmacSHA512加密
*
* @param data 明文字节数组
* @param key 秘钥
* @return 密文字节数组
*/
public static byte[] encryptHmacSHA512(byte[] data, byte[] key) {
return hmacTemplate(data, key, "HmacSHA512");
}
/**
* Hmac加密模板
*
* @param data 数据
* @param key 秘钥
* @param algorithm 加密算法
* @return 密文字节数组
*/
private static byte[] hmacTemplate(byte[] data, byte[] key, String algorithm) {
if (data == null || data.length == 0 || key == null || key.length == 0) return null;
try {
SecretKeySpec secretKey = new SecretKeySpec(key, algorithm);
Mac mac = Mac.getInstance(algorithm);
mac.init(secretKey);
return mac.doFinal(data);
} catch (InvalidKeyException | NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
/************************ DES加密相关 ***********************/
/**
* DES转变
* <p>法算法名称/加密模式/填充方式</p>
* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
*/
public static String DES_Transformation = "DES/ECB/NoPadding";
private static final String DES_Algorithm = "DES";
/**
* DES加密后转为Base64编码
*
* @param data 明文
* @param key 8字节秘钥
* @return Base64密文
*/
public static byte[] encryptDES2Base64(byte[] data, byte[] key) {
return EncodeUtils.base64Encode(encryptDES(data, key));
}
/**
* DES加密后转为16进制
*
* @param data 明文
* @param key 8字节秘钥
* @return 16进制密文
*/
public static String encryptDES2HexString(byte[] data, byte[] key) {
return bytes2HexString(encryptDES(data, key));
}
/**
* DES加密
*
* @param data 明文
* @param key 8字节秘钥
* @return 密文
*/
public static byte[] encryptDES(byte[] data, byte[] key) {
return desTemplate(data, key, DES_Algorithm, DES_Transformation, true);
}
/**
* DES解密Base64编码密文
*
* @param data Base64编码密文
* @param key 8字节秘钥
* @return 明文
*/
public static byte[] decryptBase64DES(byte[] data, byte[] key) {
return decryptDES(EncodeUtils.base64Decode(data), key);
}
/**
* DES解密16进制密文
*
* @param data 16进制密文
* @param key 8字节秘钥
* @return 明文
*/
public static byte[] decryptHexStringDES(String data, byte[] key) {
return decryptDES(hexString2Bytes(data), key);
}
/**
* DES解密
*
* @param data 密文
* @param key 8字节秘钥
* @return 明文
*/
public static byte[] decryptDES(byte[] data, byte[] key) {
return desTemplate(data, key, DES_Algorithm, DES_Transformation, false);
}
/************************ 3DES加密相关 ***********************/
/**
* 3DES转变
* <p>法算法名称/加密模式/填充方式</p>
* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
*/
public static String TripleDES_Transformation = "DESede/ECB/NoPadding";
private static final String TripleDES_Algorithm = "DESede";
/**
* 3DES加密后转为Base64编码
*
* @param data 明文
* @param key 24字节秘钥
* @return Base64密文
*/
public static byte[] encrypt3DES2Base64(byte[] data, byte[] key) {
return EncodeUtils.base64Encode(encrypt3DES(data, key));
}
/**
* 3DES加密后转为16进制
*
* @param data 明文
* @param key 24字节秘钥
* @return 16进制密文
*/
public static String encrypt3DES2HexString(byte[] data, byte[] key) {
return bytes2HexString(encrypt3DES(data, key));
}
/**
* 3DES加密
*
* @param data 明文
* @param key 24字节密钥
* @return 密文
*/
public static byte[] encrypt3DES(byte[] data, byte[] key) {
return desTemplate(data, key, TripleDES_Algorithm, TripleDES_Transformation, true);
}
/**
* 3DES解密Base64编码密文
*
* @param data Base64编码密文
* @param key 24字节秘钥
* @return 明文
*/
public static byte[] decryptBase64_3DES(byte[] data, byte[] key) {
return decrypt3DES(EncodeUtils.base64Decode(data), key);
}
/**
* 3DES解密16进制密文
*
* @param data 16进制密文
* @param key 24字节秘钥
* @return 明文
*/
public static byte[] decryptHexString3DES(String data, byte[] key) {
return decrypt3DES(hexString2Bytes(data), key);
}
/**
* 3DES解密
*
* @param data 密文
* @param key 24字节密钥
* @return 明文
*/
public static byte[] decrypt3DES(byte[] data, byte[] key) {
return desTemplate(data, key, TripleDES_Algorithm, TripleDES_Transformation, false);
}
/************************ AES加密相关 ***********************/
/**
* AES转变
* <p>法算法名称/加密模式/填充方式</p>
* <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
* <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
*/
public static String AES_Transformation = "AES/ECB/NoPadding";
private static final String AES_Algorithm = "AES";
/**
* AES加密后转为Base64编码
*
* @param data 明文
* @param key 16、24、32字节秘钥
* @return Base64密文
*/
public static byte[] encryptAES2Base64(byte[] data, byte[] key) {
return EncodeUtils.base64Encode(encryptAES(data, key));
}
/**
* AES加密后转为16进制
*
* @param data 明文
* @param key 16、24、32字节秘钥
* @return 16进制密文
*/
public static String encryptAES2HexString(byte[] data, byte[] key) {
return bytes2HexString(encryptAES(data, key));
}
/**
* AES加密
*
* @param data 明文
* @param key 16、24、32字节秘钥
* @return 密文
*/
public static byte[] encryptAES(byte[] data, byte[] key) {
return desTemplate(data, key, AES_Algorithm, AES_Transformation, true);
}
/**
* AES解密Base64编码密文
*
* @param data Base64编码密文
* @param key 16、24、32字节秘钥
* @return 明文
*/
public static byte[] decryptBase64AES(byte[] data, byte[] key) {
return decryptAES(EncodeUtils.base64Decode(data), key);
}
/**
* AES解密16进制密文
*
* @param data 16进制密文
* @param key 16、24、32字节秘钥
* @return 明文
*/
public static byte[] decryptHexStringAES(String data, byte[] key) {
return decryptAES(hexString2Bytes(data), key);
}
/**
* AES解密
*
* @param data 密文
* @param key 16、24、32字节秘钥
* @return 明文
*/
public static byte[] decryptAES(byte[] data, byte[] key) {
return desTemplate(data, key, AES_Algorithm, AES_Transformation, false);
}
/**
* DES加密模板
*
* @param data 数据
* @param key 秘钥
* @param algorithm 加密算法
* @param transformation 转变
* @param isEncrypt {@code true}: 加密 {@code false}: 解密
* @return 密文或者明文，适用于DES，3DES，AES
*/
public static byte[] desTemplate(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt) {
if (data == null || data.length == 0 || key == null || key.length == 0) return null;
try {
SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
Cipher cipher = Cipher.getInstance(transformation);
SecureRandom random = new SecureRandom();
cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, keySpec, random);
return cipher.doFinal(data);
} catch (Throwable e) {
e.printStackTrace();
return null;
}
}
}android 加密解密相关
猜你喜欢
转载自blog.csdn.net/dubo_csdn/article/details/86014584
今日推荐
周排行