奇安信攻防社区-初探hook技术

初探hook技术

# 基础知识对于Windows系统，它是建立在事件驱动机制上的，说白了就是整个系统都是通过消息传递实现的。hook（钩子）是一种特殊的消息处理机制，它可以监视系统或者进程中的各种事件...

基础知识
====

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

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

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

**hook原理**

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

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

几点需要说明的地方：

（1） 如果对于同一事件（如鼠标消息）既安装了线程钩子又安装了系统钩子，那么系统会自动先调用线程钩子，然后调用系统钩子。  
 （2） 对同一事件消息可安装多个钩子处理过程，这些钩子处理过程形成了钩子链。当前钩子处理结束后应把钩子信息传递给下一个钩子函数。而且最近安装的钩子放在链的开始，而最早安装的钩子放在最后，也就是后加入的先获得控制权。  
 （3） 钩子特别是系统钩子会消耗消息处理时间，降低系统性能。只有在必要的时候才安装钩子，在使用完毕后要及时卸载。

**应用场景**

我们知道杀软有一个检测的点就是一些敏感的api，如OpenProcess，VirtualAllocEx，WriteProcessMemory 等等。最常用的一个方式就是加一个jmp，跳转到一个地址，这个地址一般就是杀软写代码进行行为检测的函数，那么jmp这个过程就是一个hook过程。当然我们如果想要杀软不分析我们的木马，那么unhook回来即可，这块就涉及到硬编码的知识，这里就不做延伸了。

IAThook
=======

在实现IAThook之前就需要很多前置知识，主要要对PE结构有一定的了解才行。

**PE结构**

PE文件大致可以分为两部分，即数据管理结构及数据部分。数据管理结构包含：DOS头、PE头、节表。数据部分包括节表数据（节表数据是包含着代码、数据等内容）。详情见下图：

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-ec46b43e5c2759c017e47b5c30eb2b98642ed7ee.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-ec46b43e5c2759c017e47b5c30eb2b98642ed7ee.png)

1.DOS头

DOS头分为两个部分，分别是MZ头及DOS存根，MZ头是真正的DOS头部，它的结构被定义为IMAGE\_DOS\_HEADER。DOS存根是一段简单程序，主要是用于兼容DOS程序，当不兼容DOS程序时，输出："this program cannot be run in DOS mode"。

2.PE头

PE头分为三个部分，分别是PE标识（IMAGE\_NT\_SIGNATRUE）、文件头(/images/hook技术/image\_FILE\_HEADER)、可选头(IMAHE\_OPTION\_HEADER)。PE头是固定不变的，位于DOS头部中e\_ifanew字段指出位置。

3.节表

程序中组织按照不同属性存在不同的节中，如果PE中文件头的NumberOfSections值中有N个节，那么节表就是由N个节表（IMAGE\_SECTION\_HEADER）组成。节表主要是存储了何种借的属性、文件位置、内存位置等。位置紧跟PE头后。

4.节表数据

PE文件真正程序部分的存储位置，有几个节表就有几个节表数据，根据节表的属性、地址等信息，程序的程序就分布在节表的指定位置。位置紧跟节表后。

在了解IAT表之前，需要知道PE数据目录项的第二个结构 -- 导入表

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-d2c01b77857d9556f8a5ce86455d5c18d277426d.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-d2c01b77857d9556f8a5ce86455d5c18d277426d.png)

