一.简介

      Hook技术是一种用于改变API执行结果的技术，Android系统中有一套自己的事件分发机制，所有的代码调用和回调都是按照一定顺序执行的，Hook技术存在的意义就在于，Hook可以帮助我们在Android中在SDK源代码逻辑执行过程中，通过代码手动拦截执行该逻辑，加入自己的代码逻辑。
      为了保证hook的稳定性，一般拦截的点都会选择比较容易找到并且不易发生变化的对象，比如静态变量和单例。
      提到Hook，就不得不说一下Java的反射机制。

二.反射

      Java反射机制主要提供了以下功能：
            在运行时判断任意一个对象所属的类
            在运行时构造任意一个类的对象
            在运行时判断任意一个类所具有的成员变量和方法
            在运行时调用任意一个对象的方法
            生成动态代理
      在运行状态中，对于任意一个类，都能够获取到这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性(包括私有的方法和属性)，这种动态获取的信息以及动态调用对象的方法的功能就称为java语言的反射机制。

反射.png

三.Hook使用案例分析

1.实现启动未注册的activity

      比如我们想启动一个activity，如果未在AndroidManifest.xml里面注册的话，调用Context.startActivity()时会出现以下异常：

1-25 10:44:54.811 E/AndroidRuntime(25309): Caused by: android.content.ActivityNotFoundException: Unable to 
find explicit activity class {com.hly.learn/com.hly.learn.HookActivity}; have you declared this activity in 
your AndroidManifest.xml?

      下面就一起来实现启动一个未在AndroidManifest.xml注册的activity。

      a.寻找hook点

      对于Context.startActivity，由于Context的实现类为ContextImpl，因此直接分析ContextImpl类的startActivity()的方法：

   @Override
    public void startActivity(Intent intent) {
        warnIfCallingFromSystemProcess();
        startActivity(intent, null);
    }

    @Override
    public void startActivity(Intent intent, Bundle options) {
        ......
        mMainThread.getInstrumentation().execStartActivity(
                getOuterContext(), mMainThread.getApplicationThread(), null,
                (Activity) null, intent, -1, options);
    }

      从上面可以看到，最终会调用mMainThread.getInstrumentation().execStartActivity()，mMainThread是ActivityThread实例，getInstrumentation()返回的是Instrumentation实例，实际上使用了ActivityThread类的mInstrumentation成员的execStartActivity方法；而ActivityThread 实际上是主线程，因为主线程一个进程只有一个，所以这里是一个良好的Hook点，即Hook主线程对象。

      b.选择合适代理方式

      要将这个主线程对象里面的mInstrumentation替换成修改过的代理对象；要替换主线程对象里面的字段，得先拿到主线程对象的引用，如何获取呢？
      ActivityThread类里面有一个静态方法currentActivityThread，通过它可以拿到这个对象类；但ActivityThread是一个隐藏类，需用反射去获取拿到currentActivityThread后，要修改它的mInstrumentation字段为修改后的代理对象。实现如下：

    public static void hookInstrumentation(Context context) {
        try {
            //step1：先获取到当前的ActivityThread对象， 该对象是mInstrumentation的持有者
            Class<?> activityThreadClz = Class.forName("android.app.ActivityThread");
            Method currentActivityThreadMethod = activityThreadClz.getDeclaredMethod("currentActivityThread");
            currentActivityThreadMethod.setAccessible(true);
            Object currentActivityThread = currentActivityThreadMethod.invoke(null);

            //step2：从ActivityThread里面拿到原始的mInstrumentation
            Field instrumentation = activityThreadClz.getDeclaredField("mInstrumentation");
            instrumentation.setAccessible(true);
            Instrumentation mInstrumentation = (Instrumentation) instrumentation.get(currentActivityThread);

            //step3：创建Instrumentation的代理对象[接下来会讲到]
            Instrumentation proxyInstrumentation = new ProxyInstrumentation(mInstrumentation, context.getPackageManager());

            //step4：将持有的Instrumentation原始对象替换成代理对象[将currentActivityThread里面的instrumentation变量替换为proxyInstrumentation]
            instrumentation.set(currentActivityThread, proxyInstrumentation);
        } catch (ClassNotFoundException | IllegalAccessException | NoSuchFieldException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }

    }

      接下来实现这个代理对象，由于JDK动态代理只支持接口，而这个Instrumentation是一个类，因此只能手写一个静态代理类，用来覆盖掉原始的方法，实现如下：

