Android so注入( inject)和Hook(挂钩)的实现思路讨论

本文博客：http://blog.csdn.net/qq1084283172/article/details/54095995

前面的博客中分析一些Android的so注入和Hook目标函数的代码，它们的实现思路基本是一致的只是在一些细节实现的地方稍有不同。下面的文章中，将前面学习的别人的Android的so注入和目标函数的Hook的实现方法，进行整理一下，对Android的so注入和目标函数的Hook的代码实现的方法进行思考和分析。

Androd so注入和函数Hook（基于got表）的步骤：

1.ptrace附加目标pid进程；

2.在目标pid进程中，查找内存空间（用于存放被注入的so文件的路径和so中被调用的函数的名称或者shellcode）；

3.调用目标pid进程中的dlopen、dlsym等函数，用于加载so文件实现Android so的注入和函数的Hook；

4.释放附加的目标pid进程和卸载注入的so文件。

一、在目标pid进程中查找内存空间的方法

方法一：获取目标pid进程加载的”/system/lib/libc.so”动态库文件中mmap函数的调用地址，然后远程调用目标pid进程中的mmap函数，在目pid进程中申请内存空间用于保存被注入加载的so库文件的路径的名称和被加载的so库文件中被调用的导出函数，主要为后面调用dlopen加载so库文件和调用dlsym获取被注入的so文件的中导出函数做准备即为后面进行Android的so注入和函数的Hook做准备（见作者ariesjzj提供的Android的so注入和函数Hook的思路）或者向目标pid进程中写入shellcode操作。

 // 获取目标pid进程中"/system/lib/libc.so"中的mmap函数的调用地址
    mmap_addr = get_remote_addr(target_pid, libc_path, (void *)mmap);
    DEBUG_PRINT("[+] Remote mmap address: %x\n", mmap_addr);    /* call mmap 准备调用目标pid进程中的mmap函数需要的参数 */
    parameters[0] = 0;  // addr
    parameters[1] = 0x4000; // size--在目标pid进程中申请的内存空间的大小
    parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC;  // prot
    parameters[3] =  MAP_ANONYMOUS | MAP_PRIVATE; // flags
    parameters[4] = 0; //fd
    parameters[5] = 0; //offset    // 调用目标pid进程中的mmap函数，在目标pid进程的内存空间中申请内存空间
    if (ptrace_call_wrapper(target_pid, "mmap", mmap_addr, parameters, 6, &regs) == -1)    // 调用失败，跳转
        goto exit;    // 获取调用目标pid进程的mmap函数完成的函数返回值即申请的内存空间地址
    map_base = ptrace_retval(&regs);    // 获取目标pid进程中dlopen函数的调用地址
    dlopen_addr = get_remote_addr( target_pid, linker_path, (void *)dlopen );    // 获取目标pid进程中dlsym函数的调用地址
    dlsym_addr = get_remote_addr( target_pid, linker_path, (void *)dlsym );

方法二：遍历目标pid进程的/proc/pid/maps文件，找到空闲的内存空间，用于存放调用dlopen、dlsym等函数的参数或者执行的shellcode代码。

