阅读 647

Block hook 正确姿势?

前言

最近在做一个项目,里面涉及到一些Mac逆向的内容,例如反编译出微信一下功能API,通过运行时拦截将我们自己的功能注入到微信中。在之中遇到这么一个难点,需要拦截微信某个功能回调,而这个回调是一个block【苹果在iOS4开始引入的对C语言的扩展,用来实现匿名函数的特性】,我们需要hook【勾住】这个block进行我们的逻辑注入,且不影响原有block逻辑。 Mac/iOS等苹果平台开发的主力语言是Objective-C,Objective-C有很强的动态性,依赖它的运行时机制,我们很容易拦截某个已实现的方法调用进行替换或者重新转发。放到我们当前这个业务来讲,拦截注入微信任何一个方法较容易,但是拦截block却没那么简单。而且网上关于block hook内容非常非常少,也没有一个相对成熟的框架或者工具来帮我们实现block hook。那今天这篇文章就来教大家如何正确进行block hook。

block hook 前提

要完成block hook有两个关键因素: 1、block也是对象,支持消息转发机制,block hook选择在消息转发时机进行操作; 2、block支持以NSInvocation的形式调用,保证block hook之后能正常响应旧block;

block也支持消息转发

Objective-C的运行时机制中最重要的一个应用场景就是消息转发。在Objective-C中,一个对象调用某个方法,严格意义上来说他不叫调用,叫发消息。Objective-C不像C/C++,在编译器就确定内部函数的地址,而是到运行时的时候才找到函数的调用地址进行调用。任何Objective-C的方法调用,编译器实际上把它转换成objc_msgSend(对象,方法名,...)这样的C函数调用。通过objc_msgSend函数,运行时机制会根据方法名在对象的方法列表里面查找方法实现,如果没有到父类中查找,一直到根类。如果没有查找到方法实现的地址,就会进入消息转发,如果消息转发没有做处理,则会抛出一个doesNotRecognizeSelector的异常。在这里我要要重点理解消息转发有什么作用。消息转发的作用就是当一个对象调用一个没有实现的方法时,给它机会去解决这个方法无法响应的问题以防止出现奔溃。 这种机制应用场景应用对象调用方法,而block也是一种对象,我们可以看下block的源码结构(以下源码是最新的libclosure-67版本):

struct Block_layout {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved; 
    void (*invoke)(void *, ...);
    struct Block_descriptor_1 *descriptor;
    // imported variables
};
复制代码

Block_layout就是block实际的源码结构,在Objective-C里,如果包含isa指针,说明这个结构类型则属于对象类型。我们可以从源码看到Block_layout包含一个isa指针,说明block是一个对象。block调用实际上是block对象调用了自己的函数实现【invoke指针,是一个函数指针,指向block的实现】,所以block也支持消息转发机制。 一个正常结构的block被响应是不会触发消息转发机制,因为消息转发机制使为了解决调用没实现方法这种异常情况。所以我们用一个比较trick的方式强制启动block的消息转发机制:

图上的意思就是当一个对象的某个方法没实现的实现,Objective-C会将该方法实现指向一个特殊的函数指针_objc_msgForward,之后方法会就进入消息动态绑定或消息转发流程。我们从这里得到启发,也就是我们强行将block的函数指针(invoke)强行指向_objc_msgForward,启动它的消息转发。启动消息转发后,我们需要实现以下函数来辅助我们对这个block进行后继的处理:

