DES加密解密

package com.cn.peitest;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;

/**
 * @功能说明：        <BR>
 * @创建日期：2016年9月21日<BR>
 * @变更记录：<BR>
 * 1、2016年9月21日 LeoLu 更新
 */
public class DESUtil {

  /**用于建立大写的十六进制字符的输出*/
  private static final char[] DIGITS_UPPER = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
 
  /**DES向量*/
  private static final byte[] iv = {0x12, 0x34, 0x56, 0x78, (byte) 0x90, (byte) 0xab, (byte) 0xcd, (byte) 0xef};
 
  //private static final  Logger log = LoggerFactory.getLogger(DESUtil.class);
 
 
 
 
 //======================加密
  /**
   * 加密1
   * @函数名称：encrypt<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：加密字符串 <br>
   * @参数说明：xml String 加密字符串 <br>
   * @参数说明：key String 秘钥 <br>
   * @返回说明：String 返回加密后的16进制字符串
   */
  public static String encrypt(String xml, String key) {
    try {
        System.out.println("加密111111111111111111");
      return encodeHexStr(encrypt(xml.getBytes("UTF-8"), key), DIGITS_UPPER);
    } catch (Exception e) {
      System.out.println(e);
      return "";
    }
   
  }  
  /**
   * 加密2
   * @函数名称：encrypt<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：加密字节数组  <br>
   * @参数说明：arrB byte[] 需要加密的字节数组 <br>
   * @参数说明：key String 秘钥 <br>
   * @返回说明：byte[]
   */
  private static byte[] encrypt(byte[] arrB, String key) throws Exception {
      System.out.println("加密2222222222222222222222");
      return converCrypt(arrB, key, true);  
  }
  /**
   * 加密3  解密4
   * @函数名称：converCrypt<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：将16位的字节数据进行加密或解密 <br>
   * @参数说明： arrB byte[] 需要加密的字节数组<br>
   * @参数说明： key String 秘钥<br>
   * @参数说明：encrypt boolean是否加密，true加密，false解密 <br>
   * @返回说明：byte[] 返回16进制字节数组
   */
  private static byte[] converCrypt(byte[] arrB, String key, boolean encrypt) throws Exception{
    
    String vikey = MD5.sign(key).substring(0, 8).toUpperCase();
    DESKeySpec desKeySpec = new DESKeySpec(vikey.getBytes());  
    SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");  
    SecretKey secretKey = keyFactory.generateSecret(desKeySpec);  
    IvParameterSpec ivp = new IvParameterSpec(vikey.getBytes());  
    Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
   
    /**加密*/
    if (encrypt == true) {
      cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivp);
      System.out.println("加密33333333333333333333333");
    } else{
      /**解密*/
      cipher.init(Cipher.DECRYPT_MODE, secretKey, ivp);  
    }
    return cipher.doFinal(arrB);
    
  }
  /**
   * 加密4  解密5
   * @函数名称：encodeHexStr<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：将16进制字节数组转换为十六进制字符串 <br>
   * @参数说明：data byte[] 16进制字节数组 <br>
   * @参数说明：toDigits char[] 向量 <br>
   * @返回说明：String 返回16进制字符串
   */
  private static String encodeHexStr(byte[] data, char[] toDigits) {
      System.out.println("加密44444444444444");
     return new String(encodeHex(data, toDigits));
 }
  /**
   * 加密5 解密6
   * @函数名称：encodeHex<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明： 将字节数组转换为十六进制字节数组 <br>
   * @参数说明：data byte[] 字节数组<br>
   * @参数说明：toDigits char[] 向量<br>
   * @返回说明：十六进制char[]
   */
  private static char[] encodeHex(byte[] data, char[] toDigits) {
      int l = data.length;
      char[] out = new char[l << 1];
      for (int i = 0, j = 0; i < l; i++) {
          out[j++] = toDigits[(0xF0 & data[i]) >>> 4];
          out[j++] = toDigits[0x0F & data[i]];
      }
      System.out.println("加密55555555555555555555");
      return out;
  }
  
  