由于导入函数就是被程序调用但其执行代码又不在程序中的函数，这些函数的代码位于一个或者多个DLL 中。当PE 文件被装入内存的时候，Windows 装载器才将DLL 装入，并将调用导入函数的指令和函数实际所处的地址联系起来(动态连接)，这操作就需要导入表完成，其中导入地址表就[指示函数](https://baike.baidu.com/item/%E6%8C%87%E7%A4%BA%E5%87%BD%E6%95%B0/3774265)实际地址。

导入表是一个结构体，如下所示

```c++
typedef struct _IMAGE_DATA_DIRECTORY {
    DWORD   VirtualAddress;
    DWORD   Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
```

这里`VirtualAddress`为导入表的RVA(PE文件在内存中会拉伸，拉伸后的文件偏移地址称为RVA，原来的文件偏移地址称为FOA，计算公式为`FOA = 导入RVA表地址 - 虚拟偏移 + 实际偏移`)，Size为导入表的大小。但是上面的解雇姿势说明导入表在哪里、有多大，并不是真正的导入表。VirtualAddress中存储的是RVA，如果要在FileBuffer中定位，需要将RVA转换成FOA，即内存偏移-&gt;文件偏移，通过转换过后才能得到真正的导入表，结构如下

```c++
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
    union {
        DWORD   Characteristics;        
        DWORD   OriginalFirstThunk;     //RVA 指向IMAGE_THUNK_DATA结构数组（即INT表）
        };
    DWORD   TimeDateStamp;              //时间戳   
    DWORD   ForwarderChain;                     
    DWORD   Name;                       //RVA,指向dll名字，该名字已0结尾                   
    DWORD   FirstThunk;                 //RVA,指向IMAGE_THUNK_DATA结构数组（即IAT表）         
} IMAGE_IMPORT_DESCRIPTOR;                          
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;    
```

到真正的导入表这个地方，又涉及到两个表，即INT表(Import Name Table)和IAT(Import Address Table)，很明显这里一个表是存储名称，一个表是存储地址的。这里又有一个注意的地方，就是在加载之前INT、IAT表里面存放的都是函数的名称并指向IMAGE\_IMPORT\_BY\_NAME结构，如下图所示

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-67c3755c57d15396f87b3f47d84970667ebe3a17.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-67c3755c57d15396f87b3f47d84970667ebe3a17.png)

在PE文件加载到内存后，INT表的内容和指向的结构都不变，但是IAT表存放的就是函数的地址，也不指向`IMAGE_IMPORT_BY_NAME`结构了，如下所示

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-e7c597644c60acc92d4de9db06ffe1516a5f0f96.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-e7c597644c60acc92d4de9db06ffe1516a5f0f96.png)  
**hook原理**

若我们找到了想要 HOOK 函数在 IAT 表中的具体位置，我们就可以通过修改该位置（该位置存放的是指针）指针的值为我们自己编写的函数的地址（在此之前肯定要把这个函数先加载到进程空间），但该函数的参数必须与被 HOOK 的函数**完全一致**

那么我们了解了导入表、INT表、IAT表之后，就来说说为什么要修改IAT表呢？

在调用api的时候，只要是通过`LoadLibrary`加载的dll，都会在IAT表里面，我们通上面了解到IAT表里面存放的地址，那么我们可以将IAT表里面的地址修改成我们自己写的函数的地址来执行我们函数的功能，这就是IAThook想要达到的目的。但是这里有很多步骤和需要用到很多api，下面就说一下IAThook的实现过程。

这里我们选择hook`user32.dll`里面的`MessageBoxW`函数，我们这里首先定义一个自己的函数`MyMessageBox`，实现的功能就是获取参数和返回值

首先定义一个指针

```c++
typedef int (WINAPI* PFNMESSAGEBOX)(HWND, LPCSTR, LPCSTR, UINT);
```

然后打印指针的参数

```c++
printf("Argument: hwnd-%x lpText-%ws lpCaption-%ws uType-%x\n\n", hwnd, lpText, lpCaption, uType);
```

因为我们将IAT表里面的地址改为了我们函数的地址，但是原来IAT表里面的函数我们还是要执行才可以，所以这里执行真正的函数，这里`pOldFuncAddr`就是原来IAT表指向函数的地址，使用`GetProcess`得到原`MessageBoxW`的地址

```c++
int ret = ((PFNMESSAGEBOX)pOldFuncAddr)(hwnd, lpText, lpCaption, uType);

DWORD pOldFuncAddr = (DWORD)::GetProcAddress(LoadLibrary(L"USER32.dll"), "MessageBoxW");
```

我们再获取返回值即可实现hook`MessageBoxW`，`MyMessageBox`的完整代码如下

```c++
int WINAPI MyMessageBox(
    HWND hwnd,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType)

{
    //定义MyMessageBox的指针
    typedef int (WINAPI* PFNMESSAGEBOX)(HWND, LPCSTR, LPCSTR, UINT);

//获取参数
    printf("Argument: hwnd-%x lpText-%ws lpCaption-%ws uType-%x\n\n", hwnd, lpText, lpCaption, uType);

//执行真正的函数
    int ret = ((PFNMESSAGEBOX)pOldFuncAddr)(hwnd, lpText, lpCaption, uType);

//获取返回值
    printf("The return value is: %x\n\n", ret);

return ret;
}
```

