S.l.e!ep.￠%

像打了激速一样，以四倍的速度运转，开心的工作
简单、开放、平等的公司文化；尊重个性、自由与个人价值；
posts - 1098, comments - 335, trackbacks - 0, articles - 1
  C++博客 :: 首页 :: 新随笔 :: 联系 :: 聚合  :: 管理

跨进程API Hook

Posted on 2009-11-06 12:05 S.l.e!ep.￠% 阅读(848) 评论(0)  编辑 收藏 引用 所属分类: RootKit

【转】跨进程API Hook

什么是“跨进程APIHook”？

众所周知Windows应用程序的各种系统功能是通过调用API函数来实现。API Hook就是给系统的API附加上一段小程序，它能监视甚至控制应用程序对API函数的调用。所谓跨进程也就是让自己的程序来控制别人程序的API调用了。
API Hook 理论

通过对Win32 PE文件的分析(如果你还不熟悉PE文件格式，可以看看Iczelion的PE教程或者LUEVELSMEYER的<<The PE File Format>>)。我们知道在PE文件中的IMPORT TABLE内存储着API函数的很多信息。其中包括API的函数名，调用地址等等。而操作系统在执行PE文件时会先将其映射到内存中。在映射的同时还会把当前版本操作系统中API函数的入口地址写入IMPORT TABLE中一组与API调用相关的结构体内，用于该应用程序的API调用。当应用程序调用API时，他会在自己内存映像里寻找API的入口地址，然后执行CALL指令。如此一来，我们通过修改应用程序内存映像的IMPORT TABLE中API函数的入口地址，就可以达到重定向API的目的。将API地址改为我们自己函数的地址，这样我们的函数就可以完成对API的监视和控制了。
API Hook 的实现
  1. /* 1 */HANDLE hCurrent = GetModuleHandle(NULL);
  2. /* 2 */IMAGE_DOS_HEADER *pidh;
  3. /* 3 */IMAGE_NT_HEADERS *pinh;
  4. /* 4 */IMAGE_DATA_DIRECTORY *pSymbolTable;
  5. /* 5 */IMAGE_IMPORT_DESCRIPTOR *piid;

  7. /* 6 */pidh = (IMAGE_DOS_HEADER *)hCurrent;
  8. /* 7 */pinh = (IMAGE_NT_HEADERS *)((DWORD)hCurrent + pidh->e_lfanew);
  9. /* 8 */pSymbolTable = &pinh->OptionalHeader.DataDirectory[1];
  10. /* 9 */piid =(IMAGE_IMPORT_DESCRIPTOR *)((DWORD)hCurrent +  pSymbolTable->VirtualAddress);
  11. /*10 */do {
  12. /*11 */    IMAGE_THUNK_DATA *pitd,*pitd2;
  13. /*12 */    pitd = (IMAGE_THUNK_DATA *)((DWORD)hCurrent + piid->OriginalFirstThunk);
  14. /*13 */    pitd2 = (IMAGE_THUNK_DATA *)((DWORD)hCurrent + piid->FirstThunk);
  15. /*14 */    do {
  16. /*15 */ IMAGE_IMPORT_BY_NAME *piibn;
  17. /*16 */ piibn = (IMAGE_IMPORT_BY_NAME *)((DWORD)hCurrent +  *((DWORD *)pitd));
  18. /*17 */ PROC *ppfn = (PROC *)(pitd2->u1.Function);
  19. /*18 */ if (!strcmp("MessageBoxW",(char *)piibn->Name)) {
  20. /*19 */     oldMsg = (MsgBoxType)(ppfn);
  21. /*20 */     DWORD addr = (DWORD)MyMessage;
  22. /*21 */     DWORD written = 0;
  23.       /* 改变内存读写状态 */
  24. /*22 */     DWORD oldAccess;
  25. /*23 */     VirtualProtect(&pitd2->u1.Function,sizeof(DWORD),PAGE_WRITECOPY,&oldAccess);
  26. /*24 */     APIAddress = (DWORD)&pitd2->u1.Function;
  27.       /* 向内存映像写入数据 */
  28. /*25 */     WriteProcessMemory(GetCurrentProcess(),&pitd2->u1.Function, &addr,sizeof(DWORD), &written);
  29. /*26 */ }
  30. /*27 */ pitd++;pitd2++;
  31. /*28 */    } while (pitd->u1.Function);

  33. /*29 */    piid++;
  34. /*30 */} while (piid->FirstThunk + piid->Characteristics
  35.   + piid->ForwarderChain + piid->Name + piid->TimeDateStamp);
