安卓动态调试七种武器之离别钩 – Hooking（上）

最新推荐文章于 2024-05-23 09:53:57 发布
转载 最新推荐文章于 2024-05-23 09:53:57 发布 · 1.2k 阅读 · 2

本文深入探讨了移动安全领域的调试工具和技术，通过一系列实例展示了如何使用动态调试工具进行Android应用的深入分析，包括系统调用钩子、内存修改、动态加载自定义库等高级技巧，旨在为国内移动安全研究者提供实用的催化剂。

作者：蒸米

地址：http://drops.wooyun.org/tips/9300

0x00 序

随着移动安全越来越火，各种调试工具也都层出不穷，但因为环境和需求的不同，并没有工具是万能的。另外工具是死的，人是活的，如果能搞懂工具的原理再结合上自身的经验，你也可以创造出属于自己的调试武器。因此，笔者将会在这一系列文章中分享一些自己经常用或原创的调试工具以及手段，希望能对国内移动安全的研究起到一些催化剂的作用。

目录如下:

安卓动态调试七种武器之长生剑 - Smali Instrumentation
安卓动态调试七种武器之孔雀翎 – Ida Pro
安卓动态调试七种武器之离别钩 – Hooking (上)
安卓动态调试七种武器之离别钩 – Hooking (下)
安卓动态调试七种武器之碧玉刀- Customized DVM
安卓动态调试七种武器之多情环- Customized Kernel
安卓动态调试七种武器之霸王枪 - Anti Anti-debugging
安卓动态调试七种武器之拳头 - Tricks & Summary

文章中所有提到的代码和工具都可以在我的github下载到，地址是：

https://github.com/zhengmin1989/TheSevenWeapons

0x01 离别钩

Hooking翻译成中文就是钩子的意思，所以正好配合这一章的名字《离别钩》。

“我知道钩是种武器，在十八般兵器中名列第七，离别钩呢?”
“离别钩也是种武器，也是钩。”
“既然是钩，为什么要叫做离别?”
“因为这柄钩，无论钩住什么都会造成离别。如果它钩住你的手，你的手就要和腕离别；如果它钩住你的脚，你的脚就要和腿离别。”
“如果它钩住我的咽喉，我就和这个世界离别了?”
“是的，”
“你为什么要用如此残酷的武器?”
“因为我不愿被人强迫与我所爱的人离别。”
“我明白你的意思了。”
“你真的明白?”
“你用离别钩，只不过为了要相聚。”
“是的。”

一提到hooking，让我又回想起了2011年的时候。当时android才出来没多久，各大安全公司都在忙着研发自己的手机助手。当时手机上最泛滥的病毒就是短信扣费类的病毒，但仅仅是靠云端的病毒库扫描是远远不够的。而这时候”LBE安全大师”横空出世，提供了主动防御的技术，可以在病毒发送短信之前拦截下来，并让用户选择是否发送。 其实这个主动防御技术就是hooking。虽然在PC上hooking的技术已经很成熟了，但是在android上的资料却非常稀少，只有少数人掌握着android上hooking的技术，因此这些人也变成了各大公司争相抢夺的对象。但是没有什么东西是能够永久保密的，这些技术早晚会被大家研究出来并对外公开的。因此，到了2015年，android上的hook资料已经遍地都是了，各种开源的hook框架也层出不穷，使用这些hook工具就可以轻松的hook native，jni和java层的函数。但这同样也带来了一些问题，新手想研究hook的时候因为资料和工具太多往往不知道如何下手，并且就算使用了工具成功的hook，也根本不知道原理是什么。因此笔者准备从hook的原理开始，配合开源工具循序渐进的介绍native，jni和java层的hook，方便大家对hook进行系统的学习。

0x02 Playing with Ptrace on Android

其实无论是hook还是调试都离不开ptrace这个system call，利用ptrace，我们可以跟踪目标进程，并且在目标进程暂停的时候对目标进程的内存进行读写。在linux上有一篇经典的文章叫《Playing with Ptrace》，简单介绍了如何玩转ptrace。在这里我们照猫画虎，来试一下playing with Ptrace on Android。PS：这里的一部分内容借鉴了harry大牛在百度Hi写的一篇文章，可惜后来百度Hi关了，就失传了。不过不用担心，我这篇比他写的还详细。：）

