功能的设置，标志C函数总是使用符号存根的，而不是直接调用

Question

一个有趣的学术问题，我试图解决：

在C代码，我想在运行时动态重新绑定符号，就像Facebook's fishhook repo这重新绑定函数符号。我主要关心Mach-O可执行文件的__DATA.__la_symbol_ptr部分中引用的符号。随着鱼钩的实现，你提供了你的新函数来替换原来的函数，一个字符串指出你想要替换的函数，还有一个全局函数指针，它可以取代原来的被替换的函数。

例如，从鱼钩回购自述采取...

static int (*orig_close)(int); 
int my_close(int fd) { 
    return orig_close(fd); 
} 

...然后在main

rebind_symbols((struct rebinding[1]){{"close", my_close, (void *)&orig_close}}, 1); 

这是真棒，但我希望能够完全切换拨打my_close的所有电话，并拨打close，反之亦然。例如，而不是指向原始close全局函数指针的，我想我的实现看起来像这样：

int my_close(int fd) { 
    return my_close(fd); 
} 

不幸的是，因为这个符号在同一模块中引用，这个符号将得到通过直接呼叫而不是符号存根调用。从main

0x100001e00 <+0>: push rbp 
0x100001e01 <+1>: mov rbp, rsp 
0x100001e04 <+4>: sub rsp, 0x20 
0x100001e08 <+8>: xor eax, eax 
0x100001e0a <+10>: mov dword ptr [rbp - 0x4], 0x0 
0x100001e11 <+17>: mov dword ptr [rbp - 0x8], edi 
0x100001e14 <+20>: mov qword ptr [rbp - 0x10], rsi 
0x100001e18 <+24>: mov edi, eax 
0x100001e1a <+26>: call 0x100001da0    ; my_close at main.m:42 
0x100001e1f <+31>: xor edi, edi 
0x100001e21 <+33>: mov dword ptr [rbp - 0x14], eax 
0x100001e24 <+36>: mov eax, edi 
0x100001e26 <+38>: add rsp, 0x20 
0x100001e2a <+42>: pop rbp 
0x100001e2b <+43>: ret 

好了，很容易的修复调用这个函数的时候，这里的集会，我可以用汇编指令来标记的功能较弱，使用weakref关闭编译了一个潜在的堆栈溢出。更改my_close到：

static int f(int) __attribute__ ((weakref ("my_close"))); 

__attribute__((weak)) 
int my_close(int fd) { 
    return f(fd); 
} 

然后将产生以下组件main：

0x100001df0 <+0>: push rbp 
0x100001df1 <+1>: mov rbp, rsp 
0x100001df4 <+4>: sub rsp, 0x20 
0x100001df8 <+8>: xor eax, eax 
0x100001dfa <+10>: mov dword ptr [rbp - 0x4], 0x0 
0x100001e01 <+17>: mov dword ptr [rbp - 0x8], edi 
0x100001e04 <+20>: mov qword ptr [rbp - 0x10], rsi 
0x100001e08 <+24>: mov edi, eax 
0x100001e0a <+26>: call 0x100001e5e    ; symbol stub for: my_close 
0x100001e0f <+31>: xor edi, edi 
0x100001e11 <+33>: mov dword ptr [rbp - 0x14], eax 
0x100001e14 <+36>: mov eax, edi 
0x100001e16 <+38>: add rsp, 0x20 
0x100001e1a <+42>: pop rbp 
0x100001e1b <+43>: ret 

因此，这里是我坚持的部分：引用my_close内my_close的时候，它总是导致直接调用。例如：这里是为my_close

0x100001dd0 <+0>: push rbp 
0x100001dd1 <+1>: mov rbp, rsp 
0x100001dd4 <+4>: sub rsp, 0x10 
0x100001dd8 <+8>: mov dword ptr [rbp - 0x4], edi 
0x100001ddb <+11>: mov edi, dword ptr [rbp - 0x4] 
0x100001dde <+14>: call 0x100001dd0    ; <+0> at main.m:44 
0x100001de3 <+19>: add rsp, 0x10 
0x100001de7 <+23>: pop rbp 
0x100001de8 <+24>: ret 

的组件有任何汇编指令，我可以使用（我已经错过了）告诉my_close被视为存根被称为内my_close什么时候？是的，我知道我可以使用dlsym来获得原版，但我很固执：]

Answer 1

以下我的评论，这里有一个可能的实现，其中my_call被声明为全局函数指针类型。

该方法意味着对符号的每个引用实际上是对全局变量（函数指针）的引用，可以随时轻松更新。

将此放在my_close.h：

extern volatile int (*my_close)(int); 

void set_my_close(int (*func)(int)); 

并添加此my_call.c到您的项目（主要是未经测试）：

#if defined(__unix__) || defined(__APPLE__) || defined(__linux__) 
#ifndef _GNU_SOURCE 
#define _GNU_SOURCE 
#endif 
#endif /* __unix__ */ 

/* Select the correct compiler builtin method. */ 
#if defined(__has_builtin) 

#if __has_builtin(__atomic_exchange_n) 
#define EXCHANGE(...) __atomic_exchange_n(__VA_ARGS__, __ATOMIC_ACQ_REL) 

#elif __has_builtin(__sync_swap) 
#define EXCHANGE(...) __sync_swap(__VA_ARGS__) 

#else 
#error Required builtin "__sync_swap" or "__atomic_exchange_n" missing from compiler. 
#endif /* defined(__has_builtin) */ 

#elif __GNUC__ > 3 
#define EXCHANGE(...) __sync_fetch_and_or(__VA_ARGS__) 

#else 
#error Required builtin "__sync_swap" or "__atomic_exchange_n" not found. 
#endif 

volatile int (*my_close)(int); 

void set_my_close(int (*func)(int)) { EXCHANGE(&my_close, func); } 

这可以很容易地动态更新它的my_close和路由功能的不同。

...

另一种选择，它采用C11原子操作（据说更便携）可能会要求my_close.h被包含在任何的源文件调用my_close（以确保atomic_load被调用）。

以下是未经测试：

在my_close.h：

#include <stdatomic.h> 

extern volatile _Atomic int (*my_close)(int); 

inline void set_my_close(int (*func)(int)) { atomic_store(&my_close, func); } 

#define my_close(fd) ((atomic_load(&my_close))(fd)) 

在my_close.c：

#include "my_close.h" 

#undef my_close 

volatile _Atomic int (*my_close)(int); 

我没有运行或棉绒任何代码我的电脑上，所以请仅将此视为概述。

Answer 2

对于dyld导入的函数，可以在运行时替换被调用的地址。以下代码依赖位于__DATA段开头的dyld存根地址，后跟全局变量。这里的代码片段执行从全局变量地址开始的向后搜索。

size_t (*orgStrlenPtr)(const char *__s); 
size_t myStrlen(const char *__s) 
{ 
    return orgStrlenPtr(__s); 
} 

int main(int argc, const char * argv[]) { 

    char *ptr = &orgStrlenPtr; 
    while (*(void**)ptr != strlen) { 
     ptr--; 
    } 
    orgStrlenPtr = *(void **)ptr; 
    *(void **)ptr = myStrlen; 
}