Android Hook框架adbi的分析(3)---编译和inline Hook实践

本文博客地址：http://blog.csdn.net/qq1084283172/article/details/75200800

一、序言

在前面的博客中，已经分析过了Android Hook框架adbi源码的具体实现，Android Hook框架adbi的实现主要分为两部分，一部分是root权限下的Android跨进程的so注入，一部分是基于Android系统的inline Hook。只要搞清楚了Android系统的跨进程so注入和基于Android系统的inline Hook这两个知识点，理解adbi等Android的Hook框架就不是问题了。Android系统的跨进程so注入和Android的各种Hook非常重要而且它们应用的范围也非常广，Android加固中的反调试对抗、反内存dump对抗，基于ClassLoader的VirtualApp的Hook等等。前面的博客中已经学习了adbi的实现原理，但是仅仅理解原理还不够，实践一下证明adbi的inline Hook是有效的才ok，在接下来的博文将着重记录一下adbi的源码的编译和inlineHook操作实践。

二、Android Hook框架adbi的inline Hook代码的简析

Android Hook框架adbi的inline Hook部分主要代码的简要解析和说明。

• 带有注释分析的Android Hook框架adbi源码下载地址：http://download.csdn.net/detail/qq1084283172/9893002
• util.c文件，只要是用于inline Hook中目标函数所在so库文件的文件路径和内存加载基地址的获取以及解析该so库文件获取被inline Hook目标函数的内存调用地址的实现。虽然代码量有点大，但是作者解析指定so库文件，获取该so库文件的静态库或动态库的符号表即”.symtab”或者”.dynsym”信息和获取目标函数的调用地址的方法还是值得去学习的，与前面提到基于Android的.got表的Hook还是有区别的。下面贴的代码中，有些函数是没有使用的，为了阅读的方便和尊重原作者的编码还是加上了。

/*
 * Elf parsing code taken from: hijack.c (for x86)
 * by Victor Zandy <zandy[at]cs.wisc.edu>
 *
 * Elf parsing code slightly modified for this project
 * (c) Collin Mulliner <collin[at]mulliner.org>
 *
 * License: LGPL v2.1
 *
 * Termios code taken from glibc with slight modifications for this project
 *
 */
#define _XOPEN_SOURCE 500
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <fcntl.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/stat.h>
#include <dlfcn.h>
#include <elf.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <termios.h>
#include <sys/ioctl.h>

#include "hook.h"

/* memory map for libraries */
#define MAX_NAME_LEN 256
#define MEMORY_ONLY  "[memory]"

struct mm {

    // 内存布局的名称
    char name[MAX_NAME_LEN];
    // 内存布局的起始地址和结束地址
    unsigned long start, end;
};

typedef struct symtab *symtab_t;
struct symlist {
    Elf32_Sym *sym;       /* symbols */
    char *str;            /* symbol strings */
    unsigned num;         /* number of symbols */
};

struct symtab {
    struct symlist *st;    /* "static" symbols */
    struct symlist *dyn;   /* dynamic symbols */
};

static void* xmalloc(size_t size)
{
    void *p;
    p = malloc(size);
    if (!p) {
        printf("Out of memory\n");
        exit(1);
    }
    return p;
}

static int my_pread(int fd, void *buf, size_t count, off_t offset)
{
    lseek(fd, offset, SEEK_SET);
    return read(fd, buf, count);
}

static struct symlist* get_syms(int fd, Elf32_Shdr *symh, Elf32_Shdr *strh)
{
    struct symlist *sl, *ret;
    int rv;

    ret = NULL;
    sl = (struct symlist *) xmalloc(sizeof(struct symlist));
    sl->str = NULL;
    sl->sym = NULL;

    /* sanity */
    if (symh->sh_size % sizeof(Elf32_Sym)) {
        //printf("elf_error\n");
        goto out;
    }

    /* symbol table */
    sl->num = symh->sh_size / sizeof(Elf32_Sym);
    sl->sym = (Elf32_Sym *) xmalloc(symh->sh_size);
    rv = my_pread(fd, sl->sym, symh->sh_size, symh->sh_offset);
    if (0 > rv) {
        //perror("read");
        goto out;
    }
    if (rv != symh->sh_size) {
        //printf("elf error\n");
        goto out;
    }

    /* string table */
    sl->str = (char *) xmalloc(strh->sh_size);
    rv = my_pread(fd, sl->str, strh->sh_size, strh->sh_offset);
    if (0 > rv) {
        //perror("read");
        goto out;
    }
    if (rv != strh->sh_size) {
        //printf("elf error");
        goto out;
    }

    ret = sl;
out:
    return ret;
}