首先来看我们要ptrace的目标程序，用来一直循环输出一句话”Hello,LiBieGou!”：

 

#include <stdio.h>
int count = 0;
 
void sevenWeapons(int number)
{
    char* str = "Hello,LiBieGou!";
    printf("%s %d\n",str,number);
}
 
int main()
{
    while(1)
    {
        sevenWeapons(count);
        count++;
        sleep(1);
    }   
    return 0;
}

想要编译它非常简单，首先建立一个Android.mk文件，然后填入如下内容，让ndk将文件编译为elf可执行文件：


LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE    := target

LOCAL_SRC_FILES := target.c

include $(BUILD_EXECUTABLE)

接下来我们写出hook1.c程序来hook target程序的system call，main函数如下：

int main(int argc, char *argv[])
{
    if(argc != 2) {
        printf("Usage: %s <pid to be traced>\n", argv[0]);
        return 1;
    }
 
    pid_t pid;
    int status;
    pid = atoi(argv[1]);
 
    if(0 != ptrace(PTRACE_ATTACH, pid, NULL, NULL))
    {
        printf("Trace process failed:%d.\n", errno);
        return 1;
    }
 
    ptrace(PTRACE_SYSCALL, pid, NULL, NULL);
 
    while(1)
    {
        wait(&status);
        hookSysCallBefore(pid);
        ptrace(PTRACE_SYSCALL, pid, NULL, NULL);
 
        wait(&status);
        hookSysCallAfter(pid);
        ptrace(PTRACE_SYSCALL, pid, NULL, NULL);
    }
 
    ptrace(PTRACE_DETACH, pid, NULL, NULL);
    return 0;
}

首先要知道hook的目标的pid，这个用ps命令就能获取到。然后我们使用ptrace(PTRACE_ATTACH, pid, NULL, NULL)这个函数对目标进程进行加载。加载成功后我们可以使用ptrace(PTRACE_SYSCALL, pid, NULL, NULL)这个函数来对目标程序下断点，每当目标程序调用system call前的时候，就会暂停下载。然后我们就可以读取寄存器的值来获取system call的各项信息。然后我们再一次使用ptrace(PTRACE_SYSCALL, pid, NULL, NULL)这个函数就可以让system call在调用完后再一次暂停下来，并获取system call的返回值。

获取system call编号的函数如下：

long getSysCallNo(int pid, struct pt_regs *regs)
{
    long scno = 0;
    scno = ptrace(PTRACE_PEEKTEXT, pid, (void *)(regs->ARM_pc - 4), NULL);
    if(scno == 0)
        return 0;
 
    if (scno == 0xef000000) {
        scno = regs->ARM_r7;
    } else {
        if ((scno & 0x0ff00000) != 0x0f900000) {
            return -1;
        }
        scno &= 0x000fffff;
    }
    return scno;   
}

ARM架构上，所有的系统调用都是通过SWI来实现的。并且在ARM 架构中有两个SWI指令，分别针对EABI和OABI：

[EABI]
机器码：1110 1111 0000 0000 -- SWI 0
具体的调用号存放在寄存器r7中.

[OABI]
机器码：1101 1111 vvvv vvvv -- SWI immed_8
调用号进行转换以后得到指令中的立即数。立即数=调用号 | 0x900000

既然需要兼容两种方式的调用，我们在代码上就要分开处理。首先要获取SWI指令判断是EABI还是OABI，如果是EABI，可从r7中获取调用号。如果是OABI，则从SWI指令中获取立即数，反向计算出调用号。

我们接着看hook system call前的函数，和hook system call后的函数：

void hookSysCallBefore(pid_t pid)
{
    struct pt_regs regs;
    int sysCallNo = 0;
 
    ptrace(PTRACE_GETREGS, pid, NULL, &regs);   
    sysCallNo = getSysCallNo(pid, &regs);
    printf("Before SysCallNo = %d\n",sysCallNo);
 
    if(sysCallNo == __NR_write)
    {
        printf("__NR_write: %ld %p %ld\n",regs.ARM_r0,(void*)regs.ARM_r1,regs.ARM_r2);
    }
}
 
