插件框架原理解析——Hook機制之Binder Hook

cszddx 8年前發布 | 16K 次閱讀 安卓開發 Android開發 移動開發

來自: http://weishu.me/2016/02/16/understand-plugin-framework-binder-hook/

Android系統通過Binder機制給應用程序提供了一系列的系統服務,諸如 ActivityManagerService , ClipboardManager , AudioManager 等;這些廣泛存在系統服務給應用程序提供了諸如任務管理,音頻,視頻等異常強大的功能。

插件框架作為各個插件的管理者,為了使得插件能夠 無縫地 使用這些系統服務,自然會對這些系統服務做出一定的改造(Hook),使得插件的開發和使用更加方便,從而大大降低插件的開發和維護成本。比如,Hook住 ActivityManagerService 可以讓插件無縫地使用 startActivity 方法而不是使用特定的方式(比如that語法)來啟動插件或者主程序的任意界面。

我們把這種Hook系統服務的機制稱之為Binder Hook,因為本質上這些服務提供者都是存在于系統各個進程的Binder對象。因此,要理解接下來的內容必須了解Android的Binder機制,可以參考我之前的文章Binder學習指南

閱讀本文之前,可以先clone一份 understand-plugin-framework ,參考此項目的 binder-hook 模塊。另外,插件框架原理解析系列文章見索引。

系統服務的獲取過程

我們知道系統的各個遠程service對象都是以Binder的形式存在的,而這些Binder有一個管理者,那就是 ServiceManager ;我們要Hook掉這些service,自然要從這個 ServiceManager 下手,不然星羅棋布的Binder廣泛存在于系統的各個角落,要一個個找出來還真是大海撈針。

回想一下我們使用系統服務的時候是怎么干的,想必這個大家一定再熟悉不過了:通過 Context 對象的 getSystemService 方法;比如要使用 ActivityManager :

ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);

</div>

可是這個貌似跟 ServiceManager 沒有什么關系啊?我們再查看 getSystemService 方法;(Context的實現在 ContextImpl 里面):

public Object getSystemService(String name) {
    ServiceFetcher fetcher = SYSTEM_SERVICE_MAP.get(name);
    return fetcher == null ? null : fetcher.getService(this);
}

</div>

很簡單,所有的service對象都保存在一張 map 里面,我們再看這個map是怎么初始化的:

registerService(ACCOUNT_SERVICE, new ServiceFetcher() {
 public Object createService(ContextImpl ctx) {
 IBinder b = ServiceManager.getService(ACCOUNT_SERVICE);
 IAccountManager service = IAccountManager.Stub.asInterface(b);
 return new AccountManager(ctx, service);
 }});

</div>

在 ContextImpl 的靜態初始化塊里面,有的Service是像上面這樣初始化的;可以看到,確實使用了 ServiceManager ;當然還有一些service并沒有直接使用 ServiceManager ,而是做了一層包裝并返回了這個包裝對象,比如我們的 ActivityManager ,它返回的是 ActivityManager 這個包裝對象:

registerService(ACTIVITY_SERVICE, new ServiceFetcher() {
 public Object createService(ContextImpl ctx) {
 return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
 }});

</div>

但是在 ActivityManager 這個類內部,也使用了 ServiceManager ;具體來說,因為ActivityManager里面所有的核心操作都是使用 ActivityManagerNative.getDefault() 完成的。那么這個語句干了什么呢?

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
        protected IActivityManager create() {
            IBinder b = ServiceManager.getService("activity");
            IActivityManager am = asInterface(b);
            return am;
        }
    };

</div>

因此,通過分析我們得知,系統Service的使用其實就分為兩步:

IBinder b = ServiceManager.getService("service_name"); // 獲取原始的IBinder對象
IXXInterface in = IXXInterface.Stub.asInterface(b); // 轉換為Service接口

</div>

尋找Hook點

插件框架原理解析——Hook機制之動態代理 里面我們說過,Hook分為三步,最關鍵的一步就是尋找Hook點。我們現在已經搞清楚了系統服務的使用過程,那么就需要找出在這個過程中,在哪個環節是最合適hook的。

