前言

以前我们在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并执行我们的函数了。

参考