void hookSysCallAfter(pid_t pid)
{
    struct pt_regs regs;
    int sysCallNo = 0;
 
    ptrace(PTRACE_GETREGS, pid, NULL, &regs); 
    sysCallNo = getSysCallNo(pid, &regs);
 
    printf("After SysCallNo = %d\n",sysCallNo);
 
    if(sysCallNo == __NR_write)
    {
        printf("__NR_write return: %ld\n",regs.ARM_r0);
    }
 
    printf("\n");
}

在获取了system call的number以后，我们可以进一步获取个个参数的值，比如说write这个system call。在arm上，如果形参个数少于或等于4，则形参由R0,R1,R2,R3四个寄存器进行传递。若形参个数大于4，大于4的部分必须通过堆栈进行传递。而执行完函数后，函数的返回值会保存在R0这个寄存器里。

下面我们就来实际运行一下看看效果。我们先把target和hook1 push到 /data/local/tmp目录下，再chmod 777一下。接着运行target。

# ./target                                                                                                                                                             
Hello,LiBieGou! 0
Hello,LiBieGou! 1
Hello,LiBieGou! 2
Hello,LiBieGou! 3
Hello,LiBieGou! 4
Hello,LiBieGou! 5
Hello,LiBieGou! 6
….

我们随后再开一个shell，然后ps获取target的pid，然后使用hook1程序对target进行hook操作：

# ./hook1 23442
Before SysCallNo = 162
After SysCallNo = 162
 
Before SysCallNo = 4
__NR_write: 1 0xadf020 19
After SysCallNo = 4
__NR_write return: 19
 
Before SysCallNo = 162
After SysCallNo = 162
 
Before SysCallNo = 4
__NR_write: 1 0xadf020 19
After SysCallNo = 4
__NR_write return: 19

我们可以看到第一个SysCallNo是162，也就是sleep函数。第二个SysCallNo是4，也就是write函数，因为printf本质就是调用write这个系统调用来完成的。关于system call number对应的具体system call可以参考我在github上的reference文件夹中的systemcalllist.txt文件，里面有对应的列表。我们的hook1程序还对write的参数做了解析，比如1表示stdout，0xadf020表示字符串的地址，19代表字符串的长度。而返回值19表示write成功写入的长度，也就是字符串的长度。

整个过程用图表达如下：

enter image description here

0x03 利用Ptrace动态修改内存

仅仅是用ptrace来获取system call的参数和返回值还不能体现出ptrace的强大，下面我们就来演示用ptrace读写内存。我们在hook1.c的基础上继续进行修改，在write被调用之前对要输出string进行翻转操作。

我们在hookSysCallBefore()函数中加入modifyString(pid, regs.ARM_r1, regs.ARM_r2)这个函数：

if(sysCallNo == __NR_write)
{
    printf("__NR_write: %ld %p %ld\n",regs.ARM_r0,(void*)regs.ARM_r1,regs.ARM_r2);
    modifyString(pid, regs.ARM_r1, regs.ARM_r2);
}

因为write的第二个参数是字符串的地址，第三个参数是字符串的长度，所以我们把R1和R2的值传给modifyString()这个函数：

void modifyString(pid_t pid, long addr, long strlen)
{
    char* str;
    str = (char *)calloc((strlen+1) * sizeof(char), 1);
    getdata(pid, addr, str, strlen);
    reverse(str);
    putdata(pid, addr, str, strlen);
}

modifyString()首先获取在内存中的字符串，然后进行翻转操作，最后再把翻转后的字符串写入原来的地址。这些操作用到了getdata()和putdata()函数：

void getdata(pid_t child, long addr,
             char *str, int len)
{   char *laddr;
    int i, j;
    union u {
            long val;
            char chars[long_size];
    }data;
    i = 0;
    j = len / long_size;
    laddr = str;
    while(i < j) {
        data.val = ptrace(PTRACE_PEEKDATA,
                          child, addr + i * 4,
                          NULL);
        memcpy(laddr, data.chars, long_size);
        ++i;
        laddr += long_size;
    }
    j = len % long_size;
    if(j != 0) {
        data.val = ptrace(PTRACE_PEEKDATA,
                          child, addr + i * 4,
                          NULL);
        memcpy(laddr, data.chars, j);
    }
    str[len] = '\0';
}
 