再就是修改IAT表的函数编写

首先定位导入表，位于数据目录项的第二个，使用指针`pImport`指向导入表

```c++
pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
pImport = (PIMAGE_IMPORT_DESCRIPTOR)(pOptionHeader->DataDirectory[1].VirtualAddress + dwImageBase);
```

然后使用`GetModuleHandle`获取进程基址

```c++
dwImageBase = (DWORD)::GetModuleHandle(NULL);
```

然后使用指针`pIAT`指向IAT表

```c++
pIAT = (PDWORD)(pImport->FirstThunk + dwImageBase);
```

这里作一个判断，因为我们之前通过`GetProcess`得到了原来`MessageBoxW`的地址，这里`pIAT`指向的也应该是原`MessageBoxW`的地址，所以正常情况下是相等的，使用`*pIAT`取值

```c++
if (*pIAT == pOldFuncAddr)
```

注意到这里有一个需要注意的地方，IAT表在默认的情况下是不能够进行写入的，如果这个地方直接修改IAT表的数据就会报错0xc0000005，所以我们需要修改IAT表为可写属性，这里用到`VirtualProtect`这个api

```c++
BOOL VirtualProtect(
  LPVOID lpAddress,             //要更改访问保护属性的页面区域的起始页面地址
  SIZE_T dwSize,                //要更改访问保护属性的区域的大小，以字节为单位
  DWORD  flNewProtect,          //内存保护选项
  PDWORD lpflOldProtect         //指向一个变量的指针，该变量接收指定页面区域中第一页的先前访问保护值。如果此参数为NULL或未指向有效变量，则函数失败
);
```

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-30209957619a10d81df5e57e7167af21b7b99a69.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-30209957619a10d81df5e57e7167af21b7b99a69.png)

这里修改第三个参数为`PAGE_EXECUTE_READWRITE`，即可读可写即可

```c++
VirtualProtect(pIAT, 0x2000, PAGE_EXECUTE_READWRITE, &oldProtected);
```

然后把IAT表的地址改向我们自己定义函数的地址即可实现IAThook

```c++
*pIAT = dwNewAddr;
```

那么我们实现IAThook之后如果想把原函数的地址还原回去，就可以写一个`UnSetIATHook`，只要把`*IAT`指向旧的地址即可

在写一个`TestIATHook`调用一下这两个函数

```c++
int TestIATHook()
{
    SetIATHook(pOldFuncAddr, (DWORD)MyMessageBox);
    MessageBox(NULL, L"IAT HOOK", L"IATHOOK success!", MB_OK);
    UnSetIATHook(pOldFuncAddr, (DWORD)MyMessageBox);

return 1;
}
```

完整代码如下

