码迷，mamicode.com
首页 > 其他好文 > 详细

使用ptrace向已运行进程中注入.so并执行相关函数

时间：2014-07-16 21:22:15      阅读：186      评论：0      收藏：0      [点我收藏+]

标签：android   des   blog   http   color   使用   

这个总结的很好，从前一个项目也用到这中技术
转自：http://blog.csdn.net/myarrow/article/details/9630377

1. 简介

    使用ptrace向已运行进程中注入.so并执行相关函数，其中的“注入”二字的真正含义为：此.so被link到已运行进程（以下简称为：目标进程）空间中，从而.so中的函数在目标进程空间中有对应的地址，然后通过此地址便可在目标进程中进行调用。

     到底是如何注入的呢？

     本文实现方案为：在目标进程中，通过dlopen把需要注入的.so加载到目标进程的空间中。

2. 如何让目标进程执行dlopen加载.so?

     显然，目标进程本来是没有实现通过dlopen来加载我们想注入的.so，为了实现此功能，我们需要目标进程执行一段我们实现的代码，此段代码的功能为通过dlopen来加载一个.so。

3. 【加载.so的实现代码】

    加载需要注入的.so的实现代码如下所示：     

 

[cpp] view plaincopy
  1. .global _dlopen_addr_s       @dlopen函数在目标进程中的地址     注：以下全局变化在C中可读写  
  2. .global _dlopen_param1_s     @dlopen参数1<.so>在目标进程中的地址   
  3. .global _dlopen_param2_s     @dlopen参数2在目标进程中的地址  
  4.   
  5. .global _dlsym_addr_s        @dlsym函数在目标进程中的地址  
  6. .global _dlsym_param2_s      @dlsym参数2在目标进程中的地址，其实为函数名  
  7.   
  8. .global _dlclose_addr_s      @dlcose在目标进程中的地址  
  9.   
  10. .global _inject_start_s      @汇编代码段的起始地址  
  11. .global _inject_end_s        @汇编代码段的结束地址  
  12.   
  13. .global _inject_function_param_s  @hook_init参数在目标进程中的地址  
  14.   
  15. .global _saved_cpsr_s        @保存CPSR，以便执行完hook_init之后恢复环境  
  16. .global _saved_r0_pc_s       @保存r0-r15，以便执行完hook_init之后恢复环境  
  17.   
  18.   
  19. .data  
  20.   
  21. _inject_start_s:  
  22.     @ debug loop  
  23. 3:  
  24.     @sub r1, r1, #0  
  25.     @B 3b  
  26.   
  27.     @ dlopen  
  28.     ldr r1, _dlopen_param2_s        @设置dlopen第二个参数, flag  
  29.     ldr r0, _dlopen_param1_s        @设置dlopen第一个参数 .so  
  30.     ldr r3, _dlopen_addr_s          @设置dlopen函数  
  31.     blx r3                          @执行dlopen函数,返回值位于r0中  
  32.     subs r4, r0, #0                 @把dlopen的返回值soinfo保存在r4中，以方便后面dlclose使用  
  33.     beq 2f  
  34.   
  35.     @dlsym  
  36.     ldr r1, _dlsym_param2_s        @设置dlsym第二个参数，第一个参数已经在r0中了  
  37.     ldr r3, _dlsym_addr_s          @设置dlsym函数  
  38.     blx r3                         @执行dlsym函数，返回值位于r0中  
  39.     subs r3, r0, #0                @把返回值<hook_init在目标进程中的地址>保存在r3中  
  40.     beq 1f  
  41.   
  42.     @call our function  
  43.     ldr r0, _inject_function_param_s  @设置hook_init第一个参数  
  44.         blx r3                            @执行hook_init  
  45.     subs r0, r0, #0  
  46.     beq 2f  
  47.   
  48. 1:  
  49.     @dlclose                          
  50.     mov r0, r4                        @把dlopen的返回值设为dlcose的第一个参数  
  51.     ldr r3, _dlclose_addr_s           @设置dlclose函数  
  52.     blx r3                            @执行dlclose函数  
  53.   
  54. 2:  
  55.     @restore context  
  56.     ldr r1, _saved_cpsr_s             @恢复CPSR  
  57.     msr cpsr_cf, r1  
  58.     ldr sp, _saved_r0_pc_s            @恢复寄存器r0-r15  
  59.     ldmfd sp, {r0-pc}  
  60.       
  61.   
  62.       
  63.   
  64. _dlopen_addr_s:                           @初始化_dlopen_addr_s  
  65. .word 0x11111111  
  66.   
  67. _dlopen_param1_s:  
  68. .word 0x11111111  
  69.   
  70. _dlopen_param2_s:  
  71. .word 0x2                                 @RTLD_GLOBAL  
  72.   
  73. _dlsym_addr_s:  
  74. .word 0x11111111  
  75.   
  76. _dlsym_param2_s:  
  77. .word 0x11111111  
  78.   
  79. _dlclose_addr_s:  
  80. .word 0x11111111  
  81.   
  82. _inject_function_param_s:  
  83. .word 0x11111111  
  84.   
  85. _saved_cpsr_s:  
  86. .word 0x11111111  
  87.   
  88. _saved_r0_pc_s:  
  89. .word 0x11111111  
  90.   
  91.   
  92. _inject_end_s:                     @代码结束地址  
  93.   
  94. .space 0x400, 0                    @代码段空间大小  
  95.   
  96. .end  

