java 加密工具类（MD5、RSA、AES等加密方式）

以你之姓@ 2022-05-27 13:10 1001阅读 0赞

1.加密工具类encryption

MD5加密

原文 https://blog.csdn.net/u011659172/article/details/50627903

**\[java\]**  [view plain][]  [copy][view plain]

1.  import org.apache.commons.codec.digest.DigestUtils;  
2.    
3.  /\*\* 
4.   \* MD5加密组件 
5.   \*  
6.   \* @author wbw 
7.   \* @version 1.0 
8.   \* @since 1.0 
9.   \*/  
10. public abstract class MD5Util \{  
11.   
12.     /\*\* 
13.      \* MD5加密 
14.      \*  
15.      \* @param data 
16.      \*            待加密数据 
17.      \* @return byte\[\] 消息摘要 
18.      \*  
19.      \* @throws Exception 
20.      \*/  
21.     public static byte\[\] encodeMD5(String data) throws Exception \{  
22.   
23.         // 执行消息摘要  
24.         return DigestUtils.md5(data);  
25.     \}  
26.   
27.     /\*\* 
28.      \* MD5加密 
29.      \*  
30.      \* @param data 
31.      \*            待加密数据 
32.      \* @return byte\[\] 消息摘要 
33.      \*  
34.      \* @throws Exception 
35.      \*/  
36.     public static String encodeMD5Hex(String data) \{  
37.         // 执行消息摘要  
38.         return DigestUtils.md5Hex(data);  
39.     \}  
40. \}

AES加密:

**\[java\]**  [view plain][]  [copy][view plain]

1. import javax.crypto.Cipher;  
2. import javax.crypto.spec.SecretKeySpec;  
3.   
4. public class AESUtil \{  
5.   
6.     private static final String KEY\_AES = "AES";  
7.   
8.     public static String encrypt(String src, String key) throws Exception \{  
9.         if (key == null || key.length() != 16) \{  
10.             throw new Exception("key不满足条件");  
11.         \}   
12.         byte\[\] raw = key.getBytes();  
13.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY\_AES);  
14.         Cipher cipher = Cipher.getInstance(KEY\_AES);  
15.         cipher.init(Cipher.ENCRYPT\_MODE, skeySpec);  
16.         byte\[\] encrypted = cipher.doFinal(src.getBytes());  
17.         return byte2hex(encrypted);  
18.     \}  
19.   
20.     public static String decrypt(String src, String key) throws Exception \{  
21.         if (key == null || key.length() != 16) \{  
22.             throw new Exception("key不满足条件");  
23.         \}  
24.         byte\[\] raw = key.getBytes();  
25.         SecretKeySpec skeySpec = new SecretKeySpec(raw, KEY\_AES);  
26.         Cipher cipher = Cipher.getInstance(KEY\_AES);  
27.         cipher.init(Cipher.DECRYPT\_MODE, skeySpec);  
28.         byte\[\] encrypted1 = hex2byte(src);  
29.         byte\[\] original = cipher.doFinal(encrypted1);  
30.         String originalString = new String(original);  
31.         return originalString;  
32.     \}  
33.   
34.     public static byte\[\] hex2byte(String strhex) \{  
35.         if (strhex == null) \{  
36.             return null;  
37.         \}  
38.         int l = strhex.length();  
39.         if (l % 2 == 1) \{  
40.             return null;  
41.         \}  
42.         byte\[\] b = new byte\[l / 2\];  
43.         for (int i = 0; i != l / 2; i++) \{  
44.             b\[i\] = (byte) Integer.parseInt(strhex.substring(i \* 2, i \* 2 + 2),  
45.                     16);  
46.         \}  
47.         return b;  
48.     \}  
49.   
50.     public static String byte2hex(byte\[\] b) \{  
51.         String hs = "";  
52.         String stmp = "";  
53.         for (int n = 0; n < b.length; n++) \{  
54.             stmp = (java.lang.Integer.toHexString(b\[n\] & 0XFF));  
55.             if (stmp.length() == 1) \{  
56.                 hs = hs + "0" + stmp;  
57.             \} else \{  
58.                 hs = hs + stmp;  
59.             \}  
60.         \}  
61.         return hs.toUpperCase();  
62.     \}  
63.   
64. \}

