Hook技術--Activity的啟動過程的攔截

Android中主要是依靠分析系統源碼類來做到的，首先我們得找到被Hook的對象，我稱之為Hook點；什麼樣的對象比較好Hook呢？自然是容易找到的對象。什麼樣的對象容易找到？靜態變數和單例；在一個進程之內，靜態變數和單例變數是相對不容易發生變化的，因此非常容易定位，而普通的對象則要麼無法標誌，要麼 ...

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檢驗的，因為我在清單文件中註冊過

<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             //獲取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。