4. 如何把【加载.so的实现代码】写入目标进程并启动执行？

   为了把【加载.so的实现代码】写入目标进程，主要有以下两步操作：

   1) 在目标进程中找到存放【加载.so的实现代码】的空间(通过mmap实现)

   2) 把【加载.so的实现代码】写入目标进程指定的空间

   3) 启动执行

4.1 在目标进程中找到存放【加载.so的实现代码】的空间

    通过mmap来实现，其实现步骤如下：

   1) 获取目标进程中mmap地址
   2) 把mmap参数据放入r0-r3,另外两个写入目标进程sp 
   3) pc设置为mmap地址，lr设置为0
   4) 把准备好的寄存器写入目标进程(PTRACE_SETREGS),并启动目标进程运行(PTRACE_CONT)
   5) 分配的内存首地址位于r0 (PTRACE_GETREGS)

4.2 为【加载.so的实现代码】中的全局变量赋值

   1) 获取目标进程中dlopen地址并赋值给_dlopen_addr_s

   2) 获取目标进程中dlsym地址并赋值给_dlsym_addr_s

   3) 获取目标进程中dlclose地址并赋值给_dlclose_addr_s

   4) 把需要加载的.so的路径放入 汇编代码中，并获取此路径在目标进程中的地址然后赋值给_dlopen_param1_s

   5) 把需要加载的.so中的hook_init放入 汇编代码中，并获取此路径在目标进程中的地址然后赋值给_dlsym_param2_s

   6) 把目标进程中的cpsr保存在_saved_cpsr_s中

   7) 把目标进程中的r0-r15存入汇编代码中，并获取此变量在目标进程中的地址然后赋值给_saved_r0_pc_s

   8) 通过ptrace( PTRACE_POKETEXT,...)把汇编代码写入目标进程中，起始地址由前面的mmap所分配

   9) 把目标进程的pc设置为汇编代码的起始地址，然后调用ptrace(PTRACE_DETACH,...)以启动目标进程执行

5. 把汇编代码写入目标进程并执行的实现代码

5.1 主函数 writecode_to_targetproc