static int do_load(int fd, symtab_t symtab)
{
    int rv;
    size_t size;
    Elf32_Ehdr ehdr;
    Elf32_Shdr *shdr = NULL, *p;
    Elf32_Shdr *dynsymh, *dynstrh;
    Elf32_Shdr *symh, *strh;
    char *shstrtab = NULL;
    int i;
    int ret = -1;

    /* elf header */
    rv = read(fd, &ehdr, sizeof(ehdr));
    if (0 > rv) {
        log("read\n")
        goto out;
    }
    if (rv != sizeof(ehdr)) {
        log("elf error 1\n")
        goto out;
    }
    if (strncmp(ELFMAG, ehdr.e_ident, SELFMAG)) { /* sanity */
        log("not an elf\n")
        goto out;
    }
    if (sizeof(Elf32_Shdr) != ehdr.e_shentsize) { /* sanity */
        log("elf error 2\n")
        goto out;
    }

    /* section header table */
    size = ehdr.e_shentsize * ehdr.e_shnum;
    shdr = (Elf32_Shdr *) xmalloc(size);
    rv = my_pread(fd, shdr, size, ehdr.e_shoff);
    if (0 > rv) {
        log("read\n")
        goto out;
    }
    if (rv != size) {
        log("elf error 3 %d %d\n", rv, size)
        goto out;
    }

    /* section header string table */
    size = shdr[ehdr.e_shstrndx].sh_size;
    shstrtab = (char *) xmalloc(size);
    rv = my_pread(fd, shstrtab, size, shdr[ehdr.e_shstrndx].sh_offset);
    if (0 > rv) {
        log("read\n")
        goto out;
    }
    if (rv != size) {
        log("elf error 4 %d %d\n", rv, size)
        goto out;
    }

    /* symbol table headers */
    symh = dynsymh = NULL;
    strh = dynstrh = NULL;
    for (i = 0, p = shdr; i < ehdr.e_shnum; i++, p++)
        if (SHT_SYMTAB == p->sh_type) {
            if (symh) {
                log("too many symbol tables\n")
                goto out;
            }
            symh = p;
        } else if (SHT_DYNSYM == p->sh_type) {
            if (dynsymh) {
                log("too many symbol tables\n")
                goto out;
            }
            dynsymh = p;
        } else if (SHT_STRTAB == p->sh_type
               && !strncmp(shstrtab+p->sh_name, ".strtab", 7)) {
            if (strh) {
                log("too many string tables\n")
                goto out;
            }
            strh = p;
        } else if (SHT_STRTAB == p->sh_type
               && !strncmp(shstrtab+p->sh_name, ".dynstr", 7)) {
            if (dynstrh) {
                log("too many string tables\n")
                goto out;
            }
            dynstrh = p;
        }
    /* sanity checks */
    if ((!dynsymh && dynstrh) || (dynsymh && !dynstrh)) {
        log("bad dynamic symbol table\n")
        goto out;
    }
    if ((!symh && strh) || (symh && !strh)) {
        log("bad symbol table\n")
        goto out;
    }
    if (!dynsymh && !symh) {
        log("no symbol table\n")
        goto out;
    }

    /* symbol tables */
    if (dynsymh)
        symtab->dyn = get_syms(fd, dynsymh, dynstrh);
    if (symh)
        symtab->st = get_syms(fd, symh, strh);
    ret = 0;
out:
    free(shstrtab);
    free(shdr);
    return ret;
}

static symtab_t load_symtab(char *filename)
{
    int fd;
    symtab_t symtab;

    symtab = (symtab_t) xmalloc(sizeof(*symtab));
    memset(symtab, 0, sizeof(*symtab));

    fd = open(filename, O_RDONLY);
    if (0 > fd) {
        log("%s open\n", __func__);
        return NULL;
    }

    if (0 > do_load(fd, symtab)) {

        log("Error ELF parsing %s\n", filename)
        free(symtab);
        symtab = NULL;
    }

    close(fd);

    return symtab;
}

// 获取指定pid进程的内存布局的信息
static int load_memmap(pid_t pid, struct mm *mm, int *nmmp)
{
    char raw[80000]; // increase this if needed for larger "maps"
    char name[MAX_NAME_LEN];
    char *p;
    unsigned long start, end;
    struct mm *m;
    int nmm = 0;
    int fd, rv;
    int i;

    // 格式字符串"/proc/pid/maps"
    sprintf(raw, "/proc/%d/maps", pid);
    // 获取目标pid进程的内存布局信息
    fd = open(raw, O_RDONLY);
    if (0 > fd) {

        //printf("Can't open %s for reading\n", raw);
        return -1;
    }

    // 数组清零
    memset(raw, 0, sizeof(raw));

    // 格式：400c2000-400da000 r-xp 00000000 b3:19 949        /system/lib/libm.so
    p = raw;
    while (1) {

        // 分行读取目标pid进程的内存布局信息
        rv = read(fd, p, sizeof(raw)-(p-raw));
        if (0 > rv) {
            //perror("read");
            return -1;
        }
        // 判断内存布局信息是否读取完了
        if (0 == rv)
            break;

        // 修改指向内存缓冲区raw中的指针偏移p
        p += rv;

        // 判断是否超过内存缓冲区范围
        if (p-raw >= sizeof(raw)) {

            //printf("Too many memory mapping\n");
            return -1;
        }
    }

    // 关闭文件
    close(fd);

    // 分割字符串
    p = strtok(raw, "\n");
    m = mm;
    while (p) {

        // 根据格式解析每一行内存布局信息
        // rv = sscanf函数都将返回成功转换并分配的字段数
        rv = sscanf(p, "%08lx-%08lx %*s %*s %*s %*s %s\n", &start, &end, name);

        // 继续分割字符串
        p = strtok(NULL, "\n");

        // sscanf函数前两个字段start、end匹配成功的情况即没有名称的情况
        if (rv == 2) {

            m = &mm[nmm++];
            // 内存布局起始地址
            m->start = start;
            // 内存布局结束地址
            m->end = end;
            // 设置默认内存布局名称为"[memory]"
            strcpy(m->name, MEMORY_ONLY);

            continue;
        }

        /* search backward for other mapping with same name */
        // 在前面保存的内存布局行信息中查找相同名称的内存布局
        // 例如：
        // 7739a000-7739c000 r-xp 00000000 b3:19 795        /system/lib/libOpenSLES.so
        // 7739c000-7739d000 r--p 00001000 b3:19 795        /system/lib/libOpenSLES.so
        // 7739d000-7739e000 rw-p 00002000 b3:19 795        /system/lib/libOpenSLES.so
        for (i = nmm-1; i >= 0; i--) {

            m = &mm[i];
            if (!strcmp(m->name, name))
                break;
        }

        // 进行相同名称的内存布局起始地址和结束地址的合并
        if (i >= 0) {

            if (start < m->start)
                m->start = start;
            if (end > m->end)
                m->end = end;

        } else {

            // 内存起始地址、内存结束地址、内存布局名称
            m = &mm[nmm++];

            // 内存起始地址
            m->start = start;
            // 内存结束地址
            m->end = end;
            // 内存布局名称
            strcpy(m->name, name);
        }
    }

    // 保存合并后内存布局的个数
    *nmmp = nmm;

    return 0;
}

