前言
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葵花宝典
扫一扫关注
如果喜欢此文，就给点鼓励呗！
