以下文章来源Java架构师技术，回复”Spring“获惊喜礼包
上一篇推文：面试官让我手写一个RPC框架 ，so easy !
大家好，我是Java架构师

1. 什么是 Hook

Hook 英文翻译过来就是「钩子」的意思，那我们在什么时候使用这个「钩子」呢？在 Android 操作系统中系统维护着自己的一套事件分发机制。应用程序，包括应用触发事件和后台逻辑处理，也是根据事件流程一步步地向下执行。而「钩子」的意思，就是在事件传送到终点前截获并监控事件的传输，像个钩子钩上事件一样，并且能够在钩上事件时，处理一些自己特定的事件。
Hook 的这个本领，使它能够将自身的代码「融入」被勾住（Hook）的程序的进程中，成为目标进程的一个部分。API Hook 技术是一种用于改变 API 执行结果的技术，能够将系统的 API 函数执行重定向。在 Android 系统中使用了沙箱机制，普通用户程序的进程空间都是独立的，程序的运行互不干扰。这就使我们希望通过一个程序改变其他程序的某些行为的想法不能直接实现，但是 Hook 的出现给我们开拓了解决此类问题的道路。当然，根据 Hook 对象与 Hook 后处理的事件方式不同，Hook 还分为不同的种类，比如消息 Hook、API Hook 等。
  1. 使用 Java 反射实现 API Hook

    通过对 Android 平台的虚拟机注入与 Java 反射的方式，来改变 Android 虚拟机调用函数的方式（ClassLoader），从而达到 Java 函数重定向的目的，这里我们将此类操作称为 Java API Hook。
下面通过 Hook View 的 OnClickListener 来说明 Hook 的使用方法。
首先进入 View 的 setOnClickListener 方法，我们看到 OnClickListener 对象被保存在了一个叫做 ListenerInfo 的内部类里，其中 mListenerInfo 是 View 的成员变量。ListeneInfo 里面保存了 View 的各种监听事件，比如 OnClickListener、OnLongClickListener、OnKeyListener 等等。
publicvoidsetOnClickListener(@Nullable OnClickListener l) 
{

if
 (!isClickable()) {

        setClickable(
true
);

    }

    getListenerInfo().mOnClickListener = l;

}


ListenerInfo getListenerInfo() 
{

if
 (mListenerInfo != 
null
) {

return
 mListenerInfo;

    }

    mListenerInfo = 
new
 ListenerInfo();

return
 mListenerInfo;

}

我们的目标是 Hook OnClickListener，所以就要在给 View 设置监听事件后，替换 OnClickListener 对象，注入自定义的操作。
privatevoidhookOnClickListener(View view)
{

try
 {

// 得到 View 的 ListenerInfo 对象
        Method getListenerInfo = View.class.getDeclaredMethod(
"getListenerInfo"
);

        getListenerInfo.setAccessible(
true
);

        Object listenerInfo = getListenerInfo.invoke(view);

// 得到 原始的 OnClickListener 对象
        Class<?> listenerInfoClz = Class.forName(
"android.view.View$ListenerInfo"
);

        Field mOnClickListener = listenerInfoClz.getDeclaredField(
"mOnClickListener"
);

        mOnClickListener.setAccessible(
true
);

        View.OnClickListener originOnClickListener = (View.OnClickListener) mOnClickListener.get(listenerInfo);

// 用自定义的 OnClickListener 替换原始的 OnClickListener
        View.OnClickListener hookedOnClickListener = 
new
 HookedOnClickListener(originOnClickListener);

        mOnClickListener.
set
(listenerInfo, hookedOnClickListener);

    } 
catch
 (Exception e) {

log
.warn(
"hook clickListener failed!"
, e);

    }

}


classHookedOnClickListenerimplementsView.OnClickListener {
private
 View.OnClickListener origin;


    HookedOnClickListener(View.OnClickListener origin) {

this
.origin = origin;

    }


    @
Override

publicvoidonClick(View v)
{

        Toast.makeText(MainActivity.
this
, 
"hook click"
, Toast.LENGTH_SHORT).show();

log
.info(
"Before click, do what you want to to."
);

if
 (origin != null) {

            origin.onClick(v);

        }

log
.info(
"After click, do what you want to to."
);

    }

}

