Hook技术--Activity的启动过程的拦截

1、寻找Hook点的原则

Android中主要是依靠分析系统源码类来做到的，首先我们得找到被Hook的对象，我称之为Hook点；什么样的对象比较好Hook呢？自然是容易找到的对象。什么样的对象容易找到？静态变量和单例；在一个进程之内，静态变量和单例变量是相对不容易发生变化的，因此非常容易定位，而普通的对象则要么无法标志，要么容易改变。我们根据这个原则找到所谓的Hook点。

2、寻找Hook点

通常点击一个Button就开始Activity跳转了，这中间发生了什么，我们如何Hook,来实现Activity启动的拦截呢？

public voidstart(View view) {Intent intent= new Intent(this, OtherActivity.class);startActivity(intent);
}

我们的目的是要拦截startActivity方法，跟踪源码，发现最后启动Activity是由Instrumentation类的execStartActivity做到的。其实这个类相当于启动Activity的中间者，启动Activity中间都是由它来操作的

1 publicActivityResult execStartActivity(2 Context who, IBinder contextThread, IBinder token, Activity target,3             Intent intent, intrequestCode, Bundle options) {4         IApplicationThread whoThread =(IApplicationThread) contextThread;5 ....6         try{7 intent.migrateExtraStreamToClipData();8 intent.prepareToLeaveProcess(who);9
10         //通过ActivityManagerNative.getDefault()获取一个对象，开始启动新的Activity
11             int result =ActivityManagerNative.getDefault()12 .startActivity(whoThread, who.getBasePackageName(), intent,13 intent.resolveTypeIfNeeded(who.getContentResolver()),14                         token, target != null ? target.mEmbeddedID : null,15                         requestCode, 0, null, options);16
17
18 checkStartActivityResult(result, intent);19         } catch(RemoteException e) {20             throw new RuntimeException("Failure from system", e);21 }22         return null;23     }

对于ActivityManagerNative这个东东，熟悉Activity/Service启动过程的都不陌生

public abstract class ActivityManagerNative extends Binder implements IActivityManager

继承了Binder，实现了一个IActivityManager接口，这就是为了远程服务通信做准备的”Stub”类，一个完整的AID L有两部分，一个是个跟服务端通信的Stub,一个是跟客户端通信的Proxy。ActivityManagerNative就是Stub,阅读源码发现在ActivityManagerNative 文件中还有个ActivityManagerProxy，这里就多不扯了。

1 static publicIActivityManager getDefault() {2       return gDefault.get();3   }