public class ProxyInstrumentation extends Instrumentation {

    private Instrumentation mBase;
    private PackageManager mPm;

    public ProxyInstrumentation(Instrumentation base, PackageManager pm) {
        mBase = base;
        mPm = pm;
    }

    public ActivityResult execStartActivity(
            Context who, IBinder contextThread, IBinder token, Activity target,
            Intent intent, int requestCode, Bundle options) {
        Log.d("Seven", "------Hook打印execStartActivity------");
        List<ResolveInfo> resolveInfos = mPm.queryIntentActivities(intent, PackageManager.MATCH_ALL);

        //检查要跳转的activity是否在Manifest.xml里面注册
        if (resolveInfos == null || resolveInfos.size() == 0) {
            //把要跳转的activity记录下来，在接下来newActivity还原的时候要拿来还原
            intent.putExtra("intent_name", intent.getComponent().getClassName());
            //把要跳转的activity改成已经在Manifest.xml里面注册过的MainActivity
            intent.setClassName(who, "com.hly.learn.MainActivity");
        }

        // 开始调用Instrumentation原始的方法,由于这个方法是隐藏的,因此需要使用反射调用;
        try {
            //找到这个方法
            Method execStartActivity = Instrumentation.class.getDeclaredMethod(
                    "execStartActivity", Context.class, IBinder.class, IBinder.class, Activity.class,
                    Intent.class, int.class, Bundle.class);
            execStartActivity.setAccessible(true);
            //通过反射调用Instrumentation的execStartActivity方法
            return (ActivityResult) execStartActivity.invoke(mBase, who,
                    contextThread, token, target, intent, requestCode, options);
        } catch (Exception e) {
            throw new RuntimeException("do not support!");
        }
    }

    @Override
    public Activity newActivity(ClassLoader cl, String className, Intent intent)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        //取出上步记录下来的要跳转的activity并进行替换，来启动未注册的activity
        String intentName = intent.getStringExtra("intent_name");
        Log.d("Seven", "------newActivity内进行替换------");
        if (!TextUtils.isEmpty(intentName)) {
            return super.newActivity(cl, intentName, intent);
        }
        return super.newActivity(cl, className, intent);
    }
}

      c.启动运行

HookUtils.hookInstrumentation(mContext);
private void hookActivity() {
    Intent i = new Intent();
    i.setClass(mContext, HookActivity.class);
    i.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    mContext.getApplicationContext().startActivity(i);
}

1-25 11:28:37.627 D/Seven   ( 1852): ------Hook打印execStartActivity------
1-25 11:28:37.665 D/Seven   ( 1852): ------newActivity内进行替换------

      至此，一个未在AndroidManifest.xml里面注册的activity通过hook技术方式就可以启动了。

