Windows Practice_Dll&Hook_封装IAT Hook

进程保护器的实现

本程序实现了一个简单的暴力的进程保护器，其原理也很简单，就是修改导入表，挂钩TerminateProcess函数，因为这个函数可以远程无条件的结束其它进程，所以我们要挂钩这个函数。

因为每一个程序都有可能结束要保护的程序，所以我们必须以Dll的形式注入到每一个进程中，这就涉及到注入的问题了，而Windows给我们提供了一个简单的全局挂钩的函数，即SetWindowsHook函数。

本工程主要有三个程序，分别是ProcessProtectorDll、ProcessProtectorExe以及TerminateProcessExe，从这三个程序的名字相信大家也都知道这些程序的作用了，就不再多做解释了。

下面我们一一将它们的源代码附上并稍作解释。

ProcessProtectorDll动态链接库程序

该程序主要是用来被其它的可执行程序调用，从而达到全局挂钩并保护相应进程的目的。代码如下：

// IATHook.h文件
#pragma once
#include <string>

namespace PoEdu
{
class CIATHook
{
public:
// 初始化即Hook
// 挂哪个Dll的哪个函数的钩
// 新的函数的地址
// 现有的所有Module
CIATHook(const std::string &dll_name, const std::string &func_name, void *new_func_addr);

HMODULE WINAPI LoadLibraryA(_In_ LPCSTR lpFileName);
HMODULE WINAPI LoadLibraryW(_In_ LPCWSTR lpFileName);
HMODULE WINAPI LoadLibraryExA(_In_ LPCSTR lpFileName, _Reserved_ HANDLE hFile, _In_ DWORD dwFlags);
HMODULE WINAPI LoadLibraryExW(_In_ LPCWSTR lpFileName, _Reserved_ HANDLE hFile, _In_ DWORD dwFlags);

FARPROC WINAPI GetProcAddress(_In_ HMODULE hModule, _In_ LPCSTR lpProcName ) const;

private:
void HookAllModule() const;
void HookOneModule(HMODULE hModule) const;

private:
std::string dll_name_;
void *new_func_addr_;
void *old_func_addr_;
};
}

//IATHook.cpp文件

#include "stdafx.h"
#include "IATHook.h"
#include <TlHelp32.h>
#include <DbgHelp.h>
#include <winbase.h>

#pragma comment(lib, "DbgHelp.lib")

// 这个类还有有些不足
// 在启用新进程的时候还是挂不上

namespace PoEdu
{
CIATHook::CIATHook(const std::string& dll_name, const std::string& func_name, void* new_func_addr) :
dll_name_(dll_name), new_func_addr_(new_func_addr)
{
old_func_addr_ = GetProcAddress(GetModuleHandleA(dll_name.c_str()), func_name.c_str());

// 开始挂钩
// 每个Module都有自己的IAT，所以需要遍历所有的Module
HookAllModule();
}

HMODULE CIATHook::LoadLibraryA(LPCSTR lpFileName)
{
HMODULE hModule = ::LoadLibraryA(lpFileName);
HookOneModule(hModule);
return hModule;
}

HMODULE CIATHook::LoadLibraryW(LPCWSTR lpFileName)
{
HMODULE hModule = ::LoadLibraryW(lpFileName);
HookOneModule(hModule);
return hModule;
}

HMODULE CIATHook::LoadLibraryExA(LPCSTR lpFileName, HANDLE hFile, DWORD dwFlags)
{
HMODULE hModule = ::LoadLibraryExA(lpFileName, hFile, dwFlags);
HookOneModule(hModule);
return hModule;
}

HMODULE CIATHook::LoadLibraryExW(LPCWSTR lpFileName, HANDLE hFile, DWORD dwFlags)
{
HMODULE hModule = ::LoadLibraryExW(lpFileName, hFile, dwFlags);
HookOneModule(hModule);
return hModule;
}

FARPROC CIATHook::GetProcAddress(HMODULE hModule, LPCSTR lpProcName) const
{
FARPROC pAddr = ::GetProcAddress(hModule, lpProcName);
if (pAddr == old_func_addr_)
{
return static_cast<FARPROC>(new_func_addr_);
}
else
{
return pAddr;
}
}

void CIATHook::HookAllModule() const
{
HANDLE hSnap = ::CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, GetCurrentProcessId());
MODULEENTRY32 me32 = { sizeof(MODULEENTRY32) };
BOOL bNext = ::Module32FirstW(hSnap, &me32);

while (bNext)
{
// 给每个Module挂钩
HookOneModule(me32.hModule);

bNext = Module32NextW(hSnap, &me32);
}
CloseHandle(hSnap);
}

