前言

Xpatch是一款免Root实现App加载Xposed插件的工具，可以非常方便地实现App的逆向破解（再也不用改smali代码了），源码也已经上传到Github上，欢迎各位Fork and Star。

本文主要介绍Xpatch的实现原理。由于其原理比较复杂，所以分三篇文章来详细讲解。

由于Xpatch处理Xposed module的方法参考了Xposed框架部分源码，所以本文先介绍Xposed框架加载Xposed模块原理，再详细讲解Xpatch如何兼容Xposed模块。

Xposed框架加载Xposed Module的原理

Xposed是github上rovo89大神设计的一个针对Android平台的动态劫持项目，其主要原理是通过替换/system/bin/app_process程序控制zygote进程，使得app_process在启动过程中会加载XposedBridge.jar这个jar包，从而完成对Zygote进程及其创建的app进程的劫持。

XposedBridge.jar的入口方法是main()，其主要逻辑如下：

//de.robv.android.xposed.XposedBridge.java
    protected static void main(String[] args) {
        // Initialize the Xposed framework and modules
        try {
            if (!hadInitErrors()) {
                initXResources();

                SELinuxHelper.initOnce();
                SELinuxHelper.initForProcess(null);

                runtime = getRuntime();
                XPOSED_BRIDGE_VERSION = getXposedVersion();

                if (isZygote) {
                    XposedInit.hookResources();
                    XposedInit.initForZygote();
                }

                XposedInit.loadModules();
            } else {
                Log.e(TAG, "Not initializing Xposed because of previous errors");
            }
        } catch (Throwable t) {
            Log.e(TAG, "Errors during Xposed initialization", t);
            disableHooks = true;
        }

        // Call the original startup code
        if (isZygote) {
            ZygoteInit.main(args);
        } else {
            RuntimeInit.main(args);
        }
    }

这里最核心的一行代码是:

XposedInit.loadModules();

在这个方法里，通过读取/data/data/de.robv.android.xposed.installer/conf/modules.list这个文件，找到需要加载的Xposed插件(APK)路径。而这些路径都是通过Xposed Installer这个App里的开关控制的。在Xposed Installer App里，有一个已安装的Xposed插件列表，用户选定某个插件后，就会将该插件APK路径写到modules.list文件里，从而实现插件开关的控制。

在modules.list文件里查找到所有插件APK路径后，根据Apk的绝对路径构造一个PathClassLoader()，然后用此Classloader加载全类名写在资源文件assets/xposed_init里的入口类，其核心逻辑代码如下：