[cpp] view plaincopy
  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <asm/ptrace.h>  
  4. #include <asm/user.h>  
  5. #include <asm/ptrace.h>  
  6. #include <sys/wait.h>  
  7. #include <sys/mman.h>  
  8. #include <dlfcn.h>  
  9. #include <dirent.h>  
  10. #include <unistd.h>  
  11. #include <string.h>  
  12. #include <android/log.h>  
  13. #include <sys/types.h>  
  14. #include <sys/socket.h>  
  15. #include <netinet/in.h>  
  16. #include <sys/stat.h>  
  17.   
  18. #define MAX_PATH 0x100  
  19. #define REMOTE_ADDR( addr, local_base, remote_base ) ( (uint32_t)(addr) + (uint32_t)(remote_base) - (uint32_t)(local_base) )  
  20.   
  21. /* write the assembler code into target proc, 
  22.  * and invoke it to execute 
  23.  */  
  24. int writecode_to_targetproc(   
  25.     pid_t target_pid, // target process pid  
  26.     const char *library_path, // the path of .so that will be   
  27.                               // upload to target process   
  28.     const char *function_name, // .so init fucntion e.g. hook_init  
  29.     void *param, // the parameters of init function  
  30.     size_t param_size ) // number of parameters   
  31. {  
  32.     int ret = -1;  
  33.     void *mmap_addr, *dlopen_addr, *dlsym_addr, *dlclose_addr;  
  34.     void *local_handle, *remote_handle, *dlhandle;  
  35.     uint8_t *map_base;  
  36.     uint8_t *dlopen_param1_ptr, *dlsym_param2_ptr, *saved_r0_pc_ptr, *inject_param_ptr, *remote_code_ptr, *local_code_ptr;  
  37.   
  38.     struct pt_regs regs, original_regs;  
  39.   
  40.     // extern global variable in the assembler code   
  41.     extern uint32_t _dlopen_addr_s, _dlopen_param1_s, _dlopen_param2_s, \  
  42.             _dlsym_addr_s, _dlsym_param2_s, _dlclose_addr_s, \  
  43.             _inject_start_s, _inject_end_s, _inject_function_param_s, \  
  44.             _saved_cpsr_s, _saved_r0_pc_s;  
  45.   
  46.     uint32_t code_length;  
  47.   
  48.     long parameters[10];  
  49.   
  50.     // make target_pid as its child process and stop  
  51.     if ( ptrace_attach( target_pid ) == -1 )  
  52.         return -1;  
  53.   
  54.     // get the values of 18 registers from target_pid  
  55.     if ( ptrace_getregs( target_pid, ®s ) == -1 )  
  56.         goto exit;  
  57.   
  58.     // save original registers   
  59.     memcpy( &original_regs, ®s, sizeof(regs) );  
  60.   
  61.     // get mmap address from target_pid  
  62.     // the mmap is the address of mmap in the cur process  
  63.     mmap_addr = get_remote_addr( target_pid, "/system/lib/libc.so", (void *)mmap );  
  64.   
  65.     // set mmap parameters  
  66.     parameters[0] = 0;  // addr  
  67.     parameters[1] = 0x4000; // size  
  68.     parameters[2] = PROT_READ | PROT_WRITE | PROT_EXEC;  // prot  
  69.     parameters[3] =  MAP_ANONYMOUS | MAP_PRIVATE; // flags  
  70.     parameters[4] = 0; //fd  
  71.     parameters[5] = 0; //offset  
  72.   
  73.     // execute the mmap in target_pid  
  74.     if ( ptrace_call( target_pid, (uint32_t)mmap_addr, parameters, 6, ®s ) == -1 )  
  75.         goto exit;  
  76.   
  77.     // get the return values of mmap <in r0>  
  78.     if ( ptrace_getregs( target_pid, ®s ) == -1 )  
  79.         goto exit;  
  80.   
  81.     // get the start address for assembler code  
  82.     map_base = (uint8_t *)regs.ARM_r0;  
  83.   
  84.     // get the address of dlopen, dlsym and dlclose in target process  
  85.     dlopen_addr = get_remote_addr( target_pid, "/system/bin/linker", (void *)dlopen );  
  86.     dlsym_addr = get_remote_addr( target_pid, "/system/bin/linker", (void *)dlsym );  
  87.     dlclose_addr = get_remote_addr( target_pid, "/system/bin/linker", (void *)dlclose );  
  88.   
  89.     // set the start address for assembler code in target process  
  90.     remote_code_ptr = map_base + 0x3C00;  
  91.   
  92.     // set the start address for assembler code in cur process  
  93.     local_code_ptr = (uint8_t *)&_inject_start_s;  
  94.   
  95.     // set global variable of assembler code  
  96.     // and these address is in the target process  
  97.     _dlopen_addr_s = (uint32_t)dlopen_addr;  
  98.     _dlsym_addr_s = (uint32_t)dlsym_addr;  
  99.     _dlclose_addr_s = (uint32_t)dlclose_addr;  
  100.   
  101.     code_length = (uint32_t)&_inject_end_s - (uint32_t)&_inject_start_s;  
  102.       
  103.     dlopen_param1_ptr = local_code_ptr + code_length + 0x20;  
  104.     dlsym_param2_ptr = dlopen_param1_ptr + MAX_PATH;  
  105.     saved_r0_pc_ptr = dlsym_param2_ptr + MAX_PATH;  
  106.     inject_param_ptr = saved_r0_pc_ptr + MAX_PATH;  
  107.   
  108.   
  109.     // save library path to assembler code global variable  
  110.     strcpy( dlopen_param1_ptr, library_path );  
  111.     _dlopen_param1_s = REMOTE_ADDR( dlopen_param1_ptr, local_code_ptr, remote_code_ptr );  
  112.       
  113.   
  114.     // save function name to assembler code global variable  
  115.     strcpy( dlsym_param2_ptr, function_name );  
  116.     _dlsym_param2_s = REMOTE_ADDR( dlsym_param2_ptr, local_code_ptr, remote_code_ptr );  
  117.   
  118.     // save cpsr to assembler code global variable  
  119.     _saved_cpsr_s = original_regs.ARM_cpsr;  
  120.   
  121.     // save r0-r15 to assembler code global variable  
  122.     memcpy( saved_r0_pc_ptr, &(original_regs.ARM_r0), 16 * 4 ); // r0 ~ r15  
  123.     _saved_r0_pc_s = REMOTE_ADDR( saved_r0_pc_ptr, local_code_ptr, remote_code_ptr );  
  124.   
  125.     // save function parameters to assembler code global variable  
  126.     memcpy( inject_param_ptr, param, param_size );  
  127.     _inject_function_param_s = REMOTE_ADDR( inject_param_ptr, local_code_ptr, remote_code_ptr );  
  128.   
  129.     // write the assembler code into target process  
  130.     // now the values of global variable is in the target process space  
  131.     ptrace_writedata( target_pid, remote_code_ptr, local_code_ptr, 0x400 );  
  132.   
  133.     memcpy( ®s, &original_regs, sizeof(regs) );  
  134.   
  135.     // set sp and pc to the start address of assembler code  
  136.     regs.ARM_sp = (long)remote_code_ptr;  
  137.     regs.ARM_pc = (long)remote_code_ptr;  
  138.   
  139.     // set registers for target process  
  140.     ptrace_setregs( target_pid, ®s );  
  141.   
  142.     // make the target_pid is not a child process of cur process  
  143.     // and make target_pid continue to running  
  144.     ptrace_detach( target_pid );  
  145.   
  146.     // now finish it successfully  
  147.     ret = 0;  
  148.   
  149. exit:  
  150.     return ret;  
  151. }  