Base64加密：

**\[java\]**  [view plain][]  [copy][view plain]

1. import org.apache.commons.codec.binary.Base64;  
2.   
3. /\*\* 
4.  \* Base64组件 
5.  \*  
6.  \* @author wbw 
7.  \* @version 1.0 
8.  \* @since 1.0 
9.  \*/  
10. public abstract class Base64Util \{  
11.   
12.     /\*\* 
13.      \* 字符编码 
14.      \*/  
15.     public final static String ENCODING = "UTF-8";  
16.   
17.     /\*\* 
18.      \* Base64编码 
19.      \*  
20.      \* @param data 待编码数据 
21.      \* @return String 编码数据 
22.      \* @throws Exception 
23.      \*/  
24.     public static String encode(String data) throws Exception \{  
25.   
26.         // 执行编码  
27.         byte\[\] b = Base64.encodeBase64(data.getBytes(ENCODING));  
28.   
29.         return new String(b, ENCODING);  
30.     \}  
31.   
32.     /\*\* 
33.      \* Base64安全编码  
34.      \* 遵循RFC 2045实现 
35.      \*  
36.      \* @param data 
37.      \*            待编码数据 
38.      \* @return String 编码数据 
39.      \*  
40.      \* @throws Exception 
41.      \*/  
42.     public static String encodeSafe(String data) throws Exception \{  
43.   
44.         // 执行编码  
45.         byte\[\] b = Base64.encodeBase64(data.getBytes(ENCODING), true);  
46.   
47.         return new String(b, ENCODING);  
48.     \}  
49.   
50.     /\*\* 
51.      \* Base64解码 
52.      \*  
53.      \* @param data 待解码数据 
54.      \* @return String 解码数据 
55.      \* @throws Exception 
56.      \*/  
57.     public static String decode(String data) throws Exception \{  
58.   
59.         // 执行解码  
60.         byte\[\] b = Base64.decodeBase64(data.getBytes(ENCODING));  
61.   
62.         return new String(b, ENCODING);  
63.     \}  
64.   
65. \}

DES加密：

**\[java\]**  [view plain][]  [copy][view plain]

