浅谈hook攻防

攻与防都是相对的，只有掌握细节才能更好的对抗。

基础知识

对于Windows系统，它是建立在事件驱动机制上的，说白了就是整个系统都是通过消息传递实现的。hook（钩子）是一种特殊的消息处理机制，它可以监视SEO靠我系统或者进程中的各种事件消息，截获发往目标窗口的消息并进行处理。所以说，我们可以在系统中自定义钩子，用来监视系统中特定事件的发生，完成特定功能，如屏幕取词，监视日志，截获键盘、鼠标输入等等。

钩子的种类SEO靠我很多，每种钩子可以截获相应的消息，如键盘钩子可以截获键盘消息，外壳钩子可以截取、启动和关闭应用程序的消息等。钩子可以分为线程钩子和系统钩子，线程钩子可以监视指定线程的事件消息，系统钩子监视系统中的所有SEO靠我线程的事件消息。因为系统钩子会影响系统中所有的应用程序，所以钩子函数必须放在独立的动态链接库(DLL) 中。

所以说，hook（钩子）就是一个Windows消息的拦截机制，可以拦截单个进程的消息(线程钩SEO靠我子)，也可以拦截所有进程的消息(系统钩子)，也可以对拦截的消息进行自定义的处理。Windows消息带了一些程序有用的信息，比如Mouse类信息，就带有鼠标所在窗体句柄、鼠标位置等信息，拦截了这些消息，SEO靠我就可以做出例如金山词霸一类的屏幕取词功能。

hook原理

在正确使用钩子函数前，我们先讲解钩子函数的工作原理。当创建一个钩子时，WINDOWS会先在内存中创建一个数据结构，该数据结构包含了钩子的相关信息，SEO靠我然后把该结构体加到已经存在的钩子链表中去。新的钩子将加到老的前面。当一个事件发生时，如果您安装的是一个线程钩子，您进程中的钩子函数将被调用。如果是一个系统钩子，系统就必须把钩子函数插入到其它进程的地址SEO靠我空间，要做到这一点要求钩子函数必须在一个动态链接库中，所以如果您想要使用系统钩子，就必须把该钩子函数放到动态链接库中去。

当然有两个例外：工作日志钩子和工作日志回放钩子。这两个钩子的钩子函数必须在安装钩SEO靠我子的线程中。原因是：这两个钩子是用来监控比较底层的硬件事件的，既然是记录和回放，所有的事件就当然都是有先后次序的。所以如果把回调函数放在DLL中，输入的事件被放在几个线程中记录，所以我们无法保证得到正SEO靠我确的次序。故解决的办法是：把钩子函数放到单个的线程中，譬如安装钩子的线程。

几点需要说明的地方：

（1） 如果对于同一事件（如鼠标消息）既安装了线程钩子又安装了系统钩子，那么系统会自动先调用线程钩子，然后SEO靠我调用系统钩子。

（2） 对同一事件消息可安装多个钩子处理过程，这些钩子处理过程形成了钩子链。当前钩子处理结束后应把钩子信息传递给下一个钩子函数。而且最近安装的钩子放在链的开始，而最早安装的钩子放在最后，SEO靠我也就是后加入的先获得控制权。

　　（3） 钩子特别是系统钩子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装钩子，在使用完毕后要及时卸载。

hook分类

hook从总体来说可以分成两类：

修改函数代码：ISEO靠我nline hook修改函数地址：IAT hook、SSDT hook、IRP hook、IDT hook等

局限性

如果修改函数地址，其实是很容易被检测到的，例如IAT hook可以通过自己的代码去找到SEO靠我在真正内存中的IAT表，再去对比函数的真正地址，SSDT hook可以通过内核重载比对函数地址来检测到，另外一个局限性就是只能hook对应表里面的函数，IAT表只能hook IAT表导出的函数

所以在实SEO靠我际的应用中一般Inline hook会使用得比较多，虽然相比于修改函数地址更不易检测到，但是还是有技术手段能够进行修改函数代码的检测，本文就基于Inline hook来从防守方制定hook检测的策略和SEO靠我攻击方如何绕过hook检测两方面来浅谈hook技术的攻防

