深海游弋的鱼 – 第 10 页

Robolectric 3.x编写屏幕分辨率/多语言/资源文件相关测试用例

在编写 Android 测试用例的时候，有时候我们需要涉及到屏幕分辨率相关测试用例。

比如不同分辨率得到不同的像素数值，可以参考如下：

@RunWith(RobolectricTestRunner.class)
@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*"})
@Config(sdk = Build.VERSION_CODES.P)
public class DimensUnitTest {

    @Test
    @Config(qualifiers = "w480dp-h800dp")
    public void dimens800x480_isCorrect() {
        final Context context = RuntimeEnvironment.application;
        final double ref100DpBase = 42.666667;

        float expectDp = 110;
        double dips = context.getResources().getDimension(R.dimen.dimen_110);

        assertEquals(ref100DpBase * expectDp / 100, dips, delta);

        for (Map.Entry<Integer, Double> entry : expectDimens.entrySet()) {
            dips = context.getResources().getDimension(entry.getKey());
            assertEquals(ref100DpBase * entry.getValue() / 100, dips, delta);
        }
    }
	
}

@RunWith(RobolectricTestRunner.class)

@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*"})

@Config(sdk = Build.VERSION_CODES.P)

public class DimensUnitTest {

@Test

@Config(qualifiers = "w480dp-h800dp")

public void dimens800x480_isCorrect() {

final Context context = RuntimeEnvironment.application;

final double ref100DpBase = 42.666667;

float expectDp = 110;

double dips = context.getResources().getDimension(R.dimen.dimen_110);

assertEquals(ref100DpBase * expectDp / 100, dips, delta);

for (Map.Entry<Integer, Double> entry : expectDimens.entrySet()) {

dips = context.getResources().getDimension(entry.getKey());

assertEquals(ref100DpBase * entry.getValue() / 100, dips, delta);

}

比如不同语言得到不同的字符串，可以参考如下：

@RunWith(RobolectricTestRunner.class)
@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*"})
@Config(sdk = Build.VERSION_CODES.P)
public class LangUnitTest {

    /**
     * 使用qualifiers加载对应的资源文件
     *
     * @throws Exception
     */
    @Config(qualifiers = "zh-rCN")
    @Test
    public void testString() throws Exception {
        final Context context = RuntimeEnvironment.application;
        assertThat(context.getString(R.string.app_name), is("单元测试Demo"));
    }
	
}

@RunWith(RobolectricTestRunner.class)

@PowerMockIgnore({"org.mockito.*", "org.robolectric.*", "android.*"})

@Config(sdk = Build.VERSION_CODES.P)

public class LangUnitTest {

/**

* 使用qualifiers加载对应的资源文件

* @throws Exception

@Config(qualifiers = "zh-rCN")

@Test

public void testString() throws Exception {

final Context context = RuntimeEnvironment.application;

assertThat(context.getString(R.string.app_name), is("单元测试Demo"));

}

其他相关的测试参数，参考 Device Configuration。

注意需要在 build.gradle 中增加资源包含信息，否则在测试的时候会找不到指定的资源文件，默认只测试代码，被测试的资源文件不打包进入应用。

参考如下：

    testOptions {
        unitTests {
            includeAndroidResources = true
            all {
                //命令行下 单元测试可能卡住的问题
                jvmArgs '-noverify'
                //robolectric外部指定下载资源链接的参数，使用 -D 参数指定 bash gradlew clean build -Drobolectric.dependency.repo.url=http://127.0.0.1/jcenter
                systemProperty 'robolectric.dependency.repo.url', System.getProperty("robolectric.dependency.repo.url")
                systemProperty 'robolectric.dependency.repo.id', System.getProperty("robolectric.dependency.repo.id")
            }
        }
    }

testOptions {

unitTests {

includeAndroidResources = true

all {

//命令行下单元测试可能卡住的问题

jvmArgs '-noverify'

//robolectric外部指定下载资源链接的参数，使用 -D 参数指定 bash gradlew clean build -Drobolectric.dependency.repo.url=http://127.0.0.1/jcenter

systemProperty 'robolectric.dependency.repo.url', System.getProperty("robolectric.dependency.repo.url")

systemProperty 'robolectric.dependency.repo.id', System.getProperty("robolectric.dependency.repo.id")

}

参考链接

Android单元测试--使用DummyActivity

在编写Android测试用例的时候，有时候我们需要测试与Activity相关的功能，同时又没办法直接调用被测试代码中的Activity的时候，我们需要创建DummyActivity的方式来进行。

我们希望这个DummyActivity只在测试代码中存在，相关的资源也只存在于测试代码里面使用，不侵入主代码。

可以参考如下布局进行项目的处理。

androidTest/
├── AndroidManifest.xml
├── java
│   └── com
│       └── mobibrw
│           └── lib_phone
│               ├── MainActivityTest.java
│               ├── TestActivity.java
│               └── actions
│                   ├── HintViewAction.java
│                   ├── KeepHintViewAction.java
│                   └── SetTextViewAction.java
└── res
    ├── layout
    │   └── activity_main.xml
    └── values
        └── styles.xml

androidTest/

├── AndroidManifest.xml

├── java

│ └── com

│ └── mobibrw

│ └── lib_phone

│ ├── MainActivityTest.java

│ ├── TestActivity.java

│ └── actions

│ ├── HintViewAction.java

│ ├── KeepHintViewAction.java

│ └── SetTextViewAction.java

└── res

├── layout

│ └── activity_main.xml

└── values

└── styles.xml

上述代码同样适用于Android资源文件相关的测试逻辑。

只是需要注意的是，当引入资源的时候，我们需要使用 {module_package}.test.R 的方式进行引入，否则代码中会提示找不到资源文件。

参考链接

测试Activity的onSaveInstanceState/onRestoreInstanceState

最近遇到一个应用崩溃问题，这个问题是由于在 Activity 的 onSaveInstanceState 中进行了数据的保存，然后在 onRestoreInstanceState 进行解析的时候出现崩溃。

实际测试的时候，发现当内存充足的时候，非常难稳定的诱发 Activity 的 onSaveInstanceState 事件。

早期的版本，可以通过 ActivityManagerNative.getDefault().setAlwaysFinish 来强制系统在 Activity 切换到后台之后，立即触发 onSaveInstanceState 。

参考代码如下：

// Updates the system Always Finish setting
private void writeFinishOptions()
{
    try
    {
        // Due to restrictions related to hidden APIs, need to emulate the line below
        // using reflection:
        // ActivityManagerNative.getDefault().setAlwaysFinish(mAlwaysFinish);
        final Class   classActivityManagerNative = Class.forName("android.app.ActivityManagerNative");
        final Method     methodGetDefault = classActivityManagerNative.getMethod("getDefault");
        final Method     methodSetAlwaysFinish = classActivityManagerNative.getMethod("setAlwaysFinish", new Class[] {boolean.class});
        final Object     objectInstance = methodGetDefault.invoke(null);
        methodSetAlwaysFinish.invoke(objectInstance, new Object[]{mAlwaysFinish});
    }
    catch (Exception ex)
    {
        showAlert("Could not set always finish:\n\n" + ex, "Error");
    }
}
 
// Gets the latest AlwaysFinish value from the system and
// updates the checkbox
private void updateFinishOptions()
{
    mAlwaysFinish = Settings.System.getInt(getContentResolver(), Settings.System.ALWAYS_FINISH_ACTIVITIES, 0) != 0;
    mAlwaysFinishCB.setChecked(mAlwaysFinish);
}

// Updates the system Always Finish setting

private void writeFinishOptions()

{

try

{

// Due to restrictions related to hidden APIs, need to emulate the line below

// using reflection:

// ActivityManagerNative.getDefault().setAlwaysFinish(mAlwaysFinish);

final Class classActivityManagerNative = Class.forName("android.app.ActivityManagerNative");

final Method methodGetDefault = classActivityManagerNative.getMethod("getDefault");

final Method methodSetAlwaysFinish = classActivityManagerNative.getMethod("setAlwaysFinish", new Class[] {boolean.class});

final Object objectInstance = methodGetDefault.invoke(null);

methodSetAlwaysFinish.invoke(objectInstance, new Object[]{mAlwaysFinish});

}

catch (Exception ex)

{

showAlert("Could not set always finish:\n\n" + ex, "Error");

}

// Gets the latest AlwaysFinish value from the system and

// updates the checkbox

private void updateFinishOptions()

{

mAlwaysFinish = Settings.System.getInt(getContentResolver(), Settings.System.ALWAYS_FINISH_ACTIVITIES, 0) != 0;

mAlwaysFinishCB.setChecked(mAlwaysFinish);

}

但是遗憾的是，新系统比如 Android 8 等系统上，在真机环境中已经没办法通过上述的方法进行诱发了。系统会直接抛出异常，或者设置无效。

真机环境，可以尝试在 开发人员选项 中设置开启 “不保留活动” 按钮，如下图所示：

继续阅读测试Activity的onSaveInstanceState/onRestoreInstanceState

Android获取导航栏/状态栏/键盘的高度和状态

最近 Android 11 系统兼容性测试的时候，发现界面适配异常（标题栏沉浸式部分），已经无法通过网上流行的，通过反射方法获取状态栏的高度了。

于是翻了一下以前公共库里的代码，发现是使用如下代码获取状态栏高度的：

/** 
* 获取状态栏高度
* */  
int statusBarH = 0;  
try {  
    Class<?> clazz = Class.forName("com.android.internal.R$dimen");  
    Object object = clazz.newInstance();  
    int height = Integer.parseInt(clazz.getField("status_bar_height").get(object).toString());  
    statusBarH = getResources().getDimensionPixelSize(height);  
} catch (Exception e) {  
    e.printStackTrace();  
}  
return statusBarH;

/**

* 获取状态栏高度

* */

int statusBarH = 0;

try {

Class<?> clazz = Class.forName("com.android.internal.R$dimen");

Object object = clazz.newInstance();

int height = Integer.parseInt(clazz.getField("status_bar_height").get(object).toString());

statusBarH = getResources().getDimensionPixelSize(height);

} catch (Exception e) {

e.printStackTrace();

}

return statusBarH;

其实从 Android 9 开始，就已经对通过反射调用非公开 API 的方式进行警告了。

Android 11以前的系统,只是给出警告， Android 11直接抛出了调用异常。

于是搜索一下，发现网上已经更改成如下方法了：

int statusBarH = 0;  
//获取status_bar_height资源的ID  
int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");  
if (resourceId > 0) {  
    //根据资源ID获取响应的尺寸值  
    statusBarH = getResources().getDimensionPixelSize(resourceId);  
}  
return statusBarH;

int statusBarH = 0;

//获取status_bar_height资源的ID

int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");

if (resourceId > 0) {

//根据资源ID获取响应的尺寸值

statusBarH = getResources().getDimensionPixelSize(resourceId);

}

return statusBarH;

仔细观察两个方法，会发现，其实两者都是获取了系统里的状态栏使用的某个资源的高度信息，然后作为状态栏的高度信息。

另外，网上流传的另一段代码

Rect frame = new Rect();
getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
int statusBarHeight = frame.top;

Rect frame = new Rect();

getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);

int statusBarHeight = frame.top;

不能解决小屏模式下的显示问题，在小屏模式下得到的偏移并不是正确的状态栏高度。

这样就引发一个问题，那就是如果非官方的系统UI，比如小米，华为等自定义的UI，不使用这个资源文件，或者根本就没有这个资源文件，那么获取到的高度信息不就是不正确的了吗？

继续阅读Android获取导航栏/状态栏/键盘的高度和状态

动态Java代码注入(JDK/Android)

JDK下使用javax.tools.JavaCompiler进行动态代码的生成，编译，执行。

在本文中，我们将研究如何将Java代码动态加载到正在运行的jvm中。该代码可能是全新的，或者我们可能想更改程序中某些现有代码的功能。

（在开始之前，您可能想知道为什么到底有人会这样做。显而易见的示例是规则引擎之类的东西。规则引擎希望为用户提供添加或更改规则的能力，而不必重新启动规则。您可以通过将DSL脚本作为规则注入，由规则引擎调用此方法，这种方法的真正问题是必须对DSL脚本进行解释，使其运行起来非常缓慢。然后可以像程序中的任何其他代码一样编译和运行该程序，效率将提高几个数量级。

我们将要使用的库是Chronicle开源库Java-Runtime-Compiler 。

从下面的代码中您将看到，该库的使用极其简单-实际上，它实际上只需要几行。创建一个CachedCompiler，然后调用loadFromJava。（有关实际最简单的用例，请参见此处的文档。）

下面列出的程序执行以下操作：

创建一个线程，该线程每秒调用一次Strategy。
加载将两个数字相加的策略
等待3秒
加载从另一个数中减去一个数的策略

这是完整的代码清单：

package test;
 
import net.openhft.compiler.CachedCompiler;
 
/**
 * Loads the addingStrategy and then after 3s replaces it with the 
 * subtractingStrategy.
 */
public class DynamicJavaClassLoading {
 
    private final static String className = "test.MyClass";
    private final static String addingStrategy = "package test;\n" +
            "import test.DynamicJavaClassLoading.Strategy;\n" +
            "public class MyClass implements Strategy {\n" +
            "    public int compute(int a, int b) {\n" +
            "        return a+b;\n" +
            "    }\n" +
            "}\n";
 
    private final static String subtractingStrategy = "package test;\n" +
            "import test.DynamicJavaClassLoading.Strategy;\n" +
            "public class MyClass implements Strategy {\n" +
            "    public int compute(int a, int b) {\n" +
            "        return a-b;\n" +
            "    }\n" +
            "}\n";
    
    public static void main(String[] args) throws Exception {
        StrategyProxy strategy = new StrategyProxy();
 
        //Thread calling the strategy once a second
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println(strategy.compute(10,20));
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
 
        {
            ClassLoader cl = new ClassLoader() {
            };
            CachedCompiler cc = new CachedCompiler(null, null);
            Class aClass = cc.loadFromJava(cl, className, addingStrategy);
 
            Strategy runner = (Strategy) aClass.newInstance();
            strategy.setStratgey(runner);
        }
 
        Thread.sleep(3000);
 
        {
            ClassLoader cl = new ClassLoader() {
            };
            CachedCompiler cc = new CachedCompiler(null, null);
            Class aClass = cc.loadFromJava(cl, className, subtractingStrategy);
 
            Strategy runner = (Strategy) aClass.newInstance();
            strategy.setStratgey(runner);
        }
    }
 
    public interface Strategy{
        int compute(int a, int b);
    }
 
    public static class StrategyProxy implements Strategy{
        private volatile Strategy underlying;
 
        public void setStratgey(Strategy underlying){
            this.underlying = underlying;
        }
 
        public int compute(int a, int b){
            Strategy underlying = this.underlying;
            return underlying == null ? Integer.MIN_VALUE : underlying.compute(a, b);
        }
    }
}

package test;

import net.openhft.compiler.CachedCompiler;

/**

* Loads the addingStrategy and then after 3s replaces it with the

* subtractingStrategy.

public class DynamicJavaClassLoading {

private final static String className = "test.MyClass";

private final static String addingStrategy = "package test;\n" +

"import test.DynamicJavaClassLoading.Strategy;\n" +

"public class MyClass implements Strategy {\n" +

" public int compute(int a, int b) {\n" +

" return a+b;\n" +

" }\n" +

"}\n";

private final static String subtractingStrategy = "package test;\n" +

"import test.DynamicJavaClassLoading.Strategy;\n" +

"public class MyClass implements Strategy {\n" +

" public int compute(int a, int b) {\n" +

" return a-b;\n" +

" }\n" +

"}\n";

public static void main(String[] args) throws Exception {

StrategyProxy strategy = new StrategyProxy();

//Thread calling the strategy once a second

Thread t = new Thread(() -> {

while (true) {

System.out.println(strategy.compute(10,20));

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

});

t.start();

{

ClassLoader cl = new ClassLoader() {

};

CachedCompiler cc = new CachedCompiler(null, null);

Class aClass = cc.loadFromJava(cl, className, addingStrategy);

Strategy runner = (Strategy) aClass.newInstance();

strategy.setStratgey(runner);

}

Thread.sleep(3000);

{

ClassLoader cl = new ClassLoader() {

};

CachedCompiler cc = new CachedCompiler(null, null);

Class aClass = cc.loadFromJava(cl, className, subtractingStrategy);

Strategy runner = (Strategy) aClass.newInstance();

strategy.setStratgey(runner);

}

public interface Strategy{

int compute(int a, int b);

}

public static class StrategyProxy implements Strategy{

private volatile Strategy underlying;

public void setStratgey(Strategy underlying){

this.underlying = underlying;

}

public int compute(int a, int b){

Strategy underlying = this.underlying;

return underlying == null ? Integer.MIN_VALUE : underlying.compute(a, b);

}

这是输出：

The strategy has not been loaded yet. underlying in the StrategyProxy is null so Integer.MIN_VALUE is returned

-2 1 4 7 4 8 3 6 4 8

The adding strategy has been loaded 10+20=30

30
30
30

After 3s the subtracting strategy is loaded. It replaces the adding strategy. 10-20=-10

-10
-10
-10
-10
 
-10

The strategy has not been loaded yet. underlying in the StrategyProxy is null so Integer.MIN_VALUE is returned

-2 1 4 7 4 8 3 6 4 8

The adding strategy has been loaded 10+20=30

After 3s the subtracting strategy is loaded. It replaces the adding strategy. 10-20=-10

-10

请注意，在每次加载策略时，在代码中我们都创建了一个新的ClassLoader和一个CachedCompiler。这样做的原因是，ClassLoader一次只能加载一个特定类的一个实例。

如果仅使用该库来加载新代码，则可以这样做，而无需创建ClassLoader（即使用默认的ClassLoader）和CachedCompiler。

Class aClass = CompilerUtils.CACHED_COMPILER.loadFromJava(className, javaCode);

1	Class aClass = CompilerUtils.CACHED_COMPILER.loadFromJava(className, javaCode);

Android下使用由于无法使用javax.tools.JavaCompiler，因此使用 linkedin/dexmaker 进行动态代码的生成，编译，执行。

参考链接

[翻译]OWASP 安卓测试指南（v1.2 - 14 May 2020）节选

原文链接：
平台概述https://mobile-security.gitbook.io/mobile-security-testing-guide/android-testing-guide/0x05a-platform-overview
Android 基础安全测试https://mobile-security.gitbook.io/mobile-security-testing-guide/android-testing-guide/0x05b-basic-security_testing
Android 反逆向防御https://mobile-security.gitbook.io/mobile-security-testing-guide/android-testing-guide/0x05j-testing-resiliency-against-reverse-engineering

继续阅读[翻译]OWASP 安卓测试指南（v1.2 - 14 May 2020）节选

Android Keystore对称－非对称加密防止关键数据被克隆

背景

最近需要解决用户使用手机克隆进行手机备份，某些设备相关的数据，比如设备ID的的存储文件也被克隆，导致用户更换设备之后，从本地读取到的设备ID信息依旧是上个手机的（Android Q以及以上的设备，有时候没办法获取设备ID，只能给一个随机数，因此只能存储在应用本地），这样会导致安全问题。

KeyStore简介

利用 Android KeyStore System，您可以在容器中存储加密密钥，从而提高从设备中提取密钥的难度。在密钥进入密钥库后，可以将它们用于加密操作，而密钥材料仍不可导出。此外，它提供了密钥使用的时间和方式限制措施，例如要求进行用户身份验证才能使用密钥，或者限制为只能在某些加密模式中使用。

密钥库系统由 KeyChain API 以及在 Android 4.3（API 级别 18）中引入的 Android 密钥库提供程序功能使用。本文说明了何时以及如何使用 Android 密钥库提供程序。

注意：Android Keystore的API非线程安全，对于API的调用需要进行互斥操作。线程不安全的原因很简单，那就是不管上层创建多少个对象，底层都只对应同一个加解密硬件，硬件没有完成操作之前给出另一个操作命令会导致硬件工作异常。这也是官方文档 EncryptedFile 类和 EncryptedSharedPreferences 类中的方法不是线程安全的根本原因。

我们从 Google Tink 项目的讨论 Bug: using EncryptedSharedPreferences, it can cause crashes to users right when initializing it #535中可以了解到，目前三星Samsung的部分机型的底层实现就是线程不安全的。

更多的机型信息参考 Bug: using EncryptedSharedPreferences, it can cause crashes to users right when initializing it 崩溃率排行中，三星，小米遥遥领先！

应用场景

1、存储密匙：Android提供的这个KeyStore最大的作用就是不需要开发者去维护这个密匙的存储问题，相比起存储在用户的数据空间或者是外部存储器都更加安全。需要注意：这个密匙随着用户清除数据或者卸载应用都会被清除掉。
2、得益于Android独立的一套密匙库系统，可以提高安全性

安全功能

Android 密钥库系统可以保护密钥材料免遭未经授权的使用。首先，Android 密钥库可以防止从应用进程和 Android 设备中整体提取密钥材料，从而避免了在 Android 设备之外以未经授权的方式使用密钥材料。其次，Android 密钥库可以让应用指定密钥的授权使用方式，并在应用进程之外强制实施这些限制，从而避免了在 Android 设备上以未经授权的方式使用密钥材料。

提取防范

Android 密钥库密钥使用两项安全措施来避免密钥材料被提取：

密钥材料永不进入应用进程。通过 Android 密钥库密钥执行加密操作时，应用会将待签署或验证的明文、密文和消息馈送到执行加密操作的系统进程。如果应用进程受攻击，攻击者也许能使用应用密钥，但无法提取密钥材料（例如，在 Android 设备以外使用）。
您可以将密钥材料绑定至 Android 设备的安全硬件，例如可信执行环境 (TEE) 和安全元素 (SE)。为密钥启用此功能时，其密钥材料永远不会暴露于安全硬件之外。如果 Android 操作系统受到攻击或者攻击者可以读取设备内部存储空间，攻击者也许能在 Android 设备上使用应用的 Android 密钥库，但无法从设备上提取这些数据。只有设备的安全硬件支持密钥算法、区块模式、填充方案和密钥有权使用的摘要的特定组合时，才可启用此功能。要检查是否为密钥启用了此功能，请获取密钥的 KeyInfo 并检查 KeyInfo.isInsideSecurityHardware() 的返回值。

密钥使用授权

为了避免在 Android 设备上以未经授权的方式使用密钥材料，在生成或导入密钥时 Android 密钥库会让应用指定密钥的授权使用方式。一旦生成或导入密钥，其授权将无法更改。然后，每次使用密钥时，都会由 Android 密钥库强制执行授权。这是一项高级安全功能，通常仅用于有以下要求的情形：在生成/导入密钥后（而不是之前或当中），应用进程受到攻击不会导致密钥以未经授权的方式使用。

支持的密钥使用授权可归为以下几个类别：

加密：授权密钥算法、运算或目的（加密、解密、签署、验证）、填充方案、区块模式以及可与密钥搭配使用的摘要；
时间有效性间隔：密钥获得使用授权的时间间隔；
用户身份验证：密钥只能在用户最近进行身份验证时使用。请参阅要求进行用户身份验证才能使用密钥。

作为一项额外的安全措施，对于密钥材料位于安全硬件内部的密钥（请参阅 KeyInfo.isInsideSecurityHardware()），某些密钥使用授权可能由安全硬件实施，具体取决于 Android 设备。加密和用户身份验证授权可能由安全硬件实施。由于安全硬件一般不具备独立的安全实时时钟，时间有效性间隔授权不可能由其实施。

您可以使用 KeyInfo.isUserAuthenticationRequirementEnforcedBySecureHardware() 查询密钥的用户身份验证授权是否由安全硬件实施。

选择密钥链或 Android 密钥库提供程序

在需要系统级凭据时请使用 KeyChain API。在应用通过 KeyChain API 请求使用任何凭据时，用户需要通过系统提供的 UI 选择应用可以访问已安装的哪些凭据。因此，在用户同意的情况下多个应用可以使用同一套凭据。

使用 Android 密钥库提供程序让各个应用存储自己的凭据，并且只允许应用自身访问。这样，应用可以管理仅能由自己使用的凭据，同时又可以提供等同于 KeyChain API 为系统级凭据提供的安全优势。这一方法不需要用户选择凭据。

使用 Android 密钥库提供程序

要使用此功能，请使用标准的 KeyStore 和 KeyPairGenerator 或 KeyGenerator 类，以及在 Android 4.3（API 级别 18）中引入的 AndroidKeyStore 提供程序。

AndroidKeyStore 注册为 KeyStore 类型以用于 KeyStore.getInstance(type) 方法，而在用于 KeyPairGenerator.getInstance(algorithm, provider) 和 KeyGenerator.getInstance(algorithm, provider) 方法时则注册为提供程序。

生成新私钥

生成新的 PrivateKey 要求您同时指定自签署证书具备的初始 X.509 属性。之后，您可以使用 KeyStore.setKeyEntry 将证书替换为由证书颁发机构 (CA) 签署的证书。

要生成密钥，则使用 KeyPairGenerator 和 KeyPairGeneratorSpec：

/*
 * Generate a new EC key pair entry in the Android Keystore by
 * using the KeyPairGenerator API. The private key can only be
 * used for signing or verification and only with SHA-256 or
 * SHA-512 as the message digest.
 */
KeyPairGenerator kpg = KeyPairGenerator.getInstance(
        KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore");
kpg.initialize(new KeyGenParameterSpec.Builder(
        alias,
        KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_VERIFY)
        .setDigests(KeyProperties.DIGEST_SHA256,
            KeyProperties.DIGEST_SHA512)
        .build());
KeyPair kp = kpg.generateKeyPair();

* Generate a new EC key pair entry in the Android Keystore by

* using the KeyPairGenerator API. The private key can only be

* used for signing or verification and only with SHA-256 or

* SHA-512 as the message digest.

KeyPairGenerator kpg = KeyPairGenerator.getInstance(

KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore");

kpg.initialize(new KeyGenParameterSpec.Builder(

alias,

KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_VERIFY)

.setDigests(KeyProperties.DIGEST_SHA256,

KeyProperties.DIGEST_SHA512)

.build());

KeyPair kp = kpg.generateKeyPair();

生成新密钥

要生成密钥，请使用 KeyGenerator 和 KeyGenParameterSpec。

使用密钥库条目

AndroidKeyStore 提供程序的使用通过所有的标准 KeyStore API 加以实现。

列出条目

通过调用 aliases() 方法列出密钥库中的条目：

/*
 * Load the Android KeyStore instance using the the
 * "AndroidKeyStore" provider to list out what entries are
 * currently stored.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
Enumeration<String> aliases = ks.aliases();

* Load the Android KeyStore instance using the the

* "AndroidKeyStore" provider to list out what entries are

* currently stored.

KeyStore ks = KeyStore.getInstance("AndroidKeyStore");

ks.load(null);

Enumeration<String> aliases = ks.aliases();

签署和验证数据

通过从密钥库提取 KeyStore.Entry 并使用 Signature API（例如 sign()）签署数据：

/*
 * Use a PrivateKey in the KeyStore to create a signature over
 * some data.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
KeyStore.Entry entry = ks.getEntry(alias, null);
if (!(entry instanceof PrivateKeyEntry)) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry");
    return null;
}
Signature s = Signature.getInstance("SHA256withECDSA");
s.initSign(((PrivateKeyEntry) entry).getPrivateKey());
s.update(data);
byte[] signature = s.sign();

* Use a PrivateKey in the KeyStore to create a signature over

* some data.

KeyStore ks = KeyStore.getInstance("AndroidKeyStore");

ks.load(null);

KeyStore.Entry entry = ks.getEntry(alias, null);

if (!(entry instanceof PrivateKeyEntry)) {

Log.w(TAG, "Not an instance of a PrivateKeyEntry");

return null;

}

Signature s = Signature.getInstance("SHA256withECDSA");

s.initSign(((PrivateKeyEntry) entry).getPrivateKey());

s.update(data);

byte[] signature = s.sign();

类似地，请使用 verify(byte[]) 方法验证数据：

/*
 * Verify a signature previously made by a PrivateKey in our
 * KeyStore. This uses the X.509 certificate attached to our
 * private key in the KeyStore to validate a previously
 * generated signature.
 */
KeyStore ks = KeyStore.getInstance("AndroidKeyStore");
ks.load(null);
KeyStore.Entry entry = ks.getEntry(alias, null);
if (!(entry instanceof PrivateKeyEntry)) {
    Log.w(TAG, "Not an instance of a PrivateKeyEntry");
    return false;
}
Signature s = Signature.getInstance("SHA256withECDSA");
s.initVerify(((PrivateKeyEntry) entry).getCertificate());
s.update(data);
boolean valid = s.verify(signature);

* Verify a signature previously made by a PrivateKey in our

* KeyStore. This uses the X.509 certificate attached to our

* private key in the KeyStore to validate a previously

* generated signature.

KeyStore ks = KeyStore.getInstance("AndroidKeyStore");

ks.load(null);

KeyStore.Entry entry = ks.getEntry(alias, null);

if (!(entry instanceof PrivateKeyEntry)) {

Log.w(TAG, "Not an instance of a PrivateKeyEntry");

return false;

}

Signature s = Signature.getInstance("SHA256withECDSA");

s.initVerify(((PrivateKeyEntry) entry).getCertificate());

s.update(data);

boolean valid = s.verify(signature);

要求进行用户身份验证才能使用密钥

生成密钥或将密钥导入到 AndroidKeyStore 时，您可以指定密钥仅授权给经过身份验证的用户使用。用户使用安全锁定屏幕凭据（模式/PIN/密码、指纹）的子集进行身份验证。

这是一项高级安全功能，通常仅用于有以下要求的情形：在生成/导入密钥后（而不是之前或当中），应用进程受到攻击不会导致密钥被未经身份验证的用户使用。

如果密钥仅授权给经过身份验证的用户使用，可以将其配置为以下列两种模式之一运行：

经过身份验证的用户可以在一段时间内使用密钥。在用户解锁安全锁定屏幕或使用 KeyguardManager.createConfirmDeviceCredentialIntent 流程确认其安全锁定屏幕凭据后，即可使用此模式中的所有密钥。每个密钥的授权持续时间各不相同，并由 setUserAuthenticationValidityDurationSeconds 在密钥生成或导入时指定。此类密钥只能在启用安全锁定屏幕时生成或导入（请参阅 KeyguardManager.isDeviceSecure()）。在安全锁定屏幕停用（重新配置为“无”、“滑动”或不验证用户身份的其他模式）或被强制重置（例如由设备管理员执行）时，这些密钥将永久失效。
用户身份验证会授权与某一密钥关联的特定加密操作。在此模式中，涉及此类密钥的每个操作都需要用户单独授权。目前，此类授权的唯一方式是指纹身份验证：FingerprintManager.authenticate。此类密钥只能在至少注册一个指纹时生成或导入（请参阅 FingerprintManager.hasEnrolledFingerprints）。一旦注册新指纹或取消注册所有指纹，这些密钥将永久失效。

Android数据加密：

Android 提供了 KeyStore 等可以长期存储和检索加密密钥的机制，Android KeyStore 系统特别适合于存储加密密钥。

“AndroidKeyStore” 是 KeyStore 的一个子集，存进 AndroidKeyStore 的 key 将受到签名保护，并且这些 key 是存在系统里的，而不是在 App 的 data 目录下，依托于硬件的 KeyChain 存储，可以做到 private key 一旦存入就无法取出，

每个 App 自己创建的 key，别的应用是访问不到的。

它提供了限制何时以何种方式使用密钥的方法，比如使用密钥时需要用户认证或限制密钥只能在加密模式下使用。

一个应用程式只能编辑、保存、取出自己的密钥。

App可以生成或者接收一个公私密钥对，并存储在Android的Keystore系统中。公钥可以用于在应用数据放置到特定文件夹前对数据进行加密，私钥可以在需要的时候解密相应的数据。

作用：

KeyStore 适用于生成和存储密钥，这些密钥可以用来加密运行时获取到的数据，比如运行时，用户输入的密码，或者服务端传下来的 token。

操作方式

存：使用 Keystore 加密信息后存入 SharedPreferences
取：从 SharedPreferences 取出信息並使用 Keystore 解密

建议做法

1. 使用对称式加解密，但只能在Api Level 23+使用

对称式加解密(AES)速度较快，但是对称式的Key若要存在 KeyStore 裡，Api Level一定要在23以上才支持，23以下是无法存入 KeyStore 的，非对称式的Key則不在此限。

2. 想兼容各Api版本(23以下也能用)

若要存取的東西不多、字串長度也不長：直接使用非对称式加解密即可
若要存取的東西很多或字串長度很長：由於非对称式加解密速度较慢，使用非对称式+对称式加解密可以解決此問題。

考慮到加解密效能、版本兼容，下面會介紹用非对称式+对称式來加解密。

KeyStore非对称+对称式加解密流程

使用 KeyStore 产生随机的 RSA Key；
产生 AES Key，并用 RSA Public Key 加密后存入 SharedPrefs；
从 SharedPrefs 取出 AES Key，並用 RSA Private Key 解密，用这把 AES Key 来加解密信息；

主流的加密方式有：（对称加密）AES、DES 、EC （非对称加密）RSA、DSA

工作模式:

DES一共有:

电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）、输出反馈模式（OFB）;

AES一共有：

电子密码本模式（ECB）、加密分组链接模式（CBC）、加密反馈模式（CFB）、输出反馈模式（OFB）、计数器模式（CTR），伽罗瓦计数器模式（GCM）

PKCS5Padding是填充模式，还有其它的填充模式;

对于初始化向量 iv: 初始化向量参数，AES 为16bytes. DES 为 8bytes

private static final String KEYSTORE_PROVIDER = "AndroidKeyStore";
// 算法/模式/补码方式 不使用CBC模式，注意Padding Oracle攻击
private static final String AES_MODE = "AES/GCM/NoPadding";
/*
 * RSA ENCRYPTION_PADDING_RSA_PKCS1 存在安全漏洞，高于API 23的版本使用 ENCRYPTION_PADDING_RSA_OAEP
 * 漏洞关键字：
 * "Chosen ciphertext attacks against protocols based on the RSA encryption standard PKCS #1"
 * 目前测试来看，很多设备暂时不支持 ENCRYPTION_PADDING_RSA_OAEP 模式，比较可惜
 */
private static final String RSA_MODE = "RSA/ECB/PKCS1Padding";


private static final String KEYSTORE_ALIAS = "KEYSTORE_DEMO";

/**
 * 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) {
        /*
        * 针对小米厂商，全系列不启用 StrongBox 支持
        * 目前已知的问题升级，在 小米 14 系列上，使用 StrongBox 生成的密钥，已经有客户反馈周期性的密钥错误，导致无法解密出数据
        * 典型的现象就是调用硬件密钥的时候抛出异常，无法读取出来，应该是密钥在硬件中丢失了
        *
        * 在小米 15 系列上，使用 "AES/GCM/NoPadding" 生成的密钥如果关联生物识别，比如指纹，则可以加密数据，但是解密加密后的数据
        * 会失败，经过与小米厂商的邮件沟通，这部分功能在整个系列上存在问题，无法正常工作
        * 
        * 因此，全系的小米手机都默认不启用 StrongBox 
        * */
        if("Xiaomi".equalsIgnoreCase(android.os.Build.BRAND)) {
            return false;
        }
        return context.getPackageManager()
            .hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE);
    }
    return false;
}

KeyStore mKeyStore = KeyStore.getInstance(KEYSTORE_PROVIDER);
mKeyStore.load(null);

private static final String KEYSTORE_PROVIDER = "AndroidKeyStore";

// 算法/模式/补码方式不使用CBC模式，注意Padding Oracle攻击

private static final String AES_MODE = "AES/GCM/NoPadding";

* RSA ENCRYPTION_PADDING_RSA_PKCS1 存在安全漏洞，高于API 23的版本使用 ENCRYPTION_PADDING_RSA_OAEP

* 漏洞关键字：

* "Chosen ciphertext attacks against protocols based on the RSA encryption standard PKCS #1"

* 目前测试来看，很多设备暂时不支持 ENCRYPTION_PADDING_RSA_OAEP 模式，比较可惜

private static final String RSA_MODE = "RSA/ECB/PKCS1Padding";

private static final String KEYSTORE_ALIAS = "KEYSTORE_DEMO";

/**

* 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) {

* 针对小米厂商，全系列不启用 StrongBox 支持

* 目前已知的问题升级，在小米 14 系列上，使用 StrongBox 生成的密钥，已经有客户反馈周期性的密钥错误，导致无法解密出数据

* 典型的现象就是调用硬件密钥的时候抛出异常，无法读取出来，应该是密钥在硬件中丢失了

* 在小米 15 系列上，使用 "AES/GCM/NoPadding" 生成的密钥如果关联生物识别，比如指纹，则可以加密数据，但是解密加密后的数据

* 会失败，经过与小米厂商的邮件沟通，这部分功能在整个系列上存在问题，无法正常工作

* 因此，全系的小米手机都默认不启用 StrongBox

* */

if("Xiaomi".equalsIgnoreCase(android.os.Build.BRAND)) {

return false;

}

return context.getPackageManager()

.hasSystemFeature(PackageManager.FEATURE_STRONGBOX_KEYSTORE);

}