```c++
// IAT hook.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <windows.h>

DWORD pOldFuncAddr = (DWORD)::GetProcAddress(LoadLibrary(L"USER32.dll"), "MessageBoxW");

BOOL SetIATHook(DWORD dwOldAddr, DWORD dwNewAddr)
{
    DWORD dwImageBase = 0;
    PIMAGE_DOS_HEADER pDosHeader;
    PIMAGE_NT_HEADERS pNTHeader = NULL;
    PIMAGE_FILE_HEADER pPEHeader = NULL;
    PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
    PIMAGE_SECTION_HEADER pSectionHeader = NULL;
    PIMAGE_IMPORT_DESCRIPTOR pImport = NULL;
    PDWORD pIAT = NULL;
    DWORD oldProtected = 0;
    bool Flag = FALSE;

dwImageBase = (DWORD)::GetModuleHandle(NULL); 
    pDosHeader = (PIMAGE_DOS_HEADER)dwImageBase;
    pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
    pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4);
    pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
    pImport = (PIMAGE_IMPORT_DESCRIPTOR)(pOptionHeader->DataDirectory[1].VirtualAddress + dwImageBase);

//定位IAT表
    while (pImport->FirstThunk != 0 && Flag == FALSE)
    {

pIAT = (PDWORD)(pImport->FirstThunk + dwImageBase);

while (*pIAT)
        {
            if (*pIAT == pOldFuncAddr)
            {
                VirtualProtect(pIAT, 0x4096, PAGE_EXECUTE_READWRITE, &oldProtected);
                *pIAT = dwNewAddr;
                Flag = TRUE;
                printf("Hook success!\n\n");
                break;
            }
            pIAT++;
        }
        pImport++;
    }

return Flag;

}

DWORD UnSetIATHook(DWORD dwOldAddr, DWORD dwNewAddr)
{
    DWORD dwImageBase = 0;
    PIMAGE_DOS_HEADER pDosHeader;
    PIMAGE_NT_HEADERS pNTHeader = NULL;
    PIMAGE_FILE_HEADER pPEHeader = NULL;
    PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
    PIMAGE_SECTION_HEADER pSectionHeader = NULL;
    PIMAGE_IMPORT_DESCRIPTOR pImport = NULL;
    PDWORD pIAT = NULL;
    DWORD oldProtected = 0;
    bool Flag = FALSE;

dwImageBase = (DWORD)::GetModuleHandle(NULL);   //获取进程基址
    pDosHeader = (PIMAGE_DOS_HEADER)dwImageBase;
    pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)pDosHeader + pDosHeader->e_lfanew);
    pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4);
    pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
    pImport = (PIMAGE_IMPORT_DESCRIPTOR)(pOptionHeader->DataDirectory[1].VirtualAddress + dwImageBase);

while (pImport->FirstThunk != 0 && Flag == FALSE)
    {
        pIAT = (PDWORD)(pImport->FirstThunk + dwImageBase);
        while (*pIAT)
        {
            if (*pIAT == dwNewAddr)
            {
                *pIAT = dwOldAddr;
                Flag = TRUE;
                break;
            }
            pIAT;
        }
        pImport;
    }

return Flag;
}

int WINAPI MyMessageBox(
    HWND hwnd,
    LPCSTR lpText,
    LPCSTR lpCaption,
    UINT uType)

{
    //定义MyMessageBox的指针
    typedef int (WINAPI* PFNMESSAGEBOX)(HWND, LPCSTR, LPCSTR, UINT);

//获取参数
    printf("Argument: hwnd-%x lpText-%ws lpCaption-%ws uType-%x\n\n", hwnd, lpText, lpCaption, uType);

//执行真正的函数
    int ret = ((PFNMESSAGEBOX)pOldFuncAddr)(hwnd, lpText, lpCaption, uType);

//获取返回值
    printf("The return value is: %x\n\n", ret);

return ret;
}

int TestIATHook()
{
    SetIATHook(pOldFuncAddr, (DWORD)MyMessageBox);
    MessageBox(NULL, L"IAT HOOK", L"IATHOOK success!", MB_OK);
    UnSetIATHook(pOldFuncAddr, (DWORD)MyMessageBox);

return 1;
}

int main()
{
    TestIATHook();
}
```

注意这里我写的时候有两个坑点，第一个地方就是打印的时候需要用`tchar.h`即宽字符，否则显示不完全

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-ceeb198d8bba898c3108bde50ff7a5c43575722d.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-ceeb198d8bba898c3108bde50ff7a5c43575722d.png)

再就是我一开始hook的是`MessageBoxA`这个api，但是获取不到返回值，改成`MessageBoxW`即可

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-5e75917e8dce99f5a2059082030d084e0a58e06b.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-5e75917e8dce99f5a2059082030d084e0a58e06b.png)

Inlinehook
==========

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

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

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

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

那么既然有了IAThook，我们为什么还要用Inlinehook呢，直接用IAThook不是更方便吗？看硬编码多麻烦。

我们思考一个问题，如果函数不是以`LoadLibrary`方式加载，那么肯定在导入表里就不会出现，那么IAThook就不能使用了，这就是Inlinehook诞生的条件。

**硬编码**

何为硬编码？

这里我就不生搬概念性的东西来解释了，说说我自己的理解。硬编码可以说就是用十六进制的字符组成的，他是给cpu读的语言，我们知道在计算机里面只有0和1，如果你要让他去读c语言的那些字符他是读不懂的，他只会读0和1，这就是硬编码。