Inline hook

API函数都保存在操作系统提供的DLL文件中，当在程序中使用某个API函数时，在运行程序后，程序会隐式地将API所在的DLSEO靠我L加载入进程中。这样，程序就会像调用自己的函数一样调用API。

在进程中当EXE模块调用CreateFile()函数的时候，会去调用kernel32.dll模块中的CreateFile()函数，因为真正SEO靠我的CreateFile()函数的实现在kernel32.dll模块中。

CreateFile()是API函数，API函数也是由人编写的代码再编译而成的，也有其对应的二进制代码。既然是代码，那么就可以被修SEO靠我改。通过一种“野蛮”的方法来直接修改API函数在内存中的映像，从而对API函数进行HOOK。使用的方法是，直接使用汇编指令的jmp指令将其代码执行流程改变，进而执行我们的代码，这样就使原来的函数的流程SEO靠我改变了。执行完我们的流程以后，可以选择性地执行原来的函数，也可以不继续执行原来的函数。

假设要对某进程的kernel32.dll的CreateFile()函数进行HOOK，首先需要在指定进程中的内存中找SEO靠我到CreateFile()函数的地址，然后修改CreateFile()函数的首地址的代码为jmp MyProc的指令。这样，当指定的进程调用CreateFile()函数时，就会首先跳转到我们的函数当中SEO靠我去执行流程，这样就完成了我们的HOOK了。

hook攻防

这里我选择使用MessageBoxA函数来进行hook的检测，因为MessageBoxA在hook之后能够比较清晰的看到结果

这里我首先使用win3SEO靠我2资源文件来创建一个图形窗口，功能是点击开始就会弹窗(不要问我为啥不用MFC写窗口，问就是不会 /狗头)，代码如下

// MessageBoxA.cpp : Defines the entry poinSEO靠我t for the application. //#include "stdafx.h" #include <windows.h> #include "SEO靠我resource.h"BOOL CALLBACK DialogProc( HWND hwndDlg, // handle to dialog box UINT uMsg, // message WPASEO靠我RAM wParam, // first message parameter LPARAM lParam // second message parameter ) { switch(SEO靠我uMsg) { case WM_INITDIALOG : return TRUE ; case WM_COMMAND : switch (LOWORD (wParam)) { case IDC_BUTSEO靠我TON_BEGIN : MessageBox(NULL,TEXT("使用hook来更改此界面"),TEXT("文本框"),MB_OK); return TRUE; }break ; case WM_CSEO靠我LOSE:{EndDialog(hwndDlg,0);break;}} return FALSE ; }int APIENTRY WinMain(HINSTANCE hInstanceSEO靠我,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow) {// TODO: Place code here.DialogBox(hSEO靠我Instance, MAKEINTRESOURCE (IDD_DIALOG_MAIN), NULL, DialogProc);return 0; }

这里生成的是一个没有任何检测代码的MSEO靠我essageBox测试程序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KC7SEVdJ-1652105984669)(image-20220403194929538.SEO靠我png)]

点击开始就会弹出文本框，我们hook要达到的目的就是修改文本框里面显示的文字

第一层

攻

这里就不细说Inline hook的细节了，跟到关键代码

定义我们要修改文本框内的值存放到szNewTextSEO靠我里面

看一下MessageBox的函数结构

int MessageBox([in, optional] HWND hWnd,[in, optional] LPCTSTR lpText,[in, optioSEO靠我nal] LPCTSTR lpCaption,[in] UINT uType );

这里我们直接选择在函数的起始位置进行hook

将szNewText赋给eax，再压到ESP + 0x24SEO靠我 + 0x8的位置，0x24是pushad和pushfd压入堆栈寄存器占用的内存，因为我们要修改MessageBox的第二个值，位于0x8偏移，修改值之后将寄存器还原并执行之前被覆盖的代码，然后通过jSEO靠我mp跳转回原函数

