Android(Linux)下的ARM注入，Android下的.

关于这个名字感觉很奇怪感觉是两个题目，其实从原理来说是基本上一个原理，稍加改动就作用于两个不同的场景，一个是在Android(Linux)下的ARM汇编注入系统调用，另一个是在Android下面注入调用另一个.so库，我们先开启上半篇《Android(Linux)下的ARM注入》

好的让我开始Android下的Hook大家一定都不陌生了，经常见的如下几种

• 修改虚拟机NativeFun的指针调用的方式
• 修改虚拟机的ArtMethod 函数结构体整体替换为想要的ArtMethod结构体
• AOP + Reflection 的方式进行调用
• 利用Android下的类加载器加载目标的Dex达到Hook目的
• 利用ARM汇编底层修改替换寄存器来实现Hook

前两个在热修复HotFix场景中非常常见，例如AndFix框架，这个框架已经开源很久了大家可以去下载看看源码，我有一篇文章简单介绍了AndFix的原理，大家有兴趣的可以去观看 《AndFix各个版本的改动以及原理》

---

第三个 AOP + Reflection 广泛运用于一些插件化框架里面例如 DroidPlugin 框架，老实说这个框架里面包含了很多的细节，最难的是在于找到合适的注入点，但是想找到合适的注入点就必须对于Android各个层面的调用都非常清楚才行， 但是话说回来最后实现的主要手法还是运用了AOP + Reflection，网络上有一个高手叫 weishu 专门写了几篇分析这个框架的文章可以给大家分享一下 http://weishu.me/

---

第四个用于一些Dex里面的方法替换，常见的例如QQZone团队很早就在网络上开源的MutiDex来进行两个Dex里面的方法替换

---

今天我们要说的是第五个也就是利用ARM汇编底层修改替换寄存器来实现Hook。

其实关于这个网络上已经有了一些文章以及资料来讲解了，而且这次这个课题是我以前在公司分享公开课的一次分享的课题，最近是又拿出了这部分来自己进行提炼以及升华来做一次总结。这次我争取从一个通俗易懂的角度来讲解下这两部分，顺便讲解一下别文章没有的东西。

在这之前我先把我调试的Demo传给大家供大家调试，这个Demo来源于网络上面，我进行一点改进以及注释，另外我已经运行过了在以前的小米手机以及模拟器都能够运行成功。
Demo 下载

项目文件夹结构如下：

image.png

jni文件夹里面是主要的代码，libs是编译出的文件，detail文件夹是我以前做的简单的原理总结。

首先这种Hook的分如下几个步骤：

1.先找到被注入进程的pid
2.附加当前进程到被注入进程
3.保存原寄存器的值
4.找到需要Hook的系统调用函数
5.修改目标进程寄存器
6.执行目标函数调用
7.恢复寄存器的值
8.分离附加进程

我们先可以运行看看效果：

image.png

hello_sleep.c 是我们想要注入的目标进程代码如下

#include<stdio.h>
#include<stdlib.h>

int count = 0;

void print()
{
    printf("hello,%d\n",count);
    sleep(1);
}

int main(int argc, char const *argv[])
{
    while(1){
        print();
        count++;
    }
    return 0;
}

很简单隔一秒打印一句话，我们要做的目的是注入sleep 系统调用把里面的参数给他改了，改成比如10秒一执行，inject_sleep.c 是要运行Hook效果的进程
其完整代码如下

#include <stdio.h>    
#include <stdlib.h>    
#include <asm/user.h>    
#include <asm/ptrace.h>    
#include <sys/ptrace.h>    
#include <sys/wait.h>    
#include <sys/mman.h>    
#include <dlfcn.h>    
#include <dirent.h>    
#include <unistd.h>    
#include <string.h>
#include <elf.h>    
#include <android/log.h>    

#if defined(__i386__)
#define pt_regs         user_regs_struct    
#endif

#define ENABLE_DEBUG 1