/* Find libc in MM, storing no more than LEN-1 chars of
   its name in NAME and set START to its starting
   address.  If libc cannot be found return -1 and
   leave NAME and START untouched.  Otherwise return 0
   and null-terminated NAME. */
// libn为要查找的lib库文件的名称字符串，如："libc."
static int find_libname(char *libn, char *name, int len, unsigned long *start, struct mm *mm, int nmm)
{
    int i;
    struct mm *m;
    char *p;

    // 遍历获取到的目标pid进程的内存布局的信息
    for (i = 0, m = mm; i < nmm; i++, m++) {

        // 直接跳过内存布局名称为"[memory]"的情况
        if (!strcmp(m->name, MEMORY_ONLY))
            continue;

        // 从右开始搜索'/'符号，获取内存布局的名称
        // 例如/system/lib/libdl.so，获取名称libdl.so
        p = strrchr(m->name, '/');
        // 跳过不符合要求的情况
        if (!p)
            continue;

        // 判断获取到的lib库名称是否是要查找的目标lib库名称libn
        p++;
        if (strncmp(libn, p, strlen(libn)))
            continue;

        // 获取查找的例如："libc."的长度
        p += strlen(libn);

        /* here comes our crude test -> 'libc.so' or 'libc-[0-9]' */
        // 作者并没有使用
        if (!strncmp("so", p, 2) || 1) // || (p[0] == '-' && isdigit(p[1])))
            break;
    }

    // 判断是否查找到目标lib库libn
    if (i >= nmm)
        /* not found */
        return -1;

    // 获取指定lib库文件的内存的起始地址
    *start = m->start;

    // 保存查找到的目标lib库文件的路径字符串m->name
    strncpy(name, m->name, len);
    // 判断lib库文件的路径字符串是否超过内存数组的长度
    if (strlen(m->name) >= len)
        // 进行截取
        name[len-1] = '\0';

    // 修改指定内存区域内存属性为可读可写可执行
    mprotect((void*)m->start, m->end - m->start, PROT_READ|PROT_WRITE|PROT_EXEC);

    return 0;
}

static int lookup2(struct symlist *sl, unsigned char type,
    char *name, unsigned long *val)
{
    Elf32_Sym *p;
    int len;
    int i;

    len = strlen(name);
    for (i = 0, p = sl->sym; i < sl->num; i++, p++) {
        //log("name: %s %x\n", sl->str+p->st_name, p->st_value)
        if (!strncmp(sl->str+p->st_name, name, len) && *(sl->str+p->st_name+len) == 0
            && ELF32_ST_TYPE(p->st_info) == type) {
            //if (p->st_value != 0) {
            *val = p->st_value;
            return 0;
            //}
        }
    }
    return -1;
}

//struct symtab {
//  struct symlist *st;    /* "static" symbols */
//  struct symlist *dyn;   /* dynamic symbols */
//};

static int lookup_sym(symtab_t s, unsigned char type,
       char *name, unsigned long *val)
{
    // 在动态系统符号表中查找获取目标函数的RVA
    if (s->dyn && !lookup2(s->dyn, type, name, val))
        return 0;

    // 在静态系统符号表中查找获取目标函数的RVA
    if (s->st && !lookup2(s->st, type, name, val))
        return 0;

    return -1;
}

static int lookup_func_sym(symtab_t s, char *name, unsigned long *val)
{
    return lookup_sym(s, STT_FUNC, name, val);
}

// 在指定pid进程的指定lib库中查找将被Hook的目标函数的地址
int find_name(pid_t pid, char *name, char *libn, unsigned long *addr)
{
    struct mm mm[1000];
    unsigned long libcaddr;
    int nmm;
    char libc[1024];
    symtab_t s;

    // 获取指定pid进程的内存布局的信息并保存到mm数组中
    if (0 > load_memmap(pid, mm, &nmm)) {

        log("cannot read memory map\n")
        return -1;
    }

    // 获取需要查找的目标lib库libn的内存基地址libcaddr并获取保存libn的全路径字符串
    if (0 > find_libname(libn, libc, sizeof(libc), &libcaddr, mm, nmm)) {

        log("cannot find lib: %s\n", libn)
        return -1;
    }
    //log("lib: >%s<\n", libc)

    // 打开查找到的lib目标库文件（路径字符串libc）解析该Elf文件
    // 获取该lib库文件的静态库和动态库的符号表信息".symtab"或者".dynsym".
    s = load_symtab(libc);
    if (!s) {

        log("cannot read symbol table\n");
        return -1;
    }

    // 在目标lib库libn的静态库和动态库的符号表查找被Hook的目标函数的RVA即相对地址偏移
    if (0 > lookup_func_sym(s, name, addr)) {

        log("cannot find function: %s\n", name);
        return -1;
    }

    // 获取到目标pid进程中被Hook的目标函数的VA即虚拟地址偏移（有效的函数调用地址）
    *addr += libcaddr;

    return 0;
}

