NDK--so插件化原理，hook技术实现andfix热修复

aruba

发布于 2020-07-03 14:34:23

1.3K0

发布于 2020-07-03 14:34:23

文章被收录于专栏：android技术

1.首先介绍so插件化原理，也就是hook，先研究一个问题：当我们知道so库中的函数名和参数时，如何调用so中的函数？

我们在linux系统下新建一个c文件如下：

sum.c

int sum(int a,int b){
  return a+b;
}

使用gcc编译成一个动态链接库

gcc -fPIC -shared -o sum.so sum.c

再新建一个c文件，用来调用so库中的函数，现在我们知道sum.so中的函数名和参数，所以先定义一个与之对应的函数指针

main.c

typedef int (*sum)(int,int);

int main(){

}

再调用dlopen函数获取动态链接库的句柄，dlopen函数需要导入dlfcn.h头文件，然后使用dlsym函数获取相应函数在内存中的地址

#include<dlfcn.h>
#include<stdio.h>

typedef int (*sum)(int,int);

int main(){
  void *handle = dlopen("./sum.so",RTLD_LAZY);
  sum sum_address = 0;
  //将函数指针指向调用dlsym函数返回的sum函数的地址
  sum_address = dlsym(handle,"sum");
  printf("%d\n",sum_address(10,20));
}

使用gcc编译main.c文件

gcc -rdynamic -o main main.c -ldl

执行可执行文件结果：

插件化原理：main.c文件不需要知道sum.so中的函数具体做了什么，只需要知道函数名和参数就可以做到调用对应函数，如：将sum函数的功能修改成将两个int变量相乘，只需要修改sum中的代码，重新编译下sum.c就可以了，不需要重新编译main.c。还可以从服务器下载so的方式调用，达成插件化。甚至调用其他APP的so。

2.热修复手写实现

在我们产品发布时，线上APP也有可能出现bug，如果想要修复bug，可以通过升级版本，重新发布APP的方式。但如果bug比较致命，那么热修复就是救命稻草，热修复可以不需要升级APP就可以做到修复bug。市面上的热修复技术有很多，今天来探究下阿里系的andfix是如何做到不升级就修复bug的

首先我们在app中模拟一个bug，在工具类中创建一个方法，用来模拟异常

package com.aruba.andfixapplication;

/**
 * Created by aruba on 2020/4/30.
 */
public class Tools {

    public static int calc(int origin) {
        int result = origin / 0;
        return result;
    }

}

很明显任何数除以0都会抛异常。在java虚拟机中，每个java文件会编译成class文件，在需要使用时会加载到JVM中，被加载到JVM中的class（每个java文件）有且仅有一份内存，而class的方法，最终会被加载到方法区。在c/c++中，我们知道每个函数最终都会存放在内存中，有一个指针指向函数的内存地址，就像上面讲到的so插件化原理，如果在java中，我们可以修改方法的指向，让它指向我们更正的方法，就可以实现不用升级APP就可以修改bug

而当我们掌握了JNI，我们不必只从java层考虑，我们可以从native层，利用c/c++改变class的方法指向。我们从这点入手，将java的方法对象（Method）传给native层。

这边模拟服务器，新建一个文件夹，创建更正的方法

package com.aruba.andfixapplication.web;

/**
 * Created by aruba on 2020/4/30.
 */
public class Tools {

    public static int calc(int origin) {
        int result = origin / 1;
        return result;
    }

}

替换方法需要知道相应的类全名和方法名，这边使用注解用于指定更正方法中需要更正的类和方法

package com.aruba.andfixapplication;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Created by aruba on 2020/4/30.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Replace {
    String clazz();

    String method();
}

package com.aruba.andfixapplication.web;

import com.aruba.andfixapplication.Replace;

/**
 * Created by aruba on 2020/4/30.
 */
public class Tools {

    @Replace(clazz = "com.aruba.andfixapplication.Tools", method = "calc")
    public static int calc(int origin) {
        int result = origin / 1;
        return result;
    }

}

接下来我们需要加载新的Tools类的class，将方法指针替换，但是在我们安卓中，虚拟机并不是JVM，而是dalvik和art虚拟机，编译过程中会将class文件打包成dex文件，所以我们还需要手动将class打包成dex文件。我们在AS中build下，找到class文件

来到目录下，将其他的class文件删除

删除其他class文件

进入cmd，切换到classes目录（该文件夹下有对应包名的目录），使用sdk目录下build-tools文件夹中的dx批处理文件，在命令行下执行如下命令：

C:\Users\tyqhc\AppData\Local\Android\sdk\build-tools\29.0.2\dx --dex --output ./out.dex ./

成功生成dex文件，如下：

先保存这份dex文件，后续我们将它放入手机sd卡中模拟从服务器下载dex文件。接下来编写加载dex文件，获取Method的代码

package com.aruba.andfixapplication;

import android.content.Context;
import android.os.Build;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Enumeration;

import dalvik.system.DexFile;

/**
 * Created by aruba on 2020/4/30.
 */
public class DexManager {
    private Context mContext;

    private static final DexManager ourInstance = new DexManager();

    public static DexManager getInstance() {
        return ourInstance;
    }

    private DexManager() {
    }

