java(md5) 加密解密简单实现

Java代码  

1. package test;  
2. import java.io.FileInputStream;  <pre class="java" name="code"></pre>  
3. <br>import java.io.FileOutputStream;    
4. <br>import java.io.IOException;    
5. <br>import java.io.ObjectInputStream;    
6. <br>import java.io.ObjectOutputStream;    
7. <br>import java.security.*;    
8. <br>import javax.crypto.Cipher;    
9. <br>import javax.crypto.KeyGenerator;    
10. <br>import javax.crypto.SecretKey;    
11. <br>/**  
12. <br> * 加密解密  
13. <br> *   
14. <br> * @author shy.qiu  
15. <br> * @since  http://blog.csdn.net/qiushyfm  
16. <br> */    
17. <br>public class CryptTest {    
18. <br>    /**  
19. <br>     * 进行MD5加密  
20. <br>     *   
21. <br>     * @param info  
22. <br>     *            要加密的信息  
23. <br>     * @return String 加密后的字符串  
24. <br>     */    
25. <br>    public String encryptToMD5(String info) {    
26. <br>        byte[] digesta = null;    
27. <br>        try {    
28. <br>            // 得到一个md5的消息摘要    
29. <br>            MessageDigest alga = MessageDigest.getInstance(&quot;MD5&quot;);    
30. <br>            // 添加要进行计算摘要的信息    
31. <br>            alga.update(info.getBytes());    
32. <br>            // 得到该摘要    
33. <br>            digesta = alga.digest();    
34. <br>        } catch (NoSuchAlgorithmException e) {    
35. <br>            e.printStackTrace();    
36. <br>        }    
37. <br>        // 将摘要转为字符串    
38. <br>        String rs = byte2hex(digesta);    
39. <br>        return rs;    
40. <br>    }    
41. <br>    /**  
42. <br>     * 进行SHA加密  
43. <br>     *   
44. <br>     * @param info  
45. <br>     *            要加密的信息  
46. <br>     * @return String 加密后的字符串  
47. <br>     */    
48. <br>    public String encryptToSHA(String info) {    
49. <br>        byte[] digesta = null;    
50. <br>        try {    
51. <br>            // 得到一个SHA-1的消息摘要    
52. <br>            MessageDigest alga = MessageDigest.getInstance(&quot;SHA-1&quot;);    
53. <br>            // 添加要进行计算摘要的信息    
54. <br>            alga.update(info.getBytes());    
55. <br>            // 得到该摘要    
56. <br>            digesta = alga.digest();    
57. <br>        } catch (NoSuchAlgorithmException e) {    
58. <br>            e.printStackTrace();    
59. <br>        }    
60. <br>        // 将摘要转为字符串    
61. <br>        String rs = byte2hex(digesta);    
62. <br>        return rs;    
63. <br>    }    
64. <br>    // //    
65. <br>    /**  
66. <br>     * 创建密匙  
67. <br>     *   
68. <br>     * @param algorithm  
69. <br>     *            加密算法,可用 DES,DESede,Blowfish  
70. <br>     * @return SecretKey 秘密（对称）密钥  
71. <br>     */    
72. <br>    public SecretKey createSecretKey(String algorithm) {    
73. <br>        // 声明KeyGenerator对象    
74. <br>        KeyGenerator keygen;    
75. <br>        // 声明 密钥对象    
76. <br>        SecretKey deskey = null;    
77. <br>        try {    
78. <br>            // 返回生成指定算法的秘密密钥的 KeyGenerator 对象    
79. <br>            keygen = KeyGenerator.getInstance(algorithm);    
80. <br>            // 生成一个密钥    
81. <br>            deskey = keygen.generateKey();    
82. <br>        } catch (NoSuchAlgorithmException e) {    
83. <br>            e.printStackTrace();    
84. <br>        }    
85. <br>        // 返回密匙    
86. <br>        return deskey;    
87. <br>    }    
88. <br>    /**  
89. <br>     * 根据密匙进行DES加密  
90. <br>     *   
91. <br>     * @param key  
92. <br>     *            密匙  
93. <br>     * @param info  
94. <br>     *            要加密的信息  
95. <br>     * @return String 加密后的信息  
96. <br>     */    
97. <br>    public String encryptToDES(SecretKey key, String info) {    
98. <br>        // 定义 加密算法,可用 DES,DESede,Blowfish    
99. <br>        String Algorithm = &quot;DES&quot;;    
100. <br>        // 加密随机数生成器 (RNG),(可以不写)    
101. <br>        SecureRandom sr = new SecureRandom();    
102. <br>        // 定义要生成的密文    
103. <br>        byte[] cipherByte = null;    
104. <br>        try {    
105. <br>            // 得到加密/解密器    
106. <br>            Cipher c1 = Cipher.getInstance(Algorithm);    
107. <br>            // 用指定的密钥和模式初始化Cipher对象    
108. <br>            // 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)    
109. <br>            c1.init(Cipher.ENCRYPT_MODE, key, sr);    
110. <br>            // 对要加密的内容进行编码处理,    
111. <br>            cipherByte = c1.doFinal(info.getBytes());    
112. <br>        } catch (Exception e) {    
113. <br>            e.printStackTrace();    
114. <br>        }    
115. <br>        // 返回密文的十六进制形式    
116. <br>        return byte2hex(cipherByte);    
117. <br>    }    
118. <br>    /**  
119. <br>     * 根据密匙进行DES解密  
120. <br>     *   
121. <br>     * @param key  
122. <br>     *            密匙  
123. <br>     * @param sInfo  
124. <br>     *            要解密的密文  
125. <br>     * @return String 返回解密后信息  
126. <br>     */    
127. <br>    public String decryptByDES(SecretKey key, String sInfo) {    
128. <br>        // 定义 加密算法,    
129. <br>        String Algorithm = &quot;DES&quot;;    
130. <br>        // 加密随机数生成器 (RNG)    
131. <br>        SecureRandom sr = new SecureRandom();    
132. <br>        byte[] cipherByte = null;    
133. <br>        try {    
134. <br>            // 得到加密/解密器    
135. <br>            Cipher c1 = Cipher.getInstance(Algorithm);    
136. <br>            // 用指定的密钥和模式初始化Cipher对象    
137. <br>            c1.init(Cipher.DECRYPT_MODE, key, sr);    
138. <br>            // 对要解密的内容进行编码处理    
139. <br>            cipherByte = c1.doFinal(hex2byte(sInfo));    
140. <br>        } catch (Exception e) {    
141. <br>            e.printStackTrace();    
142. <br>        }    
143. <br>        // return byte2hex(cipherByte);    
144. <br>        return new String(cipherByte);    
145. <br>    }    
146. <br>    // /    
147. <br>    /**  
148. <br>     * 创建密匙组，并将公匙，私匙放入到指定文件中  
149. <br>     *   
150. <br>     * 默认放入mykeys.bat文件中  
151. <br>     */    
152. <br>    public void createPairKey() {    
153. <br>        try {    
154. <br>            // 根据特定的算法一个密钥对生成器    
155. <br>            KeyPairGenerator keygen = KeyPairGenerator.getInstance(&quot;DSA&quot;);    
156. <br>            // 加密随机数生成器 (RNG)    
157. <br>            SecureRandom random = new SecureRandom();    
158. <br>            // 重新设置此随机对象的种子    
159. <br>            random.setSeed(1000);    
160. <br>            // 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器    
161. <br>            keygen.initialize(512, random);// keygen.initialize(512);    
162. <br>            // 生成密钥组    
163. <br>            KeyPair keys = keygen.generateKeyPair();    
164. <br>            // 得到公匙    
165. <br>            PublicKey pubkey = keys.getPublic();    
166. <br>            // 得到私匙    
167. <br>            PrivateKey prikey = keys.getPrivate();    
168. <br>            // 将公匙私匙写入到文件当中    
169. <br>            doObjToFile(&quot;mykeys.bat&quot;, new Object[] { prikey, pubkey });    
170. <br>        } catch (NoSuchAlgorithmException e) {    
171. <br>            e.printStackTrace();    
172. <br>        }    
173. <br>    }    
174. <br>    /**  
175. <br>     * 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中  
176. <br>     *   
177. <br>     * @param info  
178. <br>     *            要签名的信息  
179. <br>     * @param signfile  
180. <br>     *            存入的文件  
181. <br>     */    
182. <br>    public void signToInfo(String info, String signfile) {    
183. <br>        // 从文件当中读取私匙    
184. <br>        PrivateKey myprikey = (PrivateKey) getObjFromFile(&quot;mykeys.bat&quot;, 1);    
185. <br>        // 从文件中读取公匙    
186. <br>        PublicKey mypubkey = (PublicKey) getObjFromFile(&quot;mykeys.bat&quot;, 2);    
187. <br>        try {    
188. <br>            // Signature 对象可用来生成和验证数字签名    
189. <br>            Signature signet = Signature.getInstance(&quot;DSA&quot;);    
190. <br>            // 初始化签署签名的私钥    
191. <br>            signet.initSign(myprikey);    
192. <br>            // 更新要由字节签名或验证的数据    
193. <br>            signet.update(info.getBytes());    
194. <br>            // 签署或验证所有更新字节的签名，返回签名    
195. <br>            byte[] signed = signet.sign();    
196. <br>            // 将数字签名,公匙,信息放入文件中    
197. <br>            doObjToFile(signfile, new Object[] { signed, mypubkey, info });    
198. <br>        } catch (Exception e) {    
199. <br>            e.printStackTrace();    
200. <br>        }    
201. <br>    }    
202. <br>    /**  
203. <br>     * 读取数字签名文件 根据公匙，签名，信息验证信息的合法性  
204. <br>     *   
205. <br>     * @return true 验证成功 false 验证失败  
206. <br>     */    
207. <br>    public boolean validateSign(String signfile) {    
208. <br>        // 读取公匙    
209. <br>        PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);    
210. <br>        // 读取签名    
211. <br>        byte[] signed = (byte[]) getObjFromFile(signfile, 1);    
212. <br>        // 读取信息    
213. <br>        String info = (String) getObjFromFile(signfile, 3);    
214. <br>        try {    
215. <br>            // 初始一个Signature对象,并用公钥和签名进行验证    
216. <br>            Signature signetcheck = Signature.getInstance(&quot;DSA&quot;);    
217. <br>            // 初始化验证签名的公钥    
218. <br>            signetcheck.initVerify(mypubkey);    
219. <br>            // 使用指定的 byte 数组更新要签名或验证的数据    
220. <br>            signetcheck.update(info.getBytes());    
221. <br>            System.out.println(info);    
222. <br>            // 验证传入的签名    
223. <br>            return signetcheck.verify(signed);    
224. <br>        } catch (Exception e) {    
225. <br>            e.printStackTrace();    
226. <br>            return false;    
227. <br>        }    
228. <br>    }    
229. <br>    /**  
230. <br>     * 将二进制转化为16进制字符串  
231. <br>     *   
232. <br>     * @param b  
233. <br>     *            二进制字节数组  
234. <br>     * @return String  
235. <br>     */    
236. <br>    public String byte2hex(byte[] b) {    
237. <br>        String hs = &quot;&quot;;    
238. <br>        String stmp = &quot;&quot;;    
239. <br>        for (int n = 0; n  0xEF   
240. <br>     *    
241. <br>     * @param src0   
242. <br>     *            byte   
243. <br>     * @param src1   
244. <br>     *            byte   
245. <br>     * @return byte   
246. <br>     */    
247. <br>    public static byte uniteBytes(byte src0, byte src1) {    
248. <br>        byte _b0 = Byte.decode(&quot;0x&quot; + new String(new byte[] { src0 }))    
249. <br>                .byteValue();    
250. <br>        _b0 = (byte) (_b0