java基于Des对称加密算法实现的加密与解密功能详解

package com.soufun.com;import java.io.IOException;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.util.Date;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;// 导入sun的64位编码import sun.misc.BASE64Decoder;import sun.misc.BASE64Encoder;/** *@author WHD * *即使导入sun.misc这个架包也会报错，这时首先把你的JRE架包移除再导入一次就可以了 */public class DesUtil {  // 定义加密方式   private final static String DES = "DES";   private final static String UTF8="GBK";   static SecretKeyFactory keyFactory = null;  static {    try {      keyFactory=SecretKeyFactory.getInstance("DES");    } catch (NoSuchAlgorithmException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }  }    public static void main(String[] args) throws Exception {      long begin=new Date().getTime();      String data = "aaades加密测试";      // 注意：DES加密和解密过程中，密钥长度都必须是8的倍数      String key = "qazwsxed";      System.err.println(encrypt(data, key));      System.err.println(decrypt(encrypt(data, key), key));      long end =new Date().getTime();      System.out.println(end-begin);    }    /**     * Description 根据键值进行加密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    public static String encrypt(String data, String key) throws Exception {      // 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以      byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes(UTF8));      //注意：在加密和解密的时候使用sun的BASE64Encoder（）进行编码和解码不然会有乱码      //网上查看了很多实例，都没有编码和解码，也说没有乱码问题，而我这里出现了乱码，所以使用BASE64Encoder（）进行了编码解码      String strs = new BASE64Encoder().encode(bt);      return strs;    }    /**     * Description 根据键值进行解密     * @param data     * @param key 加密键byte数组     * @return     * @throws IOException     * @throws Exception     */    public static String decrypt(String data, String key) throws IOException,        Exception {      if (data == null)        return null;      //注意：在加密和解密的时候使用sun的BASE64Encoder（）进行编码和解码不然会有乱码      BASE64Decoder decoder = new BASE64Decoder();      byte[] buf = decoder.decodeBuffer(data);      byte[] bt = decrypt(buf,key.getBytes());      return new String(bt,UTF8);    }    /**     * Description 根据键值进行加密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {      // 生成一个可信任的随机数源      SecureRandom sr = new SecureRandom();      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容      DESKeySpec dks = new DESKeySpec(key);      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。      // 这里改为使用单例模式      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥) 对象。      SecretKey securekey = keyFactory.generateSecret(dks);      // Cipher对象实际完成加密操作,此类为加密和解密提供密码功能      Cipher cipher = Cipher.getInstance(DES);      // 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。      cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);      //正式执行加密操作      return cipher.doFinal(data);    }    /**     * Description 根据键值进行解密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {      // 生成一个可信任的随机数源      SecureRandom sr = new SecureRandom();      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容      DESKeySpec dks = new DESKeySpec(key);      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。      // 这里改为使用单例模式      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥)对象。      SecretKey securekey = keyFactory.generateSecret(dks);      // Cipher类为加密和解密提供密码功能      Cipher cipher = Cipher.getInstance(DES);      // DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。      cipher.init(Cipher.DECRYPT_MODE, securekey, sr);      // 正式进行解密操作      return cipher.doFinal(data);    }}

