java常用工具类之DES和Base64加密解密类

一、DES加密和解密

1. package com.itjh.javaUtil; 
2.   
3. import java.io.UnsupportedEncodingException; 
4. import java.security.InvalidKeyException; 
5. import java.security.NoSuchAlgorithmException; 
6. import java.security.SecureRandom; 
7. import java.security.spec.InvalidKeySpecException; 
8.   
9. import javax.crypto.BadPaddingException; 
10. import javax.crypto.Cipher; 
11. import javax.crypto.IllegalBlockSizeException; 
12. import javax.crypto.KeyGenerator; 
13. import javax.crypto.NoSuchPaddingException; 
14. import javax.crypto.SecretKey; 
15. import javax.crypto.SecretKeyFactory; 
16. import javax.crypto.spec.DESKeySpec; 
17.   
18. /** 
19.  * DES加密和解密。 
20.  *  
21.  * @author 宋立君 
22.  * @date 2014年07月03日 
23.  */ 
24. public class DESUtil { 
25.   
26.     /** 安全密钥 */ 
27.     private String keyData = "ABCDEFGHIJKLMNOPQRSTWXYZabcdefghijklmnopqrstwxyz0123456789-_."; 
28.   
29.     /** 
30.      * 功能：构造 
31.      *  
32.      * @author 宋立君 
33.      * @date 2014年07月03日 
34.      */ 
35.     public DESUtil() { 
36.     } 
37.   
38.     /** 
39.      * 功能：构造 
40.      *  
41.      * @author 宋立君 
42.      * @date 2014年07月03日 
43.      * @param keyData 
44.      *  key 
45.      */ 
46.     public DESUtil(String key) { 
47.         this.keyData = key; 
48.     } 
49.   
50.     /** 
51.      * 功能：加密 (UTF-8) 
52.      *  
53.      * @author 宋立君 
54.      * @date 2014年07月03日 
55.      * @param source 
56.      *  源字符串 
57.      * @param charSet 
58.      *  编码 
59.      * @return String 
60.      * @throws UnsupportedEncodingException 
61.      *  编码异常 
62.      */ 
63.     public String encrypt(String source) throws UnsupportedEncodingException { 
64.         return encrypt(source, "UTF-8"); 
65.     } 
66.   
67.     /** 
68.      *  
69.      * 功能：解密 (UTF-8) 
70.      *  
71.      * @author 宋立君 
72.      * @date 2014年07月03日 
73.      * @param encryptedData 
74.      *  被加密后的字符串 
75.      * @return String 
76.      * @throws UnsupportedEncodingException 
77.      *  编码异常 
78.      */ 
79.     public String decrypt(String encryptedData) 
80.             throws UnsupportedEncodingException { 
81.         return decrypt(encryptedData, "UTF-8"); 
82.     } 
83.   
84.     /** 
85.      * 功能：加密 
86.      *  
87.      * @author 宋立君 
88.      * @date 2014年07月03日 
89.      * @param source 
90.      *  源字符串 
91.      * @param charSet 
92.      *  编码 
93.      * @return String 
94.      * @throws UnsupportedEncodingException 
95.      *  编码异常 
96.      */ 
97.     public String encrypt(String source, String charSet) 
98.             throws UnsupportedEncodingException { 
99.         String encrypt = null; 
100.         byte[] ret = encrypt(source.getBytes(charSet)); 
101.         encrypt = new String(Base64.encode(ret)); 
102.         return encrypt; 
103.     } 
104.   
105.     /** 
106.      *  
107.      * 功能：解密 
108.      *  
109.      * @author 宋立君 
110.      * @date 2014年07月03日 
111.      * @param encryptedData 
112.      *  被加密后的字符串 
113.      * @param charSet 
114.      *  编码 
115.      * @return String 
116.      * @throws UnsupportedEncodingException 
117.      *  编码异常 
118.      */ 
119.     public String decrypt(String encryptedData, String charSet) 
120.             throws UnsupportedEncodingException { 
121.         String descryptedData = null; 
122.         byte[] ret = descrypt(Base64.decode(encryptedData.toCharArray())); 
123.         descryptedData = new String(ret, charSet); 
124.         return descryptedData; 
125.     } 
126.   
127.     /** 
128.      * 加密数据 用生成的密钥加密原始数据 
129.      *  
130.      * @param primaryData 
131.      *  原始数据 
132.      * @return byte[] 
133.      * @author 宋立君 
134.      * @date 2014年07月03日 
135.      */ 
136.     private byte[] encrypt(byte[] primaryData) { 
137.   
138.         /** 取得安全密钥 */ 
139.         byte rawKeyData[] = getKey(); 
140.   
141.         /** DES算法要求有一个可信任的随机数源 */ 
142.         SecureRandom sr = new SecureRandom(); 
143.   
144.         /** 使用原始密钥数据创建DESKeySpec对象 */ 
145.         DESKeySpec dks = null; 
146.         try { 
147.             dks = new DESKeySpec(keyData.getBytes()); 
148.         } catch (InvalidKeyException e) { 
149.             e.printStackTrace(); 
150.         } 
151.   
152.         /** 创建一个密钥工厂 */ 
153.         SecretKeyFactory keyFactory = null; 
154.         try { 
155.             keyFactory = SecretKeyFactory.getInstance("DES"); 
156.         } catch (NoSuchAlgorithmException e) { 
157.             e.printStackTrace(); 
158.         } 
159.   
160.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */ 
161.         SecretKey key = null; 
162.         try { 
163.             key = keyFactory.generateSecret(dks); 
164.         } catch (InvalidKeySpecException e) { 
165.             e.printStackTrace(); 
166.         } 
167.   
168.         /** Cipher对象实际完成加密操作 */ 
169.         Cipher cipher = null; 
170.         try { 
171.             cipher = Cipher.getInstance("DES"); 
172.         } catch (NoSuchAlgorithmException e) { 
173.             e.printStackTrace(); 
174.         } catch (NoSuchPaddingException e) { 
175.             e.printStackTrace(); 
176.         } 
177.   
178.         /** 用密钥初始化Cipher对象 */ 
179.         try { 
180.             cipher.init(Cipher.ENCRYPT_MODE, key, sr); 
181.         } catch (InvalidKeyException e) { 
182.             e.printStackTrace(); 
183.         } 
184.   
185.         /** 正式执行加密操作 */ 
186.         byte encryptedData[] = null; 
187.         try { 
188.             encryptedData = cipher.doFinal(primaryData); 
189.         } catch (IllegalStateException e) { 
190.             e.printStackTrace(); 
191.         } catch (IllegalBlockSizeException e) { 
192.             e.printStackTrace(); 
193.         } catch (BadPaddingException e) { 
194.             e.printStackTrace(); 
195.         } 
196.   
197.         /** 返回加密数据 */ 
198.         return encryptedData; 
199.     } 
200.   
201.     /** 
202.      * 用密钥解密数据 
203.      *  
204.      * @param encryptedData 
205.      *  加密后的数据 
206.      * @return byte[] 
207.      * @author 宋立君 
208.      * @date 2014年07月03日 
209.      */ 
210.     private byte[] descrypt(byte[] encryptedData) { 
211.   
212.         /** DES算法要求有一个可信任的随机数源 */ 
213.         SecureRandom sr = new SecureRandom(); 
214.   
215.         /** 取得安全密钥 */ 
216.         byte rawKeyData[] = getKey(); 
217.   
218.         /** 使用原始密钥数据创建DESKeySpec对象 */ 
219.         DESKeySpec dks = null; 
220.         try { 
221.             dks = new DESKeySpec(keyData.getBytes()); 
222.         } catch (InvalidKeyException e) { 
223.             e.printStackTrace(); 
224.         } 
225.   
226.         /** 创建一个密钥工厂 */ 
227.         SecretKeyFactory keyFactory = null; 
228.         try { 
229.             keyFactory = SecretKeyFactory.getInstance("DES"); 
230.         } catch (NoSuchAlgorithmException e) { 
231.             e.printStackTrace(); 
232.         } 
233.   
234.         /** 用密钥工厂把DESKeySpec转换成一个SecretKey对象 */ 
235.         SecretKey key = null; 
236.         try { 
237.             key = keyFactory.generateSecret(dks); 
238.         } catch (InvalidKeySpecException e) { 
239.             e.printStackTrace(); 
240.         } 
241.   
242.         /** Cipher对象实际完成加密操作 */ 
243.         Cipher cipher = null; 
244.         try { 
245.             cipher = Cipher.getInstance("DES"); 
246.         } catch (NoSuchAlgorithmException e) { 
247.             e.printStackTrace(); 
248.         } catch (NoSuchPaddingException e) { 
249.             e.printStackTrace(); 
250.         } 
251.   
252.         /** 用密钥初始化Cipher对象 */ 
253.         try { 
254.             cipher.init(Cipher.DECRYPT_MODE, key, sr); 
255.         } catch (InvalidKeyException e) { 
256.             e.printStackTrace(); 
257.         } 
258.   
259.         /** 正式执行解密操作 */ 
260.         byte decryptedData[] = null; 
261.         try { 
262.             decryptedData = cipher.doFinal(encryptedData); 
263.         } catch (IllegalStateException e) { 
264.             e.printStackTrace(); 
265.         } catch (IllegalBlockSizeException e) { 
266.             e.printStackTrace(); 
267.         } catch (BadPaddingException e) { 
268.             e.printStackTrace(); 
269.         } 
270.   
271.         return decryptedData; 
272.     } 
273.   
274.     /** 
275.      * 取得安全密钥 此方法作废,因为每次key生成都不一样导致解密加密用的密钥都不一样， 从而导致Given final block not 
276.      * properly padded错误. 
277.      *  
278.      * @return byte数组 
279.      * @author 宋立君 
280.      * @date 2014年07月03日 
281.      */ 
282.     private byte[] getKey() { 
283.   
284.         /** DES算法要求有一个可信任的随机数源 */ 
285.         SecureRandom sr = new SecureRandom(); 
286.   
287.         /** 为我们选择的DES算法生成一个密钥生成器对象 */ 
288.         KeyGenerator kg = null; 
289.         try { 
290.             kg = KeyGenerator.getInstance("DES"); 
291.         } catch (NoSuchAlgorithmException e) { 
292.             e.printStackTrace(); 
293.         } 
294.         kg.init(sr); 
295.   
296.         /** 生成密钥工具类 */ 
297.         SecretKey key = kg.generateKey(); 
298.   
299.         /** 生成密钥byte数组 */ 
300.         byte rawKeyData[] = key.getEncoded(); 
301.   
302.         return rawKeyData; 
303.     } 
304.   
305. } 

