java中DES加密解密

废话不多说，直接奉上代码：

代码一

1. package com.eabax.plugin.yundada.utils; 
2. import java.io.IOException; 
3. import java.security.InvalidKeyException; 
4. import java.security.NoSuchAlgorithmException; 
5. import java.security.SecureRandom; 
6. import java.security.spec.InvalidKeySpecException; 
7. import javax.crypto.BadPaddingException; 
8. import javax.crypto.Cipher; 
9. import javax.crypto.IllegalBlockSizeException; 
10. import javax.crypto.NoSuchPaddingException; 
11. import javax.crypto.SecretKey; 
12. import javax.crypto.SecretKeyFactory; 
13. import javax.crypto.spec.DESKeySpec; 
14. import org.apache.commons.codec.binary.Base64; 
15. import sun.misc.BASE64Decoder; 
16. public class DESEncryptHelper { 
17.   private final static String DES = "DES"; 
18.   /** 
19.    * 生成密钥 
20.    * @param employeeCode 
21.    */ 
22.   public static String getDESKey(String encryptStr){ 
23.     if (!CacheManager.getCache().containsKey("encryptKey_"+encryptStr)) { 
24.       CacheManager.getCache().put("encryptKey_"+encryptStr, encryptStr+"tablemiyaokey"); 
25.     } 
26.     String key = (String) CacheManager.getCache().get("encryptKey_"+encryptStr); 
27.     return key; 
28.   } 
29.    /** 
30.    * Description 根据键值进行解密 
31.    * @param data 
32.    * @param key 加密键byte数组 
33.    * @return 
34.    * @throws IOException 
35.    * @throws Exception 
36.    */ 
37.   public static String decrypt(String data, String key) throws IOException, 
38.       Exception { 
39.     if (data == null) 
40.       return null; 
41.     BASE64Decoder decoder = new BASE64Decoder(); 
42.     byte[] buf = decoder.decodeBuffer(data); 
43.     byte[] bt = decrypt(buf,key.getBytes()); 
44.     return new String(bt); 
45.   } 
46.   /** 
47.    * 对字符串加密  
48.    * @param str 
49.    * @return 
50.    * @throws InvalidKeyException 
51.    * @throws IllegalBlockSizeException 
52.    * @throws BadPaddingException 
53.    * @throws InvalidKeySpecException 
54.    * @throws NoSuchAlgorithmException 
55.    * @throws NoSuchPaddingException 
56.    */ 
57.   public static String getEncryptStr(String str,String encryptStr) throws InvalidKeyException, 
58.       IllegalBlockSizeException, BadPaddingException, 
59.       InvalidKeySpecException, NoSuchAlgorithmException, 
60.       NoSuchPaddingException { 
61.     //获取key 
62.     String key = getDESKey(encryptStr); 
63.     //获取密钥 
64.     SecretKeyFactory factory = SecretKeyFactory.getInstance("DES"); 
65.     DESKeySpec keyspec = new DESKeySpec(key.getBytes()); 
66.     SecretKey deskey = factory.generateSecret(keyspec); 
67.     // Cipher负责完成加密或解密工作 
68.     Cipher c = Cipher.getInstance("DES"); 
69.     // 根据密钥，对Cipher对象进行初始化，DECRYPT_MODE表示加密模式  
70.     c.init(Cipher.ENCRYPT_MODE, deskey); 
71.     byte[] src = str.getBytes(); 
72.     // 该字节数组负责保存加密的结果 
73.     byte[] cipherByte = c.doFinal(src); 
74.     String enstr = new String(Base64.encodeBase64(cipherByte)); 
75.     return enstr; 
76.   } 
77.    /** 
78.    * Description 根据键值进行解密 
79.    * @param data 
80.    * @param key 加密键byte数组 
81.    * @return 
82.    * @throws Exception 
83.    */ 
84.   private static byte[] decrypt(byte[] data, byte[] key) throws Exception { 
85.     // 生成一个可信任的随机数源 
86.     SecureRandom sr = new SecureRandom(); 
87.     // 从原始密钥数据创建DESKeySpec对象 
88.     DESKeySpec dks = new DESKeySpec(key); 
89.     // 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象 
90.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES); 
91.     SecretKey securekey = keyFactory.generateSecret(dks); 
92.     // Cipher对象实际完成解密操作 
93.     Cipher cipher = Cipher.getInstance(DES); 
94.     // 用密钥初始化Cipher对象 
95.     cipher.init(Cipher.DECRYPT_MODE, securekey, sr); 
96.     return cipher.doFinal(data); 
97.   } 
98. } 