package com.soufun.com;import java.io.IOException;import java.security.NoSuchAlgorithmException;import java.security.SecureRandom;import java.util.Date;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import org.apache.commons.codec.binary.Base64;/** *@author WHD * */public class DesUtil {  // 定义加密方式   private final static String DES = "DES";   private final static String UTF8="GBK";   static SecretKeyFactory keyFactory = null;  static {    try {      keyFactory=SecretKeyFactory.getInstance("DES");    } catch (NoSuchAlgorithmException e) {      // TODO Auto-generated catch block      e.printStackTrace();    }  }    public static void main(String[] args) throws Exception {      long begin=new Date().getTime();      String data = "aaades加密测试";      // 注意：DES加密和解密过程中，密钥长度都必须是8的倍数      String key = "qazwsxed";      System.err.println(encrypt(data, key));      System.err.println(decrypt(encrypt(data, key), key));      long end =new Date().getTime();      System.out.println(end-begin);    }    /**     * Description 根据键值进行加密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    public static String encrypt(String data, String key) throws Exception {      // 使用指定的编码获取要加密的内容，一般秘钥都是字母或数字不用指定编码，但指定也可以      byte[] bt = encrypt(data.getBytes(UTF8), key.getBytes());      // 第一个使用了sun.misc.BASE64Encoder;进行了编码，但网上说使用org.apache.commons.codec.binary.Base64比较好所以拿来试试      String strs = Base64.encodeBase64String(bt);      return strs;    }    /**     * Description 根据键值进行解密     * @param data     * @param key 加密键byte数组     * @return     * @throws IOException     * @throws Exception     */    public static String decrypt(String data, String key) throws IOException,        Exception {      if (data == null)        return null;      // 使用org.apache.commons.codec.binary.Base64解码      byte [] buf=Base64.decodeBase64(data);      byte[] bt = decrypt(buf,key.getBytes());      return new String(bt,UTF8);    }    /**     * Description 根据键值进行加密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    private static byte[] encrypt(byte[] data, byte[] key) throws Exception {      // 生成一个可信任的随机数源      SecureRandom sr = new SecureRandom();      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容      DESKeySpec dks = new DESKeySpec(key);      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。      // 这里改为使用单例模式      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥) 对象。      SecretKey securekey = keyFactory.generateSecret(dks);      // Cipher对象实际完成加密操作,此类为加密和解密提供密码功能      Cipher cipher = Cipher.getInstance(DES);      // 用密钥和随机源初始化此 Cipher。ENCRYPT_MODE用于将 Cipher 初始化为加密模式的常量。      cipher.init(Cipher.ENCRYPT_MODE, securekey, sr);      //正式执行加密操作      return cipher.doFinal(data);    }    /**     * Description 根据键值进行解密     * @param data     * @param key 加密键byte数组     * @return     * @throws Exception     */    private static byte[] decrypt(byte[] data, byte[] key) throws Exception {      // 生成一个可信任的随机数源      SecureRandom sr = new SecureRandom();      // 从原始密钥数据创建DESKeySpec对象，也就是创建秘钥的秘钥内容      DESKeySpec dks = new DESKeySpec(key);      // 密钥工厂用来将密钥（类型 Key 的不透明加密密钥）转换为密钥规范（底层密钥材料的透明表示形式），反之亦然。秘密密钥工厂只对秘密（对称）密钥进行操作。      // 这里改为使用单例模式      //SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);      //根据提供的密钥规范（密钥材料）生成 SecretKey(秘钥)对象。      SecretKey securekey = keyFactory.generateSecret(dks);      // Cipher类为加密和解密提供密码功能      Cipher cipher = Cipher.getInstance(DES);      // DECRYPT_MODE用于将 Cipher 初始化为解密模式的常量。      cipher.init(Cipher.DECRYPT_MODE, securekey, sr);      // 正式进行解密操作      return cipher.doFinal(data);    }}

package com.soufun.com;import java.io.IOException;import java.security.NoSuchAlgorithmException;import java.util.Date;import java.util.HashMap;import java.util.Map;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.SecretKeyFactory;import javax.crypto.spec.DESKeySpec;import javax.crypto.spec.IvParameterSpec;/** *@author WHD * */public class DESCrypt {  static SecretKeyFactory secretKeyFactory = null;  //Cipher 的“算法/模式/填充”  static final String CIPHER = "DES/CBC/PKCS5Padding";  static {    try {      // 在静态代码块中获取秘钥工程      secretKeyFactory = SecretKeyFactory.getInstance("DES");    } catch (NoSuchAlgorithmException e) {      e.printStackTrace();    }  }  // 定义常量 ，编码格式  private static final String UTF8 = "GBK";  /*   * 对象缓存的容器   */  static abstract class Cache {    private final Map innerCache = new HashMap();    protected abstract Object createValue(Object key) throws Exception;    public Object get(Object key) throws Exception {      Object value;      synchronized (innerCache) {        value = innerCache.get(key);        if (value == null) {          value = new CreationPlaceholder();          innerCache.put(key, value);        }      }      if (value instanceof CreationPlaceholder) {        synchronized (value) {          CreationPlaceholder progress = (CreationPlaceholder) value;          if (progress.value == null) {            progress.value = createValue(key);            synchronized (innerCache) {              innerCache.put(key, progress.value);            }          }          return progress.value;        }      }      return value;    }    static final class CreationPlaceholder {      Object value;    }  }  /*   * hex->str & str->hex   */  public static byte[] stringToHex(String ss) {    // 字符串转化we    byte digest[] = new byte[ss.length() / 2];    for (int i = 0; i < digest.length; i++) {      String byteString = ss.substring(2 * i, 2 * i + 2);      int byteValue = Integer.parseInt(byteString, 16);      digest[i] = (byte) byteValue;    }    return digest;  }  public static String hexToString(byte b[]) {    StringBuffer hexString = new StringBuffer();    for (int i = 0; i < b.length; i++) {      String plainText = Integer.toHexString(0xff & b[i]);      if (plainText.length() < 2) {        hexString.append("0");      }      hexString.append(plainText);    }    return hexString.toString();  }  private static byte[] _convertKeyIv(String text) throws IOException {    if (text.length() == 8) {      return text.getBytes(UTF8);    }    if (text.startsWith("0x") && text.length() == 32) {      byte[] result = new byte[8];      for (int i = 0; i < text.length(); i += 2) {        if (text.charAt(i++) == '0' && text.charAt(i++) == 'x') {          try {            result[i / 4] = (byte) Integer.parseInt(                text.substring(i, i + 2), 16);          } catch (Exception e) {            throw new IOException("TXT '" + text + "' is invalid!");          }        }      }      return result;    }    throw new IOException("TXT '" + text + "' is invalid!");  }  /*   * SecretKey & IvParameterSpec的缓存   */  private static Cache SecretKeySpecs = new Cache() {    protected Object createValue(Object key) throws Exception {      SecretKey secretKeyObj = null;      try {        secretKeyObj = secretKeyFactory.generateSecret(new DESKeySpec(            _convertKeyIv((String) key)));      } catch (Exception e) {        e.printStackTrace();      }      return secretKeyObj;    }  };  private static Cache IvParamSpecs = new Cache() {    protected Object createValue(Object key) throws Exception {      IvParameterSpec ivObj = null;      ivObj = new IvParameterSpec(_convertKeyIv((String) key));      return ivObj;    }  };  /*   * 加密&解密   */  public static String encrypt(String text, String authKey, String authIv) {    SecretKey secretKeyObj = null;    IvParameterSpec ivObj = null;    try {      secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);      ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);    } catch (Exception e) {      e.printStackTrace();    }    byte[] data = null;    try {      data = text.getBytes(UTF8);    } catch (Exception e) {      e.printStackTrace();    }    byte[] authToken = null;    try {      authToken = encrypt(data, secretKeyObj, ivObj);    } catch (Exception e) {      e.printStackTrace();    }    return hexToString(authToken);  }  public static byte[] encrypt(byte[] data, SecretKey secretKey,      IvParameterSpec iv) throws Exception {    Cipher cipher = Cipher.getInstance(CIPHER);    cipher.init(Cipher.ENCRYPT_MODE, secretKey, iv);    return cipher.doFinal(data);  }  public static String decrypt(String hexString, String authKey, String authIv)      throws Exception {    SecretKey secretKeyObj = null;    IvParameterSpec ivObj = null;    try {      secretKeyObj = (SecretKey) SecretKeySpecs.get(authKey);      ivObj = (IvParameterSpec) IvParamSpecs.get(authIv);    } catch (Exception e) {      e.printStackTrace();    }    String text = decrypt(hexString, secretKeyObj, ivObj);    return text;  }  public static String decrypt(String message, SecretKey secretKey,      IvParameterSpec iv) throws Exception {    byte[] data = stringToHex(message);    return decrypt(data, secretKey, iv);  }  public static String decrypt(byte[] data, SecretKey secretKey,      IvParameterSpec iv) throws Exception {    Cipher cipher = Cipher.getInstance(CIPHER);    cipher.init(Cipher.DECRYPT_MODE, secretKey, iv);    byte[] retByte = cipher.doFinal(data);    return new String(retByte);  }  public static void main(String[] args) throws Exception {    long begin= new Date().getTime();    String authKey = "w8f3k9c2";    String authIv = "w8f3k9c2";    String text = "aaades加密测试";    // 140CB412BA03869F    // 140cb412ba03869f    // 对原文进行加密    String encryptedText = encrypt(text, authKey, authIv);    System.out.println("encryptedText:" + encryptedText);    // 对密文进行还原    String plainText = decrypt(encryptedText, authKey, authIv);    System.out.println("plainText:" + plainText);    //2a329740ce15f549be64190b183a5be2    long end =new Date().getTime();    System.out.println(end-begin);  }}