然后通过HookMessageBox进行Inline hook

BOOL HookMessageBox(BOOL bOpen) {BOOL bRet = FALSE;BYSEO靠我TE byJmpCode[PATCH_LENGTH] = {0xE9};DWORD dwOldProtect = 0;static BYTE byOriginalCode[PATCH_LENGTH] SEO靠我= {0};static BOOL bHookFlag = FALSE;memset(&byJmpCode[1],0x90,PATCH_LENGTH-1);*(DWORD*)&byJmpCode[1]SEO靠我 = (DWORD)NewMessageBox - (DWORD)dwHookAddress - 5;memcpy(byOriginalCode, (LPVOID)dwHookAddress, PATSEO靠我CH_LENGTH);if (bOpen){if (!bHookFlag){VirtualProtect((LPVOID)dwHookAddress, PATCH_LENGTH, PAGE_EXECUSEO靠我TE_READWRITE, &dwOldProtect);memcpy((LPVOID)dwHookAddress, byJmpCode, PATCH_LENGTH);::VirtualProtectSEO靠我((LPVOID)dwHookAddress, PATCH_LENGTH, dwOldProtect, 0);bHookFlag = TRUE;bRet = TRUE;}else{if (bHookFSEO靠我lag){VirtualProtect((LPVOID)dwHookAddress, PATCH_LENGTH, PAGE_EXECUTE_READWRITE, &dwOldProtect);memcSEO靠我py((LPVOID)dwHookAddress, byOriginalCode, PATCH_LENGTH);::VirtualProtect((LPVOID)dwHookAddress, PATCSEO靠我H_LENGTH, dwOldProtect, 0);bHookFlag = FALSE;bRet = TRUE;}}return bRet;} }

然后打包成dll，通过远程线程注入来SEO靠我hook

首先看一下没有hook的效果

通过远程线程注入，可以看到已经注入成功

然后这里再点击开始，可以看到文本框的内容已经是我们自己的内容

这里到汇编层面去看一下hook前后的变化，首先在MessageBoSEO靠我xA断点

在77D507EA的位置的汇编语句是mov edi,edi

注入dll之后再断MessageBoxA

在77D507EA的位置已经变成了jmp Hook.1000100F，即我们自己写的jmp语句SEO靠我

这里F7跟进去看看

可以发现这里正是我们通过_asm传入的语句

防

我们通过阅读MessageBox的源码可以发现，汇编语句里面是没有E9即jmp指令的，也就是说我们如果在MessageBox这一块内存里面SEO靠我检测到了有E9即jmp指令就可以认为MessageBox被hook

这里创建一个新线程检测在MessageBox的内存空间里是否有E9，这里因为MessageBox这里只有0x48字节的空间，这里就只循SEO靠我环判断80字节的空间里面有没有E9即可，如果发现E9则弹窗并直接退出进程

