Java 加密解密之消息摘要算法（MD5 SHA MAC）

消息摘要

消息摘要（Message Digest）又称为数字摘要(Digital Digest)。它是一个唯一对应一个消息或文本的固定长度的值，它由一个单向Hash加密函数对消息进行作用而产生。如果消息在途中改变了，则接收者通过对收到消息的新产生的摘要与原摘要比较，就可知道消息是否被改变了。因此消息摘要保证了消息的完整性。消息摘要采用单向Hash 函数将需加密 的明文"摘要"成一串128bit的密文，这一串密文亦称为数字指纹(Finger Print)，它有固定的长度，且不同的明文摘要成密文，其结果总是不同的，而同样的明文其摘要必定一致 。这样这串摘要便可成为验证明文是否是"真身"的"指纹"了。 
 
HASH函数的抗冲突性使得如果一段明文稍有变化，哪怕只更改该段落的一个字母，通过哈希算法作用后都将产生不同的值。而HASH算法的单向性使得要找到到哈希值相同的两个不 同的输入消息，在计算上是不可能的。所以数据的哈希值，即消息摘要，可以检验数据的完整性。哈希函数的这种对不同的输入能够生成不同的值的特性使得无法找到两个具有相同哈希值的输入。因此，如果两个文档经哈希转换后成为相同的值，就可以肯定它们是同一文档。 所以，当希望有效地比较两个数据块时，就可以比较它们的哈希值。例如，可以通过比较邮件发送前和发送后的哈希值来验证该邮件在传递时是否修改。 

消息摘要算法

消息摘要算法的主要特征是加密过程不需要密钥，并且经过加密的数据无法被解密，只有输入相同的明文数据经过相同的消息摘要算法才能得到相同的密文。消息摘要算法不存在 密钥的管理与分发问题，适合于分布式网络相同上使用。由于其加密计算的工作量相当可观，所以以前的这种算法通常只用于数据量有限的情况下的加密，例如计算机的口令就是 用不可逆加密算法加密的。近年来，随着计算机相同性能的飞速改善，加密速度不再成为限制这种加密技术发展的桎梏，因而消息摘要算法应用的领域不断增加。

消息摘要算法的特点：

① 无论输入的消息有多长，计算出来的消息摘要的长度总是固定的。
② 消息摘要看起来是“随机的”。这些比特看上去是胡乱的杂凑在一起的。
③ 一般地，只要输入的消息不同，对其进行摘要以后产生的摘要消息也必不相同；但相同的输入必会产生相同的输出。
④ 消息摘要函数是无陷门的单向函数，即只能进行正向的信息摘要，而无法从摘要中恢复出任何的消息，甚至根本就找不到任何与原信息相关的信息。
⑤ 好的摘要算法，无法找到两条消息，是它们的摘要相同。

现有的消息摘要算法

消息摘要算法包含MD、SHA和MAC三大系列，常用于验证数据的完整性，是数据签名算法的核心算法。 
MAC与MD和SHA不同，MAC是含有密钥的散列函数算法，我们也常把MAC称为HMAC。 
 

JDK对消息摘要算法的支持

JDK6支持MD2/MD5/SHA/SHA256/SHA384/SHA512/HmacMD5/HmacSHA1/ HmacSHA256/HmacSHA384/HmacSHA512
 

使用到 十六进制工具类Hex.java  见：   java byte数组与十六进制字符串互转

MD和SHA系列的java实现：

DigestUtils.java

Java代码  

