Inline Hook 之(监视任意函数)

前面已经写过两次inline hook的博文了,第一篇为:《C/C++ HOOK API(原理深入剖析之-LoadLibraryA)》,这篇博文的方法是通过修改任意函数的前面N个字节,实现跳转并进入到我们自定义的hook函数里,执行完毕我们的hook函数之后,再直接调用被hook的函数。第一篇的方法没有考虑多线程的情况,所以在多线程环境下会有问题。第二篇为:《 Inline HOOK API 改进版(hot-patching)》,这篇的初衷是为了解决多线程的问题,因为这种方式是一直hook的,直到程序结束。因此在多线程情况下,并不会在hook与unhook期间执行被hook的函数。不过,第二种方式有局限性,它主要针对windows的很多API而设计,在函数头部必须有空闲的两个字节和函数首地址之前的5个空闲字节(一般为5个nop指令),这样能够实现一个short jmp和一个long jmp。从而实现了hook,在此就不再累述了。

 

好了,本文已经是第三次写hook相关的东西了。前两种hook有个共同点就是他们都是直接hook掉某个函数,也就是说,当执行完我们自定义的hook函数之后,又从被hook函数的首部开始执行,被hook函数一进入就被跳转了。而本文,则要实现在某个函数体内部任意地方进行hook并跳转,执行完我们的函数之后,再回到原来的位置继续向下执行完未执行的逻辑。那么,初看这种方式似乎与前面写的两篇hook没有什么差别,都是hook,都是跳转然后回到被hook的函数。但仔细一想,你会发现本文要实现的方式要比前面两种hook复杂,因为hook的地方是函数体内任意地方,那么回来的时候就不是直接调用被hook的函数了,而是要回到之前hook的地方去。这期间就涉及到hook函数的返回地址问题和被hook函数的返回地址问题。

 

说了这么多,可能还是有点晕,先不管为什么要这么做,也不管这种hook方式能有什么用途(在本文最后会说明用途),下面我们先写一些代码,在实践中来想一想这种方式有什么用途,并且与之前的两篇hook进行比较。

 

