這幾天研究了一下android方面的加密技術，有RSA，md5，base64，AES等以及這幾種加密的混合加密，其他還好，在RSA和AES混合加密的時候出現點問題，就拿出來說一下。

        遇到的問題是，從網上找到的AES工具類大多數時base64編碼輸出格式的，所以一般情況下，與後臺配合使用的時候，加密結果不一致，甚至是解密後臺傳過來的密文失敗，同樣的內容，同樣的金鑰，加密出來的結果卻一直在變化（是整個字串都在變，沒有固定不變的部分）這個一直沒找到原因，後來瞭解到還有hex編碼的輸出格式，就驗證了一下，問題就解決了，以下是兩個工具類程式碼：

base64編碼輸出：

/**
 * AES
 */
public class AESUtils {
	public static String encrypt(String encodeRules,String content){
        try {
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            SecretKey original_key=keygen.generateKey();
            byte [] raw=original_key.getEncoded();
            SecretKey key=new SecretKeySpec(raw, "AES");
            Cipher cipher=Cipher.getInstance("AES");
            cipher.init(Cipher.ENCRYPT_MODE, key);
            byte [] byte_encode=content.getBytes("utf-8");
            byte [] byte_AES=cipher.doFinal(byte_encode);
            String AES_encode=new String(TranscoderUtils.encodeBase64(byte_AES));
            return AES_encode;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
       
        return null;         
    }
    
    public static String decrypt(String encodeRules,String content){
        try {
            KeyGenerator keygen=KeyGenerator.getInstance("AES");
            keygen.init(128, new SecureRandom(encodeRules.getBytes()));
            SecretKey original_key=keygen.generateKey();
            byte [] raw=original_key.getEncoded();
            SecretKey key=new SecretKeySpec(raw, "AES");
            Cipher cipher=Cipher.getInstance("AES");
            cipher.init(Cipher.DECRYPT_MODE, key);
            byte [] byte_content= TranscoderUtils.decodeBase64(content);
            byte [] byte_decode=cipher.doFinal(byte_content);
            String AES_decode=new String(byte_decode,"utf-8");
            return AES_decode;
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        
        return null;         
    }
}
 

public class AES {

    static final String algorithmStr = "AES/ECB/PKCS5Padding";

    private static final Object TAG = "AES";

    static private KeyGenerator keyGen;

    static private Cipher cipher;

    static boolean isInited = false;
      
      private static  void init() {
        try { 
                /**為指定演算法生成一個 KeyGenerator 物件。
                *此類提供（對稱）金鑰生成器的功能。
                *金鑰生成器是使用此類的某個 getInstance 類方法構造的。
                *KeyGenerator 物件可重複使用，也就是說，在生成金鑰後，
                *可以重複使用同一 KeyGenerator 物件來生成進一步的金鑰。
                *生成金鑰的方式有兩種：與演算法無關的方式，以及特定於演算法的方式。
                *兩者之間的惟一不同是物件的初始化：
                *與演算法無關的初始化
                *所有金鑰生成器都具有金鑰長度 和隨機源 的概念。
                *此 KeyGenerator 類中有一個 init 方法，它可採用這兩個通用概念的引數。
                *還有一個只帶 keysize 引數的 init 方法，
                *它使用具有最高優先順序的提供程式的 SecureRandom 實現作為隨機源
                *（如果安裝的提供程式都不提供 SecureRandom 實現，則使用系統提供的隨機源）。
                *此 KeyGenerator 類還提供一個只帶隨機源引數的 inti 方法。
                *因為呼叫上述與演算法無關的 init 方法時未指定其他引數，
                *所以由提供程式決定如何處理將與每個金鑰相關的特定於演算法的引數（如果有）。
                *特定於演算法的初始化
                *在已經存在特定於演算法的引數集的情況下，
                *有兩個具有 AlgorithmParameterSpec 引數的 init 方法。
                *其中一個方法還有一個 SecureRandom 引數，
                *而另一個方法將已安裝的高優先順序提供程式的 SecureRandom 實現用作隨機源
                *（或者作為系統提供的隨機源，如果安裝的提供程式都不提供 SecureRandom 實現）。
                *如果客戶端沒有顯式地初始化 KeyGenerator（通過呼叫 init 方法），
                *每個提供程式必須提供（和記錄）預設初始化。
                */
            keyGen = KeyGenerator.getInstance("AES");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        // 初始化此金鑰生成器，使其具有確定的金鑰長度。
        keyGen.init(128); //128位的AES加密
        try {    
                // 生成一個實現指定轉換的 Cipher 物件。
            cipher = Cipher.getInstance(algorithmStr);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        }
        //標識已經初始化過了的欄位
        isInited = true;
    }

    private static byte[] genKey() {
        if (!isInited) {
            init();  
        }
        //首先 生成一個金鑰(SecretKey),
        //然後,通過這個祕鑰,返回基本編碼格式的金鑰，如果此金鑰不支援編碼，則返回 null。 
        return keyGen.generateKey().getEncoded();
    }

    private static byte[] encrypt(byte[] content, byte[] keyBytes) {
        byte[] encryptedText = null;
        if (!isInited) { 
            init();
        }
        /**
        *類 SecretKeySpec
        *可以使用此類來根據一個位元組陣列構造一個 SecretKey，
        *而無須通過一個（基於 provider 的）SecretKeyFactory。
        *此類僅對能表示為一個位元組陣列並且沒有任何與之相關聯的鑰引數的原始金鑰有用 
        *構造方法根據給定的位元組陣列構造一個金鑰。
        *此構造方法不檢查給定的位元組陣列是否指定了一個演算法的金鑰。
        */
        Key key = new SecretKeySpec(keyBytes, "AES");
        try {
                // 用金鑰初始化此 cipher。
            cipher.init(Cipher.ENCRYPT_MODE, key);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
        try {
                //按單部分操作加密或解密資料，或者結束一個多部分操作。(不知道神馬意思)
            encryptedText = cipher.doFinal(content);
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        return encryptedText;
    }

    private static byte[] encrypt(String content, String password) {
        try {
            byte[] keyStr = getKey(password);
            SecretKeySpec key = new SecretKeySpec(keyStr, "AES");
            Cipher cipher = Cipher.getInstance(algorithmStr);//algorithmStr          
            byte[] byteContent = content.getBytes("utf-8");
            cipher.init(Cipher.ENCRYPT_MODE, key);//   ʼ  
            byte[] result = cipher.doFinal(byteContent);
            return result; //     
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        return null;
    }
 
    private static byte[] decrypt(byte[] content, String password) {
        try {
            byte[] keyStr = getKey(password);
            SecretKeySpec key = new SecretKeySpec(keyStr, "AES");
            Cipher cipher = Cipher.getInstance(algorithmStr);//algorithmStr           
            cipher.init(Cipher.DECRYPT_MODE, key);//   ʼ  
            byte[] result = cipher.doFinal(content);
            return result; //     
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (NoSuchPaddingException e) {
            e.printStackTrace();
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        } catch (IllegalBlockSizeException e) {
            e.printStackTrace();
        } catch (BadPaddingException e) {
            e.printStackTrace();
        }
        return null;
    }
    
    private static byte[] getKey(String password) {
        byte[] rByte = null;
        if (password!=null) {
            rByte = password.getBytes();
        }else{
            rByte = new byte[24];
        }
        return rByte;
    }

    /**
     * 將二進位制轉換成16進位制
     * @param buf
     * @return
     */
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 將16進位制轉換為二進位制
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null; 
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2),
                    16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }
    
        //注意: 這裡的password(祕鑰必須是16位的)
    private static final String keyBytes = "abcdefgabcdefg12"; 
    
    /**
    *加密
    */
    public static String encode(String content){
            //加密之後的位元組陣列,轉成16進位制的字串形式輸出
        return parseByte2HexStr(encrypt(content, keyBytes));
    }
    
    /**
    *解密
    */
    public static String decode(String content){
            //解密之前,先將輸入的字串按照16進位制轉成二進位制的位元組陣列,作為待解密的內容輸入
        byte[] b = decrypt(parseHexStr2Byte(content), keyBytes);
        return new String(b);
    }
    
    //測試用例
    public static void test1(){
        String content = "hello abcdefggsdfasdfasdf";
        String pStr = encode(content );
        System.out.println("加密前："+content);
        System.out.println("加密後:" + pStr);
        
        String postStr = decode(pStr);
        System.out.println("解密後："+ postStr );
    }
    
    public static void main(String[] args) {
        test1();
    }
}
 

hex這種是將加密後的byte陣列進行16進位制轉換，然後再轉換成字串的形式，這樣的話，就會與後臺加密的結果一致了，並且相關AES線上加密解密網站，也都能成功解密出對應內容

下面是demo連結