由于系統服務的使用者都是對第二步獲取到的 IXXInterface 進行操作,因此如果我們要hook掉某個系統服務, 只需要把第二步的 asInterface 方法返回的對象修改為為我們Hook過的對象就可以了。

asInterface過程

接下來我們分析 asInterface 方法,然后想辦法把這個方法的返回值修改為我們Hook過的系統服務對象。這里我們以系統剪切版服務為例,源碼位置為 android.content.IClipboard , IClipboard.Stub.asInterface 方法代碼如下:

public static android.content.IClipboard asInterface(android.os.IBinder obj) {
    if ((obj == null)) {
        return null; 
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); // Hook點
    if (((iin != null) && (iin instanceof android.content.IClipboard))) {
        return ((android.content.IClipboard) iin);
    }
    return new android.content.IClipboard.Stub.Proxy(obj);
}

</div>

這個方法的意思就是:先查看本進程是否存在這個Binder對象,如果有那么直接就是本進程調用了;如果不存在那么創建一個代理對象,讓代理對象委托驅動完成跨進程調用。

觀察這個方法,前面的那個if語句判空返回肯定動不了手腳;最后一句調用構造函數然后直接返回我們也是無從下手,要修改 asInterface 方法的返回值,我們唯一能做的就是從這一句下手:

android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR); // Hook點

</div>

我們可以嘗試修改這個 obj 對象的 queryLocalInterface 方法的返回值,并保證這個返回值符合接下來的 if 條件檢測,那么就達到了修改 asInterface 方法返回值的目的。

而這個 obj 對象剛好是我們第一步返回的 IBinder 對象,接下來我們嘗試對這個 IBinder 對象的 queryLocalInterface 方法進行hook。

getService過程

上文分析得知,我們想要修改 IBinder 對象的 queryLocalInterface 方法;獲取 IBinder 對象的過程如下:

IBinder b = ServiceManager.getService("service_name");

</div>

因此,我們希望能修改這個 getService 方法的返回值,讓這個方法返回一個我們偽造過的 IBinder 對象;這樣,我們可以在自己偽造的 IBinder 對象的 queryLocalInterface 方法作處理,進而使得 asInterface 方法返回在 queryLocalInterface 方法里面處理過的值,最終實現hook系統服務的目的。

在跟蹤這個 getService 方法之前我們思考一下,由于系統服務是一系列的遠程Service,它們的本體,也就是Binder本地對象一般都存在于某個單獨的進程,在這個進程之外的其他進程存在的都是這些Binder本地對象的代理。因此在我們的進程里面,存在的也只是這個Binder代理對象,我們也只能對這些Binder代理對象下手。(如果這一段看不懂,建議不要往下看了,先看Binder學習指南)

然后,這個 getService 是一個靜態方法,如果此方法什么都不做,拿到Binder代理對象之后直接返回;那么我們就無能為力了:我們沒有辦法攔截一個靜態方法,也沒有辦法獲取到這個靜態方法里面的局部變量(即我們希望修改的那個Binder代理對象)。

接下來就可以看這個 getService 的代碼了:

public static IBinder getService(String name) {
    try {
        IBinder service = sCache.get(name);
        if (service != null) {
            return service;
        } else {
            return getIServiceManager().getService(name);
        }
    } catch (RemoteException e) {
        Log.e(TAG, "error in getService", e);
    }
    return null;
}

</div>

天無絕人之路! ServiceManager 為了避免每次都進行跨進程通信,把這些Binder代理對象緩存在一張 map 里面。

我們可以替換這個map里面的內容為Hook過的 IBinder 對象,由于系統在 getService 的時候每次都會優先查找緩存,因此返回給使用者的都是被我們修改過的對象,從而達到瞞天過海的目的。

總結一下,要達到修改系統服務的目的,我們需要如下兩步:

  1. 首先肯定需要 偽造一個系統服務對象 ,接下來就要想辦法讓 asInterface 能夠返回我們的這個偽造對象而不是原始的系統服務對象。
  2. 通過上文分析我們知道,只要讓 getService 返回 IBinder 對象的 queryLocalInterface 方法直接返回我們偽造過的系統服務對象就能達到目的。所以,我們需要 偽造一個IBinder對象 ,主要是修改它的 queryLocalInterface 方法,讓它返回我們偽造的系統服務對象;然后把這個偽造對象放置在 ServiceManager 的緩存 map 里面即可。

