前言

以前我们在window在vx上做过进程注入，效果好极了。现在我们就来看看在Android上的进程注入，网上有很多资料但是都大同小异，主要是使用了Linux上的ptrace函数，这个函数可以对目标进程进行内存读写附加等功能。所以我们只需要对其进行封装就可以得到我们所需的函数了。

思路

我们的目的是在目标进程中打开我们自己的so库，然后执行so中导出的函数。在正常的开发逻辑中打开so，然后调用其导出函数的代码如下

    //打开文件
    void *handle = dlopen(dllPath, RTLD_NOW | RTLD_GLOBAL);

    if (!handle) {
        __android_log_print(ANDROID_LOG_ERROR, "SharkChilli",
                            "handle error");
    }
    //获取函数地址
    void *hook_entry_addr = dlsym(handle, "main_entry");

    __android_log_print(ANDROID_LOG_ERROR, "SharkChilli",
                        "hook_entry_addr = %p\n", hook_entry_addr);

    typedef int(* HOOK_ENTRY)(char *); // 定义函数指针类型的别名

    HOOK_ENTRY my_hook_entry = (HOOK_ENTRY)hook_entry_addr;
    my_hook_entry("test");
    dlclose(handle);

由于Linux是进程隔离所以我们在自己的进程中执行上面代码是没有用的，所以我们等依靠ptrace函数来完成这些操作。其中定义的字符串变量都得是目标进程中分配的。我们还得从目标进程中获取返回值等结果。所以按照这个思路我们有以下函数需要实现

函数实现

附加卸载函数

//挂载到目标进程
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;
}

寄存器读写函数

//读取进程寄存器数据
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;
}

获得函数返回值、获得PC执行地址

long ptrace_retval(struct pt_regs *regs) {
    return regs->ARM_r0;
}

long ptrace_ip(struct pt_regs *regs) {
    return regs->ARM_pc;
}

1.读取目标进程数据函数
ptrace(PTRACE_PEEKTEXT, pid, addr, data)

ptrace的第一个参数为PTRACE_PEEKTEXT的时候，从子进程内存空间addr指向的位置读取一个字节，并作为调用的结果返回。Linux内部对文本段和数据段不加区分

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++) {
        //拷贝src指向的数据
        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;
}

参数一：目标进程id
参数二：目标进程读取的地址
参数二：buf用于保存读出的结果
参数四：读取的大小
这里是每次读取4个字节，最后在if判断中读取剩下的字节。
这里之所以使用union 是因为ptrace这时候返回的是long，使用union就省去了转化。

2.写入目标进程数据函数
ptrace(PTRACE_POKETEXT, pid, addr, data);
ptrace的第一个参数为PTRACE_POKETEXT的时候，将data指向的字拷贝到子进程内存空间由addr指向的位置。

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;
    remain = size % 4;

    laddr = data;

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

        dest += 4;
        laddr += 4;
    }

    if (remain > 0) {
        for (i = 0; i < remain; i++) {
            d.chars[i] = *laddr++;
        }

        ptrace(PTRACE_POKETEXT, pid, dest, d.val);
    }

    return 0;
}

参数一：目标进程id
参数二：目标进程写入的地址
参数二：data写入数据
参数四：写入的大小
这个和上面读取的操作是类似的。

3.调用目标进程指定地址函数
这里我们要知道arm中的调用约定，参数1~参数4 分别保存到 R0~R3 寄存器中 ，剩下的参数从右往左依次入栈，被调用者实现栈平衡，返回值存放在 R0 中。

int ptrace_call(pid_t pid, uint32_t addr, long *params, uint32_t num_params, struct pt_regs* regs)
{
    uint32_t i;
    //前4个参数放入寄存器
    for (i = 0; i < num_params && i < 4; i ++) {
        regs->uregs[i] = params[i];
    }

        //后面的参数从右往左依次入栈
    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;
    if (regs->ARM_pc & 1) {
        /* thumb */
        regs->ARM_pc &= (~1u);
        regs->ARM_cpsr |= CPSR_T_MASK;
    } else {
        /* arm */
        regs->ARM_cpsr &= ~CPSR_T_MASK;
    }
        
        //那么如何notify进程我们mmp执行完了。就是通过下面这句话。
        //原因是当函数调用时候，当我们使用bl或者bx，链接寄存器指向的是下一条返回地址，
        //如果把下条返回地址赋值成0，返回时候pc=0，就会产生异常。相当于一个notify，
        //然后用下面那个waitpid得到异常模式，确定mmp执行完。所以其实下面不一定是0，只要是无效即可。
    regs->ARM_lr = 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;
}

参数一：目标进程id
参数二：函数地址
参数三：参数数组
参数四：参数数量
参数五：寄存器结构体

这里有一点需要注意，在ARM架构下有ARM和Thumb两种指令，因此在调用函数前需要判断函数被解析成哪种指令，上面代码就是通过地址的最低位是否为1来判断调用地址处指令为ARM或Thumb，若为Thumb指令，则需要将最低位重新设置为0，并且将CPSR寄存器的T标志位置位，若为ARM指令，则将CPSR寄存器的T标志位复位。

再次封装得到返回值代码如下

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

4.获取目标进程模块基址
读取”/proc/pid/maps”可以获取到系统模块在本地进程和远程进程的加载基地址

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, "-");
                //转成16进制
                addr = strtoul(pch, NULL, 16);

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

                break;
            }
        }

        fclose(fp);
    }

    return (void *) addr;
}

参数一：目标pid(小于0时查看自己的模块地址)
参数二：模块名称

尾言

有了这些函数我们就可以，在目标进程中加载我们的so并执行我们的函数了。

参考

常见函数调用约定(x86、x64、arm、arm64)
linux ptrace函数
Android进程注入
Android ptrace进程注入原理