2.拦截点击事件统计点击次数

      a.寻找hook点

      对一个view设置点击事件的调用流程如下：

    hkBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                
            }
        });

    public void setOnClickListener(@Nullable OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);
        }
        getListenerInfo().mOnClickListener = l;
    }

    ListenerInfo getListenerInfo() {
        if (mListenerInfo != null) {
            return mListenerInfo;
        }
        mListenerInfo = new ListenerInfo();
        return mListenerInfo;
    }

    static class ListenerInfo {
        ......
        /**
         * Listener used to dispatch click events.
         * This field should be made private, so it is hidden from the SDK.
         * {@hide}
         */
        public OnClickListener mOnClickListener;
        ......
}

      Hook操作onClickListener实例，需要首先获取到onClickListener的拥有者，即：ListenerInfo，最后通过ListenerInfo获取到原始的mOnClickListener。

      b.选择合适的代理方式

      从上面的流程可以发现，要将ListenerInfo类里面的mOnClickListener替换成修改过的代理对象；要替换ListenerInfo里面的字段，得先拿到ListenerInfo，View类中有一个方法getListenerInfo() ，通过它可以拿到这个ListenerInfo，实现如下：

    public static void hookOnClickListener(View view) {
        //step1：反射执行View类的getListenerInfo()方法，拿到view的mListenerInfo对象，这个对象是点击事件mOnClickListener的持有者
        try {
            Class<?> viewClz = Class.forName("android.view.View");
            Method method = viewClz.getDeclaredMethod("getListenerInfo");
            //由于getListenerInfo()方法并不是public的，所以要加这个代码来保证访问权限
            method.setAccessible(true);
            //拿到mListenerInfo，也就是点击事件的持有者
            Object listenerInfo = method.invoke(view);

            //step2：找到mListenerInfo持有的点击事件对象mOnClickListener
            //内部类的表示方法:android.view.View$ListenerInfo
            Class<?> listenerInfoClz = Class.forName("android.view.View$ListenerInfo");
            Field onClickListener = listenerInfoClz.getDeclaredField("mOnClickListener");
            final View.OnClickListener onClickListenerInstance = (View.OnClickListener) onClickListener.get(
                    listenerInfo);

            //step3：创建自己点击事件的OnClickListener代理类
             动态或静态创建OnClickListener的代理类proxyOnClickListener

            //step4：将持有者拥有的点击事件替换成代理对象[将listenerInfo里面的onClickListener变量替换为proxyOnClickListener]
            onClickListener.set(listenerInfo, proxyOnClickListener);
        } catch (NoSuchMethodException | IllegalAccessException | ClassNotFoundException | NoSuchFieldException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    }

      接下来要创建OnClickListener的代理对象，由于OnClickListener是一个接口，因此可以使用JDK动态代理方式Java动态代理，也可以用静态代理类实现，实现方式如下：

    //方式1：自己实现代理类,将原始的View.OnClickListener对象onClickListenerInstance作为参数传入
    ProxyOnClickListener proxyOnClickListener = new ProxyOnClickListener(onClickListenerInstance);
    static class ProxyOnClickListener implements View.OnClickListener{

        private View.OnClickListener listener;
        private int clickCount = 0;
        ProxyOnClickListener(View.OnClickListener listener){
            this.listener = listener;
        }

        @Override
        public void onClick(View v) {
            clickCount++;
            Log.d("Seven", "Hook OnClickListener 2 click count " + clickCount);
            if(this.listener != null){
                this.listener.onClick(v);
            }
    }
            
    //方式2：由于View.OnClickListener是一个接口，所以可以直接用动态代理模式
    //参数：类的加载器，要代理实现的接口（用Class数组表示，支持多接口），代理类的实际逻辑封装在new出来的InvocationHandler内
    Object proxyOnClickListener = Proxy.newProxyInstance(View.OnClickListener.class.getClassLoader(),
                    new Class[]{View.OnClickListener.class}, new InvocationHandler() {
                private int clickCount = 0;
                @Override
                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                         clickCount++;
                         Log.d("Seven", "Hook OnClickListener 1 click count " + clickCount);
                         return method.invoke(onClickListenerInstance, args);
                }
    });

      c.启动运行

hkBtn.setOnClickListener(this);
HookUtils.hookonClickListener(hkBtn);

      运行结果如下：

1-25 10:51:12.190 D/Seven   (26125): Hook OnClickListener 1 click count 1
1-25 10:51:21.428 D/Seven   (26125): Hook OnClickListener 1 click count 2
1-25 10:51:21.607 D/Seven   (26125): Hook OnClickListener 1 click count 3
1-25 10:51:21.770 D/Seven   (26125): Hook OnClickListener 1 click count 4
1-25 10:51:21.918 D/Seven   (26125): Hook OnClickListener 1 click count 5
1-25 10:51:22.068 D/Seven   (26125): Hook OnClickListener 1 click count 6
1-25 10:51:22.217 D/Seven   (26125): Hook OnClickListener 1 click count 7
1-25 10:51:22.394 D/Seven   (26125): Hook OnClickListener 1 click count 8
1-25 10:51:22.543 D/Seven   (26125): Hook OnClickListener 1 click count 9
1-25 10:51:22.722 D/Seven   (26125): Hook OnClickListener 1 click count 10
1-25 10:51:22.854 D/Seven   (26125): Hook OnClickListener 1 click count 11
1-25 10:51:23.009 D/Seven   (26125): Hook OnClickListener 1 click count 12
1-25 10:51:23.158 D/Seven   (26125): Hook OnClickListener 1 click count 13

      至此已经实现了对点击事件的hook。

3.总结

      针对以上两个案例分析，我们可以看到在进行hook时主要分为以下几步：
      a.寻找合适的hook点；
      b.找到Hook点对应的class；
      c.直接通过class或class内部的method找到对应的filed；
      d.替换对象是interface的话，直接用动态代理方式创建对象；否则，直接写个类继承要替换的类；
      e.调用filed.set(obj, proxy)来对变量进行替换；
      f.针对hook点进行相应的处理；

      hook技术涉及到的知识点主要有反射、代理及android源码的熟练程度。