MinHook 如何对.NET底层的 Win32函数进行拦截（上）

摘要：在前面的系列中，我们聊过.NET外挂 harmony，他可以对.NET SDK方法进行拦截，这在.NET高级调试领域中非常重要，但这里也有一些遗憾，就是不能对SDK领域之外的函数进行拦截，比如 Win32 函数。。。

1. 讲故事

在前面的系列中，我们聊过.NET外挂 harmony，他可以对.NET SDK方法进行拦截，这在.NET高级调试领域中非常重要，但这里也有一些遗憾，就是不能对SDK领域之外的函数进行拦截，比如 Win32 函数。。。

这篇我们就来解决这个问题，对，它就是 MinHook，当然我也调查了easyhook和detours，前者年久失修，后者是商业库，加上我的要求相对简单，使用极简版的 minhook 就够了，而且该项目在github上也是非常活跃的：https://github.com/TsudaKageyu/minhook

1. 开箱即用方式观察MinHook.h头文件，会发现很多的 C 导出函数，如下所示：
#ifdef __cplusplus
extern"C" {
#endif

// Initialize the MinHook library. You must call this function EXACTLY ONCE
// at the beginning of your program.
MH_STATUS WINAPI MH_Initialize(void);

// Uninitialize the MinHook library. You must call this function EXACTLY
// ONCE at the end of your program.
MH_STATUS WINAPI MH_Uninitialize(VOID);

...
}

有了这些导出函数，就可以通过 C# 的 PInvoke 直接调用，这里就演示一个拦截 MessageBox 方法,完整代码如下：

using System;
using System.Diagnostics;
using System.Runtime.InteropServices;

