前言
以前我们在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 *)¶ms[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进程注入原理