DWORD WINAPI Hook_E9_Thread(LPVOID lpParameter) {char MeSEO靠我ssageBoxAddrString[0x10] = {0};while(1){Sleep(500);sprintf(MessageBoxAddrString,"%x",*(char*)MessageSEO靠我Box);//MessageBox(0,0,MessageBoxAddrString,0);for (int i = 0; i < 80 ; i++){if (*(unsigned char*)MesSEO靠我sageBox + i == 0xE9){MessageBoxA(NULL,TEXT("MessageBoxA is been hooked"),TEXT("MessageBoxA is been hSEO靠我ooked"),MB_OK);::ExitProcess(0);}}}return 0;}DWORD Hook_E9() {HANDLE hThread;DWORD threadId;SEO靠我hThread = CreateThread(NULL, 0, Hook_E9_Thread, 0, 0, &threadId);return 0; }

这里首先启动程序

可以看到有两个线SEO靠我程

然后通过远程线程注入dll，这里显示dll已经注入成功，但是程序会退出，证明反调试成功

破

我们知道在汇编里面进行跳转一般有两个硬编码，分别为E8和E9，E8即为call，E9即为jmp

短跳转：机器码为SEO靠我2个字节EB XX，E8是call的硬编码，XX是跳转范围-128~127长跳转：机器码为5个字节E9 XX XX XX XX，E9是jmp的硬编码，剩下4个字节表示转移偏移量

我们知道如果要对E9进行SEO靠我监控肯定只会在MessageBoxA这块内存空间进行监控，那么我们就可以通过E8短跳到其他地址，再通过E9长跳到我们自己的函数

第二层

防

在第一层的hook攻防中，我们首先用常规方式被hook，然后使用ESEO靠我8指令代替E9来实现了绕过hook的效果，作为蓝队人员也对检测机制进行了升级，在第二层hook攻防中，蓝方成员选择的是CRC/全代码校验。通俗来说，就是把某个API的硬编码给抠出来，单独起一个线程一直SEO靠我循环比对，无论是使用E8还是E9都会修改内存中的硬编码，这时候就会被检测到。CRC校验的定义如下：

因为CRC校验的实现难度较大，这里我就使用抠出MessageBox硬编码的方式，这里MessageBoSEO靠我x的内存范围就是77D507EA到77D50832这一块

这里有一个坑，如果对着上面的硬编码抠的话有些硬编码是没有显示出来的，这里最好是对着下面的内存窗口抠

然后将抠出来的硬编码存放到szAPICode里SEO靠我面，使用memcmp函数进行比较，并用VirtualProtect来改变内存的读写情况，如果不相等则使用ExitProcess()结束进程

if (memcmp((LPVOID)MessageBoxAdSEO靠我dr, szAPICode, 0x30) != 0){BOOL bRet = VirtualProtect((LPVOID)MessageBoxAddr, 0x10, PAGE_READWRITE, SEO靠我&dwOldProtect);if (bRet){::memcpy((LPVOID)MessageBoxAddr, szAPICode, 0x30);::VirtualProtect((LPVOID)SEO靠我MessageBoxAddr,0x10, dwOldProtect, &dwOldProtect);}MessageBoxA(NULL,TEXT("MessageBoxA is been hookedSEO靠我"),TEXT("MessageBoxA is been hooked by CRC"),MB_OK);::ExitProcess(0);}

然后检验一下，首先启动exe

然后还是使用之前的dll进行远程SEO靠我线程注入，这里可以看到被检测到hook

攻

当检测程序使用了全代码校验的情况下，就不能使用常规的方式去进行hook，这里我们去逆向分析一下代码

硬件断点

首先定位到MessageBox，尝试直接软件断点，这里SEO靠我软件断点的原理就是将8B这个硬编码改为CC，也就是说在全代码校验的情况下肯定是会被拦截的

果然不出所料拦截了

程序直接退出

我们在内存里面找到77D507EA

右键下一个硬件访问断点，我们知道硬件断点的原理是SEO靠我通过控制dr0-dr3寄存器的值来实现异常，也就是说我们不会去修改内存里面的值

可以看到断到了全代码的检测函数

这里单步往下跟，到call MessageB.memcmp是比较的关键

可以看到memcmp这SEO靠我个函数就是将edi和esi所在地址里面存的值存入cl和dl，如果相等继续往下走，取下一个地址里面存的值放入，不相等则直接跳转到0040114A

到00401118这个地址，如果上面都没有跳转，则又继续回SEO靠我到004010FD这个地址，可以发现这就是一个循环比较的过程，这里当eax的值减为0的时候结束循环

那么我们就可以将比较的jcc语句直接置为nop，然后让最后跳转会函数起始地址的jcc语句直接改为jmpSEO靠我，即恒执行循环

修改完成后我们删除硬件断点

再次执行hook，注入成功

线程挂起

这里因为我们的程序比较简单，通过线程很容易看出来哪个线程是检测线程，这里我们直接将检测线程挂起

然后进行注入也可以注入成功

第三层SEO靠我

防

我们从第二层的hook攻防可以得出两种思路，因为我们程序的逻辑比较简单，那么我们在进行逆向分析的过程中很容易找到程序运行的逻辑点，对于相对复杂的程序，这种方法是行不通的，第二种思路当然也有一定的局限SEO靠我性，但是总体来说实现也还是比较容易

那么作为防守方，又想出了相应的对策：

对于硬件断点修改逻辑，防守方选择写多个call嵌套，在其中的一个call里面retn，但是不是retn到初始call的下一行，而是SEO靠我跳转到其他地址。那么当调试者看到这个call的时候，因为逻辑很复杂，会选择直接步过，如果直接步过，因为retn的地址并不是下一行，这样就会跟丢

对于挂起线程，同时起多个线程互相检测是否都处于活动状态，例SEO靠我如A检测B，B检测C，C检测D，D再检测防止hook的线程，这样就会使攻击方的工作量大大提升

攻

对于防守方的策略可以概括为：首先对API进行全代码校验，然后通过多个线程互相监控线程状态，对VirtualSEO靠我Protect和ExitProcess进行挂钩处理。那么针对防守方的策略我们可以想到两种方法进行绕过，一种是通过逆向分析检测线程的代码，通过寻找代码的漏洞进行绕过，另一种方法就是通过CPU层面的DR0SEO靠我-DR7寄存器实现硬件断点来触发异常。

瞬时钩子

假设这里我们已经通过逆向分析找到了主监测线程的代码，这里可以发现是先监测E9，再监测ExitProcess有没有被hook，然后再检测MessageBoxSEO靠我A有没有被hook，这里我们的一个想法是直接hook ExitProcess函数，但是这里因为有另外一个线程监控着主线程，如果直接hook程序也会直接退出，那么我们可以发现主检测线程的一个漏洞点，就是SEO靠我先检测ExitProcess有没有被hook，再继续往下走，那么我们就可以在1这个地方给ExitProcess挂钩，这里要注意VirtualProtect这个函数并不是只有我们一个线程在使用，所以这里SEO靠我需要写一个判断确认当前的地址，然后在2这个地方ExitProcess因为被hook的关系不会正常退出，在即将进入下一个循环的时候将钩子摘除，即可达到瞬时钩子的效果

那么我们首先hookVirtualPrSEO靠我otect，这里我就直接用E9来hook，如果有E9的检测就可以用E8来跳

BOOL bRet = FALSE;BYTE byJmpCode[PATCH_LENGTH_VP] = { 0xE9 };DWSEO靠我ORD dwOldProtect = 0;static BYTE byOriginalCode[PATCH_LENGTH_VP] = { 0 };static BOOL bHookFlag = FALSEO靠我SE;// 初始化 byJmpCodememset(&byJmpCode[1], 0x90, PATCH_LENGTH_VP - 1);// 存储跳转地址*(DWORD*)&byJmpCode[1] SEO靠我= (DWORD)NewVirtualProtect - (DWORD)dwHookAddressVP - 5;// 备份被覆盖的 Codememcpy(byOriginalCode, (LPVOIDSEO靠我)dwHookAddressVP, PATCH_LENGTH_VP);

然后把要hook的地址存到数组里面

VirtualProtect((LPVOID)dwHookAddressVP, PATCH_LESEO靠我NGTH_VP, PAGE_EXECUTE_READWRITE, &dwOldProtect); memcpy((LPVOID)dwHookAddressVP, byJmpCode, SEO靠我PATCH_LENGTH_VP); VirtualProtect((LPVOID)dwHookAddressVP, PATCH_LENGTH_VP, dwOldProtect, 0);SEO靠我

这里VirtualProtect在内存中的地址可以通过GetProcAddress配合LoadLibrary获取

dwHookAddressVP = (DWORD)GetProcAddress(LoadSEO靠我Library("kernel32.dll"), "VirtualProtect");

在NewVirtualProtect使用asm调用VirtualProtectProc为ExitProcess挂钩SEO靠我

void VirtualProtectProc() {dwHookAddressVP = (DWORD)GetProcAddress(LoadLibrary("kernel32.dll"), "ExiSEO靠我tProcess");OutputDebugString("VirtualProtect 开始挂钩 , hook ExitProcess successfully");HookExitProcess(SEO靠我TRUE); }

再就是hook ExitProcess，跟hook VirtualProtect的方法相同

BOOL bRet = FALSE;BYTE byJmpCode[PATCH_SEO靠我LENGTH_EP] = { 0xE9 };DWORD dwOldProtect = 0;static BYTE byOriginalCode[PATCH_LENGTH_EP] = { 0 };staSEO靠我tic BOOL bHookFlag = FALSE;// 初始化 byJmpCodememset(&byJmpCode[1], 0x90, PATCH_LENGTH_EP - 1);// 存储跳转地SEO靠我址*(DWORD*)&byJmpCode[1] = (DWORD)NewExitProcess - (DWORD)dwHookAddressEP - 5;// 备份被覆盖的 Codememcpy(bySEO靠我OriginalCode, (LPVOID)dwHookAddressEP, PATCH_LENGTH_EP);

同样将地址存入数组

VirtualProtect((LPVOID)dwHookAddresSEO靠我sEP, PATCH_LENGTH_EP, PAGE_EXECUTE_READWRITE, &dwOldProtect); memcpy((LPVOID)dwHookAddressEPSEO靠我, byJmpCode, PATCH_LENGTH_EP); VirtualProtect((LPVOID)dwHookAddressEP, PATCH_LENGTH_EP, dwOlSEO靠我dProtect, 0);

然后同样在NewExitProcess里面将钩子摘除，避免在进入下一个循环的时候被检测到

void ExitProcessProc() {// 卸载瞬时 HOOSEO靠我K 避免被检测到OutputDebugString("ExitProcess 开始卸载 , unhook ExitProcess successfully");HookExitProcess(FALSSEO靠我E); }

再就是hook MessageBox的函数，这里直接用之前写好的Inline hook挂钩到NewMessageBox即可

void __declspec(naked) NewSEO靠我MessageBox() {__asm {pushadpushfdlea eax, dword ptr ds : [szNewText] mov dword ptr ss : [esp + 0x24 SEO靠我+ 8] , eaxpopfdpopadmov edi, edipush ebpmov ebp, espjmp dwRetAddress} }

然后加载dll

首先在VirtualProtSEO靠我ect挂钩ExitProcess，再对MessageBox进行hook，再将ExitProcess的钩子摘除，如此循环往复

看一下实现的效果，这里还是执行一下hook之前的程序

然后远程线程注入瞬时钩子的SEO靠我dll，修改文本框内容成功，可以看到windbg里面挂钩函数跟卸载函数是不断的交替执行的，hook成功

硬件钩子

我们知道硬件断点是基于线程的，因为每个线程的CONTEXT结构是不同的，这里首先就需要找到SEO靠我我们要修改dr寄存器的线程，也就是我们要hook的检测线程，找到线程之后我们通过OpenThread去获得线程的句柄，然后通过SetUnhandledExceptionFilter去注册一个异常处理函SEO靠我数，注册完成之后就可以更改dr寄存器的值来触发访问/写入/执行断点，然后再通过SetThreadContext放到CONTEXT结构里面即可

那么这里先找到OpenThread和MessageBoxA在SEO靠我内存中的地址

g_fnOpenThread = (FNOPENTHREAD)::GetProcAddress(LoadLibrary("kernel32.dll"), "OpenThread");g_dSEO靠我wHookAddr = (DWORD)GetProcAddress(GetModuleHandle("user32.dll"),"MessageBoxA");

然后拍摄快照遍历线程

HANDLE hTooSEO靠我l32 = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);

定位到我们要hook的线程

if (Thread32First(hTool32, &threadSEO靠我_entry32)){do{if (thread_entry32.th32OwnerProcessID == GetCurrentProcessId()){dwCount++; if (dwCountSEO靠我 == 1)

这里定位到线程之后我们把THREADENTRY32里面的进程ID和线程ID打印出来

char szBuffer[0x100]; ZeroMemory(szBuffer,0x1SEO靠我00); sprintf(szBuffer, "PID:%x - TID:%x\n", thread_entry32.th32OwnerProcessID, thread_entry3SEO靠我2.th32ThreadID); OutputDebugString(szBuffer);

然后通过内存中定位的OpenThread得到线程的句柄

hHookThread = g_fnOpSEO靠我enThread(THREAD_SET_CONTEXT | THREAD_GET_CONTEXT | THREAD_QUERY_INFORMATION, FALSE, thread_entry32.tSEO靠我h32ThreadID);

拿到线程句柄之后我们通过SetUnhandledExceptionFilter注册一个异常处理函数MyExceptionFilter

SetUnhandledExceptionSEO靠我Filter(MyExceptionFilter);

通过ExceptionRecord里面的ExceptionCode判断错误码是否为EXCEPTION_SINGLE_STEP即单步异常以及ExcepSEO靠我tionAddress判断是否到我们设置hook的地址，然后通过ChangeContext修改CONTEXT，再修改EIP

LONG WINAPI MyExceptionFilter(PEXCEPTIOSEO靠我N_POINTERS pExceptionInfo) {if (pExceptionInfo->ExceptionRecord->ExceptionCode == EXCEPTION_SEO靠我SINGLE_STEP){if((DWORD)pExceptionInfo->ExceptionRecord->ExceptionAddress == g_dwHookAddr){PCONTEXT pSEO靠我Context = pExceptionInfo->ContextRecord;ChangeContext(pContext);pContext->Eip = (DWORD)&OriginalFuncSEO靠我;return EXCEPTION_CONTINUE_EXECUTION;}}return EXCEPTION_CONTINUE_SEARCH; }

这里ChangeContext要实现SEO靠我的功能就是修改文本框中的内容，esp指向的是MessageBox，那么esp+8即为MessageBox的第二个参数

void ChangeContext(PCONTEXT pContext) SEO靠我 {char szBuffer[0x100];DWORD dwOldProtect = 0;DWORD dwLength = 0;LPSTR lpOldText = NULL;char szNeSEO靠我wText[] = "SEH Hook successfully";lpOldText = (LPSTR)(*(DWORD*)(pContext->Esp + 0x8));dwLength = strSEO靠我len(lpOldText);VirtualProtect(lpOldText, dwLength, PAGE_EXECUTE_READWRITE, &dwOldProtect);memcpy(lpOSEO靠我ldText, szNewText, dwLength);VirtualProtect(lpOldText, dwLength, dwOldProtect, 0); }

然后就是Eip修SEO靠我改到hook+2的位置，我们知道一般API起始的位置都是mov edi,edi，不能从这个起始位置执行，否则会死循环

g_dwHookAddrOffset = g_dwHookAddr + 2;voidSEO靠我 __declspec(naked) OriginalFunc(void) {__asm{mov edi,edijmp [g_dwHookAddrOffset]} }

然SEO靠我后将hook的地址放到dr0寄存器里面，设置dr7的L0位为1即局部有效，断点长度设置为1即18、19位设置为0即可，断点类型设置为访问断点对应的值为0(20、21位设置为0)，这样dr7寄存器的1-SEO靠我31位都为0，32位为1，所以将dr7寄存器的值设置为1。然后通过SetThreadContext存入CONTEXT结构

threadContext.Dr0 = g_dwHookAddr;threadCSEO靠我ontext.Dr7 = 1;SetThreadContext(hHookThread, &threadContext);CloseHandle(hHookThread);

首先看一下没有hook之前

这SEO靠我里在ChangeContext里面将CONTEXT结构里面的EAX和ECX寄存器打印出来，修改文本框的内容为SEH Hook successfully

然后注入dll，hook成功

打印出了EAX和ECXSEO靠我

这里再打印出PID跟TID，证明hook成功