    public void setContext(Context mContext) {
        this.mContext = mContext;
    }

    public void loadDexFile(File file) {
        try {
            DexFile dexFile = DexFile.loadDex(file.getAbsolutePath(),
                    new File(mContext.getCacheDir(), "fix.dex").getAbsolutePath(),
                    Context.MODE_PRIVATE);
            //类名迭代器
            Enumeration<String> entry = dexFile.entries();
            while (entry.hasMoreElements()) {
                String className = entry.nextElement();
                //Class.forName()获取不到，因为没有加载，我们需要手动加载
                Class clazz = dexFile.loadClass(className, mContext.getClassLoader());
                if (clazz != null) {
                    //开始修复
                    fixClass(clazz);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void fixClass(Class clazz) {
        //获取class中的方法
        Method[] methods = clazz.getDeclaredMethods();
        for (int i = 0; i < methods.length; i++) {
            //获取注解
            Replace replace = methods[i].getAnnotation(Replace.class);
            if (replace == null) continue;

            //获取注解中需要被修复的方法和类
            String bugClazzStr = replace.clazz();
            String bugMethodStr = replace.method();

            try {
                Class bugClazz = Class.forName(bugClazzStr);
                //错误的方法
                Method bugMethod = bugClazz.getMethod(bugMethodStr, methods[i].getParameterTypes());
                if (Build.VERSION.SDK_INT <= 19) {//4.4版本以下，dalvik
                    replace(Build.VERSION.SDK_INT, bugMethod, methods[i], clazz);
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            }
        }
    }

    private native void replace(int sdk, Method wrongMethod, Method rightMethod, Class rightClazz);
}

最后将两个Method通过native方法replace处理。在处理之前，我们还需要了解安卓虚拟机的原理，在安卓4.4以前使用的是dalvik虚拟机：

DVM的源码位于dalvik/目录下，其中dalvik/vm目录下的内容是DVM的具体实现部分，它会被编译成libdvm.so；dalvik/libdex会被编译成libdex.a静态库，作为dex工具使用； dalvik/dexdump是.dex文件的反编译工具；DVM的可执行程序位于dalvik/dalvikvm中，将会被编译成dalvikvm可执行程序。

我们java的对象都继承至Object，而它其实是一个c语言中的结构体ClassObject，结构如下图：

其中vtable为方法表，存放了这个class的所有函数指针，我们核心就是要改变函数指针的指向

虚拟机加载类的流程如下图：

类加载最终会打上CLASS_INITIALIZED的标记，即上述结构体中ClassStatus对象为CLASS_INITIALIZED，只有有这个标记，它才能被正常使用

了解了这些后，接下来的思路为：在native层中，找到刚才在java层利用DexFile加载的class，与之对应的native层的ClassObject结构体，将它的ClassStatus对象status变为CLASS_INITIALIZED；然后将出现bug的Method指向修复的Method指针

编写相应c++代码

#include <jni.h>
#include <string>
#include <dlfcn.h>
#include "dalvik.h"

extern "C"
JNIEXPORT void JNICALL
Java_com_aruba_andfixapplication_DexManager_replace(JNIEnv *env, jobject instance, jint sdk,
                                                    jobject bug_methodMethod,
                                                    jobject fix_methodMethod,
                                                    jclass fix_methodClazz) {
    //第一步，根据java中的Method，获取native层中的Method指针
    Method *bug_method = (Method *) env->FromReflectedMethod(bug_methodMethod);
    Method *fix_method = (Method *) env->FromReflectedMethod(fix_methodMethod);

    //第二步，找到ClassObject
    //获取dalvik虚拟机动态链接库的句柄
    void *dvm_hand = dlopen("libdvm.so", RTLD_NOW);
    //利用hook，获取so库中的方法
    typedef Object *(*FindObject)(void *thread, jobject jobject1);
    typedef void *(*FindThread)();
    //该函数为根据方法返回ClassObject，需要两个参数，1：虚拟机线程 2：class对象
    FindObject findObject = (FindObject) dlsym(dvm_hand, sdk > 10 ?
                                                         "_Z20dvmDecodeIndirectRefP6ThreadP8_jobject"
                                                                  :
                                                         "dvmDecodeIndirectRef");;
    //该函数返回虚拟机线程
    FindThread findThread = (FindThread) dlsym(dvm_hand,
                                               sdk > 10 ? "_Z13dvmThreadSelfv" : "dvmThreadSelf");

    //找到ClassObject，将status变为CLASS_INITIALIZED
    ClassObject *firstFiled = (ClassObject *) findObject(findThread(), fix_methodClazz);
    firstFiled->status = CLASS_INITIALIZED;

    //第三步，改变method指针
    bug_method->accessFlags |= ACC_PUBLIC;
    bug_method->methodIndex = fix_method->methodIndex;
    bug_method->jniArgInfo = fix_method->jniArgInfo;
    bug_method->registersSize = fix_method->registersSize;
    bug_method->outsSize = fix_method->outsSize;
    //方法参数 原型
    bug_method->prototype = fix_method->prototype;
    bug_method->insns = fix_method->insns;
    bug_method->nativeFunc = fix_method->nativeFunc;
}

最终效果：

正常运行：