首先,我们需要一个自定义的hook函数,这个函数也就是被hook函数被hook后跳转到的地方,这个hook函数负责hook与unhook,还可以监视寄存器,监视内存,也可以管理hook的次数,以供我们灵活的hook需求。直接贴代码吧:

  1. #include <iostream>  
  2. #include <windows.h>  
  3.   
  4. #pragma warning( disable : 4311 )  
  5. #pragma warning( disable : 4312 )  
  6.   
  7. #define HOOK_BYTES 5  
  8. typedef unsigned int uint;  
  9.   
  10. uint  hookAddr = 0;  
  11. char  old_code[ HOOK_BYTES ];  
  12. char  new_code[ HOOK_BYTES ];  
  13.   
  14. void printRegisters( void );  
  15.   
  16. bool hook( void )  
  17. {  
  18.     DWORD dwFlag;  
  19.     if ( VirtualProtect( ( void* )hookAddr, HOOK_BYTES, PAGE_EXECUTE_READWRITE, &dwFlag ) )  
  20.     {  
  21.         memcpy( old_code, ( void* )hookAddr, HOOK_BYTES );  
  22.         memcpy( ( void* )hookAddr, new_code, HOOK_BYTES );  
  23.         VirtualProtect( ( void* )hookAddr, HOOK_BYTES, dwFlag, &dwFlag );  
  24.         return true;  
  25.     }  
  26.     return false;  
  27. }  
  28.   
  29. void unhook( void )  
  30. {  
  31.     DWORD dwFlag;  
  32.     if ( VirtualProtect( ( void* )hookAddr, HOOK_BYTES, PAGE_EXECUTE_READWRITE, &dwFlag ) )  
  33.     {  
  34.         memcpy( ( void* )hookAddr, old_code, HOOK_BYTES );  
  35.         VirtualProtect( ( void* )hookAddr, HOOK_BYTES, dwFlag, &dwFlag );  
  36.     }  
  37. }  
  38.   
  39. namespace global  
  40. {  
  41.     uint gEAX = 0;  
  42.     uint gEBX = 0;  
  43.     uint gECX = 0;  
  44.     uint gEDX = 0;  
  45.     uint gESP = 0;  
  46.     uint gEBP = 0;  
  47.     uint gESI = 0;  
  48.     uint gEDI = 0;  
  49.   
  50.     uint gRet = 0;  // 临时的返回地址  
  51.     uint gTmp = 0;  // 一些临时的值保存  
  52.     uint gPar = 0;  // 被hook函数的正常返回地址  
  53.     uint gCnt = 1;  // 当前hook的次数  
  54.     uint gMax = 0;  // 最大hook次数,为0表示一直hook  
  55.     bool bEnt = 0;  // 是否为第一次进入hook函数  
  56. }  
  57.   
  58. void __declspecnaked ) hook_jmp( void )  
  59. {  
  60.     __asm  
  61.     {  
  62. __entry:  
  63.         pushad  
  64.         {  
  65.             cmp global::bEnt, 0   // 如果没有进入则表示需要unhook  
  66.             je  __first  
  67.   
  68.             cmp global::gMax, 0   // 如果为0,则一直启用hook逻辑  
  69.             je  __second  
  70.   
  71.             mov eax, global::gCnt  
  72.             cmp eax, global::gMax // 如果当前hook次数没有达到最大次数,则继续  
  73.             jl  __second  
  74.   
  75.             mov global::gCnt, 1   // reset state  
  76.             mov global::bEnt, 0   // reset state  
  77.             mov global::gMax, 0   // reset state  
  78.   
  79.             mov eax, global::gPar // 被hook函数的正常返回地址  
  80.             mov global::gRet, eax // 准备跳转到被hook函数的上层调用,结束hook  
  81.             popad  
  82.             jmp __ret  
  83.         }  
  84.   
  85. __first:  
  86.         // 保存相关重要寄存器值  
  87.         {  
  88.             popad  
  89.             mov global::gEAX, eax    
  90.             mov global::gEBX, ebx  
  91.             mov global::gECX, ecx  
  92.             mov global::gEDX, edx  
  93.             mov global::gESP, esp  
  94.             mov global::gEBP, ebp  
  95.             mov global::gESI, esi  
  96.             mov global::gEDI, edi  
  97.         }  
  98.   
  99.         // 第一次进入,unhook并监视相关状态  
  100.         pushad  
  101.         {  
  102.             mov global::bEnt, 1    // 记录状态  
  103.   
  104.             mov edi, global::gEBP  // 被hook函数的ebp  
  105.             mov eax, [ edi + 4 ]   // 被hook函数的返回地址(其上层调用地址)  
  106.             mov global::gPar, eax  // 保存返回地址  
  107.             mov esi, __entry       // 将被hook函数的返回地址修改为  
  108.             mov [ edi + 4 ], esi   // 本函数的首地址,以便执行完被hook函数的  
  109.                                    // 剩余逻辑之后能够返回到本函数,决定是否  
  110.                                    // 还需要hook。  
  111.   
  112.             call printRegisters    // 打印寄存器值[测试],或者其他  
  113.             call unhook            // unhook  
  114.   
  115.             mov  eax, hookAddr     // 获得被hook的内存地址  
  116.             mov  global::gRet, eax  
  117.         }  
  118.         popad  
  119.   
  120.         pop  global::gTmp          // 移除本函数的返回地址,并将hook的地址设置  
  121.         jmp __ret                  // 为本函数的返回地址,从而实现跳转  
  122.   
  123. __second:  
  124.         // 第二次进入, 继续hook, 这次进入是被hook函数ret返回的,没有新的ret地址被压栈  
  125.         {  
  126.             mov global::bEnt, 0    // 设置状态  
  127.             add global::gCnt, 1    // 增加hook计数  
  128.   
  129.             call hook              // hook  
  130.   
  131.             mov  eax, global::gPar // 将被hook函数的返回地址设置为本函数的  
  132.             mov  global::gRet, eax // 返回地址,从而实现正常的函数流程  
  133.         }  
  134.         popad  
  135.   
  136. __ret:  
  137.         push global::gRet                   // 修改本函数的返回地址  
  138.         ret  
  139.     }  
  140. }  
  141.   
  142. void setHookBytes( uint addr )  
  143. {  
  144.     hookAddr = addr;  
  145.     new_code[ 0 ] = ( char )0xe8; // call 指令机器码  
  146.     ( uint& )new_code[ 1 ] = ( uint )hook_jmp - addr - 5; // 计算跳转偏移  
  147. }  
  148.   
  149. void printRegisters( void )  
  150. {  
  151.     printf( "EAX = 0x%08x/n", global::gEAX );  
  152.     printf( "EBX = 0x%08x/n", global::gEBX );  
  153.     printf( "ECX = 0x%08x/n", global::gECX );  
  154.     printf( "EDX = 0x%08x/n", global::gEDX );  
  155.     printf( "ESP = 0x%08x/n", global::gESP );  
  156.     printf( "EBP = 0x%08x/n", global::gEBP );  
  157.     printf( "ESI = 0x%08x/n", global::gESI );  
  158.     printf( "EDI = 0x%08x/n", global::gEDI );  
  159. }  

