简易Android ARM&ARM64 GOT Hook (一)

更新

简易Android ARM&ARM64 GOT Hook (二)
基本思路为：基于执行视图，解析内存中的ELF，查找导入符号并替换函数地址

概述

本文以Hook公共库libc.so的getpid函数为例，基于ELF的链接视图(Linking View)，讨论Android ARM&ARM64架构的GOT/PLT Hook。

原理

程序加载后，在执行之前，需要先进行动态链接，并进行重定位。

调用外部函数时，需要先跳转到PLT(Procedure Link Table 程序链接表，位于代码段)，再跳转到GOT(Global Offset Table 全局偏移表，位于数据段)，执行目标函数。

延迟绑定(Lazy Binding)：当外部函数被调用时，才进行地址解析和重定位

由于Android ARM架构不支持延迟绑定，在linker重定位后，GOT已被填充为内存地址 (可使用IDA动态调试验证)

因此，可以通过比对函数地址，修改指定模块的对应GOT表项，实现对外部导入函数的Hook

具体思路

编写so库，在so加载的构造函数（linker会主动调用）中完成以下操作：定位目标模块基址、基于链接视图解析ELF文件，得到GOT表地址及大小、遍历GOT表替换目标函数地址。

注入方式

使用LIEF修改ELF文件，导入该动态库。

编译环境

Android Studio 2020.3.1、Gradle 7.0.1、CMake 3.18.1、NDK 23.0.7599858
ABI: armeabi-v7a,arm64-v8a

PS：其实也可以脱离Android Studio手动编译，见使用CMake交叉编译Android ARM程序

编码

使用Android Studio创建Native C++项目，然后增加两个Android Native Library模块，分别命名为victim和inject

待注入程序

victim.cpp

#include <stdio.h>
#include <unistd.h>

int main()
{
    printf("my pid: %d\n", getpid());
    // getchar();
    return 0;
}

调用getpid获取进程id（IDA动态调试时使用getchar，方便查看内存）

CMakeLists.txt

cmake_minimum_required(VERSION 3.18.1)
project(victim)

add_executable(victim victim.cpp)

编译为可执行文件

注入动态库

// 基于链接视图解析ELF
uintptr_t hackBySection(const char *module_name, const char *target_lib, const char *target_func,
                        uintptr_t replace) {
    LOGE("hackBySection start.\n");
    // 获取目标函数地址
    void *handle = dlopen(target_lib, RTLD_LAZY);
    auto ori = (uintptr_t) dlsym(handle, target_func);
//    LOGE("ori addr: %" SCNxPTR "\n", ori);
    int GOTSize = 0;
    // 获取GOT表地址及大小 (解析Section)
    uintptr_t GOTBase = getGOTBase(GOTSize, module_name);
    // 遍历GOT表，查找符号地址
    uintptr_t addrArray[MAX_ADDRARRAY_SIZE];
    int addrArraySize = getSymAddrInGOT(GOTBase, GOTSize, ori, addrArray);
    // 替换地址
    for (int i = 0; i < addrArraySize; i++) {
        uintptr_t replaceAddr = addrArray[i];
        replaceFunction(replaceAddr, replace, ori);
    }
    return ori;
}

// 原方法的备份
int (*getpidOri)();

// 替换方法
int getpidReplace() {
    LOGE("before hook getpid\n");
    //调用原方法
    int pid = (int) getpidOri();
    LOGE("after hook getpid: %d\n", pid);
    return 233333;
}

//so加载时由linker调用
void __attribute__((constructor)) init() {
    uintptr_t ori = hackBySection(MODULE_PATH, "libc.so", "getpid",
                                  (uintptr_t) getpidReplace);
    getpidOri = (int (*)()) (ori);
}

注意：Android 7.0以上，dlopen只能加载公共库，加载非公共库需要绕过命名空间限制。

子函数

获取模块基址