return false;

}

KeyStore mKeyStore = KeyStore.getInstance(KEYSTORE_PROVIDER);

mKeyStore.load(null);

（1）产生随机的 RSA Key

产生 RSA Key 会使用到 KeyPairGenerator：

其中 KeyPairGeneratorSpec 在Api 23以上已经 Deprecated 了；

Api level 23以上改使用 KeyGenParameterSpec

/*
 * 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿
 * 建议全部调度到一个统一的HanderThread子线程进行处理
 **/
@WorkerThread
private void genKeyStoreKey(@NonNull final Context context) throws Exception {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        generateRSAKey_AboveApi23(context);
    } else {
        generateRSAKey_BelowApi23(context);
    }
}

* 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿

* 建议全部调度到一个统一的HanderThread子线程进行处理

**/

@WorkerThread

private void genKeyStoreKey(@NonNull final Context context) throws Exception {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

generateRSAKey_AboveApi23(context);

} else {

generateRSAKey_BelowApi23(context);

}

Api 23 以上使用 KeyGenParameterSpec

/*
 * 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿
 * 建议全部调度到一个统一的HanderThread子线程进行处理
 **/
@WorkerThread
@RequiresApi(api = Build.VERSION_CODES.M)
private void generateHwAesKey_AboveApi23(@NonNull final String keystoreAlias, @NonNull final String provider) throws Exception {

    // 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); //要求硬件生成随机向量

    if (hasStrongBox(context) && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)) {
        try {
            /* 如果系统支持硬件StrongBox保存密钥，则尝试交给StrongBox保护 */
            builder.setIsStrongBoxBacked(true);
            generateHwAesKey_AboveApi23(builder, provider);
        } catch (Throwable t) {
            Logs.e(TAG, t.getMessage(), t);
            /*
             * 2024/06
             * 已知在小米 14/15 Xiaomi HyperOS 系统上，部分手机在启用 StrongBox 的情况下，会发生如下异常：
             * <p>
             * java.security.ProviderException: Keystore key generation failed
             * 	 at android.security.keystore2.AndroidKeyStoreKeyGeneratorSpi.engineGenerateKey(AndroidKeyStoreKeyGeneratorSpi.java:413)
             * 	 at javax.crypto.KeyGenerator.generateKey(KeyGenerator.java:612)
             * 	 at com.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.x(SourceFile:28)
             * <p>
             * Caused by: android.security.KeyStoreException: Not implemented (internal Keystore code: -100 message: system/security/keystore2/src/security_level.rs:622
             * <p>
             * Caused by:
             * 	 0: system/security/keystore2/src/security_level.rs:620: While generating Key without explicit attestation key.
             * 	 1: Error::Km(r....
             *
             * 我们需要先尝试使用 StrongBox 生成密钥，如果生成失败，则尝试不使用 StrongBox 生成密钥
             **/
            builder.setIsStrongBoxBacked(false);
            generateHwAesKey_AboveApi23(builder, provider);
        }
    } else {
        generateHwAesKey_AboveApi23(builder, provider);
    }
}

