Hook简述以及Hook AMS 实现统一登录

什么是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 会报错。 请注意~~~~！！！

代码地址:

https://download.csdn.net/download/mike_cui_ls/10342043