http://xiaonieblog.com/?post=121http://hbprotoss.github.io/posts/li-yong-ld_preloadjin-xing-hook.htmlhttp://www.catonmat.net/blog/simple-ld-preload-tutorial/http://os.51cto.com/art/201004/195510.htmhttp://sebug.net/paper/pst_WebZine/pst_WebZine_0x03/html/%5BPSTZine%200x03%5D%5B0x03%5D%5B%E9%AB%98%E7%BA%A7Linux%20Kernel%20Inline%20Hook%E6%8A%80%E6%9C%AF%E5%88%86%E6%9E%90%E4%B8%8E%E5%AE%9E%E7%8E%B0%5D.htmlhttp://blog.chinaunix.net/uid-26310563-id-3175021.htmlhttp://laokaddk.blog.51cto.com/368606/d-26/p-2http://m.blog.csdn.net/blog/panfengyun12345/19480567https://www.kernel.org/doc/Documentation/kprobes.txthttp://blog.chinaunix.net/uid-23769728-id-3198044.htmlhttps://sourceware.org/systemtap/http://alanwu.blog.51cto.com/3652632/1111213http://laokaddk.blog.51cto.com/368606/421862http://www.elliotbradbury.com/linux-syscall-hooking-interrupt-descriptor-table/http://baike.baidu.com/view/336501.htmhttp://blog.csdn.net/dog250/article/details/6451762http://blog.csdn.net/sanbailiushiliuye/article/details/7552359

1. 系统调用Hook简介2. Ring3中Hook技术3. Ring0中Hook技术4. 后记

1. Windows下通过修改import table来hook API2. PHP中修改functions_table来hook function

#include <stdio.h>#include <string.h>int main(int argc, char *argv[]){    if( strcmp(argv[1], "test") )    {        printf("Incorrect password\n");    }    else    {        printf("Correct password\n");    }    return 0;}

#include <stdio.h>#include <string.h>#include <dlfcn.h>/*hook的目标是strcmp，所以typedef了一个STRCMP函数指针hook的目的是要控制函数行为，从原库libc.so.6中拿到strcmp指针，保存成old_strcmp以备调用*/typedef int(*STRCMP)(const char*, const char*);int strcmp(const char *s1, const char *s2){    static void *handle = NULL;    static STRCMP old_strcmp = NULL;    if( !handle )    {        handle = dlopen("libc.so.6", RTLD_LAZY);        old_strcmp = (STRCMP)dlsym(handle, "strcmp");    }    printf("oops!!! hack function invoked. s1=<%s> s2=<%s>\n", s1, s2);    return old_strcmp(s1, s2);}

gcc -o test main.cgcc -fPIC -shared -o hook.so hook.c -ldl

LD_PRELOAD=./hook.so ./test 123

asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count){        struct file *file;        ssize_t ret = -EBADF;        int fput_needed;        file = fget_light(fd, &fput_needed);        if (file)     {                loff_t pos = file_pos_read(file);                ret = vfs_read(file, buf, count, &pos);                file_pos_write(file, pos);                fput_light(file, fput_needed);        }        return ret;}EXPORT_SYMBOL_GPL(sys_read);

1. 搜索sys_read的opcode2. 如果发现是call指令，根据call后面的offset计算要跳转的地址是不是我们要hook的函数地址    1) 如果"不是"就重新计算Hook函数的offset，用Hook函数的offset替换原来的offset    2) 如果"已经是"Hook函数的offset，则说明函数已经处于被劫持状态了，我们的Hook引擎应该直接忽略跳过，避免重复劫持