void CIATHook::HookOneModule(HMODULE hModule) const
{
ULONG ulSize = 0;
PIMAGE_IMPORT_DESCRIPTOR pImageImportDescriptor = static_cast<PIMAGE_IMPORT_DESCRIPTOR>(ImageDirectoryEntryToData(hModule, TRUE, IMAGE_DIRECTORY_ENTRY_IMPORT, &ulSize));
if (!pImageImportDescriptor)
{
return;
}

while (pImageImportDescriptor->Name)
{
char *pDllName = reinterpret_cast<char *>(reinterpret_cast<BYTE *>(hModule) + pImageImportDescriptor->Name);
if (dll_name_.compare(pDllName) == 0)
{
break;
}

++pImageImportDescriptor;
}

if (pImageImportDescriptor->Name)
{
PIMAGE_THUNK_DATA pImageThunkData = reinterpret_cast<PIMAGE_THUNK_DATA>(reinterpret_cast<BYTE *>(hModule) + pImageImportDescriptor->FirstThunk);

while (pImageThunkData->u1.Function)
{
DWORD *pDwAddr = &(pImageThunkData->u1.Function);

if (*pDwAddr == reinterpret_cast<DWORD>(old_func_addr_))
{
MEMORY_BASIC_INFORMATION mbi;
VirtualQuery(pDwAddr, &mbi, sizeof(MEMORY_BASIC_INFORMATION));
DWORD dwOldProtection = 0;
VirtualProtect(pDwAddr, sizeof(DWORD_PTR), PAGE_READWRITE, &dwOldProtection);

// 为了安全起见，可以使用WriteProcessMemory函数进行远进程写入，这样即使权限不够，也不会报异常
if (!WriteProcessMemory(GetCurrentProcess(), pDwAddr, &new_func_addr_, sizeof(DWORD_PTR), nullptr))
{
MessageBoxW(nullptr, L"WriteProcessMemory", L"WriteProcessMemory", MB_OK);
}

VirtualProtect(pDwAddr, sizeof(DWORD_PTR), dwOldProtection, nullptr);
break;
}
++pImageThunkData;
}
}
}
}

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "stdafx.h"
#include "IATHook.h"

// 找到当前注入后的 IAT 表 Hook TerminateProcess
//PoEdu::CIATHook g_MyHook;

DWORD g_dwPID = 0;
HHOOK g_hHook = nullptr;

BOOL WINAPI MyTerminateProcess(_In_ HANDLE hProcess, _In_ UINT uExitCode)
{
return FALSE;

//  DWORD dwPID = GetProcessId(hProcess);
//  if (g_dwPID == dwPID)
//  {
//      MessageBoxW(nullptr, L"这是我要保护的进程，请不要无条件终止它！", L"警告", MB_OK);
//      return TRUE;
//  }

//return TerminateProcess(hProcess, uExitCode);
}

PoEdu::CIATHook g_MyHook("KERNEL32.dll", "TerminateProcess", MyTerminateProcess);

BOOL APIENTRY DllMain( HMODULE hModule,
DWORD  ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
default:
break;
}
return TRUE;
}

HMODULE GetFuncModule(void * pFuncAddr)
{
HMODULE hRet = nullptr;
MEMORY_BASIC_INFORMATION mbi;
if (VirtualQuery(pFuncAddr, &mbi, sizeof(MEMORY_BASIC_INFORMATION)) != 0)
{
hRet = static_cast<HMODULE>(mbi.AllocationBase);
}

return hRet;
}

LRESULT CALLBACK GetMsgProc(_In_ int code, _In_ WPARAM wParam, _In_ LPARAM lParam)
{
//MessageBoxW(nullptr, L"GetMsgProc", L"GetMsgProc", MB_OK);
return CallNextHookEx(g_hHook, code, wParam, lParam);
}

// 用SetWindowsHook做的注入
extern "C" _declspec(dllexport) BOOL StartProtecting(DWORD dwPID)
//extern "C" _declspec(dllexport) BOOL StartProtecting()
{
BOOL bRet = FALSE;

if (g_hHook == nullptr)
{
g_hHook = SetWindowsHookEx(WH_GETMESSAGE, GetMsgProc, GetFuncModule(GetMsgProc), 0);
if (g_hHook != nullptr)
{
g_dwPID = dwPID;
bRet = TRUE;
}
}

return bRet;
}

extern "C" _declspec(dllexport) BOOL EndProtecting()
{
BOOL bRet = FALSE;

if (g_hHook != nullptr)
{
if (UnhookWindowsHookEx(g_hHook))
{
bRet = TRUE;
}
}

return bRet;
}