// 获取指定so库文件的内存加载地址
int find_libbase(pid_t pid, char *libn, unsigned long *addr)
{
    struct mm mm[1000];
    unsigned long libcaddr;
    int nmm;
    char libc[1024];
    symtab_t s;

    if (0 > load_memmap(pid, mm, &nmm)) {
        log("cannot read memory map\n")
        return -1;
    }
    if (0 > find_libname(libn, libc, sizeof(libc), &libcaddr, mm, nmm)) {
        log("cannot find lib\n");
        return -1;
    }
    *addr = libcaddr;
    return 0;
}

// --------------------------------------------------------------
#if 0

# define IBAUD0 0

/* Set *T to indicate raw mode. */
void cfmakeraw (struct termios *t)
    {
      t->c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IXON);
      t->c_oflag &= ~OPOST;
      t->c_lflag &= ~(ECHO|ECHONL|ICANON|ISIG|IEXTEN);
      t->c_cflag &= ~(CSIZE|PARENB);
      t->c_cflag |= CS8;
      t->c_cc[VMIN] = 1; /* read returns when one char is available. */
      t->c_cc[VTIME] = 0;
    }
#define __KERNEL_NCCS 19
struct __kernel_termios
    {
        tcflag_t c_iflag; /* input mode flags */
        tcflag_t c_oflag; /* output mode flags */
        tcflag_t c_cflag; /* control mode flags */
        tcflag_t c_lflag; /* local mode flags */
        cc_t c_line; /* line discipline */
    cc_t c_cc[__KERNEL_NCCS]; /* control characters */
    };

/* Set the state of FD to *TERMIOS_P. */
int tcsetattr (int fd, int optional_actions, const struct termios *termios_p)
    {
        struct __kernel_termios k_termios;
        unsigned long int cmd;
        int retval;

        switch (optional_actions)
        {
        case TCSANOW:
            cmd = TCSETS;
            break;
        case TCSADRAIN:
            cmd = TCSETSW;
            break;
        case TCSAFLUSH:
            cmd = TCSETSF;
            break;
        default:
            //__set_errno (EINVAL);
            return -1;
        }

        k_termios.c_iflag = termios_p->c_iflag & ~IBAUD0;
        k_termios.c_oflag = termios_p->c_oflag;
        k_termios.c_cflag = termios_p->c_cflag;
        k_termios.c_lflag = termios_p->c_lflag;
        k_termios.c_line = termios_p->c_line;
    #ifdef _HAVE_C_ISPEED
    k_termios.c_ispeed = termios_p->c_ispeed;
    #endif
    #ifdef _HAVE_C_OSPEED
        k_termios.c_ospeed = termios_p->c_ospeed;
    #endif
        memcpy (&k_termios.c_cc[0], &termios_p->c_cc[0],
            __KERNEL_NCCS * sizeof (cc_t));

        retval = ioctl (fd, cmd, &k_termios);

        if (retval == 0 && cmd == TCSETS)
        {
        /* The Linux kernel has a bug which silently ignore the invalid
           c_cflag on pty. We have to check it here. */
        int save = 0; //errno;
        retval = ioctl (fd, TCGETS, &k_termios);
        if (retval)
        {
            /* We cannot verify if the setting is ok. We don't return
               an error (?). */
            //__set_errno (save);
            retval = 0;
        }
        else if ((termios_p->c_cflag & (PARENB | CREAD))
            != (k_termios.c_cflag & (PARENB | CREAD))
            || ((termios_p->c_cflag & CSIZE)
                && ((termios_p->c_cflag & CSIZE)
                != (k_termios.c_cflag & CSIZE))))
        {
            /* It looks like the Linux kernel silently changed the
               PARENB/CREAD/CSIZE bits in c_cflag. Report it as an
               error. */
            //__set_errno (EINVAL);
            retval = -1;
        }
        }

        return retval;
}

int tcgetattr (int fd, struct termios *termios_p)
    {
        struct __kernel_termios k_termios;
        int retval;

        retval = ioctl (fd, TCGETS, &k_termios);
        if(retval == 0) {
            termios_p->c_iflag = k_termios.c_iflag;
            termios_p->c_oflag = k_termios.c_oflag;
            termios_p->c_cflag = k_termios.c_cflag;
            termios_p->c_lflag = k_termios.c_lflag;
            termios_p->c_line = k_termios.c_line;
    #ifdef _HAVE_C_ISPEED
            termios_p->c_ispeed = k_termios.c_ispeed;
    #endif
    #ifdef _HAVE_C_OSPEED
            termios_p->c_ospeed = k_termios.c_ospeed;
    #endif

            if (sizeof (cc_t) == 1 || _POSIX_VDISABLE == 0
                || (unsigned char) _POSIX_VDISABLE == (unsigned char) -1)
            {
            #if 0
            memset (mempcpy (&termios_p->c_cc[0], &k_termios.c_cc[0],
                    __KERNEL_NCCS * sizeof (cc_t)),
                _POSIX_VDISABLE, (NCCS - __KERNEL_NCCS) * sizeof (cc_t));
            #endif
            memset ( (memcpy (&termios_p->c_cc[0], &k_termios.c_cc[0],
                    __KERNEL_NCCS * sizeof (cc_t)) + (__KERNEL_NCCS * sizeof (cc_t))) ,
                _POSIX_VDISABLE, (NCCS - __KERNEL_NCCS) * sizeof (cc_t));

            } else {
            size_t cnt;

            memcpy (&termios_p->c_cc[0], &k_termios.c_cc[0],
                __KERNEL_NCCS * sizeof (cc_t));

            for (cnt = __KERNEL_NCCS; cnt < NCCS; ++cnt)
                termios_p->c_cc[cnt] = _POSIX_VDISABLE;
            }
        }

        return retval;
    }