void putdata(pid_t child, long addr,
             char *str, int len)
{   char *laddr;
    int i, j;
    union u {
            long val;
            char chars[long_size];
    }data;
    i = 0;
    j = len / long_size;
    laddr = str;
    while(i < j) {
        memcpy(data.chars, laddr, long_size);
        ptrace(PTRACE_POKEDATA, child,
               addr + i * 4, data.val);
        ++i;
        laddr += long_size;
    }
    j = len % long_size;
    if(j != 0) {
        memcpy(data.chars, laddr, j);
        ptrace(PTRACE_POKEDATA, child,
               addr + i * 4, data.val);
    }
}

getdata()和putdata()分别使用PTRACE_PEEKDATA和PTRACE_POKEDATA对内存进行读写操作。因为ptrace的内存操作一次只能控制4个字节，所以如果修改比较长的内容需要进行多次操作。

我们现在运行一下target，并且在运行中用hook2程序进行hook：

# ./target                                                                                                                                                             
Hello,LiBieGou! 0
Hello,LiBieGou! 1
Hello,LiBieGou! 2
Hello,LiBieGou! 3
Hello,LiBieGou! 4
Hello,LiBieGou! 5
Hello,LiBieGou! 6
Hello,LiBieGou! 7
8 !uoGeiBiL,olleH
9 !uoGeiBiL,olleH
01 !uoGeiBiL,olleH
11 !uoGeiBiL,olleH
21 !uoGeiBiL,olleH
31 !uoGeiBiL,olleH
Hello,LiBieGou! 14
Hello,LiBieGou! 15
Hello,LiBieGou! 16

哈哈，是不是看到字符串都被翻转了。如果我们退出hook2程序，字符串又会回到原来的样子。

0x04 利用Ptrace动态执行sleep()函数

上一节中我们介绍了如何使用ptrace来修改内存，现在继续介绍如何用ptrace来执行libc .so中的sleep()函数。主要逻辑都在inject()这个函数中：

void inject(pid_t pid)
{
    struct pt_regs old_regs,regs;
    long sleep_addr;
 
    //save old regs
    ptrace(PTRACE_GETREGS, pid, NULL, &old_regs);
    memcpy(&regs, &old_regs, sizeof(regs));
 
    printf("getting remote sleep_addr:\n");
    sleep_addr = get_remote_addr(pid, libc_path, (void *)sleep);
 
    long parameters[1];
    parameters[0] = 10;
 
    ptrace_call(pid, sleep_addr, parameters, 1, &regs);
 
    //restore old regs
    ptrace(PTRACE_SETREGS, pid, NULL, &old_regs);
}

首先我们用ptrace(PTRACE_GETREGS, pid, NULL, &old_regs)来保存一下寄存器的值，然后获取sleep()函数在目标进程中的地址，接着利用ptrace执行sleep()函数，最后在执行完sleep()函数后再用ptrace(PTRACE_SETREGS, pid, NULL, &old_regs)恢复寄存器原来值。

下面是获取sleep()函数在目标进程中地址的代码：

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) {
        snprintf(filename, sizeof(filename), "/proc/self/maps");
    } 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;
}
 
long get_remote_addr(pid_t target_pid, const char* module_name, void* local_addr)
{
    void* local_handle, *remote_handle;
 
    local_handle = get_module_base(0, module_name);
    remote_handle = get_module_base(target_pid, module_name);
 
    printf("module_base: local[%p], remote[%p]\n", local_handle, remote_handle);
 
    long ret_addr = (long)((uint32_t)local_addr + (uint32_t)remote_handle - (uint32_t)local_handle);
 
    printf("remote_addr: [%p]\n", (void*) ret_addr);
 
    return ret_addr;
}

因为libc.so在内存中的地址是随机的，所以我们需要先获取目标进程的libc.so的加载地址，再获取自己进程的libc.so的加载地址和sleep()在内存中的地址。然后我们就能计算出sleep()函数在目标进程中的地址了。要注意的是获取目标进程和自己进程的libc.so的加载地址是通过解析/proc/[pid]/maps得到的。

