arm linux 进程注入,Android(Linux)下的ARM注入，Android下的.so注入下篇

最新推荐文章于 2024-05-31 09:53:26 发布

超高校级的社畜

最新推荐文章于 2024-05-31 09:53:26 发布

阅读量537

点赞数

文章标签： arm linux 进程注入

话说在上篇中，我们介绍了怎么使用 Ptrace 附加到目标进程，然后找到目标进程的 sleep 系统调用函数，并且通过修改寄存器的值来进行Hook，并且调用的原理，今天我们来讲解下半部分也就是如何使得被注入进程运行一个自定义的.so库，开始吧：

我们还是把代码贴上来，但是最后调用的方式有了更改：

#include

#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);

inject_remote_process(target_pid, "./libhello.so", "hook_entry", "I'm parameter!", strlen("I'm parameter!"));

//ptrace(PTRACE_DETACH, target_pid, NULL, NULL);

return 0;

}

替换为了这句：

inject_remote_process(target_pid, "./libhello.so", "hook_entry", "I'm parameter!", strlen("I'm parameter!"));

然后再看一下 libhello.so 里面的内容也就是源码中hello.c里面的内容：

#include

#define LOG_TAG "DEBUG"

#define LOGD(fmt, args...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG, fmt, ##args)

int hook_entry(char * a){

LOGD("Hook success, pid = %d\n", getpid());

LOGD("Hello %s\n", a);

return 0;

}

打印两句话说明调用成功，那执行的原理是怎么样的呢，大概分以下几个步骤：

1.先找到被注入进程的pid

2.附加当前进程到被注入进程

3.保存当前寄存器的状态

4.获取目标程序的mmap, dlopen, dlsym, dlclose函数地址

5.调用mmap分配一块小的空间用来保存信息

6.向mmap分配的空间写入运行的库libhello.so与传递中的参数信息

7.调用dlopen加载so库

8.调用dlsym找到目标函数地址

9.执行目标函数

10.调用dlclose卸载so库

11.恢复寄存器的状态

12.分离附加进程

其中1，2，3，11，12是上篇讲解过一模一样的我们就不再重复了，只是ptrace_attach函数稍微提一下，这里调用了 ptrace 以后然后调用了 waitpid(pid, &status , WUNTRACED); 等待返回这种 wait 等待 ptrace调用是很常见的使用方式，但是我们在上篇 ptrace 的时候貌似没有 wait 这是为什么呢，我查了下说明：

PTRACE_ATTACH：

根据pid将调试进程附加到被调试进程上,PTRACE_ATTACH向被调试进程发送SIGSTOP信号使之停下.

但是在ptrace(PTRACE_ATTACH,pid,0,0)执行完毕时被调试进程可能还没有暂停,可以使用waitpid()等待其停下.

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

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;

}

其中第4点：获取目标程序的mmap, dlopen, dlsym, dlclose函数地址上篇也讲过类似的原理就是利用获取本进程的函数地址 - 本进程库的基地址 + 目标进程的库基地址来实现

然后拼出mmap的参数，申请一个0x4000的空间进行是为了接下来要在这里写入运行的库libhello.so与传递中的参数信息，并通过r0寄存器得到返回值也就是这个片空间的首地址，然向这片空间调入 ptrace_writedata 被附加进程里面写入.so 库的内容，然后调用 dlopen 打开这个库(也就是这个首地址)

/* 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

void *dlopen(const char *filename, int flags);

然后得到 dlopen 返回的地址句柄，随后调用 dlsym_addr 方法拿到想要运行目标方法的 hook_entry 的地址，然后再使用 ptrace_call 方法调用目标进程的 hook_entry 函数，其中每次调用的时候需要向mmap这片区域一个偏移量写入参数作为函数调用传参给寄存器(类似模拟出了一个sp寄存器传参的功能)，例如：

#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)

然后调用dlclose卸载so库，恢复寄存器的状态，分离附加进程这些就不多说了，比起上篇需要多掌握的内容就是些Linux的系统调用函数：mmap，以及使用 dlopen，dlsym，dlclose 来调用动态库的过程，好了下篇的原理就介绍到这里了，最后面我们来一个总结。

总结：经过了上下两篇来介绍这种Hook的方式相信大家已经掌握了基本使用的原理以及方法，我们还是回过头来看看这种Hook的方式有什么优缺点呢

先说优点：就是基于系统调用例如：ptrace,mmap 加上直接操作寄存器来实现，很底层稳定性以及可移植性会好一点，不像利用SDK的函数Hook，这种Hook要看SDK的更新情况，越底层那么稳定性理所应当会好一点

再说缺点：缺点简直太多了

首先实现的方式过于复杂了，分为以下几个：

1.例如上面的源码只兼容了ARM以及X86的那么如果你的手机是mips平台的，那么还要移植一个mips平台的实现方式，如果是基于SDK的Hook有SDK来帮你兼容了各种平台的情况；

2.调用的步骤过于多了又是附加进程，又是查找地址，又是操作寄存器，调用的过程通过 ptrace_continue 来实现一修改一执行，再修改再执行整个过程显得不那么干练；

其次就是这种Hook方式需要Root权限，就这个问题让你丧失了很多的应用场景

再者就是 ptrace 很容易被反调试禁止例如 ptrace(PT_DENY_ATTACH, 0, 0, 0);

最后的话：老实说这种Hook的方式优点不多但是缺点很明显，不太适合在项目中那种 “小而精” 的Hook场景，我能想象的只能用于做一个基于Hook功能的框架，你的手机在这个框架中运行，话说回来学习这种Hook的过程和结果我觉得同样重要，因为有了这个“过程”你掌握了一些相关的知识要点，掌握了一种Hook的思路以及运用，在你接下来的过程中你不断掌握的知识会为你平铺道路，打开新的视野···