1. import java.security.MessageDigest;  
2. import java.security.NoSuchAlgorithmException;  
3.   
4. /** 
5.  * reference apache commons <a 
6.  * href=http://www.mamicode.com/"http://commons.apache.org/codec/">http://commons.apache.org/codec/ 
7.  *  
8.  * support MD2/MD5/SHA/SHA256/SHA384/SHA512 
9.  * @author Aub 
10.  *  
11.  */  
12. public class DigestUtils {  
13.   
14.     /** 
15.      * 根据给定摘要算法创建一个消息摘要实例 
16.      *  
17.      * @param algorithm 
18.      *            摘要算法名 
19.      * @return 消息摘要实例 
20.      * @see MessageDigest#getInstance(String) 
21.      * @throws RuntimeException 
22.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
23.      */  
24.     static MessageDigest getDigest(String algorithm) {  
25.         try {  
26.             return MessageDigest.getInstance(algorithm);  
27.         } catch (NoSuchAlgorithmException e) {  
28.             throw new RuntimeException(e.getMessage());  
29.         }  
30.     }  
31.   
32.     /** 
33.      * 获取 MD5 消息摘要实例 
34.      *  
35.      * @return MD5 消息摘要实例 
36.      * @throws RuntimeException 
37.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
38.      */  
39.     private static MessageDigest getMd5Digest() {  
40.         return getDigest("MD5");  
41.     }  
42.   
43.     /** 
44.      * 获取 SHA-1 消息摘要实例 
45.      *  
46.      * @return SHA-1 消息摘要实例 
47.      * @throws RuntimeException 
48.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
49.      */  
50.     private static MessageDigest getShaDigest() {  
51.         return getDigest("SHA");  
52.     }  
53.   
54.     /** 
55.      * 获取 SHA-256 消息摘要实例 
56.      *  
57.      * @return SHA-256 消息摘要实例 
58.      * @throws RuntimeException 
59.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
60.      */  
61.     private static MessageDigest getSha256Digest() {  
62.         return getDigest("SHA-256");  
63.     }  
64.   
65.     /** 
66.      * 获取 SHA-384 消息摘要实例 
67.      *  
68.      * @return SHA-384 消息摘要实例 
69.      * @throws RuntimeException 
70.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
71.      */  
72.     private static MessageDigest getSha384Digest() {  
73.         return getDigest("SHA-384");  
74.     }  
75.   
76.     /** 
77.      * 获取 SHA-512 消息摘要实例 
78.      *  
79.      * @return SHA-512 消息摘要实例 
80.      * @throws RuntimeException 
81.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
82.      */  
83.     private static MessageDigest getSha512Digest() {  
84.         return getDigest("SHA-512");  
85.     }  
86.   
87.     /** 
88.      * 使用MD5消息摘要算法计算消息摘要 
89.      *  
90.      * @param data 
91.      *            做消息摘要的数据 
92.      * @return 消息摘要（长度为16的字节数组） 
93.      */  
94.     public static byte[] encodeMD5(byte[] data) {  
95.         return getMd5Digest().digest(data);  
96.     }  
97.   
98.     /** 
99.      * 使用MD5消息摘要算法计算消息摘要 
100.      *  
101.      * @param data 
102.      *            做消息摘要的数据 
103.      * @return 消息摘要（长度为32的十六进制字符串） 
104.      */  
105.     public static String encodeMD5Hex(byte[] data) {  
106.         return Hex.encodeHexStr(encodeMD5(data));  
107.     }  
108.   
109.     /** 
110.      * 使用SHA-1消息摘要算法计算消息摘要 
111.      *  
112.      * @param data 
113.      *            做消息摘要的数据 
114.      * @return SHA-1消息摘要（长度为20的字节数组） 
115.      */  
116.     public static byte[] encodeSHA(byte[] data) {  
117.         return getShaDigest().digest(data);  
118.     }  
119.   
120.     /** 
121.      * 使用SHA-1消息摘要算法计算消息摘要 
122.      *  
123.      * @param data 
124.      *            做消息摘要的数据 
125.      * @return SHA-1消息摘要（长度为40的十六进制字符串） 
126.      */  
127.     public static String encodeSHAHex(byte[] data) {  
128.         return Hex.encodeHexStr(getShaDigest().digest(data));  
129.     }  
130.   
131.     /** 
132.      * 使用SHA-256消息摘要算法计算消息摘要 
133.      *  
134.      * @param data 
135.      *            做消息摘要的数据 
136.      * @return SHA-256消息摘要（长度为32的字节数组） 
137.      */  
138.     public static byte[] encodeSHA256(byte[] data) {  
139.         return getSha256Digest().digest(data);  
140.     }  
141.   
142.     /** 
143.      * 使用SHA-256消息摘要算法计算消息摘要 
144.      *  
145.      * @param data 
146.      *            做消息摘要的数据 
147.      * @return SHA-256消息摘要（长度为64的十六进制字符串） 
148.      */  
149.     public static String encodeSHA256Hex(byte[] data) {  
150.         return Hex.encodeHexStr(encodeSHA256(data));  
151.     }  
152.   
153.     /** 
154.      * 使用SHA-384消息摘要算法计算消息摘要 
155.      *  
156.      * @param data 
157.      *            做消息摘要的数据 
158.      * @return SHA-384消息摘要（长度为43的字节数组） 
159.      */  
160.     public static byte[] encodeSHA384(byte[] data) {  
161.         return getSha384Digest().digest(data);  
162.     }  
163.   
164.     /** 
165.      * 使用SHA-384消息摘要算法计算消息摘要 
166.      *  
167.      * @param data 
168.      *            做消息摘要的数据 
169.      * @return SHA-384消息摘要（长度为86的十六进制字符串） 
170.      */  
171.     public static String encodeSHA384Hex(byte[] data) {  
172.         return Hex.encodeHexStr(encodeSHA384(data));  
173.     }  
174.   
175.     /** 
176.      * 使用SHA-512消息摘要算法计算消息摘要 
177.      *  
178.      * @param data 
179.      *            做消息摘要的数据 
180.      * @return SHA-512消息摘要（长度为64的字节数组） 
181.      */  
182.     public static byte[] encodeSHA512(byte[] data) {  
183.         return getSha512Digest().digest(data);  
184.     }  
185.   
186.     /** 
187.      * 使用SHA-512消息摘要算法计算消息摘要 
188.      *  
189.      * @param data 
190.      *            做消息摘要的数据 
191.      * @return SHA-512消息摘要（长度为128的十六进制字符串） 
192.      */  
193.     public static String encodeSHA512Hex(byte[] data) {  
194.         return Hex.encodeHexStr(encodeSHA512(data));  
195.     }  
196.   
197. }  