我們通過Binder機制的 優先查找本地Binder對象 的這個特性達到了Hook掉系統服務對象的目的。因此 queryLocalInterface 也失去了它原本的意義(只查找本地Binder對象,沒有本地對象返回null),這個方法只是一個傀儡,是我們實現hook系統對象的橋梁:我們通過這個“漏洞”讓 asInterface 永遠都返回我們偽造過的對象。由于我們接管了 asInterface 這個方法的全部,我們偽造過的這個系統服務對象不能是只擁有本地Binder對象(原始 queryLocalInterface 方法返回的對象)的能力,還要有Binder代理對象操縱驅動的能力。

接下來我們就以Hook系統的剪切版服務為例,用實際代碼來說明,如何Hook掉系統服務。

Hook系統剪切版服務

偽造剪切版服務對象

首先我們用代理的方式偽造一個剪切版服務對象,關于如何使用代理的方式進行hook以及其中的原理,可以查看 插件框架原理解析——Hook機制之動態代理

具體代碼如下,我們用動態代理的方式Hook掉了 hasPrimaryClip() , getPrimaryClip() 這兩個方法:

public class BinderHookHandler implements InvocationHandler {

    private static final String TAG = "BinderHookHandler";

    // 原始的Service對象 (IInterface)
    Object base;

    public BinderHookHandler(IBinder base, Class<?> stubClass) {
        try {
            Method asInterfaceMethod = stubClass.getDeclaredMethod("asInterface", IBinder.class);
            // IClipboard.Stub.asInterface(base);
            this.base = asInterfaceMethod.invoke(null, base);
        } catch (Exception e) {
            throw new RuntimeException("hooked failed!");
        }
    }

    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        // 把剪切版的內容替換為 "you are hooked"
        if ("getPrimaryClip".equals(method.getName())) {
            Log.d(TAG, "hook getPrimaryClip");
            return ClipData.newPlainText(null, "you are hooked");
        }

        // 欺騙系統,使之認為剪切版上一直有內容
        if ("hasPrimaryClip".equals(method.getName())) {
            return true;
        }

        return method.invoke(base, args);
    }
}

</div>

注意,我們拿到原始的 IBinder 對象之后,如果我們希望使用被Hook之前的系統服務,并不能直接使用這個 IBinder 對象,而是需要使用 asInterface 方法將它轉換為 IClipboard 接口;因為 getService 方法返回的 IBinder 實際上是一個 裸Binder代理對象 ,它只有與驅動打交道的能力,但是它并不能獨立工作,需要人指揮它; asInterface 方法返回的 IClipboard.Stub.Proxy 類的對象通過操縱這個裸 BinderProxy 對象從而實現了具體的 IClipboard 接口定義的操作。

偽造 IBinder 對象

在上一步中,我們已經偽造好了系統服務對象,現在要做的就是想辦法讓 asInterface 方法返回我們偽造的對象了;我們偽造一個 IBinder 對象:

public class BinderProxyHookHandler implements InvocationHandler {

    private static final String TAG = "BinderProxyHookHandler";

    // 絕大部分情況下,這是一個BinderProxy對象
    // 只有當Service和我們在同一個進程的時候才是Binder本地對象
    // 這個基本不可能
    IBinder base;

    Class<?> stub;

    Class<?> iinterface;