//解密======================

  
  /**
   * 解密1
   * @函数名称：decrypt<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：解密16进制字符串  <br>
   * @参数说明： desStr String 需要解密的16进制字符串<br>
   * @参数说明： key String 秘钥<br>
   * @返回说明：String 返回解密后的10进制字符串
   */
  public static String decrypt(String desStr, String key) {
      System.out.println("解密1111111111111111111");
    try{
      if (null == desStr || null == key) {
        return "";
      }
      String kk=hexStringToString(encodeHexStr(decrypt(hexStringToByte(new String(desStr.getBytes("UTF-8"))), key), DIGITS_UPPER));
      return kk;
    } catch (Exception e) {
      System.out.println();
      return "";
    }
   
  }
 
  /**
   * 解密2
   * @函数名称：hexStringToByte<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明：将16进制字符串转换为16进制字节数组 <br>
   * @参数说明：hex String需要转换的16进制字符串 <br>
   * @返回说明：byte[] 返回转换后的16进制字节数组
   */
  private static byte[] hexStringToByte(String hex) {
    int len = (hex.length() / 2);
    byte[] result = new byte[len];
    char[] achar = hex.toCharArray();
    for (int i = 0; i < len; i++) {
     int pos = i * 2;
     result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
    }
    System.out.println("解密22222222222222222222");
    return result;
   }
  
 
  /**
   * 解密3
   * @函数名称：decrypt<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明： 将16进制字节数组进行解密  <br>
   * @参数说明： arrB byte[] 解密字节数组<br>
   * @参数说明：key String 秘钥 <br>
   * @返回说明：byte[] 返回解密后 的16位字节数组
   */
  private static byte[] decrypt(byte[] arrB, String key) throws Exception {
      System.out.println("解密3333333333333333333333333333333");
      return converCrypt(arrB, key, false);  
  }
  
  /**
   * @函数名称：hexStringToString<br>
   * @创建日期：2016年9月21日<br>
   * @功能说明：将16进制字符串转换为10进制字符串 <br>
   * @参数说明：str String 16进制字符串 <br>
   * @返回说明：String
   */
 private static String hexStringToString(String str) {
     System.out.println("解密77777777777777777");
    if (str == null || str.equals("")) {  
        return null;  
    }  
    str = str.replace(" ", "");  
    byte[] baKeyword = new byte[str.length() / 2];  
    for (int i = 0; i < baKeyword.length; i++) {  
        try {  
            baKeyword[i] = (byte) (0xff & Integer.parseInt(  
                    str.substring(i * 2, i * 2 + 2), 16));  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
    }  
    try {  
        str = new String(baKeyword, "UTF-8");  
        new String();  
    } catch (Exception e1) {  
        e1.printStackTrace();  
    }  
    return str;  
}  
 
 
 
  /**
   * @函数名称：toByte<br>
   * @创建日期：2016年9月22日<br>
   * @功能说明： 将字符转换为字节<br>
   * @参数说明： c char 需要转换的字符<br>
   * @返回说明：int 返回字符对应的字节码
   */
  private static int toByte(char c) {
    byte b = (byte) "0123456789ABCDEF".indexOf(c);
    return b;
 }
  /**
   * @构造函数
   */
  public DESUtil() {
    // TODO Auto-generated constructor stub
  }

  /**
   * @函数名称：main<br>
   * @创建日期：2016年9月21日<br>
   * @功能说明： <br>
   * @参数说明： <br>
   * @返回说明：void
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
     try {
     System.out.println("-----------------------------");
     String bStr = "123";
     String key = "SZAOA589";
     System.out.println("加密前:"+bStr);
     String binSing = encrypt(bStr, key);
     System.out.println("加密后:"+binSing);
     System.out.println("加密結束》》》》》》》》》》》》》》》》》》》》》》》");
     System.out.println("解密后:"+decrypt(binSing, key));
     System.out.println("-------------------------");
    
    } catch (Exception e) {
      // TODO Auto-generated catch bloc
      e.printStackTrace();
    }
     //3B976A2A2919A60B57DFF3518F65E1FF
     //3B976A2A2919A60B57DFF3518F65E1FF
     /*
      * C4A737D04D0D05E2
        BD2DD4FC5050EBD0
      */
     
  }

}
//==================
package com.cn.peitest;

import java.security.MessageDigest;
import sun.misc.BASE64Encoder;
 
public class MD5 {
     // 生成MD5（截取16位长度）
    public static String sign(String message) {
        String md5 = "";
        try {
            MessageDigest md = MessageDigest.getInstance("MD5"); // 创建一个md5算法对象
            byte[] messageByte = message.getBytes("UTF-8");
            byte[] md5Byte = md.digest(messageByte); // 获得MD5字节数组,16*8=128位
            md5 = bytesToHex(md5Byte).substring(0, 16); // 转换为16进制字符串
        } catch (Exception e) {
            e.printStackTrace();
        }
        return md5;
    }

    // 二进制转十六进制
    public static String bytesToHex(byte[] bytes) {
        StringBuffer hexStr = new StringBuffer();
        int num;
        for (int i = 0; i < bytes.length; i++) {
            num = bytes[i];
            if (num < 0) {
                num += 256;
            }
            if (num < 16) {
                hexStr.append("0");
            }
            hexStr.append(Integer.toHexString(num));
        }
        return hexStr.toString().toUpperCase();
    }
}