参考 org.apache.commons.codec.digest.DigestUtils 
下载地址： http://commons.apache.org/codec/download_codec.cgi

MAC系列的java实现

Hmac.java

Java代码  

1. import java.security.InvalidKeyException;  
2. import java.security.Key;  
3. import java.security.NoSuchAlgorithmException;  
4.   
5. import javax.crypto.KeyGenerator;  
6. import javax.crypto.Mac;  
7. import javax.crypto.SecretKey;  
8. import javax.crypto.spec.SecretKeySpec;  
9.   
10. /** 
11.  * Hmac<br/> 
12.  * algorithm HmacMD5/HmacSHA/HmacSHA256/HmacSHA384/HmacSHA512 
13.  * @author Aub 
14.  */  
15. public class Hmac {  
16.       
17.     /** 
18.      * 根据给定密钥生成算法创建密钥 
19.      *  
20.      * @param algorithm 
21.      *            密钥算法 
22.      * @return 密钥 
23.      * @throws RuntimeException 
24.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
25.      */  
26.     private static byte[] getHmacKey(String algorithm){  
27.         //初始化KeyGenerator  
28.         KeyGenerator keyGenerator = null;  
29.         try {  
30.             keyGenerator = KeyGenerator.getInstance(algorithm);  
31.         } catch (NoSuchAlgorithmException e) {  
32.             throw new RuntimeException(e.getMessage());  
33.         }  
34.         //产生密钥  
35.         SecretKey secretKey = keyGenerator.generateKey();  
36.         //获得密钥  
37.         return secretKey.getEncoded();  
38.     }  
39.       
40.     /** 
41.      * 获取 HmaMD5的密钥 
42.      *  
43.      * @return  HmaMD5的密钥 
44.      * @throws RuntimeException 
45.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
46.      */  
47.     public static byte[] getHmaMD5key(){  
48.         return getHmacKey("HmacMD5");  
49.     }  
50.       
51.     /** 
52.      * 获取 HmaSHA的密钥 
53.      *  
54.      * @return  HmaSHA的密钥 
55.      * @throws RuntimeException 
56.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
57.      */  
58.     public static byte[] getHmaSHAkey(){  
59.         return getHmacKey("HmacSHA1");  
60.     }  
61.       
62.     /** 
63.      * 获取 HmaSHA256的密钥 
64.      *  
65.      * @return  HmaSHA256的密钥 
66.      * @throws RuntimeException 
67.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
68.      */  
69.     public static byte[] getHmaSHA256key(){  
70.         return getHmacKey("HmacSHA256");  
71.     }  
72.       
73.     /** 
74.      * 获取 HmaSHA384的密钥 
75.      *  
76.      * @return  HmaSHA384的密钥 
77.      * @throws RuntimeException 
78.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
79.      */  
80.     public static byte[] getHmaSHA384key(){  
81.         return getHmacKey("HmacSHA384");  
82.     }  
83.       
84.     /** 
85.      * 获取 HmaSHA512的密钥 
86.      *  
87.      * @return  HmaSHA384的密钥 
88.      * @throws RuntimeException 
89.      *             当 {@link java.security.NoSuchAlgorithmException} 发生时 
90.      */  
91.     public static byte[] getHmaSHA512key(){  
92.         return getHmacKey("HmacSHA512");  
93.     }  
94.       
95.     /** 
96.      * 转换密钥 
97.      *  
98.      * @param key   二进制密钥 
99.      * @param algorithm 密钥算法 
100.      * @return 密钥 
101.      */  
102.     private static Key toKey(byte[] key,String algorithm){  
103.         //生成密钥  
104.         return new SecretKeySpec(key, algorithm);  
105.     }  
106.       
107.     /** 
108.      * 使用HmacMD5消息摘要算法计算消息摘要 
109.      *  
110.      * @param data 做消息摘要的数据 
111.      * @param key 密钥 
112.      * @return 消息摘要（长度为16的字节数组） 
113.      */  
114.     public static byte[] encodeHmacMD5(byte[] data, Key key){  
115.         Mac mac = null;  
116.         try {  
117.             mac = Mac.getInstance("HmacMD5");  
118.             mac.init(key);  
119.         } catch (NoSuchAlgorithmException e) {  
120.             e.printStackTrace();  
121.             return new byte[0];  
122.         }catch (InvalidKeyException e) {  
123.             e.printStackTrace();  
124.             return new byte[0];  
125.         }  
126.         return mac.doFinal(data);  
127.     }  
128.       
129.     /** 
130.      * 使用HmacMD5消息摘要算法计算消息摘要 
131.      *  
132.      * @param data 做消息摘要的数据 
133.      * @param key 密钥 
134.      * @return 消息摘要（长度为16的字节数组） 
135.      */  
136.     public static byte[] encodeHmacMD5(byte[] data, byte[] key){  
137.         Key k = toKey(key, "HmacMD5");  
138.         return encodeHmacMD5(data, k);  
139.     }  
140.       
141.     /** 
142.      * 使用HmacSHA消息摘要算法计算消息摘要 
143.      *  
144.      * @param data 做消息摘要的数据 
145.      * @param key 密钥 
146.      * @return 消息摘要（长度为16的字节数组） 
147.      */  
148.     public static byte[] encodeHmacSHA(byte[] data, Key key){  
149.         Mac mac = null;  
150.         try {  
151.             mac = Mac.getInstance("HmacSHA1");  
152.             mac.init(key);  
153.         } catch (NoSuchAlgorithmException e) {  
154.             e.printStackTrace();  
155.             return new byte[0];  
156.         }catch (InvalidKeyException e) {  
157.             e.printStackTrace();  
158.             return new byte[0];  
159.         }  
160.         return mac.doFinal(data);  
161.     }  
162.       
163.     /** 
164.      * 使用HmacSHA消息摘要算法计算消息摘要 
165.      *  
166.      * @param data 做消息摘要的数据 
167.      * @param key 密钥 
168.      * @return 消息摘要（长度为16的字节数组） 
169.      */  
170.     public static byte[] encodeHmacSHA(byte[] data, byte[] key){  
171.         Key k = toKey(key, "HmacSHA1");  
172.         return encodeHmacSHA(data, k);  
173.     }  
174.       
175.     /** 
176.      * 使用HmacSHA256消息摘要算法计算消息摘要 
177.      *  
178.      * @param data 做消息摘要的数据 
179.      * @param key 密钥 
180.      * @return 消息摘要（长度为16的字节数组） 
181.      */  
182.     public static byte[] encodeHmacSHA256(byte[] data, Key key){  
183.         Mac mac = null;  
184.         try {  
185.             mac = Mac.getInstance("HmacSHA256");  
186.             mac.init(key);  
187.         } catch (NoSuchAlgorithmException e) {  
188.             e.printStackTrace();  
189.             return new byte[0];  
190.         }catch (InvalidKeyException e) {  
191.             e.printStackTrace();  
192.             return new byte[0];  
193.         }  
194.         return mac.doFinal(data);  
195.     }  
196.       
197.     /** 
198.      * 使用HmacSHA256消息摘要算法计算消息摘要 
199.      *  
200.      * @param data 做消息摘要的数据 
201.      * @param key 密钥 
202.      * @return 消息摘要（长度为16的字节数组） 
203.      */  
204.     public static byte[] encodeHmacSHA256(byte[] data, byte[] key){  
205.         Key k = toKey(key, "HmacSHA256");  
206.         return encodeHmacSHA256(data, k);  
207.     }  
208.       
209.       
210.     /** 
211.      * 使用HmacSHA384消息摘要算法计算消息摘要 
212.      *  
213.      * @param data 做消息摘要的数据 
214.      * @param key 密钥 
215.      * @return 消息摘要（长度为16的字节数组） 
216.      */  
217.     public static byte[] encodeHmacSHA384(byte[] data, Key key){  
218.         Mac mac = null;  
219.         try {  
220.             mac = Mac.getInstance("HmacSHA384");  
221.             mac.init(key);  
222.         } catch (NoSuchAlgorithmException e) {  
223.             e.printStackTrace();  
224.             return new byte[0];  
225.         }catch (InvalidKeyException e) {  
226.             e.printStackTrace();  
227.             return new byte[0];  
228.         }  
229.         return mac.doFinal(data);  
230.     }  
231.       
232.     /** 
233.      * 使用HmacSHA384消息摘要算法计算消息摘要 
234.      *  
235.      * @param data 做消息摘要的数据 
236.      * @param key 密钥 
237.      * @return 消息摘要（长度为16的字节数组） 
238.      */  
239.     public static byte[] encodeHmacSHA384(byte[] data, byte[] key){  
240.         Key k = toKey(key, "HmacSHA384");  
241.         return encodeHmacSHA384(data, k);  
242.     }  
243.       
244.       
245.       
246.     /** 
247.      * 使用HmacSHA512消息摘要算法计算消息摘要 
248.      *  
249.      * @param data 做消息摘要的数据 
250.      * @param key 密钥 
251.      * @return 消息摘要（长度为16的字节数组） 
252.      */  
253.     public static byte[] encodeHmacSHA512(byte[] data, Key key){  
254.         Mac mac = null;  
255.         try {  
256.             mac = Mac.getInstance("HmacSHA512");  
257.             mac.init(key);  
258.         } catch (NoSuchAlgorithmException e) {  
259.             e.printStackTrace();  
260.             return new byte[0];  
261.         }catch (InvalidKeyException e) {  
262.             e.printStackTrace();  
263.             return new byte[0];  
264.         }  
265.         return mac.doFinal(data);  
266.     }  
267.       
268.     /** 
269.      * 使用HmacSHA512消息摘要算法计算消息摘要 
270.      *  
271.      * @param data 做消息摘要的数据 
272.      * @param key 密钥 
273.      * @return 消息摘要（长度为16的字节数组） 
274.      */  
275.     public static byte[] encodeHmacSHA512(byte[] data, byte[] key){  
276.         Key k = toKey(key, "HmacSHA512");  
277.         return encodeHmacSHA512(data, k);  
278.     }  
279.       
280.       
281.     private static String  showByteArray(byte[] data){  
282.         if(null == data){  
283.             return null;  
284.         }  
285.         StringBuilder sb = new StringBuilder("{");  
286.         for(byte b:data){  
287.             sb.append(b).append(",");  
288.         }  
289.         sb.deleteCharAt(sb.length()-1);  
290.         sb.append("}");  
291.         return sb.toString();  
292.     }  
293.       
294.     public static void main(String[] args) {  
295. //      byte[] key = getHmaMD5key();  
296. //      byte[] key = getHmaSHAkey();  
297. //      byte[] key = getHmaSHA256key();  
298. //      byte[] key = getHmaSHA384key();  
299.         byte[] key = getHmaSHA512key();  
300.           
301.           
302.         System.out.println("加密密钥: byte[]:"+showByteArray(key).length());  
303.           
304.         String data = "Mac数据";  
305.         System.out.println("加密前数据: string:"+data);  
306.         System.out.println("加密前数据: byte[]:"+showByteArray(data.getBytes()));  
307.         System.out.println();  
308. //      byte[] encodeData = encodeHmacMD5(data.getBytes(), key);  
309. //      byte[] encodeData = encodeHmacSHA(data.getBytes(), key);  
310. //      byte[] encodeData = encodeHmacSHA256(data.getBytes(), key);  
311. //      byte[] encodeData = encodeHmacSHA384(data.getBytes(), key);  
312.         byte[] encodeData = encodeHmacSHA512(data.getBytes(), key);  
313.         System.out.println("加密后数据: byte[]:"+showByteArray(encodeData).length());  
314.         System.out.println("加密后数据: byte[]:"+encodeData.length);  
315.         System.out.println("加密后数据: hexStr:"+Hex.encodeHexStr(encodeData));  
316.         System.out.println();  
317.     }  
318. }  

密码学4——Java 加密解密之消息摘要算法（MD5 SHA MAC）