自己实现函数钩子

看了detour的原理，心里想着自己能不能动手模拟一个。

比划的时候发现了一些细节问题。detour将函数的前几个字节（刚开始看文档的时候说5个字节）替换成jmp __

。但是发生机器码截断整么办？可以在vs的反汇编窗口看到每条汇编指令的机器码，每条指令的机器码长度并不是固定的，我想detour并不是固定复制5个字节这么简单（目前还没研究detour源码）。所以退而求其次（这是一个学习性质的实验），改变设计。

我选择在自己定义的函数执行完之后将修改的代码再改回去，跳回原函数运行。看起来是这样的：

而且自定义函数是不知道自己返回到的是traceBack的。

即原函数总是会被执行。这就变成了钩子，而且只能钩住一次，因为我把被修改区域复原了。

不过暂且就不计较这个了（这是一个学习性质的实验）。

真正自己实现的时候才发现一些有趣的细节问题，比如jmp对应有多个机器码，选择哪一个，代码页原来是不允许写的，要VirtualProtect函数修改，traceBack不能return只能jmp，为了保证栈平衡需要写成__declspec(naked)之类。

还有我修改了15个字节，三个句子：

push __

push __

jmp __

第一个push压入的信息提供给traceBack，好让他能找到修改前的代码拷回去。

第二个push压入traceBack的地址，这样跳转到traceBack就对自定义函数(hook)是透明的了。

最后转跳，是一个近转跳，所以还要计算相对位移。

效果：

#include "detour.h"
#include <stdio.h>
#include <windows.h>

#pragma optimize("",off)

void hook()
{
    printf("detoured\n");
}

int main()
{
    detourInit();
//---------------------------------------------------------

    detour( Sleep,hook );

    Sleep(1);

    system("pause");
    return 0;
}

PS: detour.h 即我自己实现的源码。(代码在下面)

结果:

Sleep就被勾住了。但是再次调用Sleep就是正常的。

具体代码：

detour.h ( 其实应该起名hook的 )

#ifndef __DETOUR_H__
#define __DETOUR_H__

#pragma once

#include <windows.h>
#include <assert.h>
#include <stdlib.h>

typedef unsigned char u8;

//push (下标) + push (traceBack地址) + jmp (hook) 覆盖15个字节
#define TBSIZE 15
#define INFOSIZE 5
#define REPSIZE 15

//machine code
#define MC_FARJMP    0xE9
#define MC_PUSH        0x68

struct s_detour
{
    void *oldFunc;
    void *hook;
    u8 backUp[TBSIZE];
};

s_detour gInfo[INFOSIZE];

void detourInit()
{
    assert( sizeof(gInfo) > sizeof(s_detour) );
    memset( gInfo,0,sizeof(gInfo) );
}

LPDWORD ftb_old = new DWORD;
BOOL ftb_res;
void* ftb_addr;
__declspec(naked) void traceBack( int tn )
{
    //restore
    //ps:只能jmp不能return
    __asm
    {
        push 0x1        //假装地址填充.使得tn能够正确访问
        push ebp
        mov ebp,esp
    }

    assert( tn >= 1 && tn < INFOSIZE );

    //#the return would work?
    ftb_res = VirtualProtect( gInfo[tn].oldFunc,REPSIZE,PAGE_EXECUTE_READWRITE,ftb_old );
    assert( ftb_res );

    memcpy( gInfo[tn].oldFunc,gInfo[tn].backUp,REPSIZE );

    ftb_res = VirtualProtect( gInfo[tn].oldFunc,REPSIZE,*ftb_old,ftb_old );
    assert( ftb_res );

    //ready to back
    ftb_addr = (void*)gInfo[tn].oldFunc;
    gInfo[tn].oldFunc = NULL;
    __asm
    {
        mov esp,ebp
        pop ebp
        pop eax        //pop 0x1
        pop eax        //balance stack  pop tn

        mov eax,ftb_addr
        jmp eax
    }
}

//register
bool detour( void *oldFunc,void *hook )
{
    if( oldFunc == NULL || hook == NULL )
        return false;

    int tn;
    for( tn = 1;tn < INFOSIZE;++tn )
    {
        if( gInfo[tn].oldFunc == NULL )        //could be used
            break;
    }
    if( tn == INFOSIZE )
        return false;

    gInfo[tn].oldFunc = oldFunc;
    gInfo[tn].hook = hook;

    LPDWORD lpOld = new DWORD;
    BOOL res = VirtualProtect( oldFunc,REPSIZE,PAGE_EXECUTE_READWRITE,lpOld );
    assert( res );

    memcpy( gInfo[tn].backUp,oldFunc,REPSIZE );    //back up

    //replace
    u8 *pf = (u8*)oldFunc;
    pf[0] = MC_PUSH;
    *((int*)((int)pf+1)) = tn;                //压入标记

    pf = (u8*)( (int)pf + 5 );
    pf[0] = MC_PUSH;
    *((int*)((int)pf+1)) = (int)traceBack;    //压入traceBack地址

    pf = (u8*)( (int)pf + 5 );
    pf[0] = MC_FARJMP;
    *((int*)((int)pf+1)) = (int)((int)hook - ((int)pf) - 5 );        //near jmp 相对地址

    res = VirtualProtect( oldFunc,REPSIZE,*lpOld,lpOld );
    assert( res );
    free( lpOld );

    return true;
}

#endif