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

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. importjava.security.MessageDigest;
2. importjava.security.NoSuchAlgorithmException;
4. /**
5. *referenceapachecommons<a
6. *href="http://commons.apache.org/codec/">http://commons.apache.org/codec/</a>
7. *
8. *supportMD2/MD5/SHA/SHA256/SHA384/SHA512
9. *@authorAub
10. *
11. */
12. publicclassDigestUtils{
14. /**
15. *根据给定摘要算法创建一个消息摘要实例
16. *
17. *@paramalgorithm
18. *摘要算法名
19. *@return消息摘要实例
20. *@seeMessageDigest#getInstance(String)
21. *@throwsRuntimeException
22. *当{@linkjava.security.NoSuchAlgorithmException}发生时
23. */
24. staticMessageDigestgetDigest(Stringalgorithm){
25. try{
26. returnMessageDigest.getInstance(algorithm);
27. }catch(NoSuchAlgorithmExceptione){
28. thrownewRuntimeException(e.getMessage());
29. }
30. }
32. /**
33. *获取MD5消息摘要实例
34. *
35. *@returnMD5消息摘要实例
36. *@throwsRuntimeException
37. *当{@linkjava.security.NoSuchAlgorithmException}发生时
38. */
39. privatestaticMessageDigestgetMd5Digest(){
40. returngetDigest("MD5");
41. }
43. /**
44. *获取SHA-1消息摘要实例
45. *
46. *@returnSHA-1消息摘要实例
47. *@throwsRuntimeException
48. *当{@linkjava.security.NoSuchAlgorithmException}发生时
49. */
50. privatestaticMessageDigestgetShaDigest(){
51. returngetDigest("SHA");
52. }
54. /**
55. *获取SHA-256消息摘要实例
56. *
57. *@returnSHA-256消息摘要实例
58. *@throwsRuntimeException
59. *当{@linkjava.security.NoSuchAlgorithmException}发生时
60. */
61. privatestaticMessageDigestgetSha256Digest(){
62. returngetDigest("SHA-256");
63. }
65. /**
66. *获取SHA-384消息摘要实例
67. *
68. *@returnSHA-384消息摘要实例
69. *@throwsRuntimeException
70. *当{@linkjava.security.NoSuchAlgorithmException}发生时
71. */
72. privatestaticMessageDigestgetSha384Digest(){
73. returngetDigest("SHA-384");
74. }
76. /**
77. *获取SHA-512消息摘要实例
78. *
79. *@returnSHA-512消息摘要实例
80. *@throwsRuntimeException
81. *当{@linkjava.security.NoSuchAlgorithmException}发生时
82. */
83. privatestaticMessageDigestgetSha512Digest(){
84. returngetDigest("SHA-512");
85. }
87. /**
88. *使用MD5消息摘要算法计算消息摘要
89. *
90. *@paramdata
91. *做消息摘要的数据
92. *@return消息摘要（长度为16的字节数组）
93. */
94. publicstaticbyte[]encodeMD5(byte[]data){
95. returngetMd5Digest().digest(data);
96. }
98. /**
99. *使用MD5消息摘要算法计算消息摘要
100. *
101. *@paramdata
102. *做消息摘要的数据
103. *@return消息摘要（长度为32的十六进制字符串）
104. */
105. publicstaticStringencodeMD5Hex(byte[]data){
106. returnHex.encodeHexStr(encodeMD5(data));
107. }
109. /**
110. *使用SHA-1消息摘要算法计算消息摘要
111. *
112. *@paramdata
113. *做消息摘要的数据
114. *@returnSHA-1消息摘要（长度为20的字节数组）
115. */
116. publicstaticbyte[]encodeSHA(byte[]data){
117. returngetShaDigest().digest(data);
118. }
120. /**
121. *使用SHA-1消息摘要算法计算消息摘要
122. *
123. *@paramdata
124. *做消息摘要的数据
125. *@returnSHA-1消息摘要（长度为40的十六进制字符串）
126. */
127. publicstaticStringencodeSHAHex(byte[]data){
128. returnHex.encodeHexStr(getShaDigest().digest(data));
129. }
131. /**
132. *使用SHA-256消息摘要算法计算消息摘要
133. *
134. *@paramdata
135. *做消息摘要的数据
136. *@returnSHA-256消息摘要（长度为32的字节数组）
137. */
138. publicstaticbyte[]encodeSHA256(byte[]data){
139. returngetSha256Digest().digest(data);
140. }
142. /**
143. *使用SHA-256消息摘要算法计算消息摘要
144. *
145. *@paramdata
146. *做消息摘要的数据
147. *@returnSHA-256消息摘要（长度为64的十六进制字符串）
148. */
149. publicstaticStringencodeSHA256Hex(byte[]data){
150. returnHex.encodeHexStr(encodeSHA256(data));
151. }
153. /**
154. *使用SHA-384消息摘要算法计算消息摘要
155. *
156. *@paramdata
157. *做消息摘要的数据
158. *@returnSHA-384消息摘要（长度为43的字节数组）
159. */
160. publicstaticbyte[]encodeSHA384(byte[]data){
161. returngetSha384Digest().digest(data);
162. }
164. /**
165. *使用SHA-384消息摘要算法计算消息摘要
166. *
167. *@paramdata
168. *做消息摘要的数据
169. *@returnSHA-384消息摘要（长度为86的十六进制字符串）
170. */
171. publicstaticStringencodeSHA384Hex(byte[]data){
172. returnHex.encodeHexStr(encodeSHA384(data));
173. }
175. /**
176. *使用SHA-512消息摘要算法计算消息摘要
177. *
178. *@paramdata
179. *做消息摘要的数据
180. *@returnSHA-512消息摘要（长度为64的字节数组）
181. */
182. publicstaticbyte[]encodeSHA512(byte[]data){
183. returngetSha512Digest().digest(data);
184. }
186. /**
187. *使用SHA-512消息摘要算法计算消息摘要
188. *
189. *@paramdata
190. *做消息摘要的数据
191. *@returnSHA-512消息摘要（长度为128的十六进制字符串）
192. */
193. publicstaticStringencodeSHA512Hex(byte[]data){
194. returnHex.encodeHexStr(encodeSHA512(data));
195. }
197. }

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