1. import java.security.Key;  
2. import java.security.SecureRandom;  
3. import java.security.Security;  
4.   
5. import javax.crypto.Cipher;  
6. import javax.crypto.KeyGenerator;  
7. import javax.crypto.SecretKey;  
8. import javax.crypto.SecretKeyFactory;  
9. import javax.crypto.spec.DESKeySpec;  
10.   
11. import org.apache.commons.codec.binary.Base64;  
12. import org.bouncycastle.jce.provider.BouncyCastleProvider;  
13.   
14. /\*\* 
15.  \* DES安全编码组件 
16.  \*  
17.  \* @author wbw 
18.  \* @version 1.0 
19.  \*/  
20. public abstract class DESUtil \{  
21.     static\{  
22.         Security.insertProviderAt(new BouncyCastleProvider(), 1);  
23.     \}  
24.     /\*\* 
25.      \* 密钥算法   
26.      \* Java 6 只支持56bit密钥   
27.      \* Bouncy Castle 支持64bit密钥 
28.      \*/  
29.     public static final String KEY\_ALGORITHM = "DES";  
30.   
31.     /\*\* 
32.      \* 加密/解密算法 / 工作模式 / 填充方式 
33.      \*/  
34.     public static final String CIPHER\_ALGORITHM = "DES/ECB/PKCS5PADDING";  
35.   
36.     /\*\* 
37.      \* 转换密钥 
38.      \*  
39.      \* @param key 
40.      \*            二进制密钥 
41.      \* @return Key 密钥 
42.      \* @throws Exception 
43.      \*/  
44.     private static Key toKey(byte\[\] key) throws Exception \{  
45.   
46.         // 实例化DES密钥材料  
47.         DESKeySpec dks = new DESKeySpec(key);  
48.   
49.         // 实例化秘密密钥工厂  
50.         SecretKeyFactory keyFactory = SecretKeyFactory  
51.                 .getInstance(KEY\_ALGORITHM);  
52.   
53.         // 生成秘密密钥  
54.         SecretKey secretKey = keyFactory.generateSecret(dks);  
55.   
56.         return secretKey;  
57.     \}  
58.   
59.     /\*\* 
60.      \* 解密 
61.      \*  
62.      \* @param data 
63.      \*            待解密数据 
64.      \* @param key 
65.      \*            密钥 
66.      \* @return byte\[\] 解密数据 
67.      \* @throws Exception 
68.      \*/  
69.     public static byte\[\] decrypt(byte\[\] data, byte\[\] key) throws Exception \{  
70.   
71.         // 还原密钥  
72.         Key k = toKey(key);  
73.   
74.         // 实例化  
75.         Cipher cipher = Cipher.getInstance(CIPHER\_ALGORITHM);  
76.   
77.         // 初始化，设置为解密模式  
78.         cipher.init(Cipher.DECRYPT\_MODE, k);  
79.   
80.         // 执行操作  
81.         return cipher.doFinal(data);  
82.     \}  
83.   
84.     /\*\* 
85.      \* 加密 
86.      \*  
87.      \* @param data 
88.      \*            待加密数据 
89.      \* @param key 
90.      \*            密钥 
91.      \* @return byte\[\] 加密数据 
92.      \* @throws Exception 
93.      \*/  
94.     public static byte\[\] encrypt(byte\[\] data, byte\[\] key) throws Exception \{  
95.   
96.         // 还原密钥  
97.         Key k = toKey(key);  
98.   
99.         // 实例化  
100.         Cipher cipher = Cipher.getInstance(CIPHER\_ALGORITHM);  
101.   
102.         // 初始化，设置为加密模式  
103.         cipher.init(Cipher.ENCRYPT\_MODE, k);  
104.   
105.         // 执行操作  
106.         return cipher.doFinal(data);  
107.     \}  
108.   
109.     /\*\* 
110.      \* 生成密钥   
111.      \* Java 6 只支持56bit密钥   
112.      \* Bouncy Castle 支持64bit密钥   
113.      \*  
114.      \* @return byte\[\] 二进制密钥 
115.      \* @throws Exception 
116.      \*/  
117.     public static byte\[\] initKey() throws Exception \{  
118.   
119.         /\* 
120.          \* 实例化密钥生成器 
121.          \*  
122.          \* 若要使用64bit密钥注意替换 将下述代码中的KeyGenerator.getInstance(CIPHER\_ALGORITHM); 
123.          \* 替换为KeyGenerator.getInstance(CIPHER\_ALGORITHM, "BC"); 
124.          \*/  
125.         KeyGenerator kg = KeyGenerator.getInstance(KEY\_ALGORITHM);  
126.   
127.         /\* 
128.          \* 初始化密钥生成器 若要使用64bit密钥注意替换 将下述代码kg.init(56); 替换为kg.init(64); 
129.          \*/  
130.         kg.init(56, new SecureRandom());  
131.   
132.         // 生成秘密密钥  
133.         SecretKey secretKey = kg.generateKey();  
134.   
135.         // 获得密钥的二进制编码形式  
136.         return secretKey.getEncoded();  
137.     \}  
138.       
139.     public static byte\[\] initKey(String seed) throws Exception \{  
140.         KeyGenerator kg = KeyGenerator.getInstance(KEY\_ALGORITHM);  
141.         SecureRandom secureRandom = new SecureRandom(new Base64().decode(seed));    
142.         kg.init(secureRandom);  
143.         SecretKey secretKey = kg.generateKey();  
144.         return secretKey.getEncoded();  
145.     \}  
146. \}

