C++ 伪任意地址HOOK类源码

梦天哥

C++ 伪任意地址HOOK类源码

前言：

代码HOOK技术不管在安全领域还是在木马病毒方面都运用很广泛，因为他可以改变程序执行流程，悄无声息执行我们自己的代码。

之前我也用过一些hook类，如mhook等，但很多都局限于API HOOK，有的时候无法满足实际应用。也因此，我自己的hook类就诞生了。

先贴核心代码：

1. /
   
2. /Hook.h
   
3. #pragma once
   
4. 
   
5. struct t_Context
   
6. {
   
7.         DWORD EDI;
   
8.         DWORD ESI;
   
9.         DWORD EBP;
   
10.         DWORD ESP;
    
11.         DWORD EBX;
    
12.         DWORD EDX;
    
13.         DWORD ECX;
    
14.         DWORD EAX;
    
15. };
    
16. 
    
17. class CHook
    
18. {
    
19. public:
    
20.         CHook(void);
    
21.         ~CHook(void);
    
22.         // 添加Hook
    
23.         bool AddHook(__in DWORD dwHookAddr, __in void *pfnHookProc);
    
24.         // 移除Hook
    
25.         bool RemoveHook();
    
26.         // 寄存器结构体
    
27.         t_Context m_Context;
    
28.         // 返回地址,没有特殊需求不要修改这里
    
29.         DWORD m_dwRetAddr;
    
30. private:
    
31.         // 保存Hook地址,用于RemoveHook
    
32.         DWORD m_dwHookAddr;
    
33.         // 保存原始字节,用于RemoveHook
    
34.         BYTE m_OldCode[5];
    
35. };

复制代码

1. //Hook.cpp
   
2. #include "StdAfx.h"
   
3. #include "Hook.h"
   
4. #include "MyOutputDebugString.h"
   
5. 
   
6. //BeaEngine 反汇编引擎
   
7. #define BEA_ENGINE_STATIC
   
8. #define BEA_USE_STDCALL
   
9. #include "bea/headers/BeaEngine.h"
   
10. #pragma comment(lib, "bea/win32/lib/BeaEngine.lib")
    
11. #pragma comment(linker,"/nodefaultlib:crt.lib")
    
12. //BeaEngine end
    
13. 
    
14. //XEDParse 汇编引擎
    
15. #include "XEDParse/XEDParse.h"
    
16. #pragma comment(lib,"XEDParse/XEDParse.lib")
    
17. 
    
18. CHook::CHook(void)
    
19. {
    
20.         memset(&m_Context, 0, sizeof(m_Context));
    
21.         memset(m_OldCode, 0x90, 5);
    
22.         m_dwRetAddr = 0;
    
23.         m_dwHookAddr = 0;
    
24. }
    
25. 
    
26. 
    
27. CHook::~CHook(void)
    
28. {
    
29. }
    
30. 
    
31. 
    
32. // 添加Hook
    
33. bool CHook::AddHook(__in DWORD dwHookAddr, __in void *lpHookProc)
    