如上,hook_jmp函数即为我们自定义的hook函数,当被hook函数被hook之后,就会跳转到这个函数里,执行相关逻辑,上面我加了很详细的注释。应该很容易看懂。还是先看怎么使用这套方法,再来细说,代码如下:

  1. void testHook( void )  
  2. {  
  3.     printf( "This is a hook test 1./n" );  
  4.     printf( "This is a hook test 2./n" );  
  5.     printf( "This is a hook test 3./n" );  
  6.     printf( "This is a hook test 4./n" );  
  7.     printf( "______________________/n" );  
  8. }  
  9.   
  10. int main( void )  
  11. {  
  12.     uint hook_addr = 0x0042ec7b;  
  13.     setHookBytes( hook_addr );  
  14.       
  15.     global::gMax = 2;  
  16.     if ( hook() )  
  17.     {  
  18.         testHook();  
  19.         testHook();  
  20.         testHook();  
  21.     }  
  22.     system( "pause" );  
  23.     return 0;  
  24. }  

如上,testHook函数即为被hook的函数,在main函数中,0x0042ec7b则为testHook函数里的第二个printf调用的地址,在你的机器上可能不一样。这里只是测试之用。testHook函数具体反汇编代码如下:

  1. void testHook( void )  
  2. {  
  3. 0042EC50  push        ebp    
  4. 0042EC51  mov         ebp,esp   
  5. 0042EC53  sub         esp,0C0h   
  6. 0042EC59  push        ebx    
  7. 0042EC5A  push        esi    
  8. 0042EC5B  push        edi    
  9. 0042EC5C  lea         edi,[ebp-0C0h]   
  10. 0042EC62  mov         ecx,30h   
  11. 0042EC67  mov         eax,0CCCCCCCCh   
  12. 0042EC6C  rep stos    dword ptr es:[edi]   
  13.     printf( "This is a hook test 1./n" );  
  14. 0042EC6E  push        offset string "This is a hook test 1./n" (487E24h)   
  15. 0042EC73  call        @ILT+4550(_printf) (42D1CBh)   
  16. 0042EC78  add         esp,4   
  17.     printf( "This is a hook test 2./n" );  
  18. 0042EC7B  push        offset string "This is a hook test 2./n" (487E08h)   
  19. 0042EC80  call        @ILT+4550(_printf) (42D1CBh)   
  20. 0042EC85  add         esp,4   
  21.     printf( "This is a hook test 3./n" );  
  22. 0042EC88  push        offset string "This is a hook test 3./n" (487DECh)   
  23. 0042EC8D  call        @ILT+4550(_printf) (42D1CBh)   
  24. 0042EC92  add         esp,4   
  25.     printf( "This is a hook test 4./n" );  
  26. 0042EC95  push        offset string "This is a hook test 4./n" (487DD0h)   
  27. 0042EC9A  call        @ILT+4550(_printf) (42D1CBh)   
  28. 0042EC9F  add         esp,4   
  29.     printf( "______________________/n" );  
  30. 0042ECA2  push        offset string "_____________________./n" (487DB4h)   
  31. 0042ECA7  call        @ILT+4550(_printf) (42D1CBh)   
  32. 0042ECAC  add         esp,4   
  33. }  
  34. 0042ECAF  pop         edi    
  35. 0042ECB0  pop         esi    
  36. 0042ECB1  pop         ebx    
  37. 0042ECB2  add         esp,0C0h   
  38. 0042ECB8  cmp         ebp,esp   
  39. 0042ECBA  call        @ILT+3570(__RTC_CheckEsp) (42CDF7h)   
  40. 0042ECBF  mov         esp,ebp   
  41. 0042ECC1  pop         ebp    
  42. 0042ECC2  ret   

