當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

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

發布時間：2025/3/15 编程问答 52 豆豆

生活随笔收集整理的這篇文章主要介紹了 Hook技术--Activity的启动过程的拦截小編覺得挺不錯的,現在分享給大家,幫大家做個參考.

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()獲取一個對象，開始啟動新的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 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 //反射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 = 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 @Override 10 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 @Override 4 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啟動的是proxyActivity 18 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檢驗的，因為我在清單文件中注冊過

為了不啟動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 //獲取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, 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 @Override 10 public boolean 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 void handleLauchActivity(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 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。

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

總結

以上是生活随笔為你收集整理的Hook技术--Activity的启动过程的拦截的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。

上一篇： Android 性能优化之谈谈Java
下一篇：阿里SopHix热修复框架