Hook API 2

最新推荐文章于 2022-02-10 09:39:36 发布
最新推荐文章于 2022-02-10 09:39:36 发布
阅读量1k 收藏
点赞数
分类专栏： 操作系统

HOOK API是指截获特定进程或系统对某个API函数的调用，使得API的执行流程转向指定的代码。最常用的一种挂钩API的方法是改变目标进程中调用API函数的代码，使得它们对API的调用变为对用户自定义函数的调用。

Windows下应用程序有自己的地址空间，它们只能调用自己地址空间中的函数；因此，在挂钩API之前，必须将一个可以代替API执行的函数的执行代码注入到目标进程，接着将目标进程对该API的调用改为对注入到目标进程中自定义函数的调用。这个自定义函数一般称为代理函数。在代理函数中，可以调用原来的API，也可以做其他事情。

注入代码到目标进程比较简单的方法是把要注入的代码写到DLL中，然后让目标进程加载这个DLL，这就是所谓的DLL注入技术。而一旦程序代码进入了另一个进程的地址空间，就可以毫无限制的使用进程的资源了。在这个要注入到目标进程的DLL中写一个与感兴趣的API函数的签名完全相同的函数（即代理函数），当DLL执行初始化代码的时候，把目标进程对这个API的调用全部改为对代理函数的调用，即可实现拦截API函数。

当然，我们也可以利用DLL在目标进程中初始化的机会去创建新的线程，该线程对目标进程有着完全的访问权限。我们可以将它视为守护线程，在接收到通知时，访问目标进程的资源，也可以通过这种方式隐藏自己，创建没有“进程”的线程。

 

HOOK的过程：

1）导入函数是被本程序调用，但其实现代码却在其他模块中的函数。API函数全是导入函数，它们的实现代码在Kernel32.dll、User32.dll等Win32子系统模块中。

模块的导入函数名和这些函数驻留的DLL名等信息都保留在它的导入表(import table)中。导入表是一个IMAGE_IMPORT_DESCRIPTOR结构的数组，每个结构对应着一个导入模块。

typedef struct _IMAGE_IMPORT_DESCRIPTOR

{

       union

       {

              DWORD Characteristics;

              DWORD OriginalFirstThunk; //hint/name(函数序号/名称)表的偏移量，记录导入函数名称

       };

       DWORD TimeDataStamp;

       DWORD ForwarderChain;

       DWORD Name;        //导入模块名称字符串的偏移量

       DWORD FirstThunk;        //IAT(Import Address Table，导入地址表)的偏移量，记录导入函数地址

}IMAGE_IMPORT_DESCRIPTOR;

应用程序启动时，载入器根据PE文件的导入表记录的DLL名（上面的Name域）加载相应的DLL模块，再根据导入表的hint/name表（OriginalFirstThunk指向的数组）记录的函数名取得函数的地址，接着将这些地址保存到导入表的IAT（FirstThunk指向的数组）中。

应用程序在调用导入函数时，要先到导入表的IAT中找到这个函数的地址，然后再调用。模块的IAT仅仅是一个DWORD数组，数组的每个成员记录着一个导入函数的地址。

一种非常常用的HOOK API的方法就是修改模块的导入表；为了保存堆栈的平衡，自定义函数使用的调用规则和参数个数必须与它所替代的API函数完全相同。

 

2）为了修改导入地址表（IAT），首先需定位目标模块PE结构中的导入表的地址。

PE文件以64字节的DOS文件头开始（IAMGE_DOS_HEADER），接着是一小段DOS程序，然后是248字节的NT文件头（IMAGE_NT_HEADERS）。NT文件头相对文件开始位置的偏移量可以由IMAGE_DOS_HEADER结构的e_lfanew给出。

NT文件头的前4个字节是文件签名（“PE00”字符串）,紧接着是20字节的IMAGE_FILE_HEADER结构，下面的代码取得一个指向IMAGE_OPTIONAL_HEADER结构的指针（以主模块为例）：

//这里是为了示例，取得主模块的模块句柄

HMODULE hMod = ::GetModuleHandle(NULL);

IMAGE_DOS_HEADER *pDosHeader = (IMAGE_DOS_HEADER*)hMod;

IMAGE_OPTIONAL_HEADER *pOptHeader =

                                   (IMAGE_OPTIONAL_HEADER*)((BYTE*)hMod + pDosHeader->e_lfanew + 24);

IMAGE_OPTIONAL_HEADER包含了许多重要的信息，有推荐的模块基地址、代码和数据的大小和基地址、线程堆栈和进程堆的配置、程序入口点的地址以及我们感兴趣的数据目录表指针。PE文件保留了16个数据目录，最常见的有导入表、导出表、资源和重定位表。

导入表是一个IMAGE_IMPORT_DESCRIPTOR结构的数组，每个结构对应一个导入模块。下面的代码取得导入表中第一个IMAGE_IMPORT_DESCRIPTOR结构的指针（即导入表首地址）：

