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

2018-03-01 07:48:35来源:cnblogs.com作者:ganchuanpu人点击

分享
1、寻找Hook点的原则

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

2、寻找Hook点

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

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

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

 1 public ActivityResult execStartActivity( 2             Context who, IBinder contextThread, IBinder token, Activity target, 3             Intent intent, int requestCode, Bundle options) { 4         IApplicationThread whoThread = (IApplicationThread) contextThread; 5         .... 6         try { 7             intent.migrateExtraStreamToClipData(); 8             intent.prepareToLeaveProcess(who); 9 10         //通过ActivityManagerNative.getDefault()获取一个对象,开始启动新的Activity11             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 public IActivityManager 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>() {        protected IActivityManager 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);            }            return am;}

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

3、Hook掉startActivity,输出日志

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

 1 public class HookUtil { 2  3     private Class<?> proxyActivity; 4  5     private Context context; 6  7     public HookUtil(Class<?> proxyActivity, Context context) { 8         this.proxyActivity = proxyActivity; 9         this.context = context;10     }11 12     public void hookAms() {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             //反射SingleTon21             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 = new AmsInvocationHandler(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 class AmsInvocationHandler implements InvocationHandler { 2  3         private Object iActivityManagerObject; 4  5         private AmsInvocationHandler(Object iActivityManagerObject) { 6             this.iActivityManagerObject = iActivityManagerObject; 7         } 8  9         @Override10         public Object 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             return method.invoke(iActivityManagerObject, args);19         }20     }21 }

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

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

看看执行结果: 

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

4、无需注册,启动Activity

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

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

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

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

 1  @Override 2   public Object 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启动的是proxyActivity18                 Intent proxyIntent = new Intent();19                 ComponentName componentName = new ComponentName(context, proxyActivity);20                 proxyIntent.setComponent(componentName);21                 proxyIntent.putExtra("oldIntent", intent);22                 args[index] = proxyIntent;23             }24 25             return method.invoke(iActivityManagerObject, args);26         }

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

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

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

public void dispatchMessage(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 void hookSystemHandler() { 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             //获取Handler13             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, new ActivityThreadHandlerCallback(handler)) ;19 20         } catch (Exception e) {21             e.printStackTrace();22         }23     }

自定义Callback类

 1 private class ActivityThreadHandlerCallback implements Handler.Callback { 2  3         private Handler handler; 4  5         private ActivityThreadHandlerCallback(Handler handler) { 6             this.handler = handler; 7         } 8  9         @Override10         public boolean handleMessage(Message msg) {11             Log.i("HookAmsUtil", "handleMessage");12             //替换之前的Intent13             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 void handleLauchActivity(Message msg) {23             Object obj = msg.obj;//ActivityClientRecord24             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 class MyApplication extends Application { 2     @Override 3     public void onCreate() { 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。

最新文章

123

最新摄影

闪念基因

微信扫一扫

第七城市微信公众平台