到这里，我们成功 Hook 了 OnClickListener，在点击之前和点击之后可以执行某些操作，达到了我们的目的。下面是调用的部分，在给 Button 设置 OnClickListener 后，执行 Hook 操作。点击按钮后，日志的打印结果是：Before click → onClick → After click。
牛逼啊！接私活必备的 N 个开源项目！赶快收藏
    Button btnSend = (Button) findViewById(R.id.btn_send);

    btnSend.setOnClickListener(
new
 View.OnClickListener() {

@Override
publicvoidonClick(View v)
{

            log.info(
"onClick"
);

        }

    });

    hookOnClickListener(btnSend);

我们再来看一个很常见的例子 startActivity

下面我们Hook掉
startActivity
这个方法，使得每次调用这个方法之前输出一条日志；（当然，这个输入日志有点点弱，只是为了展示原理，如果你想可以替换参数，拦截这个
startActivity
过程，使得调用它导致启动某个别的Activity，指鹿为马！）

我们知道对于Context.startActivity，Context的实现实际上是ContextImpl;我们看ConetxtImpl类的startActivity方法：
@Override
publicvoidstartActivity(Intent intent, Bundle options)
{

    warnIfCallingFromSystemProcess();

if
 ((intent.getFlags()&Intent.FLAG_ACTIVITY_NEW_TASK) == 
0
) {

thrownew
 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是一个隐藏类，我们需要用反射去获取，代码如下：
// 先获取到当前的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可以做到基于类的动态代理，这里先不介绍）
public 
classEvilInstrumentationextendsInstrumentation
{


    private 
staticfinalString
 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修改了  需要手动适配
thrownew
 RuntimeException(
"do not support!!! pls adapt it"
);

        }

    }

}

Ok，有了代理对象，我们要做的就是偷梁换柱！代码比较简单，采用反射直接修改：
publicstaticvoidattactContext() throws Exception
{

// 先获取到当前的ActivityThread对象
        Class<?> activityThreadClass = Class.forName(
"android.app.ActivityThread"
);

        Field currentActivityThreadField = activityThreadClass.getDeclaredField(
"sCurrentActivityThread"
);

        currentActivityThreadField.setAccessible(
true
);

        Object currentActivityThread = currentActivityThreadField.
get
(
null
);


// 拿到原始的 mInstrumentation字段
        Field mInstrumentationField = activityThreadClass.getField(
"mInstrumentation"
);

        mInstrumentationField.setAccessible(
true
);

        Instrumentation mInstrumentation = (Instrumentation) mInstrumentationField.
get
(currentActivityThread);


// 创建代理对象
        Instrumentation evilInstrumentation = 
new
 EvilInstrumentation(mInstrumentation);


// 偷梁换柱
        mInstrumentationField.
set
(currentActivityThread, evilInstrumentation);

    }

好了，我们启动一个Activity测试一下，结果如下：
总结一下：
Hook 过程：

寻找 Hook 点，原则是静态变量或者单例对象，尽量 Hook public 的对象和方法。

选择合适的代理方式，如果是接口可以用动态代理。

偷梁换柱——用代理对象替换原始对象。

Android 的 API 版本比较多，方法和类可能不一样，所以要做好 API 的兼容工作。另外，搜索公众号顶级科技后台回复“API接口”，获取一份惊喜礼包。
举个例子

Android10后添加了
ActivityTaskManager
int
 result = ActivityTaskManager.getService().startActivity(whoThread,

                    who.getBasePackageName(), who.getAttributionTag(), intent,

                    intent.resolveTypeIfNeeded(who.getContentResolver()), token,

                    target != 
null
 ? target.mEmbeddedID : 
null
, requestCode, 
0
, 
null
, options);

