DESCBC加密參考:點選開啟連結

public class TripleDESUtil    {

字元轉換參考之前一片博文點選開啟連結

    /**
     * 加密位元組陣列
     *
     * @param arrB 需加密的位元組陣列
     * @return 加密後的位元組陣列
     * @throws Exception
     */
private static byte[] encrypt(byte[] arrB) throws Exception {
        return encryptCipher.doFinal(arrB);
    }

    /**
 
     * 加密字串
     *
     * @param strIn 需加密的字串
     * @return 加密後的字串
     * @throws Exception
     */
public static String encrypt(String strIn) {
        String encryptStr = "";

        if (null == encryptCipher || null == decryptCipher) {
            try {
                init();
            } catch 
 
(Exception e) {
            }
        }
        try {
            encryptStr = byteArr2HexStr(encrypt(strIn.getBytes()));
        } catch (Exception e) {
        }

        return encryptStr;
    }

    /*定義DES加密\解密初始化方法*/
private static void init() throws Exception {
        Security.addProvider(new 
 
com.sun.crypto.provider.SunJCE());
        Key key = getKey(strDefaultKey.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
     */
private static byte[] decrypt(byte[] arrB) throws Exception {
        return decryptCipher.doFinal(arrB);
    }

    /**
     * 解密字串
     *
     * @param strIn 需解密的字串
     * @return 解密後的字串
     * @throws Exception
     */
public static String decrypt(String strIn) {
        String decryptStr = "";
        if (null == encryptCipher || null == decryptCipher) {
            try {
                init();
            } catch (Exception e) {
            }
        }

        try {
            decryptStr = new String(decrypt(hexStr2ByteArr(strIn)));
        } catch (Exception e) {
        }

        return decryptStr;
    }

    /**
     * 從指定字串生成DES金鑰，DES金鑰所需的位元組陣列長度為8位 不足8位時後面補0，超出8位只取前8位
     *
     * @param arrBTmp 構成該字串的位元組陣列
     * @return 生成的金鑰
     * @throws java.lang.Exception
     */
private static 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;
    }

    // 3DESECB加密,key必須是長度大於等於 3*8 = 24 位哈
public static String encryptThreeDESECB(String src, String key) throws Exception {
        // 生成金鑰
DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("UTF-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
        SecretKey securekey = keyFactory.generateSecret(dks);
        // 3DES/ECB/無填充方式加密(必須保證引數位元組是8的整數倍,否則報錯)
Cipher cipher = Cipher.getInstance("DESede/ECB/NOPadding");
        cipher.init(Cipher.ENCRYPT_MODE, securekey);
        byte[] b = cipher.doFinal(binStrToByteArr(src));
        /*轉為二進位制字串形式, 方便入庫*/
return byteArrToBinStr(b);
    }

    // 3DESECB解密,key必須是長度大於等於 3*8 = 24 位哈
public static String decryptThreeDESECB(byte[] src, String key) throws Exception {
        // --解密的key
DESedeKeySpec dks = new DESedeKeySpec(key.getBytes("UTF-8"));
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DESede");
        SecretKey securekey = keyFactory.generateSecret(dks);
        // 生成金鑰
        //SecretKey deskey  = new SecretKeySpec(hexStr2ByteArr(key),"DESede");
        // 3DES/ECB/無填充方式解密
Cipher c1 = Cipher.getInstance("DESede/ECB/NOPadding");
        // --Chipher物件解密
        //Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
c1.init(Cipher.DECRYPT_MODE, securekey);
        byte[] retByte = c1.doFinal(src);
        /*轉為二進位制字串*/
return byteArrToBinStr(retByte);
    }

    /*
     * 根據字串生成3DES解密金鑰 要求24位位元組陣列
     * @param keyStr 金鑰字串
     * @return
     * @throws UnsupportedEncodingException
     */
public static byte[] build3DesKey(String keyStr) throws Exception {
        byte[] key = new byte[24];    //宣告一個24位的位元組陣列，預設裡面都是0
byte[] temp = keyStr.getBytes("UTF-8");    //將普通字串轉成位元組陣列
//        byte[] temp = hexStr2ByteArr(keyStr);    //將16進位制字串轉成位元組陣列
        /*
         * 執行陣列拷貝
         * System.arraycopy(源陣列，從源陣列哪裡開始拷貝，目標陣列，拷貝多少位)
         */
if (key.length > temp.length) {
            //如果temp不夠24位，則拷貝temp陣列整個長度的內容到key陣列中
System.arraycopy(temp, 0, key, 0, temp.length);
        } else {
            //如果temp大於24位，則拷貝temp陣列24個長度的內容到key陣列中
System.arraycopy(temp, 0, key, 0, key.length);
        }
        return key;
    }

}