硬编码的结构如下，有定长指令、变长指令等等一系列指令，还跟各种寄存器相关联起来，确实如果我们去读硬编码的话太痛苦了

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-2c0b0fc59b25cab17605e6348d471c8427360116.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-2c0b0fc59b25cab17605e6348d471c8427360116.png)

这里就不过多延伸了，我们在Inlinehook里面只会用到一个硬编码就是E9，对应的汇编代码就是jmp

我们的思路还是跟之前的IAThook一样，通过修改jmp跳转的地址跳转到我们的函数执行功能之后再跳转到原函数的地址执行原函数

那么这里我们首先定义一个`Add`函数，定义三个变量，函数的功能就是实现三个数的相加

```c++
DWORD Add(int x, int y, int z)
{
    return x + y + z;
}
```

我们在vs里面写入`Add`函数并跟进反汇编进行查看，注意这里汇编代码对应的硬编码的字节数是确定的，例如55对应的就是push ebp，54对应的就是push esp，这是一个定长指令，也就是说push这个汇编代码在硬编码里面就是一字节

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-4b826da92c75a64a35e353f0f6e985e1a46c113a.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-4b826da92c75a64a35e353f0f6e985e1a46c113a.png)

那么我们要实现jmp跳转，执行的命令为`jmp 0x123454678`，对应的字节数为5(jmp也为定长指令)，也就是说至少要有5个字节的空间才能够写入jmp跳转的硬编码。

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-092e8431c48f837f218fa983cf559578955d968b.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-092e8431c48f837f218fa983cf559578955d968b.png)

这里我们可以先将这几行代码移到一块空白的缓冲区里，再使用jmp即E9call跳转到我们想执行的函数的地址，执行完成过后再执行这几行代码之后跳转回来，如下所示。这里说一下E9的计算，E9后面要填的硬编码计算公式为 要跳转的地址 - (E9地址 + 5)