// 在目标pid进程的"/system/lib/libc.so"的内存范围内(从内存结束地址往回的方向)查找内存空间
void* find_space_in_maps(int pid, int size) {char statline[1024];
FILE * fp;
uint32_t* addr = (uint32_t*) 0x40008000;
char *address, *proms, *ptr;
const char* tname = "/system/lib/libc.so";
const char* tproms = "r-xp";// 获取字符串"/system/lib/libc.so"的长度
int tnaem_size = strlen(tname);
// 获取字符串"r-xp"的长度
int tproms_size = strlen(tproms);// 内存以4字节对齐
size = ((size / 4) + 1) * 4;// 格式化得到字符串"/proc/pid/maps"
sprintf(statline, "/proc/%d/maps", pid);// 打开文件"/proc/pid/maps"
fp = fopen(statline, "r");
if (fp == 0)
return 0;// 读取文件"/proc/pid/maps"中内容（每次读一行）
while (fgets(statline, sizeof(statline), fp)) {// 分割字符串
ptr = statline;
// 得到内存模块的起始和结束地址
address = nexttok(&ptr); // skip address
// 内存模块的属性
proms = nexttok(&ptr); // skip proms
nexttok(&ptr); // skip offset
nexttok(&ptr); // skip dev
nexttok(&ptr); // skip inode// ptr中最终保存的是加载的内存模块的路径字符串
while (*ptr != '\0') {
if (*ptr == ' ')
ptr++;
else
break;
}// 查找目标so模块
if (ptr && proms && address) {// 判断是否是"r-xp"属性的模块
if (strncmp(tproms, proms, tproms_size) == 0) {// 判断是否是"/system/lib/libc.so"模块
if (strncmp(tname, ptr, tnaem_size) == 0) {// address like afe00000-afe3a000
if (strlen(address) == 17) {// 获取内存加载模块/system/lib/libc.so的内存范围的结束地址（方便后面查找内存空间）
addr = (uint32_t*) strtoul(address + 9, NULL, 16);
// 在目标pid进程的/system/lib/libc.so的内存范围内查找到size大小内存空间
addr -= size;printf("proms=%s address=%s name=%s", proms, address, ptr);
break;
}
}
}
}
}// 关闭文件
fclose(fp);// 返回在目标进程中查找到的内存空间的地址
return (void*) addr;
}

二、在目标pid进程中加载so实现Android的so注入和函数Hook的方法

方法一：初期Android so的注入版本（古河）的Android的so的注入和函数Hook是由arm汇编的shellcode实现，代码的移植性不好而且不易阅读，具体的实现就是：将dlopen、dlsym等函数调用需要的函数参数以及执行so加载和执行Hook目标pid进程中的函数的shellcode代码指令写入到目标pid进程内存中，然后修改目标pid进程的PC指令计数寄存器跳转到目标pid进程内存的shellcode处执行加载so和Hook目标pid进程的函数（基于got表）。

.global _dlopen_addr_s             @全局变量_dlopen_addr_s保存dlopen函数的调用地址
.global _dlopen_param1_s           @全局变量_dlopen_param1_s保存函数dlopen的第一个参数-加载库文件的路径
.global _dlopen_param2_s           @全局变量_dlopen_param2_s保存函数dlopen的第二个参数-库文件的打开模式  .global _dlsym_addr_s              @全局变量_dlsym_addr_s保存函数dlsym的调用地址
.global _dlsym_param2_s            @全局变量_dlsym_param2_s保存函数dlsym的第二个参数-获取调用地址的函数的名称  .global _dlclose_addr_s            @全局变量_dlclose_addr_s保存函数dlclose的调用地址  .global _inject_start_s            @全局变量_inject_start_s保存注入代码的起始地址
.global _inject_end_s              @全局变量_inject_end_s保存注入代码的结束地址  .global _inject_function_param_s   @全局变量_inject_function_param_s保存Hook函数的参数  .global _saved_cpsr_s              @全局变量_saved_cpsr_s保存当前程序状态寄存器CPSR的值
.global _saved_r0_pc_s             @全局变量_saved_r0_pc_s保存寄存器环境R0-R15(PC)的值起始地址  @定义数据段.data
.data                                @注入代码的起始地址
_inject_start_s:
    @ debug loop
