【Java】通過DES加密和解密工具，對字符串進行加密和解密操作

分享一個非常不錯的字符串加密和解密的程序。

可以指定不同的密鑰對同一字符串進行不同的加密操作，增強加密性能。

Java代碼如下：

    package com.app;  

    import java.security.Key;  
    import java.security.Security;  
    import javax.crypto.Cipher;  
    /** 
     * DES加密和解密工具,可以對字符串進行加密和解密操作  。  
     */  
    public class Test4 {  
        /** 
         * 默認構造方法，使用默認密鑰 
         */  
        public Test4() throws Exception {  
            this(strDefaultKey);  
        }  
        /** 
         * 指定密鑰構造方法 
         * @param strKey  指定的密鑰 
         * @throws Exception 
         */  
        public Test4(String strKey) throws Exception {  
            // Security.addProvider(new com.sun.crypto.provider.SunJCE());  
            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);  
        }  
        /** 字符串默認鍵值 */  
        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數組 
         */  
        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;  
        }  
        /** 
         * 加密字節數組 
         * @param arrB  需加密的字節數組 
         * @return 加密后的字節數組 
         */  
        public byte[] encrypt(byte[] arrB) throws Exception {  
            return encryptCipher.doFinal(arrB);  
        }  
        /** 
         * 加密字符串 
         * @param strIn  需加密的字符串 
         * @return 加密后的字符串 
         */  
        public String encrypt(String strIn) throws Exception {  
            return byteArr2HexStr(encrypt(strIn.getBytes()));  
        }  
        /** 
         * 解密字節數組 
         * @param arrB  需解密的字節數組 
         * @return 解密后的字節數組 
         */  
        public byte[] decrypt(byte[] arrB) throws Exception {  
            return decryptCipher.doFinal(arrB);  
        }  
        /** 
         * 解密字符串 
         * @param strIn  需解密的字符串 
         * @return 解密后的字符串 
         */  
        public String decrypt(String strIn) throws Exception {  
            return new String(decrypt(hexStr2ByteArr(strIn)));  
        }  
        /** 
         * 從指定字符串生成密鑰，密鑰所需的字節數組長度為8位 不足8位時后面補0，超出8位只取前8位 
         * @param arrBTmp  構成該字符串的字節數組 
         * @return 生成的密鑰 
         */  
        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;  
        }  
        public static void main(String[] args) {  
            try {  
                String test1 = "987654321";  
                Test4 des1 = new Test4();// 使用默認密鑰  
                System.out.println("加密前的字符：" + test1);  
                System.out.println("加密后的字符：" + des1.encrypt(test1));  
                System.out.println("解密后的字符：" + des1.decrypt(des1.encrypt(test1)));  

                String test2 = "123456789";  
                Test4 des2 = new Test4("leeme32nz");// 自定義密鑰  
                System.out.println("加密前的字符：" + test2);  
                System.out.println("加密后的字符：" + des2.encrypt(test2));  
                System.out.println("解密后的字符：" + des2.decrypt(des2.encrypt(test2)));  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    }  

運行結果：

    加密前的字符：987654321  
    加密后的字符：5579cb6ffef7b473e6b92e28c43dccd4  
    解密后的字符：987654321  

    加密前的字符：123456789  
    加密后的字符：beeaf4d9ae0b2b5153a02d9feb0f6a9c  
    解密后的字符：123456789  

【注】轉載自http://www.blogjava.net/vwpolo/archive/2009/12/05/304874.html