复制代码
分析:
寻觅IMPORT TALBE

在/*1*/中我们使用GetModuleHandle(NULL)来返回当前进程在内存中映像的基地址。但这个值在文档中仅仅被描述为"a module handle for the specified module"，虽然他确实是进程内存映像的基地址。如果你不太放心的话也可以使用，GetModuleInformation函数来获得基地址，只不过你要额外包含psapi.h和psapi.lib了(这个库在VC6里没有，所以我就没有用这个函数了)。在/* 6 */里我们先找到IMAGE_DOS_HEADER结构，他的起始地址就是映像的基地址。/*7*/通过IMAGE_DOS_HEADER给出的PE文件头的偏移量，找到IMAGE_NT_HEADERS结构。顺藤摸瓜，IMAGE_NT_HEADERS里的OptionalHeader中的DataDirectory数组里的第二个元素正是指向我们想要的IMPORT TABLE的地址。在/*9*/中我们将其转化为一个IMAGE_IMPORT_DESCRIPTOR的结构指针存入piid中。
替换的API函数入口地址

在/*12*/和/*13*/中我们分别取得OriginalFirstThunk和FirstThunk结构，用于以后得到API函数的名称和入口地址。/*10*/的do循环让我们遍历每一个IMAGE_IMPORT_DESCRIPTOR结构也就是应用程序引用的每个DLL。在/*14*/的循环中我们遍历DLL中的IMAGE_THUNK_DATA结构来一一查询API的信息。/*16*/中我们将OriginalFirstThunk转换为IMAGE_IMPORT_BY_NAME结构用于获得API函数的名称进行比对。在/*18*/我们找到MessageBoxW函数之后，在/*19*/保存其原始入口地址便于以后恢复时使用。在/*23*/我们需要用VirtualProtect改变一下内存区域的读写性，因为一般应用程序的映像都是只读的，直接写入会造成一个非法访问的异常出现。在/*25*/我们写入自己函数的地址。

这样就基本完成一个API函数的重定向。
其他

恢复函数的API入口地址相对比较简单。只要把保存的值再写回去就可以了。上面的程序中/*24*/我用APIAddress保存了存有MessageBoxW入口地址的地方的地址，便于以后调用WriteProcessMemory恢复时使用。
跨进程理论

我们要用自己的函数来替代别人程序里的API函数，但我们的函数与别人的程序处于不同的进程空间内啊。不同的进程空间是不能相互调用函数的。因此我们要想办法把自己的函数放入别人的进程空间去。这时我们就需要使用DLL injection技术了。如果你对她还不是十分熟悉的话，建议看看Jeffrey Richter大师的<<;Programming Applications for Microsoft Windows>>，也可以参考陈宽达先生的<<C++ Builder深度历险>>。

简而言之，DLL injection就是想办法让对方的进程加载我们的一个DLL程序，把需要替换的函数放在我们这个DLL里。如此一来，我们的函数就进入了别人的进程空间了。DLL injection方法很多，Richter大师在书中对各方法利弊有详细解释，陈宽大先生的书中也有深入的分析。我在这里使用SetWindowsHookEx函数来达到目的。主要有这几个原因: 1, 不用重新启动系统，调试方便。2, 可以利用消息循环机制进行两个进程之间的通信，可以较好的掌握Hook的状态。便于安装与卸载。

