Android插件化原理解析——Hook机制之动态代理

转自 http://weishu.me/2016/01/28/understand-plugin-framework-proxy-hook/

使用代理机制进行API Hook进而达到方法加强是框架的经常使用手段，好比J2EE框架Spring经过动态代理优雅地实现了AOP编程，极大地提高了Web开发效率；一样，插件框架也普遍使用了代理机制来加强系统API从而达到插件化的目的。本文将带你了解基于动态代理的Hook机制。

阅读本文以前，能够先clone一份 understand-plugin-framework，参考此项目的dynamic-proxy-hook模块。另外，插件框架原理解析系列文章见索引。

代理是什么

为何须要代理呢？其实这个代理与平常生活中的“代理”，“中介”差很少；好比你想海淘买东西，总不可能亲自飞到国外去购物吧，这时候咱们使用第三方海淘服务好比惠惠购物助手等；一样拿购物为例，有时候第三方购物会有折扣好比当初的米折网，这时候咱们能够少花点钱；固然有时候这个“代理”比较坑，坑咱们的钱，坑咱们的货。

从这个例子能够看出来，代理能够实现方法加强，好比经常使用的日志,缓存等；也能够实现方法拦截，经过代理方法修改原方法的参数和返回值，从而实现某种不可告人的目的～接下来咱们用代码解释一下。

静态代理

静态代理，是最原始的代理方式；假设咱们有一个购物的接口，以下：

1 2 3

public interface Shopping { Object[] doShopping(long money); }

它有一个原始的实现，咱们能够理解为亲自，直接去商店购物：

1 2 3 4 5 6 7 8

public class ShoppingImpl implements Shopping { @Override public Object[] doShopping(long money) { System.out.println("逛淘宝 ,逛商场,买买买!!"); System.out.println(String.format("花了%s块钱", money)); return new Object[] { "鞋子", "衣服", "零食" }; } }

好了，如今咱们本身没时间可是须要买东西，因而咱们就找了个代理帮咱们买：

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