//de.robv.android.xposed.XposedInit.java
...
...
ClassLoader mcl = new PathClassLoader(apk, XposedBridge.BOOTCLASSLOADER);
        BufferedReader moduleClassesReader = new BufferedReader(new InputStreamReader(is));
        try {
            String moduleClassName;
            while ((moduleClassName = moduleClassesReader.readLine()) != null) {
                moduleClassName = moduleClassName.trim();
                if (moduleClassName.isEmpty() || moduleClassName.startsWith("#"))
                    continue;

                try {
                    Log.i(TAG, "  Loading class " + moduleClassName);
                    Class<?> moduleClass = mcl.loadClass(moduleClassName);

                    if (!IXposedMod.class.isAssignableFrom(moduleClass)) {
                        Log.e(TAG, "    This class doesn't implement any sub-interface of IXposedMod, skipping it");
                        continue;
                    } else if (disableResources && IXposedHookInitPackageResources.class.isAssignableFrom(moduleClass)) {
                        Log.e(TAG, "    This class requires resource-related hooks (which are disabled), skipping it.");
                        continue;
                    }
                    ...
                    ...

加载到这些类之后，将这些类使用全局变量保存起来：

if (moduleInstance instanceof IXposedHookLoadPackage)
    XposedBridge.hookLoadPackage(new IXposedHookLoadPackage.Wrapper((IXposedHookLoadPackage) moduleInstance));

    ...
    ...
    
    //保存在全局变量sLoadedPackageCallbacks里
public static void hookLoadPackage(XC_LoadPackage callback) {
        synchronized (sLoadedPackageCallbacks) {
            sLoadedPackageCallbacks.add(callback);
        }
    }

保存起来后，何时执行这些类里的入口方法呢？
下面一段代码，给出了答案：

// normal process initialization (for new Activity, Service, BroadcastReceiver etc.)
        findAndHookMethod(ActivityThread.class, "handleBindApplication", "android.app.ActivityThread.AppBindData", new XC_MethodHook() {
            @Override
            protected void beforeHookedMethod(MethodHookParam param) {
                ...
            
                XC_LoadPackage.LoadPackageParam lpparam = new XC_LoadPackage.LoadPackageParam(XposedBridge.sLoadedPackageCallbacks);
                lpparam.packageName = reportedPackageName;
                lpparam.processName = (String) getObjectField(param.args[0], "processName");
                lpparam.classLoader = loadedApk.getClassLoader();
                lpparam.appInfo = appInfo;
                lpparam.isFirstApplication = true;
                XC_LoadPackage.callAll(lpparam);
                ...
        });

通过上面代码可知，是在main入口处拦截了ActivityThread的handleBindApplication方法，在这个方法执行之前，加载了Xposed插件里的Hook代码(入口代码)。而ActivityThread的handleBindApplication方法的主要功能就是创建Application，并调用其attachBaseContext，onCreate等方法。因此，在App的Application创建之前就实现了Xposed Hook。

至此，Xposed框架加载Xposed module的流程就非常清晰了。

免Root实现Xposed的探索

由于Xposed框架是修改了/system/bin/app_process程序，控制的zygote进程的启动，从而在app进程启动之前执行了加载xposed模块，实现了App代码的Hook。因此，只有Root的手机才能使用Xposed。

那有没有办法实现免Root下也能让App加载Xposed模块呢？

其中一种已经被探索过的方法是使用App双开工具，让其他App运行在自己的App里面。比如，利用大名鼎鼎的开源双开工具VirtualApp，让其他App运行其中，这样VirtualApp就可以控制其他App的进程启动了，当然也就可以实现免Root加载Xposed模块了。

不过，这样做也有一些问题，其兼容性和稳定性比较差。而且，由于VirtualApp的开源版本已经很少维护，bug会比较多，有些App在里面启动非常卡顿，甚至无法启动

那有没有更好的方案呢？

有，那就是基于Apk二次打包的Xpatch方案。

为了实现免Root Xposed，我们可以修改App入口代码，在App的Application初始化时，插入我们加载Xposed模块的代码，并对App进行重新打包签名即可。

Xpatch加载Xposed模块的方法

通过以上分析，Xposed框架执行Xposed模块的入口位置是通过Hook ActivityThread的handleBindApplication方法，从而使在创建应用的Application之前就执行Xposed模块里的入口方法（执行Hook流程）。

由于我们是修改应用代码，因此入口只能在应用的Application里，可以是Application的静态方法块，也可以是attachBaseContext方法或onCreate方法。

那到底应该选择哪个作为加载Xposed模块的入口呢？

首先，肯定是越早Hook越好，否则可能会出现有些方法调用之后才执行Hook方法，导致方法没有被Hook到。而且加载Xposed插件需要用到Applicatin的context参数，所以笔者选了在attachBaseContext方法的第一行代码执行加载Xposed模块：

    // MyApplication.java
    @Override
    protected void attachBaseContext(Context base) {
        XposedModuleEntry.init(base);
        ...
        //App其他业务代码
        ...
        super.attachBaseContext(base);
    }

通过对一些app进行测试，发现大多数应用走这个流程都没问题，唯一有问题的是微信，修改后的微信一启动就奔溃，具体原因暂时不清楚。

因此，我尝试将加载Xposed模块的入口代码放在Application的静态代码块里，静态代码块在类创建的时候就会执行，比attachBaseContext方法执行的时机更早。

通过测试，修改后的微信的确能够成功启动！！

    // MyApplication.java中的静态代码块
    static {
        XposedModuleEntry.init();
    }

但是，在Application的静态代码块中，并没有Application的context参数，而加载Xposed模块时，需要传递参数，参数中的applicationInfo和应用的classLoader都是需要从Context中取得，没有Context怎么办？总不能传个空过去吧。

既然没有Context，我们就自己构造一个Context。

创建App Context流程

Android sdk并没有提供应用自己创建context的方法，为了找到构建一个Application Context的方法，我们先来了解android Framework里是如何创建Application的Context。

Application里最早出现Context的地方是attachBaseContext方法:

// Application的父类android.content.ContextWrapper.java
    protected void attachBaseContext(Context base) {
        if (mBase != null) {
            throw new IllegalStateException("Base context already set");
        }
        mBase = base;
    }

这个方法唯一调用的地方是：

// android.app.Application.java
    /**
     * @hide
     */
    /* package */ final void attach(Context context) {
        attachBaseContext(context);
        mLoadedApk = ContextImpl.getImpl(context).mPackageInfo;
    }

Application里的attach方法是在new Application之后立即调用的，具体是在android.app.Instrumentation.java里：

// android.app.Instrumentation.java
public Application newApplication(ClassLoader cl, String className, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
        return newApplication(cl.loadClass(className), context);
    }
    
static public Application newApplication(Class<?> clazz, Context context)
            throws InstantiationException, IllegalAccessException, 
            ClassNotFoundException {
    Application app = (Application)clazz.newInstance();
    app.attach(context);
    return app;
}

Instrumentation类的newApplication方法最终又是在android.app.LoadedApk.java类里的makeApplication方法调用的：

// android.app.LoadedApk.java
public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation) {
            ...
            //代码省略
            ...
            String appClass = mApplicationInfo.className;
        if (forceDefaultAppClass || (appClass == null)) {
            appClass = "android.app.Application";
        }
           ...
           //代码省略
           ...
            ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);
            app = mActivityThread.mInstrumentation.newApplication(
                    cl, appClass, appContext);
            appContext.setOuterContext(app);
          
            ...
            //代码省略
            ...
}

终于看到构造context的方法了

ContextImpl appContext = ContextImpl.createAppContext(mActivityThread, this);

这个方法的实现是：

// android.app.ContextImpl.java
static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo) {
        if (packageInfo == null) throw new IllegalArgumentException("packageInfo");
        ContextImpl context = new ContextImpl(null, mainThread, packageInfo, null, null, null, 0,
                null);
        context.setResources(packageInfo.getResources());
        return context;
    }

createAppContext方法需要传两个参数，一个是mActivityThread，另一个是this，也就是LoadedApk对象。mActivityThread这个对象比较容易找到，因为一个进程只有一个ActivityThread对象，只用通过反射调用ActivityThread的静态方法currentActivityThread即可：

// android.app.ActivityThread.java
public static ActivityThread currentActivityThread() {
        return sCurrentActivityThread;
}

反射：

//反射调用ActivityThread.java的静态方法currentActivityThread()
Class activityThreadClass = Class.forName("android.app.ActivityThread");
Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");
currentActivityThreadMethod.setAccessible(true);
Object activityThreadObj = currentActivityThreadMethod.invoke(null);

另外一个对象LoadedApk该如何获取呢？

LoadedApk对象的获取

上面代码分析过，App启动时最先调用 ActivityThead的handleBindApplication(AppBindData data)方法，并在其这个方法里创建Application，而创建Application的唯一方法是

// android.app.LoadedApk.java
public Application makeApplication(boolean forceDefaultAppClass,
            Instrumentation instrumentation){}

查看handleBindApplication方法具体实现过程，发现makeApplication确实被调用到：

// android.app.ActivityThread.java
private void handleBindApplication(AppBindData data) {
        ...
        //其他代码省略
        ...
    mBoundApplication = data;
    mConfiguration = new Configuration(data.config);
    mCompatConfiguration = new Configuration(data.config);
         ...
        //其他代码省略
        ...
    data.info = getPackageInfoNoCheck(data.appInfo, data.compatInfo);
         ...
        //其他代码省略
        ...
        // 创建Application
    Application app = data.info.makeApplication(data.restrictedBackupMode, null);
    mInitialApplication = app;
        ...
        //其他代码省略
        ...
}

根据以上代码可知，LoadedApk的实例就是data.info，而data.info是通过方法getPackageInfoNoCheck来获取的，而且data.info对象存到了全局变量mBoundApplication里，因此，mBoundApplication对象里的info变量就是我们要找的LoadedApk实例。

我们可以通过反射来获取它：

// 获取ActivityThread的mBoundApplication变量
Field boundApplicationField = activityThreadClass.getDeclaredField("mBoundApplication");
boundApplicationField.setAccessible(true);
Object mBoundApplicationObj = boundApplicationField.get(activityThreadObj);   // mBoundApplication: AppBindData

// 获取mBoundApplication的info变量（LoadedApk）
Field infoField = mBoundApplicationObj.getClass().getDeclaredField("info");   // info: LoadedApk
infoField.setAccessible(true);
Object loadedApkObj = infoField.get(mBoundApplicationObj);  // LoadedApk

获取到ActivityThread和LoadedApk后，通过反射调用ContextImpl的静态方法createAppContext就可以构造一个context对象：

Class contextImplClass = Class.forName("android.app.ContextImpl");
//Get createAppContext method
Method createAppContextMethod = contextImplClass.getDeclaredMethod("createAppContext", activityThreadClass, loadedApkObj.getClass());
createAppContextMethod.setAccessible(true);

// call method: ContextImpl.createAppContext()
Object context = createAppContextMethod.invoke(null, activityThreadObj, loadedApkObj);

至此，我们在Application的静态代码块中成功得到Application context。

Comming soon...

下一篇Xpatch源码解析中，我们将接着这部分内容介绍XposedModuleEntry.init();这个方法的具体实现逻辑，然后再介绍如何利用dex2jar工具修改Apk中dex文件。

关注我的技术公众号获取最新高质量Android技术文章：Android葵花宝典
扫一扫关注

如果喜欢此文，就给点鼓励呗！