SetWindowsHookEx之所以能完成DLL injection是因为它要给一个应用程序某个环节加上一个Hook,而Hook就要有Hook Procedure也就是Hook函数。如果这个Hook函数在一个DLL中，那么系统就会把这个DLL加载到SetWindowsHookEx的目标进程上。从而也就达到了我们DLL injection的目的了。当然这里我们会用WH_GETMESSAGE的Hook进行injection,因为这个Hook可以用来监视目标进程的消息循环方便我们的进程与目标进程通信。
跨进程的实现和几点注意
  1. /* DllPart.Dll */
  2. #include <windows.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. typedef (WINAPI *MsgBoxType)(HWND,LPCWSTR,LPCWSTR,UINT);
  7. MsgBoxType oldMsg;  /*API原入口地址*/
  8. DWORD APIAddress; /*存储API入口地址的地方的地址*/
  9. int WINAPI  MyMessage(HWND hWnd ,LPCWSTR M1,LPCWSTR M2, UINT M3) {
  10. /* 这是用来替换的函数 */
  11. return oldMsg(hWnd,buf,M2,MB_OK);
  12. }
  13. const char szApp[] = "DllPart.dll";
  14. HHOOK hHook; /*Hook的句柄*/
  15. HMODULE hInst; /*DLL 模块句柄，用于SetWindowsHookEx函数*/
  16. HWND hTarget; /*目标窗口句柄*/
  17. /*DLL 入口*/
  18. BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID lpvReserved)
  19. {
  20.     hInst = inst;
  21.     switch (reason) {
  22. case DLL_PROCESS_ATTACH:
  23.      /*调试信息，表示DLL已经加载*/
  24.      MessageBox(NULL,"DLL_PROCESS_ATTACH",szApp,MB_OK);
  25.      break;
  26. case DLL_PROCESS_DETACH:
  27.      /*调试信息，表示DLL已经卸载*/
  28.      MessageBox(NULL,"DLL_PROCESS_DETACH",szApp,MB_OK);
  29.      break;
  30.     }
  31.     return true;
  32. }
  33. /*显示GetLastError的信息*/
  34. void showerr(const char *m) {
  35.     char message[255];
  36.     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,0,GetLastError()
  37. ,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),message,255, 0);
  38.     MessageBox(NULL,message,m,MB_OK);
  39. }
  40. //-----------------------
  41. void UnHookApi() {
  42. /*卸载API Hook用*/
  43. }
  44. void HookApi() {
  45. /*加载API Hook同上面介绍的函数一样*/
  46. }
  47. //-----------------------
  48. /*用于WH_GETMESSAGE的Hook Procedure*/
  49. LRESULT CALLBACK GetMsgProc(int nCode,WPARAM wParam, LPARAM lParam) {
  50. if (nCode == HC_ACTION) {
  51.      MSG *msg = (MSG *)lParam;
  52.      if (msg->message == WM_CHAR) {
  53.       if (msg->wParam == 'h') HookApi();
  54.       if (msg->wParam == 'u') UnHookApi();
  55.      }
  56. }
  57.     return CallNextHookEx(hHook,nCode,wParam,lParam);
  58. }
  59. extern "C" __declspec(dllexport) SetAPIHook(HWND handle) {
  60.     DWORD ThreadId = GetWindowThreadProcessId(handle, NULL);
  61.     hTarget = handle;
  62.     MessageBox(NULL, "Enabling CallWndProc Hook", szApp, MB_OK);
  63.     hHook = SetWindowsHookEx(WH_GETMESSAGE,GetMsgProc,hInst,ThreadId);
  64.     if (hHook) {
  65. MessageBox(NULL,"Hook OK!", szApp, MB_OK);
  66.     } else {
  67. showerr("SetWindowsHookEx");
  68.     }
  69. }
  70. extern "C" __declspec(dllexport) UnHookAPIHook() {
  71.     MessageBox(NULL, "Disenabling CallWndProc Hook", szApp, MB_OK);
  72.     if (UnhookWindowsHookEx(hHook)) {
  73.         MessageBox(NULL,"UnHook OK!", szApp, MB_OK);
  74.     } else {
  75. showerr("UnHookWindowsHookEx");
  76.     }
  77. }
复制代码
分析
几个需要注意的问题

SetAPIHook和UnHookAPIHook是我们自己进程调用的用来加载WH_GETMESSAGE Hook的函数。由于我们的程序要用LoadLibrary加载这个Dll因此这两个函数要用__declspec(dllexport)修饰，使其成为导出函数，才能被GetAddressProc函数找到。加上 extern "C"是让编译器使用C语言编码方式。因为C++编译器会进行Dynamic Binding(C++函数重载的实现),将函数的参数类型附加到名称上。是函数的导出名看起来像SetAPIHook@XYTZX之类的,不利于GetAddressProc进行引用。因此使用extern "C"让编译器不使用Dynamic Binding，自然使用extern"C"的函数也就不能被重载了。

