【利用 Commons Codec 实现 MD5、RSA、AES 加密】

---

一、MD5 加密算法

1. 什么是 MD5？

MD5（Message Digest Algorithm 5）是一种广泛利用的哈希函数，由 Ronald Rivest 在 1991 年计划。它的主要用途是将恣意长度的输入数据（称为消息）转换为固定长度的散列值（称为消息摘要）。MD5 生成的摘要长度为 128 位，即 16 字节。由于其生成的散列值长度固定，即使输入数据发生微小变化，输出也会明显变化，这使得 MD5 适用于数据完备性校验，如文件校验和、密码加密（虽然不推荐用于密码存储）等。
MD5 的主要特点包括：

• 固定输出长度：无论输入数据大小怎样，输出的摘要长度都是 128 位。
  
• 不可逆性：从散列值不能反推出原始数据。
  
• 强抗碰撞性：理论上不应出现差异的输入生成雷同的散列值（然而实际中已被破解）。
  

2. 利用 Commons Codec 实现 MD5

1. import org.apache.commons.codec.digest.DigestUtils;
3. import java.io.UnsupportedEncodingException;
5. /**
6. * MD5加密工具类
7. * MD5，全称为“Message-Digest Algorithm 5”，中文名“消息摘要算法5”，是一种单向加密算法。
8. * 加密特点：1.不可逆；2.不可还原；3.相同内容加密后的结果相同；4.不同内容加密后的结果不同。
9. * 应用场景：1.密码加密；2.文件完整性校验；3.数字签名。
10. * 步骤：1.初始化MD5；2.更新MD5；3.计算MD5；4.输出MD5。
11. * 优点：1.压缩性；2.容易计算；3.抗修改性；4.强抗碰撞。
12. * 缺点：1.不可逆；2.碰撞攻击。
13. * 安全性：1.碰撞攻击；2.彩虹表攻击。
14. */
15. public abstract class MD5Util {
16.         /**
17.          * 对content进行MD5加密
18.          * @param content  需要加密的内容
19.          * @param salt   盐值
20.          * @param charset  字符编码
21.          * @return  加密后的内容
22.          */
23.         public static String sign(String content, String salt, String charset) {
24.                 content = content + salt;
25.                 return DigestUtils.md5Hex(getContentBytes(content, charset));  // 使用MD5加密算法对content进行加密
26.         }
28.         /**
29.          * 验证签名
30.          * @param content  需要加密的内容
31.          * @param sign  签名
32.          * @param salt  盐值
33.          * @param charset  字符编码
34.          * @return  是否验证通过
35.          */
36.         public static boolean verify(String content, String sign, String salt, String charset) {
37.                 content = content + salt;
38.                 String mySign = DigestUtils.md5Hex(getContentBytes(content, charset));  // 使用MD5加密算法对content进行加密
39.                 return mySign.equals(sign);  // 判断mySign和sign是否相等
40.         }
42.         /**
43.          * 将content转换为字节数组
44.          * @param content  需要转换的内容
45.          * @param charset  字符编码
46.          * @return  字节数组
47.          */
48.         private static byte[] getContentBytes(String content, String charset) {
49.                 if (charset == null || "".equals(charset)) {
50.                         return content.getBytes();
51.                 }
52.                 try {
53.                         return content.getBytes(charset);
54.                 } catch (UnsupportedEncodingException e) {
55.                         throw new RuntimeException("MD5签名过程中出现错误，指定的编码集不对，您目前指定的编码集是：" + charset);
56.                 }
57.         }
59.         public static void main(String[] args) {
60.                 String content = "123456";  // 需要加密的内容
61.                 String salt = "abc";  // 盐值
62.                 String charset = "utf-8";  // 字符编码
63.                 String sign = sign(content, salt, charset);  // 对content进行MD5加密,并返回加密后的内容
64.                 System.out.println("加密后的内容: " + sign);  // 输出加密后的内容
65.                 boolean verify = verify(content, sign, salt, charset);  // 验证签名
66.                 System.out.println("验证签名: " + verify);  // 输出验证签名
67.         }
68. }

