DES 加密

1. package encrypt;   
2.    
3. import java.security.*;   
4. import javax.crypto.Cipher;   
5. import javax.crypto.SecretKey;   
6. import javax.crypto.SecretKeyFactory;   
7. import javax.crypto.spec.DESKeySpec;   
8.    
9.    
10. public class DesEncrypt {   
11.    
12.     private static final String PASSWORD_CRYPT_KEY = "xredleaf";   
13.     private final static String DES = "DES";   
14.    
15.    
16.     
17. /**  
19. * 加密  
21. * @param src 数据源  
23. * @param key 密钥，长度必须是8的倍数  
25. * @return  返回加密后的数据  
27. * @throws Exception  
29. */   
30.    
31. public static byte[] encrypt(byte[] src, byte[] key)throws Exception {   
32.    
33.        //DES算法要求有一个可信任的随机数源   
34.    
35.        SecureRandom sr = new SecureRandom();   
36.    
37.        // 从原始密匙数据创建DESKeySpec对象    
38.    
39.        DESKeySpec dks = new DESKeySpec(key);   
40.    
41.        // 创建一个密匙工厂，然后用它把DESKeySpec转换成   
42.    
43.        // 一个SecretKey对象   
44.    
45.        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);   
46.    
47.        SecretKey securekey = keyFactory.generateSecret(dks);   
48.    
49.        // Cipher对象实际完成加密操作   
50.    
51.        Cipher cipher = Cipher.getInstance(DES);   
52.    
53.        // 用密匙初始化Cipher对象   
54.    
55.        cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);   
56.    
57.        // 现在，获取数据并加密   
58.    
59.        // 正式执行加密操作   
60.    
61.        return cipher.doFinal(src);   
62.    
63.     }   
64.    
65.    
66.    
67.     /**  
69.     * 解密  
71.     * @param src 数据源  
73.     * @param key 密钥，长度必须是8的倍数  
75.     * @return   返回解密后的原始数据  
77.     * @throws Exception  
79.     */   
80.    
81.     public static byte[] decrypt(byte[] src, byte[] key)throws Exception {   
82.    
83.        // DES算法要求有一个可信任的随机数源   
84.    
85.        SecureRandom sr = new SecureRandom();   
86.    
87.        // 从原始密匙数据创建一个DESKeySpec对象   
88.    
89.        DESKeySpec dks = new DESKeySpec(key);   
90.    
91.        // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成   
92.    
93.        // 一个SecretKey对象   
94.    
95.        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);   
96.    
97.        SecretKey securekey = keyFactory.generateSecret(dks);   
98.    
99.        // Cipher对象实际完成解密操作   
100.    
101.        Cipher cipher = Cipher.getInstance(DES);   
102.    
103.        // 用密匙初始化Cipher对象   
104.    
105.        cipher.init(Cipher.DECRYPT_MODE, securekey, sr);   
106.    
107.        // 现在，获取数据并解密   
108.    
109.        // 正式执行解密操作   
110.    
111.        return cipher.doFinal(src);   
112.    
113.     }   
114.    
115.  /**  
117.   * 密码解密  
119.   * @param data  
121.   * @return  
123.   * @throws Exception  
125.   */   
126.    
127.  public final static String decrypt(String data){   
128.    
129.     try {   
130.    
131.      return new String(decrypt(hex2byte(data.getBytes()),   
132.    
133.         PASSWORD_CRYPT_KEY.getBytes()));   
134.    
135.    }catch(Exception e) {   
136.    
137.    }   
138.    
139.    return null;   
140.    
141.  }   
142.    
143.  /**  
145.   * 密码加密  
147.   * @param password  
149.   * @return  
151.   * @throws Exception  
153.   */   
154.    
155.  public final static String encrypt(String password){   
156.    
157.    try {   
158.    
159.      return byte2hex(encrypt(password.getBytes(),PASSWORD_CRYPT_KEY.getBytes()));   
160.    }catch(Exception e) {   
161.    
162.    }   
163.    
164.    return null;   
165.    
166.  }   
167.    
168. /**  
170. * 二行制转字符串  
172. * @param b  
174. * @return  
176. */   
177.    
178.  public static String byte2hex(byte[] b) {   
179.    
180.        String hs = "";   
181.    
182.        String stmp = "";   
183.    
184.        for (int n = 0; n < b.length; n++) {   
185.    
186.            stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));   
187.    
188.            if (stmp.length() == 1)   
189.    
190.                hs = hs + "0" + stmp;   
191.    
192.            else   
193.    
194.                hs = hs + stmp;   
195.    
196.        }   
197.    
198.        return hs.toUpperCase();   
199.    
200.   }   
201.    
202.     
203.    
204.  public static byte[] hex2byte(byte[] b) {   
205.    
206.    if((b.length%2)!=0)   
207.    
208.       throw new IllegalArgumentException("长度不是偶数");   
209.    
210.        byte[] b2 = new byte[b.length/2];   
211.    
212.        for (int n = 0; n < b.length; n+=2) {   
213.    
214.          String item = new String(b,n,2);   
215.    
216.          b2[n/2] = (byte)Integer.parseInt(item,16);   
217.    
218.        }   
219.    
220.    return b2;   
221.  }   
222. }