不要忘记在GetMsgProc最后要调用CallNextHookEx函数，保证Hook链的完整性。

一定要在Hook Procedure中调用HookApi和UnHookApi函数，因为保存API入口地址的地方在目标进程中，你必须在目标进程的进程空间内完成卸载操作，不能在UnHookAPIHook或是SetAPIHook函数中调用，因为UnHookAPIHook是我们的进程调用的，因此在我们的进程空间中。在这里使用UnHookApi会造成一个非法访问的错误。而使用HookApi会给自己的DLL加上API Hook。

SetWindowsHookEx的最后参数是ThreadId不是Handle,因此要通过调用GetWindowThreadProcessId转换一下。
在跨进程API HOOK时可能用到的其他技术
主进程与目标进程的信息交互和共享

由于使用了WH_GETMESSAGE钩子我们可以利用Windows消息机制实现进程间通讯。需要注意的是应该使用PostThreadMessage来发送让WH_GETMESSAGE得到的消息而不是SendMessage或者PostMessage,因为后两个是用来给窗口发送消息的。而我们的WH_GETMESSAGE是Hook在线程上面的，因此需使用PostThreadMessage.

传递不太大的数据可以使用WM_COPYDATA消息来进行。同样也应该注意，如果使用MFC的窗口过程获得消息就需要用SendMessage发送了。WM_COPYDATA的使用相对简单可以参考MSDN的文档。也可以参考附录里的程序Hook.cpp的showerr函数部分。

如果传递较大的数据或者希望数据共享比较方便可以开辟共享内存来进行数据共享。这里简单分析一下使用共享内存的代码
  1. HANDLE hMap;
  2. switch (reason) {
  3.     case DLL_PROCESS_ATTACH:
  4.     /*创建/打开共享内存区域*/
  5.     hMap = CreateFileMapping((HFILE *)0xFFFFFFFF,NULL,PAGE_READWRITE,0,sizeof(GLOBALDATA),ID_MAP);
  6.     pg_data = (GLOBALDATA*)MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS,0 ,0 ,0);
  7.     if (!pg_data) {
  8. MessageBox(NULL,"无法建立共享内存，程序终止！",szApp,MB_OK);
  9. if (hMap) {
  10.      CloseHandle(hMap);
  11.      hMap = NULL;
  12.      return 0;
  13.        }
  14.     }
  15.     pg_data->hInst = hInst;
  16.     showerr("共享内存映像文件");
  17.     showerr("DLL装载中...",FALSE);
  18.     break;
  19.     case DLL_PROCESS_DETACH:
  20.     if (pg_data) {
  21.         UnmapViewOfFile(pg_data);
  22. pg_data = NULL;
  23.     }
  24.     if (hMap) {
  25. CloseHandle(hMap);
  26. hMap = NULL;
  27.      }
  28.     break;
  29. }
复制代码
上面的代码通过CreateFileMapping建立共享区域。将其第一个参数设置为0xFFFFFFFF使其能创建一个内存共享区域而不是文件。并标记为可读写的(PAGE_READWRITE).其大小为我们定义的结构体GLOBALDATA的大小。最后的ID_MAP是一个用来标示这个区域的字符串。打开或者创建完共享区域后，我们用MapViewOfFile来获得这个区域的地址。之后就可以直接使用pg_data来操作共享区域了。不要忘记在DLL退出的时候安全的删除共享区域释放内存。
消息等待与安全卸载