#if ENABLE_DEBUG
#define  LOG_TAG "INJECT"
#define  LOGD(fmt, args...)  __android_log_print(ANDROID_LOG_DEBUG,LOG_TAG, fmt, ##args)
#define DEBUG_PRINT(format,args...) \    
    LOGD(format, ##args)
#else
#define DEBUG_PRINT(format,args...)    
#endif

#define CPSR_T_MASK     ( 1u << 5 )

const char *libc_path = "/system/lib/libc.so";
const char *linker_path = "/system/bin/linker";

int ptrace_readdata(pid_t pid,  uint8_t *src, uint8_t *buf, size_t size)
{
    uint32_t i, j, remain;
    uint8_t *laddr;

    union u {
        long val;
        char chars[sizeof(long)];
    } d;

    j = size / 4;
    remain = size % 4;

    laddr = buf;

    for (i = 0; i < j; i ++) {
        d.val = ptrace(PTRACE_PEEKTEXT, pid, src, 0);
        memcpy(laddr, d.chars, 4);
        src += 4;
        laddr += 4;
    }

    if (remain > 0) {
        d.val = ptrace(PTRACE_PEEKTEXT, pid, src, 0);
        memcpy(laddr, d.chars, remain);
    }

    return 0;
}

int ptrace_writedata(pid_t pid, uint8_t *dest, uint8_t *data, size_t size)
{
    uint32_t i, j, remain;
    uint8_t *laddr;

    union u {
        long val;
        char chars[sizeof(long)];
    } d;

    j = size / 4;                                   //分两部分,一部分4的整数倍来写,一部分4的余数来写
    remain = size % 4;

    laddr = data;

    for (i = 0; i < j; i ++) {                      //向目标进程中写入4字节的整数倍的数据
        memcpy(d.chars, laddr, 4);
        ptrace(PTRACE_POKETEXT, pid, dest, d.val);

        dest  += 4;
        laddr += 4;
    }

    if (remain > 0) {
        d.val = ptrace(PTRACE_PEEKTEXT, pid, dest, 0);      //感觉没什么用
        for (i = 0; i < remain; i ++) {
            d.chars[i] = *laddr ++;
        }

        ptrace(PTRACE_POKETEXT, pid, dest, d.val);      //向目标进程中写入剩余字节的的数据
    }

    return 0;
}

#if defined(__arm__)
int ptrace_call(pid_t pid, uint32_t addr, long *params, uint32_t num_params, struct pt_regs* regs)    
{    
    uint32_t i;    
    for (i = 0; i < num_params && i < 4; i ++) {    
        regs->uregs[i] = params[i];    
    }    
    
    // 前4个参数通过r0-r3 寄存器传递
    // push remained params onto stack    
    // 后面的参数通过sp 寄存器传递
    if (i < num_params) {    
        regs->ARM_sp -= (num_params - i) * sizeof(long) ;    
        ptrace_writedata(pid, (void *)regs->ARM_sp, (uint8_t *)&params[i], (num_params - i) * sizeof(long));    
    }    
    
    regs->ARM_pc = addr;                    //pc寄存器赋值到函数基地址
    if (regs->ARM_pc & 1) {    
        /* thumb */    
        regs->ARM_pc &= (~1u);    
        regs->ARM_cpsr |= CPSR_T_MASK;    
    } else {    
        /* arm */    
        regs->ARM_cpsr &= ~CPSR_T_MASK;    
    }    
    
    regs->ARM_lr = 0;                           ///设置附加进程的LR寄存器的值为0，触发地址0异常回到当前进程中
    
    if (ptrace_setregs(pid, regs) == -1         //设计寄存器并且调用函数
            || ptrace_continue(pid) == -1) {    
        printf("error\n");    
        return -1;    
    }    
    
    int stat = 0;  
    waitpid(pid, &stat, WUNTRACED);             //等待附加进程的调用结束
    while (stat != 0xb7f) {  
        if (ptrace_continue(pid) == -1) {  
            printf("error\n");  
            return -1;  
        }  
        waitpid(pid, &stat, WUNTRACED);  
    }  
    
    return 0;    
}

#elif defined(__i386__)
long ptrace_call(pid_t pid, uint32_t addr, long *params, uint32_t num_params, struct user_regs_struct * regs)    
{    
    regs->esp -= (num_params) * sizeof(long) ;    
    ptrace_writedata(pid, (void *)regs->esp, (uint8_t *)params, (num_params) * sizeof(long));    
    
    long tmp_addr = 0x00;    
    regs->esp -= sizeof(long);    
    ptrace_writedata(pid, regs->esp, (char *)&tmp_addr, sizeof(tmp_addr));     
    
    regs->eip = addr;    
    
    if (ptrace_setregs(pid, regs) == -1     
            || ptrace_continue( pid) == -1) {    
        printf("error\n");    
        return -1;    
    }    
    
    int stat = 0;  
    waitpid(pid, &stat, WUNTRACED);  
    while (stat != 0xb7f) {  
        if (ptrace_continue(pid) == -1) {  
            printf("error\n");  
            return -1;  
        }  
        waitpid(pid, &stat, WUNTRACED);  
    }  
    
    return 0;    
}
#else
#error "Not supported"    
#endif

int ptrace_getregs(pid_t pid, struct pt_regs * regs)
{
    if (ptrace(PTRACE_GETREGS, pid, NULL, regs) < 0) {
        perror("ptrace_getregs: Can not get register values");
        return -1;
    }

    return 0;
}

int ptrace_setregs(pid_t pid, struct pt_regs * regs)
{
    if (ptrace(PTRACE_SETREGS, pid, NULL, regs) < 0) {
        perror("ptrace_setregs: Can not set register values");
        return -1;
    }

    return 0;
}

int ptrace_continue(pid_t pid)
{
    if (ptrace(PTRACE_CONT, pid, NULL, 0) < 0) {
        perror("ptrace_cont");
        return -1;
    }

    return 0;
}

int ptrace_attach(pid_t pid)
{
    if (ptrace(PTRACE_ATTACH, pid, NULL, 0) < 0) {
        perror("ptrace_attach");
        return -1;
    }

    int status = 0;
    waitpid(pid, &status , WUNTRACED);

    return 0;
}

int ptrace_detach(pid_t pid)
{
    if (ptrace(PTRACE_DETACH, pid, NULL, 0) < 0) {
        perror("ptrace_detach");
        return -1;
    }

    return 0;
}

void* get_module_base(pid_t pid, const char* module_name)
{
    FILE *fp;
    long addr = 0;
    char *pch;
    char filename[32];
    char line[1024];

    if (pid < 0) {
        /* self process */
        snprintf(filename, sizeof(filename), "/proc/self/maps", pid);
    } else {
        snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
    }

    fp = fopen(filename, "r");

    if (fp != NULL) {
        while (fgets(line, sizeof(line), fp)) {
            if (strstr(line, module_name)) {
                pch = strtok( line, "-" );
                addr = strtoul( pch, NULL, 16 );

                if (addr == 0x8000)
                    addr = 0;

                break;
            }
        }

        fclose(fp) ;
    }

    return (void *)addr;
}

void* get_remote_addr(pid_t target_pid, const char* module_name, void* local_addr)
{
    void* local_handle, *remote_handle;

    local_handle = get_module_base(-1, module_name);            //获取本进程指定函数的模块的基地址
    remote_handle = get_module_base(target_pid, module_name);   //获取被附加进程指定函数的模块的基地址

    DEBUG_PRINT("[+] get_remote_addr: local[%x], remote[%x]\n", local_handle, remote_handle);

    //根据便偏移量计算出被附加进程指定函数的基地址
    void * ret_addr = (void *)((uint32_t)local_addr + (uint32_t)remote_handle - (uint32_t)local_handle);

#if defined(__i386__)
    if (!strcmp(module_name, libc_path)) {
        ret_addr += 2;    
    }
#endif
    return ret_addr;
}

int find_pid_of(const char *process_name)
{
    int id;
    pid_t pid = -1;
    DIR* dir;
    FILE *fp;
    char filename[32];
    char cmdline[256];

    struct dirent * entry;

    if (process_name == NULL)
        return -1;

    dir = opendir("/proc");
    if (dir == NULL)
        return -1;

    while((entry = readdir(dir)) != NULL) {
        id = atoi(entry->d_name);
        if (id != 0) {
            sprintf(filename, "/proc/%d/cmdline", id);
            fp = fopen(filename, "r");
            if (fp) {
                fgets(cmdline, sizeof(cmdline), fp);
                fclose(fp);

                if (strcmp(process_name, cmdline) == 0) {
                    /* process found */
                    pid = id;
                    break;
                }
            }
        }
    }

    closedir(dir);
    return pid;
}

long ptrace_retval(struct pt_regs * regs)
{
#if defined(__arm__)
    return regs->ARM_r0;
#elif defined(__i386__)
    return regs->eax;
#else
#error "Not supported"    
#endif
}

long ptrace_ip(struct pt_regs * regs)
{
#if defined(__arm__)
    return regs->ARM_pc;
#elif defined(__i386__)
    return regs->eip;
#else
#error "Not supported"    
#endif
}

int ptrace_call_wrapper(pid_t target_pid, const char * func_name, void * func_addr, long * parameters, int param_num, struct pt_regs * regs)
{
    DEBUG_PRINT("[+] Calling %s in target process.\n", func_name);
    if (ptrace_call(target_pid, (uint32_t)func_addr, parameters, param_num, regs) == -1)
        return -1;

    if (ptrace_getregs(target_pid, regs) == -1)
        return -1;
    DEBUG_PRINT("[+] Target process returned from %s, return value=%x, pc=%x \n",
                func_name, ptrace_retval(regs), ptrace_ip(regs));
    return 0;
}

int inject_remote_process(pid_t target_pid, const char *library_path, const char *function_name, const char *param, size_t param_size)
{
    int ret = -1;
    void *mmap_addr, *dlopen_addr, *dlsym_addr, *dlclose_addr, *dlerror_addr;
    void *local_handle, *remote_handle, *dlhandle;
    uint8_t *map_base = 0;
    uint8_t *dlopen_param1_ptr, *dlsym_param2_ptr, *saved_r0_pc_ptr, *inject_param_ptr, *remote_code_ptr, *local_code_ptr;

    struct pt_regs regs, original_regs;
    extern uint32_t _dlopen_addr_s, _dlopen_param1_s, _dlopen_param2_s, _dlsym_addr_s, \
        _dlsym_param2_s, _dlclose_addr_s, _inject_start_s, _inject_end_s, _inject_function_param_s, \    
        _saved_cpsr_s, _saved_r0_pc_s;

    uint32_t code_length;
    long parameters[10];

    DEBUG_PRINT("[+] Injecting process: %d\n", target_pid);

    if (ptrace_attach(target_pid) == -1)        //开始进程的附加
        goto exit;

    if (ptrace_getregs(target_pid, &regs) == -1)    //读取被附加进程的寄存器
        goto exit;

    /* save original registers */
    memcpy(&original_regs, &regs, sizeof(regs));    //保存附加进程所有的寄存器r0-r15,cpsr

    mmap_addr = get_remote_addr(target_pid, libc_path, (void *)mmap);   //获得被附加进程mmap函数的基地址
    DEBUG_PRINT("[+] Remote mmap address: %x\n", mmap_addr);

    /* call mmap */                                 //构造mmap函数的参数
    parameters[0] = 0;  // addr
    parameters[1] = 0x4000; // size
    parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC;  // prot
    parameters[3] =  MAP_ANONYMOUS | MAP_PRIVATE; // flags
    parameters[4] = 0; //fd
    parameters[5] = 0; //offset

    if (ptrace_call_wrapper(target_pid, "mmap", mmap_addr, parameters, 6, &regs) == -1) //开始调用被附加进程的mmap函数
        goto exit;

    map_base = ptrace_retval(&regs);        //获取函数调用的返回值

    dlopen_addr = get_remote_addr( target_pid, linker_path, (void *)dlopen );           //获得附加进程dlopen函数的基地址
    dlsym_addr = get_remote_addr( target_pid, linker_path, (void *)dlsym );
    dlclose_addr = get_remote_addr( target_pid, linker_path, (void *)dlclose );
    dlerror_addr = get_remote_addr( target_pid, linker_path, (void *)dlerror );

    DEBUG_PRINT("[+] Get imports: dlopen: %x, dlsym: %x, dlclose: %x, dlerror: %x\n",
                dlopen_addr, dlsym_addr, dlclose_addr, dlerror_addr);

    printf("library path = %s\n", library_path);
    ptrace_writedata(target_pid, map_base, library_path, strlen(library_path) + 1);     //被附加进程里面写入.so 库的内容

    parameters[0] = map_base;                   //设置参数 被附加进程的mmap函数的基地址
    parameters[1] = RTLD_NOW| RTLD_GLOBAL;      //常量值

    if (ptrace_call_wrapper(target_pid, "dlopen", dlopen_addr, parameters, 2, &regs) == -1) //调用被附加进程里面指定的函数
        goto exit;

    void * sohandle = ptrace_retval(&regs);

#define FUNCTION_NAME_ADDR_OFFSET       0x100
    ptrace_writedata(target_pid, map_base + FUNCTION_NAME_ADDR_OFFSET, function_name, strlen(function_name) + 1);
    parameters[0] = sohandle;
    parameters[1] = map_base + FUNCTION_NAME_ADDR_OFFSET;

    if (ptrace_call_wrapper(target_pid, "dlsym", dlsym_addr, parameters, 2, &regs) == -1)
        goto exit;

    void * hook_entry_addr = ptrace_retval(&regs);                  //获取被附加进程被调用函数的地址
    DEBUG_PRINT("hook_entry_addr = %p\n", hook_entry_addr);

#define FUNCTION_PARAM_ADDR_OFFSET      0x200
    ptrace_writedata(target_pid, map_base + FUNCTION_PARAM_ADDR_OFFSET, param, strlen(param) + 1);
    parameters[0] = map_base + FUNCTION_PARAM_ADDR_OFFSET;

    if (ptrace_call_wrapper(target_pid, "hook_entry", hook_entry_addr, parameters, 1, &regs) == -1) //调用被附加进程被调用函数
        goto exit;

    printf("Press enter to dlclose and detach\n");
    getchar();
    parameters[0] = sohandle;

    if (ptrace_call_wrapper(target_pid, "dlclose", dlclose, parameters, 1, &regs) == -1)    //关闭调用
        goto exit;

    /* restore */
    ptrace_setregs(target_pid, &original_regs);             //恢复寄存器
    ptrace_detach(target_pid);                              //分离附加
    ret = 0;

    exit:
    return ret;
}

void inject(int pid)
{
    struct pt_regs old_regs,regs;
    long sleep_addr;
    //保存寄存器
    ptrace(PTRACE_GETREGS, pid, NULL, &old_regs);
    memcpy(&regs, &old_regs, sizeof(regs));

    long parameters[1];
    parameters[0] = 10;
    sleep_addr = get_remote_addr(pid, "libc.so", (void*)sleep);
    ptrace_call(pid,sleep_addr,parameters,1,&regs);
    //恢复寄存器
    ptrace(PTRACE_SETREGS, pid, NULL, &old_regs);
}


int main(int argc, char** argv) {
    pid_t target_pid;
    target_pid = find_pid_of("./hello_sleep"); //查找所需要注入的进程的pid
    if (-1 == target_pid) {
        printf("Can't find the process\n");
        return -1;
    }


    if(0 != ptrace(PTRACE_ATTACH, target_pid, NULL, NULL)){
        printf("attach failed.");
        return 1;
    }

    inject(target_pid);

    ptrace(PTRACE_DETACH, target_pid, NULL, NULL);
    return 0;
}

目标函数是 libc.so 中的 sleep 函数.正常情况是每输出一次暂停一秒,现在我们让它暂停10秒.

第一步：拿到被注入的进行ID号 find_pid_of("./hello_sleep");

int find_pid_of(const char *process_name)
{
    int id;
    pid_t pid = -1;
    DIR* dir;
    FILE *fp;
    char filename[32];
    char cmdline[256];

    struct dirent * entry;

    if (process_name == NULL)
        return -1;

    dir = opendir("/proc");
    if (dir == NULL)
        return -1;

    while((entry = readdir(dir)) != NULL) {
        id = atoi(entry->d_name);
        if (id != 0) {
            sprintf(filename, "/proc/%d/cmdline", id);
            fp = fopen(filename, "r");
            if (fp) {
                fgets(cmdline, sizeof(cmdline), fp);
                fclose(fp);

                if (strcmp(process_name, cmdline) == 0) {
                    /* process found */
                    pid = id;
                    break;
                }
            }
        }
    }

    closedir(dir);
    return pid;
}

原理很简单去找到/proc 虚拟文件系统然后对比名字拿到进程号ID

然后调用 Ptrace 函数附加当前进程到被注入进程，这里介绍下Ptrace函数：

ptrace()系统调用函数提供了一个进程（the “tracer”）监察和控制另一个进程（the “tracee”）的方法。并且可以检查和改变“tracee”进程的内存和寄存器里的数据。它可以用来实现断点调试和系统调用跟踪。
当进程被跟踪后，每当信号量传来，甚至信号量会被忽略时，tracee会暂停。tracer会在下次调用waitpid(或者其它wait系统调用)处被通知。该调用会返回一个包含tracee暂停原因信息的状态码。当tracee暂停后，tracer可以使用一系列ptrace请求来查看和修改tracee中的信息。tracer接着可以让tracee继续执行。

这里面我一直有个疑问就是为什么这个Demo中的 ptrace 居然没有用 wait 来等待目标进程暂停后切换执行，但是这样也能正常运行，我查了下资料说是

PTRACE_ATTACH：
根据pid将调试进程附加到被调试进程上,PTRACE_ATTACH向被调试进程发送SIGSTOP信号使之停下.
但是在ptrace(PTRACE_ATTACH,pid,0,0)执行完毕时被调试进程可能还没有暂停,可以使用waitpid()等待其停下.

意思是说有被附加进程可能停下执行附加进程，也可能被附加进程停不下来使用wait使其停下来，保险起见还是使用wait使其停下来为好 （如果有高见的可以给我留言）

if(0 != ptrace(PTRACE_ATTACH, target_pid, NULL, NULL)){
        printf("attach failed.");
        return 1;
    }

附加成功以后，目标进程会暂停，Hook进程会得到执行的机会，这个时候调用 inject 函数，函数首先通过PTRACE_GETREGS拿到源寄存器，然后保存，设置好等下要注入的sleep系统调用所需要的参数parameters[0] = 10 也就是睡10秒，然后通过get_remote_addr函数拿到了目标进程的sleep系统调用在目标进程的地址：

首先拿到本进程与目标进程的基地址也就是代码段的地址，也就是去查询虚拟文件系统/proc/%d/maps 查询里面代码段的libc库地址作为基地址，然后计算出偏移量，偏移量的计算很简单拿本进程的sleep地址 - 本进程libc基地址 + 目标进程的libc基地址

待会会涉及到ARM寄存器的操作，让我们先复习下 ATPCS 即ARM-THUMB procedure call standard（ARM-Thumb过程调用标准）的简称：

寄存器的使用规则:

1. 子程序通过寄存器R0~R3来传递参数. 这时寄存器可以记作: A0~A3 , 被调用的子程序在返回前无需恢复寄存器R0~R3的内容.
2. 在子程序中,使用R4-R11来保存局部变量,这时寄存器R4-R11可以记作: V1-V8 .如果在子程序中使用到V1-V8的某些寄存器,子程序进入时必须保存这些寄存器的值,在返回前必须恢复这些寄存器的值,对于子程序中没有用到的寄存器则不必执行这些操作.在THUMB程序中，通常只能使用寄存器R4-R7来保存局部变量.
   3.寄存器R12用作子程序间scratch寄存器,记作ip; 在子程序的连接代码段中经常会有这种使用规则.
3. 寄存器R13用作数据栈指针,记做SP,在子程序中寄存器R13不能用做其他用途. 寄存器SP在进入子程序时的值和退出子程序时的值必须相等.
4. 寄存器R14用作连接寄存器,记作lr ; 它用于保存子程序的返回地址,如果在子程序中保存了返回地址,则R14可用作其它的用途.
5. 寄存器R15是程序计数器,记作PC ; 它不能用作其他用途.
6. ATPCS中的各寄存器在ARM编译器和汇编器中都是预定义的.

上面说的是大致的总规则，下面具体介绍下 参数的传递规则 与 子程序结果返回规则

参数的传递规则 ：对于参数个数可变的子程序,当参数不超过4个时,可以使用寄存器R0~R3来进行参数传递,当参数超过4个时,还可以使用数据栈来传递参数. 在参数传递时,将所有参数看做是存放在连续的内存单元中的字数据。然后,依次将各名字数据传送到寄存器R0,R1,R2,R3; 如果参数多于4个,将剩余的字数据传送到数据栈中（即sp寄存器）,入栈的顺序与参数顺序相反,即最后一个字数据先入栈. 按照上面的规则,一个浮点数参数可以通过寄存器传递,也可以通过数据栈传递,也可能一半通过寄存器传递，另一半通过数据栈传递.

子程序结果返回规则：
1.结果为一个32位的整数时,可以通过寄存器R0返回.
2.结果为一个64位整数时,可以通过R0和R1返回，依此类推.
3.结果为一个浮点数时,可以通过浮点运算部件的寄存器f0,d0或者s0来返回.
4.结果为一个复合的浮点数时,可以通过寄存器f0-fN或者d0~dN来返回.
5.对于位数更多的结果,需要通过调用内存来传递.

😁我们下面会用到R0-R3 , SP , LR , PC寄存器，大家可以参考上面的说明来查看使用

然后进行 ptrace_call 调用，这个是这里面最重要的函数，我们只看ARM架构的，一开始参数赋值给寄存器，前4个参数通过r0-r3 寄存器传递（直接赋值就可以），后面的后面的参数通过sp 寄存器传递（熟悉ARM编程这个肯定不陌生，说直白的就是利用栈空间存储，然后传递这个栈的地址），然后把pc寄存器赋值为目标进程的sleep地址

regs->ARM_pc = addr;

然后寄存器赋值给目标进程，并且进行函数调用（运行pc寄存器地址的函数）

if (ptrace_setregs(pid, regs) == -1         //设计寄存器并且调用函数
            || ptrace_continue(pid) == -1) {    
        printf("error\n");    
        return -1;    
    }  

运行完成以后由于由于我们在前面设置了regs->ARM_lr = 0，它就会返回到0地址处继续执行，这样就会产生SIGSEGV了，程序中的 0xb7f 就表示子进程进入了暂停状态，且发送的错误信号为11(SIGSEGV)，它表示试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据，这样就做到了目标进制执行完暂停切换到注入进程执行

WUNTRACED:
告诉 waitpid ，如果子进程进入暂停状态或者已经终止，那么就立即返回 status 信息,正常情况是子进程终止的时候才返回.
如果是被ptrace的子进程，那么即使不提供WUNTRACED参数，也会在子进程进入暂停状态的时候立即返回。
对于使用 ptrace_cont 运行的子进程，它会在3种情况下进入暂停状态：①下一次系统调用；②子进程退出；③子进程的执行发生错误。

regs->ARM_lr = 0; 

其中这个 stat != 0xb7f 这句话我理解很久都理解不清楚什么意思直到我找到了下面这张图，0xb7f表示stopped信号为11，进程状态为stopped，为此我还专门记录了下这个问题有兴趣大家可以去捧场：

Linux wait函数status的含义

image.png

最后寄存器恢复

ptrace(PTRACE_SETREGS, pid, NULL, &old_regs);

这样看来还不算复杂的，无非就是操作寄存器修改里面的值而已，搞过汇编或者做过逆向的对于这些应该很熟悉，再者就是要掌握Linux Ptrace函数的使用这个是个要点，这个函数功能非常强大，GDB断点调试都基于这个原理来实现的，大家一定要掌握。

我们上篇算是打好了一个基础，下篇可能会复杂一点，但是是基于这个基础上实现的，另外这种方式的Hook的优缺点我们也会在下篇展开讲解···

Android(Linux)下的ARM注入，Android下的.so注入 下篇