@WorkerThread
@RequiresApi(api = Build.VERSION_CODES.M)
private void generateHwAesKey_AboveApi23(@NonNull final KeyGenParameterSpec.Builder builder, @NonNull final String provider) throws Exception {
    final KeyGenerator keyGenerator = KeyGenerator
        .getInstance(KeyProperties.KEY_ALGORITHM_AES, provider);

    final KeyGenParameterSpec spec = builder.build();
    keyGenerator.init(spec);
    keyGenerator.generateKey();
}

* 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿

* 建议全部调度到一个统一的HanderThread子线程进行处理

**/

@WorkerThread

@RequiresApi(api = Build.VERSION_CODES.M)

private void generateHwAesKey_AboveApi23(@NonNull final String keystoreAlias, @NonNull final String provider) throws Exception {

// 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); //要求硬件生成随机向量

if (hasStrongBox(context) && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)) {

try {

/* 如果系统支持硬件StrongBox保存密钥，则尝试交给StrongBox保护 */

builder.setIsStrongBoxBacked(true);

generateHwAesKey_AboveApi23(builder, provider);

} catch (Throwable t) {

Logs.e(TAG, t.getMessage(), t);

* 2024/06

* 已知在小米 14/15 Xiaomi HyperOS 系统上，部分手机在启用 StrongBox 的情况下，会发生如下异常：

*

* java.security.ProviderException: Keystore key generation failed

* at android.security.keystore2.AndroidKeyStoreKeyGeneratorSpi.engineGenerateKey(AndroidKeyStoreKeyGeneratorSpi.java:413)

* at javax.crypto.KeyGenerator.generateKey(KeyGenerator.java:612)

* at com.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.x(SourceFile:28)

*

* Caused by: android.security.KeyStoreException: Not implemented (internal Keystore code: -100 message: system/security/keystore2/src/security_level.rs:622

*

* Caused by:

* 0: system/security/keystore2/src/security_level.rs:620: While generating Key without explicit attestation key.

* 1: Error::Km(r....

* 我们需要先尝试使用 StrongBox 生成密钥，如果生成失败，则尝试不使用 StrongBox 生成密钥

**/

builder.setIsStrongBoxBacked(false);

generateHwAesKey_AboveApi23(builder, provider);

}

} else {

generateHwAesKey_AboveApi23(builder, provider);

}

@WorkerThread

@RequiresApi(api = Build.VERSION_CODES.M)

private void generateHwAesKey_AboveApi23(@NonNull final KeyGenParameterSpec.Builder builder, @NonNull final String provider) throws Exception {

final KeyGenerator keyGenerator = KeyGenerator

.getInstance(KeyProperties.KEY_ALGORITHM_AES, provider);

final KeyGenParameterSpec spec = builder.build();

keyGenerator.init(spec);

keyGenerator.generateKey();

}

Api 23 以下使用 KeyPairGeneratorSpec

/*
 * 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿
 * 建议全部调度到一个统一的HanderThread子线程进行处理
 **/
@WorkerThread
private void generateRSAKey_BelowApi23(@NonNull final Context context) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {
    final Calendar end = Calendar.getInstance();
    end.add(Calendar.YEAR, 99);

    final KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(context)
        .setAlias(KEYSTORE_ALIAS)
        .setSubject(new X500Principal("CN=" + KEYSTORE_ALIAS))
        .setSerialNumber(BigInteger.TEN)
        /* 开始时间设置为1970/1/1原因在于
         * 防止系统由于时间无效或者电池没电导致的时间只能从最早时间开始的问题，
         * 如果时间不正确会导致在调用的时候抛出
         * android.security.keystore.KeyNotYetValidException: Key not yet valid
         */
        .setStartDate(new Date(0))
        .setEndDate(end.getTime())
        .build();

    final KeyPairGenerator keyPairGenerator = KeyPairGenerator
        .getInstance("RSA", KEYSTORE_PROVIDER);

    keyPairGenerator.initialize(spec);
    keyPairGenerator.generateKeyPair();
}

* 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿

* 建议全部调度到一个统一的HanderThread子线程进行处理

**/

@WorkerThread

private void generateRSAKey_BelowApi23(@NonNull final Context context) throws NoSuchAlgorithmException, NoSuchProviderException, InvalidAlgorithmParameterException {

final Calendar end = Calendar.getInstance();

end.add(Calendar.YEAR, 99);

final KeyPairGeneratorSpec spec = new KeyPairGeneratorSpec.Builder(context)

.setAlias(KEYSTORE_ALIAS)

.setSubject(new X500Principal("CN=" + KEYSTORE_ALIAS))

.setSerialNumber(BigInteger.TEN)

/* 开始时间设置为1970/1/1原因在于

* 防止系统由于时间无效或者电池没电导致的时间只能从最早时间开始的问题，

* 如果时间不正确会导致在调用的时候抛出

* android.security.keystore.KeyNotYetValidException: Key not yet valid

.setStartDate(new Date(0))

.setEndDate(end.getTime())

.build();

final KeyPairGenerator keyPairGenerator = KeyPairGenerator

.getInstance("RSA", KEYSTORE_PROVIDER);

keyPairGenerator.initialize(spec);

keyPairGenerator.generateKeyPair();

}

注意，已知，在某些低端设备上，RSA密钥对生成的时间可能超过1S以上。尝试过异步子线程初始化，但是由KeyStore内部的函数在实现的时候，线程不安全，导致子线程初始化的时候诱发了异常行为，因此只能在主线程中进行操作。

（2）产生AES Key后，并用RSA Public Key加密后存入SharedPrefs

private void genAESKey() throws Exception {
     // Generate AES-Key
    final byte[] aesKey = new byte[16];
    final SecureRandom secureRandom = new SecureRandom();
    secureRandom.nextBytes(aesKey);

    // Generate 12 bytes iv then save to SharedPrefs
    final byte[] generated = secureRandom.generateSeed(12);
    final String iv = Base64.encodeToString(generated, Base64.DEFAULT);
    final String encryptIV = encryptRSA(iv.getBytes());
    prefsHelper.setIV(encryptIV);
 
    // Encrypt AES-Key with RSA Public Key then save to SharedPrefs
    final String encryptAESKey = encryptRSA(aesKey);
    prefsHelper.setAESKey(encryptAESKey);
}

private void genAESKey() throws Exception {

// Generate AES-Key

final byte[] aesKey = new byte[16];

final SecureRandom secureRandom = new SecureRandom();

secureRandom.nextBytes(aesKey);

// Generate 12 bytes iv then save to SharedPrefs

final byte[] generated = secureRandom.generateSeed(12);

final String iv = Base64.encodeToString(generated, Base64.DEFAULT);

final String encryptIV = encryptRSA(iv.getBytes());

prefsHelper.setIV(encryptIV);

// Encrypt AES-Key with RSA Public Key then save to SharedPrefs

final String encryptAESKey = encryptRSA(aesKey);

prefsHelper.setAESKey(encryptAESKey);

}

　　1］加密存储：使用RSA Public Key 加密 AES Key，存入缓存中。

　　2] 解密使用：使用RSA Private Key 解密得到 AES Key。

private String encryptRSA(@NonNull final byte[] plainText) throws Exception {
    final PublicKey publicKey = keyStore.getCertificate(KEYSTORE_ALIAS).getPublicKey();

    final Cipher cipher = Cipher.getInstance(RSA_MODE);
    cipher.init(Cipher.ENCRYPT_MODE, publicKey);

    final byte[] encryptedByte = cipher.doFinal(plainText);
    return Base64.encodeToString(encryptedByte, Base64.DEFAULT);
}

private byte[] decryptRSA(@NonNull final String encryptedText) throws Exception {
    final PrivateKey privateKey = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

    final Cipher cipher = Cipher.getInstance(RSA_MODE);
    cipher.init(Cipher.DECRYPT_MODE, privateKey);

    final byte[] encryptedBytes = Base64.decode(encryptedText, Base64.DEFAULT);
    final byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

    return decryptedBytes;
}

private String encryptRSA(@NonNull final byte[] plainText) throws Exception {

final PublicKey publicKey = keyStore.getCertificate(KEYSTORE_ALIAS).getPublicKey();

final Cipher cipher = Cipher.getInstance(RSA_MODE);

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

final byte[] encryptedByte = cipher.doFinal(plainText);

return Base64.encodeToString(encryptedByte, Base64.DEFAULT);

}

private byte[] decryptRSA(@NonNull final String encryptedText) throws Exception {

final PrivateKey privateKey = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

final Cipher cipher = Cipher.getInstance(RSA_MODE);

cipher.init(Cipher.DECRYPT_MODE, privateKey);

final byte[] encryptedBytes = Base64.decode(encryptedText, Base64.DEFAULT);

final byte[] decryptedBytes = cipher.doFinal(encryptedBytes);

return decryptedBytes;

}

获取AES :

private SecretKeySpec getAESKey() throws Exception {
    final String encryptedKey = prefsHelper.getAESKey();
    final byte[] aesKey = decryptRSA(encryptedKey);

    return new SecretKeySpec(aesKey, AES_MODE); 
}

private SecretKeySpec getAESKey() throws Exception {

final String encryptedKey = prefsHelper.getAESKey();

final byte[] aesKey = decryptRSA(encryptedKey);

return new SecretKeySpec(aesKey, AES_MODE);

}

再使用AES 加解密内容：

对于：Cipher 初始化

//实例化加密类，参数为加密方式，要写全
// 算法/模式/补码方式 不使用CBC模式，注意Padding Oracle攻击
Cipher cipher = Cipher.getIntance("AES/CBC/PKCS5Padding");

//初始化，此方法可以采用三种方式，按服务器要求来添加。
//（1）无第三个参数
//（2）第三个参数为SecureRandom random = new SecureRandom();
// 中random对象，随机数。(AES不可采用这种方法)
//（3）第三个参数：IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes);
cipher.init(Cipher.ENCRYPT_MODE,  keySpec,  ivSpec/random);

//实例化加密类，参数为加密方式，要写全

// 算法/模式/补码方式不使用CBC模式，注意Padding Oracle攻击

Cipher cipher = Cipher.getIntance("AES/CBC/PKCS5Padding");

//初始化，此方法可以采用三种方式，按服务器要求来添加。

//（1）无第三个参数

//（2）第三个参数为SecureRandom random = new SecureRandom();

// 中random对象，随机数。(AES不可采用这种方法)

//（3）第三个参数：IvParameterSpec ivSpec = new IvParameterSpec(iv.getBytes);

cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivSpec/random);

具体使用：

/**
* AES Encryption
* @param plainText: A string which needs to be encrypted.
* @return A base64's string after encrypting.
*/
private String encryptAES(@NonNull final String plainText) throws Exception {
    final Cipher cipher = Cipher.getInstance(AES_MODE);
    cipher.init(Cipher.ENCRYPT_MODE, getAESKey(), new IvParameterSpec(getIV()));

    // 加密過後的byte
    final byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());

    // 將byte轉為base64的string編碼
    return Base64.encodeToString(encryptedBytes, Base64.DEFAULT);
}

private String decryptAES(@NonNull final String encryptedText) throws Exception {
    // 將加密過後的Base64編碼格式 解碼成 byte
    final byte[] decodedBytes = Base64.decode(encryptedText.getBytes(), Base64.DEFAULT);

    // 將解碼過後的byte 使用AES解密
    final Cipher cipher = Cipher.getInstance(AES_MODE);
    cipher.init(Cipher.DECRYPT_MODE, getAESKey(), new IvParameterSpec(getIV()));

    return new String(cipher.doFinal(decodedBytes));
}

/**

* AES Encryption

* @param plainText: A string which needs to be encrypted.

* @return A base64's string after encrypting.

private String encryptAES(@NonNull final String plainText) throws Exception {

final Cipher cipher = Cipher.getInstance(AES_MODE);

cipher.init(Cipher.ENCRYPT_MODE, getAESKey(), new IvParameterSpec(getIV()));

// 加密過後的byte

final byte[] encryptedBytes = cipher.doFinal(plainText.getBytes());

// 將byte轉為base64的string編碼

return Base64.encodeToString(encryptedBytes, Base64.DEFAULT);

}

private String decryptAES(@NonNull final String encryptedText) throws Exception {

// 將加密過後的Base64編碼格式解碼成 byte

final byte[] decodedBytes = Base64.decode(encryptedText.getBytes(), Base64.DEFAULT);

// 將解碼過後的byte 使用AES解密

final Cipher cipher = Cipher.getInstance(AES_MODE);

cipher.init(Cipher.DECRYPT_MODE, getAESKey(), new IvParameterSpec(getIV()));

return new String(cipher.doFinal(decodedBytes));

}

iv 初始化向量

private byte[] getIV() throws Exception {
    final String prefIV = prefsHelper.getIV();
    final byte[] iv = decryptRSA(prefIV);
    return Base64.decode(iv, Base64.DEFAULT);
}

private byte[] getIV() throws Exception {

final String prefIV = prefsHelper.getIV();

final byte[] iv = decryptRSA(prefIV);

return Base64.decode(iv, Base64.DEFAULT);

}

关于RSA：

使用RSA加解密时，在较低版本的手机上可能无法选择OAEP(最优非对称加密填充，RSA的加密解密是基于OAEP的)這個模式;

因此可以改使用RSA_PKCS1_PADDING模式，使用这个模式的話，输入必须比RSA的Key最大长度少11個字节，如果需要被加密的字串过长的话，可以在产生Key时指定Key Size长度，或是将字串分段加密。

以预设Key Size = 2048bit(256byte)來说，输入最长只能到256–11=245byte，我們可以透过setKeySize(int keySize)指定Key的长度，但是Key Size越大，加解密时速度就越慢。

KeyGenParameterSpec keyGenParameterSpec = new KeyGenParameterSpec
        .Builder(KEYSTORE_ALIAS, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
        .setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)
        .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)
        .setKeySize(4096)
        .build();

KeyGenParameterSpec keyGenParameterSpec = new KeyGenParameterSpec

.Builder(KEYSTORE_ALIAS, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)

.setDigests(KeyProperties.DIGEST_SHA256, KeyProperties.DIGEST_SHA512)

.setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_RSA_PKCS1)

.setKeySize(4096)

.build();

需要注意，由于设备可能存储密钥到硬件设备（KeyInfo.isInsideSecurityHardware()），然而硬件设备不一定能保存我们手工指定的某些长度的密钥。导致如果我们设置了指定长度，可能由于硬件设备不支持，反而只能存储到系统中，造成密钥存储的安全性反而下降了。

我们希望厂家设置的默认值是硬件能支持的最大安全性，并且尽量存储到硬件中。尽管密钥安全性可能下降了，但是存储安全性反而上升了。

或者从高到低重试，选择当前设备支持的最高的硬件存储的长度。究竟是存储位置重要还是加密级别更重要，需要权衡。

判断生成的密钥是否由硬件存储，参考如下代码：

/*API 23 以下的硬件，我们默认就无法存储密钥到硬件设备*/
public boolean isInsideSecurityHardware() throws Exception {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final PrivateKey key = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);
        final KeyFactory factory = KeyFactory.getInstance(key.getAlgorithm());
        final KeyInfo info = factory.getKeySpec(key, KeyInfo.class);

        //RSA密钥的长度也可以通过KeyInfo进行查询
        return info.isInsideSecurityHardware();
    }
    return false;
}

