java中DES加密解密

时间:2022-04-02 04:09:03

废话不多说,直接奉上代码:

代码一

  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.   } 

代码二

  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.   

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