/*参数：1. handler是上层函数的地址，这里就是sys_read的地址2. old_func是要替换的函数地址，这里就是vfs_read3. new_func是新函数的地址，这里就是new_vfs_read的地址*/unsigned int patch_kernel_func(unsigned int handler, unsigned int old_func,         unsigned int new_func){    unsigned char *p = (unsigned char *)handler;    unsigned char buf[4] = "\x00\x00\x00\x00";    unsigned int offset = 0;    unsigned int orig = 0;    int i = 0;    DbgPrint("\n*** hook engine: start patch func at: 0x%08x\n", old_func);    while (1) {        if (i > 512)            return 0;        if (p[0] == 0xe8) {            DbgPrint("*** hook engine: found opcode 0x%02x\n", p[0]);                        DbgPrint("*** hook engine: call addr: 0x%08x\n",                 (unsigned int)p);            buf[0] = p[1];            buf[1] = p[2];            buf[2] = p[3];            buf[3] = p[4];            DbgPrint("*** hook engine: 0x%02x 0x%02x 0x%02x 0x%02x\n",                 p[1], p[2], p[3], p[4]);                offset = *(unsigned int *)buf;                DbgPrint("*** hook engine: offset: 0x%08x\n", offset);                orig = offset + (unsigned int)p + 5;                DbgPrint("*** hook engine: original func: 0x%08x\n", orig);            if (orig == old_func) {                DbgPrint("*** hook engine: found old func at"                    " 0x%08x\n",                     old_func);                DbgPrint("%d\n", i);                break;            }        }        p++;        i++;    }    offset = new_func - (unsigned int)p - 5;    DbgPrint("*** hook engine: new func offset: 0x%08x\n", offset);    p[1] = (offset & 0x000000ff);    p[2] = (offset & 0x0000ff00) >> 8;    p[3] = (offset & 0x00ff0000) >> 16;    p[4] = (offset & 0xff000000) >> 24;    DbgPrint("*** hook engine: pachted new func offset.\n");    return orig;} 

1. 获取中断描述符表(IDT)的地址(使用C ASM汇编)2. 从中查找0x80中断(系统调用中断)的服务例程(8*0x80偏移)3. 搜索该例程的内存空间，4. 从其中获取sys_call_table(保存所有系统调用例程的入口地址)的地址

#include <linux/module.h>#include <linux/kernel.h>// 中断描述符表寄存器结构struct {    unsigned short limit;    unsigned int base;} __attribute__((packed)) idtr;// 中断描述符表结构struct {    unsigned short off1;    unsigned short sel;    unsigned char none, flags;    unsigned short off2;} __attribute__((packed)) idt;// 查找sys_call_table的地址void disp_sys_call_table(void){    unsigned int sys_call_off;    unsigned int sys_call_table;    char* p;    int i;    // 获取中断描述符表寄存器的地址    asm("sidt %0":"=m"(idtr));    printk("addr of idtr: %x\n", &idtr);    // 获取0x80中断处理程序的地址    memcpy(&idt, idtr.base+8*0x80, sizeof(idt));    sys_call_off=((idt.off2<<16)|idt.off1);    printk("addr of idt 0x80: %x\n", sys_call_off);    // 从0x80中断服务例程中搜索sys_call_table的地址    p=sys_call_off;    for (i=0; i<100; i++)    {        if (p==‘\xff‘ && p[i+1]==‘\x14‘ && p[i+2]==‘\x85‘)        {            sys_call_table=*(unsigned int*)(p+i+3);            printk("addr of sys_call_table: %x\n", sys_call_table);            return ;        }    }}// 模块载入时被调用static int __init init_get_sys_call_table(void){    disp_sys_call_table();    return 0;}module_init(init_get_sys_call_table);// 模块卸载时被调用static void __exit exit_get_sys_call_table(void){}module_exit(exit_get_sys_call_table);// 模块信息MODULE_LICENSE("GPL2.0");MODULE_AUTHOR("LittleHann");

obj-m := find_sys_call_table.o  

make -C /usr/src/kernels/2.6.32-358.el6.i686 M=$(pwd) modules

#include <stdio.h>void fun1(){        printf("fun1/n");}void fun2(){        printf("fun2/n");}unsigned int sys_call_table[2] = {fun1, fun2};int main(int argc, char **argv){        asm("call *sys_call_table(%eax,4");}编译gcc test.c -o testobjdump进行dumpobjdump -D ./test | grep sys_call_table