#endif

---

• hook.c文件，adbi源码的inline Hook的主要实现部分也是整个adbi框架的精华部分；hook函数实现了20个字节Thumb指令模式和12字节Arm指令模式的inline Hook，hook_precall函数实现Thumb或者Arm模式被inline Hook目标函数指令的恢复即实现函数inline Hook的恢复还原；hook_postcall函数实现Thumb或者Arm指令模式inline Hook目标函数的指令覆盖即实现目标函数的再次inline Hook，hook_cacheflush函数调用Android系统的私有系统调用__ARM_NR_cacheflush实现缓存指令的刷新，现代的很多处理器为了提高指令的运行效率都有指令缓存机制，因此为了inline Hook的生效和被执行，需要进行inline Hook操作之后的指令刷新。

struct hook_t {

    // arm指令模式的12字节Hook
    unsigned int jump[3];   /* 要修改的hook指令（Arm） */
    unsigned int store[3]; /* 被修改的原指令（Arm） */

    // thumb指令模式的20字节Hook
    unsigned char jumpt[20]; /* 要修改的hook指令（Thumb） */
    unsigned char storet[20]; /* 被修改的源指令（Thumb） */

    unsigned int orig; /* 被hook的目标函数地址 */
    unsigned int patch; /* hook的自定义函数地址 */

    unsigned char thumb; /* 表明被hook函数使用的指令集，1为Thumb，0为Arm */
    unsigned char name[128]; /* 被hook的函数名 */

    // 用于存放其他的数据（未使用）
    void *data;
};

 *  Collin's Binary Instrumentation Tool/Framework for Android
 *  Collin Mulliner <collin[at]mulliner.org>
 *  http://www.mulliner.org/android/
 *
 *  (c) 2012,2013
 *
 *  License: LGPL v2.1
 *
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <string.h>
#include <termios.h>
#include <pthread.h>
#include <sys/epoll.h>

#include <jni.h>

#include "util.h"
#include "hook.h"

//void __attribute__ ((constructor)) my_init(void);

// 调用Android系统的私有系统调用__ARM_NR_cacheflush实现缓存指令的刷新
void inline hook_cacheflush(unsigned int begin, unsigned int end)
{
    const int syscall = 0xf0002;

    // 禁止编译器对汇编指令进行指令优化
    __asm __volatile (
        "mov     r0, %0\n"
        "mov     r1, %1\n"
        "mov     r7, %2\n"
        "mov     r2, #0x0\n"
        "svc     0x00000000\n"
        :
        :   "r" (begin), "r" (end), "r" (syscall) // 输入列表
        :   "r0", "r1", "r7"                      // 修改寄存器列表
        );
}

// 未使用
int hook_direct(struct hook_t *h, unsigned int addr, void *hookf)
{
    int i;

    log("addr  = %x\n", addr)
    log("hookf = %lx\n", (unsigned long)hookf)

    if ((addr % 4 == 0 && (unsigned int)hookf % 4 != 0) || (addr % 4 != 0 && (unsigned int)hookf % 4 == 0))
        log("addr 0x%x and hook 0x%lx\n don't match!\n", addr, (unsigned long)hookf)

    //log("ARM\n")
    h->thumb = 0;
    h->patch = (unsigned int)hookf;
    h->orig = addr;
    log("orig = %x\n", h->orig)
    h->jump[0] = 0xe59ff000; // LDR pc, [pc, #0]
    h->jump[1] = h->patch;
    h->jump[2] = h->patch;
    for (i = 0; i < 3; i++)
        h->store[i] = ((int*)h->orig)[i];
    for (i = 0; i < 3; i++)
        ((int*)h->orig)[i] = h->jump[i];

    hook_cacheflush((unsigned int)h->orig, (unsigned int)h->orig+sizeof(h->jumpt));
    return 1;
}

// 对目标pid进程的指定函数进行Hook处理