IMAGE_IMPORT_DESCRIPTOR *pImportDesc = (IMAGE_IMPORT_DESCRIPTOR)*

                     ((BYTE*)hMod + pOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

 

除了可以通过PE文件结构定位模块的导入表外，还可以使用ImageDirectoryEntryToData函数，这个函数知道模块基地址后直接返回指向指定数据目录表的首地址：

#include <ImageHlp.h>

#pragma comment(lib, "ImageHlp")

 

PVOID ImageDirectoryEntryToData(

       PVOID Base,                                                               //模块基地址

       BOOLEAN MappedAsImage,        //如果此参数是TRUE，文件被系统ª当做镜像映射，否则，当做数据文件映射

       USHORT DirectoryEntry,               //指定IMAGE_DIRECTORY_ENTRY_IMPORT说明要取得导入表首地址

       PULONG Size)                                                     //返回表项的大小

 

IMAGE_IMPORT_DESCRIPTOR结构包含了hint/name（函数序号/名称）表和IAT（导入地址表）的偏移量。这两个表的大小相同，一个成员对应一个导入函数，分别记录了导入函数的名称和地址。

 

HOOK API的实现：

定位导入表之后，就可以定位导入地址表（IAT）了。为了截获API的调用，只要用自定义函数的地址覆盖导入地址表（IAT）中真实的API函数地址即可。

下面是挂钩MessageBoxA函数的例子，主模块中对MessageBoxA的调用都变为对自定义函数AceMessageBoxA的调用：

#include <Windows.h>

#include <stdio.h>

//挂钩指定模块hMod对MessageBoxA的调用

BOOL SetHook(HMODULE hMod);

//定义MessageBoxA函数原型

typedef int(WINAPI *PFNMESSAGEBOX)(HWND, LPCSTR, LPCSTR, UINT uType);

//保存MessageBoxA函数的真实地址

PROC g_orgProc = (PROC)MessageBoxA;

 

void main()

{

       //调用原API函数

       ::MessageBox(NULL, "原函数", "ACE", 0);

       //挂钩后再调用

       SetHook(::GetModouleHandle(NULL));

       ::MessageBox(NULL, "原函数", "ACE", 0);

}

 

//用于替换MessageBoxA的自定义函数

int WINAPI AceMessageBoxA(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)

{

       return ((PFNMESSAGEBOX)g_orgProc)(hWnd, "新函数", "ACE", uType);

}

 

BOOL SetHook(HMODULE hMod)

{

       IMAGE_DOS_HEADER *pDosHeader = (IMAGE_DOS_HEADER*)hMod;

       IMAGE_OPTIONAL_HEADER *pOptHeader =

                     (IMAGE_OPTIONAL_HEADER*)((BYTE*)hMod + pDosHeader->e_lfanew + 24);

       IMAGE_IMPORT_DESCRIPTOR *PImportDesc = (IMAGE_IMPORT_DESCRIPTOR*)

                     ((BYTE*)hMod + pOptHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

       //在导入表中查找user32.dll模块，因为MessageBoxA函数从user32.dll模块导出

       while(pImportDesc->FirstThunk)

       {

              char* pszDllName = (char*)((BYTE*)hMod + pImportDesc->Name);

              if(lstrcmpiA(pszDllName, "user32.dll") == 0)

              {

                     break;

              }

              pImportDesc++;

       }

 

       if(pImportDesc->FirstThunk)

       {

              //一个IMAGE_THUNK_DATA结构就是一个双字，它指定了一个导入函数

              //调用地址表其实是IMAGE_THUNK_DATA结构的数组，也就是DWORD数组

              IMAGE_THUNK_DATA *pThunk = (IMAGE_THUNK_DATA*)

                                   ((BYTE*)hMod + pImportDesc->FirstThunk);

              while(pThunk->u1.Function)

              {

                     //lpAddr指向的内存保存了函数的地址

                     DWORD *lpAddr = (DWORD*)&(pThunk->u1.Function);

                     if(*lpAddr == (DWORD)g_orgProc)

                     {

                            //修改IAT表项，使其指向我们自定义的函数

                            //相当于语句"*lpAddr = (DWORD)AceMessageBoxA"

                            DWORD* lpNewProc = (DWORD*)AceMessageBoxA;

                            ::WriteProcessMemory(GetCurrentProcess(), lpAddr, &lpNewProc, sizeof(DWORD), NULL);

                            return TRUE;

                     }

                     pThunk++;

              }

       }

       return FALSE;

}




封装CAPIHook类：（某本书的笔记）

 

1）HOOK所有模块

HOOK一个进程对某个API的调用时，不仅要修改主模块的导入表，还必须遍历此进程的所有模块，替换掉每个对目标API的调用：

void CAPIHook::ReplaceIATEntryInOneMod(LPSTR pszExportMod, PROC pfnCurrent,

                            PROC pfnNew, HMODULE hModCaller)

{

       //取得模块的导入表(import descriptor)的首地址

       //ImageDirectoryEntryToData函数可以返回导入表地址

       ULONG ulSize;

       PIMAGE_IMPORT_DESCRIPTOR pImportDesc =

              (PIMAGE_IMPORT_DESCRIPTOR)::ImageDirectoryEntryToData(hModCaller, TRUE,

                                                                             IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);

       if(pImportDesc == NULL)      //这个模块没有导入表项

              return;  

       //查找包含pszExportMod模块中函数导入信息的导入表项

       while(pImportDesc->Name != 0)

       {

              LPSTR pszMod = (LPSTR)((DWORD)hModCaller + pImportDesc->Name);

              if (lstrcmpiA(pszMod, pszExportMod) == 0)   //找到

              {

                     break;

              }

              pImportDesc++;

       }

 

       if (pImportDesc->Name == 0)    //hModCaller模块没有从pszExportMod模块导入任何函数

       {

              return;

       }

 

       //取得调用者的导入地址表(import address table, IAT)

       PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(pImportDesc->FirstThunk +

                                                                             (DWORD)hModCaller);

       //查找我们要HOOK的函数，将它的地址用新函数的地址替换掉

       while (pThunk->u1.Function)

       {

              //lpAddr指向的内存保存了函数的地址

              PDWORD lpAddr = (PDWORD)&(pThunk->u1.Function);

              if (*lpAddr == (DWORD)pfnCurrent)

              {

                     //修改页的保护属性

                     DWORD dwOldProtect;

                     MEMORY_BASIC_INFORMATION mbi;

                     ::VirtualQuery(lpAddr, &mbi, sizeof(mbi));

                     ::VirtualProtect(lpAddr, sizeof(DWORD), PAGE_READWRITE, &dwOldProtect);

 

                     //修改内存地址，相当于"lpAddr = (DWORD)pfnNew;"

                     ::WriteProcessMemory(::GetCurrentProcess(), lpAddr,

                                   &pfnNew, sizeof(DWORD), NULL);

                     ::VirtualProtect(lpAddr, sizeof(DWORD), dwOldProtect, 0);

                     break;

              }

              pThunk++;

       }

}

 

void CAPIHook::ReplaceIATEntryInAllMods(LPSTR pszExportMod, PROC pfnCurrent,

                                                        PROC pfnNew, BOOL bExcludeAPIHookMod)

{

       //取得当前模块的句柄

       HMODULE hModThis = NULL;

       if(bExcludeAPIHookMod)

       {

              MEMORY_BASIC_INFORMATION mbi;

              if(::VirtualQuery(ReplaceIATEntryInAllMods, &mbi, sizeof(mbi)) != 0)

                     hModThis = (HMODULE)mbi.AllocationBase;

       }

 

       //取得本进程的模块列表

       HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ::GetCurrentProcessId());

 

       //遍历所有模块，分别对它们调用ReplaceIATEntryInOnMod函数，修改导入地址表

       MODULEENTRY32 me = {sizeof(MODULEENTRY32)};

       BOOL bOK = ::Module32First(hSnap, &me);

       while (bOK)

       {

              //注意，我们不HOOK当前模块的函数

              if (me.hModule != hModThis)

              {

                     ReplaceIATEntryInOneMod(pszExportMod, pfnCurrent, pfnNew, me.hModule);

              }

 

              bOK = ::Module32Next(hSnap, &me);

       }

       ::CloseHandle(hSnap);

}

ReplaceIATEntryInOneMod函数修改hModCaller模块的IAT，将所有对pfnCurrent函数的调用改为对pfnNew函数的调用，参数pszExportMod是目标API所在的模块。例如，为了将自定义的函数AceMessageBoxA替换当前模块中的MessageBoxA函数，可以调用如下：

CAPIHOOK::ReplaceIATEntryInOneMod("User32.dll",

       (PROC)AceMessageBoxA, (PROC)MessageBoxA, ::GetModuleHandle(NULL));

ReplaceIATEntryInAllMods函数修改进程内所有模块的IAT，挂钩用户指定的API函数，最后一个参数bExcludeAPIHookMod指定是否将负责HOOK API的模块排除在外。

由于CAPIHook类工作在一个单独的DLL中，为了在此模块中方便地调用原来的API函数，一般选择不HOOK当前模块的函数，即将bExcludeAPIHookMod设为TRUE。

 

2）防止程序在运行期间动态加载模块

在HOOK完目标进程当前所有模块之后，目标进程还可以调用LoadLibrary函数加载新的模块。为了将今后目标进程动态加载的模块也HOOK掉，我们可以默认挂钩LoadLibrary之类的函数。方法就是在代理函数中首先调用原来的LoadLibrary函数，然后再对新加载的模块调用ReplaceIATEntryInOneMod函数。

我们设替换LoadLibrary的自定义函数是HookNewlyLoadedModule。一个CAPIHook对象仅能够挂钩一个API函数，为了挂钩多个API，用户很可能申请了多个CAPIHook对象，所以，在自定义函数HookNewlyLoadedModule中，必须为每个CAPIHook对象调用ReplaceIATEntryInOneMod函数才能确保新模块中相应的IAT项被修改。因此，我们需要记录用户申请的所有CAPIHook对象的指针。

比较简单的方法是将所有CAPIHook对象连成一个链表，用一个静态变量记录下表头地址，在每个CAPIHook对象中再记录表中下一个CAPIHook对象的地址：

class CAPIHook

{

       //这两个指针用来将当前模块中所有的CAPIHook对象连在一起

       static CAPIHook *sm_pHeader;

       CAPIHook *m_pNext;

}

静态函数HookNewlyLoadedModule的实现代码如下：

void WINAPI CAPIHook::HookNewlyLoadedModule(HMODULE hModule, DWORD dwFlags)

{

       //如果一个新的模块被加载，挂钩各CAPIHook对象要求的API函数

       if((hModule != NULL) && ((dwFlags&LOAD_LIBRARY_AS_DATAFILE) == 0 ))

       {

              CAPIHook *p = sm_pHeader;

              while(p != NULL)

              {

                     ReplaceIATEntryInOneMod(p->m_pszModName, p->m_pfnOrig,

                                   p->m_pfnHook, hModule);

                     p = p->m_pNext;   

              }

       }

}

其中，dwFlags是LoadLibraryEx函数的一个附加参数，它指定了加载时采取的行动，只要它的值中不包含LOAD_LIBRARY_AS_DATAFILE标记，就说明文件要以镜像方式映射到内存中。

 

3）防止程序在运行期间动态调用API函数

并不是只有经过导入表才能调用API函数，应用程序可以在运行期间调用GetProcAddress函数取得API函数的地址再调用它，因此，我们也需要默认挂钩GetProcAddress函数。CAPIHook类的静态成员函数GetProcAddress将替换这个API：

FARPROC WINAPI CAPIHook::GetProcAddress(HMODULE hModule, PCSTR pszProcName)

{

       //得到这个函数的真实地址

       FARPROC pfn = ::GetProcAddress(hModule, pszProcName);

       //看它是不是我们要hook的函数

       CAPIHook *p = sm_pHeader;

       while(p != NULL)

       {

              if(p->m_pfnOrig == pfn)

              {

                     pfn = p->m_pfnHook;

                     break;   

              }     

              p = p->m_pNext;

       }     

       return pfn;

}

 

下面是完整的CAPIHook类的实现：

=====================APIHook.h============================

#ifndef __APIHOOK_H__

#define __APIHOOK_H__

#include <windows.h>

class CAPIHook 

{

public:

       CAPIHook(LPSTR  pszModName, LPSTR pszFuncName,

                            PROC pfnHook, BOOL bExcludeAPIHookMod=TRUE);

       virtual ~CAPIHook();

       operator PROC() {return m_pfnOrig;}

 

private:

       LPSTR m_pszModName;        //导出要HOOK函数的模块的名字

       LPSTR m_pszFuncName;  //要HOOK的函数的名字

       PROC m_pfnOrig;                  //原API函数地址

       PROC m_pfnHook;                //HOOK后函数的地址

       BOOL m_bExcludeAPIHookMod; //是否将HOOK API的模块本身排除在外

 

private:

       static void ReplaceIATEntryInAllMods(LPSTR pszExportMod, PROC pfnCurrent,

                     PROC pfnNew, BOOL bExcludeAPIHookMod);

       static void ReplaceIATEntryInOneMod(LPSTR pszExportMod, PROC pfnCurrent,

                     PROC pfnNew, HMODULE hModCaller);

 

       //下面的代码用来解决其他模块动态加载DLL的问题

private:

       //这两个指针用来将所有的CAPIHook对象连在一起

       static CAPIHook *sm_pHeader;

       CAPIHook *m_pNext;

 

private:

       //当一个新的DLL被加载时，调用此函数

       static void WINAPI HookNewlyLoadedModule(HMODULE hModule, DWORD dwFlags);

       //用来跟踪当前进程加载新的DLL

       static HMODULE WINAPI LoadLibraryA(PCSTR pszModulePath);

       static HMODULE WINAPI LoadLibraryW(PCWSTR pszModulePath);

       static HMODULE WINAPI LoadLibraryExA(PCSTR pszModulePath, HANDLE hFile, DWORD dwFlags);

       static HMODULE WINAPI LoadLibraryExW(PCWSTR pszModulePath, HANDLE hFile, DWORD dwFlags);

       //如果请求已HOOK的API函数，则返回用户自定义函数的地址

       static FARPROC WINAPI GetProcAddress(HMODULE hModule, PCSTR pszProcName);

 

private:

       //自动对这些函数进行挂钩

       static CAPIHook sm_LoadLibraryA;

       static CAPIHook sm_LoadLibraryW;

       static CAPIHook sm_LoadLibraryExA;

       static CAPIHook sm_LoadLibraryExW;

       static CAPIHook sm_GetProcAddress;

 

};

#endif

 

========================APIHook.cpp========================

#include "APIHook.h"

#include "Tlhelp32.h"

#include <ImageHlp.h>  //为了调用ImageDirectoryEntryToData函数

#pragma comment(lib, "ImageHlp")

 

//CAPIHook对象链表的头指针

CAPIHook *CAPIHook::sm_pHeader = NULL;

 

//

// Construction/Destruction

//

 

CAPIHook::CAPIHook(LPSTR pszModName, LPSTR pszFuncName,

                               PROC pfnHook, BOOL bExcludeAPIHookMod/* =TRUE */)

{

       //保存这个Hook函数的信息

       m_bExcludeAPIHookMod = bExcludeAPIHookMod;

       m_pszModName = pszModName;

       m_pszFuncName = pszFuncName;

       m_pfnHook = pfnHook;

       m_pfnOrig = ::GetProcAddress(::GetModuleHandle(pszModName), pszFuncName);

 

       //将此对象添加到链表中

       m_pNext = sm_pHeader;

       sm_pHeader = this;

       //在所有当前已加载的模块中HOOK这个函数

       ReplaceIATEntryInAllMods(m_pszModName, m_pfnOrig, m_pfnHook,

                     bExcludeAPIHookMod);

}

 

CAPIHook::~CAPIHook()

{

       //取消对所有模块中函数的HOOK

       ReplaceIATEntryInAllMods(m_pszModName, m_pfnHook, m_pfnOrig,

                     m_bExcludeAPIHookMod);

       CAPIHook *p = sm_pHeader;

       //从链表中移除此对象

       if(p == this)

       {

              sm_pHeader = p->m_pNext;

       }

       else

       {

              while(p != NULL)

              {

                     if(p->m_pNext == this)

                     {

                            p->m_pNext = this->m_pNext;

                            break;

                     }

                     p = p->m_pNext;

              }

       }

      

}

 

void CAPIHook::ReplaceIATEntryInOneMod(LPSTR pszExportMod, PROC pfnCurrent,

                                                               PROC pfnNew, HMODULE hModCaller)

{

       //取得模块的导入表(import descriptor)的首地址

       //ImageDirectoryEntryToData函数可以返回导入表地址

       ULONG ulSize;

       PIMAGE_IMPORT_DESCRIPTOR pImportDesc =

              (PIMAGE_IMPORT_DESCRIPTOR)::ImageDirectoryEntryToData(hModCaller, TRUE,

                                                                             IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize);

       if(pImportDesc == NULL)      //这个模块没有导入表项

              return;  

       //查找包含pszExportMod模块中函数导入信息的导入表项

       while(pImportDesc->Name != 0)

       {

              LPSTR pszMod = (LPSTR)((DWORD)hModCaller + pImportDesc->Name);

              if (lstrcmpi(pszMod, pszExportMod) == 0)      //找到

              {

                     break;

              }

              pImportDesc++;

       }

 

       if (pImportDesc->Name == 0)    //hModCaller模块没有从pszExportMod模块导入任何函数

       {

              return;

       }

 

       //取得调用者的导入地址表(import address table, IAT)

       PIMAGE_THUNK_DATA pThunk = (PIMAGE_THUNK_DATA)(pImportDesc->FirstThunk +

                                                                             (DWORD)hModCaller);

       //查找我们要HOOK的函数，将它的地址用新函数的地址替换掉

       while (pThunk->u1.Function)

       {

              //lpAddr指向的内存保存了函数的地址

              PDWORD lpAddr = (PDWORD)&(pThunk->u1.Function);

              if (*lpAddr == (DWORD)pfnCurrent)

              {

                     //修改页的保护属性

                     DWORD dwOldProtect;

                     MEMORY_BASIC_INFORMATION mbi;

                     ::VirtualQuery(lpAddr, &mbi, sizeof(mbi));

                     ::VirtualProtect(lpAddr, sizeof(DWORD), PAGE_READWRITE, &dwOldProtect);

 

                     //修改内存地址，相当于"lpAddr = (DWORD)pfnNew;"

                     ::WriteProcessMemory(::GetCurrentProcess(), lpAddr,

                                   &pfnNew, sizeof(DWORD), NULL);

                     ::VirtualProtect(lpAddr, sizeof(DWORD), dwOldProtect, 0);

                     break;

              }

              pThunk++;

       }

}

 

void CAPIHook::ReplaceIATEntryInAllMods(LPSTR pszExportMod, PROC pfnCurrent,

                                                        PROC pfnNew, BOOL bExcludeAPIHookMod)

{

       //取得当前模块的句柄

       HMODULE hModThis = NULL;

       if(bExcludeAPIHookMod)

       {

              MEMORY_BASIC_INFORMATION mbi;

              if(::VirtualQuery(ReplaceIATEntryInAllMods, &mbi, sizeof(mbi)) != 0)

                     hModThis = (HMODULE)mbi.AllocationBase;

       }

 

       //取得本进程的模块列表

       HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, ::GetCurrentProcessId());

 

       //遍历所有模块，分别对它们调用ReplaceIATEntryInOnMod函数，修改导入地址表

       MODULEENTRY32 me = {sizeof(MODULEENTRY32)};

       BOOL bOK = ::Module32First(hSnap, &me);

       while (bOK)

       {

              //注意，我们不HOOK当前模块的函数

              if (me.hModule != hModThis)

              {

                     ReplaceIATEntryInOneMod(pszExportMod, pfnCurrent, pfnNew, me.hModule);

              }

 

              bOK = ::Module32Next(hSnap, &me);

       }

       ::CloseHandle(hSnap);

}

 