在我们卸载WH_GETMESSAGE钩子之前必须先把目标程序的API调用恢复正常。我们不能再调用UnHookApi之后就立刻调用UnhookWindowsHookEx,因为很有可能UnHookApi还没来得急完成API入口地址的恢复操作，WH_GETMESSAGE钩子就已经被卸载了。因此需要等待一段时间，等UnHookApi完成了恢复操作在调用UnhookWindowsHookEx。以防错误发生。
  1. extern "C" __declspec(dllexport) void UnHookAPIHook() {
  2.     /*向目标线程发送消息进行API UNHOOK*/
  3.     PostThreadMessage(pg_data->idTarget,WM_DISABLEAPIHOOK,(WPARAM)GetCurrentThreadId(),0);
  4.     showerr("WM_DISABLEAPIHOOK");
  5.     /*等待目标进程返回WM_UNHOOKOK消息，确认可以将WH_GETMESSAGE的HOOK去掉*/

  7.     MSG Msg;
  8.     do {
  9.         GetMessage(&Msg,NULL,0,0);
  10.     }while(Msg.message !=  WM_UNHOOKOK);
  11.     UnhookWindowsHookEx(pg_data->hHook);
  12.     PostThreadMessage(pg_data->idTarget,WM_DISABLEAPIHOOKOK,(WPARAM)GetCurrentThreadId(),0);
  13.     showerr("UnHookWindowsHookEx");
  14. }
复制代码
上面的代码中我们使用一个含有GetMessage的循环来等待消息的到达，一旦UnHookApi完成他就会发送WM_UNHOOKOK消息。等我们接收到消息确认一切安全了在来卸载WH_GETMESSAGE钩子。
弄清消息对象

我们一定要清楚代码是在主程序进程空间中执行的还是在目标程序进程空间中执行的。像上面的UnHookAPIHook函数就是通过主程序调用的，因此在主程序进程空间中执行。这样一来用来恢复目标程序API信息的UnHookApi完成后就应该向主程序发送消息，而不是目标程序。
目标进程加载了其他DLL

如果目标进程动态加载了其他的DLL文件，我们必须监视LoadLibrary函数。保证DLL中的API入口地址也被正确修改。防止出现混乱的情况。我从LoadLibrary获得DLL的路径用于GetModuleHandle来取得他的ImageBase的地址。
不知道文章写的如何，希望大家能多给些批评意见。发现问题我马上改正

Email: detrox@yang.com.cn
参考资料

<<;Programming Applications for Microsoft Windows>>, Jeffrey Richter, Microsoft Press

<<C++ Builder 深度历险>>,陈宽达,华中科大出版社

<<The PE File Format>>, LUEVELSMEYER

<<Iczelion's PE Tutorial>>, Iczelion
附:跨进程APIHook的例子

先打开一个记事本程序并输入几个字符，运行下面的程序，加载APIHook.之后在记事本的文件菜单中选择新建就会看到API Hook将MessageBoxW 函数Hook的结果了.
代码在WinXP SP1 + VC6.0测试成功。

下载源代码

