DesUtils 加解密類使用

/**
 * 加密解密類
 */

import javax.crypto.Cipher;
import java.security.Key;
import java.text.SimpleDateFormat;
import java.util.Date;


public class DesUtils {

    /**
     * 字符串默認鍵值
     */
    private static String strDefaultKey = "national";

    /**
     * 加密工具
     */
    private Cipher encryptCipher = null;

    /**
     * 解密工具
     */
    private Cipher decryptCipher = null;

    /**
     * 將byte數組轉換為表示16進制值的字符串， 如：byte[]{8,18}轉換為：0813， 和public static byte[]
     * hexStr2ByteArr(String strIn) 互為可逆的轉換過程
     *
     * @param arrB 需要轉換的byte數組
     * @return 轉換后的字符串
     * @throws Exception 本方法不處理任何異常，所有異常全部拋出
     */
    public static String byteArr2HexStr(byte[] arrB) throws Exception {
        int iLen = arrB.length;
        // 每個byte用兩個字符才能表示，所以字符串的長度是數組長度的兩倍
        StringBuffer sb = new StringBuffer(iLen * 2);
        for (int i = 0; i < iLen; i++) {
            int intTmp = arrB[i];
            // 把負數轉換為正數
            while (intTmp < 0) {
                intTmp = intTmp + 256;
            }
            // 小於0F的數需要在前面補0
            if (intTmp < 16) {
                sb.append("0");
            }
            sb.append(Integer.toString(intTmp, 16));
        }
        return sb.toString();
    }

    /**
     * 將表示16進制值的字符串轉換為byte數組， 和public static String byteArr2HexStr(byte[] arrB)
     * 互為可逆的轉換過程
     *
     * @param strIn 需要轉換的字符串
     * @return 轉換后的byte數組
     * @throws Exception 本方法不處理任何異常，所有異常全部拋出
     * @author <a href="mailto:[e-mail]">LiGuoQing</a>
     */
    public static byte[] hexStr2ByteArr(String strIn) throws Exception {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;

        // 兩個字符表示一個字節，所以字節數組長度是字符串長度除以2
        byte[] arrOut = new byte[iLen / 2];
        for (int i = 0; i < iLen; i = i + 2) {
            String strTmp = new String(arrB, i, 2);
            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
        }
        return arrOut;
    }

    /**
     * 默認構造方法，使用默認密鑰
     *
     * @throws Exception
     */
    public DesUtils() throws Exception {
        this(strDefaultKey);
    }

    /**
     * 指定密鑰構造方法
     * 由指定的秘鑰生成加密器和解密器
     *
     * @param strKey 指定的密鑰
     * @throws Exception
     */
    public DesUtils(String strKey) throws Exception {
        Key key = getKey(strKey.getBytes());

        encryptCipher = Cipher.getInstance("DES");
        encryptCipher.init(Cipher.ENCRYPT_MODE, key);

        decryptCipher = Cipher.getInstance("DES");
        decryptCipher.init(Cipher.DECRYPT_MODE, key);
    }

    /**
     * 加密字節數組
     *
     * @param arrB 需加密的字節數組
     * @return 加密后的字節數組
     * @throws Exception
     */
    public byte[] encrypt(byte[] arrB) throws Exception {
        return encryptCipher.doFinal(arrB);
    }

    /**
     * 加密字符串
     *
     * @param strIn 需加密的字符串
     * @return 加密后的字符串
     * @throws Exception
     */
    public String encrypt(String strIn) throws Exception {
        return byteArr2HexStr(encrypt(strIn.getBytes()));
    }

    /**
     * 解密字節數組
     *
     * @param arrB 需解密的字節數組
     * @return 解密后的字節數組
     * @throws Exception
     */
    public byte[] decrypt(byte[] arrB) throws Exception {
        return decryptCipher.doFinal(arrB);
    }

    /**
     * 解密字符串
     *
     * @param strIn 需解密的字符串
     * @return 解密后的字符串
     * @throws Exception
     */
    public String decrypt(String strIn) throws Exception {
        return new String(decrypt(hexStr2ByteArr(strIn)));
    }

    /**
     * 從指定字符串生成密鑰，密鑰所需的字節數組長度為8位 不足8位時后面補0，超出8位只取前8位
     *
     * @param arrBTmp 構成該字符串的字節數組
     * @return 生成的密鑰
     * @throws Exception
     */
    private Key getKey(byte[] arrBTmp) throws Exception {
        // 創建一個空的8位字節數組（默認值為0）
        byte[] arrB = new byte[8];

        // 將原始字節數組轉換為8位
        for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
            arrB[i] = arrBTmp[i];
        }

        // 生成密鑰
        Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");

        return key;
    }

    /**
     * 明文轉密文
     *
     * @throws Exception
     */
    public static String password(String str) {
        DesUtils des;
        try {
            if (str == null || str.trim().equals("")) return "";
            des = new DesUtils("mmid");
            String password = des.encrypt(str);
            return password;
        } catch (Exception e) {
            return str;
        }//自定義密鑰
    }

    public static String password(String str, String key) throws Exception {
        DesUtils des = new DesUtils(key);
        String password = des.encrypt(str);
        return password;
    }

    /**
     * 密文轉明文
     *
     * @throws Exception
     */
    public static String clear(String str) {
        DesUtils des;
        //自定義密鑰
        try {
            des = new DesUtils("fgh");
            String clear = des.decrypt(str);
            return clear;
        } catch (Exception e) {
            return "";
        }
    }

    public static String clear(String str, String key) {
        // Decript de = new Decript();
        //    String mmid =(String) de.getData().getMap().get("mmid");
        String mmid = "fgh";
        key = mmid;
        DesUtils des = null;
        try {
            des = new DesUtils(key);
        } catch (Exception e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        String clear = null;
        try {
            clear = des.decrypt(str);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return clear;
    }


    /**
     * 購買產品時生成的產品密鑰（主要作為廣告查詢工具密鑰使用）
     *
     * @param userIdentifier-用戶唯一編碼（7位）
     * @param key-0為官網購買，1為工具生成（1位）
     * @param StaffIdentifier-員工編號（4位，默認8011，區分是在員工那里購買的）
     * @param agencyIdentifier-代理編號（5位，默認10000，區分在代理那里購買的）
     * @param discount-折扣(2位）
     * @param buying-購買時間，換算成1,2,3天數
     */
    public static String createSecretKey(String userIdentifier, int key, int softwareType, String StaffIdentifier, String agencyIdentifier, String discount, int buying) {
        String secretKey = null;
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        String nowtime = sdf.format(date);
        secretKey = password(userIdentifier + key + softwareType + nowtime + StaffIdentifier + agencyIdentifier + discount + buying);
        return secretKey;
    }

    public static String createSecretKey(String nickname,
                                         Double preferentialPrice, String staffIdentifier, String type,
                                         String date) {
        StringBuffer secStr = new StringBuffer();
        secStr.append(nickname).append(">")
                .append(preferentialPrice.intValue()).append(">")
                .append(staffIdentifier).append(">").append(type).append(">")
                .append(date);
        try {
            DesUtils des = new DesUtils("driver");
//       System.out.println(secStr);
            String sec = des.encrypt(secStr.toString());
//       System.out.println(sec);
            return sec;
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }
}