/*API 23 以下的硬件，我们默认就无法存储密钥到硬件设备*/

public boolean isInsideSecurityHardware() throws Exception {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

final PrivateKey key = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

final KeyFactory factory = KeyFactory.getInstance(key.getAlgorithm());

final KeyInfo info = factory.getKeySpec(key, KeyInfo.class);

//RSA密钥的长度也可以通过KeyInfo进行查询

return info.isInsideSecurityHardware();

}

return false;

}

获取设备生成的密钥的长度，参考如下代码：

public int getSecureKeySize() throws Exception {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        final PrivateKey key = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);
        final KeyFactory factory = KeyFactory.getInstance(key.getAlgorithm());
        final KeyInfo info = factory.getKeySpec(key, KeyInfo.class);
        if (null != info) {
            return info.getKeySize();
        }
    } else {
        final Certificate certificate = keyStore.getCertificate(KEYSTORE_ALIAS);
        if (certificate instanceof X509Certificate) {
            final X509Certificate cert = (X509Certificate) certificate;
            final PublicKey publicKey = cert.getPublicKey();
            if (publicKey instanceof RSAPublicKey) {
                final RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
                final BigInteger bigInteger = rsaPublicKey.getModulus();
                if (null != bigInteger) {
                    return bigInteger.bitLength();
                }
            }
        }
    }
    return 0;
}