ActivityManagerNative.getDefault()获取的是一个IActivityManager对象，由IActivityManager去启动Activity，IActivityManager的实现类是ActivityManagerService，ActivityManagerService是在另外一个进程之中，所有Activity 启动是一个跨进程的通信的过程，所以真正启动Activity的是通过远端服务ActivityManagerService来启动的。

 private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {protectedIActivityManager create() {IBinder b= ServiceManager.getService("activity");if (false) {Log.v("ActivityManager", "default service binder =" +b);}IActivityManager am=asInterface(b);if (false) {Log.v("ActivityManager", "default service =" +am);}returnam;
}

其实gDefalut借助Singleton实现的单例模式，而在内部可以看到先从ServiceManager中获取到AMS远端服务的Binder对象，然后使用asInterface方法转化成本地化对象，我们目的是拦截startActivity,所以改变IActivityManager对象可以做到这个一点，这里gDefault又是静态的，根据Hook原则，这是一个比较好的Hook点。

3、Hook掉startActivity，输出日志

我们先实现一个小需求，启动Activity的时候打印一条日志。

1 public classHookUtil {2
3     private Class<?>proxyActivity;4
5     privateContext context;6
7     public HookUtil(Class<?>proxyActivity, Context context) {8         this.proxyActivity =proxyActivity;9         this.context =context;10 }11
12     public voidhookAms() {13
14         //一路反射，直到拿到IActivityManager的对象
15         try{16             Class<?> ActivityManagerNativeClss = Class.forName("android.app.ActivityManagerNative");17             Field defaultFiled = ActivityManagerNativeClss.getDeclaredField("gDefault");18             defaultFiled.setAccessible(true);19             Object defaultValue = defaultFiled.get(null);20             //反射SingleTon
21             Class<?> SingletonClass = Class.forName("android.util.Singleton");22             Field mInstance = SingletonClass.getDeclaredField("mInstance");23             mInstance.setAccessible(true);24             //到这里已经拿到ActivityManager对象
25             Object iActivityManagerObject = mInstance.get(defaultValue);26
27
28             //开始动态代理，用代理对象替换掉真实的ActivityManager，瞒天过海
29             Class<?> IActivityManagerIntercept = Class.forName("android.app.IActivityManager");30
31             AmsInvocationHandler handler = newAmsInvocationHandler(iActivityManagerObject);32
33             Object proxy = Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{IActivityManagerIntercept}, handler);34
35             //现在替换掉这个对象
36             mInstance.set(defaultValue, proxy);37
38
39         } catch(Exception e) {40 e.printStackTrace();41 }42     }

1  private classAmsInvocationHandler implements InvocationHandler {2
3         privateObject iActivityManagerObject;4
5         privateAmsInvocationHandler(Object iActivityManagerObject) {6             this.iActivityManagerObject =iActivityManagerObject;7 }8
9 @Override10         publicObject invoke(Object proxy, Method method, Object[] args) throws Throwable {11
12             Log.i("HookUtil", method.getName());13             //我要在这里搞点事情
14             if ("startActivity".contains(method.getName())) {15                 Log.e("HookUtil","Activity已经开始启动");16                 Log.e("HookUtil","小弟到此一游！！！");17 }18             returnmethod.invoke(iActivityManagerObject, args);19 }20 }21 }

结合注释应该很容易看懂，在Application中配置一下

1 public classMyApplication extends Application {2
3 @Override4     public voidonCreate() {5 super.onCreate();6         HookUtil hookUtil=new HookUtil(SecondActivity.class, this);7 hookUtil.hookAms()；8 }9 }

看看执行结果：

可以看到，我们成功的Hook掉了startActivity，输出了一条日志。有了上面的基础，现在我们开始来点有用的东西，Activity不用在清单文件中注册，就可以启动起来，这个怎么搞呢？

4、无需注册，启动Activity

如下，TargetActivity没有在清单文件中注册，怎么去启动TargetActivity？

public voidstart(View view) {Intent intent= new Intent(this, TargetActivity.class);startActivity(intent);}

这个思路可以是这样，上面已经拦截了启动Activity流程，在invoke中我们可以得到启动参数intent信息，那么就在这里，我们可以自己构造一个假的Activity信息的intent，这个Intent启动的Activity是在清单文件中注册的，当真正启动的时候（ActivityManagerService校验清单文件之后），用真实的Intent把代理的Intent在调换过来，然后启动即可。

首先获取真实启动参数intent信息

1 @Override2   publicObject invoke(Object proxy, Method method, Object[] args) throws Throwable {3             if ("startActivity".contains(method.getName())) {4                 //换掉
5                 Intent intent = null;6                 int index = 0;7                 for (int i = 0; i < args.length; i++) {8                     Object arg =args[i];9                     if(arg instanceof Intent) {10                         //说明找到了startActivity的Intent参数
11                         intent =(Intent) args[i];12                         //这个意图是不能被启动的，因为Acitivity没有在清单文件中注册
13                         index =i;14 }15 }16
17                //伪造一个代理的Intent，代理Intent启动的是proxyActivity
18                 Intent proxyIntent = newIntent();19                 ComponentName componentName = newComponentName(context, proxyActivity);20 proxyIntent.setComponent(componentName);21                 proxyIntent.putExtra("oldIntent", intent);22                 args[index] =proxyIntent;23 }24
25             returnmethod.invoke(iActivityManagerObject, args);26         }