cd /bootgrep sys_call_table System.map-2.6.32-358.el6.i686

1. 用户指定一个探测点，并把一个用户定义的处理函数关联到该探测点2. 在注册探测点的时候，对被探测函数的指令码进行替换，替换为int 3的指令码3. 在执行int 3的异常执行中，通过通知链的方式调用kprobe的异常处理函数4. 在kprobe的异常出来函数中，判断是否存在pre_handler钩子，存在则执行5. 执行完后，准备进入单步调试，通过设置EFLAGS中的TF标志位，并且把异常返回的地址修改为保存的原指令码6. 代码返回，执行原有指令，执行结束后触发单步异常7. 在单步异常的处理中，清除单步标志，执行post_handler流程，并最终返回 

1. kprobeskprobes是可以被插入到内核的任何指令位置的探测点，kprobe允许在同一地址注册多个kprobes，但是不能同时在该地址上有多个jprobes2. jprobesjprobes则只能被插入到一个内核函数的入口3. kretprobes(也叫返回探测点)而kretprobes则是在指定的内核函数返回时才被执行

/*kprobes执行流程*/1. 当安装一个kprobes探测点时，kprobe首先备份被探测的指令2. 使用断点指令(int 3指令)来取代被探测指令的头一个或几个字节(这点和OD很像)3. CPU执行到探测点时，将因运行断点指令而执行trap操作，那将导致保存CPU的寄存器，调用相应的trap处理函数4. trap处理函数将调用相应的notifier_call_chain(内核中一种异步工作机制)中注册的所有notifier函数5. kprobe正是通过向trap对应的notifier_call_chain注册关联到探测点的处理函数来实现探测处理的6. 当kprobe注册的notifier被执行时    6.1 它首先执行关联到探测点的pre_handler函数，并把相应的kprobe struct和保存的寄存器作为该函数的参数    6.2 然后，kprobe单步执行被探测指令的备份(原始函数)    6.3 最后，kprobe执行post_handler7. 等所有这些运行完毕后，紧跟在被探测指令后的指令流将被正常执行

int register_kprobe(struct kprobe *kp);int pre_handler(struct kprobe *p, struct pt_regs *regs);void post_handler(struct kprobe *p, struct pt_regs *regs,    unsigned long flags);fault_handler()

/*jprobe执行流程*/1. jprobe通过注册kprobes在被探测函数入口的来实现，它能无缝地访问被探测函数的参数2. jprobe处理函数应当和被探测函数有同样的原型，而且该处理函数在函数末必须调用kprobe提供的函数jprobe_return()3. 当执行到该探测点时，kprobe备份CPU寄存器和栈的一些部分，然后修改指令寄存器指向jprobe处理函数4. 当执行该jprobe处理函数时，寄存器和栈内容与执行真正的被探测函数一模一样，因此它不需要任何特别的处理就能访问函数参数， 在该处理函数执行到最后
时，它调用jprobe_return()，那导致寄存器和栈恢复到执行探测点时的状态，因此被探测函数能被正常运行5. 需要注意，被探测函数的参数可能通过栈传递，也可能通过寄存器传递，但是jprobe对于两种情况都能工作，因为它既备份了栈，又备份了寄存器，当然，前提
是jprobe处理函数原型必须与被探测函数完全一样

int register_jprobe(struct jprobe *jp);

