【利用 Commons Codec 实现 MD5、RSA、AES 加密】 - ToB企服应用市场:ToB评测及商务社交产业平台

import org.apache.commons.codec.digest.DigestUtils;
import java.io.UnsupportedEncodingException;
/**
* MD5加密工具类
* MD5，全称为“Message-Digest Algorithm 5”，中文名“消息摘要算法5”，是一种单向加密算法。
* 加密特点：1.不可逆；2.不可还原；3.相同内容加密后的结果相同；4.不同内容加密后的结果不同。
* 应用场景：1.密码加密；2.文件完整性校验；3.数字签名。
* 步骤：1.初始化MD5；2.更新MD5；3.计算MD5；4.输出MD5。
* 优点：1.压缩性；2.容易计算；3.抗修改性；4.强抗碰撞。
* 缺点：1.不可逆；2.碰撞攻击。
* 安全性：1.碰撞攻击；2.彩虹表攻击。
*/
public abstract class MD5Util {
/**
* 对content进行MD5加密
* @param content 需要加密的内容
* @param salt 盐值
* @param charset 字符编码
* @return 加密后的内容
*/
public static String sign(String content, String salt, String charset) {
content = content + salt;
return DigestUtils.md5Hex(getContentBytes(content, charset)); // 使用MD5加密算法对content进行加密
}
/**
* 验证签名
* @param content 需要加密的内容
* @param sign 签名
* @param salt 盐值
* @param charset 字符编码
* @return 是否验证通过
*/
public static boolean verify(String content, String sign, String salt, String charset) {
content = content + salt;
String mySign = DigestUtils.md5Hex(getContentBytes(content, charset)); // 使用MD5加密算法对content进行加密
return mySign.equals(sign); // 判断mySign和sign是否相等
}
/**
* 将content转换为字节数组
* @param content 需要转换的内容
* @param charset 字符编码
* @return 字节数组
*/
private static byte[] getContentBytes(String content, String charset) {
if (charset == null || "".equals(charset)) {
return content.getBytes();
}
try {
return content.getBytes(charset);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("MD5签名过程中出现错误，指定的编码集不对，您目前指定的编码集是：" + charset);
}
}
public static void main(String[] args) {
String content = "123456"; // 需要加密的内容
String salt = "abc"; // 盐值
String charset = "utf-8"; // 字符编码
String sign = sign(content, salt, charset); // 对content进行MD5加密,并返回加密后的内容
System.out.println("加密后的内容: " + sign); // 输出加密后的内容
boolean verify = verify(content, sign, salt, charset); // 验证签名
System.out.println("验证签名: " + verify); // 输出验证签名
}
}

复制代码

import org.apache.commons.codec.binary.Base64;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
/**
* RSA加密解密工具类
* RSA，全称为“Rivest-Shamir-Adleman”，中文名“RSA算法”，是一种非对称加密算法。
* RSA加密解密的过程中，密钥长度越长，加密强度越大，但是加密解密速度越慢。
* 加密特点：1.公钥加密，私钥解密；2.私钥签名，公钥验签；3.加密解密速度慢；4.适合对少量数据进行加密解密。
* 应用场景：1.数字签名；2.加密解密；3.密钥协商。
* 步骤：1.生成密钥对；2.加密；3.解密；4.签名；5.验签。
* 优点：1.安全性高；2.密钥管理方便。
* 缺点：1.加密解密速度慢；2.适合对少量数据进行加密解密。
* 安全性：1.公钥加密，私钥解密；2.私钥签名，公钥验签。
*/
public class RSAUtil {
/**
* RSA最大加密明文大小
*/
private static final int MAX_ENCRYPT_BLOCK = 117;
/**
* RSA最大解密密文大小
*/
private static final int MAX_DECRYPT_BLOCK = 128;
/**
* 获取密钥对
* @return 密钥对
*/
public static KeyPair getKeyPair() throws Exception {
// 获取密钥对生成器，指定算法为RSA
KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
// 设置密钥长度为1024位
generator.initialize(1024);
return generator.generateKeyPair(); // 生成密钥对
}
/**
* 获取私钥
* @param privateKey 私钥字符串
* @return 私钥
*/
public static PrivateKey getPrivateKey(String privateKey) throws Exception {
// 获取密钥工厂，指定算法为RSA
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
// 使用base64解码私钥字符串
byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
// 获取私钥对象
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
return keyFactory.generatePrivate(keySpec); // 生成私钥
}
/**
* 获取公钥
* @param publicKey 公钥字符串
* @return 公钥
*/
public static PublicKey getPublicKey(String publicKey) throws Exception {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
return keyFactory.generatePublic(keySpec);
}
/**
* RSA加密
* @param data 待加密数据
* @param publicKey 公钥
* @return 加密后的数据
*/
public static String encrypt(String data, PublicKey publicKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
int inputLen = data.getBytes().length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offset = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offset > 0) {
if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
}
out.write(cache, 0, cache.length);
i++;
offset = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
// 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
// 加密后的字符串
return new String(Base64.encodeBase64String(encryptedData));
}
/**
* RSA解密
* @param data 待解密数据
* @param privateKey 私钥
* @return 解密后的数据
*/
public static String decrypt(String data, PrivateKey privateKey) throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] dataBytes = Base64.decodeBase64(data);
int inputLen = dataBytes.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offset = 0;
byte[] cache;
int i = 0;
// 对数据分段解密
while (inputLen - offset > 0) {
if (inputLen - offset > MAX_DECRYPT_BLOCK) {
cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
} else {
cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
}
out.write(cache, 0, cache.length);
i++;
offset = i * MAX_DECRYPT_BLOCK;
}
byte[] decryptedData = out.toByteArray();
out.close();
// 解密后的内容
return new String(decryptedData, "UTF-8");
}
/**
* 签名
* @param data 待签名数据
* @param privateKey 私钥
* @return 签名
*/
public static String sign(String data, PrivateKey privateKey) throws Exception {
byte[] keyBytes = privateKey.getEncoded();
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey key = keyFactory.generatePrivate(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(key);
signature.update(data.getBytes());
return new String(Base64.encodeBase64(signature.sign()));
}
/**
* 验签
* @param srcData 原始字符串
* @param publicKey 公钥
* @param sign 签名
* @return 是否验签通过
*/
public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
byte[] keyBytes = publicKey.getEncoded();
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey key = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initVerify(key);
signature.update(srcData.getBytes());
return signature.verify(Base64.decodeBase64(sign.getBytes()));
}
public static void main(String[] args) {
try {
// 生成密钥对，其中的公钥私钥是唯一对应的
KeyPair keyPair = getKeyPair();
String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
System.out.println("私钥:" + privateKey);
System.out.println("公钥:" + publicKey);
// RSA加密
String data = "test";
String encryptData = encrypt(data, getPublicKey(publicKey));
System.out.println("加密后内容:" + encryptData);
// RSA解密
String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
System.out.println("解密后内容:" + decryptData);
// RSA签名
String sign = sign(data, getPrivateKey(privateKey));
// RSA验签
boolean result = verify(data, getPublicKey(publicKey), sign);
System.out.print("验签结果:" + result);
} catch (Exception e) {
e.printStackTrace();
System.out.print("加解密异常");
}
}
}