public int getSecureKeySize() throws Exception {

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

final PrivateKey key = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

final KeyFactory factory = KeyFactory.getInstance(key.getAlgorithm());

final KeyInfo info = factory.getKeySpec(key, KeyInfo.class);

if (null != info) {

return info.getKeySize();

}

} else {

final Certificate certificate = keyStore.getCertificate(KEYSTORE_ALIAS);

if (certificate instanceof X509Certificate) {

final X509Certificate cert = (X509Certificate) certificate;

final PublicKey publicKey = cert.getPublicKey();

if (publicKey instanceof RSAPublicKey) {

final RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;

final BigInteger bigInteger = rsaPublicKey.getModulus();

if (null != bigInteger) {

return bigInteger.bitLength();

}

return 0;

}

需要解决的一个疑惑就是，既然可以通过

final PrivateKey privateKey = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

1	final PrivateKey privateKey = (PrivateKey) keyStore.getKey(KEYSTORE_ALIAS, null);

的方式获得RSA私钥，那么，我们能不导出这个私钥呢？

答案显然是不能的，原因在于系统给出的私钥只是一个代理，并没有实际的私钥数据，私钥数据被存储在相关的硬件或者系统内核中，主要证据就是privateKey.getEncoded()返回了null，这样就实现了关键的私钥数据都无法获得。

参考如下测试代码：

final PrivateKey privateKey = (PrivateKey) keyStore.getKey(alias, null);
assertNotNull(privateKey);
// 默认的AndroidKeyStore应该不能读出私钥数据
assertNull(privateKey.getEncoded());
assertNull(privateKey.getFormat());

/* RSA 密钥重新生产的方法参考下面的代码，从获取到的 PrivateKey中我们只能得到系数（modulus），其他参数都得不到
因此保证了密钥的安全性
RSAPrivateCrtKeySpec spec = new RSAPrivateCrtKeySpec(modulus, publicExponent, privateExponent, primeP, primeQ, primeExponentP, primeExponentQ, crtCoefficient);
KeyFactory keyFactory = KeyFactory.getInstance("RSA","BC");
PrivateKey privateKey = keyFactory.generatePrivate(spec);
*/

//公钥要可以被导出
final Certificate cert = keyStore.getCertificate(alias);
assertNotNull(cert.getEncoded());

final PrivateKey privateKey = (PrivateKey) keyStore.getKey(alias, null);

assertNotNull(privateKey);

// 默认的AndroidKeyStore应该不能读出私钥数据

assertNull(privateKey.getEncoded());

assertNull(privateKey.getFormat());

/* RSA 密钥重新生产的方法参考下面的代码，从获取到的 PrivateKey中我们只能得到系数（modulus），其他参数都得不到

因此保证了密钥的安全性

RSAPrivateCrtKeySpec spec = new RSAPrivateCrtKeySpec(modulus, publicExponent, privateExponent, primeP, primeQ, primeExponentP, primeExponentQ, crtCoefficient);

KeyFactory keyFactory = KeyFactory.getInstance("RSA","BC");

PrivateKey privateKey = keyFactory.generatePrivate(spec);

//公钥要可以被导出

final Certificate cert = keyStore.getCertificate(alias);

assertNotNull(cert.getEncoded());

需要注意的一个问题在于，由于RSA的大素数搜索机制，导致每次生成密钥的时间可能会超过预期，最长的可能会耗时1-2S以上。因此，如果设备支持，我们直接申请硬件AES密钥的方式来进行数据的加解密操作，达到更高的安全程度。

可用的参考代码如下：

import android.content.Context;
import android.content.pm.PackageManager;
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.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RequiresApi;
import androidx.annotation.WorkerThread;

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;
import javax.security.auth.x500.X500Principal;

/**
 * 通过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 "";
    }

    /*
     * 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿
     * 建议全部调度到一个统一的HanderThread子线程进行处理
     **/
    @WorkerThread
    @RequiresApi(api = Build.VERSION_CODES.M)
    private void generateHwAesKey_AboveApi23(@NonNull final String keystoreAlias, @NonNull final String provider) throws Exception {

        // 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); //要求硬件生成随机向量

        if (hasStrongBox(context) && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)) {
            try {
                /* 如果系统支持硬件StrongBox保存密钥，则尝试交给StrongBox保护 */
                builder.setIsStrongBoxBacked(true);
                generateHwAesKey_AboveApi23(builder, provider);
            } catch (Throwable t) {
                Logs.e(TAG, t.getMessage(), t);
                /*
                 * 2024/06 
                 * 已知在小米 14/15 Xiaomi HyperOS 系统上，部分手机在启用 StrongBox 的情况下，会发生如下异常：
                 * <p>
                 * java.security.ProviderException: Keystore key generation failed
                 * 	at android.security.keystore2.AndroidKeyStoreKeyGeneratorSpi.engineGenerateKey(AndroidKeyStoreKeyGeneratorSpi.java:413)
                 * 	at javax.crypto.KeyGenerator.generateKey(KeyGenerator.java:612)
                 * 	at com.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.x(SourceFile:28)
                 * <p>
                 * Caused by: android.security.KeyStoreException: Not implemented (internal Keystore code: -100 message: system/security/keystore2/src/security_level.rs:622
                 * <p>
                 * Caused by:
                 * 	0: system/security/keystore2/src/security_level.rs:620: While generating Key without explicit attestation key.
                 * 	1: Error::Km(r....
                 *
                 * 我们需要先尝试使用 StrongBox 生成密钥，如果生成失败，则尝试不使用 StrongBox 生成密钥
                 **/
                builder.setIsStrongBoxBacked(false);
                generateHwAesKey_AboveApi23(builder, provider);
            }
        } else {
            generateHwAesKey_AboveApi23(builder, provider);
        }
    }

    @WorkerThread
    @RequiresApi(api = Build.VERSION_CODES.M)
    private void generateHwAesKey_AboveApi23(@NonNull final KeyGenParameterSpec.Builder builder, @NonNull final String provider) throws Exception {
        final KeyGenerator keyGenerator = KeyGenerator
                .getInstance(KeyProperties.KEY_ALGORITHM_AES, provider);

        final KeyGenParameterSpec spec = builder.build();
        keyGenerator.init(spec);
        keyGenerator.generateKey();
    }

    /*
     * 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿
     * 建议全部调度到一个统一的HanderThread子线程进行处理
     **/
    @WorkerThread
    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;
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

import android.content.Context;

import android.content.pm.PackageManager;

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.NonNull;

import androidx.annotation.Nullable;

import androidx.annotation.RequiresApi;

import androidx.annotation.WorkerThread;

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;

import javax.security.auth.x500.X500Principal;

/**

* 通过AES加密方式，用KeyGenerator生成秘钥，保存在Android Keystore中

* 对数据进行加解密

*

* 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 "";

}

* 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿

* 建议全部调度到一个统一的HanderThread子线程进行处理

**/

@WorkerThread

@RequiresApi(api = Build.VERSION_CODES.M)

private void generateHwAesKey_AboveApi23(@NonNull final String keystoreAlias, @NonNull final String provider) throws Exception {

// 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); //要求硬件生成随机向量

if (hasStrongBox(context) && (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P)) {

try {

/* 如果系统支持硬件StrongBox保存密钥，则尝试交给StrongBox保护 */

builder.setIsStrongBoxBacked(true);

generateHwAesKey_AboveApi23(builder, provider);

} catch (Throwable t) {

Logs.e(TAG, t.getMessage(), t);

* 2024/06

* 已知在小米 14/15 Xiaomi HyperOS 系统上，部分手机在启用 StrongBox 的情况下，会发生如下异常：

*

* java.security.ProviderException: Keystore key generation failed

* at android.security.keystore2.AndroidKeyStoreKeyGeneratorSpi.engineGenerateKey(AndroidKeyStoreKeyGeneratorSpi.java:413)

* at javax.crypto.KeyGenerator.generateKey(KeyGenerator.java:612)

* at com.xxxx.xxxx.xxxx.xxxx.xxxx.xxxx.x(SourceFile:28)

*

* Caused by: android.security.KeyStoreException: Not implemented (internal Keystore code: -100 message: system/security/keystore2/src/security_level.rs:622

*

* Caused by:

* 0: system/security/keystore2/src/security_level.rs:620: While generating Key without explicit attestation key.

* 1: Error::Km(r....

* 我们需要先尝试使用 StrongBox 生成密钥，如果生成失败，则尝试不使用 StrongBox 生成密钥

**/

builder.setIsStrongBoxBacked(false);

generateHwAesKey_AboveApi23(builder, provider);

}

} else {

generateHwAesKey_AboveApi23(builder, provider);

}

@WorkerThread

@RequiresApi(api = Build.VERSION_CODES.M)

private void generateHwAesKey_AboveApi23(@NonNull final KeyGenParameterSpec.Builder builder, @NonNull final String provider) throws Exception {

final KeyGenerator keyGenerator = KeyGenerator

.getInstance(KeyProperties.KEY_ALGORITHM_AES, provider);

final KeyGenParameterSpec spec = builder.build();

keyGenerator.init(spec);

keyGenerator.generateKey();

}

* 注意KeyStore的API线程不安全，不建议主线程执行，主线程可能导致界面卡顿

* 建议全部调度到一个统一的HanderThread子线程进行处理

**/

@WorkerThread

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;

}

参考链接

ubuntu 20.04系统AOSP(Android 11)集成Frida

参考 ubuntu 20.04编译Android 11源代码&模拟器完成Android 11源代码的编译工作，保证能编译通过。

想自己手工编译Frida源代码的话，请参照下面：

$ git clone https://github.com/frida/frida.git

$ cd frida

$ make

$ export ANDROID_NDK_ROOT=/data/Android/android-sdk-linux/ndk/22.0.6917172

$ sudo apt-get install npm

$ sudo apt install python3-pip

$ pip3 install colorama prompt-toolkit pygments

$ rm -rf build

$ make core-android-x86_64

$ make core-android-x86

# 最后生成的文件在 build/frida-android-x86 build/frida-android-x86_64 
# 如果需要调整编译参数，在releng/setup-env.sh中进行调整 比如: meson_common_flags="['-g']"

$ git clone https://github.com/frida/frida.git

$ cd frida

$ make

$ export ANDROID_NDK_ROOT=/data/Android/android-sdk-linux/ndk/22.0.6917172

$ sudo apt-get install npm

$ sudo apt install python3-pip

$ pip3 install colorama prompt-toolkit pygments

$ rm -rf build

$ make core-android-x86_64

$ make core-android-x86

# 最后生成的文件在 build/frida-android-x86 build/frida-android-x86_64

# 如果需要调整编译参数，在releng/setup-env.sh中进行调整比如: meson_common_flags="['-g']"

如果想直接下载对应版本的Frida库并存放到已经编译过的库位置，由于64位系统需要兼容32位应用，因此需要安装两个版本的动态库：

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib64

$ wget https://github.com/frida/frida/releases/download/14.2.2/frida-gadget-14.2.2-android-x86_64.so.xz

$ xz -d frida-gadget-14.2.2-android-x86_64.so.xz

# Android要求动态库必须是lib开头
$ mv frida-gadget-14.2.2-android-x86_64.so libfrida-gadget-14.2.2-android-x86_64.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib

$ wget https://github.com/frida/frida/releases/download/14.2.2/frida-gadget-14.2.2-android-x86.so.xz

$ xz -d frida-gadget-14.2.2-android-x86.so.xz

# Android要求动态库必须是lib开头
$ mv frida-gadget-14.2.2-android-x86.so libfrida-gadget-14.2.2-android-x86.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib64

$ wget https://github.com/frida/frida/releases/download/14.2.2/frida-gadget-14.2.2-android-x86_64.so.xz

$ xz -d frida-gadget-14.2.2-android-x86_64.so.xz

# Android要求动态库必须是lib开头

$ mv frida-gadget-14.2.2-android-x86_64.so libfrida-gadget-14.2.2-android-x86_64.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib

$ wget https://github.com/frida/frida/releases/download/14.2.2/frida-gadget-14.2.2-android-x86.so.xz

$ xz -d frida-gadget-14.2.2-android-x86.so.xz

# Android要求动态库必须是lib开头

$ mv frida-gadget-14.2.2-android-x86.so libfrida-gadget-14.2.2-android-x86.so

创建Frida Gadget库的配置文件

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib64

$ touch libfrida-gadget-14.2.2-android-x86_64.config.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib

$ touch libfrida-gadget-14.2.2-android-x86.config.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib64

$ touch libfrida-gadget-14.2.2-android-x86_64.config.so

$ cd ~/AndSrc/aosp/

$ cd out/target/product/generic_x86_64/system/lib

$ touch libfrida-gadget-14.2.2-android-x86.config.so

里面的配置内容如下：

{
  "interaction": {
    "type": "listen",
    "address": "127.0.0.1",
    "port": 27042,
    "on_load": "resume"
  }
}

{

"interaction": {

"type": "listen",

"address": "127.0.0.1",

"port": 27042,

"on_load": "resume"

}

观察Frida源代码，发现在 frida-core/lib/gadget/gadget-glue.c中配置了lib库的入口函数

__attribute__ ((constructor)) static void
frida_on_load (void)
{
  frida_gadget_load (NULL, NULL, NULL);
}

__attribute__ ((constructor)) static void

frida_on_load (void)

{

frida_gadget_load (NULL, NULL, NULL);

}

这就意味着只要使用dlopen加载frida-gadget,我们就能实现对于指定应用的Hook。

我们只需要监听子进程，不需要在Zygote中加载，因此只需要在源代码 frameworks/base/core/jni/com_android_internal_os_Zygote.cpp 的com_android_internal_os_Zygote_nativeForkAndSpecialize函数中增加加载代码：

    /*
     * 在虚拟机，系统框架初始化完成之后，加载frida框架
     * 需要增加头文件的引用 #include <dlfcn.h>
     */
#if defined(__x86_64__) || defined(__i386__)
      {
          #if defined(__x86_64__)
              #define FRIDA_LIB "/system/lib64/libfrida-gadget-14.2.2-android-x86_64.so"
          #else
              #define FRIDA_LIB "/system/lib/libfrida-gadget-14.2.2-android-x86.so"
          #endif
          const char *name = env->GetStringUTFChars(nice_name, 0);
          void* frida = dlopen(FRIDA_LIB, RTLD_NOW);
          if(NULL == frida) {
              ALOGE("(%s) load frida-gadget(%s) failed, err= %d\n", name, FRIDA_LIB, errno);
          } else {
              ALOGI("(%s) load frida-gadget(%s) success\n", name, FRIDA_LIB);
          }
          env->ReleaseStringUTFChars(nice_name, name);
      }
#endif

* 在虚拟机，系统框架初始化完成之后，加载frida框架

* 需要增加头文件的引用 #include <dlfcn.h>

#if defined(__x86_64__) || defined(__i386__)

{

#if defined(__x86_64__)

#define FRIDA_LIB "/system/lib64/libfrida-gadget-14.2.2-android-x86_64.so"

#else

#define FRIDA_LIB "/system/lib/libfrida-gadget-14.2.2-android-x86.so"

#endif

const char *name = env->GetStringUTFChars(nice_name, 0);

void* frida = dlopen(FRIDA_LIB, RTLD_NOW);

if(NULL == frida) {

ALOGE("(%s) load frida-gadget(%s) failed, err= %d\n", name, FRIDA_LIB, errno);

} else {

ALOGI("(%s) load frida-gadget(%s) success\n", name, FRIDA_LIB);

}

env->ReleaseStringUTFChars(nice_name, name);

}

#endif

具体添加位置如下：

static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(
        JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,
        jint runtime_flags, jobjectArray rlimits,
        jint mount_external, jstring se_info, jstring nice_name,
        jintArray managed_fds_to_close, jintArray managed_fds_to_ignore, jboolean is_child_zygote,
        jstring instruction_set, jstring app_data_dir, jboolean is_top_app,
        jobjectArray pkg_data_info_list, jobjectArray whitelisted_data_info_list,
        jboolean mount_data_dirs, jboolean mount_storage_dirs) {
    jlong capabilities = CalculateCapabilities(env, uid, gid, gids, is_child_zygote);

    if (UNLIKELY(managed_fds_to_close == nullptr)) {
      ZygoteFailure(env, "zygote", nice_name, "Zygote received a null fds_to_close vector.");
    }

    std::vector<int> fds_to_close =
        ExtractJIntArray(env, "zygote", nice_name, managed_fds_to_close).value();
    std::vector<int> fds_to_ignore =
        ExtractJIntArray(env, "zygote", nice_name, managed_fds_to_ignore)
            .value_or(std::vector<int>());

    std::vector<int> usap_pipes = MakeUsapPipeReadFDVector();

    fds_to_close.insert(fds_to_close.end(), usap_pipes.begin(), usap_pipes.end());
    fds_to_ignore.insert(fds_to_ignore.end(), usap_pipes.begin(), usap_pipes.end());

    fds_to_close.push_back(gUsapPoolSocketFD);

    if (gUsapPoolEventFD != -1) {
      fds_to_close.push_back(gUsapPoolEventFD);
      fds_to_ignore.push_back(gUsapPoolEventFD);
    }

    if (gSystemServerSocketFd != -1) {
        fds_to_close.push_back(gSystemServerSocketFd);
        fds_to_ignore.push_back(gSystemServerSocketFd);
    }

    pid_t pid = ForkCommon(env, false, fds_to_close, fds_to_ignore, true);

    if (pid == 0) {
      SpecializeCommon(env, uid, gid, gids, runtime_flags, rlimits,
                       capabilities, capabilities,
                       mount_external, se_info, nice_name, false,
                       is_child_zygote == JNI_TRUE, instruction_set, app_data_dir,
                       is_top_app == JNI_TRUE, pkg_data_info_list,
                       whitelisted_data_info_list,
                       mount_data_dirs == JNI_TRUE,
                       mount_storage_dirs == JNI_TRUE);

    /*
     * 在虚拟机，系统框架初始化完成之后，加载frida框架
     * 需要增加头文件的引用 #include <dlfcn.h>
     */
#if defined(__x86_64__) || defined(__i386__)
      {
          #if defined(__x86_64__)
              #define FRIDA_LIB "/system/lib64/libfrida-gadget-14.2.2-android-x86_64.so"
          #else
              #define FRIDA_LIB "/system/lib/libfrida-gadget-14.2.2-android-x86.so"
          #endif
          const char *name = env->GetStringUTFChars(nice_name, 0);
          void* frida = dlopen(FRIDA_LIB, RTLD_NOW);
          if(NULL == frida) {
              ALOGE("(%s) load frida-gadget(%s) failed, err= %d\n", name, FRIDA_LIB, errno);
          } else {
              ALOGI("(%s) load frida-gadget(%s) success\n", name, FRIDA_LIB);
          }
          env->ReleaseStringUTFChars(nice_name, name);
      }
#endif

    }
    return pid;
}

static jint com_android_internal_os_Zygote_nativeForkAndSpecialize(

JNIEnv* env, jclass, jint uid, jint gid, jintArray gids,

jint runtime_flags, jobjectArray rlimits,

jint mount_external, jstring se_info, jstring nice_name,

jintArray managed_fds_to_close, jintArray managed_fds_to_ignore, jboolean is_child_zygote,

jstring instruction_set, jstring app_data_dir, jboolean is_top_app,

jobjectArray pkg_data_info_list, jobjectArray whitelisted_data_info_list,

jboolean mount_data_dirs, jboolean mount_storage_dirs) {

jlong capabilities = CalculateCapabilities(env, uid, gid, gids, is_child_zygote);

if (UNLIKELY(managed_fds_to_close == nullptr)) {

ZygoteFailure(env, "zygote", nice_name, "Zygote received a null fds_to_close vector.");

}

std::vector<int> fds_to_close =

ExtractJIntArray(env, "zygote", nice_name, managed_fds_to_close).value();

std::vector<int> fds_to_ignore =

ExtractJIntArray(env, "zygote", nice_name, managed_fds_to_ignore)

.value_or(std::vector<int>());

std::vector<int> usap_pipes = MakeUsapPipeReadFDVector();

fds_to_close.insert(fds_to_close.end(), usap_pipes.begin(), usap_pipes.end());

fds_to_ignore.insert(fds_to_ignore.end(), usap_pipes.begin(), usap_pipes.end());

fds_to_close.push_back(gUsapPoolSocketFD);

if (gUsapPoolEventFD != -1) {

fds_to_close.push_back(gUsapPoolEventFD);

fds_to_ignore.push_back(gUsapPoolEventFD);

}

if (gSystemServerSocketFd != -1) {

fds_to_close.push_back(gSystemServerSocketFd);

fds_to_ignore.push_back(gSystemServerSocketFd);

}

pid_t pid = ForkCommon(env, false, fds_to_close, fds_to_ignore, true);

if (pid == 0) {

SpecializeCommon(env, uid, gid, gids, runtime_flags, rlimits,

capabilities, capabilities,

mount_external, se_info, nice_name, false,

is_child_zygote == JNI_TRUE, instruction_set, app_data_dir,

is_top_app == JNI_TRUE, pkg_data_info_list,

whitelisted_data_info_list,

mount_data_dirs == JNI_TRUE,

mount_storage_dirs == JNI_TRUE);

* 在虚拟机，系统框架初始化完成之后，加载frida框架

* 需要增加头文件的引用 #include <dlfcn.h>

#if defined(__x86_64__) || defined(__i386__)

{

#if defined(__x86_64__)

#define FRIDA_LIB "/system/lib64/libfrida-gadget-14.2.2-android-x86_64.so"

#else

#define FRIDA_LIB "/system/lib/libfrida-gadget-14.2.2-android-x86.so"

#endif

const char *name = env->GetStringUTFChars(nice_name, 0);

void* frida = dlopen(FRIDA_LIB, RTLD_NOW);

if(NULL == frida) {

ALOGE("(%s) load frida-gadget(%s) failed, err= %d\n", name, FRIDA_LIB, errno);

} else {

ALOGI("(%s) load frida-gadget(%s) success\n", name, FRIDA_LIB);

}

env->ReleaseStringUTFChars(nice_name, name);

}

#endif

}

return pid;

}

编译并重新生成系统镜像：

$ cd ~/AndSrc/aosp/

$ export USE_CCACHE=1  

$ source build/envsetup.sh

$ lunch aosp_x86_64-eng

$ cd frameworks/base

$ mmm

# 如果只是替换镜像里面的so文件，不修改源代码，则需要执行 make snod 才能重新生成镜像
# cd ~/AndSrc/aosp/
# make snod

$ cd ~/AndSrc/aosp/

$ export USE_CCACHE=1

$ source build/envsetup.sh

$ lunch aosp_x86_64-eng

$ cd frameworks/base

$ mmm

# 如果只是替换镜像里面的so文件，不修改源代码，则需要执行 make snod 才能重新生成镜像

# cd ~/AndSrc/aosp/

# make snod

运行镜像

选择system-qemu.img和vendor-qemu.img，这两个镜像是专门为qemu运行制作的，如果选择system.img 和vendor.img，则avd运行失败。

$ cd ~/AndSrc/aosp

$ export ANDROID_BUILD_TOP=~/AndSrc/aosp

$ export PATH=$PATH:$ANDROID_BUILD_TOP/out/host/linux-x86/bin

$ export ANDROID_SWT=$ANDROID_BUILD_TOP/out/host/linux-x86/framework

$ export ANDROID_PRODUCT_OUT=$ANDROID_BUILD_TOP/out/target/product/generic_x86_64

$ ./prebuilts/android-emulator/linux-x86_64/emulator -system ./out/target/product/generic_x86_64/system-qemu.img -data ./out/target/product/generic_x86_64/data.img -ramdisk ./out/target/product/generic_x86_64/ramdisk-qemu.img -vendor ./out/target/product/generic_x86_64/vendor-qemu.img -verbose -show-kernel

$ cd ~/AndSrc/aosp

$ export ANDROID_BUILD_TOP=~/AndSrc/aosp

$ export PATH=$PATH:$ANDROID_BUILD_TOP/out/host/linux-x86/bin

$ export ANDROID_SWT=$ANDROID_BUILD_TOP/out/host/linux-x86/framework

$ export ANDROID_PRODUCT_OUT=$ANDROID_BUILD_TOP/out/target/product/generic_x86_64

$ ./prebuilts/android-emulator/linux-x86_64/emulator -system ./out/target/product/generic_x86_64/system-qemu.img -data ./out/target/product/generic_x86_64/data.img -ramdisk ./out/target/product/generic_x86_64/ramdisk-qemu.img -vendor ./out/target/product/generic_x86_64/vendor-qemu.img -verbose -show-kernel

上面运行起来的镜像是从~/AndSrc/aosp/out/debug/target/product/generic/hardware-qemu.ini即可读取配置信息的，但是这个文件直接修改无效，我们如果需要修改参数，只能从启动参数中设置。
比如我们如果需要增大内存，开启GPU的支持，则执行如下命令：

$ ./prebuilts/android-emulator/linux-x86_64/emulator -system ./out/target/product/generic_x86_64/system-qemu.img -data ./out/target/product/generic_x86_64/data.img -ramdisk ./out/target/product/generic_x86_64/ramdisk-qemu.img -vendor ./out/target/product/generic_x86_64/vendor-qemu.img -gpu on -memory 4096 -verbose -show-kernel

参考链接

Clang的线程安全分析模块Thread Safety Analysis

背景

最近在浏览 Android 11 源代码的时候，发现在ART虚拟机头文件 art_method.h 中，存在大量的类似REQUIRES_SHARED(Locks::mutator_lock_); 的代码。

继续阅读Clang的线程安全分析模块Thread Safety Analysis

Android SSL证书设置和锁定(SSL/TLS Pinning)

我们认识到在移动端开发中安全性设置非常重要，尤其是目前非常流程H5混合式开发APP，在Android开发中，我们可以通过证书锁定的方式来增加客户端与服务端的安全保障《证书锁定SSL Pinning简介及用途》，本文主要介绍 SSL数字证书在Android开发中的证书锁定(SSL/TLS Pinning)

1. 常规SSL证书设置

通常由CA权威机构签发的证书，其根证书都内置在最新的Android操作系统中，因此默认情况下可不进行SSL证书锁定，开发APP时也就变得非常简单，以infinisign.com为例，摘自App security best practices

1.1 JAVA方法

URL url = new URL("https://infinisign.com");
HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();
urlConnection.connect();
InputStream in = urlConnection.getInputStream();

URL url = new URL("https://infinisign.com");

HttpsURLConnection urlConnection = (HttpsURLConnection) url.openConnection();

urlConnection.connect();

InputStream in = urlConnection.getInputStream();

1.2 KOTLIN方法

val url = URL("https://infinisign.com")
val urlConnection = url.openConnection() as HttpsURLConnection
urlConnection.connect()
urlConnection.inputStream.use {
    ...
}

val url = URL("https://infinisign.com")

val urlConnection = url.openConnection() as HttpsURLConnection

urlConnection.connect()

urlConnection.inputStream.use {

...

}

2. 网络安全性设置

本方案是官方提供，但需要依赖Android N（Android 7.0 API 24）及以后版本，可在APP开发阶段在APP中内置安全性设置，以达到防止中间人攻击（MITM）的目的，此方法只限制在Android 7.0 API 24以后版本，因此该版本之前的安全性设置仍然需要使用证书锁定方法，本文以infinisign.com为例。

2.1 创建配置文件

创建文件res/xml/network_security_config.xml，需要注意的是，使用证书锁定，需要配置一个备份密钥，假如证书到期或更换了CA品牌后，不至于重新发行APP，这个备份密码可以是中级证书或根证书。

通俗的说，如果系统检测到签发证书过期了，则自动使用其中级或才根级证书作为验证，因为通常中级机构、根机构的证书到期时间非常长。

但实际情况是，infinisign.com所售的CA签发证书有效期都是一年，而现在发行APP或更新APP通常在一年都会有更新重新上架操作。

<?xml version="1.0" encoding="utf-8"?>
<network-security-config>
    <domain-config>
        <domain includeSubdomains="true">infinisign.com</domain>
        <pin digest="SHA-256">wLgBEAGmLltnXbK6pzpvPMeOCTKZ0QwrWGem6DkNf6o</pin>
        <!-- 备份密钥，比如infinisign.com的中级机构是geotrust -->
        <pin digest="SHA-256">wLgBEAGmLltnXbK6pzpvPMeOCTKZ0QwrWGem6DkNf6o</pin>
    </domain-config>
</network-security-config>

<?xml version="1.0" encoding="utf-8"?>

<network-security-config>

<domain-config>

<domain includeSubdomains="true">infinisign.com</domain>

<pin digest="SHA-256">wLgBEAGmLltnXbK6pzpvPMeOCTKZ0QwrWGem6DkNf6o</pin>

<pin digest="SHA-256">wLgBEAGmLltnXbK6pzpvPMeOCTKZ0QwrWGem6DkNf6o</pin>

</domain-config>

</network-security-config>

2.2 引入配置文件

在Androidmanifest.xml引入配置文件android:networkSecurityConfig="@xml/network_security_config"

<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
    <application
        android:networkSecurityConfig="@xml/network_security_config">
        <!-- application 其它子元素 -->
    </application>
</manifest>

<?xml version="1.0" encoding="utf-8"?>

<application

android:networkSecurityConfig="@xml/network_security_config">

</application>

</manifest>

3. okHttp锁定

okHttp是一个用于Android处理网络请求的开源项目，是安卓端最流行的轻量级的网络框架，其主要用来替代HttpUrlConnection处理方式

client = new OkHttpClient.Builder()
    .certificatePinner(new CertificatePinner.Builder()
    .add("infinisign.com", "sha256/S8Ff3JCaO4V...")
    .build())
    .build();

client = new OkHttpClient.Builder()

.certificatePinner(new CertificatePinner.Builder()

.add("infinisign.com", "sha256/S8Ff3JCaO4V...")

.build())

.build();

不过需要注意的是，okHttp锁定证书方式不适用于公钥锁定方式，必须以证书锁定方式内置SSL数字证书。

4. TrustManager锁定

TrustManager是一个比较老的证书锁定方法，主要用于早期的Android版本或者用于一些CA根机构在Android系统中缺失根证书的情形下，当然也适用于自签名证书的锁定，通常我们不建议这样做，因为TrustManager的缺点是中间人仍然可以使用成熟的绕过方案来实现截持。

在SSL普及的今天，let's encrypt的开源免费解决方案，和一些入门的便宜DV域名型SSL证书（见PositiveSSL ￥39/年）足以媲美自签名方案。

详细请参考javax.net.ssl.TrustManager接口实现，简单步骤如下

在APP源码中内置证书

/res/raw

1

/res/raw

使用KeyStore加载证书

val resourceStream = resources.openRawResource(R.raw.infinisign_cert)
val keyStoreType = KeyStore.getDefaultType()
val keyStore = KeyStore.getInstance(keyStoreType)
keyStore.load(resourceStream, null)

val resourceStream = resources.openRawResource(R.raw.infinisign_cert)

val keyStoreType = KeyStore.getDefaultType()

val keyStore = KeyStore.getInstance(keyStoreType)

keyStore.load(resourceStream, null)

TrustManagerFactory实例化证书

val trustManagerAlgorithm = TrustManagerFactory.getDefaultAlgorithm()
val trustManagerFactory = TrustManagerFactory.getInstance(trustManagerAlgorithm)
trustManagerFactory.init(keyStore)

val trustManagerAlgorithm = TrustManagerFactory.getDefaultAlgorithm()

val trustManagerFactory = TrustManagerFactory.getInstance(trustManagerAlgorithm)

trustManagerFactory.init(keyStore)

创建SSLContext实例，与TrustManager进行绑定。

val sslContext = SSLContext.getInstance("TLS")
sslContext.init(null, trustManagerFactory.trustManagers, null)
val url = URL("http://infinisign.com/")
val urlConnection = url.openConnection() as HttpsURLConnection
urlConnection.sslSocketFactory = sslContext.socketFactory

val sslContext = SSLContext.getInstance("TLS")

sslContext.init(null, trustManagerFactory.trustManagers, null)

val url = URL("http://infinisign.com/")

val urlConnection = url.openConnection() as HttpsURLConnection

urlConnection.sslSocketFactory = sslContext.socketFactory

总结

在多数移动操作系统中有大大小小几十个CA机构内置的根证书，但也不排除已经不被信任的CA机构存在的旧根证书，还有一些例如国内的一些基于Android老版本的操作系统仍然面临着安全风险，所以使用SSL数字证书锁定（SSL/TLS Pinning）的目标是缩小可信CA的范围，让APP客户端传送数据更安全，更切实地保障用户数据。

2025 年 5 月
一	二	三	四	五	六	日
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31