代码二

1. package com.sinosoft.olyvem.common; 
2.   
3. import java.security.SecureRandom; 
4.   
5. import javax.crypto.Cipher; 
6. import javax.crypto.SecretKey; 
7. import javax.crypto.SecretKeyFactory; 
8. import javax.crypto.spec.DESKeySpec; 
9.   
10. import sun.misc.BASE64Encoder; 
11.   
12. public class DES ...{ 
13.   private byte[] desKey; 
14.   
15.   public DES(byte[] desKey) ...{ 
16.     this.desKey = desKey; 
17.   } 
18.   
19.   public byte[] doEncrypt(byte[] plainText) throws Exception ...{ 
20.     // DES算法要求有一个可信任的随机数源 
21.     SecureRandom sr = new SecureRandom(); 
22.     byte rawKeyData[] = desKey;/**//* 用某种方法获得密匙数据 */ 
23.     // 从原始密匙数据创建DESKeySpec对象 
24.     DESKeySpec dks = new DESKeySpec(rawKeyData); 
25.     // 创建一个密匙工厂，然后用它把DESKeySpec转换成 
26.     // 一个SecretKey对象 
27.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); 
28.     SecretKey key = keyFactory.generateSecret(dks); 
29.     // Cipher对象实际完成加密操作 
30.     Cipher cipher = Cipher.getInstance("DES"); 
31.     // 用密匙初始化Cipher对象 
32.     cipher.init(Cipher.ENCRYPT_MODE, key, sr); 
33.     // 现在，获取数据并加密 
34.     byte data[] = plainText;/**//* 用某种方法获取数据 */ 
35.     // 正式执行加密操作 
36.     byte encryptedData[] = cipher.doFinal(data); 
37.     return encryptedData; 
38.   } 
39.   
40.   public byte[] doDecrypt(byte[] encryptText) throws Exception ...{ 
41.     // DES算法要求有一个可信任的随机数源 
42.     SecureRandom sr = new SecureRandom(); 
43.     byte rawKeyData[] = desKey; /**//* 用某种方法获取原始密匙数据 */ 
44.     // 从原始密匙数据创建一个DESKeySpec对象 
45.     DESKeySpec dks = new DESKeySpec(rawKeyData); 
46.     // 创建一个密匙工厂，然后用它把DESKeySpec对象转换成 
47.     // 一个SecretKey对象 
48.     SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES"); 
49.     SecretKey key = keyFactory.generateSecret(dks); 
50.     // Cipher对象实际完成解密操作 
51.     Cipher cipher = Cipher.getInstance("DES"); 
52.     // 用密匙初始化Cipher对象 
53.     cipher.init(Cipher.DECRYPT_MODE, key, sr); 
54.     // 现在，获取数据并解密 
55.     byte encryptedData[] = encryptText;/**//* 获得经过加密的数据 */ 
56.     // 正式执行解密操作 
57.     byte decryptedData[] = cipher.doFinal(encryptedData); 
58.     return decryptedData; 
59.   } 
60.   
61.   public static void main(String[] args) throws Exception ...{ 
62.     String key = "FtpXPass"; 
63.     String value = "olympic"; 
64.     BASE64Encoder base64Encoder = new BASE64Encoder(); 
65.   
66.     DES desEncrypt = new DES(key.getBytes()); 
67.     byte[] encryptText = desEncrypt.doEncrypt(value.getBytes()); 
68.     //System.out.println("doEncrypt  -  " + toHexString(encryptText)); 
69.     System.out.println("doEncrypt  -  " 
70.         + base64Encoder.encode(encryptText)); 
71.     byte[] decryptText = desEncrypt.doDecrypt("r9NGYcKAtdo=".getBytes()); 
72.     System.out.println("doDecrypt  -  " + new String(decryptText)); 
73.     //System.out.println("doDecrypt  -  " + toHexString(decryptText)); 
74.   
75.   } 
76.   
77.   public static String toHexString(byte[] value) ...{ 
78.     String newString = ""; 
79.     for (int i = 0; i < value.length; i++) ...{ 
80.       byte b = value[i]; 
81.       String str = Integer.toHexString(b); 
82.       if (str.length() > 2) ...{ 
83.         str = str.substring(str.length() - 2); 
84.       } 
85.       if (str.length() < 2) ...{ 
86.         str = "0" + str; 
87.       } 
88.       newString += str; 
89.     } 
90.     return newString.toUpperCase(); 
91.   } 
92.   
93. } 

以上就是本文关于DES加密解密的代码了，希望对大家学习java有所帮助。