3:
    @sub r1, r1, #0
    @B 3b      @调用dlopen函数
    ldr r1, _dlopen_param2_s    @库文件的打开模式
    ldr r0, _dlopen_param1_s    @加载库文件的路径字符串即Hook函数所在的模块
    ldr r3, _dlopen_addr_s      @dlopen函数的调用地址
    blx r3                      @调用函数dlopen加载并打开动态库文件
    subs r4, r0, #0             @判断函数返回值r0-是否打开动态库文件成功
    beq 2f                  @打开动态库文件失败跳转标签2的地方执行
                    @r0保存加载库的引用pHandle      @调用dlsym函数
    ldr r1, _dlsym_param2_s     @获取调用的地址的函数名称字符串
    ldr r3, _dlsym_addr_s       @dlsym函数的调用地址
    blx r3                      @调用函数dlsym获取目标函数的调用地址
    subs r3, r0, #0             @判断函数的返回值r0
    beq 1f                      @不成功跳转到标签1的地方执行
                                    @r3保存获取到的函数的调用地址      @调用Hook_Api函数
    ldr r0, _inject_function_param_s   @给Hook函数传入参数r0
    blx r3                             @调用Hook函数Hook远程目标进程的某系统调用函数
    subs r0, r0, #0                    @判断函数的返回值r0
    beq 2f                             @r0=0跳转到标签2的地方执行 ??  1:
    @调用dlclose函数
    mov r0, r4                         @参数r0动态库的应用
    ldr r3, _dlclose_addr_s            @赋值r3为dlclose函数的调用地址
    blx r3                             @调用dlclose函数关闭库文件的引用pHandle            2:
    @恢复目标进程的原来状态
    ldr r1, _saved_cpsr_s
    msr cpsr_cf, r1                    @恢复目标进程寄存器CPSR的值      ldr sp, _saved_r0_pc_s
    ldmfd sp, {r0-pc}                  @恢复目标进程寄存器环境R0-R15(PC)的值且sp不改变     _dlopen_addr_s:
.word 0x11111111                           @初始化word型全局变量_dlopen_addr_s  _dlopen_param1_s:
.word 0x11111111                           @初始化word型全局变量_dlopen_param1_s  _dlopen_param2_s:                          @初始化word型全局变量_dlopen_param2_s = 0x2
.word 0x2  _dlsym_addr_s:
.word 0x11111111                           @初始化word型全局变量_dlsym_addr_s  _dlsym_param2_s:
.word 0x11111111                           @初始化word型全局变量_dlsym_param2_s  _dlclose_addr_s:
.word 0x11111111                           @初始化word型全局变量_dlclose_addr_s  _inject_function_param_s:
.word 0x11111111                           @初始化word型全局变量_inject_function_param_s  _saved_cpsr_s:
.word 0x11111111                           @初始化word型全局变量_saved_cpsr_s  _saved_r0_pc_s:
.word 0x11111111                           @初始化word型全局变量_saved_r0_pc_s  @注入代码的结束地址
_inject_end_s:                               .space 0x400, 0                            @申请的代码段内存空间大小  @数据段.data的结束位置
.end

方法二：其实呢，注入so库文件到目标pid进程以及Hook目标pid进程中got表的函数的实现，不需要用注入shellcode到目标pid进程中的方式来解决。通过获取目标pid进程中dlopen、dlsym等函数的调用地址，远程调用目标pid进程的dlpoen函数可以实现so库文件的注入，远程调用目标pid进程中dlsym函数获取加载的so库文件中的导出函数，调用该导出函数对目标pid进程中基于got表的目标函数进行Hook即可。

// 调用目标pid进程中的mmap函数，在目标pid进程的内存空间中申请内存空间
    if (ptrace_call_wrapper(target_pid, "mmap", mmap_addr, parameters, 6, &regs) == -1)    // 调用失败，跳转
        goto exit;    // 获取调用目标pid进程的mmap函数完成的函数返回值即申请的内存空间地址
    map_base = ptrace_retval(&regs);    // 获取目标pid进程中dlopen函数的调用地址
    dlopen_addr = get_remote_addr( target_pid, linker_path, (void *)dlopen );    // 获取目标pid进程中dlsym函数的调用地址
    dlsym_addr = get_remote_addr( target_pid, linker_path, (void *)dlsym );    // 获取目标pid进程中dlclose函数的调用地址
    dlclose_addr = get_remote_addr( target_pid, linker_path, (void *)dlclose );    // 获取目标pid进程中dlerror函数的调用地址
    dlerror_addr = get_remote_addr( target_pid, linker_path, (void *)dlerror );    // 打印获取到目标pid进程中dlopen等函数的地址
    DEBUG_PRINT("[+] Get imports: dlopen: %x, dlsym: %x, dlclose: %x, dlerror: %x\n",
            dlopen_addr, dlsym_addr, dlclose_addr, dlerror_addr);    // 打印即将被注入的so库文件的文件路径
    printf("library path = %s\n", library_path);    // 将要被注入到目标pid进程中的so库文件的路径字符串library_path写入到前面mmap申请的内存空间中
    ptrace_writedata(target_pid, map_base, library_path, strlen(library_path) + 1);    // 设置调用dlopen函数的函数参数
    parameters[0] = map_base;// library_path将被加载到目标pid进程中的so文件路径
    parameters[1] = RTLD_NOW| RTLD_GLOBAL;    // 调用目标pid进程中的dlopen函数，加载library_path路径的so文件到目标pid进程中，实现so注入
    if (ptrace_call_wrapper(target_pid, "dlopen", dlopen_addr, parameters, 2, &regs) == -1)    // 失败进行跳转
        goto exit;    // 获取dlopen函数调用后的返回值即library_path指定的so文件在目标pid进程中的加载基址
    void * sohandle = ptrace_retval(&regs);    // 设置map_base中保存library_path指定的so文件的导出函数function_name字符串的内存偏移
