Android SDK安全加固问题与分析_android 加固时候软件有安全风险； 请确认软件是否为风险软件(2)

本人从事网路安全工作12年，曾在2个大厂工作过，安全服务、售后服务、售前、攻防比赛、安全讲师、销售经理等职位都做过，对这个行业了解比较全面。

最近遍览了各种网络安全类的文章，内容参差不齐，其中不伐有大佬倾力教学，也有各种不良机构浑水摸鱼，在收到几条私信，发现大家对一套完整的系统的网络安全从学习路线到学习资料，甚至是工具有着不小的需求。

最后，我将这部分内容融会贯通成了一套282G的网络安全资料包，所有类目条理清晰，知识点层层递进，需要的小伙伴可以点击下方小卡片领取哦！下面就开始进入正题，如何从一个萌新一步一步进入网络安全行业。

学习路线图

其中最为瞩目也是最为基础的就是网络安全学习路线图，这里我给大家分享一份打磨了3个月，已经更新到4.0版本的网络安全学习路线图。

相比起繁琐的文字，还是生动的视频教程更加适合零基础的同学们学习，这里也是整理了一份与上述学习路线一一对应的网络安全视频教程。

网络安全工具箱

当然，当你入门之后，仅仅是视频教程已经不能满足你的需求了，你肯定需要学习各种工具的使用以及大量的实战项目，这里也分享一份我自己整理的网络安全入门工具以及使用教程和实战。

项目实战

最后就是项目实战，这里带来的是SRC资料&HW资料，毕竟实战是检验真理的唯一标准嘛~

面试题

归根结底，我们的最终目的都是为了就业，所以这份结合了多位朋友的亲身经验打磨的面试题合集你绝对不能错过！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以点击这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

全文8359字，预计阅读时间21分钟。

01 问题背景

在移动互联网快速发展的背景下，Android 作为全球最受欢迎的移动操作系统，吸引了大量开发者和用户。随着应用市场的竞争加剧，保护应用程序的安全性和知识产权变得越来越重要。

同时，随着公司业务的发展，百度与外部友商深度合作，需要对外输出了百度业务能力SDK。在这种背景下，对Android代码进行加固成为了一种必要的安全措施。加固可以提高应用程序的安全性，保护知识产权，防止逆向工程和破解。

02 问题分析

Android 应用程序是由 Java/Kotlin 语言编写而成，然后打包成 APK 文件。Java 代码被编译成 APK/AAR 中的 dex 文件，dalvik/art 虚拟机解释执行 dex 中的字节码。攻击者可以使用反编译工具很容易的逆向分析 dex 文件，理解代码关键逻辑，增加恶意代码，再打包回 APK 文件。

可以看到，dex 文件就是代码加固的保护核心！

03 加固调研

为了解决对 dex文件的代码加固，我们进行了相关技术调研，其实在Android代码安全领域，相关技术一直属于不断攻防演进的过程。如下是业界常用的加固技术方案：比如最初的360加固给APK加壳，通过不落地动态加载实现加固；市场上常用的类方法抽取指令加固；以及将java方法转native方法jni调用等。

3.1 DexClassLoader 动态加载机制

利用 Android 系统的 DexClassLoader 动态加载机制，通过将保护的 dex 文件解压解密后，动态加载到内存中执行。

这种方式有效地抵御了 APK 文件的静态分析，使得逆向分析者无法在 APK 文件中找到真实的 dex 文件。但是由于动态加载技术主要依赖于java的动态加载机制，所以要求关键逻辑部分必须进行解压，并且释放到文件系统。

这种动态加载技术不足之处在于：1.这一解压释放机制就给攻击者留下直接获取对应文件的机会; 2.可以通过hook虚拟机关键函数，进行dump出原始的dex文件数据。

3.2 Hook 技术

针对 DexClassLoader 动态加载机制的保护缺陷，采用 Hook 技术来解决问题。

在动态加载过程中，通过替换 DexClassLoader 执行过程中的 dex 内存，将其替换为真实 dex 文件的内存，从而实现了无需将 dex 落地的加载方式。

然而，dex 文件虽然不会解密并保存到文件系统，但它在内存中是完整存在的。因此，在应用程序运行后，逆向分析者可以通过内存搜索的方式将 dex 文件转储出来。

3.3 指令抽取

为了对抗逆向开发通过内存搜索的方式将 dex 文件转储出来，加固技术采用了函数抽取的方法，使得 dex 文件在内存中一直处于不完整的状态。

其实现思路大致如下：

1、对要保护的 dex 文件进行预处理，将需要保护的函数指令抽取出来并进行加密存储，同时在原位置填充 nop 指令。