MAC系列的java实现

Hmac.java

Java代码

1. importjava.security.InvalidKeyException;
2. importjava.security.Key;
3. importjava.security.NoSuchAlgorithmException;
5. importjavax.crypto.KeyGenerator;
6. importjavax.crypto.Mac;
7. importjavax.crypto.SecretKey;
8. importjavax.crypto.spec.SecretKeySpec;
10. /**
11. *Hmac<br/>
12. *algorithmHmacMD5/HmacSHA/HmacSHA256/HmacSHA384/HmacSHA512
13. *@authorAub
14. */
15. publicclassHmac{
17. /**
18. *根据给定密钥生成算法创建密钥
19. *
20. *@paramalgorithm
21. *密钥算法
22. *@return密钥
23. *@throwsRuntimeException
24. *当{@linkjava.security.NoSuchAlgorithmException}发生时
25. */
26. privatestaticbyte[]getHmacKey(Stringalgorithm){
27. //初始化KeyGenerator
28. KeyGeneratorkeyGenerator=null;
29. try{
30. keyGenerator=KeyGenerator.getInstance(algorithm);
31. }catch(NoSuchAlgorithmExceptione){
32. thrownewRuntimeException(e.getMessage());
33. }
34. //产生密钥
35. SecretKeysecretKey=keyGenerator.generateKey();
36. //获得密钥
37. returnsecretKey.getEncoded();
38. }
40. /**
41. *获取HmaMD5的密钥
42. *
43. *@returnHmaMD5的密钥
44. *@throwsRuntimeException
45. *当{@linkjava.security.NoSuchAlgorithmException}发生时
46. */
47. publicstaticbyte[]getHmaMD5key(){
48. returngetHmacKey("HmacMD5");
49. }
51. /**
52. *获取HmaSHA的密钥
53. *
54. *@returnHmaSHA的密钥
55. *@throwsRuntimeException
56. *当{@linkjava.security.NoSuchAlgorithmException}发生时
57. */
58. publicstaticbyte[]getHmaSHAkey(){
59. returngetHmacKey("HmacSHA1");
60. }
62. /**
63. *获取HmaSHA256的密钥
64. *
65. *@returnHmaSHA256的密钥
66. *@throwsRuntimeException
67. *当{@linkjava.security.NoSuchAlgorithmException}发生时
68. */
69. publicstaticbyte[]getHmaSHA256key(){
70. returngetHmacKey("HmacSHA256");
71. }
73. /**
74. *获取HmaSHA384的密钥
75. *
76. *@returnHmaSHA384的密钥
77. *@throwsRuntimeException
78. *当{@linkjava.security.NoSuchAlgorithmException}发生时
79. */
80. publicstaticbyte[]getHmaSHA384key(){
81. returngetHmacKey("HmacSHA384");
82. }
84. /**
85. *获取HmaSHA512的密钥
86. *
87. *@returnHmaSHA384的密钥
88. *@throwsRuntimeException
89. *当{@linkjava.security.NoSuchAlgorithmException}发生时
90. */
91. publicstaticbyte[]getHmaSHA512key(){
92. returngetHmacKey("HmacSHA512");
93. }
95. /**
96. *转换密钥
97. *
98. *@paramkey二进制密钥
99. *@paramalgorithm密钥算法
100. *@return密钥
101. */
102. privatestaticKeytoKey(byte[]key,Stringalgorithm){
103. //生成密钥
104. returnnewSecretKeySpec(key,algorithm);
105. }
107. /**
108. *使用HmacMD5消息摘要算法计算消息摘要
109. *
110. *@paramdata做消息摘要的数据
111. *@paramkey密钥
112. *@return消息摘要（长度为16的字节数组）
113. */
114. publicstaticbyte[]encodeHmacMD5(byte[]data,Keykey){
115. Macmac=null;
116. try{
117. mac=Mac.getInstance("HmacMD5");
118. mac.init(key);
119. }catch(NoSuchAlgorithmExceptione){
120. e.printStackTrace();
121. returnnewbyte[0];
122. }catch(InvalidKeyExceptione){
123. e.printStackTrace();
124. returnnewbyte[0];
125. }
126. returnmac.doFinal(data);
127. }
129. /**
130. *使用HmacMD5消息摘要算法计算消息摘要
131. *
132. *@paramdata做消息摘要的数据
133. *@paramkey密钥
134. *@return消息摘要（长度为16的字节数组）
135. */
136. publicstaticbyte[]encodeHmacMD5(byte[]data,byte[]key){
137. Keyk=toKey(key,"HmacMD5");
138. returnencodeHmacMD5(data,k);
139. }
141. /**
142. *使用HmacSHA消息摘要算法计算消息摘要
143. *
144. *@paramdata做消息摘要的数据
145. *@paramkey密钥
146. *@return消息摘要（长度为16的字节数组）
147. */
148. publicstaticbyte[]encodeHmacSHA(byte[]data,Keykey){
149. Macmac=null;
150. try{
151. mac=Mac.getInstance("HmacSHA1");
152. mac.init(key);
153. }catch(NoSuchAlgorithmExceptione){
154. e.printStackTrace();
155. returnnewbyte[0];
156. }catch(InvalidKeyExceptione){
157. e.printStackTrace();
158. returnnewbyte[0];
159. }
160. returnmac.doFinal(data);
161. }
163. /**
164. *使用HmacSHA消息摘要算法计算消息摘要
165. *
166. *@paramdata做消息摘要的数据
167. *@paramkey密钥
168. *@return消息摘要（长度为16的字节数组）
169. */
170. publicstaticbyte[]encodeHmacSHA(byte[]data,byte[]key){
171. Keyk=toKey(key,"HmacSHA1");
172. returnencodeHmacSHA(data,k);
173. }
175. /**
176. *使用HmacSHA256消息摘要算法计算消息摘要
177. *
178. *@paramdata做消息摘要的数据
179. *@paramkey密钥
180. *@return消息摘要（长度为16的字节数组）
181. */
182. publicstaticbyte[]encodeHmacSHA256(byte[]data,Keykey){
183. Macmac=null;
184. try{
185. mac=Mac.getInstance("HmacSHA256");
186. mac.init(key);
187. }catch(NoSuchAlgorithmExceptione){
188. e.printStackTrace();
189. returnnewbyte[0];
190. }catch(InvalidKeyExceptione){
191. e.printStackTrace();
192. returnnewbyte[0];
193. }
194. returnmac.doFinal(data);
195. }
197. /**
198. *使用HmacSHA256消息摘要算法计算消息摘要
199. *
200. *@paramdata做消息摘要的数据
201. *@paramkey密钥
202. *@return消息摘要（长度为16的字节数组）
203. */
204. publicstaticbyte[]encodeHmacSHA256(byte[]data,byte[]key){
205. Keyk=toKey(key,"HmacSHA256");
206. returnencodeHmacSHA256(data,k);
207. }
210. /**
211. *使用HmacSHA384消息摘要算法计算消息摘要
212. *
213. *@paramdata做消息摘要的数据
214. *@paramkey密钥
215. *@return消息摘要（长度为16的字节数组）
216. */
217. publicstaticbyte[]encodeHmacSHA384(byte[]data,Keykey){
218. Macmac=null;
219. try{
220. mac=Mac.getInstance("HmacSHA384");
221. mac.init(key);
222. }catch(NoSuchAlgorithmExceptione){
223. e.printStackTrace();
224. returnnewbyte[0];
225. }catch(InvalidKeyExceptione){
226. e.printStackTrace();
227. returnnewbyte[0];
228. }
229. returnmac.doFinal(data);
230. }
232. /**
233. *使用HmacSHA384消息摘要算法计算消息摘要
234. *
235. *@paramdata做消息摘要的数据
236. *@paramkey密钥
237. *@return消息摘要（长度为16的字节数组）
238. */
239. publicstaticbyte[]encodeHmacSHA384(byte[]data,byte[]key){
240. Keyk=toKey(key,"HmacSHA384");
241. returnencodeHmacSHA384(data,k);
242. }
246. /**
247. *使用HmacSHA512消息摘要算法计算消息摘要
248. *
249. *@paramdata做消息摘要的数据
250. *@paramkey密钥
251. *@return消息摘要（长度为16的字节数组）
252. */
253. publicstaticbyte[]encodeHmacSHA512(byte[]data,Keykey){
254. Macmac=null;
255. try{
256. mac=Mac.getInstance("HmacSHA512");
257. mac.init(key);
258. }catch(NoSuchAlgorithmExceptione){
259. e.printStackTrace();
260. returnnewbyte[0];
261. }catch(InvalidKeyExceptione){
262. e.printStackTrace();
263. returnnewbyte[0];
264. }
265. returnmac.doFinal(data);
266. }
268. /**
269. *使用HmacSHA512消息摘要算法计算消息摘要
270. *
271. *@paramdata做消息摘要的数据
272. *@paramkey密钥
273. *@return消息摘要（长度为16的字节数组）
274. */
275. publicstaticbyte[]encodeHmacSHA512(byte[]data,byte[]key){
276. Keyk=toKey(key,"HmacSHA512");
277. returnencodeHmacSHA512(data,k);
278. }
281. privatestaticStringshowByteArray(byte[]data){
282. if(null==data){
283. returnnull;
284. }
285. StringBuildersb=newStringBuilder("{");
286. for(byteb:data){
287. sb.append(b).append(",");
288. }
289. sb.deleteCharAt(sb.length()-1);
290. sb.append("}");
291. returnsb.toString();
292. }
294. publicstaticvoidmain(String[]args){
295. //byte[]key=getHmaMD5key();
296. //byte[]key=getHmaSHAkey();
297. //byte[]key=getHmaSHA256key();
298. //byte[]key=getHmaSHA384key();
299. byte[]key=getHmaSHA512key();
302. System.out.println("加密密钥:byte[]:"+showByteArray(key).length());
304. Stringdata="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. }