5.2 attach目标进程ptrace_attach

 

 

[cpp] view plaincopy
  1. int ptrace_attach( pid_t pid )  
  2. {  
  3.     // after PTRACE_ATTACH, the proc<pid> will stop  
  4.     if ( ptrace( PTRACE_ATTACH, pid, NULL, 0  ) < 0 )  
  5.     {  
  6.         perror( "ptrace_attach" );  
  7.         return -1;  
  8.     }  
  9.   
  10.     // wait proc<pid> stop  
  11.     waitpid( pid, NULL, WUNTRACED );  
  12.   
  13.     // after PTRACE_SYSCALL, the proc<pid> will continue,  
  14.     // but when exectue sys call function, proc<pid> will stop  
  15.     if ( ptrace( PTRACE_SYSCALL, pid, NULL, 0  ) < 0 )  
  16.     {  
  17.         perror( "ptrace_syscall" );  
  18.         return -1;  
  19.     }  
  20.   
  21.     // wait proc<pid> stop  
  22.     waitpid( pid, NULL, WUNTRACED );  
  23.   
  24.     return 0;  
  25. }  

5.3 获取目标进程寄存器值ptrace_getregs

 

 

[cpp] view plaincopy
  1. int ptrace_getregs( pid_t pid, struct pt_regs* regs )  
  2. {  
  3.     if ( ptrace( PTRACE_GETREGS, pid, NULL, regs ) < 0 )  
  4.     {  
  5.         perror( "ptrace_getregs: Can not get register values" );  
  6.         return -1;  
  7.     }  
  8.   
  9.     return 0;  
  10. }  


 