2、当 dalvik/art 执行到抽取的函数时，利用 hook 技术拦截 libdalvik.so/libart.so 中的指令读取部分，将函数对应的真实指令解密并填充，使得 dalvik/art 能够继续解释执行。

随着逆向技术的不断发展，改造 dalvik 并遍历所有 dex 方法，以及内存重组 dex，成为了对抗此种加固保护的有效方法。其中，dexhunter 是该领域的主要代表之一。

3.4 java2cpp 技术

随着内存脱壳机的出现，指令抽取的保护方式逐渐失去有效性。为了应对这一问题，java2cpp 技术开始被引入到加固保护中。

核心是对 dex 中的函数进行处理，将函数中的 dalvik 指令转换成等效的 cpp 代码（基于 JNI），然后编译成本地的动态链接库（native so 库），并将保护的方法标记为 native 属性。这样，在执行到受保护的方法时，执行流会转移到本地层执行对应的 cpp 代码。

比如原函数：

public class HelloVMP2 {
    public int compute(int a, int b) {
        int c = a + a;
        int d = a * b;
        int e = a - b;
        int f = a / b;
        int result = c + d + e + f;
        return result;
    }
}

转换后：

public class HelloVMP2 {

    static {
        System.loadLibrary("hello_vmp2");
    }

    public native int compute(int a, int b);
}

extern "C" JNIEXPORT jint JNICALL
Java_com_vmp_mylibrary_HelloVMP2_compute(JNIEnv* env, jobject obj, jint a, jint b) {
    jint c = a + a;
    jint d = a * b;
    jint e = a - b;
    jint f = a / b;
    jint result = c + d + e + f;
    return result;
}

这种方式下，仅将 java 转 cpp 编译成动态链接库，但是so代码依然可以被破解，在此基础上其实还是可以继续提高代码保护的安全性，那就是 DEX-VMP 技术。

3.5 DEX-VMP

DEX-VMP 原理理解起来比较容易，其针对的保护单位也是函数。将方法的 dalvik 指令转换成等价的自定义指令，函数原指令替换成自定义 VM 的调用入口指令，再将函数参数通过 VMP 入口传入到自定义 VM 中执行，自定义 VM 解释执行自定义指令。

如图，当 Dalvik VM 执行到 DEX-VMP 保护的函数时，执行的是 VMP native 入口函数，开始进入 VMP 的执行流程，VMP 首先会初始化 dex 文件信息，接着获取该保护方法的一些信息，比如寄存器数量，待执行指令的内存位置等，然后初始化寄存器存储结构，最后进入到解释器中解释执行每一条指令。在解释执行的过程，如果执行到外部函数，就会使用 JNI CallMethod 的形式调用，让其切换回 Dalvik VM，让 Dalvik 去执行真正的函数。

加固过程原函数的代码逻辑替换为 native 方法，同时对 Custom VM 进行初始化，原函数 native 方法负责将参数传入到 Custom VM 中，Custom VM 解释执行原代码的等价指令。

实现 DEX-VMP 总体来说需要两步：

1、对原 dex 处理，找到要保护的方法，将原指令翻译成等价指令，加密存储，并将原指令替换为 VMP 入口指令

2、实现 VM，解释执行存储的等价指令

3.6 加固方案对比

可以看到，加固技术是不断攻防升级的过程，下面我们将以上加固技术分为五代进行对比：

由以上对比我们可以看出，在加固技术演进过程中，VMP方案是发展到目前，加固安全度最高的方式，本着安全性角度出发，我们选择VMP方案重点介绍与分析，以下是对于项目中VMP加固的分析过程。

04 DEX-VMP加固落地实现

以下是我们要保护的一段示例代码：

package com.vmp.mylibrary;

public class HelleVMP3 {
    public int compute(int a, int b) {
        int c = a + a;
        int d = a * b;
        int e = a - b;
        int f = a / b;
        int result = c + d + e + f;
        return result;
    }
}

4.1 dex 文件预处理

dex 预处理主要做两方面工作:

1、保护方法的原指令拷贝出来并存储

2、保护方法的原指令替换成 VMP 入口方法

将要保护的 java 代码编译成 dex 文件，放入 010editor 中可以查看 compute 方法对应的指令数据：

可以看到蓝色区域包含的方法所需要的寄存器数，内部参数，外部参数及指令长度。这些都是 VM 需要的关键信息，需要存储起来。然后将指令替换为 DEX-VMP 的 native 入口指令。

有一些工具可以帮我们实现以上操作，比如 dexlib2，使用该工具可以对指定方法构造 dalvik 指令，或获取方法的指令数据。该工具的具体使用方法大家可以自定搜索。

4.2 寄存器结构设计