#define FUNCTION_NAME_ADDR_OFFSET       0x100
    // 将library_path指定的so文件的导出函数function_name的函数名称字符串写入到目标pid进程中前面mmap申请的内存空间offset=0x100的位置
    ptrace_writedata(target_pid, map_base + FUNCTION_NAME_ADDR_OFFSET, function_name, strlen(function_name) + 1);    // 设置dlsym函数调用的函数参数
    parameters[0] = sohandle;// so基址模块句柄
    parameters[1] = map_base + FUNCTION_NAME_ADDR_OFFSET;// 将被获取的导出函数的调用地址    // 在目标pid进程中调用dlsym函数，获取上面加载的so文件中的导出函数function_name的调用地址
    if (ptrace_call_wrapper(target_pid, "dlsym", dlsym_addr, parameters, 2, &regs) == -1)    // 失败，跳转
        goto exit;    // 获取调用dlsym函数后，返回的导出函数function_name的调用地址
    void * hook_entry_addr = ptrace_retval(&regs);    // 打印获取到的导出函数function_name的调用地址
    DEBUG_PRINT("hook_entry_addr = %p\n", hook_entry_addr);    // 设置map_base中保存调用导出函数function_name需要的函数参数的内存偏移
#define FUNCTION_PARAM_ADDR_OFFSET      0x200
    // 将调用hook_entry_addr函数需要的函数参数保存到前面在目标pid进程中mmap申请的内存空间offset=0x200的位置
    ptrace_writedata(target_pid, map_base + FUNCTION_PARAM_ADDR_OFFSET, param, strlen(param) + 1);    // 设置调用目标pid进程中hook_entry函数的函数参数
    parameters[0] = map_base + FUNCTION_PARAM_ADDR_OFFSET;    // 调用注入到目标pid进程中的so库的导出函数hook_entry实现我们自定义的代码，可以是Hook目标pid进程的函数
    if (ptrace_call_wrapper(target_pid, "hook_entry", hook_entry_addr, parameters, 1, &regs) == -1)
        goto exit;

三、在目标pid进程中注入so以后进行一次函数调用，实现Hook目标函数

方法一：前面的步骤中已经将so库文件注入到目标pid进程中了，只需要远程调用目标pid进程中的dlsym函数获取执行函数Hook的导出函数，然后远程调用目标pid进程中该导出函数即可实现Hook目标pid进程中基于got表的目标函数。

  // 设置map_base中保存library_path指定的so文件的导出函数function_name字符串的内存偏移