    public BinderProxyHookHandler(IBinder base) {
        this.base = base;
        try {
            this.stub = Class.forName("android.content.IClipboard$Stub");
            this.iinterface = Class.forName("android.content.IClipboard");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        if ("queryLocalInterface".equals(method.getName())) {

            Log.d(TAG, "hook queryLocalInterface");

            // 這里直接返回真正被Hook掉的Service接口
            // 這里的 queryLocalInterface 就不是原本的意思了
            // 我們肯定不會真的返回一個本地接口, 因為我們接管了 asInterface方法的作用
            // 因此必須是一個完整的 asInterface 過的 IInterface對象, 既要處理本地對象,也要處理代理對象
            // 這只是一個Hook點而已, 它原始的含義已經被我們重定義了; 因為我們會永遠確保這個方法不返回null
            // 讓 IClipboard.Stub.asInterface 永遠走到if語句的else分支里面
            return Proxy.newProxyInstance(proxy.getClass().getClassLoader(),

                    // asInterface 的時候會檢測是否是特定類型的接口然后進行強制轉換
                    // 因此這里的動態代理生成的類型信息的類型必須是正確的
                    new Class[] { IBinder.class, IInterface.class, this.iinterface },
                    new BinderHookHandler(base, stub));
        }

        Log.d(TAG, "method:" + method.getName());
        return method.invoke(base, args);
    }
}

</div>

我們使用動態代理的方式偽造了一個跟原始 IBinder 一模一樣的對象,然后在這個偽造的 IBinder 對象的 queryLocalInterface 方法里面返回了我們第一步創建的 偽造過的系統服務對象 ;注意看注釋,詳細解釋可以看 代碼

替換ServiceManager的 IBinder 對象

現在就是萬事具備,只欠東風了;我們使用反射的方式修改 ServiceManager 類里面緩存的Binder對象,使得 getService 方法返回我們偽造的 IBinder 對象,進而 asInterface 方法使用偽造 IBinder 對象的 queryLocalInterface 方法返回了我們偽造的系統服務對象。代碼較簡單,如下:

final String CLIPBOARD_SERVICE = "clipboard";

// 下面這一段的意思實際就是: ServiceManager.getService("clipboard");
// 只不過 ServiceManager這個類是@hide的
Class<?> serviceManager = Class.forName("android.os.ServiceManager");
Method getService = serviceManager.getDeclaredMethod("getService", String.class);
// ServiceManager里面管理的原始的Clipboard Binder對象
// 一般來說這是一個Binder代理對象
IBinder rawBinder = (IBinder) getService.invoke(null, CLIPBOARD_SERVICE);

// Hook 掉這個Binder代理對象的 queryLocalInterface 方法
// 然后在 queryLocalInterface 返回一個IInterface對象, hook掉我們感興趣的方法即可.
IBinder hookedBinder = (IBinder) Proxy.newProxyInstance(serviceManager.getClassLoader(),
        new Class<?>[] { IBinder.class },
        new BinderProxyHookHandler(rawBinder));

// 把這個hook過的Binder代理對象放進ServiceManager的cache里面
// 以后查詢的時候 會優先查詢緩存里面的Binder, 這樣就會使用被我們修改過的Binder了
Field cacheField = serviceManager.getDeclaredField("sCache");
cacheField.setAccessible(true);
Map<String, IBinder> cache = (Map) cacheField.get(null);
cache.put(CLIPBOARD_SERVICE, hookedBinder);

</div>

接下來,在app里面使用剪切版,比如長按進行粘貼之后,剪切版的內容永遠都是 you are hooked 了;這樣,我們Hook系統服務的目的宣告完成!詳細的代碼參見 github

也許你會問,插件框架會這么hook嗎?如果不是那么插件框架hook這些干什么?插件框架當然不會做替換文本這么無聊的事情,DroidPlugin插件框架管理插件使得插件就像是主程序一樣,因此插件需要使用主程序的剪切版,插件之間也會共用剪切版;其他的一些系統服務也類似,這樣就可以達到插件和宿主程序之間的天衣服縫,水乳交融!另外, ActivityManager 以及 PackageManager 這兩個系統服務雖然也可以通過這種方式hook,但是由于它們的重要性和特殊性,DroidPlugin使用了另外一種方式,我們會單獨講解。

喜歡就點個贊吧~持續更新,請關注github項目 understand-plugin-framework 和我的博客!

</div>

 本文由用戶 cszddx 自行上傳分享,僅供網友學習交流。所有權歸原作者,若您的權利被侵害,請聯系管理員。
 轉載本站原創文章,請注明出處,并保留原始鏈接、圖片水印。
 本站是一個以用戶分享為主的開源技術平臺,歡迎各類分享!