(特别感谢老罗的代码着色器，比我自己那个好多了)
这是DLL的程序，Hook.dll
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "mydef.h"

  7. const char szApp[] = "Hook.dll"; /*应用程序名称*/
  8. HANDLE hMap;/*在共享内存映像的句柄*/
  9. GLOBALDATA *pg_data; /*在共享内存中的全局数据*/
  10. LRESULT CALLBACK GetMsgProc(int,WPARAM, LPARAM);

  12. /*显示GetLastError指出的错误*/
  13. void showerr(const char *m, BOOL GetError = TRUE) {
  14.     char message[127];
  15.     char buf[255];
  16.     COPYDATASTRUCT cds;
  17.     if (GetError)
  18.         FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,0
  19.   ,GetLastError(),MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),message,127, 0);
  20.     else
  21.         *message = 0;
  22.     if (GetCurrentThreadId() != pg_data->idMain)
  23.         sprintf(buf,"目标程序空间DLL: %-30s [%-40s]",m, message);
  24.     else
  25.         sprintf(buf,"主程序空间DLL  : %-30s [%-40s]",m, message);
  26.     cds.lpData = buf;
  27.     cds.cbData = sizeof(buf);
  28.     cds.dwData = 0;
  29.      SendMessage(pg_data->hWndMain,WM_COPYDATA,(WPARAM)pg_data->hWndTarget,(LPARAM)&cds);
  30.       SetLastError(0);
  31. }
  32. int WINAPI MyMessageBoxW(HWND hWnd ,LPCWSTR M1,LPCWSTR M2, UINT M3) {
  33.     wchar_t buf[255];
  34.     swprintf(buf,L"!!这个窗口的API被Hook了!!\nHWND: 0x%08X\nMessage: %s\nCaption: %s"
  35.         ,(DWORD *)hWnd
  36.         , M1
  37.         , M2);
  38.     pg_data->oldAPIFunction(hWnd,buf,M2,MB_OK);
  39.     return pg_data->oldAPIFunction(hWnd,M1,M2,M3);
  40. }

  42. /*DLL 入口函数*/
  43. BOOL WINAPI DllMain(HINSTANCE hInst, DWORD reason,LPVOID lpvReserved)
  44. {
  45.     switch (reason) {
  46.     case DLL_PROCESS_ATTACH:
  47.         /*创建/打开共享内存区域*/
  48.         hMap = CreateFileMapping((HFILE *)0xFFFFFFFF,NULL,PAGE_READWRITE,0,sizeof(GLOBALDATA),ID_MAP);
  49.         pg_data = (GLOBALDATA*)MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS,0 ,0 ,0);
  50.         if (!pg_data) {
  51.            MessageBox(NULL,"无法建立共享内存，程序终止！",szApp,MB_OK);
  52.            if (hMap) {
  53.                CloseHandle(hMap);
  54.                hMap = NULL;
  55.                return 0;
  56.             }
  57.         }
  58.         pg_data->hInst = hInst;
  59.         showerr("共享内存映像文件");
  60.         showerr("DLL装载中...",FALSE);
  61.         break;
  62.     case DLL_PROCESS_DETACH:
  63.         showerr("DLL卸载中...",FALSE);
  64.         if (pg_data) {
  65.             UnmapViewOfFile(pg_data);
  66.             pg_data = NULL;
  67.         }
  68.         if (hMap) {
  69.             CloseHandle(hMap);
  70.             hMap = NULL;
  71.         }
  72.         break;
  73.     }
  74.     return true;
  75. }
  76. /*卸载API Hook*/
  77. void UnHookApi() {
  78.     DWORD written = 0;
  79.     DWORD oldaddrAPIFunction = (DWORD)pg_data->oldAPIFunction;
  80.     WriteProcessMemory(GetCurrentProcess(),(DWORD *)pg_data->addrAPIEntryPoint
  81.         , &oldaddrAPIFunction,sizeof(DWORD), &written);
  82.     showerr("WriteProcessMemory on UnHook");
  83.     /*向主线程发送 API UNHOOK 处理完毕的消息*/
  84.     PostThreadMessage(pg_data->idMain,WM_UNHOOKOK,0,0);
  85. }

  87. /*加载API Hook*/
  88. void HookApi(const char* szApiName, tAPIFunction newAddr, DWORD ImageBase) {
  89.     /*这段代码请参考文章中的分析*/
  90.     IMAGE_DOS_HEADER *pidh;
  91.     IMAGE_NT_HEADERS *pinh;
  92.     IMAGE_DATA_DIRECTORY *pSymbolTable;
  93.     IMAGE_IMPORT_DESCRIPTOR *piid;
  94.       pidh = (IMAGE_DOS_HEADER *)ImageBase;
  95.        pinh = (IMAGE_NT_HEADERS *)((DWORD)ImageBase + pidh->e_lfanew);
  96.     pSymbolTable = &pinh->OptionalHeader.DataDirectory[1];
  97.     piid =(IMAGE_IMPORT_DESCRIPTOR *)((DWORD)ImageBase +  pSymbolTable->VirtualAddress);

  99.     do {
  100.         IMAGE_THUNK_DATA *pitd_org,*pitd_1st;
  101.         pitd_org = (IMAGE_THUNK_DATA *)((DWORD)ImageBase + piid->OriginalFirstThunk);
  102.         pitd_1st = (IMAGE_THUNK_DATA *)((DWORD)ImageBase + piid->FirstThunk);
  103.         do {
  104.             IMAGE_IMPORT_BY_NAME *piibn;
  105.             piibn = (IMAGE_IMPORT_BY_NAME *)((DWORD)ImageBase +  *((DWORD *)pitd_org));
  106.             PROC *pAPIFunction = (PROC *)(pitd_1st->u1.Function);
  107.             if (!strcmp(szApiName,(char *)piibn->Name)) {
  108.                 DWORD addrNewAPIFunction = (DWORD)MyMessageBoxW;
  109.                 DWORD written = 0;
  110.                 DWORD oldAccess;

  112.                 pg_data->oldAPIFunction = (tAPIFunction)(pAPIFunction);
  113.                 /*Change Memeory State*/
  114.                 VirtualProtect(&pitd_1st->u1.Function,sizeof(DWORD),PAGE_WRITECOPY,&oldAccess);
  115.                 showerr("VirtualProtect");
  116.                 pg_data->addrAPIEntryPoint = (DWORD)&pitd_1st->u1.Function;
  117.                 /*Write Process Memory*/
  118.                 WriteProcessMemory(GetCurrentProcess(),&pitd_1st->u1.Function
  119.                     , &addrNewAPIFunction,sizeof(DWORD), &written);
  120.                 showerr("WriteProcessMemory on Hook");
  121.             }
  122.             pitd_org++;
  123.             pitd_1st++;
  124.         } while (pitd_1st->u1.Function);
  125.                piid++;
  126.     } while (piid->FirstThunk + piid->Characteristics
  127. + piid->ForwarderChain + piid->Name + piid->TimeDateStamp);
  128. }

  130. //-----------------------
  131. extern "C" __declspec(dllexport) BOOL SetAPIHook(HWND _target) {
  132.     pg_data->hHook = SetWindowsHookEx(WH_GETMESSAGE,GetMsgProc,pg_data->hInst,pg_data->idTarget);
  133.        showerr("SetWindowsHookEx");
  134.     /*向目标线程发送消息进行API HOOK*/
  135.     if (pg_data->hHook) {
  136.         PostThreadMessage(pg_data->idTarget,WM_ENABLEAPIHOOK,0,0);
  137.     } else {
  138.         return FALSE;
  139.     }
  140.     showerr("WM_ENABLEAPIHOOK");
  141.     return TRUE;
  142. }

  144. extern "C" __declspec(dllexport) void UnHookAPIHook() {
  145.     /*向目标线程发送消息进行API UNHOOK*/
  146.     PostThreadMessage(pg_data->idTarget,WM_DISABLEAPIHOOK,(WPARAM)GetCurrentThreadId(),0);
  147.     showerr("WM_DISABLEAPIHOOK");
  148.     /*等待目标进程返回WM_UNHOOKOK消息，确认可以将WH_GETMESSAGE的HOOK去掉*/
  149.     MSG Msg;
  150.     do {
  151.         GetMessage(&Msg,NULL,0,0);
  152.     }while(Msg.message !=  WM_UNHOOKOK);

  154.     UnhookWindowsHookEx(pg_data->hHook);
  155.     PostThreadMessage(pg_data->idTarget,WM_DISABLEAPIHOOKOK,(WPARAM)GetCurrentThreadId(),0);
  156.     showerr("UnHookWindowsHookEx");
  157. }

  159. LRESULT CALLBACK GetMsgProc(int nCode,WPARAM wParam, LPARAM lParam) {
  160.     if (nCode == HC_ACTION) {
  161.         MSG *msg = (MSG *)lParam;
  162.              if (msg->message == WM_ENABLEAPIHOOK) {
  163.             HookApi("MessageBoxW",MyMessageBoxW,(DWORD)GetModuleHandle(NULL));
  164.         }
  165.         if (msg->message == WM_DISABLEAPIHOOK) {
  166.             UnHookApi();
  167.         }
  168.         if (msg->message == WM_DESTROY) {
  169.             showerr("目标进程退出!",FALSE);
  170.         }
  171.     }
  172.     return CallNextHookEx(pg_data->hHook,nCode,wParam,lParam);
  173. }
  174. 　
  175. 这个是主程序的关键部分 HookGui.cpp

  177. 用MFC建立一个窗口程序，包含两个按钮和一个ListBox
  178. typedef void (*PUnHookAPIHook)();
  179. typedef BOOL (*PSetAPIHook)(HWND);
  180. HMODULE hDll = NULL;
  181. HWND hNotePad = NULL;
  182. PSetAPIHook SetAPIHook;
  183. PUnHookAPIHook UnHookAPIHook;
  184. GLOBALDATA *pg_data; /*在共享内存中的全局数据*/
  185. HANDLE hMap; /*在共享内存映像的句柄*/
  186. int CHookGUIDlg::showerr(const char* m) {
  187.     char message[127];
  188.     char buf[255];
  189.     int errId = GetLastError();
  190.     FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,0
  191. ,errId,MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),message,127, 0);
  192.     sprintf(buf,"主程序         : %-30s [%-40s]\n",m, message);
  193.     c_List1.InsertString(c_List1.GetCount(),buf);
  194.     UpdateData(FALSE);
  195.     return errId;
  196. }

  198. void CHookGUIDlg::OnSetapihook()
  199. {
  200.     // TODO: Add your control notification handler code here
  201.     hDll = LoadLibrary("Hook.dll");
  202.     showerr("LoadLibrary");
  203.     hMap = OpenFileMapping(FILE_MAP_ALL_ACCESS,false,ID_MAP);
  204.     showerr("OpenFileMapping");
  205.        pg_data = (GLOBALDATA *)MapViewOfFile(hMap,FILE_MAP_ALL_ACCESS,0,0,0);
  206.     showerr("MapViewOfFile");
  207.        if (!pg_data) {
  208.         MessageBox("不能打开共享内存程序终止!");
  209.         return;
  210.     }
  211.     SetAPIHook = (PSetAPIHook)GetProcAddress(hDll,"SetAPIHook");
  212.     showerr("GetProcAddress-SetAPIHOOK");
  213.        pg_data->hWndTarget = ::FindWindow("NotePad",NULL);
  214.     pg_data->hWndMain = m_hWnd;
  215.     pg_data->idMain = GetWindowThreadProcessId(m_hWnd,NULL);
  216.     pg_data->idTarget = GetWindowThreadProcessId(pg_data->hWndTarget,NULL);
  217.     if (!showerr("FindWindow")) {
  218.         if (SetAPIHook) {
  219.             if (SetAPIHook(hNotePad))
  220.                 PostThreadMessage(pg_data->idTarget
  221.    , WM_SETCALLERID,(LPARAM)GetCurrentThreadId(),0);
  222.             else {
  223.                 MessageBox("SetWindowHookEx时出错，程序终止！");
  224.                 return;
  225.             }
  226.         } else {
  227.             MessageBox("无法取得SetAPIHook函数！程序终止！");
  228.                            }
  229.     } else {
  230.             MessageBox("内存中没有找到NOTEPAD.EXE");
  231.                }
  232.     c_SetApiHook.EnableWindow(FALSE);
  233.     c_UnsetApiHook.EnableWindow();
  234. }

  236. void CHookGUIDlg::OnUnsetapihook()
  237. {
  238.     // TODO: Add your control notification handler code here
  239.     if (hDll) {
  240.         if ( !IsWindow(pg_data->hWndTarget)) {
  241.             MessageBox("目标进程不在内存中");
  242.             return;
  243.         }
  244.         UnHookAPIHook = (PUnHookAPIHook)GetProcAddress(hDll,"UnHookAPIHook");
  245.         showerr("GetProcAddress-UnHookAPIHook");
  246.         if (UnHookAPIHook)
  247.             UnHookAPIHook();
  248.         FreeLibrary(hDll);
  249.         showerr("FreeLibrary");
  250.         hDll = NULL;
  251.     } else {
  252.         MessageBox("请先加载DLL");
  253.     }
  254.     c_SetApiHook.EnableWindow();
  255.     c_UnsetApiHook.EnableWindow(FALSE);
  256. }

  258. void CHookGUIDlg::OnOK()
  259. {
  260.     // TODO: Add extra validation here
  261.     if (hDll) {
  262.         OnUnsetapihook();
  263.     }
  264.     CDialog::OnOK();
  265. }

  267. BOOL CHookGUIDlg::OnCopyData(CWnd* pWnd, COPYDATASTRUCT* pCopyDataStruct)
  268. {
  269.     // TODO: Add your message handler code here and/or call default
  270.     c_List1.InsertString(c_List1.GetCount(),(char *)pCopyDataStruct->lpData);
  271.     return CDialog::OnCopyData(pWnd, pCopyDataStruct);
复制代码
附件: 您需要登录才可以下载或查看附件。没有帐号？注册

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理