int
 result = ActivityManagerNative.getDefault()

            .startActivity(whoThread, who.getBasePackageName(), intent,

                    intent.resolveTypeIfNeeded(who.getContentResolver()),

                    token, target != 
null
 ? target.mEmbeddedID : 
null
,

                    requestCode, 
0
, 
null
, 
null
, options);

https://www.jianshu.com/p/8632fdc86009

2. Xposed

通过替换 /system/bin/app_process 程序控制 Zygote 进程，使得 app_process 在启动过程中会加载 XposedBridge.jar 这个 Jar 包，从而完成对 Zygote 进程及其创建的 Dalvik 虚拟机的劫持。

Xposed 在开机的时候完成对所有的 Hook Function 的劫持，在原 Function 执行的前后加上自定义代码。
现在安装Xposed比较方便，因为Xposed作者开发了一个Xposed Installer App，下载后按照提示傻瓜式安装（前提是root手机）。其实它的安装过程是这个样子的：首先探测手机型号，然后按照手机版本下载不同的刷机包，最后把Xposed刷机包刷入手机重启就好。刷机包下载 里面有所有版本的刷机包。

刷机包解压打开里面的问件构成是这个样子的：
META-INF/    里面有文件配置脚本 flash-script.sh 配置各个文件安装位置。

system
/bin/   替换zygote进程等文件

system
/framework/XposedBridge.jar jar包位置

system
/lib 
system
/lib64 一些so文件所在位置

xposed.prop xposed版本说明文件

所以安装Xposed的过程就上把上面这些文件放到手机里相同文件路径下。

通过查看文件安装脚本发现：

system/bin/下面的文件替换了app_process等文件，app_process就是zygote进程文件。所以Xposed通过替换zygote进程实现了控制手机上所有app进程。因为所有app进程都是由Zygote fork出来的。
Xposed的基本原理是修改了ART/Davilk虚拟机，将需要hook的函数注册为Native层函数。当执行到这一函数是虚拟机会优先执行Native层函数，然后再去执行Java层函数，这样完成函数的hook。如下图：
通过读Xposed源码发现其启动过程：
  1. 手机启动时init进程会启动zygote这个进程。由于zygote进程文件app_process已被替换，所以启动的时Xposed版的zygote进程。
  2. Xposed_zygote进程启动后会初始化一些so文件（system/lib system/lib64），然后进入XposedBridge.jar中的XposedBridge.main中初始化jar包完成对一些关键Android系统函数的hook。
  3. Hook则是利用修改过的虚拟机将函数注册为native函数。
  4. 然后再返回zygote中完成原本zygote需要做的工作。

    这只是在宏观层面稍微介绍了下Xposed，要想详细了解需要读它的源码了。
欢迎有需要的同学试试，如果本文对您有帮助，也请帮忙点个 赞 + 在看 啦！❤️
在 程序员小乐 还有更多优质项目系统学习资源，欢迎分享给其他同学吧！
最后，整理了400多套项目，赠送读者。扫码下方二维码，后台回复【赚钱】即可获取。
--END--
来源：若无初见
链接：jianshu.com/p/2674a716fb3f
版权申明：内容来源网络，版权归原创者所有。除非无法确认，我们都会标明作者及出处，如有侵权烦请告知，我们会立即删除并表示歉意。谢谢!
往期惊喜：
何谓架构？
一个很酷的后台权限管理系统
一个很酷的博客系统
一个很酷的快速开发代码生成器系统
看看人家那 IM 即时通讯系统，那叫一个优雅（附源码）
公司架构师写的API网关选型总结，就是牛逼！
一个很酷的个人工作站系统！
Controller应该怎么写？
这是我见过最好的 SaaS 快速开发平台！
史上最污技术解读，我竟然秒懂了！
比 Redis 还快，更省内存，惊爆了！
最全SQL 语句大全，值得收藏！
看看人家那文本识别系统，那叫一个优雅！
扫码关注我们的Java架构师技术
带你全面深入Java
继续阅读
阅读原文