34. {
    
35.         //00240000    60              PUSHAD
    
36.         //00240001    9C              PUSHFD
    
37.         //00240002    BF 00012400     MOV EDI,0x240100
    
38.         //00240007    8BF4            MOV ESI,ESP
    
39.         //00240009    83C6 04         ADD ESI,0x4
    
40.         //0024000C    B9 20000000     MOV ECX,0x20
    
41.         //00240011    F3:A4           REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]     ; 保存寄存器结构体，备用
    
42.         //00240013    B8 90909090     MOV EAX,0x90909090
    
43.         //00240018    FFD0            CALL EAX                                         ; 调用HookPro
    
44.         //0024001A    9D              POPFD
    
45.         //0024001B    61              POPAD
    
46.         //0024001C    90              NOP                                              ; 个数等于被毁掉的指令总长度
    
47.         //0024001D    68 90909090     PUSH 0x90909090                                  ; jmp back
    
48.         //00240022    C3              RETN
    
49.         //00240023    90              NOP
    
50.         BYTE Shell[0x100] = {0x60, 0x9C, 0xBF, 0x90, 0x90, 0x90, 0x90, 0x8B, 0xF4, 0x83, 0xC6, 0x04, 0xB9, 0x20, 0x00, 0x00, 0x00, 0xF3, 0xA4, 0xB8, 0x90, 0x90, 0x90, 0x90, 0xFF, 0xD0, 0x9D, 0x61, 0x90, 0x90};
    
51.         int pContext = (int)&m_Context;
    
52.         memcpy(&Shell[3], &pContext, 4);
    
53.         int pHookProc = (int)lpHookProc;
    
54.         memcpy(&Shell[0x14], &pHookProc, 4);
    
55. 
    
56.         //保存原始机器码
    
57.         DWORD dwOldProtect = 0;
    
58.         BOOL bRet = VirtualProtect((LPVOID)dwHookAddr, 0x20, PAGE_EXECUTE_READWRITE, &dwOldProtect);
    
59.         if (!bRet)
    
60.         {
    
61.                 MyOutputDebugStringA("VirtualProtect(0x%p) Error!!!", dwHookAddr);
    
62.                 MyOutputDebugStringA("AddHook Failed:0x%p", dwHookAddr);
    
63.                 return false;
    
64.         }
    
65.         memcpy(m_OldCode, (LPVOID)dwHookAddr, 5);//用于hook还原
    
66. 
    
67.         DWORD dwStart = (DWORD)VirtualAlloc(NULL, 0x100, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
68.         if (dwStart == 0)
    
69.         {
    
70.                 OutputDebugStringA("VirtualAlloc Error!!!");
    
71.                 MyOutputDebugStringA("AddHook Failed:0x%p", dwHookAddr);
    
72.                 return false;
    
73.         }
    
74. 
    
75.         //开始解析原始指令,通过反汇编引擎，识别要Hook的地址处的指令，以及破坏的指令长度
    
76.         int nSize = 0;//毁掉的指令的总字节数
    
77.         DWORD dwASM = dwStart + 30;//30为前面shell前面部分代码长度
    
78. 
    
79.         DISASM MyDisasm;
    
80.         memset (&MyDisasm, 0, sizeof(DISASM));
    
81.         MyDisasm.EIP = (UIntPtr)dwHookAddr;
    
82.         MyDisasm.Options = PrefixedNumeral + ShowSegmentRegs;
    
83. 
    
84.         while (1)
    
85.         {
    
86.                 //反汇编
    
87.                 int nInstLen = Disasm(&MyDisasm);
    
88.                 if (nInstLen < 1)
    
89.                 {
    
90.                         MyOutputDebugStringA("Disasm(%p) Error!!!", MyDisasm.EIP);
    
91.                         MyOutputDebugStringA("AddHook Failed:0x%p", dwHookAddr);
    
92.                         return false;
    
93.                 }
    
94.                 MyOutputDebugStringA("Addr = 0x%p nInstLen = %d %s", MyDisasm.EIP, nInstLen, MyDisasm.CompleteInstr);
    
95.                 if (MyDisasm.Instruction.BranchType == RetType)
    
96.                 {
    
97.                         MyOutputDebugStringA("要hook的地址开始，后面5个字节对应的指令，不能有ret");
    
98.                         MyOutputDebugStringA("AddHook Failed:0x%p", dwHookAddr);
    
99.                         return false;
    
100.                 }
     
101.                 nSize += nInstLen;
     
102.                 //汇编，先反汇编再汇编的好处在于不用修正相对偏移地址
     
103.                 XEDPARSE parse;
     
104.                 memset(&parse, 0, sizeof(parse));
     
105.                 parse.x64 = false;
     
106.                 parse.cip = dwASM;
     
107.                 memset(parse.instr, 0, 256);
     
108.                 memcpy(parse.instr, MyDisasm.CompleteInstr, 64);
     
109.                 XEDPARSE_STATUS status = XEDParseAssemble(&parse);
     
110.                 if (status == XEDPARSE_ERROR)
     
111.                 {
     
112.                         MyOutputDebugStringA("Parse Error:%s", parse.error);
     
113.                         MyOutputDebugStringA("AddHook Failed:0x%p", dwHookAddr);
     
114.                         return false;
     
115.                 }
     
116.                 memcpy(&Shell[dwASM - dwStart], &parse.dest[0], parse.dest_size);
     
117. 
     
118.                 dwASM += parse.dest_size;
     
119.                 MyDisasm.EIP  += nInstLen;
     
120.                 if (nSize >= 5)
     
121.                 {
     
122.                         m_dwRetAddr = MyDisasm.EIP;
     
123.                         m_dwHookAddr = dwHookAddr;
     
124.                         break;
     
125.                 }
     
126.         }
     
127.         BYTE PushRet[6] = {0x68, 0x90, 0x90, 0x90, 0x90, 0xC3};
     
128.         memcpy(&PushRet[1], &m_dwRetAddr, 4);
     
129.         memcpy(&Shell[dwASM - dwStart], &PushRet[0], 6);
     
130.         //Shell整理好了 写过去
     
131.         memcpy((LPVOID)dwStart, Shell, 0x100);
     
132. 
     
133.         BYTE jmpcode[] = {0xE9, 0xFF, 0xFF, 0xFF, 0xFF}; //jmp Start
     
134.         DWORD VA =  dwStart - dwHookAddr - 5;
     
135.         memcpy(&jmpcode[1], &VA, 4);
     
136.         //hook jmp Start;
     
137.         memcpy((LPVOID)dwHookAddr, jmpcode, sizeof(jmpcode) / sizeof(jmpcode[0]));
     
138.         VirtualProtect((LPVOID)dwHookAddr, 5, dwOldProtect, &dwOldProtect);
     
139. 
     
140.         MyOutputDebugStringA("AddHook Success:0x%p", dwHookAddr);
     
141.         return true;
     
142. }
     
143. 
     
144. 
     
145. // 移除Hook
     
146. bool CHook::RemoveHook(void)
     
147. {
     
148.         //还原原始机器码
     
149.         if (m_dwHookAddr == 0)
     
150.         {
     
151.                 return false;
     
152.         }        
     
153.         DWORD dwOldProtect = 0;
     
154.         VirtualProtect((LPVOID)m_dwHookAddr, 0x20, PAGE_EXECUTE_READWRITE, &dwOldProtect);
     
155.         memcpy((LPVOID)m_dwHookAddr, m_OldCode, 5);
     
156.         VirtualProtect((LPVOID)m_dwHookAddr, 5, dwOldProtect, &dwOldProtect);
     
157. 
     
158.         return true;
     
159. }
     

复制代码

核心代码就这些了，由于使用反汇编，汇编库，实现起来代码非常简单，连注释一起也就150行代码哈，下面讲一下如何使用。
使用方法
0x00：将MyOutputDebugString.h，MyOutputDebugString.cpp，Hook.h，Hook.cpp，bea文件夹，XEDParse文件夹复制到自己项目的代码目录。
0x01：将MyOutputDebugString.h，MyOutputDebugString.cpp，Hook.h，Hook.cpp添加到项目中。
0x02：在需要使用hook的地方，#include "Hook.h",然后就可以使用了。
0x03：使用示例如下

1. CHook hook1;
   
2. 
   
3. void MyHookPro()
   
4. {
   
5.         //hook回调函数，这里写自己的代码
   
6. }
   
7. 
   
8. hook1.AddHook(dwHookAddr,MyHookPro);
   

复制代码

HookDll Demo核心代码：

1. 
   
2. #include "stdafx.h"
   
3. #include "Hook.h"
   
4. #include "MyOutputDebugString.h"
   
5. 
   
6. CHook hook1;
   
7. CHook hook2;
   
8. CHook hook3;
   
9. CHook hook4;
   
10. 
    
11. wchar_t szTitle[] = L"Tip:Modify by sunflover";
    
12. void Hook1Proc(void)
    
13. {
    
14.         //在这里添加你的代码
    
15.         MyOutputDebugStringA("Hook1Proc EAX = 0x%.8X ECX = 0x%.8X EDX = 0x%.8X EBX = 0x%.8X ESP = 0x%.8X EBP = 0x%.8X ESI = 0x%.8X EDI = 0x%.8X",
    
16.                 hook1.m_Context.EAX,hook1.m_Context.ECX,hook1.m_Context.EDX,hook1.m_Context.EBX,
    
17.                 hook1.m_Context.ESP,hook1.m_Context.EBP,hook1.m_Context.ESI,hook1.m_Context.EDI);
    
18. 
    
19.         //$ ==>    > 00405AAE  /CALL 到 MessageBoxW 来自 HookTest.00405AA8
    
20.         //$+4      > 00120A06  |hOwner = 00120A06 ('HookDemo',class='#32770')
    
21.         //$+8      > 00550BB8  |Text = "www.jmpoep.com"
    
22.         //$+C      > 02607D40  |Title = "HookTest"
    
23.         //$+10     > 00000000  \Style = MB_OK|MB_APPLMODAL
    
24.         //这里我们改变消息框的标题吧。
    
25.         LPVOID ppTitle= (LPVOID)(hook1.m_Context.ESP +0xC);
    
26.         DWORD pszTitle = (DWORD)&szTitle[0];
    
27.         memcpy(ppTitle,&pszTitle,4);
    
28. }
    
29. 
    
30. void Hook2Proc(void)
    
31. {
    
32.         //在这里添加你的代码
    
33.         MyOutputDebugStringA("Hook2Proc EAX = 0x%.8X ECX = 0x%.8X EDX = 0x%.8X EBX = 0x%.8X ESP = 0x%.8X EBP = 0x%.8X ESI = 0x%.8X EDI = 0x%.8X",
    
34.                 hook2.m_Context.EAX,hook2.m_Context.ECX,hook2.m_Context.EDX,hook2.m_Context.EBX,
    
35.                 hook2.m_Context.ESP,hook2.m_Context.EBP,hook2.m_Context.ESI,hook2.m_Context.EDI);
    
36. }
    
37. 
    
38. void Hook3Proc(void)
    
39. {
    
40.         //在这里添加你的代码
    
41.         MyOutputDebugStringA("Hook3Proc EAX = 0x%.8X ECX = 0x%.8X EDX = 0x%.8X EBX = 0x%.8X ESP = 0x%.8X EBP = 0x%.8X ESI = 0x%.8X EDI = 0x%.8X",
    
42.                 hook3.m_Context.EAX,hook3.m_Context.ECX,hook3.m_Context.EDX,hook3.m_Context.EBX,
    
43.                 hook3.m_Context.ESP,hook3.m_Context.EBP,hook3.m_Context.ESI,hook3.m_Context.EDI);
    
44.         //这里就简单的弹出个消息框
    
45.         MessageBoxA(NULL, "Hook3Proc\tBy sunflover","www.jmpoep.com",MB_ICONINFORMATION);
    
46. }
    
47. 
    
48. void Hook4Proc(void)
    
49. {
    
50.         //在这里添加你的代码
    
51.         MyOutputDebugStringA("Hook3Proc EAX = 0x%.8X ECX = 0x%.8X EDX = 0x%.8X EBX = 0x%.8X ESP = 0x%.8X EBP = 0x%.8X ESI = 0x%.8X EDI = 0x%.8X",
    
52.                 hook4.m_Context.EAX,hook4.m_Context.ECX,hook4.m_Context.EDX,hook4.m_Context.EBX,
    
53.                 hook4.m_Context.ESP,hook4.m_Context.EBP,hook4.m_Context.ESI,hook4.m_Context.EDI);
    
54. }
    
55. 
    
56. //bug1:要hook的地址开始后5个字节，不会retn,如下hook 00405AC5 处会失败，hook 00405AC0成功
    
57. //00405ABD  |.  8B45 E4       mov eax,[local.7]
    
58. //00405AC0  |>  E8 C0CB0F00   call HookDemo.00502685
    
59. //00405AC5  \.  C3            retn
    
60. //00405AC6  /$  33C0          xor eax,eax
    
61. //00405AC8  |.  3945 E4       cmp [local.7],eax
    
62. 
    
63. 
    
64. //请使用Release目录的HookTest.exe测试hook
    
65. 
    
66. BOOL APIENTRY DllMain( HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
    
67. {
    
68.         switch (ul_reason_for_call)
    
69.         {
    
70.         case DLL_PROCESS_ATTACH:
    
71.                 {
    
72.                         DWORD dwAddrMSGBOX = (DWORD)GetProcAddress(GetModuleHandle("user32.dll"), "MessageBoxW");
    
73.                         hook1.AddHook(dwAddrMSGBOX, Hook1Proc);
    
74.                         hook2.AddHook(0x00405AB1, Hook2Proc);
    
75.                         hook3.AddHook(0x00405AC0, Hook3Proc);
    
76.                         hook4.AddHook(0x00405AC5, Hook4Proc);//ret处hook会失败         
    
77.                 }
    
78.         case DLL_THREAD_ATTACH:
    
79.         case DLL_THREAD_DETACH:
    
80.         case DLL_PROCESS_DETACH:
    
81.                 break;
    
82.         }
    
83.         return TRUE;
    
84. }

复制代码

理论上存在的问题（也因为这点所以叫伪任意地址Hook）：
0x00：要hook的地址开始后5个字节，不能有retn,如下hook 00405AC5 处会失败，hook 00405AC0成功
//00405ABD  |.  8B45 E4       mov eax,[local.7]
//00405AC0  |>  E8 C0CB0F00   call HookDemo.00502685
//00405AC5  \.  C3            retn
//00405AC6  /$  33C0          xor eax,eax
//00405AC8  |.  3945 E4       cmp [local.7],eax