//挂钩LoadLibrary和GetProcAddress函数，以便在这些函数被调用以后，挂钩的函数也能够被正确的处理

CAPIHook CAPIHook::sm_LoadLibraryA("Kernel32.dll", "LoadLibraryA",

                                                           (PROC)CAPIHook::LoadLibraryA, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryW("Kernel32.dll", "LoadLibraryW",

                                                           (PROC)CAPIHook::LoadLibraryW, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryExA("Kernel32.dll", "LoadLibraryExA",

                                                                (PROC)CAPIHook::LoadLibraryExA, TRUE);

CAPIHook CAPIHook::sm_LoadLibraryExW("Kernel32.dll", "LoadLibraryExW",

                                                                (PROC)CAPIHook::LoadLibraryExW, TRUE);

CAPIHook CAPIHook::sm_GetProcAddress("Kernel32.dll", "GetProcAddress",

                                                                (PROC)CAPIHook::GetProcAddress, TRUE);

 

void WINAPI CAPIHook::HookNewlyLoadedModule(HMODULE hModule, DWORD dwFlags)

{

       //如果一个新的模块被加载，挂钩各CAPIHook对象要求的API函数

       if((hModule != NULL) && ((dwFlags&LOAD_LIBRARY_AS_DATAFILE) == 0))

       {

              CAPIHook *p = sm_pHeader;

              while (p != NULL)

              {

                     ReplaceIATEntryInOneMod(p->m_pszModName, p->m_pfnOrig,

                                                                      p->m_pfnHook, hModule);

                     p = p->m_pNext;

              }

       }

}

 

HMODULE WINAPI CAPIHook::LoadLibraryA(PCSTR pszModulePath)

{

       HMODULE hModule = ::LoadLibraryA(pszModulePath);

       HookNewlyLoadedModule(hModule, 0);

       return hModule;

}

 

HMODULE WINAPI CAPIHook::LoadLibraryW(PCWSTR pszModulePath)

{

       HMODULE hModule = ::LoadLibraryW(pszModulePath);

       HookNewlyLoadedModule(hModule, 0);

       return hModule;

}

 

HMODULE WINAPI CAPIHook::LoadLibraryExA(PCSTR pszModulePath, HANDLE hFile, DWORD dwFlags)

{

       HMODULE hModule = ::LoadLibraryExA(pszModulePath, hFile, dwFlags);

       HookNewlyLoadedModule(hModule, dwFlags);

       return hModule;

}

 

HMODULE WINAPI CAPIHook::LoadLibraryExW(PCWSTR pszModulePath, HANDLE hFile, DWORD dwFlags)

{

       HMODULE hModule = ::LoadLibraryExW(pszModulePath, hFile, dwFlags);

       HookNewlyLoadedModule(hModule, dwFlags);

       return hModule;

}

 

FARPROC WINAPI CAPIHook::GetProcAddress(HMODULE hModule, PCSTR pszProcName)

{

       //得到函数的真实地址

       FARPROC pfn = ::GetProcAddress(hModule, pszProcName);

       //看它是否我们要HOOK的函数

       CAPIHook *p = sm_pHeader;

       while(p != NULL)

       {

              if (p->m_pfnOrig == pfn)

              {

                     pfn = p->m_pfnHook;

                     break;

              }

              p = p->m_pNext;

       }

       return pfn;

}

woshinia
关注
专栏目录
API Hook总结之一
Jack的博客
07-30 752
6,API Hook总结 实际上, droidplugin框架一共Hook了十多个服务对应的API接口, ServiceManager和LocationManager API的Hook 在前面已经详细论述了。 这些Hook一般都是在HookFactory的installHook方法中构造和安装的。 其实主要就是三要素,Hook类, Hook 代理类以及Hook 方法实现类。 6.1, A
HOOK Windows API
flowwaterdog的博客
04-26 539
HOOK Windows API 只能HOOK 本地的API，适用于入门学习 HOOK API的一般步骤： 1.定义假API函数 假API函数，除了函数名称和真API不一样之外，其它的都要跟真API的定义相同，如参数类型和返回值、调用形式等。 int WINAPI MyMessageBoxW(HWND hWnd,LPCWSTR lpText,LPCWSTR lpCaption,UINT uType...
APi Hook教程
08-09
API_Hooking(LoadLibrary)
Windows API Hook
热门推荐
friendan的专栏
10-02 3万+
原文地址：http://blog.sina.com.cn/s/blog_628821950100xmuc.html 原文对我的帮助极大，正是因为看了原文，我才学会了HOOK，鉴于原文的排版不是很好， 又没有原工程例子源码下载，因此我决定对其重新整理，文章后面附有我测试时的工程源码下载地址。 注：我测试的环境为Win7+VS2008+MFC -------------------------
Windows下Hook API技术
08-20 2230
Windows下Hook API技术     什么叫Hook API？所谓Hook就是钩子的意思，而API是指Windows开放给程序员的编程接口，使得在用户级别下可以对操作系统
Windows下Hook API 技术(HOOK SEND）
weixin_33749242的博客
11-10 554
Windows下HookAPI技术 什么叫HookAPI？所谓Hook就是钩子的意思，而API是指Windows开放给程序员的编程接口，使得在用户级别下可以对操作系统进行控制，也就是...
Windows Hook 易核心编程(3) API Hook 续 拦截API
10-08 1268
Windows Hook 易核心编程(3) API Hook 续 拦截API 在开始之前,让我们先来回顾一下:什么叫Hook API？      所谓Hook就是钩子的意思，而API是指Windows开放给程序员的编程接口，使得在用户级别下可以对操作系统进行控制，也就是一般的应用程序都需要调用API来完成某些功能，Hook API的意思就是在这些应用程序调用真正的系统API
HOOKAPI.rar_api hook_hook api_hookapi
最新发布
09-24
本资源"HOOKAPI.rar_api hook_hook api_hookapi"包含了一组与API Hook相关的MFC（Microsoft Foundation Class）代码，这对于理解API Hook的工作原理以及在实际项目中应用这一技术是非常有价值的。 API Hook的基本...
hook_api.zip_API_HOOK API_Hook_api_hook_hook api
09-23
标题中的"hook_api.zip_API_HOOK API_Hook_api_hook_hook api"可能是指一个包含有关API Hook实现的压缩包文件，可能包含了代码示例或工具。 描述中提到"api钩子好像比较好用"，这意味着API Hook在某些场景下非常...
api.rar_HOOK API_api hook_api hook codeproject_hook_hook api
09-22
在"api.rar_HOOK API_api hook_api hook codeproject_hook_hook api"这个主题中，我们主要讨论的是在CodeProject平台上关于API Hook的技术文章和资源。CodeProject是一个程序员社区，提供了大量的编程教程和技术文章...
Hook Windows API
03-14
修改API函数前5个字节为一条jmp指令，跳转到自己写的Hook_api，实现hook系统api函数
Windows下Hook API 技术
04-15
windows hook技术，讲解如何在系统调用API之前植入自己的代码，完成自己设计的相关功能，外挂，木马，侦听监测程序都用到该技术，此技术仅用于技术交流。
windows钩子编程大全
10-26
二、API Hook的原理 这里的API既包括传统的Win32 APIs，也包括任何Module输出的函数调用。熟悉PE文件格 式的朋友都知道，PE文件将对外部Module输出函数的调用信息保存在输入表中，即.idata段。 下面首先介绍本段的结构。 输入表首先以一个IMAGE_IMPORT_DESCRIPTOR(简称IID)数组开始。每个被PE文件隐式链接 进来的DLL都有一个IID.在这个数组中的最后一个单元是NULL，可以由此计算出该数组的项数。 例如，某个PE文件从两个DLL中引入函数，就存在两个IID结构来描述这些DLL文件，并在两个 IID结构的最后由一个内容全为0的IID结构作为结束。几个结构定义如下： IMAGE_IMPORT_DESCRIPTOR struct union{ DWORD Characteristics; ;00h DWORD OriginalFirstThunk; }; TimeDateStamp DWORD ;04h ForwarderChain DWORD ;08h Name DWORD ;0Ch FirstThunk DWORD ;10h IMAGE_IMPROT_DESCRIPTOR ends typedef struct _IMAGE_THUNK_DATA{ union{ PBYTE ForwarderString; PDWORD Functions; DWORD Ordinal; PIMAGE_IMPORT_BY_NAME AddressOfData; }u1; } IMAGE_IMPORT_BY_NAME结构保存一个输入函数的相关信息： IMAGE_IMPORT_BY_NAME struct Hint WORD ? ;本函数在其所驻留DLL的输出表中的序号 Name BYTE ? ;输入函数的函数名，以NULL结尾的ASCII字符串 IMAGE_IMPORT_BY_NAME ends OriginalFirstThunk(Characteristics):这是一个IMAGE_THUNK_DATA数组的RVA（相对于PE文件 起始处）。其中每个指针都指向IMAGE_IMPORT_BY_NAME结构。 TimeDateStamp:一个32位的时间标志，可以忽略。 ForwarderChain:正向链接索引，一般为0。当程序引用一个DLL中的API，而这个API又引用别的 DLL的API时使用。 NameLL名字的指针。是个以00结尾的ASCII字符的RVA地址，如"KERNEL32.DLL"。 FirstThunk:通常也是一个IMAGE_THUNK_DATA数组的RVA。如果不是一个指针，它就是该功能在 DLL中的序号。 OriginalFirstThunk与FirstThunk指向两个本质相同的数组IMAGE_THUNK_DATA，但名称不同， 分别是输入名称表(Import Name Table,INT)和输入地址表(Import Address Table,IAT)。 IMAGE_THUNK_DATA结构是个双字，在不同时刻有不同的含义，当双字最高位为1时，表示函数以 序号输入，低位就是函数序号。当双字最高位为0时，表示函数以字符串类型的函数名 方式输入，这时它是指向IMAGE_IMPORT_BY_NAME结构的RVA。 三个结构关系如下图： IMAGE_IMPORT_DESCRIPTOR INT IMAGE_IMPORT_BY_NAME IAT -------------------- /-->---------------- ---------- ---------------- |01| 函数1 ||02| 函数2 || n| ... |"USER32.dll" | |--------------------| | | FirstThunk |---------------------------------------------------------------/ -------------------- 在PE文件中对DLL输出函数的调用，主要以这种形式出现： call dword ptr[xxxxxxxx] 或 jmp [xxxxxxxx] 其中地址xxxxxxxx就是IAT中一个IMAGE_THUNK_DATA结构的地址，[xxxxxxxx]取值为IMAGE_THUNK_DATA 的值，即IMAGE_IMPORT_BY_NAME的地址。在操作系统加载PE文件的过程中，通过IID中的Name加载相应 的DLL，然后根据INT或IAT所指向的IMAGE_IMPORT_BY_NAME中的输入函数信息，在DLL中确定函数地址， 然后将函数地址写到IAT中，此时IAT将不再指向IMAGE_IMPORT_BY_NAME数组。这样[xxxxxxxx]取到的 就是真正的API地址。 从以上分析可以看出，要拦截API的调用，可以通过改写IAT来实现，将自己函数的地址写到IAT中， 达到拦截目的。 另外一种方法的原理更简单，也更直接。我们不是要拦截吗，先在内存中定位要拦截的API的地址， 然后改写代码的前几个字节为 jmp xxxxxxxx，其中xxxxxxxx为我们的API的地址。这样对欲拦截API的 调用实际上就跳转到了咱们的API调用去了，完成了拦截。不拦截时，再改写回来就是了。 这都是自己从网上辛辛苦苦找来的，真的很好啊
HOOKAPI.rar_API函数_asm hook_hook_hook api
09-20
在这个名为"HOOKAPI.rar"的压缩包中，很可能包含了一系列用于实现ASM HOOK的源代码、示例、文档或库文件。 API（应用程序编程接口）是操作系统或其他软件提供给开发者用于交互的接口，如Windows API、Linux API等。...
HookAPI.rar_Hook Api rmxp_hook a_hook api_好学习Hook_注册表 hook
09-23
"HookAPI.rar_Hook Api rmxp_hook a_hook api_好学习Hook_注册表 hook"这个压缩包似乎包含了一系列关于Hook API的实践教程和示例，特别关注于RMXP（RPG Maker XP）平台，以及注册表相关的Hook应用。 RMXP是一款流行...
WINDOWS钩子函数(HOOK)
shailen126的专栏
07-24 922
   WINDOWS钩子函数的功能非常强大，      有了它您可以探测其它进程并且改变其它进程的行为。　　理论：　　WINDOWS的钩子函数可以认为是WINDOWS的主要特性之一。利用它们，您可以捕捉您自己进程或其它进程发生的事件。 通过“挂钩”，您可以给WINDOWS一个处理或过滤事件的回调函数，该函数也叫做“钩子函数”，当每次发生您感兴趣的事件时，WINDOWS都
WinAPI Hook
yinhaijing123的专栏
11-15 579
1、抢先load 需要hook的dll，替换需要hook的函数的地址，
Windows Hook Api
是我
12-14 386
今天在写Hook ws2_32 的函数send的时候,发现总是让程序崩溃, 崩溃的时候程序的崩溃点总是在ws2_32的模块中,最后发现在调用Hook函数时候,我进行了还原, 还原的保护代码是PAGE_READWRITE,这样子导致其他线程在执行对应的地址代码产生了一个执行错误的代码! 哎,太久没有使用逆向了,导致就生疏了! 具体原因是: VirtualProtect ( pOld
Windows Hook程序 (仅限于个人练习使用)
To be an artist
02-10 1267
Windows Hook的简单介绍 最近看到一些关于Windows Hook的相关使用，出于好奇心的角度，同时在系统API和DLL方面存在一定的知识欠缺，因此希望通过此机会来熟悉一下Win32的系统API~~ Window是一个事件驱动机制的OS，整个OS都是通过消息传递来实现的，而Hook就是类似于WireShark一样的截获处理工具，分为多种Hook，例如键盘钩子、外壳钩子(截获、启动关闭应用程序消息) Windows Hook的运行机制 Hook的运行遵从"栈”的原理，即先安装的Hook放在最后
使用IAT替换实现Hook API详解
"替换IAT中的导入函数地址实现Hook API技术" 在Windows程序设计中，Hook API是一种常用的技术，用于拦截和修改其他进程中的函数调用。这种技术通常用于调试、监控、性能分析以及功能扩展等场景。本摘要将详细讨论...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值