上面主要有问题的是MyTerminateProcess函数，从这个函数的实现可以看出，我们屏蔽的是所有的TerminateProcess，因为每一个进程在调用ProcessProtectorDll动态链接库的时候都是重新复制一份，所以没法简单的在挂钩的时候传递一个要保护的进程ID，因为在新的进程调用该动态链接库的时候，一切都是初始化状态，并没有要保护的进程ID，只能通过共享空间实现所有进程的数据共享，这里我们没有实现，感兴趣的朋友可以实现一下。。。

ProcessProtectorExe程序源码

该程序主要是加载ProcessProtectorDll动态链接库从而达到保护进程不被远程无条件结束的目的。

// ProcessProtectorExe.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>
#include <clocale>

// 选择需要保护的进程
// 启动Hook

typedef BOOL(*FUNC)(DWORD dwPID);

void PrintErrorMessage(DWORD dwErrorCode)
{
setlocale(LC_ALL, "chs");
TCHAR strErrorMessage[MAXBYTE] = { 0 };
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, dwErrorCode, 0, strErrorMessage, MAXBYTE, nullptr);
wprintf(L"错误代码是：%d    %s\r\n", dwErrorCode, strErrorMessage);
}

int main()
{
HMODULE hDllModule = nullptr;
FUNC StartProtecting = nullptr;
FARPROC EndProtecting = nullptr;
do
{
// 查找窗口
char strProcessName[MAXBYTE] = "计算器";
HWND hWnd = FindWindowA(nullptr, strProcessName);
if (hWnd == nullptr)
{
printf("the handle of window do not found!\r\n");
break;
}

// 根据窗口句柄查找进程ID
DWORD dwProcessId = 0;
GetWindowThreadProcessId(hWnd, &dwProcessId);
if (dwProcessId == NULL)
{
printf("process Id do not found!\r\n");
break;
}

// 打开进程
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
if (hProcess == nullptr)
{
printf("open the process failed!\r\n");
break;
}

// LoadLibray
hDllModule = LoadLibrary(L"ProcessProtectorDll.dll");
if (hDllModule == nullptr)
{
PrintErrorMessage(GetLastError());
break;
}

// SetHook
StartProtecting = reinterpret_cast<FUNC>(GetProcAddress(hDllModule, "StartProtecting"));
if (StartProtecting == nullptr)
{
PrintErrorMessage(GetLastError());
break;
}
if (!StartProtecting(dwProcessId))
{
PrintErrorMessage(GetLastError());
break;
}

printf("进程保护成功！\r\n");

MSG msg;
BOOL ret;
while ((ret = GetMessage(&msg, nullptr, 0, 0)))
{
if (ret == -1)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}

// UnHook
EndProtecting = GetProcAddress(hDllModule, "EndProtecting");
if (EndProtecting == nullptr)
{
PrintErrorMessage(GetLastError());
break;
}
if (!EndProtecting())
{
PrintErrorMessage(GetLastError());
break;
}
} while (false);

if (hDllModule)
{
FreeLibrary(hDllModule);
}

system("pause");
return 0;
}

由于动态链接库是被所有进程调用的，所以这里保护的是所有的进程不被远程无条件结束掉，而不只是计算器这个程序，这个需要注意一下。

**

// TerminateProcessExe.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <Windows.h>

int main()
{
do
{
// 查找窗口
char strProcessName[MAXBYTE] = "计算器";
HWND hWnd = FindWindowA(nullptr, strProcessName);
if (hWnd == nullptr)
{
printf("the handle of window do not found!\r\n");
break;
}

// 根据窗口句柄查找进程ID
DWORD dwProcessId = 0;
GetWindowThreadProcessId(hWnd, &dwProcessId);
if (dwProcessId == NULL)
{
printf("process Id do not found!\r\n");
break;
}

// 打开进程
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcessId);
if (hProcess == nullptr)
{
printf("open the process failed!\r\n");
break;
}

MessageBoxW(nullptr, L"", L"", MB_OK);

if (TerminateProcess(hProcess, 1))
{
printf("已经被终止运行！\r\n");
}
else
{
printf("没有被终止运行！\r\n");
}
} while (false);

system("pause");
return 0;
}

本程序就是尝试远程结束计算器程序，当开启了我们的进程保护器后，我们是无法终止计算器的，这也就达到了要保护的目的。

当然了，这种全局挂钩的方式是存在问题的，它会使我们的系统变得非常的慢。我们的这个进程保护器目的只是让大家了解一下什么是IAT Hook，它的原理是什么，实际上基本上不会用这种方式来实现进程保护器的。