[![](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-41f569752390b16344ccce070f87ec4684c14af3.png)](https://shs3.b.qianxin.com/attack_forum/2021/10/attach-41f569752390b16344ccce070f87ec4684c14af3.png)

先编写钩子函数，首先定义一个裸函数，由我们自己来平衡堆栈，因为C语言默认为stdcall，是自动平衡堆栈的，即内平栈

```c++
extern "C" _declspec(naked) void Hook()
```

我们在进行函数的hook过程中，要保证寄存器和标志寄存器的数值不能改变，否则程序可能会报错，所以这里先把标志寄存器的值压入堆栈

```c++
    _asm
    {
        pushad;     //保留寄存器
        pushfd;     //保留标志寄存器
    }

//读取寄存器的值
    _asm
    {
        mov reg.EAX, eax
        mov reg.EBX, ebx
        mov reg.ECX, ecx
        mov reg.EDX, edx
        mov reg.EDI, edi
        mov reg.ESI, esi
        mov reg.ESP, esp
        mov reg.EBP, ebp
    }
```

然后把我们函数的三个参数压入堆栈，这里前面已经有10个值了，所以压栈的地址为`esp + 28`

```c++
    _asm
    {
        mov eax, DWORD PTR ss : [esp + 0x28]
        mov x, eax
        mov eax, DWORD PTR ss : [esp + 0x2c]
        mov y, eax
        mov eax, DWORD PTR ss : [esp + 0x30]
        mov z, eax
    }
```

然后我们实现的功能就是把寄存器的值打印出来，当然这里是实验，实战中师傅们自行发挥

```c++
    printf("EAX:%x EBX:%x ECX:%x EDX:%x EDI:%x ESI:%x ESP:%x EBP:%x\n\n", reg.EAX, reg.EBX, reg.ECX, reg.EDX, reg.EDI, reg.ESI, reg.ESP, reg.EBP);

printf("x:%d y:%d z:%d\n\n", x, y, z);
```

然后还原寄存器和标志寄存器

```c++
    _asm
    {
        popfd;      //还原标志寄存器
        popad;      //还原寄存器
    }
```

到这里我们想要执行的函数功能就已经执行完成了，那么我们还需要将之前覆盖的汇编代码给还原回去

```c++
    //执行之前覆盖的代码
    _asm
    {
        push        ebp
        mov         ebp, esp
        sub         esp, 0C0h
    }
```

完成后我们再跳转回之前执行hook的地址

```c++
    //执行完后跳转回hook地址
    _asm
    {
        jmp RetWriteHookAddr;
    }
```

钩子的完整代码如下

```c++
extern "C" _declspec(naked) void Hook()
{
    _asm
    {
        pushad;     //保留寄存器
        pushfd;     //保留标志寄存器
    }

//读取寄存器的值
    _asm
    {
        mov reg.EAX, eax
        mov reg.EBX, ebx
        mov reg.ECX, ecx
        mov reg.EDX, edx
        mov reg.EDI, edi
        mov reg.ESI, esi
        mov reg.ESP, esp
        mov reg.EBP, ebp
    }

//将参数压入堆栈
    _asm
    {
        mov eax, DWORD PTR ss : [esp + 0x28]
        mov x, eax
        mov eax, DWORD PTR ss : [esp + 0x2c]
        mov y, eax
        mov eax, DWORD PTR ss : [esp + 0x30]
        mov z, eax
    }

printf("EAX:%x EBX:%x ECX:%x EDX:%x EDI:%x ESI:%x ESP:%x EBP:%x\n\n", reg.EAX, reg.EBX, reg.ECX, reg.EDX, reg.EDI, reg.ESI, reg.ESP, reg.EBP);

printf("x:%d y:%d z:%d\n\n", x, y, z);

_asm
    {
        popfd;      //还原标志寄存器
        popad;      //还原寄存器
    }

//执行之前覆盖的代码
    _asm
    {
        push        ebp
        mov         ebp, esp
        sub         esp, 0C0h
    }

//执行完后跳转回hook地址
    _asm
    {
        jmp RetWriteHookAddr;
    }

}
```

然后我们再写`SetInlineHook`函数，首先判断传入的钩子函数的地址和钩子函数是否存在再往下执行

```c++
    if (HookAddr == NULL || HookProc == NULL)
    {
        printf("The address is error,please try again!\n\n");
        return FALSE;
    }
```

判断是否大于5字节，小于5字节则报错空间不够写不进去

```c++
    if (dwLength < 5)
    {
        printf("The alloc is too small,please try adgin!\n\n");
        return FALSE;
    }
```

然后使用之前IAThook里面的`VirtualProtect`修改为可读写属性

```c++
    ReAdd = VirtualProtect((LPBYTE)HookAddr, dwLength, PAGE_EXECUTE_READWRITE, &OldProtect);
```

申请空间

```c++
    szBuffer = malloc(dwLength * sizeof(char));
```

将内存全部首先置nop

```c++
    memcpy(szBuffer, HookAddr, dwLength);
    memset(HookAddr, 0x90, dwLength); 
```

然后计算E9后面跟的硬编码，使用要跳转的地址 - E9地址 - 5

```c++
DWORD JmpAddr = (DWORD)HookProc - (DWORD)HookAddr - 5;
```

执行跳转即可

```c++
    *(LPBYTE)HookAddr = 0xE9;
    *(PDWORD)((LPBYTE)HookAddr + 1) = JmpAddr;

WriteHookAddr = (DWORD)HookAddr;
    RetWriteHookAddr = (DWORD)HookAddr + dwLength;
    dwHookFlag = 1;
```

再写一个解钩函数，成功后把`dwHookFlag`置0，代码如下

```c++
DWORD UnInlineHook(DWORD dwLength)
{
    if (!dwHookFlag)
    {
        printf("UnInlineHook!\n\n");
        return FALSE;
    }

memcpy((LPVOID)WriteHookAddr, szBuffer, dwLength);
    szBuffer = NULL;
    dwHookFlag = 0;

return 1;
}
```

完整代码如下

```c++
// InlineHook.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <windows.h>

//保留硬编码

BOOL ReAdd;
BOOL dwHookFlag;
LPVOID szBuffer;
LPBYTE HookAddr;
LPVOID HookProc;
DWORD dwLength;
DWORD WriteHookAddr, RetWriteHookAddr;
DWORD x, y, z;
DWORD Add(int x, int y, int z);
DWORD Sub(int i, int j, int k);

typedef struct _regeist
{
    DWORD EAX;
    DWORD EBX;
    DWORD ECX;
    DWORD EDX;
    DWORD EBP;
    DWORD ESP;
    DWORD ESI;
    DWORD EDI;
}regeist;

regeist reg = { 0 };

extern "C" _declspec(naked) void Hook()
{
    _asm
    {
        pushad;     //保留寄存器
        pushfd;     //保留标志寄存器
    }

_asm
    {
        mov reg.EAX, eax
        mov reg.EBX, ebx
        mov reg.ECX, ecx
        mov reg.EDX, edx
        mov reg.EDI, edi
        mov reg.ESI, esi
        mov reg.ESP, esp
        mov reg.EBP, ebp
    }

_asm
    {
        mov eax, DWORD PTR ss : [esp + 0x28]
        mov x, eax
        mov eax, DWORD PTR ss : [esp + 0x2c]
        mov y, eax
        mov eax, DWORD PTR ss : [esp + 0x30]
        mov z, eax
    }

printf("EAX:%x EBX:%x ECX:%x EDX:%x EDI:%x ESI:%x ESP:%x EBP:%x\n\n", reg.EAX, reg.EBX, reg.ECX, reg.EDX, reg.EDI, reg.ESI, reg.ESP, reg.EBP);

printf("x:%d y:%d z:%d\n\n", x, y, z);

_asm
    {
        popfd;      //还原标志寄存器
        popad;      //还原寄存器
    }

//执行之前覆盖的代码
    _asm
    {
        push        ebp
        mov         ebp, esp
        sub         esp, 0C0h

}

//执行完后跳转回hook地址
    _asm
    {
        jmp RetWriteHookAddr;
    }

}

//HookAddr为钩子地址，HookProc为钩子函数，dwLength为要修改的硬编码长度
DWORD SetInlineHook(LPBYTE HookAddr, LPVOID HookProc, DWORD dwLength)
{

if (HookAddr == NULL || HookProc == NULL)
    {
        printf("The address is error,please try again!\n\n");
        return FALSE;
    }

if (dwLength < 5)
    {
        printf("The alloc is too small,please try adgin!\n\n");
        return FALSE;
    }

DWORD OldProtect;
    ReAdd = VirtualProtect((LPBYTE)HookAddr, dwLength, PAGE_EXECUTE_READWRITE, &OldProtect);

if (!ReAdd)
    {
        printf("SetInlineHook_VirtualProtect - Error!\n\n");
        return FALSE;
    }

szBuffer = malloc(dwLength * sizeof(char));
    memcpy(szBuffer, HookAddr, dwLength);
    memset(HookAddr, 0x90, dwLength);   //将Hook的内存全部初始化为nop(dwLength > 5)

//E9后面的值 = 要跳转的地址 - E9 - 5
    DWORD JmpAddr = (DWORD)HookProc - (DWORD)HookAddr - 5;

*(LPBYTE)HookAddr = 0xE9;
    *(PDWORD)((LPBYTE)HookAddr + 1) = JmpAddr;

WriteHookAddr = (DWORD)HookAddr;
    RetWriteHookAddr = (DWORD)HookAddr + dwLength;
    dwHookFlag = 1;

}

DWORD UnInlineHook(DWORD dwLength)
{
    if (!dwHookFlag)
    {
        printf("UnInlineHook!\n\n");
        return FALSE;
    }

memcpy((LPVOID)WriteHookAddr, szBuffer, dwLength);
    szBuffer = NULL;
    dwHookFlag = 0;

return 1;
}

DWORD Add(int x, int y, int z)
{
    return x + y + z;
}

DWORD TestInlineHook()
{

PBYTE Addr = (BYTE*)Add + 1;
    Addr += *(DWORD*)Addr + 4;

SetInlineHook((LPBYTE)Addr, Hook, 9);

Add(8, 1, 5);

UnInlineHook(9);

Add(8, 1, 5);

return 0;
}

int main()
{
    //Add(8, 1, 5);

TestInlineHook();

return 0;
}
```

实现效果如下，因为在`TestInlineHook`调用了两个`Add`函数，在第二个`Add`函数之前调用了`UnInlineHook`，最后的结果只显示了一次，所以`UnInlineHook`也执行成功了

发表于 2021-10-14 14:01:39
阅读 ( 4120 )
分类：渗透测试

初探hook技术

0 条评论