#define FUNCTION_NAME_ADDR_OFFSET       0x100
    // 将library_path指定的so文件的导出函数function_name的函数名称字符串写入到目标pid进程中前面mmap申请的内存空间offset=0x100的位置
    ptrace_writedata(target_pid, map_base + FUNCTION_NAME_ADDR_OFFSET, function_name, strlen(function_name) + 1);    // 设置dlsym函数调用的函数参数
    parameters[0] = sohandle;// so基址模块句柄
    parameters[1] = map_base + FUNCTION_NAME_ADDR_OFFSET;// 将被获取的导出函数的调用地址    // 在目标pid进程中调用dlsym函数，获取上面加载的so文件中的导出函数function_name的调用地址
    if (ptrace_call_wrapper(target_pid, "dlsym", dlsym_addr, parameters, 2, &regs) == -1)    // 失败，跳转
        goto exit;    // 获取调用dlsym函数后，返回的导出函数function_name的调用地址
    void * hook_entry_addr = ptrace_retval(&regs);    // 打印获取到的导出函数function_name的调用地址
    DEBUG_PRINT("hook_entry_addr = %p\n", hook_entry_addr);    // 设置map_base中保存调用导出函数function_name需要的函数参数的内存偏移
#define FUNCTION_PARAM_ADDR_OFFSET      0x200
    // 将调用hook_entry_addr函数需要的函数参数保存到前面在目标pid进程中mmap申请的内存空间offset=0x200的位置
    ptrace_writedata(target_pid, map_base + FUNCTION_PARAM_ADDR_OFFSET, param, strlen(param) + 1);    // 设置调用目标pid进程中hook_entry函数的函数参数
    parameters[0] = map_base + FUNCTION_PARAM_ADDR_OFFSET;    // 调用注入到目标pid进程中的so库的导出函数hook_entry实现我们自定义的代码，可以是Hook目标pid进程的函数
    if (ptrace_call_wrapper(target_pid, "hook_entry", hook_entry_addr, parameters, 1, &regs) == -1)
        goto exit;

方法二：不需要调用目标pid进程中dlsym函数获取注入so文件的导出函数，来实现Hook目标pid进程的目标函数。在so库文件加载的时候，会首先执行.init段的构造函数，该构造函数的定义方法为 void __attribute__((constructor)) x_init(void)，因此当我们向目标pid进程注入so库文件的时候，执行该x_init函数，可以实现Hook目标pid进程的函数的目的，该x_init函数唯一的不足就是不能传递函数参数。

共享库文件的高级特性：

dlopen函数的调用流程图：

因此，被注入的so库文件的源码文件中实现Hook目标函数的导出函数 hook_entry 的定义为：

void __attribute__((constructor)) hook_entry(void) {// 执行Hook目标函数的操作
}

方法三：在注入到目标pid进程中的so库文件的源码文件中定义全局变量，在so库文件加载到目标pid进程的内存中，全局变量的初始化的时候，有一次执行Hook目标pid进程的基于got表的目标函数的机会。也就是在注入的so的源码文件中定义一个全局变量（对象），当全局变量初始化时（全局对象变量调用构造函数的时候），有一次执行Hook目标函数的机会即使用c++全局对象初始化，其构造函数会被自动执行。

void Main();  // 线程的过程回调函数
static void* _main(void*){      Main();
    return NULL;
}  // 全局类对象的定义
class EntryClass {
public:      EntryClass() {
        pthread_t tid;
        pthread_create(&tid, NULL, _main, NULL);
        pthread_detach(tid);
    }  } object;

参考链接：

《UNIX系统编程手册下》.((德)Michael Kerrisk )

http://blog.csdn.net/l173864930/article/details/38456313

http://bbs.pediy.com/showthread.php?p=1299179

http://bbs.pediy.com/showthread.php?t=212035

四、在目标pid进程中Hook目标函数的实现方法

方法一：通过解析目标pid进程内存中的需要被Hook的目标so库文件，找到该目标so文件的.got表，然后遍历查找到需要被Hook的目标函数的调用地址进行替换，替换为我们自定义的函数的地址。

