import android.content.Context;
import android.os.Build;
import android.security.keystore.KeyGenParameterSpec;
import android.security.keystore.KeyInfo;
import android.security.keystore.KeyProperties;
import android.util.Base64;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import org.json.JSONObject;
import java.security.KeyStore;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.GCMParameterSpec;
/**
* 通过AES加密方式，用KeyGenerator生成秘钥，保存在Android Keystore中
* 对数据进行加解密
* <p>
* 1、创建秘钥，保存在AndroidKeystore里面，秘钥别名为alias
* 2、创建并初始化cipher对象，获取秘钥，对数据进行加解密
*/
class HwAesSecProvider {
private static final String TAG = "HwAesSecProvider";
private static final String KEYSTORE_AES_ALIAS = "Alias_AES_";
// 算法/模式/补码方式 不使用CBC模式，注意Padding Oracle攻击
private static final String AES_MODE = "AES/GCM/NoPadding";
private final static String KEY_IV = "iv";
private final static String KEY_DATA = "data";
private final Context context;
private final KeyStore keyStore;
public HwAesSecProvider(@NonNull final Context context, @NonNull final KeyStore keyStore) {
this.context = context;
this.keyStore = keyStore;
}
@NonNull
private static String getKeyStoreAlias(@NonNull final Context context) {
return KEYSTORE_AES_ALIAS + PrefsHelper.getPackageNameHash(context);
}
@NonNull
public String decryptAES(@NonNull final String encryptedText) {
try {
final JSONObject json = new JSONObject(encryptedText);
final byte[] iv = Base64.decode(json.optString(KEY_IV, ""), Base64.DEFAULT);
final byte[] data = Base64.decode(json.optString(KEY_DATA, ""), Base64.DEFAULT);
if (iv.length <= 0 || data.length <= 0) {
return "";
}
final KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry) keyStore.getEntry(getKeyStoreAlias(context), null);
if (null != secretKeyEntry) {
final SecretKey secretKey = secretKeyEntry.getSecretKey();
//KeyGenParameterSpecs中设置的block模式是KeyProperties.BLOCK_MODE_GCM,所以这里只能使用这个模式解密数据。
final Cipher cipher = Cipher.getInstance(AES_MODE);
//需要为GCMParameterSpec 指定一个加密的block的长度(可以是128、120、112、104、96),从密钥信息中读取后填入
// 并且用到之前的加密过程中用到的IV。
final GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(getSecureKeySize(secretKey), iv, 0, iv.length);
cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmParameterSpec);
return new String(cipher.doFinal(data));
}
} catch (Throwable t) {
Logs.e(TAG, t.getMessage(), t);
}
return "";
}
@NonNull
public String encryptAES(@NonNull final String plainText) {
try {
final KeyStore.SecretKeyEntry secretKeyEntry = (KeyStore.SecretKeyEntry) keyStore.getEntry(getKeyStoreAlias(context), null);
if (null != secretKeyEntry) {
final SecretKey secretKey = secretKeyEntry.getSecretKey();
//KeyGenParameterSpecs中设置的block模式是KeyProperties.BLOCK_MODE_GCM,所以这里只能使用这个模式解密数据。
final Cipher cipher = Cipher.getInstance(AES_MODE);
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
final JSONObject json = new JSONObject();
json.put(KEY_DATA, Base64.encodeToString(cipher.doFinal(plainText.getBytes()), Base64.DEFAULT));
/*使用相同的IV多次加密不同的数据，会存在被恶意穷举的风险，我们要求硬件每次加密返回不同的加密向量IV
*这就要求我们需要存储加密数据的同时，存储返回的随机向量，然后在解密的时候提供加密时候的随机向量
*/
json.put(KEY_IV, Base64.encodeToString(cipher.getIV(), Base64.DEFAULT));
return json.toString();
}
} catch (Throwable t) {
Logs.e(TAG, t.getMessage(), t);
}
return "";
}
/*
* 目前测试发现，只能在主线程中调用，子线程中调用会出现死锁问题
**/
@MainThread
@RequiresApi(api = Build.VERSION_CODES.M)
private void generateHwAesKey_AboveApi23(@NonNull final String keystoreAlias, @NonNull final String provider) throws Exception {
final KeyGenerator keyGenerator = KeyGenerator
.getInstance(KeyProperties.KEY_ALGORITHM_AES, provider);
// https://developer.android.com/training/articles/keystore.html#SupportedCiphers)
// https://developer.android.com/reference/android/security/keystore/KeyGenParameterSpec.Builder.html#setRandomizedEncryptionRequired(boolean)).
final KeyGenParameterSpec.Builder builder = new KeyGenParameterSpec
.Builder(keystoreAlias, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
.setBlockModes(KeyProperties.BLOCK_MODE_GCM)
.setCertificateSubject(new X500Principal("CN=" + getKeyStoreAlias(context)))
.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
/*使用相同的IV多次加密不同的数据，会存在被恶意穷举的风险，我们要求硬件每次加密返回不同的加密向量IV
*这就要求我们需要存储加密数据的同时，存储返回的随机向量，然后在解密的时候提供加密时候的随机向量
*/
.setRandomizedEncryptionRequired(true); //要求硬件生成随机向量
/* 如果系统支持硬件StrongBox保存密钥，则交给StrongBox保护*/
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
builder.setIsStrongBoxBacked(hasStrongBox(context));
}
final KeyGenParameterSpec spec = builder.build();
keyGenerator.init(spec);
keyGenerator.generateKey();
}
/*
* 目前测试发现，只能在主线程中调用，子线程中调用会出现死锁问题
**/
@MainThread
public boolean generateSecStoreKeys() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
try {
generateHwAesKey_AboveApi23(getKeyStoreAlias(context), SecConst.AND_KEYSTORE_PROVIDER);
return isInsideSecureHardware();
} catch (Throwable t) {
Logs.e(TAG, t.getMessage(), t);
}
}
return false;
}
public boolean isInsideSecureHardware() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
final KeyInfo info = getKeyInfo();
if (null != info) {
return info.isInsideSecureHardware();
}
}
return false;
}
public int getSecureKeySize() {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
final KeyInfo info = getKeyInfo();
if (null != info) {
return info.getKeySize();
}
}
return 0;
}
@RequiresApi(api = Build.VERSION_CODES.M)
@Nullable
private KeyInfo getKeyInfo(@NonNull final SecretKey secretKey) throws Exception {
final SecretKeyFactory factory = SecretKeyFactory.getInstance(secretKey.getAlgorithm(), SecConst.AND_KEYSTORE_PROVIDER);
if (null != factory) {
final KeySpec spec = factory.getKeySpec(secretKey, KeyInfo.class);
if (null != spec) {
return (KeyInfo) spec;
}
}
return null;
}
private int getSecureKeySize(@NonNull final SecretKey secretKey) throws Exception {
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
final KeyInfo info = getKeyInfo(secretKey);
if (null != info) {
return info.getKeySize();
}
}
return 0;
}
@RequiresApi(api = Build.VERSION_CODES.M)
@Nullable
private KeyInfo getKeyInfo(@NonNull final String alias) {
try {
final SecretKey key = (SecretKey) keyStore.getKey(alias, null);
if (null != key) {
return getKeyInfo(key);
}
} catch (Throwable t) {
Logs.e(TAG, "Exception getting key info", t);
}
return null;
}
@RequiresApi(api = Build.VERSION_CODES.M)
@Nullable
private KeyInfo getKeyInfo() {
return getKeyInfo(getKeyStoreAlias(context));
}
/**
* Returns whether the device has a StrongBox backed KeyStore.
*/
public static boolean hasStrongBox(@NonNull final Context context) {
if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
return context.getPackageManager()
.hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE);
}
return false;
}
}