android 系统内存配置安卓内存call

转载

mob6454cc6d5f87 2023-06-27 16:07:36

文章标签 android 系统内存配置 android 进程注入 x86 寄存器数据入栈 文章分类 Android 移动开发

前言

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

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。