安卓AES加解密（兼容Android7.0）

相关参考

http://blog.csdn.net/q4878802/article/details/76690493
http://blog.csdn.net/drkcore/article/details/69931654
http://www.cnblogs.com/whoislcj/p/5473030.html

从网上拷贝了AES的加密代码，一丢丢，当在安卓7.0上运行时(实际上是在android7.1模拟器上跑)，直接报错了。原因是安卓的密钥生成的方式又有变动了，具体报错形如：

New versions of the Android SDK no longer support the Crypto provider.

以及接下来的xxx，错误贼多多的。简直是歪门邪道啊。

解决的方法找到了3个，实测通过了第一，第三种方式，第二种未测。

第三种方式更为完善，相对安全，但使用起来略麻烦；而第一种方式则更简洁。

注意：

本文所引代码和第三方库写死了AES加密的模式，模式为CBC模式，而其他模式是否支持我就不知道了，需要自行修改测试或另寻他法去吧。可以参见本文下方一个层主的评论。

如果对AES加密的各种细节和参数没有清晰的概念，可以到下方网址去尝试各种AES的加密模式和方法：

http://tool.chacuo.net/cryptaes

安卓上具体情况记录如下。

---

1、博客园的一篇博文

参考这篇博文以及其下的评论后干掉了上述问题：

http://www.cnblogs.com/whoislcj/p/5473030.html

不过，这里还是用了Provider，这样子似乎还是“歪门邪道”了。但是目前能够正常运行。
这个的加密结果简单一些。原文使用的 Base64 编解码工具被我用谷歌原生的工具代替。加解密时，如果想和java获得同样的结果，可能需要对这里的代码修改一下，Base64 的编解码模式可能有所不同。曾经我在安卓平台上，对 java 后台生成的 RSA密文解密就失败过，原因正是安卓 Base64 和 Java 后台的 Base64 的工作方式的结果不一致导致的。

整理的代码工具类如下：

package com.codeignis.smartled.util;

import android.text.TextUtils;
import android.util.Base64;

import java.security.Provider;
import java.security.SecureRandom;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

public class AESUtils {
    private final static String HEX = "0123456789ABCDEF";
    private  static final String CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";//AES是加密方式 CBC是工作模式 PKCS5Padding是填充模式
    private  static final String AES = "AES";//AES 加密
    private  static final String  SHA1PRNG="SHA1PRNG";// SHA1PRNG 强随机种子算法, 要区别4.2以上版本的调用方法