我们hook的就是第18行(0042EC7B)那句代码,setHookBytes构建了一个5字节的call语句,0xe8为CALL指令的机器码,后面4个字节是CALL的偏移量(目标地址 - 当前地址 - CALL指令占用的5个字节)。

 

在main函数中,构建了hook的5个字节之后,设置了hook次数,如main函数那段代码的第15行:global::gMax = 2,则会hook两次。然后是main函数那段代码的第16行,调用hook函数,将5个字节的call指令写入0042EC7B中,并保存了0042EC7B中原来的代码到old_code中。之后,我们便可以调用testHook函数进行测试hook的流程了。最终输出结果为:

This is a hook test 1.
EAX = 0x00000017
EBX = 0x7ffdc000
ECX = 0x8df97741
EDX = 0x00499148
ESP = 0x0012fd84
EBP = 0x0012fe54
ESI = 0x00000000
EDI = 0x0012fe54
This is a hook test 2.
This is a hook test 3.
This is a hook test 4.
______________________
This is a hook test 1.
EAX = 0x00000017
EBX = 0x7ffdc000
ECX = 0x8df97741
EDX = 0x00499148
ESP = 0x0012fd84
EBP = 0x0012fe54
ESI = 0x00000000
EDI = 0x0012fe54
This is a hook test 2.
This is a hook test 3.
This is a hook test 4.
______________________
This is a hook test 1.
This is a hook test 2.
This is a hook test 3.
This is a hook test 4.
______________________

 

可以看出,前面两次调用testHook函数时,都执行了hook_jmp函数,并调用了printRegisters函数将寄存器打印了出来,之后又回到testHook中,继续输出后面的3句字符串。当两次hook之后,第三次调用testHook时,就不会再输出寄存器了,也没有被hook了。

 

我们来看几个比较hook_jmp中比较关键的几个地方:

第104到110行:这段汇编代码,主要用于保存testHook函数(被hook函数)的正常的返回地址(main函数里调用testHook的下一句指令的地址)到global::gPar变量中,并将hook_jmp的首地址(也就是__entry标签指示的地址)写入testHook函数的返回地址所在的内存里。这样当unhook并执行完testHook之后又能回到hook_jmp中,进一步判断是否需要下一次hook。如果不需要再hook(已经达到最大hook次数)时,则会执行第79到80行的两句汇编代码,这两句汇编代码的作用是将hook_jmp函数的返回地址设置为testHook函数正常的返回地址,也就是main函数里调用testHook函数的下一句汇编代码的地址(ret指令的原理如果不清楚,请看前两篇hook文章或查阅相关资料)。这样一来,当不再需要hook时,就能顺利的从hook_jmp函数返回后直接跳转到main函数的作用域里。这样整个调用流程就符合原本的调用流程了。

 

第113行:这句代码是在调用了printRegister函数之后进行unhook操作,将原本的5个字节的代码重新拷贝到testHook函数的相应代码地址的内存里,本例中为testHook函数中第二句printf函数调用的地址。unhook之后,第115到116行的两句代码与第79到80行的两句汇编代码类似,只不过这时是将被hook的内存地址设置为hook_jmp的返回地址,这样就能在第一次进入testHook函数并执行完毕返回时,能够跳转到被hook的地址(hookTest函数里第2句printf调用的地址)继续向下执行剩余的逻辑。

 

