如何为钩子创建蹦床函数

我对挂钩很感兴趣，我决定看看是否可以挂钩一些函数。我对使用 detours 这样的库不感兴趣，因为我想拥有自己做的经验。通过我在互联网上找到的一些资源，我能够创建下面的代码。这是基本的，但效果还不错。然而，当挂钩由多个线程调用的函数时，它被证明是极其不稳定的。如果几乎同时进行两个调用，则会崩溃。经过一番研究，我认为我需要创建一个蹦床功能。经过几个小时的寻找，除了关于蹦床是什么的一般描述之外，我找不到任何其他东西。我找不到任何关于编写蹦床函数或它们如何真正工作的具体内容。如果有人可以帮助我写一篇文章，发布一些资料，或者至少通过推荐一些文章、网站、书籍等为我指明正确的方向。我将不胜感激。

下面是我写的代码。这确实很基础，但我希望其他人可以从中学习。

test.cpp

#include "stdafx.h"

Hook hook;

typedef int (WINAPI *tMessageBox)(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType);

DWORD hMessageBox(HWND hWnd, LPCTSTR lpText, LPCTSTR lpCaption, UINT uType)
{
    hook.removeHook();
    tMessageBox oMessageBox = (tMessageBox)hook.funcPtr; 
    int ret =oMessageBox(hWnd, lpText, "Hooked!", uType);
    hook.applyHook(&hMessageBox);

    return ret;
}

void hookMessageBox()
{
    printf("Hooking MessageBox...\n");
    if(hook.findFunc("User32.dll", "MessageBoxA")) 
    {
        if(hook.applyHook(&hMessageBox))
        {
            printf("hook applied! \n\n");
        } else printf("hook could not be applied\n");
    }   
}

hook.cpp

#include "stdafx.h"

bool Hook::findFunc(char* libName, char* funcName) 
{
    Hook::funcPtr = (void*)GetProcAddress(GetModuleHandleA(libName), funcName); 
    return (Hook::funcPtr != NULL);
}

bool Hook::removeHook() 
{
    DWORD dwProtect;
    if(VirtualProtect(Hook::funcPtr, 6, PAGE_EXECUTE_READWRITE, &dwProtect))
        {
        WriteProcessMemory(GetCurrentProcess(), (LPVOID)Hook::funcPtr, Hook::origData, 6, 0);
        VirtualProtect(Hook::funcPtr, 6, dwProtect, NULL);
        return true;
    } else return false;
}

bool Hook::reapplyHook() 
{
    DWORD dwProtect;
    if(VirtualProtect(funcPtr, 6, PAGE_EXECUTE_READWRITE, &dwProtect)) 
        {
        WriteProcessMemory(GetCurrentProcess(), (LPVOID)funcPtr, Hook::hookData, 6, 0);
        VirtualProtect(funcPtr, 6, dwProtect, NULL);
        return true;
    } else return false;
}

bool Hook::applyHook(void* hook) 
{ 
    return setHookAtAddress(Hook::funcPtr, hook);
}

bool Hook::setHookAtAddress(void* funcPtr, void* hook) 
{
    Hook::funcPtr = funcPtr;
    BYTE jmp[6] = { 0xE9, //jmp
                   0x00, 0x00, 0x00, 0x00,  //address
                   0xC3 //retn 
                 };

    DWORD dwProtect;

    if(VirtualProtect(funcPtr, 6, PAGE_EXECUTE_READWRITE, &dwProtect)) // make memory writable
    {

        ReadProcessMemory(GetCurrentProcess(), (LPVOID)funcPtr, Hook::origData, 6, 0); // save old data
        DWORD offset = ((DWORD)hook - (DWORD)funcPtr - 5);  //((to)-(from)-5)
        memcpy(&jmp[1], &offset, 4); // write address into jmp
        memcpy(Hook::hookData, jmp, 6); // save hook data
        WriteProcessMemory(GetCurrentProcess(), (LPVOID)funcPtr, jmp, 6, 0); // write jmp
        VirtualProtect(funcPtr, 6, dwProtect, NULL); // reprotect

        return true;
    } else return false;
}

如果您希望您的钩子在被多个线程调用时是安全的，那么您不希望不断地取消钩子并重新钩子原始 API。

蹦床只是您生成的一段代码，它复制原始 API 的前几个字节的功能（您用跳转覆盖了这些字节），然后在您覆盖的字节之后跳转到 API。

您只需调用蹦床，而不是取消 API、调用它并重新挂钩它。

在 x86 上执行此操作相当复杂，因为您需要（相当少的）反汇编程序来查找指令边界。您还需要检查复制到蹦床中的代码是否没有执行与指令指针相关的任何操作（例如 jmp、分支或调用）。

这足以使对钩子的调用成为线程安全的，但如果多个线程正在使用该 API，则无法创建钩子。为此，您需要使用两个字节的近跳转（可以原子方式写入）来挂钩该函数。 Windows API 前面经常有一些 NOP（可以用远跳转覆盖）来为近跳转提供目标。

在 x64 上执行此操作是much更复杂。您不能简单地使用 64 位远跳转来修补该函数（因为没有这样的远跳转，而且模拟它的指令通常太长）。而且，根据您的蹦床的用途，您可能需要将其添加到操作系统的堆栈展开信息中。

我希望这不是太笼统。