    /**
     * 生成随机数，可以当做动态的密钥 加密和解密的密钥必须一致，不然将不能解密
     */
    public static String generateKey() {
        try {
            SecureRandom localSecureRandom = SecureRandom.getInstance(SHA1PRNG);
            byte[] bytes_key = new byte[20];
            localSecureRandom.nextBytes(bytes_key);
            String str_key = toHex(bytes_key);
            return str_key;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    // 对密钥进行处理
    private static byte[] getRawKey(byte[] seed) throws Exception {
        KeyGenerator kgen = KeyGenerator.getInstance(AES);
        //for android
        SecureRandom sr = null;
        // 在4.2以上版本中，SecureRandom获取方式发生了改变
        int sdk_version = android.os.Build.VERSION.SDK_INT;
        if(sdk_version>23){  // Android  6.0 以上
            sr = SecureRandom.getInstance(SHA1PRNG,new CryptoProvider());
        }else if(android.os.Build.VERSION.SDK_INT >= 17){   //4.2及以上
            sr = SecureRandom.getInstance(SHA1PRNG, "Crypto");
        }else {
            sr = SecureRandom.getInstance(SHA1PRNG);
        }


        // for Java
        // secureRandom = SecureRandom.getInstance(SHA1PRNG);
        sr.setSeed(seed);
        kgen.init(128, sr); //256 bits or 128 bits,192bits
        //AES中128位密钥版本有10个加密循环，192比特密钥版本有12个加密循环，256比特密钥版本则有14个加密循环。
        SecretKey skey = kgen.generateKey();
        byte[] raw = skey.getEncoded();
        return raw;
    }

    /*
     * 加密
     */
    public static String encrypt(String key, String cleartext) {
        if (TextUtils.isEmpty(cleartext)) {
            return cleartext;
        }
        try {
            byte[] result = encrypt(key, cleartext.getBytes());
//            return Base64Encoder.encode(result);
            return new String(Base64.encode(result,Base64.DEFAULT));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
    * 加密
    */
    private static byte[] encrypt(String key, byte[] clear) throws Exception {
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
        byte[] encrypted = cipher.doFinal(clear);
        return encrypted;
    }
    /**
     * 解密
     */
    public static String decrypt(String key, String encrypted) {
        if (TextUtils.isEmpty(encrypted)) {
            return encrypted;
        }
        try {
//            byte[] enc = Base64Decoder.decodeToBytes(encrypted);
            byte[] enc = Base64.decode(encrypted,Base64.DEFAULT);
            byte[] result = decrypt(key, enc);
            return new String(result);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解密
     */
    private static byte[] decrypt(String key, byte[] encrypted) throws Exception {
        byte[] raw = getRawKey(key.getBytes());
        SecretKeySpec skeySpec = new SecretKeySpec(raw, AES);
        Cipher cipher = Cipher.getInstance(CBC_PKCS5_PADDING);
        cipher.init(Cipher.DECRYPT_MODE, skeySpec, new IvParameterSpec(new byte[cipher.getBlockSize()]));
        byte[] decrypted = cipher.doFinal(encrypted);
        return decrypted;
    }
    //二进制转字符
    public static String toHex(byte[] buf) {
        if (buf == null)
            return "";
        StringBuffer result = new StringBuffer(2 * buf.length);
        for (int i = 0; i < buf.length; i++) {
            appendHex(result, buf[i]);
        }
        return result.toString();
    }

    private static void appendHex(StringBuffer sb, byte b) {
        sb.append(HEX.charAt((b >> 4) & 0x0f)).append(HEX.charAt(b & 0x0f));
    }


    // 增加  CryptoProvider  类

    public static  class CryptoProvider extends Provider {
        /**
         * Creates a Provider and puts parameters
         */
        public CryptoProvider() {
            super("Crypto", 1.0, "HARMONY (SHA1 digest; SecureRandom; SHA1withDSA signature)");
            put("SecureRandom.SHA1PRNG",
                    "org.apache.harmony.security.provider.crypto.SHA1PRNG_SecureRandomImpl");
            put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
        }
    }
}

这个的使用方式很简单。

---

2、终极的谷歌大法，可能要参考这里：

http://blog.csdn.net/drkcore/article/details/69931654

3、github上的安卓AES加解密库：

https://github.com/tozny/java-aes-crypto

这个库可以加 salt，使密码更安全，就是朕实测之时，用于加密的 key 生成速度实在不敢恭维，可以卡住 ui 2秒钟，不知是否是朕的写法有问题还是怎么的。虽然key生成（口令 + salt —> 生成key密钥串）速度不能恭维，但是根据已经生成的key字符串进行加解密，速度杠杠，没有问题。所以，如果只保存了salt 和口令而不是生成的key字符串，妄图每次都重新构建一下key，是不理想的，会卡卡卡卡。

同样歪门邪道。

要使用这个库，首先下载或copy它：

https://github.com/tozny/java-aes-crypto/blob/master/aes-crypto/src/main/java/com/tozny/crypto/android/AesCbcWithIntegrity.java

演示结果：

11-10 19:02:13.415 23766-23766/com.example.testapplication D/>>>: 口令+salt 初始化一个密钥耗时：2262 fLRPCNVGiq6gVuoGwxm9xg==:r6zSIJVHcynb9REHTE6FdIbiUOy/i+E8o9YyKWqhrh4=

11-10 19:03:57.925 29518-29518/com.example.yue.testapplication D/>>>: 密钥串生成密钥耗时：5 fLRPCNVGiq6gVuoGwxm9xg==:r6zSIJVHcynb9REHTE6FdIbiUOy/i+E8o9YyKWqhrh4=

这个密钥串（用于解密的key）：

fLRPCNVGiq6gVuoGwxm9xg==:r6zSIJVHcynb9REHTE6FdIbiUOy/i+E8o9YyKWqhrh4=

是由口令（密码） 和 salt 进行计算形成的：

String key = AesCbcWithIntegrity.generateKeyFromPassword(“www.hao123.com”, “aabbccddeeffgghh”).toString();

这个计算相当耗时。2秒钟杠杠的。

然后，根据这个密钥加解密文字，即使是特殊的表情符，也同样搞的定，结果如下：

这个库的完整使用代码如下：

package com.example.yue.testapplication;

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.TextView;

import com.example.yue.testapplication.util.AesCbcWithIntegrity;
import com.example.yue.testapplication.util.AesCbcWithIntegrity.CipherTextIvMac;
import com.example.yue.testapplication.util.AesCbcWithIntegrity.SecretKeys;

import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private SecretKeys key;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        try {
            long time = System.currentTimeMillis();
            //生成密钥串
            key = AesCbcWithIntegrity.generateKeyFromPassword("www.hao123.com", "aabbccddeeffgghh");

            Log.d(">>>", "口令+salt 初始化一个密钥耗时：" + (System.currentTimeMillis() - time) + "        " + key);

//            key = AesCbcWithIntegrity.keys("fLRPCNVGiq6gVuoGwxm9xg==:r6zSIJVHcynb9REHTE6FdIbiUOy/i+E8o9YyKWqhrh4=");
//            Log.d(">>>", "从密钥串生成密钥耗时：" + (System.currentTimeMillis() - time) + "        " + key);

        } catch (GeneralSecurityException e) {

        }

        findViewById(R.id.button).setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        EditText etClearText = (EditText) findViewById(R.id.et_clearText);
        TextView tvResult = (TextView) findViewById(R.id.tv_result);

        StringBuilder sb = new StringBuilder();
        String enText = getEnString(etClearText.getText().toString());

        sb.append("加密结果：\n" + enText);
        Log.d(">>>", sb + "");

        sb.append("\n解密结果：\n" + getDeString(enText));
        Log.d(">>>", sb + "");


        tvResult.setText(sb.toString());
    }

/**
 * 加密
 */
    private String getEnString(String clearText) {
        try {
            CipherTextIvMac cipherTextIvMac = AesCbcWithIntegrity.encrypt(clearText, key, "utf-8");
            return cipherTextIvMac.toString();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return "";
    }


/**
 * 解密
 */
    private String getDeString(String enText) {
        try {
            CipherTextIvMac cipherTextIvMac = new AesCbcWithIntegrity.CipherTextIvMac(enText);
            return AesCbcWithIntegrity.decryptString(cipherTextIvMac, key, "utf-8");
        } catch (UnsupportedEncodingException e) {
        } catch (GeneralSecurityException e) {
        }
        return "";
    }
}

oo，以上只是示例。实际上我们可以在它的基础上封装一层。或者干脆修改掉它，这东东抓异常太多了，提供的方法也略奇葩。

对吾这等普通人来说，大概将它这样子封装来用就可以了。就提供加密，解密，密钥生成三个出入口就行，没必要弄的很复杂：

package com.example.yue.testapplication.util;

import com.example.yue.testapplication.util.AesCbcWithIntegrity.CipherTextIvMac;
import com.example.yue.testapplication.util.AesCbcWithIntegrity.SecretKeys;

import java.io.UnsupportedEncodingException;
import java.security.GeneralSecurityException;

/**
 * Created by lu on 2017/11/10 19:34
 */
public class AesUtil {


    /**
     * 生成一个key。该key用于加密明文与解密密文
     * @param password 口令
     * @param salt 盐值（密码学中的“颜值”，这玩意黑黑的）
     * @return 密钥串
     */
    public static String generateKey(String password, String salt) {
        try {
            SecretKeys key = AesCbcWithIntegrity.generateKeyFromPassword(password, salt);
            if (key != null) {
                return key.toString();
            }
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }

        return null;
    }

    public static String getEnString(String clearText, String keyStr) {
        return getEnString(clearText, keyStr, "utf-8");
    }

    /**
     * aes字符串加密
     *
     * @param clearText 待加密的明文
     * @param keyStr    密钥串
     * @param charset   字符串编码，utf-8，gbk等
     * @return 加密String（base64Iv And Cipher text）
     */
    public static String getEnString(String clearText, String keyStr, String charset) {
        try {
            SecretKeys key = AesCbcWithIntegrity.keys(keyStr);
            CipherTextIvMac cipherTextIvMac = AesCbcWithIntegrity.encrypt(clearText, key, charset);
            return cipherTextIvMac.toString();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getDeString(String cipherText, String keyStr) {
        return getDeString(cipherText, keyStr, "utf-8");
    }

    /**
     * aes解密
     *
     * @param cipherText 已使用aes加密的密文（base64Iv And Cipher text）
     * @param keyStr     密钥串
     * @param charset    字符串编码，utf-8，gbk等
     * @return 解密结果，明文
     */
    public String getDeString(String cipherText, String keyStr, String charset) {
        try {
            SecretKeys key = AesCbcWithIntegrity.keys(keyStr);
            CipherTextIvMac cipherTextIvMac = new AesCbcWithIntegrity.CipherTextIvMac(cipherText);
            return AesCbcWithIntegrity.decryptString(cipherTextIvMac, key, charset);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        return null;
    }
}

---

——the end