/*kretprobe执行流程*/1. kretprobe也使用了kprobes来实现22. 当用户调用register_kretprobe()时，kprobe在被探测函数的入口建立了一个探测点3. 当执行到探测点时，kprobe保存了被探测函数的返回地址并取代返回地址为一个trampoline的地址，kprobe在初始化时定义了该trampoline并且为该
trampoline注册了一个kprobe4. 当被探测函数执行它的返回指令时，控制传递到该trampoline，因此kprobe已经注册的对应于trampoline的处理函数将被执行，而该处理函数会调用用户
关联到该kretprobe上的处理函数5. 处理完毕后，设置指令寄存器指向已经备份的函数返回地址，因而原来的函数返回被正常执行。6. 被探测函数的返回地址保存在类型为kretprobe_instance的变量中，结构kretprobe的maxactive字段指定了被探测函数可以被同时探测的实例数7. 函数register_kretprobe()将预分配指定数量的kretprobe_instance:    7.1 如果被探测函数是非递归的并且调用时已经保持了自旋锁(spinlock)，那么maxactive为1就足够了    7.2 如果被探测函数是非递归的且运行时是抢占失效的，那么maxactive为NR_CPUS就可以了    7.3 如果maxactive被设置为小于等于0, 它被设置到缺省值(如果抢占使能， 即配置了 CONFIG_PREEMPT，缺省值为10和2*NR_CPUS中的最大值，否则
缺省值为NR_CPUS)    7.4 如果maxactive被设置的太小了，一些探测点的执行可能被丢失，但是不影响系统的正常运行，在结构kretprobe中nmissed字段将记录被丢失的探测
点执行数，它在返回探测点被注册时设置为0，每次当执行探测函数而没有kretprobe_instance可用时，它就加1

int register_kretprobe(struct kretprobe *rp);int kretprobe_handler(struct kretprobe_instance *ri, struct pt_regs *regs);

void unregister_kprobe(struct kprobe *kp);void unregister_jprobe(struct jprobe *jp);void unregister_kretprobe(struct kretprobe *rp);

/* * * You will see the trace data in /var/log/messages and on the console * * whenever do_fork() is invoked to create a new process. * */#include <linux/kernel.h>#include <linux/module.h>#include <linux/kprobes.h>//定义要Hook的函数，本例中do_forkstatic struct kprobe kp = {    .symbol_name = "do_fork",};static int handler_pre(struct kprobe *p, struct pt_regs *regs){    struct thread_info *thread = current_thread_info();    printk(KERN_INFO "pre-handler thread info: flags = %x, status = %d, cpu = %d, task->pid = %d\n",    thread->flags, thread->status, thread->cpu, thread->task->pid);    return 0;}static void handler_post(struct kprobe *p, struct pt_regs *regs, unsigned long flags){      struct thread_info *thread = current_thread_info();    printk(KERN_INFO "post-handler thread info: flags = %x, status = %d, cpu = %d, task->pid = %d\n",    thread->flags, thread->status, thread->cpu, thread->task->pid);}static int handler_fault(struct kprobe *p, struct pt_regs *regs, int trapnr){    printk(KERN_INFO "fault_handler: p->addr = 0x%p, trap #%dn",    p->addr, trapnr);    return 0;}/*内核模块加载初始化，这个过程和windows下的内核驱动注册分发例程很类似*/static int __init kprobe_init(void){    int ret;    kp.pre_handler = handler_pre;    kp.post_handler = handler_post;    kp.fault_handler = handler_fault;    ret = register_kprobe(&kp);    if (ret < 0)     {        printk(KERN_INFO "register_kprobe failed, returned %d\n", ret);        return ret;    }    printk(KERN_INFO "Planted kprobe at %p\n", kp.addr);    return 0;}static void __exit kprobe_exit(void){    unregister_kprobe(&kp);    printk(KERN_INFO "kprobe at %p unregistered\n", kp.addr);}module_init(kprobe_init)module_exit(kprobe_exit)MODULE_LICENSE("GPL");

obj-m := do_fork.o

make -C /usr/src/kernels/2.6.32-358.el6.i686 M=$(pwd) modules

insmod do_fork.ko

1. 通过"劫持"在关键流程上的某些函数的执行地址，在Hook函数执行完之后，再跳回原始的函数继续执行(做好现场保护)2. 或者通过dll、进程、线程注入比原始程序提前获得CPU执行权限

1. 注册标准的回调方法，包括:    1) 进程    2) 线程    3) 模块的创建    4) 卸载回调函数    5) 文件/网络等各种过滤驱动 2. 内核提供的标准处理流程Hook点    1) kprobe机制2. 网络协议栈提供的标准Hook点    1) netfilter的链式处理流程