一直不明白 hook 与 注入 有什么区别，关系

注入跟hook确实有密不可分的联系，我们通常都是把这两者放到一起来谈，导致很多人认为它们是一回事。应用安全里面有一个概念叫完整性，指的是程序或数据不能被攻击者恶意篡改。根据篡改时刻的不同，我们有两类方式来破坏应用的完整性：静态和动态。在安卓上，静态的篡改方式是反编译apk，修改或添加代码后重打包，用户只要安装了这个修改过的apk，运行时攻击者的代码就会被加载到进程空间。动态的篡改方法就是hook。如果我要篡改代码，那么我要实现的就是在程序将要执行某段逻辑的时候控制它去执行我的代码，这个行为就叫hook。一个运行时的程序表现形式是进程，代码跟数据都放在自己的进程里面。那么问题来了， *** 作系统隔离了进程，我的代码在我的进程里，别人的代码在别人的进程里，别人的进程是不能跳到我的进程来执行我的代码的，这怎么办呢，所以要先想办法把代码注入到别人的进程里。之前提到的重打包也算是一种静态的注入方法，动态的注入方法在安卓上与Linux的共享库注入是类似的，这种方法网上用的最多的应该是看雪的古河发布的libinject。另外还有Xposed，它采取了一种特殊的注入方法，是动静结合的。

有啊，一切顺序逻辑，都有被hook的可能。 下面是一个linux上的hook的实例

截获write系统调用:

#ifndef MODULE

#define MODULE

#endif

                                                                              

#ifndef __KERNEL__

#define __KERNEL__

#endif 

#include <linux/init.h>

#include <linux/module.h>

#include <linux/version.h>

#include <linux/kernel.h>

#include <asm/unistd.h>

#include <linux/slab.h>

/*

#include <sys/types.h>

#include <asm/fcntl.h>

#include <linux/malloc.h>

#include <linux/types.h>

#include <linux/string.h>

#include <linux/fs.h>

#include <asm/errno.h> 

#include <sys/syscall.h>

*/ 

MODULE_LICENSE("GPL")

struct descriptor_idt

{

        unsigned short offset_low

        unsigned short ignore1

        unsigned short ignore2

        unsigned short offset_high

}

static struct {

        unsigned short limit

        unsigned long base

}__attribute__ ((packed)) idt48

static unsigned int SYS_CALL_TABLE_ADDR

void **sys_call_table

int base_system_call

int (*orig_write)(unsigned int fd,char *buf,unsigned int count)

unsigned char opcode_call[3]={0xff,0x14,0x85}

int match(unsigned char *source)

{

        int i

        for(i=0i<3i++){

                if(source[i] != opcode_call[i])

                        return 0

        }

        return 1

}

int get_sys_call_table(void)

{

        int i,j

        unsigned char *ins=(unsigned char *)base_system_call

        unsigned int sct

                                                                              

        for(i=0i<100i++){

                if(ins[i]==opcode_call[0]){

                        if(match(ins+i)){

                                sct=*((unsigned int *)(ins+3+i))

                                printk(KERN_ALERT "sys_call_tabl's address is

0x%X\n",sct)

                                return sct

                        }

                }

        }

                                                                              

        printk(KERN_ALERT "can't find the address of sys_call_table\n")

        return -1

}

int hacked_write(unsigned int fd,char *buf,unsigned int count)

{ 

 char *hide="hello"

 if(strstr(buf,hide)!=NULL){

  printk(KERN_ALERT "find name.\n")

  return count

 }

 else{

  return orig_write(fd,buf,count)

 }

}

int init_module(void)

{

        __asm__ volatile ("sidt %0": "=m" (idt48))

        struct descriptor_idt *pIdt80 = (struct descriptor_idt *)(idt48.base + 8*0x80)

        base_system_call = (pIdt80->offset_high<<16 | pIdt80->offset_low)

        printk(KERN_ALERT "system_call address at 0x%x\n",base_system_call)

 SYS_CALL_TABLE_ADDR=get_sys_call_table()

 sys_call_table=(void **)SYS_CALL_TABLE_ADDR

 orig_write=sys_call_table[__NR_write]

 sys_call_table[__NR_write]=hacked_write

        return 0

}

void cleanup_module()

{

 sys_call_table[__NR_write]=orig_write

}

---