uintptr_t getModuleBase(const char *modulePath) {
    uintptr_t addr = 0;
    char buff[256] = "\n";

    FILE *fp = fopen("/proc/self/maps", "r");
    while (fgets(buff, sizeof(buff), fp)) {
        if (strstr(buff, "r-xp") && strstr(buff, modulePath) &&
            sscanf(buff, "%lx", &addr) == 1)
            return addr;
    }
//    LOGE("buff: %s", buff);
    LOGE("[%s] moduleBase not found!\n", modulePath);
    fclose(fp);
    return 0;
}

遍历/proc/self/maps文件内容，根据权限及模块路径找到基址。

获取GOT表地址及其大小

篇幅所限，此处仅给出思路（以ARM为例），完整代码见AndroidGotHook

根据模块路径打开ELF文件（本例为/data/local/tmp/victim-patch-arm），解析ELF文件结构（图片为010Editor ELF模板解析结果）:

首先从elf header中得到section header table的起始偏移（e_shoff）、字符串表索引（e_shstrndx）、section header大小(e_shentsize)和总section header个数（e_shnum）

然后计算出字符串表section header的偏移地址（e_shoff + e_shstrndx * e_shentsize），从而得到字符串表的偏移值（s_offset）及大小（s_size）

再遍历section header table，查找sh_type为SHT_PROGBITS 且 section名（通过sh_name查询字符串表）为.got的section header，得到GOT表偏移值（s_offset）及大小（s_size）

最终将GOT表偏移值与模块基址相加，得到GOT表地址。

查找目标函数地址

uintptr_t getSymAddrInGOT(uintptr_t GOTBase, int GOTSize, uintptr_t ori) {
 if (GOTBase == 0) {
        LOGE("getSymAddrInGOT failed! addr [%lX] is wrong\n", GOTBase);
        return 0;
    }

    for (int i = 0; i < GOTSize; ++i) {
        uintptr_t addr = GOTBase + i * 4;
        uintptr_t item = *(uintptr_t *) (addr);
//        LOGE("GOT [%d]: %lX\n", i, item);
        if (item == ori) {
            return addr;
        }
    }

    LOGE("getSymAddrInGOT %lX not found!\n", ori);
    return 0;
}

遍历GOT表，查找目标函数地址。

替换函数地址

void replaceFunction(uintptr_t addr, uintptr_t replace, uintptr_t ori) {
    if (addr == 0) {
        LOGE("replace failed! addr is wrong\n");
        return;
    }
    // 比对函数地址
    uintptr_t item = *(uintptr_t *) (addr);
    if (item == replace) {
        LOGE("function has been replaced!\n");
        return;
    }
    if (item != ori) {
        LOGE("replace failed! unexpected function address %X\n", item);
        return;
    }
    //修改权限、替换地址、清空指令缓存
    LOGE("replace %X to %X\n", ori, replace);
    mprotect((void *) PAGE_START(addr), PAGE_SIZE, PROT_READ | PROT_WRITE);
    *(uintptr_t *) addr = replace;
    __builtin___clear_cache((char *) PAGE_START(addr), (char *) PAGE_END(addr));
}

首先判断函数是否已被替换，然后与期望值相比较，如果一致，则进行以下操作：
将该地址权限设置为可读可写，然后替换函数地址，并清空指令缓存。

适配ARM64

添加宏，将Elf32_w替换为ELFW(w)：

#if defined(__LP64__)
#define ELFW(what) Elf64_ ## what
#else
#define ELFW(what) Elf32_ ## what
#endif

根据架构使用不同的路径：

#if defined(__LP64__)
#define MODULE_PATH "victim-patch-arm64"
#else
#define MODULE_PATH "victim-patch-arm"
#endif

使用LIEF添加依赖

编译完成后，打开victim/build/intermediates/cmake/debug/obj/CPU架构/，使用LIEF注入victim

import lief,sys

abi = "armeabi-v7a"
tail = "-arm"
if(len(sys.argv) > 1 and sys.argv[1] == "arm64-v8a"):
    abi = sys.argv[1]
    tail = "-arm64"

path = "../victim/build/intermediates/cmake/debug/obj/"+abi+"/victim"
elf = lief.parse(path)
elf.add_library("/data/local/tmp/libinject"+tail+".so")
elf.write("victim-patch"+tail)
print("patch success")