5.4 获取目标进程中指定模块中指定函数的地址get_remote_addr

 

[cpp] view plaincopy
  1.    
  2. /* find the start address of module whose name is module_name  
  3.  * in the designated process 
  4.  */  
  5. void* get_module_base( pid_t pid, const char* module_name )  
  6. {  
  7.     FILE *fp;  
  8.     long addr = 0;  
  9.     char *pch;  
  10.     char filename[32];  
  11.     char line[1024];  
  12.   
  13.     if ( pid < 0 )  
  14.     {  
  15.         /* self process */  
  16.         snprintf( filename, sizeof(filename), "/proc/self/maps", pid );  
  17.     }  
  18.     else  
  19.     {  
  20.         snprintf( filename, sizeof(filename), "/proc/%d/maps", pid );  
  21.     }  
  22.   
  23.     fp = fopen( filename, "r" );  
  24.   
  25.     if ( fp != NULL )  
  26.     {  
  27.         while ( fgets( line, sizeof(line), fp ) )  
  28.         {  
  29.             if ( strstr( line, module_name ) )  
  30.             {  
  31.                 pch = strtok( line, "-" );  
  32.                 addr = strtoul( pch, NULL, 16 );  
  33.   
  34.                 if ( addr == 0x8000 )  
  35.                     addr = 0;  
  36.   
  37.                 break;  
  38.             }  
  39.         }  
  40.         fclose( fp ) ;  
  41.     }  
  42.   
  43.     return (void *)addr;  
  44. }  
  45.   
  46. void* get_remote_addr( pid_t target_pid, const char* module_name, void* local_addr )  
  47. {  
  48.     void* local_handle, *remote_handle;  
  49.   
  50.     local_handle = get_module_base( -1, module_name );  
  51.     remote_handle = get_module_base( target_pid, module_name );  
  52.   
  53.     return (void *)( (uint32_t)local_addr + (uint32_t)remote_handle - (uint32_t)local_handle );  
  54. }  

 

 

5.5 在目标进程中执行指定函数ptrace_call

 

[cpp] view plaincopy
  1. int ptrace_call( pid_t pid, uint32_t addr, long *params, uint32_t num_params, struct pt_regs* regs )  
  2. {  
  3.     uint32_t i;  
  4.   
  5.     // put the first 4 parameters into r0-r3  
  6.     for ( i = 0; i < num_params && i < 4; i ++ )  
  7.     {  
  8.         regs->uregs[i] = params[i];  
  9.     }  
  10.   
  11.     // push remained params into stack  
  12.     if ( i < num_params )  
  13.     {  
  14.         regs->ARM_sp -= (num_params - i) * sizeof(long) ;  
  15.         ptrace_writedata( pid, (void *)regs->ARM_sp, (uint8_t *)¶ms[i], (num_params - i) * sizeof(long) );  
  16.     }  
  17.     // set the pc to func <e.g: mmap> that will be executed  
  18.     regs->ARM_pc = addr;  
  19.     if ( regs->ARM_pc & 1 )  
  20.     {  
  21.         /* thumb */  
  22.         regs->ARM_pc &= (~1u);  
  23.         regs->ARM_cpsr |= CPSR_T_MASK;  
  24.     }  
  25.     else  
  26.     {  
  27.         /* arm */  
  28.         regs->ARM_cpsr &= ~CPSR_T_MASK;  
  29.     }  
  30.   
  31.     // when finish this func, pid will stop  
  32.     regs->ARM_lr = 0;      
  33.   
  34.     // set the regsister and start to execute  
  35.     if ( ptrace_setregs( pid, regs ) == -1   
  36.         || ptrace_continue( pid ) == -1 )  
  37.     {  
  38.         return -1;  
  39.     }  
  40.   
  41.     // wait pid finish work and stop  
  42.     waitpid( pid, NULL, WUNTRACED );  
  43.   
  44.     return 0;  
  45. }  