二、Base64加密和解密

1. package com.itjh.javaUtil; 
2.   
3. import java.io.*; 
4.   
5. /** 
6.  * Base64 编码和解码。 
7.  *  
8.  * @author 宋立君 
9.  * @date 2014年07月03日 
10.  */ 
11. public class Base64 { 
12.   
13.     public Base64() { 
14.     } 
15.   
16.     /** 
17.      * 功能：编码字符串 
18.      *  
19.      * @author 宋立君 
20.      * @date 2014年07月03日 
21.      * @param data 
22.      *  源字符串 
23.      * @return String 
24.      */ 
25.     public static String encode(String data) { 
26.         return new String(encode(data.getBytes())); 
27.     } 
28.   
29.     /** 
30.      * 功能：解码字符串 
31.      *  
32.      * @author 宋立君 
33.      * @date 2014年07月03日 
34.      * @param data 
35.      *  源字符串 
36.      * @return String 
37.      */ 
38.     public static String decode(String data) { 
39.         return new String(decode(data.toCharArray())); 
40.     } 
41.   
42.     /** 
43.      * 功能：编码byte[] 
44.      *  
45.      * @author 宋立君 
46.      * @date 2014年07月03日 
47.      * @param data 
48.      *  源 
49.      * @return char[] 
50.      */ 
51.     public static char[] encode(byte[] data) { 
52.         char[] out = new char[((data.length + 2) / 3) * 4]; 
53.         for (int i = 0, index = 0; i < data.length; i += 3, index += 4) { 
54.             boolean quad = false; 
55.             boolean trip = false; 
56.   
57.             int val = (0xFF & (int) data[i]); 
58.             val <<= 8; 
59.             if ((i + 1) < data.length) { 
60.                 val |= (0xFF & (int) data[i + 1]); 
61.                 trip = true; 
62.             } 
63.             val <<= 8; 
64.             if ((i + 2) < data.length) { 
65.                 val |= (0xFF & (int) data[i + 2]); 
66.                 quad = true; 
67.             } 
68.             out[index + 3] = alphabet[(quad ? (val & 0x3F) : 64)]; 
69.             val >>= 6; 
70.             out[index + 2] = alphabet[(trip ? (val & 0x3F) : 64)]; 
71.             val >>= 6; 
72.             out[index + 1] = alphabet[val & 0x3F]; 
73.             val >>= 6; 
74.             out[index + 0] = alphabet[val & 0x3F]; 
75.         } 
76.         return out; 
77.     } 
78.   
79.     /** 
80.      * 功能：解码 
81.      *  
82.      * @author 宋立君 
83.      * @date 2014年07月03日 
84.      * @param data 
85.      *  编码后的字符数组 
86.      * @return byte[] 
87.      */ 
88.     public static byte[] decode(char[] data) { 
89.   
90.         int tempLen = data.length; 
91.         for (int ix = 0; ix < data.length; ix++) { 
92.             if ((data[ix] > 255) || codes[data[ix]] < 0) { 
93.                 --tempLen; // ignore non-valid chars and padding 
94.             } 
95.         } 
96.         // calculate required length: 
97.         // -- 3 bytes for every 4 valid base64 chars 
98.         // -- plus 2 bytes if there are 3 extra base64 chars, 
99.         // or plus 1 byte if there are 2 extra. 
100.   
101.         int len = (tempLen / 4) * 3; 
102.         if ((tempLen % 4) == 3) { 
103.             len += 2; 
104.         } 
105.         if ((tempLen % 4) == 2) { 
106.             len += 1; 
107.   
108.         } 
109.         byte[] out = new byte[len]; 
110.   
111.         int shift = 0; // # of excess bits stored in accum 
112.         int accum = 0; // excess bits 
113.         int index = 0; 
114.   
115.         // we now go through the entire array (NOT using the 'tempLen' value) 
116.         for (int ix = 0; ix < data.length; ix++) { 
117.             int value = (data[ix] > 255) ? -1 : codes[data[ix]]; 
118.   
119.             if (value >= 0) { // skip over non-code 
120.                 accum <<= 6; // bits shift up by 6 each time thru 
121.                 shift += 6; // loop, with new bits being put in 
122.                 accum |= value; // at the bottom. 
123.                 if (shift >= 8) { // whenever there are 8 or more shifted in, 
124.                     shift -= 8; // write them out (from the top, leaving any 
125.                     out[index++] = // excess at the bottom for next iteration. 
126.                     (byte) ((accum >> shift) & 0xff); 
127.                 } 
128.             } 
129.         } 
130.   
131.         // if there is STILL something wrong we just have to throw up now! 
132.         if (index != out.length) { 
133.             throw new Error("Miscalculated data length (wrote " + index 
134.                     + " instead of " + out.length + ")"); 
135.         } 
136.   
137.         return out; 
138.     } 
139.   
140.     /** 
141.      * 功能：编码文件 
142.      *  
143.      * @author 宋立君 
144.      * @date 2014年07月03日 
145.      * @param file 
146.      *  源文件 
147.      */ 
148.     public static void encode(File file) throws IOException { 
149.         if (!file.exists()) { 
150.             System.exit(0); 
151.         } 
152.   
153.         else { 
154.             byte[] decoded = readBytes(file); 
155.             char[] encoded = encode(decoded); 
156.             writeChars(file, encoded); 
157.         } 
158.         file = null; 
159.     } 
160.   
161.     /** 
162.      * 功能：解码文件。 
163.      *  
164.      * @author 宋立君 
165.      * @date 2014年07月03日 
166.      * @param file 
167.      *  源文件 
168.      * @throws IOException 
169.      */ 
170.     public static void decode(File file) throws IOException { 
171.         if (!file.exists()) { 
172.             System.exit(0); 
173.         } else { 
174.             char[] encoded = readChars(file); 
175.             byte[] decoded = decode(encoded); 
176.             writeBytes(file, decoded); 
177.         } 
178.         file = null; 
179.     } 
180.   
181.     // 
182.     // code characters for values 0..63 
183.     // 
184.     private static char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" 
185.             .toCharArray(); 
186.   
187.     // 
188.     // lookup table for converting base64 characters to value in range 0..63 
189.     // 
190.     private static byte[] codes = new byte[256]; 
191.     static { 
192.         for (int i = 0; i < 256; i++) { 
193.             codes[i] = -1; 
194.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
195.         } 
196.         for (int i = 'A'; i <= 'Z'; i++) { 
197.             codes[i] = (byte) (i - 'A'); 
198.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
199.         } 
200.   
201.         for (int i = 'a'; i <= 'z'; i++) { 
202.             codes[i] = (byte) (26 + i - 'a'); 
203.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
204.         } 
205.         for (int i = '0'; i <= '9'; i++) { 
206.             codes[i] = (byte) (52 + i - '0'); 
207.             // LoggerUtil.debug(i + "&" + codes[i] + " "); 
208.         } 
209.         codes['+'] = 62; 
210.         codes['/'] = 63; 
211.     } 
212.   
213.     private static byte[] readBytes(File file) throws IOException { 
214.         ByteArrayOutputStream baos = new ByteArrayOutputStream(); 
215.         byte[] b = null; 
216.         InputStream fis = null; 
217.         InputStream is = null; 
218.         try { 
219.             fis = new FileInputStream(file); 
220.             is = new BufferedInputStream(fis); 
221.             int count = 0; 
222.             byte[] buf = new byte[16384]; 
223.             while ((count = is.read(buf)) != -1) { 
224.                 if (count > 0) { 
225.                     baos.write(buf, 0, count); 
226.                 } 
227.             } 
228.             b = baos.toByteArray(); 
229.   
230.         } finally { 
231.             try { 
232.                 if (fis != null) 
233.                     fis.close(); 
234.                 if (is != null) 
235.                     is.close(); 
236.                 if (baos != null) 
237.                     baos.close(); 
238.             } catch (Exception e) { 
239.                 System.out.println(e); 
240.             } 
241.         } 
242.   
243.         return b; 
244.     } 
245.   
246.     private static char[] readChars(File file) throws IOException { 
247.         CharArrayWriter caw = new CharArrayWriter(); 
248.         Reader fr = null; 
249.         Reader in = null; 
250.         try { 
251.             fr = new FileReader(file); 
252.             in = new BufferedReader(fr); 
253.             int count = 0; 
254.             char[] buf = new char[16384]; 
255.             while ((count = in.read(buf)) != -1) { 
256.                 if (count > 0) { 
257.                     caw.write(buf, 0, count); 
258.                 } 
259.             } 
260.   
261.         } finally { 
262.             try { 
263.                 if (caw != null) 
264.                     caw.close(); 
265.                 if (in != null) 
266.                     in.close(); 
267.                 if (fr != null) 
268.                     fr.close(); 
269.             } catch (Exception e) { 
270.                 System.out.println(e); 
271.             } 
272.         } 
273.   
274.         return caw.toCharArray(); 
275.     } 
276.   
277.     private static void writeBytes(File file, byte[] data) throws IOException { 
278.         OutputStream fos = null; 
279.         OutputStream os = null; 
280.         try { 
281.             fos = new FileOutputStream(file); 
282.             os = new BufferedOutputStream(fos); 
283.             os.write(data); 
284.   
285.         } finally { 
286.             try { 
287.                 if (os != null) 
288.                     os.close(); 
289.                 if (fos != null) 
290.                     fos.close(); 
291.             } catch (Exception e) { 
292.                 System.out.println(e); 
293.             } 
294.         } 
295.     } 
296.   
297.     private static void writeChars(File file, char[] data) throws IOException { 
298.         Writer fos = null; 
299.         Writer os = null; 
300.         try { 
301.             fos = new FileWriter(file); 
302.             os = new BufferedWriter(fos); 
303.             os.write(data); 
304.   
305.         } finally { 
306.             try { 
307.                 if (os != null) 
308.                     os.close(); 
309.                 if (fos != null) 
310.                     fos.close(); 
311.             } catch (Exception e) { 
312.                 e.printStackTrace(); 
313.             } 
314.         } 
315.     } 
316.   
317.     // ///////////////////////////////////////////////// 
318.     // end of test code. 
319.     // ///////////////////////////////////////////////// 
320.   
321. }