public class ProxyShopping implements Shopping { Shopping base; ProxyShopping(Shopping base) { this.base = base; } @Override public Object[] doShopping(long money) { // 先黑点钱(修改输入参数) long readCost = (long) (money * 0.5); System.out.println(String.format("花了%s块钱", readCost)); // 帮忙买东西 Object[] things = base.doShopping(readCost); // 偷梁换柱(修改返回值) if (things != null && things.length > 1) { things[0] = "被掉包的东西!!"; } return things; }

很不幸，咱们找的这个代理有点坑，坑了咱们的钱还坑了咱们的货；先忍忍。

动态代理

传统的静态代理模式须要为每个须要代理的类写一个代理类，若是须要代理的类有几百个那不是要累死？为了更优雅地实现代理模式，JDK提供了动态代理方式，能够简单理解为JVM能够在运行时帮咱们动态生成一系列的代理类，这样咱们就不须要手写每个静态的代理类了。依然以购物为例，用动态代理实现以下：

1 2 3 4 5 6 7 8 9 10

public static void main(String[] args) { Shopping women = new ShoppingImpl(); // 正常购物 System.out.println(Arrays.toString(women.doShopping(100))); // 招代理 women = (Shopping) Proxy.newProxyInstance(Shopping.class.getClassLoader(), women.getClass().getInterfaces(), new ShoppingHandler(women)); System.out.println(Arrays.toString(women.doShopping(100))); }

动态代理主要处理InvocationHandler和Proxy类；完整代码能够见github

代理Hook

咱们知道代理有比原始对象更强大的能力，好比飞到国外买东西，好比坑钱坑货；那么很天然，若是咱们本身建立代理对象，而后把原始对象替换为咱们的代理对象，那么就能够在这个代理对象随心所欲了；修改参数，替换返回值，咱们称之为Hook。

下面咱们Hook掉startActivity这个方法，使得每次调用这个方法以前输出一条日志；（固然，这个输入日志有点点弱，只是为了展现原理；只要你想，你想能够替换参数，拦截这个startActivity过程，使得调用它致使启动某个别的Activity，混淆是非！）

首先咱们得找到被Hook的对象，我称之为Hook点；什么样的对象比较好Hook呢？天然是容易找到的对象。什么样的对象容易找到？静态变量和单例；在一个进程以内，静态变量和单例变量是相对不容易发生变化的，所以很是容易定位，而普通的对象则要么没法标志，要么容易改变。咱们根据这个原则找到所谓的Hook点。

而后咱们分析一下startActivity的调用链，找出合适的Hook点。咱们知道对于Context.startActivity（Activity.startActivity的调用链与之不一样），因为Context的实现其实是ContextImpl;咱们看ConetxtImpl类的startActivity方法：

1 2 3 4 5 6 7 8 9 10 11 12 13

@Override public void startActivity(Intent intent, Bundle options) { warnIfCallingFromSystemProcess(); if ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 0) { throw new AndroidRuntimeException( "Calling startActivity() from outside of an Activity " + " context requires the FLAG_ACTIVITY_NEW_TASK flag." + " Is this really what you want?"); } mMainThread.getInstrumentation().execStartActivity( getOuterContext(), mMainThread.getApplicationThread(), null, (Activity)null, intent, -1, options); }

这里，实际上使用了ActivityThread类的mInstrumentation成员的execStartActivity方法；注意到，ActivityThread 其实是主线程，而主线程一个进程只有一个，所以这里是一个良好的Hook点。

接下来就是想要Hook掉咱们的主线程对象，也就是把这个主线程对象里面的mInstrumentation给替换成咱们修改过的代理对象；要替换主线程对象里面的字段，首先咱们得拿到主线程对象的引用，如何获取呢？ActivityThread类里面有一个静态方法currentActivityThread能够帮助咱们拿到这个对象类；可是ActivityThread是一个隐藏类，咱们须要用反射去获取，代码以下：

1 2 3 4 5

// 先获取到当前的ActivityThread对象 Class<?> activityThreadClass = Class.forName("android.app.ActivityThread"); Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread"); currentActivityThreadMethod.setAccessible(true); Object currentActivityThread = currentActivityThreadMethod.invoke(null);

拿到这个currentActivityThread以后，咱们须要修改它的mInstrumentation这个字段为咱们的代理对象，咱们先实现这个代理对象，因为JDK动态代理只支持接口，而这个Instrumentation是一个类，没办法，咱们只有手动写静态代理类，覆盖掉原始的方法便可。（cglib能够作到基于类的动态代理，这里先不介绍）

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 32 33 34 35 36 37

public class EvilInstrumentation extends Instrumentation { private static final String TAG = "EvilInstrumentation"; // ActivityThread中原始的对象, 保存起来 Instrumentation mBase; public EvilInstrumentation(Instrumentation base) { mBase = base; } public ActivityResult execStartActivity( Context who, IBinder contextThread, IBinder token, Activity target, Intent intent, int requestCode, Bundle options) { // Hook以前, XXX到此一游! Log.d(TAG, "\n执行了startActivity, 参数以下: \n" + "who = [" + who + "], " + "\ncontextThread = [" + contextThread + "], \ntoken = [" + token + "], " + "\ntarget = [" + target + "], \nintent = [" + intent + "], \nrequestCode = [" + requestCode + "], \noptions = [" + options + "]"); // 开始调用原始的方法, 调不调用随你,可是不调用的话, 全部的startActivity都失效了. // 因为这个方法是隐藏的,所以须要使用反射调用;首先找到这个方法 try { Method execStartActivity = Instrumentation.class.getDeclaredMethod( "execStartActivity", Context.class, IBinder.class, IBinder.class, Activity.class, Intent.class, int.class, Bundle.class); execStartActivity.setAccessible(true); return (ActivityResult) execStartActivity.invoke(mBase, who, contextThread, token, target, intent, requestCode, options); } catch (Exception e) { // 某该死的rom修改了 须要手动适配 throw new RuntimeException("do not support!!! pls adapt it"); } } }

Ok，有了代理对象，咱们要作的就是偷梁换柱！代码比较简单，采用反射直接修改：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public static void attachContext() throws Exception{ // 先获取到当前的ActivityThread对象 Class<?> activityThreadClass = Class.forName("android.app.ActivityThread"); Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread"); currentActivityThreadMethod.setAccessible(true); Object currentActivityThread = currentActivityThreadMethod.invoke(null); // 拿到原始的 mInstrumentation字段 Field mInstrumentationField = activityThreadClass.getDeclaredField("mInstrumentation"); mInstrumentationField.setAccessible(true); Instrumentation mInstrumentation = (Instrumentation) mInstrumentationField.get(currentActivityThread); // 建立代理对象 Instrumentation evilInstrumentation = new EvilInstrumentation(mInstrumentation); // 偷梁换柱 mInstrumentationField.set(currentActivityThread, evilInstrumentation); }

好了，咱们启动一个Activity测试一下

可见，Hook确实成功了！这就是使用代理进行Hook的原理——偷梁换柱。整个Hook过程简要总结以下：

1. 寻找Hook点，原则是静态变量或者单例对象，尽可能Hook pulic的对象和方法，非public不保证每一个版本都同样，须要适配。
2. 选择合适的代理方式，若是是接口能够用动态代理；若是是类能够手动写代理也可使用cglib。
3. 偷梁换柱——用代理对象替换原始对象

完整代码参照：understand-plugin-framework；里面留有一个做业：咱们目前仅Hook了Context类的startActivity方法，可是Activity类却使用了本身的mInstrumentation；你能够尝试Hook掉Activity类的startActivity方法。

喜欢就点个赞吧～持续更新，请关注github项目 understand-plugin-framework和个人 博客!