通过dexdump 命令查看，原方法二进制结构内容如下：

Virtual methods   -
    #0              : (in Lcom/vmp/mylibrary/HelloVMP3;)
      name          : 'compute'
      registers     : 6
      ins           : 3
      outs          : 0
      insns size    : 11 16-bit code units
28e588:                                        |[28e588] com.vmp.mylibrary.HelloVMP3.compute:(II)I
28e598: 9000 0404                              |0000: add-int v0, v4, v4
28e59c: 9201 0405                              |0002: mul-int v1, v4, v5
28e5a0: 9102 0405                              |0004: sub-int v2, v4, v5
28e5a4: b354                                   |0006: div-int/2addr v4, v5
28e5a6: b010                                   |0007: add-int/2addr v0, v1
28e5a8: b020                                   |0008: add-int/2addr v0, v2
28e5aa: b040                                   |0009: add-int/2addr v0, v4
28e5ac: 0f00                                   |000a: return v0

从示例 compute 方法的一些 hex 数据中，可以得到一些关键信息：

compute 方法在执行过程中需要使用到 6 个寄存器，传入参数 3 个， 没有使用 try 结构，指令数据为 16 个字。

Dalvik 寄存器最大长度为 32bit，我们可以直接申请一段内存来表示寄存器：

regptr_t regs[6];
regs[0] = 0;
regs[1] = 0;
regs[2] = 0;
regs[3] = 0;
regs[4] = 0;
regs[5] = 0;
regs[3] = (regptr_t) thiz;
regs[4] = p1;
regs[5] = p2;

u1 reg_flags[6];
reg_flags[0] = 0;
reg_flags[1] = 0;
reg_flags[2] = 0;
reg_flags[3] = 0;
reg_flags[4] = 0;
reg_flags[5] = 0;
reg_flags[3] = 1;

regs 表示寄存器，4 个寄存器分别为 regs [0], regs [1], regs [2], regs [3]。regs_bits_obj 表示对应寄存器是否是 Object，比如 regs [3] 是 Object，则 regs_bits_obj [3] = 1，非 object 的情况均为 0；

每一个保护方法在进入 VM 后，我们就像示例这样创建好这样的寄存器单元，供 VM 在解释执行阶段使用，执行完毕销毁即可。

注意这个过程的专业的加固工具会在 dex 预处理过程中识别二进制结构内容进行执行，无需每保护一个方法单独开发。

4.3 虚拟机实现

我们就以示例 compute 方法中的 add-int, mul-int, sub-int, div-int 这几条指令来实现一个简易的解释器

介绍一下这几条指令的作用：add-int、mul-int、sub-int、div-int 对两个源寄存器执行已确定的二元运算，并将结果存储到目标寄存器中。

首先定义自定义虚拟机需要执行的vmCode结构：

typedef struct {
    const u2 *insns; // 指令
    const u4 insnsSize; // 指令大小
    regptr_t *regs; // 寄存器
    u1 *reg_flags; // 寄存器数据类型标记,主要标记是否为对象
    const u1 *triesHandlers; // 异常表
} vmCode;

自定义Opcode：

enum Opcode {
    OP_ADD_INT = 0x3a,
    OP_MUL_INT = 0xe4,
    OP_SUB_INT = 0x77,
    OP_DIV_INT_2ADDR = 0x6c,
    OP_ADD_INT_2ADDR = 0xcf,
    OP_RETURN = 0xde,
};

目标方法转化的 native 方法：

static jint Java_com_vmp_mylibrary_HelloVMP3_compute__II_I(JNIEnv *env, jobject thiz , jint p1, jint p2) {
    regptr_t regs[6];
    regs[0] = 0;
    regs[1] = 0;
    regs[2] = 0;
    regs[3] = 0;
    regs[4] = 0;
    regs[5] = 0;
    regs[3] = (regptr_t) thiz;
    regs[4] = p1;
    regs[5] = p2;

    u1 reg_flags[6];
    reg_flags[0] = 0;
    reg_flags[1] = 0;
    reg_flags[2] = 0;
    reg_flags[3] = 0;
    reg_flags[4] = 0;
    reg_flags[5] = 0;
    reg_flags[3] = 1;

    static const u2 insns[] = {


### 给大家的福利


**零基础入门**


对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。


![](https://img-blog.csdnimg.cn/img_convert/95608e9062782d28f4f04f821405d99a.png)


同时每个成长路线对应的板块都有配套的视频提供：


![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/a91b9e8100834e9291cfcf1695d8cd42.png#pic_center)


因篇幅有限，仅展示部分资料

**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化资料的朋友，可以点击这里获取](https://bbs.csdn.net/forums/4f45ff00ff254613a03fab5e56a57acb)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**