接下来是执行sleep()函数的代码：

int ptrace_call(pid_t pid, long 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];
    }
    //
    // push remained params onto stack
    //
    if (i < num_params) {
        regs->ARM_sp -= (num_params - i) * sizeof(long) ;
        putdata(pid, (long)regs->ARM_sp, (char*)&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;
    }
 
    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;
}

首先是将参数赋值给R0-R3，如果参数大于四个的话，再使用putdata()将参数存放在栈上。然后我们将PC的值设置为函数地址。接着再根据是否是thumb指令设置ARM_cpsr寄存器的值。随后我们使用ptrace_setregs()将目标进程寄存器的值进行修改。最后使用waitpid()等待函数被执行。

编译完后，我们使用hook3对target程序进行hook：

# ./target                                                                                                                                                             
Hello,LiBieGou! 0
Hello,LiBieGou! 1
Hello,LiBieGou! 2
Hello,LiBieGou! 3
[…sleep 10 seconds…]
Hello,LiBieGou! 4
Hello,LiBieGou! 5
 
# ./hook3 24835
getting remote sleep_addr:
module_base: local[0xb6f35000], remote[0xb6eec000]
remote_addr: [0xb6f1a24b]

正常的情况是target程序每秒输出一句话，但是用hook3程序hook后，就会暂停10秒钟的时间，因为我们利用ptrace运行了sleep(10)在目标程序中。

0x05 利用Ptrace动态加载so并执行自定义函数

仅仅是执行现有的libc函数是不能满足我们的需求的，接下来我们继续介绍如何动态的加载自定义so文件并且运行so文件中的函数。逻辑大概如下：

保存当前寄存器的状态 -> 获取目标程序的mmap, dlopen, dlsym, dlclose 地址 -> 调用mmap分配一段内存空间用来保存参数信息 –> 调用dlopen加载so文件 -> 调用dlsym找到目标函数地址 -> 使用ptrace_call执行目标函数 -> 调用 dlclose 卸载so文件 -> 恢复寄存器的状态。

实现整个逻辑的函数 injectSo()的代码如下：

void injectSo(pid_t pid,char* so_path, char* function_name,char* parameter)
{
    struct pt_regs old_regs,regs;
    long mmap_addr, dlopen_addr, dlsym_addr, dlclose_addr;
 
//save old regs
 
    ptrace(PTRACE_GETREGS, pid, NULL, &old_regs);
    memcpy(&regs, &old_regs, sizeof(regs));
 
// get remote addres
 
    printf("getting remote addres:\n");
    mmap_addr = get_remote_addr(pid, libc_path, (void *)mmap);
    dlopen_addr = get_remote_addr( pid, libc_path, (void *)dlopen );
    dlsym_addr = get_remote_addr( pid, libc_path, (void *)dlsym );
    dlclose_addr = get_remote_addr( pid, libc_path, (void *)dlclose );
 
    printf("mmap_addr=%p dlopen_addr=%p dlsym_addr=%p dlclose_addr=%p\n",
    (void*)mmap_addr,(void*)dlopen_addr,(void*)dlsym_addr,(void*)dlclose_addr);
 
    long parameters[10];
 
//mmap
 
    parameters[0] = 0; //address
    parameters[1] = 0x4000; //size
    parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC; //WRX
    parameters[3] = MAP_ANONYMOUS | MAP_PRIVATE; //flag
    parameters[4] = 0; //fd
    parameters[5] = 0; //offset
 
ptrace_call(pid, mmap_addr, parameters, 6, &regs);
 
    ptrace(PTRACE_GETREGS, pid, NULL, &regs);
long map_base = regs.ARM_r0;
 
    printf("map_base = %p\n", (void*)map_base);
 
//dlopen
 
    printf("save so_path = %s to map_base = %p\n", so_path, (void*)map_base);
    putdata(pid, map_base, so_path, strlen(so_path) + 1);
 
    parameters[0] = map_base;
    parameters[1] = RTLD_NOW| RTLD_GLOBAL;
 
ptrace_call(pid, dlopen_addr, parameters, 2, &regs);
 
    ptrace(PTRACE_GETREGS, pid, NULL, &regs);
    long handle = regs.ARM_r0;
 
    printf("handle = %p\n",(void*) handle);
 
//dlsym
 
    printf("save function_name = %s to map_base = %p\n", function_name, (void*)map_base);
    putdata(pid, map_base, function_name, strlen(function_name) + 1);
 
    parameters[0] = handle;
    parameters[1] = map_base;
 
ptrace_call(pid, dlsym_addr, parameters, 2, &regs);
 
    ptrace(PTRACE_GETREGS, pid, NULL, &regs);
    long function_ptr = regs.ARM_r0;
 
    printf("function_ptr = %p\n", (void*)function_ptr);
 
//function_call
 
    printf("save parameter = %s to map_base = %p\n", parameter, (void*)map_base);
    putdata(pid, map_base, parameter, strlen(parameter) + 1);
 
    parameters[0] = map_base;
 
    ptrace_call(pid, function_ptr, parameters, 1, &regs);
 
//dlcose
 
    parameters[0] = handle;
 
    ptrace_call(pid, dlclose_addr, parameters, 1, &regs);
 
//restore old regs
 
    ptrace(PTRACE_SETREGS, pid, NULL, &old_regs);
}

mmap()可以用来将一个文件或者其它对象映射进内存，如果我们把flag设置为MAP_ANONYMOUS并且把参数fd设置为0的话就相当于直接映射一段内容为空的内存。mmap()的函数声明和参数如下：

void* mmap(void* start,size_t length,int prot,int flags,int fd,off_t offset);
start：映射区的开始地址，设置为0时表示由系统决定映射区的起始地址。
length：映射区的长度。
prot：期望的内存保护标志，不能与文件的打开模式冲突。我们这里设置为RWX。
flags：指定映射对象的类型，映射选项和映射页是否可以共享。我们这里设置为：MAP_ANONYMOUS(匿名映射，映射区不与任何文件关联)，MAP_PRIVATE(建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件)。
fd：有效的文件描述词。匿名映射设置为0。
off_toffset：被映射对象内容的起点。设置为0。

在我们使用ptrace_call(pid, mmap_addr, parameters, 6, &regs)调用完mmap()函数之后，要记得使用ptrace(PTRACE_GETREGS, pid, NULL, &regs); 用来获取保存返回值的regs.ARM_r0，这个返回值也就是映射的内存的起始地址。

mmap()映射的内存主要用来保存我们传给其他函数的参数。比如接下来我们需要用dlopen()去加载”/data/local/tmp/libinject.so”这个文件，所以我们需要先用putdata()将”/data/local/tmp/libinject.so”这个字符串放置在mmap()所映射的内存中，然后就可以将这个映射的地址作为参数传递给dlopen()了。接下来的dlsym()，so中的目标函数，dlclose()都是相同调用的方式，这里就不一一赘述了。

我们再来看一下被加载的so文件，里面的内容为：

int mzhengHook(char * str){
    printf("mzheng Hook pid = %d\n", getpid());
    printf("Hello %s\n", str);
    LOGD("mzheng Hook pid = %d\n", getpid());
    LOGD("Hello %s\n", str);
    return 0;
}

这里我们不光使用printf()还使用了android debug的函数LOGD()用来输出调试结果。所以在编译时我们需要加上LOCAL_LDLIBS := -llog。

编译完后，我们使用hook4对target程序进行hook：

# ./target                                                                                                        
Hello,LiBieGou! 0
Hello,LiBieGou! 1
Hello,LiBieGou! 2
mzheng Hook pid = 6043
Hello 7weapons
Hello,LiBieGou! 3
Hello,LiBieGou! 4
Hello,LiBieGou! 5
…
 
logcat:
D/DEBUG   ( 6043): mzheng Hook pid = 6043
D/DEBUG   ( 6043): Hello 7weapons
 
# ./hook4 6043
getting remote addres:
mmap_addr=0xb6f80c81 dlopen_addr=0xb6fd0f4d dlsym_addr=0xb6fd0e9d dlclose_addr=0xb6fd0e19
map_base = 0xb6f2f000
save so_path = /data/local/tmp/libinject.so to map_base = 0xb6f2f000
handle = 0xb6fcd494
save function_name = mzhengHook to map_base = 0xb6f2f000
function_ptr = 0xb6f29cbd
save parameter = 7weapons to map_base = 0xb6f2f000

可以看到无论是stdout还是logcat都成功的输出了我们的调试信息。这意味着我们可以通过注入让目标进程加载so文件并执行任意代码了。

0x06 小节

现在我们已经可以做到hook system call以及动态的加载自定义so文件并且运行so文件中的函数了，但离执行以及hook java层的函数还有一定距离。因为篇幅原因，我们的hook之旅就先进行到这里，敬请期待一下篇《离别钩 - Hooking》（听说打赏能让作者写的快一点…）。

文章中所有提到的代码和工具都可以在我的github下载到，地址是：

https://github.com/zhengmin1989/TheSevenWeapons

0x07 参考资料

  1. Playing with Ptrace http://www.linuxjournal.com/article/6100
  2. System Call Tracing using ptrace
  3. 古河的Libinject http://bbs.pediy.com/showthread.php?t=141355


浅谈ARM上的Ptrace
少仲
04-30 2872
/* author:少仲 blog: http://blog.youkuaiyun.com/py_panyu weibo: http://weibo.com/u/3849478598 欢迎转载,转载请注明出处. */ 0x0 前言 你想过怎么实现对系统调用的拦截吗?你尝试过通过改变系统调用的参数来愚弄你的系统kernel吗?你想过调试器是如何使运行中的进程暂停并且控制它吗?你可能会开
Linux 0.11 系统调用的实现机制
ac_dao_di的专栏
12-05 3675
Linux 0.11 系统调用的实现机制 一、系统调用概述     系统调用本质上是一种中断，中断号为0x80，即128号中断。通常我们使用的是库函数，而不是直接使用系统调用，这主要是因为库函数一般都是规定好的，是可以移植的。而系统调用的具体子调用号可能会发生改变，可能不同平台可能不一样，写出来的程序难以移植。触发系统调用，会进入内核态，并调用绑定的处理函数。内核开发人员必须考虑如何将用户空间
安卓动态调试七种武器之孔雀翎 – Ida Pro
把梦想放飞在蓝色的天空里...
09-07 1688
作者：蒸米 地址：http://drops.wooyun.org/tips/6840 0x00 序 随着移动安全越来越火，各种调试工具也都层出不穷，但因为环境和需求的不同，并没有工具是万能的。另外工具是死的，人是活的，如果能搞懂工具的原理再结合上自身的经验，你也可以创造出属于自己的调试武器。因此，笔者将会在这一系列文章中分享一些自己经常用或原创的调试工具以及手段，希望能对
Android ptrace注入基础
weixin_43632667的博客
06-13 1298
一、Android ptrace注入基础 1.可执行文件建立 首先建立一个ELF可执行文件target,使用ndk-build进行编译 需要先在任意地方建立一个jni，然后在jni目录下建立Android.mk,Application.mk,target.c Android.mk: LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := target LOCAL_SRC_FILES := target.c include
微信双开是定时炸弹？关于非越狱iOS上微信分身高危插件ImgNaix的分析
AliMobileSecurity的博客
05-03 9140
当一个随便修改客户端内容，推送任意广告和收费信息，甚至可以窃取微信账号密码的微信双开，你还敢用吗？
Android动态调试七种武器.zip
最新发布
12-05
目录如下:安卓动态调试七种武器之长生剑 - Smali InstrumentationAndroid动态调试七种武器之孔雀翎 - IdaAndroid动态调试七种武器之离别钩 - Hooking安卓动态调试七种武器之碧玉刀 - 定制DVMAndroid动态调试七种武器...
移动安全新武器：动态调试七种技术解密
6. 安卓动态调试七种工具之离别钩 - Customized Kernel: 在安卓设备中，内核是操作系统的核心部分，文章讨论了如何定制内核以获得更强大的调试能力。通过修改内核，开发者可以对操作系统底层进行更精细的控制。 7. ...
精选资源
pine：ART上的动态java方法挂钩框架
02-16
Pine是ART运行时上的动态Java方法挂钩框架，它可以拦截此过程中几乎所有的Java方法调用。 目前，它支持Android 4.4与拇指-2 / arm64架构（仅ART）〜11.0。 关于它的工作原理，可以参考这篇中文。 注意：对于...
Offensive-API-Hooking:进攻API挂钩用于获取明文凭证
03-25
在网络安全领域，API挂钩（Hooking）是一种技术，它允许我们拦截并控制应用程序与操作系统或其他组件之间的通信。这种技术在防御性安全分析中被广泛使用，但也可以被攻击者利用来执行恶意活动，例如“进攻API挂钩”...
Inline Hook Syscall 详解
pwl999的博客
07-20 3216
文章目录1. hook一般syscall2. hook stub syscall2.1 stub_xxx 原理2.2 方法1：hook `stub_xxx`2.3 方法2：hook `call sys_xxx`参考文档： 1. hook一般syscall 在安全、性能分析等领域，经常会需要对系统调用syscall进行hook。有些模块在kernel代码中已经预先hook，例如syscall trace event。 通常syscall使用sys_call_table[]数组来间接调用： kernel\arc
推荐开源项目：SyscallHook - 系统调用监控与钩子大师
gitblog_00083的博客
05-23 555
推荐开源项目：SyscallHook - 系统调用监控与钩子大师 在深入探讨 SyscallHook 这个开源项目之前，我们先要理解它的起源和核心价值。SyscallHook 是基于 Nick Peterson 的 InfinityHook 项目进行改良的版本，针对 Windows 10 20H1 及其后续更新提供了系统调用监控和钩子功能。这意味着你可以透视操作系统底层，洞察每一个系统调用的行为，...
Linux Hook--ptrace的常用参数使用
热门推荐
钞sir的博客
04-28 1万+
简介 ptrace是一种系统调用,也就是进程追踪(process trace);用于对进程的执行进行干涉以及寄存器状态（值）的读取以及设置，内存的写入与读取;我们常用的Linux下的gdb主要功能实现就是通过ptrace系统调用的: #include <sys/ptrace.h> long ptrace(enum __ptrace_request request, pid_t pid,...
VT Msr Hook Syscall
小烟的博客
02-26 1296
VT Hook Syscall
安卓动态调试七种武器之离别钩 – Hooking（下）
beyond702的专栏
02-23 2423
作者：蒸米 地址：http://drops.wooyun.org/papers/10156 0x00 序 随着移动安全越来越火，各种调试工具也都层出不穷，但因为环境和需求的不同，并没有工具是万能的。另外工具是死的，人是活的，如果能搞懂工具的原理再结合上自身的经验，你也可以创造出属于自己的调试武器。因此，笔者将会在这一系列文章中分享一些自己经常用或原创的调试工具以及手段，希望能
windows server 2003镜像_升级网维大师9170部分镜像黑屏蓝屏
weixin_39681058的博客
12-12 935
上一篇文章：安全、速度，云更新14195够强大标题：升级网维大师9170部分镜像黑屏蓝屏编辑：diyi55555更新：2020年7月19日声明：转载请注明来自于微信公众号diyi55555最近网维大师9170发布正式版本后，很多愿意尝鲜的小伙伴就打头阵了，然后个别运气差的，就被黑屏，蓝屏挡住了去路；不过还好，做助攻的研发很快跟上了，披荆斩棘，开辟新道，下面给小伙伴总结一下。现象一...
在Android使用上ptrace的尝试（一）
犀牛划水
08-10 2750
Ptrace功能强大，可以用于调试跟踪。跑了蒸米大神写的例子，学习一下。 实验1：获取system call的编号 要ptrace的目标程序target，用来一直循环输出 #include int count = 0; void sevenWeapons(int number){ char* str = "hello!"; printf("%s, %d\n",str,n
基于ARM的Ptrace
zhangmiaoping23的专栏
01-06 4393
转：http://hi.baidu.com/harry_lime/item/cce5161e4af86d4a71d5e8ff 前面提到过打算研究一下基于ARM的Ptrace，并在Mobile上实现Hook. 今天程序调通了，记录如下. 平台：Android 2.3.3, 具体Linux Kernel和ARM的版本大家可以自己去查 目标：实现两个程序target和trace. target
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值