// h为记录Hook信息的静态变量的指针，pid为被Hook的目标进程的pid，libname为被Hook函数所在的so库文件名称，
// funcname为被Hook的目标函数，hook_arm为被Hook的函数的arm指令模式的替换函数，hook_thumb为被Hook的函数的thumb指令模式的替换函数
int hook(struct hook_t *h, int pid, char *libname, char *funcname, void *hook_arm, void *hook_thumb)
{
    unsigned long int addr;
    int i;

    // 在指定pid进程的指定so库中查找将被Hook的目标函数funcname的调用地址VA即addr
    if (find_name(pid, funcname, libname, &addr) < 0) {

        log("can't find funcname: %s\n", funcname)
        return 0;
    }

    log("hooking:   %s = 0x%lx ", funcname, addr)
    // 保存被Hook的目标函数的名称
    strncpy(h->name, funcname, sizeof(h->name)-1);

    // 通过判断函数跳转地址的最后两位是不是全0,来判断指令的运行模式，
    // 如果后两位全是的0,那就一定是用Arm指令，如果后两位不全为0，那一定是用Thumb指令集

    // Arm指令模式的HooK目标函数的处理
    if (addr % 4 == 0) {

        log("ARM using 0x%lx\n", (unsigned long)hook_arm)

        // arm指令模式
        h->thumb = 0;
        // 自己实现的Hook函数地址
        h->patch = (unsigned int)hook_arm;
        // 被Hook目标函数的原函数地址
        h->orig = addr;

        // 用于Hook目标函数的调用地址为新地址hook_arm
        h->jump[0] = 0xe59ff000; // LDR pc, [pc, #0]
        h->jump[1] = h->patch;
        // pc寄存器读出的值实际上是当前指令地址加8
        // 把jump[2]的值加载进pc寄存器
        h->jump[2] = h->patch;

        // 保存原目标函数的12字节指令，用于函数的恢复
        for (i = 0; i < 3; i++)
            h->store[i] = ((int*)h->orig)[i];

        // 覆盖目标函数的12字节指令为Hook函数指令，实现对目标函数的Hook
        for (i = 0; i < 3; i++)
            ((int*)h->orig)[i] = h->jump[i];

    }

    // Thumb指令模式的Hook目标函数的处理
    else {

        // 对自定义Hook函数的调用地址进行指令模式的判断
        if ((unsigned long int)hook_thumb % 4 == 0)
            log("warning hook is not thumb 0x%lx\n", (unsigned long)hook_thumb)

        // thumb指令模式
        h->thumb = 1;
        log("THUMB using 0x%lx\n", (unsigned long)hook_thumb)

        // 保存用于Hook目标函数的调用地址为新地址hook_thumb
        h->patch = (unsigned int)hook_thumb;
        // 保存被Hook目标函数的原函数地址
        h->orig = addr; 

        // 保存寄存器r5,r6的值用于恢复环境
        h->jumpt[1] = 0xb4;
        h->jumpt[0] = 0x60; // push {r5,r6}
//      将PC寄存器的值加上12赋值给r5。加上的立即数必须是4的倍数，而加上8又不够，只能加12。
//      这样的话，读出的PC寄存器的值是当前指令地址加上4，再加上12的话，那么可以算出来r5寄存器的值实际指向的是jumpt[18]，而不是jumpt[16]了。
//      这里还有一点需要注意，对于Thumb的“Add Rd, Rp, #expr”指令来说，如果Rp是PC寄存器的话，那么PC寄存器读出的值应该是（当前指令地址+4）& 0xFFFFFFFC，
//      也就是去掉最后两位，算下来正好可以减去2。但这里也有个假设，就是被hook函数的起始地址必须是4字节对齐的，哪怕被hook函数使用Thumb指令集写的。
        h->jumpt[3] = 0xa5;
        h->jumpt[2] = 0x03; // add r5, pc, #12 (比较难理解)
        // 将保存在jumpt[16]处的hook函数地址加载到r5寄存器中
        h->jumpt[5] = 0x68;
        h->jumpt[4] = 0x2d; // ldr r5, [r5]
        // 降低栈顶，恢复到初始的状态，释放内存空间
        h->jumpt[7] = 0xb0;
        h->jumpt[6] = 0x02; // add sp,sp,#8
        // 用保存的自定义hook函数地址覆盖原来压入的r6的值，r5的值暂时不受影响
        h->jumpt[9] = 0xb4;
        h->jumpt[8] = 0x20; // push {r5}
        // 抬高栈顶，r5的值被保护
        h->jumpt[11] = 0xb0;
        h->jumpt[10] = 0x81; // sub sp,sp,#4
        // 进行出栈操作，pc寄存器得到自定义的Hook函数的地址，r5的值还是原来的
        h->jumpt[13] = 0xbd;
        h->jumpt[12] = 0x20; // pop {r5, pc}
        // 仅仅用于4字节对齐的填充，只是因为前面的add指令只能加4的倍数
        h->jumpt[15] = 0x46;
        h->jumpt[14] = 0xaf; // mov pc, r5 ; just to pad to 4 byte boundary

        // 用于存放自定义Hook函数的调用地址（4字节）
        memcpy(&h->jumpt[16], (unsigned char*)&h->patch, sizeof(unsigned int));

        // sub 1 to get real address
        unsigned int orig = addr - 1;
        // 保存被Hook目标函数的原始thumb指令
        for (i = 0; i < 20; i++) {

            h->storet[i] = ((unsigned char*)orig)[i];
            //log("%0.2x ", h->storet[i])
        }
        //log("\n")

        // 覆盖被Hook目标函数的指令为自定义的Hook函数指令
        for (i = 0; i < 20; i++) {

            ((unsigned char*)orig)[i] = h->jumpt[i];
            //log("%0.2x ", ((unsigned char*)orig)[i])
        }

    }

    // 刷新指令缓存（被修改的这段字节数的指令）
    hook_cacheflush((unsigned int)h->orig, (unsigned int)h->orig+sizeof(h->jumpt));

    return 1;
}

// 进行thumb或者arm模式被Hook目标函数指令的恢复即实现函数Hook的恢复
void hook_precall(struct hook_t *h)
{
    int i;

    // thumb指令模式被Hook目标函数的指令的恢复
    if (h->thumb) {

        // 获取被Hook目标函数的真实调用地址
        unsigned int orig = h->orig - 1;
        // 进行thumb指令模式被Hook指令的恢复
        for (i = 0; i < 20; i++) {

            ((unsigned char*)orig)[i] = h->storet[i];
        }

    } else {

        // 进行arm指令模式被Hook指令的恢复
        for (i = 0; i < 3; i++){

            ((int*)h->orig)[i] = h->store[i];
        }
    }   

    // 刷新指令缓存
    hook_cacheflush((unsigned int)h->orig, (unsigned int)h->orig+sizeof(h->jumpt));
}

// 进行thumb或者arm指令模式Hook目标函数的指令覆盖即实现函数的Hook
void hook_postcall(struct hook_t *h)
{
    int i;

    if (h->thumb) {

        // 获取thumb指令模式函数真实的调用地址
        unsigned int orig = h->orig - 1;
        // 进行thumb指令模式Hook目标函数指令的覆盖
        for (i = 0; i < 20; i++)
            ((unsigned char*)orig)[i] = h->jumpt[i];

    } else {

        // 进行arm指令模式Hook目标函数指令的覆盖
        for (i = 0; i < 3; i++)
            ((int*)h->orig)[i] = h->jump[i];
    }

    // 刷新指令缓存
    hook_cacheflush((unsigned int)h->orig, (unsigned int)h->orig+sizeof(h->jumpt));
}