namespaceConsoleApp2
{
internalclassProgram
{
static void Main(string args)
{
// 安装钩子
HookManager.InstallHook("user32.dll", "MessageBoxW",
(IntPtr hWnd, string text, string caption, uint type) =>
{
Console.WriteLine($"我已成功拦截到 MessageBox：内容{text}, 标题:{caption}");

var original = Marshal.GetDelegateForFunctionPoInter(HookManager.OriginalFunction);

return original(hWnd, text, caption, type);
});

// 测试 MessageBox 调用（钩子会捕获这个）
MessageBox(IntPtr.Zero, "This is a test", "Test",0);

// 卸载钩子
HookManager.UninstallHook;

Console.ReadLine;
}

[DllImport("user32.dll", CharSet = CharSet.Unicode)]
private static extern int MessageBox(IntPtr hWnd, string text, string caption, uint type);
}

publicstaticclassHookManager
{
// 定义 MessageBox 的委托
[UnmanagedFunctionPointer(CallingConvention.StdCall, CharSet = CharSet.Unicode)]
public delegate int MessageBoxDelegate(IntPtr hWnd, string text, string caption, uint type);

// 原始函数的指针
publicstatic IntPtr OriginalFunction = IntPtr.Zero;

// 当前钩子的目标函数地址
privatestatic IntPtr _targetFunction = IntPtr.Zero;

public static void InstallHook(string moduleName, string functionName, MessageBoxDelegate detourFunc)
{
// 1. 初始化 MinHook
var status = MinHook.MH_Initialize;
if (status != MinHook.MH_STATUS.MH_OK)
{
Console.WriteLine($"MH_Initialize failed:{status}");
return;
}

// 2. 获取目标函数的地址
_targetFunction = MinHook.GetProcAddress(MinHook.GetModuleHandle(moduleName), functionName);
if (_targetFunction == IntPtr.Zero)
{
Console.WriteLine($"Failed to get{functionName}address");
return;
}

// 3. 创建钩子
var detourPtr = Marshal.GetFunctionPointerForDelegate(detourFunc);
status = MinHook.MH_CreateHook(_targetFunction, detourPtr, out OriginalFunction);

{
Console.WriteLine($"MH_CreateHook failed:{status}");
return;
}

// 4. 启用钩子
status = MinHook.MH_EnableHook(_targetFunction);

{
Console.WriteLine($"MH_EnableHook failed:{status}");
return;
}

Console.WriteLine($"{functionName}hook installed successfully");
}

public static void UninstallHook
{

{
Console.WriteLine("No active hook to uninstall");
return;
}

// 1. 禁用钩子
var status = MinHook.MH_DisableHook(_targetFunction);

{
Console.WriteLine($"MH_DisableHook failed:{status}");
}

// 2. 移除钩子
status = MinHook.MH_RemoveHook(_targetFunction);

{
Console.WriteLine($"MH_RemoveHook failed:{status}");
}

// 3. 卸载 MinHook
status = MinHook.MH_Uninitialize;

{
Console.WriteLine($"MH_Uninitialize failed:{status}");
}

_targetFunction = IntPtr.Zero;
OriginalFunction = IntPtr.Zero;

Console.WriteLine("Hook uninstalled successfully");
}
}

publicclassMinHook
{
// MH_STATUS 枚举
publicenum MH_STATUS
{
MH_UNKNOWN =-1
MH_OK =0
MH_ERROR_ALREADY_INITIALIZED,
MH_ERROR_NOT_INITIALIZED,
MH_ERROR_ALREADY_CREATED,
MH_ERROR_NOT_CREATED,
MH_ERROR_ENABLED,
MH_ERROR_DISABLED,
MH_ERROR_NOT_EXECUTABLE,
MH_ERROR_UNSUPPORTED_FUNCTION,
MH_ERROR_MEMORY_ALLOC,
MH_ERROR_MEMORY_PROTECT,
MH_ERROR_MODULE_NOT_FOUND,
MH_ERROR_FUNCTION_NOT_FOUND
}

public IntPtr MH_ALL_HOOKS = IntPtr.Zero;

// 导入 MinHook 函数
[DllImport("MinHook.x86.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern MH_STATUS MH_Initialize;

public static extern MH_STATUS MH_Uninitialize;

public static extern MH_STATUS MH_CreateHook(IntPtr pTarget, IntPtr pDetour, out IntPtr ppOriginal);

[DllImport("MinHook.x86.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Unicode)]
public static extern MH_STATUS MH_CreateHookApi(string pszModule, string pszProcName, IntPtr pDetour, out IntPtr ppOriginal);

public static extern MH_STATUS MH_RemoveHook(IntPtr pTarget);

public static extern MH_STATUS MH_EnableHook(IntPtr pTarget);

public static extern MH_STATUS MH_DisableHook(IntPtr pTarget);

public static extern IntPtr MH_StatusToString(MH_STATUS status);

[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
public static extern IntPtr GetModuleHandle(string lpModuleName);

[DllImport("kernel32.dll", CharSet = CharSet.Ansi, SetLastError = true)]
public static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName);
}
}

由于这个 C# 程序是 32bit 的，所以将MinHook.x86.dll拷贝到C#程序的当前目录。

最后将程序运行起来，该有的都出现了。

个人实践下来，我发现有两个小问题：

当你用 vs 单步调试的时候，走到 MH_CreateHook方法时会抛Fatal error. Internal CLR error. (0x80131506)CLR 内部错误，看起来VS调试器做了一些手脚，截图如下：

2. 当你想在 InstallHook 中的 detourFunc 函数下断点，也不会被命中，截图如下：

总的来说对VS调试有一点影响，但也不太大，还是可以接受的，毕竟用 C# 来调用轻车熟路，如果你熟悉 windbg 的话，用它是一点问题都没有。。。

2. 深度融合方式

用 C# 的 Pinvoke 调用 MinHook，总感觉少了那个味，如果用原汁原味的 C 调用 MinHook 那就相当完美了，在解决一些比较复杂注入非常有必要。

这里我采用libMinHook.x86.lib以静态链接的方式将当前的 ConsoleApplication2 和 MinHook 合二为一，截图如下：

接下来做三点配置：

右键属性配置下头文件和 dll库搜索路径，截图如下：

2. 右键属性配置下依赖文件名，截图如下：

最后就是完整的 C 代码。

#include
#include
#include
#include
#include

typedef int (WINAPI* Real_MessageBoxW)(
HWND hWnd,
LPCWSTR lpText,
LPCWSTR lpCaption,
UINT uType
);

Real_MessageBoxW fpMessageBoxW = ;

int WINAPI Hook_MessageBoxW(
HWND hWnd,
LPCWSTR lpText,
LPCWSTR lpCaption,
UINT uType)
{
_setmode(_fileno(stdout), _O_U16TEXT);

wprintf(L"拦截 MessageBoxW:\n");
wprintf(L" 文本: %s\n", lpText); // 移除 &，直接使用 lpText
wprintf(L" 标题: %s\n", lpCaption); // 移除 &，直接使用 lpCaption

return fpMessageBoxW(
hWnd,
lpText,
lpCaption,
uType);
}

extern"C" __declspec(dllexport) void InstallHook
{
HMODULE hModule = GetModuleHandleW(L"user32.dll");
Real_MessageBoxW pOrigMessageBoxW = (Real_MessageBoxW)GetProcAddress(hModule, "MessageBoxW");

if (pOrigMessageBoxW == ) {
printf("无法获取 MessageBoxW 地址\n");
return;
}

if (MH_Initialize != MH_OK) {
printf("MinHook 初始化失败\n");
return;
}

if (MH_CreateHook(pOrigMessageBoxW, &Hook_MessageBoxW, (void**)&fpMessageBoxW) != MH_OK) {
printf("创建 Hook 失败\n");
return;
}

if (MH_EnableHook(pOrigMessageBoxW) != MH_OK) {
printf("启用 Hook 失败\n");
return;
}

printf("MessageBoxW Hook 安装成功\n");
}

extern"C" __declspec(dllexport) void UninstallHook
{
MH_DisableHook(MH_ALL_HOOKS);
MH_Uninitialize;
}

这是只对外公开了 InstallHook 和 UninstallHook 装卸载方法，最后就是高层的 C# 代码。

using System;
using System.Runtime.InteropServices;

namespaceConsoleApp1
{
internalclassProgram
{
static void Main(string args)
{
Console.WriteLine("正在安装 MessageBox 钩子...");
InstallHook;

Console.WriteLine("将弹出测试消息框，观察输出...");

// 弹出测试消息框（会被钩子拦截）
MessageBoxW(IntPtr.Zero, "这是测试内容", "测试标题",0);

Console.WriteLine("按任意键退出并卸载钩子...");
Console.ReadKey;

UninstallHook;
Console.WriteLine("钩子已卸载");
}

// 导入 user32.dll 的 MessageBoxW
[DllImport("user32.dll", CharSet = CharSet.Unicode, CallingConvention = CallingConvention.Winapi)]
public static extern int MessageBoxW(
IntPtr hWnd,
string lpText,
string lpCaption,
uint uType);

// 导入DLL中的函数
[DllImport("ConsoleApplication2.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void InstallHook;

public static extern void UninstallHook;
}
}

在运行之前将ConsoleApplication2拷贝到 C# 程序的当前目录，直接运行 C# 项目即可。