复制代码

3. 注意事项

MD5 算法不适用于安全性要求高的场景，由于其存在碰撞漏洞和被暴力破解的风险。

---

二、RSA 加密算法

1. 什么是 RSA？

RSA 是一种非对称加密算法，由 Ron Rivest、Adi Shamir 和 Leonard Adleman 于 1977 年提出。RSA 算法基于大整数因数分解的数学困难，其安全性依赖于大数分解的困难性。与对称加密差异，RSA 利用一对密钥：公钥和私钥。公钥用于加密数据，私钥用于解密数据。RSA 可以用于加密和数字签名，其广泛应用于 SSL/TLS 协议、电子邮件加密和数字签名等领域。
RSA 的主要特点包括：

• 非对称性：加密和解密利用差异的密钥，公钥公开，私钥保密。
  
• 数据加密和签名：可以用于加密数据和生成数字签名。
  
• 安全性：基于大数分解题目的困难性，现在没有有用的快速分解大数的方法。
  

尽管 RSA 安全性较高，但其加密速率较慢，不得当加密大数据量。在实际应用中，通常结合对称加密算法，如 AES，来加密数据内容，而 RSA 用于加密对称密钥。
2. 利用 Commons Codec 实现 RSA

1. import org.apache.commons.codec.binary.Base64;
3. import javax.crypto.Cipher;
4. import java.io.ByteArrayOutputStream;
5. import java.security.*;
6. import java.security.spec.PKCS8EncodedKeySpec;
7. import java.security.spec.X509EncodedKeySpec;
10. /**
11. * RSA加密解密工具类
12. * RSA，全称为“Rivest-Shamir-Adleman”，中文名“RSA算法”，是一种非对称加密算法。
13. * RSA加密解密的过程中，密钥长度越长，加密强度越大，但是加密解密速度越慢。
14. * 加密特点：1.公钥加密，私钥解密；2.私钥签名，公钥验签；3.加密解密速度慢；4.适合对少量数据进行加密解密。
15. * 应用场景：1.数字签名；2.加密解密；3.密钥协商。
16. * 步骤：1.生成密钥对；2.加密；3.解密；4.签名；5.验签。
17. * 优点：1.安全性高；2.密钥管理方便。
18. * 缺点：1.加密解密速度慢；2.适合对少量数据进行加密解密。
19. * 安全性：1.公钥加密，私钥解密；2.私钥签名，公钥验签。
20. */
21. public class RSAUtil {
22.     /**
23.      * RSA最大加密明文大小
24.      */
25.     private static final int MAX_ENCRYPT_BLOCK = 117;
27.     /**
28.      * RSA最大解密密文大小
29.      */
30.     private static final int MAX_DECRYPT_BLOCK = 128;
32.     /**
33.      * 获取密钥对
34.      * @return 密钥对
35.      */
36.     public static KeyPair getKeyPair() throws Exception {
37.         // 获取密钥对生成器，指定算法为RSA
38.         KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
39.         // 设置密钥长度为1024位
40.         generator.initialize(1024);
41.         return generator.generateKeyPair();  // 生成密钥对
42.     }
44.     /**
45.      * 获取私钥
46.      * @param privateKey 私钥字符串
47.      * @return 私钥
48.      */
49.     public static PrivateKey getPrivateKey(String privateKey) throws Exception {
50.         // 获取密钥工厂，指定算法为RSA
51.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
52.         // 使用base64解码私钥字符串
53.         byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
54.         // 获取私钥对象
55.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
56.         return keyFactory.generatePrivate(keySpec); // 生成私钥
57.     }
59.     /**
60.      * 获取公钥
61.      * @param publicKey 公钥字符串
62.      * @return 公钥
63.      */
64.     public static PublicKey getPublicKey(String publicKey) throws Exception {
65.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
66.         byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
67.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
68.         return keyFactory.generatePublic(keySpec);
69.     }
71.     /**
72.      * RSA加密
73.      * @param data      待加密数据
74.      * @param publicKey 公钥
75.      * @return 加密后的数据
76.      */
77.     public static String encrypt(String data, PublicKey publicKey) throws Exception {
78.         Cipher cipher = Cipher.getInstance("RSA");
79.         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
80.         int inputLen = data.getBytes().length;
81.         ByteArrayOutputStream out = new ByteArrayOutputStream();
82.         int offset = 0;
83.         byte[] cache;
84.         int i = 0;
85.         // 对数据分段加密
86.         while (inputLen - offset > 0) {
87.             if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
88.                 cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
89.             } else {
90.                 cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
91.             }
92.             out.write(cache, 0, cache.length);
93.             i++;
94.             offset = i * MAX_ENCRYPT_BLOCK;
95.         }
96.         byte[] encryptedData = out.toByteArray();
97.         out.close();
98.         // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
99.         // 加密后的字符串
100.         return new String(Base64.encodeBase64String(encryptedData));
101.     }
103.     /**
104.      * RSA解密
105.      * @param data       待解密数据
106.      * @param privateKey 私钥
107.      * @return 解密后的数据
108.      */
109.     public static String decrypt(String data, PrivateKey privateKey) throws Exception {
110.         Cipher cipher = Cipher.getInstance("RSA");
111.         cipher.init(Cipher.DECRYPT_MODE, privateKey);
112.         byte[] dataBytes = Base64.decodeBase64(data);
113.         int inputLen = dataBytes.length;
114.         ByteArrayOutputStream out = new ByteArrayOutputStream();
115.         int offset = 0;
116.         byte[] cache;
117.         int i = 0;
118.         // 对数据分段解密
119.         while (inputLen - offset > 0) {
120.             if (inputLen - offset > MAX_DECRYPT_BLOCK) {
121.                 cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
122.             } else {
123.                 cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
124.             }
125.             out.write(cache, 0, cache.length);
126.             i++;
127.             offset = i * MAX_DECRYPT_BLOCK;
128.         }
129.         byte[] decryptedData = out.toByteArray();
130.         out.close();
131.         // 解密后的内容
132.         return new String(decryptedData, "UTF-8");
133.     }
135.     /**
136.      * 签名
137.      * @param data       待签名数据
138.      * @param privateKey 私钥
139.      * @return 签名
140.      */
141.     public static String sign(String data, PrivateKey privateKey) throws Exception {
142.         byte[] keyBytes = privateKey.getEncoded();
143.         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
144.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
145.         PrivateKey key = keyFactory.generatePrivate(keySpec);
146.         Signature signature = Signature.getInstance("MD5withRSA");
147.         signature.initSign(key);
148.         signature.update(data.getBytes());
149.         return new String(Base64.encodeBase64(signature.sign()));
150.     }
152.     /**
153.      * 验签
154.      * @param srcData   原始字符串
155.      * @param publicKey 公钥
156.      * @param sign      签名
157.      * @return 是否验签通过
158.      */
159.     public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
160.         byte[] keyBytes = publicKey.getEncoded();
161.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
162.         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
163.         PublicKey key = keyFactory.generatePublic(keySpec);
164.         Signature signature = Signature.getInstance("MD5withRSA");
165.         signature.initVerify(key);
166.         signature.update(srcData.getBytes());
167.         return signature.verify(Base64.decodeBase64(sign.getBytes()));
168.     }
170.     public static void main(String[] args) {
171.         try {
172.             // 生成密钥对，其中的公钥私钥是唯一对应的
173.             KeyPair keyPair = getKeyPair();
174.             String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
175.             String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
176.             System.out.println("私钥:" + privateKey);
177.             System.out.println("公钥:" + publicKey);
178.             // RSA加密
179.             String data = "test";
180.             String encryptData = encrypt(data, getPublicKey(publicKey));
181.             System.out.println("加密后内容:" + encryptData);
182.             // RSA解密
183.             String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
184.             System.out.println("解密后内容:" + decryptData);
185.             // RSA签名
186.             String sign = sign(data, getPrivateKey(privateKey));
187.             // RSA验签
188.             boolean result = verify(data, getPublicKey(publicKey), sign);
189.             System.out.print("验签结果:" + result);
190.         } catch (Exception e) {
191.             e.printStackTrace();
192.             System.out.print("加解密异常");
193.         }
194.     }
195. }