第131到132行:这两句汇编代码与第79到80行的两句汇编代码一致,都是将main函数里相应的代码地址设置为hook_jmp函数的ret返回地址,这样就能直接从hook_jmp跳转到main函数里继续向下执行,这样也就代表testHook被顺利的调用完成。

 

所以,总结下来,hook_jmp函数会进入两次,第一次用于监视一些数据,本例只监视了相关寄存器,还可以增加监视指定内存地址等等。第一次进入时,会保存被hook函数(testHook函数)的返回地址,并将其修改为hook_jmp函数的首地址,这样做是为了执行完testHook函数之后能够第二次进入hook_jmp函数。那么,第二次进入后,首先是判断是否还需要hook,不需要则直接返回到main函数里,如果还要继续hook,则再次调用hook函数,然后跳转到main函数里。这样就构成了一个严密的调用流程,一切都看起来很和谐的调用,有点类似缓冲区溢出攻击的原理。

 

hook_jmp函数中需要注意寄存器的保存,否则输出的寄存器值并不是testHook函数执行到hook位置时的寄存器状态,这样就丧失了监视的意义。

 

原理上其实比较简单,构建稍微细致了一些,与前两篇hook最大的不同就是需要手动修改ret的返回地址,从而达到hook的目的,不像之前的两篇hook,在进入hook函数之后,要回到被hook的函数时,只需要直接call就可以了,并不需要维护ret指令的返回地址。另外,由于本文的hook方式与第一篇的hook方式类似,所以本文的方式并没有支持多线程环境。

 

再者,本文的方式还有另外一些局限性:

1. 不能hook函数大括号以外的代码,也就是反汇编代码中大括号之前和之后的代码,因为本文的hook方式是需要通过被hook函数的ebp获取ret地址的,如果设置ebp的相关代码被hook,就得不到正确的ret返回地址等。而且hook大括号之外的代码意义并不大。

2. 被hook的函数的栈帧不能被编译器优化掉,否则得不到ret地址和ebp。

3. hook的代码地址必须为某条汇编指令机器码序列的首地址,本文并没有兼容任意代码地址hook,当然任意代码地址是可以实现的,不过在实际中要监视一些状态,这样做并没有太大的意义。所以你需要明确的知道你hook的代码地址是合法的,并且不会破坏原有的代码逻辑。

 

好了,整个hook的逻辑和原理就介绍得差不多了,再附上一张流程图:

如图所示,testHook函数如果被hook了,它是不会直接返回到main函数的,而是要先进入hook_jmp函数,再由hook_jmp函数返回到main函数,知道不再hook的时候,testHook才有“权利”直接返回到main函数里。

 

好了差不多就介绍完了,最后说说这套hook的用途,其实最初我是想用于反外挂检测上,于是写了这么一套hook逻辑,方便在不用调试客户端程序的情况下,监视在运行有外挂的客户端的一些关键的反外挂检测点,例如某个反外挂检测逻辑是否被执行,某些检测结果值的监视等。外挂一般加了比较强悍的保护壳,这些壳具有反调试等功能。典型的就是VMP壳和UPX壳。当然在这之前尝试了脱壳等方式调试跟踪有外挂的客户端,但是脱壳和绕过反调试机制的工作量都相对较大一些,我们的一贯思想又是以最少的工作量去做到好的反外挂效果。于是我便写了这套hook规则,用于检测当前反外挂系统是否被破解,是否被绕开。通过这套规则,就可以很方便的设立观测点,监视相关逻辑和数据,当然还可以有更多用途,此处不再一一说明,另外为此还写了一个可视化工具,方便工作中使用,并成功检测了多个外挂的破解机制,如图:

 


左边为hook逻辑的界面,右边tool页面为调用任意函数的功能,同时支持查看模块和查看并修改内存。基本上已经够用了。- -

 

好了,本文到此结束,由于水平有限,可能存在bug,还望指教,衷心感谢!


评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值