复制代码

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
/**
* AES加密解密工具类
* AES，全称为“Advanced Encryption Standard”，中文名“高级加密标准”，是一种对称加密算法。
* AES加密解密的过程中，密钥长度越长，加密强度越大，但是加密解密速度越慢。
* 加密特点：1.密钥长度可变；2.加密解密速度快；3.适合对大量数据进行加密解密。
* 应用场景：1.文件加密；2.数据传输加密；3.数据库加密。
* 步骤：1.生成密钥；2.加密；3.解密。
* 优点：1.加密解密速度快；2.适合对大量数据进行加密解密。
* 缺点：1.密钥管理不方便；2.适合对大量数据进行加密解密。
* 安全性：1.密钥长度可变；2.加密解密速度快。
*/
public class AESUtil {
private static final String KEY_AES = "AES"; // 算法
private static final int KEY_SIZE = 128; // 密钥长度（位）
/**
* 生成随机AES密钥
*
* @return 随机生成的AES密钥
* @throws NoSuchAlgorithmException
*/
public static String generateRandomKey() throws NoSuchAlgorithmException {
KeyGenerator keyGen = KeyGenerator.getInstance(KEY_AES);
keyGen.init(KEY_SIZE, new SecureRandom()); // AES密钥长度
SecretKey secretKey = keyGen.generateKey();
return byte2hex(secretKey.getEncoded());
}
/**
* 加密
*
* @param src 需要加密的内容
* @param keyHex 十六进制表示的加密密钥
* @return 加密后的内容
* @throws Exception
*/
public static String encrypt(String src, String keyHex) throws Exception {
if (isValidKey(keyHex)) {
throw new Exception("key不满足条件");
}
byte[] raw = hex2byte(keyHex);
SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
Cipher cipher = Cipher.getInstance(KEY_AES);
cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
byte[] encrypted = cipher.doFinal(src.getBytes());
return byte2hex(encrypted);
}
/**
* 解密
*
* @param src 需要解密的内容
* @param keyHex 十六进制表示的解密密钥
* @return 解密后的内容
* @throws Exception
*/
public static String decrypt(String src, String keyHex) throws Exception {
if (isValidKey(keyHex)) {
throw new Exception("key不满足条件");
}
byte[] raw = hex2byte(keyHex);
SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
Cipher cipher = Cipher.getInstance(KEY_AES);
cipher.init(Cipher.DECRYPT_MODE, skeySpec);
byte[] encrypted1 = hex2byte(src);
byte[] original = cipher.doFinal(encrypted1);
return new String(original);
}
/**
* 验证密钥是否有效
*
* @param keyHex 十六进制表示的密钥
* @return 是否有效
*/
private static boolean isValidKey(String keyHex) {
return keyHex == null || keyHex.length() != (KEY_SIZE / 4);
}
/**
* 将16进制转换为二进制
*
* @param strhex 16进制字符串
* @return 二进制字节数组
*/
public static byte[] hex2byte(String strhex) {
if (strhex == null) {
return null;
}
int l = strhex.length();
if (l % 2 == 1) {
return null;
}
byte[] b = new byte[l / 2];
for (int i = 0; i != l / 2; i++) {
b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2), 16);
}
return b;
}
/**
* 将二进制转换为16进制
*
* @param b 二进制字节数组
* @return 16进制字符串
*/
public static String byte2hex(byte[] b) {
StringBuilder hs = new StringBuilder();
String stmp;
for (byte value : b) {
stmp = Integer.toHexString(value & 0XFF);
if (stmp.length() == 1) {
hs.append("0").append(stmp);
} else {
hs.append(stmp);
}
}
return hs.toString().toUpperCase();
}
public static void main(String[] args) {
try {
// 生成随机密钥
String randomKey = generateRandomKey();
System.out.println("随机生成的密钥：" + randomKey);
String[] dataArr = {"hello", "hello world", "12345678901234567890"};
for (String data : dataArr) {
System.out.println("加密前：" + data);
// 加密
String encrypt = encrypt(data, randomKey);
System.out.println("加密后：" + encrypt + " 长度：" + encrypt.length());
// 解密
String decrypt = decrypt(encrypt, randomKey);
System.out.println("解密后：" + decrypt);
System.out.println();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

复制代码