关于这个名字感觉很奇怪感觉是两个题目，其实从原理来说是基本上一个原理，稍加改动就作用于两个不同的场景，一个是在Android(Linux)下的ARM汇编注入系统调用，另一个是在Android下面注入调用另一个.so库，我们先开启上半篇《Android(Linux)下的ARM注入》
好的让我开始Android下的Hook大家一定都不陌生了，经常见的如下几种
- 修改虚拟机NativeFun的指针调用的方式
- 修改虚拟机的ArtMethod 函数结构体整体替换为想要的ArtMethod结构体
- AOP + Reflection 的方式进行调用
- 利用Android下的类加载器加载目标的Dex达到Hook目的
- 利用ARM汇编底层修改替换寄存器来实现Hook
前两个在热修复HotFix场景中非常常见，例如AndFix框架，这个框架已经开源很久了大家可以去下载看看源码，我有一篇文章简单介绍了AndFix的原理，大家有兴趣的可以去观看 《AndFix各个版本的改动以及原理》
第三个 AOP + Reflection 广泛运用于一些插件化框架里面例如 DroidPlugin 框架，老实说这个框架里面包含了很多的细节，最难的是在于找到合适的注入点，但是想找到合适的注入点就必须对于Android各个层面的调用都非常清楚才行， 但是话说回来最后实现的主要手法还是运用了AOP + Reflection，网络上有一个高手叫 weishu 专门写了几篇分析这个框架的文章可以给大家分享一下 http://weishu.me/
第四个用于一些Dex里面的方法替换，常见的例如QQZone团队很早就在网络上开源的MutiDex来进行两个Dex里面的方法替换
今天我们要说的是第五个也就是利用ARM汇编底层修改替换寄存器来实现Hook。
其实关于这个网络上已经有了一些文章以及资料来讲解了，而且这次这个课题是我以前在公司分享公开课的一次分享的课题，最近是又拿出了这部分来自己进行提炼以及升华来做一次总结。这次我争取从一个通俗易懂的角度来讲解下这两部分，顺便讲解一下别文章没有的东西。
在这之前我先把我调试的Demo传给大家供大家调试，这个Demo来源于网络上面，我进行一点改进以及注释，另外我已经运行过了在以前的小米手机以及模拟器都能够运行成功。
Demo 下载
项目文件夹结构如下：
image.png
jni文件夹里面是主要的代码，libs是编译出的文件，detail文件夹是我以前做的简单的原理总结。
首先这种Hook的分如下几个步骤：
1.先找到被注入进程的pid
2.附加当前进程到被注入进程
3.保存原寄存器的值
4.找到需要Hook的系统调用函数
5.修改目标进程寄存器
6.执行目标函数调用
7.恢复寄存器的值
8.分离附加进程
我们先可以运行看看效果：
image.png
hello_sleep.c 是我们想要注入的目标进程代码如下
#include
#include
int count = 0;
void print()
{
printf("hello,%d\n",count);
sleep(1);
}
int main(int argc, char const *argv[])
{
while(1){
print();
count++;
}
return 0;
}
很简单隔一秒打印一句话，我们要做的目的是注入sleep 系统调用把里面的参数给他改了，改成比如10秒一执行，inject_sleep.c 是要运行Hook效果的进程
其完整代码如下
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#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 *)¶ms[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, ®s) == -1) //读取被附加进程的寄存器
goto exit;
/* save original registers */
memcpy(&original_regs, ®s, 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, ®s) == -1) //开始调用被附加进程的mmap函数
goto exit;
map_base = ptrace_retval(®s); //获取函数调用的返回值
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, ®s) == -1) //调用被附加进程里面指定的函数
goto exit;
void * sohandle = ptrace_retval(®s);
#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, ®s) == -1)
goto exit;
void * hook_entry_addr = ptrace_retval(®s); //获取被附加进程被调用函数的地址
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, ®s) == -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, ®s) == -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(®s, &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,®s);
//恢复寄存器
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);
ptrace(PTRACE_DETACH, target_pid, NULL, NULL);
return 0;
}
目标函数是 libc.so 中的 sleep 函数.正常情况是每输出一次暂停一秒,现在我们让它暂停10秒.
第一步：拿到被注入的进行ID号 find_pid_of("./hello_sleep");
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;
}
原理很简单去找到/proc 虚拟文件系统然后对比名字拿到进程号ID
然后调用 Ptrace 函数附加当前进程到被注入进程，这里介绍下Ptrace函数：
ptrace()系统调用函数提供了一个进程（the “tracer”）监察和控制另一个进程（the “tracee”）的方法。并且可以检查和改变“tracee”进程的内存和寄存器里的数据。它可以用来实现断点调试和系统调用跟踪。
当进程被跟踪后，每当信号量传来，甚至信号量会被忽略时，tracee会暂停。tracer会在下次调用waitpid(或者其它wait系统调用)处被通知。该调用会返回一个包含tracee暂停原因信息的状态码。当tracee暂停后，tracer可以使用一系列ptrace请求来查看和修改tracee中的信息。tracer接着可以让tracee继续执行。
这里面我一直有个疑问就是为什么这个Demo中的 ptrace 居然没有用 wait 来等待目标进程暂停后切换执行，但是这样也能正常运行，我查了下资料说是
PTRACE_ATTACH：
根据pid将调试进程附加到被调试进程上,PTRACE_ATTACH向被调试进程发送SIGSTOP信号使之停下.
但是在ptrace(PTRACE_ATTACH,pid,0,0)执行完毕时被调试进程可能还没有暂停,可以使用waitpid()等待其停下.
意思是说有被附加进程可能停下执行附加进程，也可能被附加进程停不下来使用wait使其停下来，保险起见还是使用wait使其停下来为好 （如果有高见的可以给我留言）
if(0 != ptrace(PTRACE_ATTACH, target_pid, NULL, NULL)){
printf("attach failed.");
return 1;
}
附加成功以后，目标进程会暂停，Hook进程会得到执行的机会，这个时候调用 inject 函数，函数首先通过PTRACE_GETREGS拿到源寄存器，然后保存，设置好等下要注入的sleep系统调用所需要的参数parameters[0] = 10 也就是睡10秒，然后通过get_remote_addr函数拿到了目标进程的sleep系统调用在目标进程的地址：
首先拿到本进程与目标进程的基地址也就是代码段的地址，也就是去查询虚拟文件系统/proc/%d/maps 查询里面代码段的libc库地址作为基地址，然后计算出偏移量，偏移量的计算很简单拿本进程的sleep地址 - 本进程libc基地址 + 目标进程的libc基地址
待会会涉及到ARM寄存器的操作，让我们先复习下 ATPCS 即ARM-THUMB procedure call standard（ARM-Thumb过程调用标准）的简称：
寄存器的使用规则:
- 子程序通过寄存器R0~R3来传递参数. 这时寄存器可以记作: A0~A3 , 被调用的子程序在返回前无需恢复寄存器R0~R3的内容.
- 在子程序中,使用R4-R11来保存局部变量,这时寄存器R4-R11可以记作: V1-V8 .如果在子程序中使用到V1-V8的某些寄存器,子程序进入时必须保存这些寄存器的值,在返回前必须恢复这些寄存器的值,对于子程序中没有用到的寄存器则不必执行这些操作.在THUMB程序中，通常只能使用寄存器R4-R7来保存局部变量.
3.寄存器R12用作子程序间scratch寄存器,记作ip; 在子程序的连接代码段中经常会有这种使用规则.- 寄存器R13用作数据栈指针,记做SP,在子程序中寄存器R13不能用做其他用途. 寄存器SP在进入子程序时的值和退出子程序时的值必须相等.
- 寄存器R14用作连接寄存器,记作lr ; 它用于保存子程序的返回地址,如果在子程序中保存了返回地址,则R14可用作其它的用途.
- 寄存器R15是程序计数器,记作PC ; 它不能用作其他用途.
- ATPCS中的各寄存器在ARM编译器和汇编器中都是预定义的.
上面说的是大致的总规则，下面具体介绍下 参数的传递规则 与 子程序结果返回规则
参数的传递规则 ：对于参数个数可变的子程序,当参数不超过4个时,可以使用寄存器R0~R3来进行参数传递,当参数超过4个时,还可以使用数据栈来传递参数. 在参数传递时,将所有参数看做是存放在连续的内存单元中的字数据。然后,依次将各名字数据传送到寄存器R0,R1,R2,R3; 如果参数多于4个,将剩余的字数据传送到数据栈中（即sp寄存器）,入栈的顺序与参数顺序相反,即最后一个字数据先入栈. 按照上面的规则,一个浮点数参数可以通过寄存器传递,也可以通过数据栈传递,也可能一半通过寄存器传递，另一半通过数据栈传递.
子程序结果返回规则：
1.结果为一个32位的整数时,可以通过寄存器R0返回.
2.结果为一个64位整数时,可以通过R0和R1返回，依此类推.
3.结果为一个浮点数时,可以通过浮点运算部件的寄存器f0,d0或者s0来返回.
4.结果为一个复合的浮点数时,可以通过寄存器f0-fN或者d0~dN来返回.
5.对于位数更多的结果,需要通过调用内存来传递.
我们下面会用到R0-R3 , SP , LR , PC寄存器，大家可以参考上面的说明来查看使用
然后进行 ptrace_call 调用，这个是这里面最重要的函数，我们只看ARM架构的，一开始参数赋值给寄存器，前4个参数通过r0-r3 寄存器传递（直接赋值就可以），后面的后面的参数通过sp 寄存器传递（熟悉ARM编程这个肯定不陌生，说直白的就是利用栈空间存储，然后传递这个栈的地址），然后把pc寄存器赋值为目标进程的sleep地址
regs->ARM_pc = addr;
然后寄存器赋值给目标进程，并且进行函数调用（运行pc寄存器地址的函数）
if (ptrace_setregs(pid, regs) == -1 //设计寄存器并且调用函数
|| ptrace_continue(pid) == -1) {
printf("error\n");
return -1;
}
运行完成以后由于由于我们在前面设置了regs->ARM_lr = 0，它就会返回到0地址处继续执行，这样就会产生SIGSEGV了，程序中的 0xb7f 就表示子进程进入了暂停状态，且发送的错误信号为11(SIGSEGV)，它表示试图访问未分配给自己的内存, 或试图往没有写权限的内存地址写数据，这样就做到了目标进制执行完暂停切换到注入进程执行
WUNTRACED:
告诉 waitpid ，如果子进程进入暂停状态或者已经终止，那么就立即返回 status 信息,正常情况是子进程终止的时候才返回.
如果是被ptrace的子进程，那么即使不提供WUNTRACED参数，也会在子进程进入暂停状态的时候立即返回。
对于使用 ptrace_cont 运行的子进程，它会在3种情况下进入暂停状态：①下一次系统调用；②子进程退出；③子进程的执行发生错误。
regs->ARM_lr = 0;
其中这个 stat != 0xb7f 这句话我理解很久都理解不清楚什么意思直到我找到了下面这张图，0xb7f表示stopped信号为11，进程状态为stopped，为此我还专门记录了下这个问题有兴趣大家可以去捧场：
Linux wait函数status的含义
image.png
最后寄存器恢复
ptrace(PTRACE_SETREGS, pid, NULL, &old_regs);
这样看来还不算复杂的，无非就是操作寄存器修改里面的值而已，搞过汇编或者做过逆向的对于这些应该很熟悉，再者就是要掌握Linux Ptrace函数的使用这个是个要点，这个函数功能非常强大，GDB断点调试都基于这个原理来实现的，大家一定要掌握。
我们上篇算是打好了一个基础，下篇可能会复杂一点，但是是基于这个基础上实现的，另外这种方式的Hook的优缺点我们也会在下篇展开讲解···
Android(Linux)下的ARM注入，Android下的.so注入 下篇