adbi学习：so hook实现机制

本篇我们来看看adbi的实现原理，其实里面的知识点前面差不多都有涉及了，没多少新知识。adbi利用hijack程序将libexample.so注入到指定的进程中，并且在进程中加载libexample.so；而libexample.so在加载过程中会执行其.init_array section里的代码，代码中实现函数hook(替换原先的函数为自定义函数)。这样运行hijack就自动实现了函数hook。

　　hijack流程图：

　　　　1.得到pid进程下的mprotect()函数地址

　　　　2.得到piid进程下的dlopen()函数地址

　　　　3.利用ptrace attach pid进程，并得到regs并保存

　　　　4.将sc结构体push进pin 进程的栈空间中；sc包含特定指令、regs、mprotect、dlopen和libexample.so的绝对路径

　　　　5.修改regs值并设置到pin进程，接着PTRACE_DETACH释放pid进程，使之得以继续运行；此时hijack已全部执行完毕

　　　　6.此时pid进程会去执行先前压入栈中的特定指令:

　　这里涉及到2个知识点：

　　　　1.如何得到pid进程下的指定的fun函数地址：

　　　　假设fun在lib.so中，首先得到本进程lib.so的地址addrLib(如何得到加载的so库地址：/proc/pid/maps存储共享库的内存地址),接着得到本进程fun地址addrFun，再得到pin进程的addrPidLib地址，则pid下的fun地址=addrFun-addrLib+addrPidLib；另外一种方式是根据so中dynamic section得到dynsym和dynstr section，利用dynsym->name作为在dynstr的字符得到字符串str1和fun比较，即可得到fun的地址(具体参考之前的文章：elf格式和linker源码分析)。

　　　　2.特定指令究竟是什么，它干了什么事？指令如下：

　　　　特定指令用mprotect改变page读写权限；dlopen加载libexample.so；利用保存的regs恢复attach 前的pid进程状态。至于这些指令的细节看参考资料1，这里就不展开了。需要提及的是arm_pc这个寄存器，在hijack修改了pid进程的pc寄存器，使pid进程在DETACH后直接执行压入栈中的特定指令。但我们知道pc是取指令的地址，arm架构中在执行指令和取指令中还有译码，怎么会在改变pc值后直接去执行pc所执行地址的指令呢？网上是说在修改pc值后，先前的流水线(取指令、译码、执行)丢弃，然后从pc出开始取指令、译码、执行。没查到arm官方资料，望知情人告知！

　　libexample执行流程：

　　　　1.得到要hook函数hookedfun的地址；如何得到函数地址看上面方法1

　　　　2.修改hookedfun函数指令前几个指令为特定指令，使hookedfun函数替换成自定义的函数

　　　　3.在进程执行hookedfun函数时，会去执行自定义函数而不是hookedfun函数;再次修改hookedfun函数指令来卸载函数hook

　　这里的知识点主要在于如何替换hookedfun中涉及到的汇编指令。arm分为arm指令和thum指令，在adbi中这么判断的：

if (addr % 4 == 0) {
    arm指令
}else {
     thumb指令
}

　　　接着arm指令涉及到的替换函数汇编指令：

h->patch = (unsigned int)hook_arm; //自定义函数的地址
h->orig = addr;      //hookedfun函数的地址
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];  //保存hookedfun函数的指令
for (i = 0; i < 3; i++)
    ((int*)h->orig)[i] = h->jump[i];    //修改hookedfun函数的指令，当调用hookedfun时，执行h->jump[0]