5.6 把代码写入目标进程指定地址ptrace_writedata

 

 

[cpp] view plaincopy
  1. int ptrace_writedata( pid_t pid, uint8_t *dest, uint8_t *data, size_t size )  
  2. {  
  3.     uint32_t i, j, remain;  
  4.     uint8_t *laddr;  
  5.   
  6.     union u {  
  7.         long val;  
  8.         char chars[sizeof(long)];  
  9.     } d;  
  10.   
  11.     j = size / 4;  
  12.     remain = size % 4;  
  13.   
  14.     laddr = data;  
  15.   
  16.     for ( i = 0; i < j; i ++ )  
  17.     {  
  18.         memcpy( d.chars, laddr, 4 );  
  19.         ptrace( PTRACE_POKETEXT, pid, dest, d.val );  
  20.   
  21.         dest  += 4;  
  22.         laddr += 4;  
  23.     }  
  24.   
  25.     if ( remain > 0 )  
  26.     {  
  27.         d.val = ptrace( PTRACE_PEEKTEXT, pid, dest, 0 );  
  28.         for ( i = 0; i < remain; i ++ )  
  29.         {  
  30.             d.chars[i] = *laddr ++;  
  31.         }  
  32.   
  33.         ptrace( PTRACE_POKETEXT, pid, dest, d.val );  
  34.           
  35.     }  
  36.   
  37.     return 0;  
  38. }  

 

 

5.7 设置目标进程寄存器ptrace_setregs

 

[cpp] view plaincopy
  1. int ptrace_setregs( pid_t pid, struct pt_regs* regs )  
  2. {  
  3.     if ( ptrace( PTRACE_SETREGS, pid, NULL, regs ) < 0 )  
  4.     {  
  5.         perror( "ptrace_setregs: Can not set register values" );  
  6.         return -1;  
  7.     }  
  8.   
  9.     return 0;  
  10. }  

 

 

5.8 detach目标进程ptrace_detach

 

[cpp] view plaincopy
  1. int ptrace_detach( pid_t pid )  
  2. {  
  3.     if ( ptrace( PTRACE_DETACH, pid, NULL, 0 ) < 0 )  
  4.     {  
  5.         perror( "ptrace_detach" );  
  6.         return -1;  
  7.     }  
  8.   
  9.     return 0;  
  10. }  


6.  需要被加载的.so

    需要被加载的.so例子程序如下，其目的是替换目标进程libapp.so中的strlen函数。其主要实现见hook_init。

 

[cpp] view plaincopy
  1. int g_isInit = 0;      
  2. pthread_t g_hThread;       
  3.   
  4. __attribute__((visibility("default"))) void hook_init( char *args )  
  5. {  
  6.    if( g_isInit == 1 )  
  7.    {  
  8.       printf("i am already in!");  
  9.       return;  
  10.    }  
  11.   
  12.    void* soHandle = NULL;  
  13.      
  14.    // the libapp.so is a .so of target process, and it call strcmp  
  15.    soHandle  = dlopen( "libapp.so", RTLD_GLOBAL );  
  16.    if( soHandle != NULL )  
  17.    {  
  18.       g_realstrcmp = NULL;  
  19.       replaceFunc( soHandle, "strcmp", my_strcmp, (void**)&g_realstrcmp );  
  20.         
  21.       int ret = pthread_create( &g_hThread, NULL, my_thread, NULL );  
  22.       if( ret != 0 )  
  23.       {  
  24.          printf("create thread error:%d", ret );  
  25.       }  
  26.         
  27.       g_isInit = 1;  
  28.    }  
  29.      
  30. }  

 