- (id)forwardingTargetForSelector:(SEL)aSelector;
- (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector;
- (void)forwardInvocation:(NSInvocation *)anInvocation;
复制代码

forwardingTargetForSelector可以为了方法指定一个能够响应这个方法的备选对象,因为hook处理不在这个时机,所以我们可以不用去实现这个方法指定一个备选者。 methodSignatureForSelector返回一个方法的签名,签名包含方法入参信息、返回值等信息,对于block来说就是block的签名,后面源码会分析怎么获取block的签名。 forwardInvocation会根据上一步返回的签名生成一个NSInvocation对象,它包含方法调用所有信息,而我们的hook关键也在这一步,重新包装NSInvocation对象进行响应,后面我会将具体怎么操作。

block支持以NSInvocation的形式调用

从苹果官方文档,我们知道NSInvocation是一条消息的对象包装,这里消息指的是我们的方法调用,同样也适用block。NSInvocation构造的关键是签名,方法的签名获取比较简单,通过[NSString instanceMethodSignatureForSelector:@selector(method:)]获取。block签名的获取则没那么直接,我们再来看下block的源码结构:

#define BLOCK_DESCRIPTOR_1 1
struct Block_descriptor_1 {
    uintptr_t reserved;
    uintptr_t size;
};

#define BLOCK_DESCRIPTOR_2 1
struct Block_descriptor_2 {
    // requires BLOCK_HAS_COPY_DISPOSE
    void (*copy)(void *dst, const void *src);
    void (*dispose)(const void *);
};

#define BLOCK_DESCRIPTOR_3 1
struct Block_descriptor_3 {
    // requires BLOCK_HAS_SIGNATURE
    const char *signature;
    const char *layout;     // contents depend on BLOCK_HAS_EXTENDED_LAYOUT
};

struct Block_layout {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved; 
    void (*invoke)(void *, ...);
    struct Block_descriptor_1 *descriptor;
    // imported variables
};
复制代码

可以看到Block_descriptor_3这个结构体包含signature这个字段,这也是我们需要的签名。我们从Block_layout结构中看到,好像没有访问Block_descriptor_3的方法,它只有一个Block_descriptor_1的指针,这是因为并不是所有block有Block_descriptor_3这个结构体,编译器根据flags上的值判断block是何种类型,生成不同的Block_layout结构。Block_descriptor_2也是同理。那怎么判断呢?先看下面的枚举:

// Values for Block_layout->flags to describe block objects
enum {
    BLOCK_DEALLOCATING =      (0x0001),  // runtime
    BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    BLOCK_IS_GC =             (1 << 27), // runtime
    BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};
复制代码

通过flags与BLOCK_HAS_SIGNATURE做一次与操作,如果值不为0,则说明当前这个block有Block_descriptor_3这个结构,这样就可以取到里面的签名信息。 接着通过[NSMethodSignature signatureWithObjCTypes]生成签名对象,再通过[NSInvocation invocationWithMethodSignature]构造NSInvocation对象,给NSInvocation对象指定消息的响应者,block响应者当然是自己本身,再调invoke方法就可以完成block的调用。

block hook 基本步骤

1、保存原来block的副本,因为不影响原有的微信业务逻辑,在hook注入我们自己业务逻辑之后,我们需要回过头响应原有的微信block逻辑;
2、强制启动block的消息转发机制;
3、在消息转发最后一步,将副本和hook block取出包装成NSInvocation进行调用;

block hook 具体操作

我这边设计一个block hook框架WBHookBlock,这个框架提供各种姿势给block hook,你可以在origin block前调用你注入的逻辑,或者在origin block后调用,甚至是替换origin block,API如下:

typedef NS_ENUM(NSUInteger, WBHookBlockPosition) {
    WBHookBlockPositionBefore = 0,
    WBHookBlockPositionAfter,
    WBHookBlockPositionReplace,
};

@interface WBHookBlock : NSObject

+ (void)hookBlock:(id)originBlock alter:(id)alterBlock position:(WBHookBlockPosition)position;

@end
复制代码

因为这需要访问block源码层面的数据(现有没有API提供访问入口),所以我仿造官方源码构造一个源码结构体的block:

typedef NS_OPTIONS(int, WBFishBlockFlage) {
    WBFish_BLOCK_DEALLOCATING =      (0x0001),  // runtime
    WBFish_BLOCK_REFCOUNT_MASK =     (0xfffe),  // runtime
    WBFish_BLOCK_NEEDS_FREE =        (1 << 24), // runtime
    WBFish_BLOCK_HAS_COPY_DISPOSE =  (1 << 25), // compiler
    WBFish_BLOCK_HAS_CTOR =          (1 << 26), // compiler: helpers have C++ code
    WBFish_BLOCK_IS_GC =             (1 << 27), // runtime
    WBFish_BLOCK_IS_GLOBAL =         (1 << 28), // compiler
    WBFish_BLOCK_USE_STRET =         (1 << 29), // compiler: undefined if !BLOCK_HAS_SIGNATURE
    WBFish_BLOCK_HAS_SIGNATURE  =    (1 << 30), // compiler
    WBFish_BLOCK_HAS_EXTENDED_LAYOUT=(1 << 31)  // compiler
};

struct WBFishBlock_layout {
    void *isa;
    volatile int32_t flags;
    int32_t reserved;
    void (*invoke)(void *, ...);
    struct WBFishBlock_descriptor_1 *descriptor;
};
typedef struct WBFishBlock_layout  *WBFishBlock;

struct WBFishBlock_descriptor_1 {
    uintptr_t reserved;
    uintptr_t size;
};

struct WBFishBlock_descriptor_2 {
    void (*copy)(void *dst, const void *src);
    void (*dispose)(const void *);
};

struct WBFishBlock_descriptor_3 {
    const char *signature;
    const char *layout;
};
复制代码

可能命名跟源码里的名字不一样,但这不影响,因为结构体结构和数据偏移是一样,这能够保证正确访问block内的数据(例如flags、invoke指针、des描述信息)

+ (void)hookBlock:(id)originBlock alter:(id)alterBlock position:(WBHookBlockPosition)position{
    WBFishBlock u_originBlock = (__bridge WBFishBlock)originBlock;
    WBFishBlock u_alterBlock = (__bridge WBFishBlock)alterBlock;
    
    wbhook_setPosInfo(u_originBlock, position);
    
    wbhook_setHookBlock(u_originBlock, u_alterBlock);
    
    wbhook_block(originBlock);
}
复制代码

先做bridge桥接将Objective-C block转化为结构体形式的block。wbhook_setPosInfo将位置信息跟origin block关联起来,wbhook_setHookBlock将alter block[自己业务逻辑的block]跟origin block关联起来,目的是先保存起来以方便后继使用,关联对象的存取如下:

static void wbhook_setHookBlock(WBFishBlock block, WBFishBlock hookBlock) {
    objc_setAssociatedObject((__bridge id _Nonnull)(block), @"wbhook_block_hookBlock", (__bridge id _Nullable)(hookBlock), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
    
}

static id wbhook_getHookBlock(WBFishBlock block) {
    return objc_getAssociatedObject((__bridge id _Nonnull)(block), @"wbhook_block_hookBlock");
}

static void wbhook_setPosInfo(WBFishBlock block, NSUInteger pos) {
    objc_setAssociatedObject((__bridge id _Nonnull)(block), @"wbhookblock_pos", @(pos), OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

static NSNumber* wbhook_getPosInfo(WBFishBlock block) {
    return objc_getAssociatedObject((__bridge id _Nonnull)(block), @"wbhookblock_pos");
}
复制代码

接下来看wbhook_block的逻辑:

wbblock_hook_once();
    WBFishBlock block = (__bridge WBFishBlock)(obj);
    if (!wbhook_block_getTmpBlock(block)) {
        //先copy一份,目的是为了复制外部变量
        _wbFish_block_deepCopy(block);
        struct WBFishBlock_descriptor_3 *desc_3 = get_WBFishBlock_descriptor_3(block);
        //设置block的invoke指针为_objc_msgForward为了调用block触发消息转发。
        block->invoke = _objc_msgForward;
    }
复制代码

wbblock_hook_once里主要做消息转发那些方法的swizzle操作,这个等下后面详细讲。 wbhook_block_getTmpBlock用于获取origin block的副本,如果是第一次hook这个block是没有这个副本,所以我们需要通过_wbFish_block_deepCopy拷贝一份副本保存起来。这时候也许会有人问为什么要拷贝一份副本,先不着急,我先将这里的整体逻辑讲完再细细道来。最后一步我们将block的invoke指针强行指向_objc_msgForward,有上文知道invoke指针指向block的实现,指向_objc_msgForward会启动block的消息转发。现在我们就来说明为什么需要拷贝一份副本,因为origin block已经被指向_objc_msgForward启动消息转发,后面在消息转发最后一个阶段如果还需要调用origin block的逻辑,我们不能直接再调origin block,因为再调用origin block会再次进入消息转发,这就变成一个死循环,所以我们需要保持一个origin block的副本用于调起origin block的逻辑,因为副本是通过深拷贝出来的,跟origin block是相互独立,所以origin block强制消息转发不会影响副本,也就不会进入死循环。 那block如何做深拷贝?这里需要分情况:

static void _wbFish_block_deepCopy(WBFishBlock block) {
    struct WBFishBlock_descriptor_2 *desc_2 = get_WBFishBlock_descriptor_2(block);
    //如果捕获的变量存在对象或者被__block修饰的变量时,在__main_block_desc_0函数内部会增加copy跟dispose函数,copy函数内部会根据修饰类型(weak or strong)对对象进行强引用还是弱引用,当block释放之后会进行dispose函数,release掉修饰对象的引用,如果都没有引用对象,将对象释放

    if (desc_2) {
        WBFishBlock newBlock = malloc(block->descriptor->size);
        if (!newBlock) {
            return;
        }
        memmove(newBlock, block, block->descriptor->size);
        newBlock->flags &= ~(WBFish_BLOCK_REFCOUNT_MASK|WBFish_BLOCK_DEALLOCATING);
        newBlock->flags |= WBFish_BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        
        (desc_2->copy)(newBlock, block);
        wbhook_block_setTmpBlock(block, newBlock);
    } else {
        WBFishBlock newBlock = malloc(block->descriptor->size);
        if (!newBlock) {
            return;
        }
        memmove(newBlock, block, block->descriptor->size);
        newBlock->flags &= ~(WBFish_BLOCK_REFCOUNT_MASK|WBFish_BLOCK_DEALLOCATING);
        newBlock->flags |= WBFish_BLOCK_NEEDS_FREE | 2;  // logical refcount 1
        wbhook_block_setTmpBlock(block, newBlock);
    }
}
复制代码

基本操作就是先声明一个新block,申请内存,执行memmove内存拷贝操作,将旧block的内容拷贝到新block上,flags的配置参考官方block_copy的源码,主要目的是标识block的类型和引用计数,这里一步不同就是如果block结构中存在WBFishBlock_descriptor_2,什么类型的block会存在WBFishBlock_descriptor_2呢?如果一个block是一个堆block,且捕获对象类型的变量或者__block修饰的变量时,这时候的block会多一个WBFishBlock_descriptor_2描述信息,里面包含两个内存辅助函数指针,用于辅助捕获变量的内存管理。对于这种类型的block的拷贝,还需要调用WBFishBlock_descriptor_2的copy函数进行捕获变量的内存管理的拷贝,这里也是参考官方block_copy的源码。拷贝结束后通过wbhook_block_setTmpBlock将拷贝的副本与origin block关联保存起来:

static void wbhook_block_setTmpBlock(WBFishBlock block, WBFishBlock tmpBlock) {
    objc_setAssociatedObject((__bridge id)block, @"wbhook_block_TmpBlock", (__bridge id)tmpBlock, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

static id wbhook_block_getTmpBlock(WBFishBlock block) {
    return objc_getAssociatedObject((__bridge id)block, @"wbhook_block_TmpBlock");
}
复制代码

我们再回到wbblock_hook_once这个函数,上面说了里面主要做一些消息转发函数的重定义的操作,还记得那几个消息转发函数吗?

#define WBFish_StrongHookMethod(selector, func) { Class cls = NSClassFromString(@"NSBlock");Method method = class_getInstanceMethod([NSObject class], selector); \
BOOL success = class_addMethod(cls, selector, (IMP)func, method_getTypeEncoding(method)); \
if (!success) { class_replaceMethod(cls, selector, (IMP)func, method_getTypeEncoding(method));}}

static void wbblock_hook_once() {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        WBFish_StrongHookMethod(@selector(methodSignatureForSelector:), wb_block_methodSignatureForSelector);
        //在forwardInvocation:中执行完自己的逻辑后,将invocation的target设置为刚刚copy的block,执行invoke。完成Hook
        WBFish_StrongHookMethod(@selector(forwardInvocation:), wb_block_forwardInvocation);
    });
}
复制代码

利用Objective-C的运行时相关函数,我们很容易实现方法的替换,详见宏定义。我们这里主要是为了替换实现两个消息转发的方法methodSignatureForSelectorforwardInvocation, methodSignatureForSelector用于返回block的签名,forwardInvocation是我们做转发逻辑的关键:

static NSMethodSignature *wb_block_methodSignatureForSelector(id self, SEL _cmd, SEL aSelector) {
    struct WBFishBlock_descriptor_3 *desc_3 = get_WBFishBlock_descriptor_3((__bridge void *)self);
    return [NSMethodSignature signatureWithObjCTypes:desc_3->signature];
}

static void wb_block_forwardInvocation(id self, SEL _cmd, NSInvocation *invo) {
    WBFishBlock block = (__bridge void *)invo.target;
    
    NSUInteger originArgNum = invo.methodSignature.numberOfArguments;
    NSUInteger hookArgNum = invo.methodSignature.numberOfArguments;
    
    //block转invoation
    WBFishBlock hookBlock = (__bridge void*)wbhook_getHookBlock(block);
    struct WBFishBlock_descriptor_3 * hookBlock_des_3 = get_WBFishBlock_descriptor_3(hookBlock);
    NSMethodSignature *hookBlockMethodSignature = [NSMethodSignature signatureWithObjCTypes:hookBlock_des_3->signature];
    NSInvocation *hookBlockInv = [NSInvocation invocationWithMethodSignature:hookBlockMethodSignature];
    
    if (originArgNum != hookArgNum) {
        NSLog(@"arguments count is not fit");
        return;
    }
    
    if (hookArgNum > 1) {
        void *tmpArg = NULL;
        for (NSUInteger i = 1; i < hookArgNum; i++) {
            const char *type = [invo.methodSignature getArgumentTypeAtIndex:i];
            NSUInteger argsSize;
            NSGetSizeAndAlignment(type, &argsSize, NULL);
            if (!(tmpArg = realloc(tmpArg, argsSize))) {
                NSLog(@"fail allocate memory for block arg");
                return;
            }
            [invo getArgument:tmpArg atIndex:i];
            [hookBlockInv setArgument:tmpArg atIndex:i];
        }
    }
    
    WBFishBlock tmpBlock = (__bridge void *)wbhook_block_getTmpBlock(block);
    
    NSNumber *pos = wbhook_getPosInfo(block);
    NSUInteger posInx = [pos unsignedIntegerValue];
    switch (posInx) {
        case 0:
            [invo invokeWithTarget:(__bridge id _Nonnull)(tmpBlock)];
            [hookBlockInv invokeWithTarget:(__bridge id _Nonnull)(hookBlock)];
            break;
        case 1:
            [hookBlockInv invokeWithTarget:(__bridge id _Nonnull)(hookBlock)];
            [invo invokeWithTarget:(__bridge id _Nonnull)(tmpBlock)];
            break;
        case 2:
            [hookBlockInv invokeWithTarget:(__bridge id _Nonnull)(hookBlock)];
            break;
        default:
            [invo invokeWithTarget:(__bridge id _Nonnull)(tmpBlock)];
            [hookBlockInv invokeWithTarget:(__bridge id _Nonnull)(hookBlock)];
            break;
    }
}
复制代码

我们看下在消息转发最后一步,我们怎么完成hook注入我们的逻辑,我们从消息转发得到NSInvocation的target中得到origin block,再从origin block的关联对象中取到保存的副本tmp block、alter block【注入的业务逻辑】及位置信息,将tmp block和alter block转化为NSInvocation对象,根据位置信息先后调用invoke实现两个block的调用。

示例源码

demo源码
想了解更多iOS终端相关知识可以前往终端杂谈

关注下面的标签,发现更多相似文章
评论