// 取消函数的Hook
void unhook(struct hook_t *h)
{
    log("unhooking %s = %x  hook = %x ", h->name, h->orig, h->patch)
    // 进行被Hook目标函数的恢复
    hook_precall(h);
}

/*
 *  workaround for blocked socket API when process does not have network
 *  permissions
 *
 *  this code simply opens a pseudo terminal (pty) which gives us a
 *  file descriptor. the pty then can be used by another process to
 *  communicate with our instrumentation code. an example program
 *  would be a simple socket-to-pty-bridge
 *
 *  this function just creates and configures the pty
 *  communication (read, write, poll/select) has to be implemented by hand
 *
 */
int start_coms(int *coms, char *ptsn)
{
    if (!coms) {
        log("coms == null!\n")
        return 0;
    }

    *coms = open("/dev/ptmx", O_RDWR|O_NOCTTY);
    if (*coms <= 0) {
        log("posix_openpt failed\n")
        return 0;
    }
    //else
    //  log("pty created\n")
    if (unlockpt(*coms) < 0) {
        log("unlockpt failed\n")
        return 0;
    }

    if (ptsn)
        strcpy(ptsn, (char*)ptsname(*coms));

    struct termios  ios;
    tcgetattr(*coms, &ios);
    ios.c_lflag = 0;  // disable ECHO, ICANON, etc...
    tcsetattr(*coms, TCSANOW, &ios);

    return 1;
}

---

• epoll.c文件，adbi框架的inline Hook的实践，实现了对Android系统的libc.so库文件的”epoll_wait”函数的inline Hook，my_init函数在so库文件被加载注入到目标进程中的时候会执行，用以实现对目标进程目标函数的inline Hook对所有进程都起作用，my_epoll_wait函数为Thumb指令模式下”epoll_wait”函数被inline Hook的自定义替换函数。

/*
 *  Collin's Binary Instrumentation Tool/Framework for Android
 *  Collin Mulliner <collin[at]mulliner.org>
 *  http://www.mulliner.org/android/
 *
 *  (c) 2012,2013
 *
 *  License: LGPL v2.1
 *
 */
#define _GNU_SOURCE
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <dlfcn.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/select.h>
#include <string.h>
#include <termios.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <jni.h>
#include <stdlib.h>

#include "../base/hook.h"
#include "../base/base.h"

#undef log

// 打印日志消息到"/data/local/tmp/adbi_example.log"文件的宏
#define log(...) \
        {FILE *fp = fopen("/data/local/tmp/adbi_example.log", "a+"); if (fp) {\
        fprintf(fp, __VA_ARGS__);\
        fclose(fp);}}

// 在adbi\instruments\example\epoll.c中定义.init段的构造函数
// this file is going to be compiled into a thumb mode binary
// 当so库文件被加载的时候，会执行的构造函数
void __attribute__ ((constructor)) my_init(void);

// 静态数据
static struct hook_t eph;

// 用于设置被Hook目标函数有效的Hook次数
static int counter;

// 全局导出arm指令模式的自定义Hook函数
extern int my_epoll_wait_arm(int epfd, struct epoll_event *events, int maxevents, int timeout);

/*
 *  log function to pass to the hooking library to implement central loggin
 *
 *  see: set_logfunction() in base.h
 */
// 将日志消息打印到"/data/local/tmp/adbi_example.log"文件中
static void my_log(char *msg)
{
    // 调用打印日志消息到"/data/local/tmp/adbi_example.log"文件的宏
    log("%s", msg)
}

// 自定义Hook函数（默认编译成thumb指令模式）
int my_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
{
    // 声明epoll_wait函数的函数指针
    int (*orig_epoll_wait)(int epfd, struct epoll_event *events, int maxevents, int timeout);

    // 获取被Hook目标函数的原始函数调用地址
    orig_epoll_wait = (void*)eph.orig;
    // 恢复被Hook的epoll_wait函数
    hook_precall(&eph);

    // 调用被Hook目标函数的原始函数epoll_wait
    int res = orig_epoll_wait(epfd, events, maxevents, timeout);

    // 再次恢复函数的Hook
    if (counter) {

        // 再次恢复目标函数的Hook
        hook_postcall(&eph);
        log("epoll_wait() called\n");

        counter--;
        // 当counter=0，说明执行一次函数Hook之后，Hook即将被移除
        if (!counter)
            log("removing hook for epoll_wait()\n");
    }

    return res;
}

// 在lib库文件被加载注入的时候会执行，用以实现对目标pid进程目标函数的inline Hook，对所有进程都起作用
void my_init(void)
{
    // 设置被Hook目标函数的Hook次数
    counter = 3;

    log("%s started\n", __FILE__)

    // 设置消息日志打印到的日志文件
    set_logfunction(my_log);

    // 实现对目标pid进程的指定库文件的目标函数进行Hook处理。
    // arm指令模式的Hook函数--my_epoll_wait_arm
    // thumb指令模式的Hook函数--my_epoll_wait
    // eph存放Hook函数的Hook信息结构体
    hook(&eph, getpid(), "libc.", "epoll_wait", my_epoll_wait_arm, my_epoll_wait);
}

---

• epoll_arm.c文件，主要用于Arm指令模式下被inline Hook的”epoll_wait”函数的自定义替换函数，因为ndk默认编译方式的函数为Thumb指令模式的函数。