// Hook库/system/lib/libsurfaceflinger.so中的eglSwapBuffers函数
#define LIBSF_PATH  "/system/lib/libsurfaceflinger.so"int hook_eglSwapBuffers()
{
// 保存被Hook的目标函数的原始调用地址
    old_eglSwapBuffers = eglSwapBuffers;
    LOGD("Orig eglSwapBuffers = %p\n", old_eglSwapBuffers);    // 获取目标pid进程中"/system/lib/libsurfaceflinger.so"模块的加载地址
    void * base_addr = get_module_base(getpid(), LIBSF_PATH);
    LOGD("libsurfaceflinger.so address = %p\n", base_addr);    int fd;
    // 打开内存模块文件"/system/lib/libsurfaceflinger.so"
    fd = open(LIBSF_PATH, O_RDONLY);
    if (-1 == fd) {        LOGD("error\n");
        return -1;
    }    // elf32文件的文件头结构体Elf32_Ehdr
    Elf32_Ehdr ehdr;
    // 读取elf32格式的文件"/system/lib/libsurfaceflinger.so"的文件头信息
    read(fd, &ehdr, sizeof(Elf32_Ehdr));    // elf32文件中区段表信息结构的文件偏移
    unsigned long shdr_addr = ehdr.e_shoff;
    // elf32文件中区段表信息结构的数量
    int shnum = ehdr.e_shnum;
    // elf32文件中每个区段表信息结构中的单个信息结构的大小（描述每个区段的信息的结构体的大小）
    int shent_size = ehdr.e_shentsize;    // elf32文件区段表中每个区段的名称存放的字符串区段，在区段表中的序号index
    unsigned long stridx = ehdr.e_shstrndx;    // elf32文件中区段表的每个单元信息结构体（描述每个区段的信息的结构体）
    Elf32_Shdr shdr;
    // elf32文件中定位到存放每个区段名称的字符串表的信息结构体位置.shstrtab
    lseek(fd, shdr_addr + stridx * shent_size, SEEK_SET);
    // 读取elf32文件中的描述每个区段的信息的结构体（这里是保存elf32文件的每个区段的名称字符串的）
    read(fd, &shdr, shent_size);    // 为保存elf32文件的所有的区段的名称字符串申请内存空间
    char * string_table = (char *)malloc(shdr.sh_size);
    // 定位到具体存放elf32文件的所有的区段的名称字符串的文件偏移处
    lseek(fd, shdr.sh_offset, SEEK_SET);
    // 从elf32内存文件中读取所有的区段的名称字符串到申请的内存空间中
    read(fd, string_table, shdr.sh_size);    // 重新设置elf32文件的文件偏移为区段信息结构的起始文件偏移处
    lseek(fd, shdr_addr, SEEK_SET);    int i;
    uint32_t out_addr = 0;
    uint32_t out_size = 0;
    uint32_t got_item = 0;
    int32_t got_found = 0;    // 循环遍历elf32文件的区段表（描述每个区段的信息的结构体）
    for (i = 0; i < shnum; i++) {    // 依次读取区段表中每个描述区段的信息的结构体
        read(fd, &shdr, shent_size);        // 判断当前区段描述结构体描述的区段是否是SHT_PROGBITS类型
        if (shdr.sh_type == SHT_PROGBITS) {        // 获取区段的名称字符串在保存所有区段的名称字符串段.shstrtab中的序号
            int name_idx = shdr.sh_name;            // 判断区段的名称是否为".got.plt"或者".got"
            if (strcmp(&(string_table[name_idx]), ".got.plt") == 0
|| strcmp(&(string_table[name_idx]), ".got") == 0) {            // 获取区段".got"或者".got.plt"在内存中实际数据存放地址
                out_addr = base_addr + shdr.sh_addr;
                // 获取区段".got"或者".got.plt"的大小
                out_size = shdr.sh_size;
                LOGD("out_addr = %lx, out_size = %lx\n", out_addr, out_size);                // 遍历区段".got"或者".got.plt"获取保存的全局的函数调用地址
                for (i = 0; i < out_size; i += 4) {                // 获取区段".got"或者".got.plt"中的单个函数的调用地址
                    got_item = *(uint32_t *)(out_addr + i);                    // 判断区段".got"或者".got.plt"中函数调用地址是否是将要被Hook的目标函数地址
                    if (got_item  == old_eglSwapBuffers) {                        LOGD("Found eglSwapBuffers in got\n");
                        // 查找到要被Hook的目标函数的地址
                        got_found = 1;                        // 获取当前内存分页的大小
                        uint32_t page_size = getpagesize();
                        // 获取内存分页的起始地址（需要内存对齐）
                        uint32_t entry_page_start = (out_addr + i) & (~(page_size - 1));
                        LOGD("entry_page_start = %lx, entry_page_start = %lx\n", entry_page_start, page_size);                        // 修改内存属性为可读可写可执行
                        if (mprotect((uint32_t *)entry_page_start, page_size, PROT_READ | PROT_WRITE | PROT_EXEC) == -1) {                        LOGD("mprotect false\n");
                        return -1;
                        }                        // Hook目标函数之前
                        LOGD("%s, old_eglSwapBuffers = %lx, new_eglSwapBuffers = %lx\n", "befor hook function", got_item, new_eglSwapBuffers);                        // Hook函数为我们自己定义的函数
                        //*(uint32_t *)(out_addr + i) = new_eglSwapBuffers;// Hook函数的作用，等价的
                        got_item = new_eglSwapBuffers;                        // Hook目标函数之后
                        LOGD("%s, old_eglSwapBuffers = %lx, new_eglSwapBuffers = %lx\n", "after hook function", got_item, new_eglSwapBuffers);                        // 恢复内存属性为可读可执行
                        if (mprotect((uint32_t *)entry_page_start, page_size, PROT_READ | PROT_EXEC) == -1) {                        LOGD("mprotect false\n");
                        return -1;
                        }                        break;                        // 此时，目标函数的调用地址已经被Hook了
                    } else if (got_item == new_eglSwapBuffers) {                        LOGD("Already hooked\n");
                        break;
                    }
                }                // Hook目标函数成功，跳出循环
                if (got_found)
                    break;
            }
        }
    }    free(string_table);    close(fd);
}