复制代码

3. 注意事项

RSA 加密算法适用于安全性要求高的场景，但运算速率较慢，得当加密较小数据量。

---

三、AES 加密算法

1. 什么是 AES？

AES（Advanced Encryption Standard）是美国国家尺度与技术研究院（NIST）于 2001 年发布的对称加密算法尺度，由比利时密码学家 Joan Daemen 和 Vincent Rijmen 计划。AES 是替换原有 DES（Data Encryption Standard）的新尺度，旨在提供更强的安全性和更高的效率。AES 支持多种密钥长度，包括 128 位、192 位和 256 位，密钥长度越长，安全性越高。
AES 的主要特点包括：

• 对称加密：利用雷同的密钥举行加密和解密。
  
• 块加密算法：AES 处理固定大小（128 位）的数据块。
  
• 高安全性和效率：AES 被广泛认为是现在最安全和高效的对称加密算法之一，得当用于保护大数据量的传输。
  

AES 在很多领域得到广泛应用，包括 SSL/TLS 协议、无线安全（如 WPA2）、文件加密、虚拟专用网络（VPN）等。其高效的加密和解密性能使其成为现代数据安全的首选方案。
2. 利用 Commons Codec 实现 AES

1. import javax.crypto.Cipher;
2. import javax.crypto.KeyGenerator;
3. import javax.crypto.SecretKey;
4. import javax.crypto.spec.SecretKeySpec;
5. import java.security.NoSuchAlgorithmException;
6. import java.security.SecureRandom;
8. /**
9. * AES加密解密工具类
10. * AES，全称为“Advanced Encryption Standard”，中文名“高级加密标准”，是一种对称加密算法。
11. * AES加密解密的过程中，密钥长度越长，加密强度越大，但是加密解密速度越慢。
12. * 加密特点：1.密钥长度可变；2.加密解密速度快；3.适合对大量数据进行加密解密。
13. * 应用场景：1.文件加密；2.数据传输加密；3.数据库加密。
14. * 步骤：1.生成密钥；2.加密；3.解密。
15. * 优点：1.加密解密速度快；2.适合对大量数据进行加密解密。
16. * 缺点：1.密钥管理不方便；2.适合对大量数据进行加密解密。
17. * 安全性：1.密钥长度可变；2.加密解密速度快。
18. */
19. public class AESUtil {
21.     private static final String KEY_AES = "AES";  // 算法
23.     private static final int KEY_SIZE = 128;  // 密钥长度（位）
25.     /**
26.      * 生成随机AES密钥
27.      *
28.      * @return 随机生成的AES密钥
29.      * @throws NoSuchAlgorithmException
30.      */
31.     public static String generateRandomKey() throws NoSuchAlgorithmException {
32.         KeyGenerator keyGen = KeyGenerator.getInstance(KEY_AES);
33.         keyGen.init(KEY_SIZE, new SecureRandom()); // AES密钥长度
34.         SecretKey secretKey = keyGen.generateKey();
35.         return byte2hex(secretKey.getEncoded());
36.     }
38.     /**
39.      * 加密
40.      *
41.      * @param src    需要加密的内容
42.      * @param keyHex 十六进制表示的加密密钥
43.      * @return 加密后的内容
44.      * @throws Exception
45.      */
46.     public static String encrypt(String src, String keyHex) throws Exception {
47.         if (isValidKey(keyHex)) {
48.             throw new Exception("key不满足条件");
49.         }
50.         byte[] raw = hex2byte(keyHex);
51.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
52.         Cipher cipher = Cipher.getInstance(KEY_AES);
53.         cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
54.         byte[] encrypted = cipher.doFinal(src.getBytes());
55.         return byte2hex(encrypted);
56.     }
58.     /**
59.      * 解密
60.      *
61.      * @param src    需要解密的内容
62.      * @param keyHex 十六进制表示的解密密钥
63.      * @return 解密后的内容
64.      * @throws Exception
65.      */
66.     public static String decrypt(String src, String keyHex) throws Exception {
67.         if (isValidKey(keyHex)) {
68.             throw new Exception("key不满足条件");
69.         }
70.         byte[] raw = hex2byte(keyHex);
71.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY_AES);
72.         Cipher cipher = Cipher.getInstance(KEY_AES);
73.         cipher.init(Cipher.DECRYPT_MODE, skeySpec);
74.         byte[] encrypted1 = hex2byte(src);
75.         byte[] original = cipher.doFinal(encrypted1);
76.         return new String(original);
77.     }
79.     /**
80.      * 验证密钥是否有效
81.      *
82.      * @param keyHex 十六进制表示的密钥
83.      * @return 是否有效
84.      */
85.     private static boolean isValidKey(String keyHex) {
86.         return keyHex == null || keyHex.length() != (KEY_SIZE / 4);
87.     }
89.     /**
90.      * 将16进制转换为二进制
91.      *
92.      * @param strhex 16进制字符串
93.      * @return 二进制字节数组
94.      */
95.     public static byte[] hex2byte(String strhex) {
96.         if (strhex == null) {
97.             return null;
98.         }
99.         int l = strhex.length();
100.         if (l % 2 == 1) {
101.             return null;
102.         }
103.         byte[] b = new byte[l / 2];
104.         for (int i = 0; i != l / 2; i++) {
105.             b[i] = (byte) Integer.parseInt(strhex.substring(i * 2, i * 2 + 2), 16);
106.         }
107.         return b;
108.     }
110.     /**
111.      * 将二进制转换为16进制
112.      *
113.      * @param b 二进制字节数组
114.      * @return 16进制字符串
115.      */
116.     public static String byte2hex(byte[] b) {
117.         StringBuilder hs = new StringBuilder();
118.         String stmp;
119.         for (byte value : b) {
120.             stmp = Integer.toHexString(value & 0XFF);
121.             if (stmp.length() == 1) {
122.                 hs.append("0").append(stmp);
123.             } else {
124.                 hs.append(stmp);
125.             }
126.         }
127.         return hs.toString().toUpperCase();
128.     }
130.     public static void main(String[] args) {
131.         try {
132.             // 生成随机密钥
133.             String randomKey = generateRandomKey();
134.             System.out.println("随机生成的密钥：" + randomKey);
136.             String[] dataArr = {"hello", "hello world", "12345678901234567890"};
138.             for (String data : dataArr) {
139.                 System.out.println("加密前：" + data);
140.                 // 加密
141.                 String encrypt = encrypt(data, randomKey);
142.                 System.out.println("加密后：" + encrypt + " 长度：" + encrypt.length());
143.                 // 解密
144.                 String decrypt = decrypt(encrypt, randomKey);
145.                 System.out.println("解密后：" + decrypt);
146.                 System.out.println();
147.             }
148.         } catch (Exception e) {
149.             e.printStackTrace();
150.         }
151.     }
152. }

复制代码

3. 注意事项

AES 加密算法适用于对称加密场景，速率快，得当加密大数据量。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。