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);
 

  /**
   * @函式名稱：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]];
      }
      return out;
  }
 
 
  /**
   * @函式名稱：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) {
     return new String(encodeHex(data, toDigits));
 }
 
  /**
   * @函式名稱：hexStringToString<br>
   * @建立日期：2016年9月21日<br>
   * @功能說明：將16進位制字串轉換為10進位制字串 <br>
   * @引數說明：str String 16進位制字串 <br>
   * @返回說明：String
   */
 private static String hexStringToString(String str) {  
    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;  
}  
 
  /**
   * @函式名稱：encrypt<br>
   * @建立日期：2016年9月22日<br>
   * @功能說明：加密位元組陣列  <br>
   * @引數說明：arrB byte[] 需要加密的位元組陣列 <br>
   * @引數說明：key String 祕鑰 <br>
   * @返回說明：byte[]
   */
  private static byte[] encrypt(byte[] arrB, String key) throws Exception {  
      return converCrypt(arrB, key, true);  
  }  
 
 
  /**
   * @函式名稱：encrypt<br>
   * @建立日期：2016年9月22日<br>
   * @功能說明：加密字串 <br>
   * @引數說明：xml String 加密字串 <br>
   * @引數說明：key String 祕鑰 <br>
   * @返回說明：String 返回加密後的16進位制字串
   */
  public static String encrypt(String xml, String key) {
    try {
      return encodeHexStr(encrypt(xml.getBytes("UTF-8"), key), DIGITS_UPPER);
    } catch (Exception e) {
      System.out.println(e);
      return "";
    }
   
  }  
 
 
  /**
   * @函式名稱：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 {
      return converCrypt(arrB, key, false);  
  }
 
  /**
   * @函式名稱：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);  
    } else{
      /**解密*/
      cipher.init(Cipher.DECRYPT_MODE, secretKey, ivp);  
    }
    
    return cipher.doFinal(arrB);
    
  }
 
 
  /**
   * @函式名稱：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) {
    try{
      if (null == desStr || null == key) {
        return "";
      }
      return hexStringToString(encodeHexStr(decrypt(hexStringToByte(new String(desStr.getBytes("UTF-8"))), key), DIGITS_UPPER));
    } catch (Exception e) {
      System.out.println();
      return "";
    }
   
  }
 
  /**
   * @函式名稱：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]));
    }
    return result;
   }
 
  /**
   * @函式名稱：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";
     String binSing = encrypt(bStr, key);
     System.out.println("加密前:"+bStr);
     System.out.println("加密後:"+binSing);
     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;
 
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();
    }
}