方法二：获取将被Hook的so库文件内存加载后产生的soinfo结构体指针，而该结构体保存着该目标so文件加载到内存中的各种信息，然后也是遍历目标so文件的got表找到将被Hook的目标函数的调用地址进行挂钩Hook替换为我自定义的函数。

// 需要添加的头文件
#include <linux/elf.h>
#include <dlfcn.h>
//#include "linker.h"// Android系统源码的私有头文件// 这种方法虽然是可行的，但是在soinfo结构体的使用时，暂时遇到了问题// Hook目标函数
int hook_api() {// 保存被Hook的目标函数的原始调用地址
    old_eglSwapBuffers = eglSwapBuffers;
    LOGD("Orig eglSwapBuffers = %p\n", old_eglSwapBuffers);// 使用打开动态库的方式得到动态库的soinfo结构
soinfo* si = (soinfo*)dlopen(LIBSF_PATH, RTLD_NOW);
if(si == NULL || si->strtab == NULL || si->plt_rel == NULL) {return -1;
}for (uint32_t i = 0; i < si->plt_rel_count; i++) {// 查找重定位表中eglSwapBuffers所在的项
if(strcmp(si->symtab[ELF32_R_SYM(si->plt_rel[i].r_info)].st_name + si->strtab, "eglSwapBuffers") == 0) {// 计算对应的GOT表项的地址
uint32_t* got = (uint32_t*)(si->base + si->plt_rel[i].r_offset);
if(*(got) != new_eglSwapBuffers) { // 获取当前内存分页的大小
 uint32_t pagesize = sysconf(_SC_PAGE_SIZE);
 // 获取当前内存分页的起始地址
 void* start = (void*)(((uint32_t)got) / pagesize*pagesize); // 修改当前分页的内存属性为可读可写可执行
 if (mprotect(start, pagesize*2, PROT_READ | PROT_WRITE | PROT_EXEC) == -1) { return -1;
 } // 替换目标函数为我们自定义的函数
 *(got) = new_eglSwapBuffers; // 修改当前分页的内存属性为可读可执行
 if (mprotect(start, pagesize*2, PROT_READ | PROT_EXEC) == -1) { return -1;
 }
}return 0;
}
}
}