有了上面的两个步骤,这个代理的Intent是可以通过ActivityManagerService检验的，因为我在清单文件中注册过

<activity android:name=".ProxyActivity" />

为了不启动ProxyActivity，现在我们需要找一个合适的时机，把真实的Intent换过了来，启动我们真正想启动的Activity。看过Activity的启动流程的朋友，我们都知道这个过程是由Handler发送消息来实现的，可是通过Handler处理消息的代码来看，消息的分发处理是有顺序的，下面是Handler处理消息的代码:

public voiddispatchMessage(Message msg) {if (msg.callback != null) {handleCallback(msg);}else{if (mCallback != null) {if(mCallback.handleMessage(msg)) {return;}}handleMessage(msg);}}

handler处理消息的时候，首先去检查是否实现了callback接口，如果有实现的话，那么会直接执行接口方法，然后才是handleMessage方法，最后才是执行重写的handleMessage方法，我们一般大部分时候都是重写了handleMessage方法,而ActivityThread主线程用的正是重写的方法，这种方法的优先级是最低的，我们完全可以实现接口来替换掉系统Handler的处理过程。这里详见Android源码解析Handler系列第（一）篇 — Message全局池

1 public voidhookSystemHandler() {2         try{3
4             Class<?> activityThreadClass = Class.forName("android.app.ActivityThread");5             Method currentActivityThreadMethod = activityThreadClass.getDeclaredMethod("currentActivityThread");6             currentActivityThreadMethod.setAccessible(true);7             //获取主线程对象
8             Object activityThread = currentActivityThreadMethod.invoke(null);9             //获取mH字段
10             Field mH = activityThreadClass.getDeclaredField("mH");11             mH.setAccessible(true);12             //获取Handler
13             Handler handler = (Handler) mH.get(activityThread);14             //获取原始的mCallBack字段
15             Field mCallBack = Handler.class.getDeclaredField("mCallback");16             mCallBack.setAccessible(true);17             //这里设置了我们自己实现了接口的CallBack对象
18             mCallBack.set(handler, newActivityThreadHandlerCallback(handler)) ;19
20         } catch(Exception e) {21 e.printStackTrace();22 }23     }

自定义Callback类

1 private classActivityThreadHandlerCallback implements Handler.Callback {2
3         privateHandler handler;4
5         privateActivityThreadHandlerCallback(Handler handler) {6             this.handler =handler;7 }8
9 @Override10         publicboolean handleMessage(Message msg) {11             Log.i("HookAmsUtil", "handleMessage");12             //替换之前的Intent
13             if (msg.what ==100) {14                 Log.i("HookAmsUtil","lauchActivity");15 handleLauchActivity(msg);16 }17
18 handler.handleMessage(msg);19             return true;20 }21
22         private voidhandleLauchActivity(Message msg) {23             Object obj = msg.obj;//ActivityClientRecord
24             try{25                 Field intentField = obj.getClass().getDeclaredField("intent");26                 intentField.setAccessible(true);27                 Intent proxyInent = (Intent) intentField.get(obj);28                 Intent realIntent = proxyInent.getParcelableExtra("oldIntent");29                 if (realIntent != null) {30 proxyInent.setComponent(realIntent.getComponent());31 }32             }catch(Exception e){33                 Log.i("HookAmsUtil","lauchActivity falied");34 }35
36 }37     }

最后在application中注入

1 public classMyApplication extends Application {2 @Override3     public voidonCreate() {4 super.onCreate();5         //这个ProxyActivity在清单文件中注册过，以后所有的Activitiy都可以用ProxyActivity无需声明，绕过监测
6         HookAmsUtil hookAmsUtil = new HookAmsUtil(ProxyActivity.class, this);7 hookAmsUtil.hookSystemHandler();8 hookAmsUtil.hookAms();9 }10 }11 1

执行，点击MainActivity中的按钮成功跳转到了TargetActivity。

https://www.cnblogs.com/ganchuanpu/p/8485715.html