/*
 *  Collin's Binary Instrumentation Tool/Framework for Android
 *  Collin Mulliner <collin[at]mulliner.org>
 *  http://www.mulliner.org/android/
 *
 *  (c) 2012,2013
 *
 *  License: LGPL v2.1
 *
 */

#include <sys/types.h>
#include <sys/epoll.h>

extern int my_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

// arm指令模式的Hook函数的执行
int my_epoll_wait_arm(int epfd, struct epoll_event *events, int maxevents, int timeout)
{
    return my_epoll_wait(epfd, events, maxevents, timeout);
}

三、adbi源码的完整编译

前面的部分一直在分析adbi源码的实现，下面就来学习一下adbi源码的编译和运行。有关adbi源码的编译和运行可以参考adbi源码官方提供的使用说明，参考地址：https://github.com/crmulliner/adbi/blob/master/README.md。

1.root权限下，Android跨进程so注入工具 hijack的编译。

• Android跨进程so注入工具 hijack的编译配置文件Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# 编译生成的模块的名称
LOCAL_MODULE    := hijack
LOCAL_SRC_FILES := ../hijack.c 

# 将源码编译成arm指令集模式
LOCAL_ARM_MODE := arm
# 在编译生成的可执行程序中包含标准调试信息
LOCAL_CFLAGS := -g

# 将源码编译成ELF可执行文件
include $(BUILD_EXECUTABLE)

• Android跨进程so注入工具 hijack的编译步骤

cd hijack
cd jni
ndk-build

Android跨进程so注入工具 hijack编译成功的示意图：

2.adbi的inline Hook实现的基础工具instruments\base的编译和生成libbase.a静态库文件。

• adbi的inline Hook工具instruments\base的编译配置文件Android.mk和Application.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

# 编译生成的模块的名称
LOCAL_MODULE    := base
LOCAL_SRC_FILES := ../util.c ../hook.c ../base.c

# 将源码编译成arm指令集模式
LOCAL_ARM_MODE := arm

# 编译生成静态库文件
include $(BUILD_STATIC_LIBRARY)

# Application.mk
APP_MODULES := base

• adbi的inline Hook工具instruments\base的编译步骤

cd instruments
cd base
cd jni
ndk-build

adbi的inline Hook工具instruments\base编译成功的示意图：

3.adbi的inline Hook实践，实现Hook掉Android系统的libc.so库文件的epoll_wait函数用以被注入到目标进程中加载的so库文件libexample.so的编译。

• 被注入到目标进程中实现inline Hook掉android系统的epoll_wait函数的动态库文件libexample.so的编译配置文件Android.mk

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := base
LOCAL_SRC_FILES := ../../base/obj/local/armeabi/libbase.a
# 导出当前模块的头文件所在路径,供其他模块使用
LOCAL_EXPORT_C_INCLUDES := ../../base

# 生成预编译静态库文件
include $(PREBUILT_STATIC_LIBRARY)

# 清除宏变量的信息
include $(CLEAR_VARS)
#由原来的libexample生成模块名称改为example
LOCAL_MODULE    := example
# 编译生成arm、thumb模式的函数调用
LOCAL_SRC_FILES := ../epoll.c  ../epoll_arm.c.arm
# 编译生成的模块带有标准的调试信息
LOCAL_CFLAGS := -g
# 需要依赖加载的动态库libdl.so
LOCAL_SHARED_LIBRARIES := dl
# 需要依赖加载的静态库libbase.a
LOCAL_STATIC_LIBRARIES := base

# 编译生成动态库文件
include $(BUILD_SHARED_LIBRARY)

• 被注入到目标进程中实现inline Hook掉android系统的epoll_wait函数的动态库文件libexample.so的编译步骤

cd example
cd jni
ndk-build

被注入到目标进程中实现inline Hook掉android系统的epoll_wait函数的动态库文件libexample.so编译成功的示意图：

四、adbi的inline Hook的运行

有关adbi源码的编译和执行可以参考官方的文档：https://github.com/crmulliner/adbi/blob/master/README.md。

在上面的步骤中已经完成了对adbi源码的完整编译，再结合adbi官方文档描述的运行参考，下面给出adbi运行的完整步骤：

$ adb push ./hijack /data/local/tmp/
$ adb shell chmod 0777 /data/local/tmp/hijack

$ adb push ./libexample.so /data/local/tmp/
$ adb shell chmod 0777 /data/local/tmp/libexample.so

$ pause

$ adb shell
$ su
$ cd /data/local/tmp

# log日志打印的重定位
$ > /data/local/tmp/adbi_example.log

# GET PID from com.android.phone(用com.android.phone作为目标进程进行so注入)
$ ps | grep com.android.phone

# inject so and inline Hook
$ ./hijack -d -p PID -l /data/local/tmp/libexample.so

# 查看自定义打印的log日志
$ cat ./adbi_example.log

# 查看被so注入的目标进程的内存布局
$ cat /pro/pid/maps

在LG G3手机（Android 4.4.2系统）上进行adbi的root权限下的跨进程so库注入和inline Hook操作，选取LG G3手机设备上的 com.android.phone 作为目标进程进行so库文件的注入和inline Hook，具体的结果如下图所示：

从adbi工具在LG G3上的运行结果来分析，hijack注入工具注入libexample.so动态库文件到目标进程com.android.phone中是成功的，但是inline Hook代码执行的log日志却没有打印出来，测试了几次也还是没有打印出来，后来换了一种打印log日志的方法看到了hook函数被执行的log日志了，有时间再研究一下log日志打印的问题。