什么是hook?
hook 翻译成中文是 名词钩子、挂钩,动词 钩住的意思。
在程序中 Hook 是一种技术,也成为钩子函数。
实际上,一个处理消息的程序段,通过系统的调用,把它挂入系统。 在系统没有调用到该函数之前,钩子程序先捕获该消息,先得到控制权,然后加工处理,然后再扔给系统做后续的处理。
比如说,有一辆货车 每天从A仓库拉货(一个集装箱的苹果) 到 B 水果分发站。 我们的钩子函数的呢,就是在 该货车拉 集装箱之前,打开集装箱 做一些自己的操作,比如把苹果换成其他的水果。然后再把集装箱放回原地,让货车拉走。 对于这个过程 货车是无法感知到的。
上面的例子比较… 但可以帮助理解hook技术。
hook的作用?
在我们开发过程中,有时候某些API 不能满足我们的需求时,我们就可以使用Hook 来进而改变一个 系统api 的原有功能。
比如通过hook AMS 实现统一登录等。
如何hook?
我们这里介绍一下 java层的hook 方式。有两种:
1.利用系统内部提供的接口,通过实现该接口,然后注入自己的操作逻辑 (只在特定的场景下适用)
2.动态代理(所有场景)
如何查找hook点:
找到hook 点: 静态的变量或者单例,生命周期跨度较长,不会轻易重新创建。
Hook 过程
- 找到要Hook的点,通过反射或者其他方式 拿到该引用。
- 选择合适的方式处理逻辑,动态代理 或者 接口方式。
- 用我们修改过的对象,替换原来的对象(即上面提到的,把集装箱放回原位置,等货车拉走)
ok,这里只是简述一下 hook 相关的概念
Hook AMS 实现应用统一登录
整体思路:
1 . 我们使用动态代理的方式 hook
到 AMS 中的startActivity()
方法。当外部启动页面时,比如,启动购物车页面(未在AndroidManifest中注册)时。我们在代理的 invoke
方法中, 替换准备启动的 Intent
对象为 空壳Activity(已在AndroidManifest中注册),并把启动购物车的Intent 传递过去, 然后让系统做后续的启动操作。
2 . hook
到 ActivityThread 中的 mH(Handler,负责系统消息的处理) ,并给他设置 CallBack
, 在 callback 中 我们便可以 获取到启动 Activity的消息 LAUNCH_ACTIVITY
即100, 然后我们可以取出 intent 替换为我们想要启动的购物车界面, 当然可以在其中加入一些判断登录的逻辑来实现统一的登录校验.
上面的思路,可能稍微有些抽象,下面我们来上代码:
我们先添加一些基本的页面以及简单的跳转操作代码:
/**
* 跳转到购物车界面
* @param view
*/
public void toCartPage(View view) {
startActivity(new Intent(MainActivity.this,CartPageActivity.class));
}
/**
* 跳转到我的界面
* @param view
*/
public void toMinePage(View view) {
startActivity(new Intent(MainActivity.this,MinePageActivity.class));
}
上面的 CartPageActivity
、 MinePageActivity
界面均未在AndroidManifest.xml 中注册。
我们需要添加一个 空壳页面, 这个页面呢,没有任何的实际作用,只是为了能让 未注册的页面可以正常的通过系统的检查。
public class ProxyActivity extends Activity{
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_proxy);
}
}
ok,下面我们来上 hook 部分的代码。
/**
* hook ams 中的 startActivity 方法,代理该方法,添加我们自己的操作,然后再抛给 系统做后续的流程
*/
public void hookStartActivity() {
try {
Class<?> mManagerNativeClazz = Class.forName("android.app.ActivityManagerNative");
//hook到 gDefault 这个单例 Singleton
Field mIActivityManagerSington = mManagerNativeClazz.getDeclaredField("gDefault");
mIActivityManagerSington.setAccessible(true);
Object gDefaultValue = mIActivityManagerSington.get(null);
Class<?> mSingletonClazz = Class.forName("android.util.Singleton");
Field mSingletonField = mSingletonClazz.getDeclaredField("mInstance");
mSingletonField.setAccessible(true);
//通过反射的方式 获取到 我们的 IActivityManager 引用
Object iActivityManagerObj = mSingletonField.get(gDefaultValue);
CheckStartActivityHandler checkStartActivityHandler = new CheckStartActivityHandler(iActivityManagerObj);
Class<?> mIActivityMangerInterface = Class.forName("android.app.IActivityManager");
// 此处通过动态代理的方式 生成 代理IActivityManager中接口的代理对象 mProxyActivityManager 并设置给了系统
Object mProxyActivityManager = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{mIActivityMangerInterface}, checkStartActivityHandler);
mSingletonField.set(gDefaultValue,mProxyActivityManager);
} catch (Exception e) {
e.printStackTrace();
}
}
我们来说说上面都干了些啥事:
1.反射的方式获取到了ActivityManageNative
中的 gDefault
字段 即 Singleton<IActivityManager>
,它的内部持有IActivityManager
的引用。 我们的 AMS 是 IActivityManager
的具体实现。
2.从 gDefault
取出了我们的 IActivityManager
通过下面这几行代码:
Class<?> mSingletonClazz = Class.forName("android.util.Singleton");
Field mSingletonField = mSingletonClazz.getDeclaredField("mInstance");
mSingletonField.setAccessible(true);
//通过反射的方式 获取到 我们的 IActivityManager 引用
Object iActivityManagerObj = mSingletonField.get(gDefaultValue);
3.创建了动态代理的Handler装置,即实现 InvocationHandler
,这是硬性要求。没的选。同时,我们传入了我们的 IActivityManager
引用.
CheckStartActivityHandler checkStartActivityHandler = new CheckStartActivityHandler(iActivityManagerObj);
4.动态代理系统 IActivityManager
中的接口,并返回 生成的代理对象 即 mProxyActivityManager
并设置给系统,就是我们说的,我们还得把集装箱还回去。所有 IActivityManager
中的接口都调用 都会被委托到 我们的 checkStartActivityHandler
中, 调用 invoke 方法。
Class<?> mIActivityMangerInterface = Class.forName("android.app.IActivityManager");
// 此处通过动态代理的方式 生成 代理IActivityManager中接口的代理对象 mProxyActivityManager 并设置给了系统
Object mProxyActivityManager = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class[]{mIActivityMangerInterface}, checkStartActivityHandler);
mSingletonField.set(gDefaultValue,mProxyActivityManager);
简单提一下动态代理的几个参数含义:
loader
:类加载器类型,由哪个类加载器来加载代理对象
interfaces
:一组接口,代理对象会实现该接口。
invocationHandler
:当代理对象调用方法时,会关联到Handler 并调用该 invoke
方法。
上面的暂且说到这,我们继续来看代理中的处理代码:
/**
* 动态代理 所需要实现的, 每一个代理的接口方法 都会委托给我们 这个handler 装置 来进行处理,即都会调用到 invoke 方法
*/
class CheckStartActivityHandler implements InvocationHandler {
private Object mOldActivityManager;
public CheckStartActivityHandler(Object iOldActivityManger) {
this.mOldActivityManager = iOldActivityManger;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Log.e(TAG,"hook method "+method);
if ("startActivity".equals(method.getName())){ //如果方法时 启动Activity
Intent mIntent = null;
int argIndex = 0;
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
if (arg instanceof Intent){
mIntent = (Intent) arg;
argIndex = i;
}
}
Intent newIntent = new Intent();
newIntent.setComponent(new ComponentName(mContext,ProxyActivity.class));
//把startActivity 中的 Intnet 传递过去, mIntent 为想要开启的页面。
newIntent.putExtra("oldIntent",mIntent);
args[argIndex] = newIntent; // 替换启动的intent
}
return method.invoke(mOldActivityManager,args);
}
}
说下 invoke
方法中的几个参数:
proxy
: 生成的代理对象
method
: 我们所要调用方法的Method对象
args
: 该Mehod所需要的方法参数
你也看到了,我们只是判断了方法的名称, 然后取出对应的 Intent
然后替换为我们的 空壳Activity,这里只是为了可以通过AMS的相关检查。 然后把我们的 想要启动的页面传递过去(比如购物车界面,注意,购物车界面并未注册)。
第一步的操作到这里就完成了。我们也可以歇一会,让 Activity 先飞一会。
接下来,我们要进行第二步的操作,即通过回调的方式 hook 系统的 消息处理Handler。
/**
* 通过设置回调的方式, hook M 即消息Handler 判断是否是启动Activity 的消息 即 100;
*/
public void hookMHandler(){
try {
Class<?> mActivityThreadClazz = Class.forName("android.app.ActivityThread");
Method currentActivityThread = mActivityThreadClazz.getDeclaredMethod("currentActivityThread");
Object mActivityThreadInstance = currentActivityThread.invoke(null);
Field mHandlerField = mActivityThreadClazz.getDeclaredField("mH");
mHandlerField.setAccessible(true);
Handler mActivityThreadHandler = (Handler) mHandlerField.get(mActivityThreadInstance);
Field mHandlerCallBackField = Handler.class.getDeclaredField("mCallback");
mHandlerCallBackField.setAccessible(true);
mHandlerCallBackField.set(mActivityThreadHandler,new HandlerCallBack(mActivityThreadHandler));
} catch (Exception e) {
e.printStackTrace();
}
}
上面做了3件事:
1.反射获取到 ActivityThread
即 mActivityThreadInstance
2.获取 ActivityThread
内部的消息处理Handler mH
,并获取其内部的 Field域 mCallback
3.给该字段,设置Callback.即下面这段代码:
mHandlerCallBackField.set(mActivityThreadHandler,new HandlerCallBack(mActivityThreadHandler));
下面我们贴上CallBack 内部的处理代码:
class HandlerCallBack implements Handler.Callback {
private Handler mActivityThreadH;
public HandlerCallBack(Handler mActivityThreadHandler) {
this.mActivityThreadH = mActivityThreadHandler;
}
@Override
public boolean handleMessage(Message msg) {
if (msg.what == 100){ // 当前是正在 启动Activity 以及过了 AMS的相关检测
launchRealActivity(msg);
}
mActivityThreadH.handleMessage(msg);
return true;
}
private void launchRealActivity(Message msg) {
// 此处的 obj 为 ActivityClientRecord 对象 保存了 Activity 启动的信息
Object mActivityRecordObj = msg.obj;
try {
Field mIntentField = mActivityRecordObj.getClass().getDeclaredField("intent");
mIntentField.setAccessible(true);
// 此处我们获取到的是 启动Activity 时的 代理intent
Intent mProxyIntent = (Intent) mIntentField.get(mActivityRecordObj);
Intent mOldIntent = mProxyIntent.getParcelableExtra("oldIntent");
//TODO: 此处判断登录的逻辑,如果未登录 则跳转到登录界面。否则 开启传递的 Intent 即 mOldIntent;
mProxyIntent.setComponent(mOldIntent.getComponent());
} catch (Exception e) {
e.printStackTrace();
}
}
}
判断消息是否是启动Activity,如果是,则从Intent中取出我们真正要启动的 Activity(比如购物车页面)。然后启动即可以了。正如你所看到的 TODO ,我们可以在这里加入登录校验的逻辑。
最后,我们只需要在 Application
中调用即可:
public class BaseApplication extends Application {
@Override
public void onCreate() {
super.onCreate();
LoginHookCheckUtil hookCheckUtil = new LoginHookCheckUtil(this);
hookCheckUtil.hookStartActivity();
hookCheckUtil.hookMHandler();
}
}
到这里呢,就结束了。
注意
有一个问题,我目前尚未处理, 仍在寻找解决方式。即 CartPageActivity
、 MinePageActivity
只能继承 Activity
. 如果继承 AppCompatActivity
会报错。 请注意~~~~!!!
代码地址: