Android注入完全剖析

 

0 前沿

本文主要分析了一份實現Android注入的代碼的技術細節，但是並不涉及ptrace相關的知識，所以讀者如果不了解ptrace的話，最好先學習下ptrace原理再來閱讀本文。首先，感謝源代碼的作者ariesjzj大牛，沒有他的源碼就沒有本文~。文中有不對的地方，望各位大牛斧正！謝謝~

相關代碼下載地址：

http://pan.baidu.com/s/1o6ul8eA

或者去代碼原作者的blog：

http://blog.csdn.net/jinzhuojun/article/details/9900105

1 測試方法

①編譯好inject和libhello.so之后，將inject和libhello.so放入/data/local/tmp/injecttest/目錄下，並chmod 777.

②確定我們要inject的進程名。例如inject com.me.keygen.activity，那么我們首先使用ps來查看該進程的信息：

 

該進程的pid = 19989，進程名為"com.me.keygen.activity"。顯然，對於apk而言，它的進程名就是apk的包名。

③確定hook進程之后，所要加入的so絕對路徑。例如，本例要向com.me.keygen.activity中注入libhello.so，此libhello.so存放在/data/local/tmp/injecttest/目錄下，那么它的絕對路徑就為/data/local/tmp/injecttest/libhello.so

④開始注入，注入代碼的格式為：

./inject  com.me.keygen.activity  /data/local/tmp/injecttest/libhello.so

注入成功的話就會顯示:

library path = /data/local/tmp/injecttest/libhello.so

Press enter to dlclose and detach

⑤查看注入結果：

首先查看目的進程com.me.keygen.activity的內存空間中是否含有我們注入的libhello.so,方法如下：

我們在第②步獲取了目的進程的pid = 19989，那么我們可以通過查看進程的mmaps文件：

root@android:/ # cat /proc/19989/maps |busybox grep hello

cat /proc/19989/maps |busybox grep hello

6674b000-6674e000 r-xp 00000000 b3:1a 3689       /data/local/tmp/injecttest/libhello.so

6674e000-6674f000 r--p 00002000 b3:1a 3689       /data/local/tmp/injecttest/libhello.so

6674f000-66750000 rw-p 00003000 b3:1a 3689       /data/local/tmp/injecttest/libhello.so

顯然，so成功注入到了目的進程之中。

然后查看該so中的函數是否執行成功，方法如下：

由於我們注入目的進程后僅僅是執行libhello.so的hook_entry方法，該方法的代碼如下：

int hook_entry(char * a){ 

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

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

    return 0; 

} 

而我們在Inject中調用該函數的代碼為：

inject_remote_process(target_pid, hookSoPath, "hook_entry",  "I'm parameter!", strlen("I'm parameter!"));

所以我們理應在目的進程的logcat中找到字符串"Hello I'm parameter!"。查看指定進程的logcat方法如下：

1|root@android:/ # logcat |busybox grep 19989

logcat |busybox grep 19989

I/ActivityManager(  595): Start proc com.me.keygen.activity for activity com.me.

keygen.activity/.MainActivity: pid=19989 uid=10091 gids={3003, 1028}

D/ActivityThread(19989): setTargetHeapUtilization:0.25

D/ActivityThread(19989): setTargetHeapIdealFree:8388608

D/ActivityThread(19989): setTargetHeapConcurrentStart:2097152

I/HASH    (19989): 46e8b009bfa60ad36aaa6ad76aeb06d5

D/INJECT  (20047): [+] Injecting process: 19989

D/DEBUG   (19989): Hook success, pid = 19989

D/DEBUG   (19989): Hello I'm parameter!

 

測試成功！

 

2對inject代碼的分析

2.1 find_pid_of(const char* targetProcessName)

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目錄下的所有子目錄，獲取這些子目錄的目錄名(一般就是進程的進程號pid)。獲取子目錄名后，就組合成/proc/pid/cmdline文件名，然后依次打開這些文件，cmdline文件里面存放的就是進程名，通過這樣就可以獲取進程的pid了。

2.2 inject_remote_process

此函數完整參數為：

inject_remote_process(pid_t target_pid, const char *library_path, const char *function_name, const char *param, size_t param_size)

其中library_path為我們想要注入到進程的so的絕對路徑；

function_name為我們想要執行的函數名，此函數是so中的函數；

param為該函數的參數，param_size為參數大小，以字節為單位。

下面開始對此函數進行詳細分析。

大致的注入過程如下：

ATTATCH，指定目標進程，開始調試；

GETREGS，獲取目標進程的寄存器，保存現場；

SETREGS，修改PC等相關寄存器，使其指向mmap；

POPETEXT，把so path寫入mmap申請的地址空間；

SETRESG，修改PC等相關寄存器，使其指向dlopen，調用dlopen，獲取sohandle；

SETRESG，修改PC等相關寄存器，使其指向dlsym， functionaddr = dlsym(sohandle,"functionname");
SETRESG，修改PC等相關寄存器，使其指向functionaddr，調用function；

SETRESG，修改PC等相關寄存器，使其指向dlclose，調用dlclose(sohandle);

SETREGS，恢復現場；

DETACH，解除調試，使其恢復；

 

下面對照着代碼進行分析。

①ATTATCH，指定目標進程，開始調試：

if (ptrace_attach(target_pid) == -1)   

        goto exit;

②GETREGS，獲取目標進程的寄存器，保存現場：

if (ptrace_getregs(target_pid, &regs) == -1)   

        goto exit;  

/* save original registers */   

    memcpy(&original_regs, &regs, sizeof(regs));  

③通過get_remote_addr函數獲取目的進程的mmap函數的地址，以便為libxxx.so分配內存：

/*

需要對(void*)mmap進行說明：這是取得inject本身進程的mmap函數的地址，由於mmap函數在libc.so 

庫中，為了將libxxx.so加載到目的進程中，就需要使用目的進程的mmap函數，所以需要查找到libc.so庫在目的進程的起始地址。

*/

mmap_addr = get_remote_addr(target_pid, libc_path, (void *)mmap);  // libc_path = "/system/lib/libc.so"

 

這里需要對get_remote_addr函數進行說明:

/*

該函數為一個封裝函數，通過調用get_module_base函數來獲取目的進程的某個模塊的起始地址，然后通過公式計算出指定函數在目的進程的起始地址。

*/

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);    //獲取遠程pid的某個模塊的起始地址

    DEBUG_PRINT("[+] get_remote_addr: local[%x], remote[%x]\n", local_handle, remote_handle);

/*這需要我們好好理解：local_addr - local_handle的值為指定函數(如mmap)在該模塊中的偏移量，然后再加上rempte_handle，結果就為指定函數在目的進程的虛擬地址*/  

    void * ret_addr = (void *)((uint32_t)local_addr - (uint32_t)local_handle) + (uint32_t)remote_handle;        

    return ret_addr;   

}   

 

顯然，這里面核心的就是get_module_base函數：

/*

此函數的功能就是通過遍歷/proc/pid/maps文件，來找到目的module_name的內存映射起始地址。

由於內存地址的表達方式是startAddrxxxxxxx-endAddrxxxxxxx的，所以會在后面使用strtok(line,"-")來分割字符串

如果pid = -1,表示獲取本地進程的某個模塊的地址，

否則就是pid進程的某個模塊的地址。

*/

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, "-" ); //分解字符串為一組字符串。line為要分解的字符串，"-"為分隔符字符串。

                addr = strtoul( pch, NULL, 16 );  //將參數pch字符串根據參數base(表示進制)來轉換成無符號的長整型數 

                if (addr == 0x8000)   

                    addr = 0;   

                break;   

            }   

        }   

        fclose(fp) ;   

    }   

    return (void *)addr;   

}   

 

④通過ptrace_call_wrapper調用mmap函數，在目的進程中為libxxx.so分配內存：

/* call mmap (null, 0x4000, PROT_READ | PROT_WRITE | PROT_EXEC,

                         MAP_ANONYMOUS | MAP_PRIVATE, 0, 0);

匿名申請一塊0x4000大小的內存

*/   

    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)   

        goto exit;   

    ........

 

ptrace_call_wrapper的代碼：

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;   

}   

ptrace_call函數比較復雜，我們可以看一下代碼：

/*

功能總結：

1，將要執行的指令寫入寄存器中，指令長度大於4個long的話，需要將剩余的指令通過ptrace_writedata函數寫入棧中；

2，使用ptrace_continue函數運行目的進程，直到目的進程返回狀態值0xb7f（對該值的分析見后面紅字）；

3，函數執行完之后，目標進程掛起，使用ptrace_getregs函數獲取當前的所有寄存器值，方便后面使用ptrace_retval函數獲取函數的返回值。

*/

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];   

    }     

    // push remained params onto stack   

    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;  // #define CPSR_T_MASK  ( 1u << 5 )  CPSR為程序狀態寄存器

    } else {   

        /* arm */   

        regs->ARM_cpsr &= ~CPSR_T_MASK;   

    }   

   

    regs->ARM_lr = 0; //設置子程序的返回地址為空，以便函數執行完后，返回到null地址，產生SIGSEGV錯誤，詳細作用見后面的紅字分析

    /*

    *Ptrace_setregs就是將修改后的regs寫入寄存器中，然后調用ptrace_continue來執行我們指定的代碼

    */

    if (ptrace_setregs(pid, regs) == -1 || ptrace_continue(pid) == -1) {  

        printf("error\n");   

        return -1;   

    }   

   

    int stat = 0; 

    waitpid(pid, &stat, WUNTRACED); 

/* WUNTRACED告訴waitpid，如果子進程進入暫停狀態，那么就立即返回。如果是被ptrace的子進程，那么即使不提供WUNTRACED參數，也會在子進程進入暫停狀態的時候立即返回。對於使用ptrace_cont運行的子進程，它會在3種情況下進入暫停狀態：①下一次系統調用；②子進程退出；③子進程的執行發生錯誤。這里的0xb7f就表示子進程進入了暫停狀態，且發送的錯誤信號為11(SIGSEGV)，它表示試圖訪問未分配給自己的內存, 或試圖往沒有寫權限的內存地址寫數據。那么什么時候會發生這種錯誤呢？顯然，當子進程執行完注入的函數后，由於我們在前面設置了regs->ARM_lr = 0，它就會返回到0地址處繼續執行，這樣就會產生SIGSEGV了！

*/   

    while (stat != 0xb7f[w1] ) {  //這個循環是否必須我還不確定。因為目前每次ptrace_call調用必定會返回0xb7f，不過在這也算是增加容錯性吧~

        if (ptrace_continue(pid) == -1) { 

            printf("error\n"); 

            return -1; 

        } 

        waitpid(pid, &stat, WUNTRACED); 

    } 

   

    return 0;   

}

 [w1]通過看ndk的源碼sys/wait.h以及man waitpid可以知道這個0xb7f的具體作用。首先說一下stat的值：高2字節用於表示導致子進程的退出或暫停狀態信號值，低2字節表示子進程是退出(0x0)還是暫停(0x7f)狀態。0xb7f就表示子進程為暫停狀態，導致它暫停的信號量為11即sigsegv錯誤。

 

   

 

其中ptrace_writedata的代碼如下：

/*

Func : 將size字節的data數據寫入到pid進程的dest地址處

@param dest: 目的進程的棧地址

@param data: 需要寫入的數據的起始地址

@param size: 需要寫入的數據的大小，以字節為單位

*/

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;  //很巧妙的聯合體，這樣就可以方便的以字節為單位寫入4字節數據，再以long為單位ptrace_poketext到棧中 

    j = size / 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) {    //為了最大程度的保持原棧的數據，先讀取dest的long數據，然后只更改其中的前remain字節，再寫回

        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;   

}   

總結一下ptrace_call_wrapper，它的完成兩個功能：

一是調用ptrace_call函數來執行指定函數，執行完后將子進程掛起；

二是調用ptrace_getregs函數獲取所有寄存器的值，主要是為了獲取r0即函數的返回值。

 

⑤從寄存器中獲取mmap函數的返回值，即申請的內存首地址：

map_base = ptrace_retval(&regs);

⑥依次獲取linker中dlopen、dlsym、dlclose、dlerror函數的地址:

dlopen_addr = get_remote_addr( target_pid, linker_path, (void *)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 ); 

⑦調用dlopen函數：

/*

①將要注入的so名寫入前面mmap出來的內存

②寫入dlopen代碼

③執行dlopen("libxxx.so", RTLD_NOW ! RTLD_GLOBAL)

RTLD_NOW之類的參數作用可參考：

http://baike.baidu.com/view/2907309.htm?fr=aladdin

④取得dlopen的返回值，存放在sohandle變量中

*/

ptrace_writedata(target_pid, map_base, library_path, strlen(library_path) + 1);   

parameters[0] = map_base;      

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

 

⑧調用dlsym函數：

 /*

等同於hook_entry_addr = (void *)dlsym(sohandle, "hook_entry");

*/

   #define FUNCTION_NAME_ADDR_OFFSET       0x100  //為functionname另找一塊區域 

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

⑨調用hook_entry函數：

/*

hook_entry("I'm parameter!");

*/

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

⑩調用dlclose關閉lib:

/*

等同於dlclose(sohandle);

*/

    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;   

   

⑪恢復現場並退出ptrace:

 

    ptrace_setregs(target_pid, &original_regs);   

    ptrace_detach(target_pid);   

總結

分析完整個注入代碼，學到了很多東西：ptrace(特別是向目的進程的寄存器和棧中寫入參數)，信號量機制，以及在獲取pid、模塊基址時使用的方法等等等等。同時，也注意到這份代碼與看雪論壇古河大大發出的代碼有些許不同：后者是將dlopen,dlsym等函數放在了一個用匯編寫的injectcode.s中，而用C寫的注入代碼僅僅將injectcode.s注入到目標進程中，過后就交由這個injectcode.s來完成后續工作了。顯然，就學習而言，本代碼完全用C語言實現，學習起來簡單易懂，且injectcode.s的編寫難度也大很多。同時需要注意的是，如果采用后者的方法，在注入代碼之前一定得預留部分空間用作函數調用的棧空間：

// 設置遠程代碼存儲空間地址

remote_code_ptr = map_base+0x3C00; // 這里就預留了0x3c00的空間

展望

那注入之后我們到底可以完成什么功能呢？目前，據我了解，大家主要還是用於hook so中的native函數。那么如何hook呢？可以參考這篇文章的NDK HOOK部分：

http://bbs.pediy.com/showthread.php?t=192047