　　看上面代码，执行hookedfun时其实是执行LDR pc,[pc,#0]。我们知道pc值为当前执行的指令+8，即pc值为h->jump[2] = 自定义函数的值。ok，这相当于就是jump去执行自定义函数了。下面看thumb汇编指令：

if ((unsigned long int)hook_thumb % 4 == 0)
            log("warning hook is not thumb 0x%lx\n", (unsigned long)hook_thumb)
        h->thumb = 1;
        log("THUMB using 0x%lx\n", (unsigned long)hook_thumb)
        h->patch = (unsigned int)hook_thumb;
        h->orig = addr;
        h->jumpt[1] = 0xb4;
        h->jumpt[0] = 0x60; // push {r5,r6}
        h->jumpt[3] = 0xa5;
        h->jumpt[2] = 0x03; // add r5, pc, #12; 这里r5实质是指向jumpt[18]那为什么会说其执行自定义函数地址junpt[16]呢？
        h->jumpt[5] = 0x68;
        h->jumpt[4] = 0x2d; // ldr r5, [r5]
        h->jumpt[7] = 0xb0;
        h->jumpt[6] = 0x02; // add sp,sp,#8
        h->jumpt[9] = 0xb4;
        h->jumpt[8] = 0x20; // push {r5}
        h->jumpt[11] = 0xb0;
        h->jumpt[10] = 0x81; // sub sp,sp,#4
        h->jumpt[13] = 0xbd;
        h->jumpt[12] = 0x20; // pop {r5, pc}
        h->jumpt[15] = 0x46;
        h->jumpt[14] = 0xaf; // mov pc, r5 ; just to pad to 4 byte boundary
        memcpy(&h->jumpt[16], (unsigned char*)&h->patch, sizeof(unsigned int));　　//存自定义函数地址到jumpt[16]——jumpt[19]
        unsigned int orig = addr - 1; // sub 1 to get real address
        注意这里减1了，thumb的函数被编译后其函数符号地址都会在真正地址+1，这是为了辨别thumb函数还是arm函数，arm函数4字节对齐最低位永远为0
        for (i = 0; i < 20; i++) {
            h->storet[i] = ((unsigned char*)orig)[i];
            //log("%0.2x ", h->storet[i])
        }
        //log("\n")
        for (i = 0; i < 20; i++) {
            ((unsigned char*)orig)[i] = h->jumpt[i];
            //log("%0.2x ", ((unsigned char*)orig)[i])
        }

　　　　利用栈的push和pop将保存自定义函数地址(jump[16])的r5赋值为pc,具体原理看参考资料2。但下面这段话需要注意

这里还有一点需要注意，对于Thumb的“Add Rd, Rp, #expr”指令来说，如果Rp是PC寄存器的话，那么PC寄存器读出的值应该是（当前指令地址+4）& 0xFFFFFFFC，也就是去掉最后两位，算下来正好可以减去2。但这里也有个假设，就是被hook函数的起始地址必须是4字节对齐的，哪怕被hook函数使用Thumb指令集写的。

　　也就说当被hook函数4字节对齐时，add r5, pc, #12这条指令的地址刚好是2字节对齐，那么根据上面这段话刚好可以减2即r5指向的是jumpt[16]而不是jumpt[18]，所以这对hook函数有要求。替换函数的指令讲解完毕，卸载hook自然就清楚了——把原来改变的指令复原就ok了。我们是改变了函数指令达到替换函数的效果。但处理都包含指令cache，若执行的时候从cache中取呢，那我就再刷新下cache；在这里我们用系统调用号的方式来执行：

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"
        );
}

　　r0=begin,r1=end，r7=0xf0002(cacheflush的系统调用号)，直接svc来执行系统调用。

　　hijack和libexample的流程就这样了，但怎么从hijack到libexample啊？

// this file is going to be compiled into a thumb mode binary
// 这里是重点，当进程第一次打开lib操作时，linker会执行此函数
void __attribute__ ((constructor)) my_init(void);

　　还记得hijack执行完毕后，pid进程执行的指令吗；它会去执行dlopen(libexample)，此时回去执行libexample中的.init_array中的指令；而加了"__attribute__ ((constructor))"则my_init就是在.init_array中。知道了吧，在dlopen中执行my_init，而在my_init中实现函数的替换即hook。当然my_init的函数可以不同，但必须有在.init_array中的函数去执行函数替换功能(对于adbi来说是调用hook())。

　　最后我们看看libinject：

　　1.利用ptrace来注入pid进程

　　2.得到pid进程中的函数地址，用的是上面第一种方法：fun地址=addrFun-addrLib+addrPidLib

　　3.libinject不注入so没实现函数挂钩，它实现了hijack的功能，但是它不仅仅是dlopen还在这里执行了自定义函数(实现方式与adbi相同)

　　下篇我们来看看adbi是如何实现dalvik hook

参考资料：

　　1 Android平台下hook框架adbi的研究（上）

　　2 Android平台下hook框架adbi的研究（下）