RSA加密：

**\[java\]**  [view plain][]  [copy][view plain]

1. import java.io.ByteArrayOutputStream;  
2. import java.security.Key;  
3. import java.security.KeyFactory;  
4. import java.security.KeyPair;  
5. import java.security.KeyPairGenerator;  
6. import java.security.PrivateKey;  
7. import java.security.PublicKey;  
8. import java.security.SecureRandom;  
9. import java.security.Security;  
10. import java.security.interfaces.RSAPrivateKey;  
11. import java.security.interfaces.RSAPublicKey;  
12. import java.security.spec.PKCS8EncodedKeySpec;  
13. import java.security.spec.X509EncodedKeySpec;  
14. import java.util.HashMap;  
15. import java.util.Map;  
16. import java.util.UUID;  
17.   
18. import javax.crypto.Cipher;  
19.   
20. import org.bouncycastle.jce.provider.BouncyCastleProvider;  
21. import org.bouncycastle.util.encoders.Base64;  
22.   
23.   
24. /\*\* 
25.  \* RSA安全编码组件 
26.  \*  
27.  \* @author wbw 
28.  \* @version 1.0 
29.  \*/  
30. public class RSAUtil \{  
31.     /\*\* 
32.      \* 非对称加密密钥算法 
33.      \*/  
34.     public static final String KEY\_ALGORITHM\_RSA = "RSA";  
35.   
36.     /\*\* 
37.      \* 公钥 
38.      \*/  
39.     private static final String RSA\_PUBLIC\_KEY = "RSAPublicKey";  
40.   
41.     /\*\* 
42.      \* 私钥 
43.      \*/  
44.     private static final String RSA\_PRIVATE\_KEY = "RSAPrivateKey";  
45.       
46.     /\*\* 
47.      \* RSA密钥长度  
48.      \* 默认1024位， 
49.      \* 密钥长度必须是64的倍数，  
50.      \* 范围在512至65536位之间。 
51.      \*/  
52.     private static final int KEY\_SIZE = 1024;  
53.       
54.     static\{  
55.         Security.insertProviderAt(new BouncyCastleProvider(), 1);  
56.     \}  
57.     /\*\* 
58.      \* 私钥解密 
59.      \*  
60.      \* @param data 
61.      \*            待解密数据 
62.      \* @param key 
63.      \*            私钥 
64.      \* @return byte\[\] 解密数据 
65.      \* @throws Exception 
66.      \*/  
67.     public static byte\[\] decryptByPrivateKey(byte\[\] data, byte\[\] key)  
68.             throws Exception \{  
69.   
70.         // 取得私钥  
71.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);  
72.   
73.         KeyFactory keyFactory = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
74.   
75.         // 生成私钥  
76.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
77.   
78.         // 对数据解密  
79.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
80.   
81.         cipher.init(Cipher.DECRYPT\_MODE, privateKey);  
82.   
83.         int blockSize = cipher.getBlockSize();  
84.         if(blockSize>0)\{  
85.             ByteArrayOutputStream bout = new ByteArrayOutputStream(64);  
86.             int j = 0;  
87.             while (data.length - j \* blockSize > 0) \{  
88.                 bout.write(cipher.doFinal(data, j \* blockSize, blockSize));  
89.                 j++;  
90.             \}  
91.             return bout.toByteArray();  
92.         \}  
93.         return cipher.doFinal(data);  
94.     \}  
95.   
96.     /\*\* 
97.      \* 公钥解密 
98.      \*  
99.      \* @param data 
100.      \*            待解密数据 
101.      \* @param key 
102.      \*            公钥 
103.      \* @return byte\[\] 解密数据 
104.      \* @throws Exception 
105.      \*/  
106.     public static byte\[\] decryptByPublicKey(byte\[\] data, byte\[\] key)  
107.             throws Exception \{  
108.   
109.         // 取得公钥  
110.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);  
111.   
112.         KeyFactory keyFactory = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
113.   
114.         // 生成公钥  
115.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);  
116.   
117.         // 对数据解密  
118.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
119.   
120.         cipher.init(Cipher.DECRYPT\_MODE, publicKey);  
121.   
122.         return cipher.doFinal(data);  
123.     \}  
124.   
125.     /\*\* 
126.      \* 公钥加密 
127.      \*  
128.      \* @param data 
129.      \*            待加密数据 
130.      \* @param key 
131.      \*            公钥 
132.      \* @return byte\[\] 加密数据 
133.      \* @throws Exception 
134.      \*/  
135.     public static byte\[\] encryptByPublicKey(byte\[\] data, byte\[\] key)  
136.             throws Exception \{  
137.   
138.         // 取得公钥  
139.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);  
140.   
141.         KeyFactory keyFactory = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
142.           
143.         PublicKey publicKey = keyFactory.generatePublic(x509KeySpec);  
144.   
145.         // 对数据加密  
146.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
147.   
148.         cipher.init(Cipher.ENCRYPT\_MODE, publicKey);  
149.           
150.         int blockSize = cipher.getBlockSize();  
151.         if(blockSize>0)\{  
152.             int outputSize = cipher.getOutputSize(data.length);  
153.             int leavedSize = data.length % blockSize;  
154.             int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
155.                     : data.length / blockSize;  
156.             byte\[\] raw = new byte\[outputSize \* blocksSize\];  
157.             int i = 0,remainSize=0;  
158.             while ((remainSize = data.length - i \* blockSize) > 0) \{  
159.                 int inputLen = remainSize > blockSize?blockSize:remainSize;  
160.                 cipher.doFinal(data, i \* blockSize, inputLen, raw, i \* outputSize);  
161.                 i++;  
162.             \}  
163.             return raw;  
164.         \}  
165.         return cipher.doFinal(data);  
166.     \}  
167.   
168.     /\*\* 
169.      \* 私钥加密 
170.      \*  
171.      \* @param data 
172.      \*            待加密数据 
173.      \* @param key 
174.      \*            私钥 
175.      \* @return byte\[\] 加密数据 
176.      \* @throws Exception 
177.      \*/  
178.     public static byte\[\] encryptByPrivateKey(byte\[\] data, byte\[\] key)  
179.             throws Exception \{  
180.   
181.         // 取得私钥  
182.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);  
183.   
184.         KeyFactory keyFactory = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
185.   
186.         // 生成私钥  
187.         PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);  
188.   
189.         // 对数据加密  
190.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
191.   
192.         cipher.init(Cipher.ENCRYPT\_MODE, privateKey);  
193.   
194.         int blockSize = cipher.getBlockSize();  
195.         if(blockSize>0)\{  
196.             int outputSize = cipher.getOutputSize(data.length);  
197.             int leavedSize = data.length % blockSize;  
198.             int blocksSize = leavedSize != 0 ? data.length / blockSize + 1  
199.                     : data.length / blockSize;  
200.             byte\[\] raw = new byte\[outputSize \* blocksSize\];  
201.             int i = 0,remainSize=0;  
202.             while ((remainSize = data.length - i \* blockSize) > 0) \{  
203.                 int inputLen = remainSize > blockSize?blockSize:remainSize;  
204.                 cipher.doFinal(data, i \* blockSize, inputLen, raw, i \* outputSize);  
205.                 i++;  
206.             \}  
207.             return raw;  
208.         \}  
209.         return cipher.doFinal(data);  
210.     \}  
211.   
212.     /\*\* 
213.      \* 取得私钥 
214.      \*  
215.      \* @param keyMap 
216.      \*            密钥Map 
217.      \* @return key 私钥 
218.      \* @throws Exception 
219.      \*/  
220.     public static Key getPrivateKey(Map<String, Key> keyMap)  
221.             throws Exception \{  
222.         return keyMap.get(RSA\_PRIVATE\_KEY);  
223.     \}  
224.   
225.     /\*\* 
226.      \* 取得私钥 
227.      \*  
228.      \* @param keyMap 
229.      \*            密钥Map 
230.      \* @return byte\[\] 私钥 
231.      \* @throws Exception 
232.      \*/  
233.     public static byte\[\] getPrivateKeyByte(Map<String, Key> keyMap)  
234.             throws Exception \{  
235.         return keyMap.get(RSA\_PRIVATE\_KEY).getEncoded();  
236.     \}  
237.       
238.     /\*\* 
239.      \* 取得公钥 
240.      \*  
241.      \* @param keyMap 
242.      \*            密钥Map 
243.      \* @return key 公钥 
244.      \* @throws Exception 
245.      \*/  
246.     public static Key getPublicKey(Map<String, Key> keyMap)  
247.             throws Exception \{  
248.         return keyMap.get(RSA\_PUBLIC\_KEY);  
249.     \}  
250.       
251.     /\*\* 
252.      \* 取得公钥 
253.      \*  
254.      \* @param keyMap 
255.      \*            密钥Map 
256.      \* @return byte\[\] 公钥 
257.      \* @throws Exception 
258.      \*/  
259.     public static byte\[\] getPublicKeyByte(Map<String, Key> keyMap)  
260.             throws Exception \{  
261.         return keyMap.get(RSA\_PUBLIC\_KEY).getEncoded();  
262.     \}  
263.       
264.     /\*\* 
265.      \* 初始化密钥 
266.      \* @param byte\[\] seed 种子 
267.      \* @return Map 密钥Map 
268.      \* @throws Exception 
269.      \*/  
270.     public static Map<String,Key> initKey(byte\[\] seed)throws Exception\{  
271.         // 实例化密钥对生成器  
272.         KeyPairGenerator keyPairGen = KeyPairGenerator  
273.                 .getInstance(KEY\_ALGORITHM\_RSA);  
274.   
275.         // 初始化密钥对生成器  
276.         keyPairGen.initialize(KEY\_SIZE, new SecureRandom(seed) );  
277.   
278.         // 生成密钥对  
279.         KeyPair keyPair = keyPairGen.generateKeyPair();  
280.   
281.         // 公钥  
282.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
283.   
284.         // 私钥  
285.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
286.   
287.         // 封装密钥  
288.         Map<String, Key> keyMap = new HashMap<String, Key>(2);  
289.   
290.         keyMap.put(RSA\_PUBLIC\_KEY, publicKey);  
291.         keyMap.put(RSA\_PRIVATE\_KEY, privateKey);  
292.   
293.         return keyMap;  
294.     \}  
295.       
296.     /\*\* 
297.      \* 初始化密钥 
298.      \* @param seed 种子 
299.      \* @return Map 密钥Map 
300.      \* @throws Exception 
301.      \*/  
302.     public static Map<String,Key> initKey(String seed)throws Exception\{  
303.         return initKey(seed.getBytes());  
304.     \}  
305.   
306.     /\*\* 
307.      \* 初始化密钥 
308.      \*  
309.      \* @return Map 密钥Map 
310.      \* @throws Exception 
311.      \*/  
312.     public static Map<String, Key> initKey() throws Exception \{  
313.         return initKey(UUID.randomUUID().toString().getBytes());  
314.     \}  
315.       
316.     public static PublicKey getPublicRSAKey(String key) throws Exception \{  
317.         X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));  
318.         KeyFactory kf = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
319.         return kf.generatePublic(x509);  
320.     \}  
321.   
322.     public static PrivateKey getPrivateRSAKey(String key) throws Exception \{  
323.         PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));  
324.         KeyFactory kf = KeyFactory.getInstance(KEY\_ALGORITHM\_RSA);  
325.         return kf.generatePrivate(pkgs8);  
326.     \}  
327.   
328. \}  
329.

[view plain]: https://blog.csdn.net/u011659172/article/details/50627903#