6.1 替换函数replaceFunc

 

 

[cpp] view plaincopy
  1. // replace function of libapp.so  
  2. // e.g: replace strcmp of libapp.so with my_strcmp  
  3. void replaceFunc(void *handle,const char *name, void* pNewFun, void** pOldFun )  
  4. {  
  5.   
  6.    if(!handle)  
  7.       return;  
  8.         
  9.    soinfo *si = (soinfo*)handle;     
  10.    Elf32_Sym *symtab = si->symtab;    
  11.    const char *strtab = si->strtab;    
  12.    Elf32_Rel *rel = si->plt_rel;  
  13.    unsigned count = si->plt_rel_count;   
  14.    unsigned idx;   
  15.   
  16.    // these external functions that are called by libapp.so   
  17.    // is in the plt_rel  
  18.    for(idx=0; idx<count; idx++)   
  19.    {    
  20.       unsigned type = ELF32_R_TYPE(rel->r_info);    
  21.       unsigned sym = ELF32_R_SYM(rel->r_info);    
  22.       unsigned reloc = (unsigned)(rel->r_offset + si->base);    
  23.       char *sym_name = (char *)(strtab + symtab[sym].st_name);   
  24.         
  25.       if(strcmp(sym_name, name)==0)   
  26.       {   
  27.          *pOldFun = (void *)*((unsigned*)reloc);   
  28.           *((unsigned*)reloc)= pNewFun;  
  29.          break;  
  30.       }   
  31.       rel++;    
  32.    }   
  33. }  

 

6.2 新函数及其它函数

 

 

[cpp] view plaincopy
  1. // global function variable, save the address of strcmp of libapp.so  
  2. int (*g_realstrcmp)(const char *s1, const char *s2);  
  3.   
  4. // my strcmp function  
  5. int my_strcmp(const char *s1, const char *s2)  
  6. {  
  7.     if( g_realstrcmp != NULL )  
  8.     {  
  9.         int nRet = g_realstrcmp( s1, s2 );  
  10.         printf("***%s: s1=%s, s2=%s\n",__FUNCTION__, s1, s2 );  
  11.         return nRet;  
  12.     }  
  13.   
  14.     return -1;  
  15. }  
  16.   
  17.   
  18. // create a thread  
  19. void* my_thread( void* pVoid )  
  20. {  
  21.     int sock;  
  22.     sock = socket(AF_INET, SOCK_DGRAM, 0);  
  23.     if( sock < -1 )  
  24.     {  
  25.       printf("create socket failed!\n");  
  26.       return 0;  
  27.     }  
  28.   
  29.     struct sockaddr_in addr_serv;    
  30.     int len;    
  31.     memset(&addr_serv, 0, sizeof(struct sockaddr_in));    
  32.     addr_serv.sin_family = AF_INET;    
  33.     addr_serv.sin_port = htons(9999);     
  34.     addr_serv.sin_addr.s_addr = inet_addr("127.0.0.1");    
  35.     len = sizeof(addr_serv);    
  36.   
  37.     int flags = fcntl( sock, F_GETFL, 0);   
  38.     fcntl( sock, F_SETFL, flags | O_NONBLOCK);  
  39.     int nPreState = -1;  
  40.     unsigned char data=0;  
  41.     while( 1 )  
  42.     {  
  43.         data++;  
  44.         sendto( sock, &data,  sizeof( data ), 0, (struct sockaddr *)&addr_serv, sizeof( addr_serv ) );  
  45.         usleep( 30000 );  
  46.     }  
  47. }  

使用ptrace向已运行进程中注入.so并执行相关函数,布布扣,bubuko.com

使用ptrace向已运行进程中注入.so并执行相关函数

标签：android   des   blog   http   color   使用   

原文地址：http://www.cnblogs.com/fly-fish/p/3835958.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！