C++ DLL函数调用拦截：原理剖析与实战解决方案

1次阅读

没有评论

共计 3522 个字符，预计需要花费 9 分钟才能阅读完成。

在 Windows 开发中，DLL 函数拦截常用于调试、性能分析、安全监控等场景。比如，我们可能需要监控某个 API 的调用频率，或者修改某些系统 API 的行为。传统的拦截方法主要有两种：修改导入表和第三方库（如 Detours）。

修改导入表：通过修改 PE 文件的导入地址表（IAT）来替换函数地址。这种方法简单，但只对显式链接的 DLL 有效，且容易被检测。
Detours 库：微软提供的官方库，功能强大，但商业使用需要授权，且在某些场景下性能开销较大。

这两种方法都存在兼容性和性能问题，尤其是在复杂的生产环境中。因此，我们需要一种更高效、更灵活的解决方案。

核心思路是通过修改目标函数的内存指令，插入一条跳转指令（如jmp）到我们的拦截函数。具体步骤如下：

备份原函数指令 ：首先备份目标函数的前几条指令（通常是 5 字节，足够放一条jmp 指令），以便后续恢复。
写入跳转指令：在目标函数的开头写入一条跳转到我们拦截函数的指令。
跳转桩（Trampoline）：为了能继续调用原函数，我们需要一个跳转桩来执行备份的指令并跳回原函数。

x86 架构：跳转指令直接使用jmp，地址是 32 位的相对偏移。
x64 架构 ：由于地址是 64 位，直接jmp 无法覆盖全部地址空间，通常需要使用 mov rax, address + jmp rax 的组合。

跳转桩的实现需要动态生成机器码，通常使用以下结构：

struct Trampoline {uint8_t original_code[5]; // 备份的原指令
    uint8_t jump_back[14];    // 跳回原函数的指令
};

以下是完整的拦截器类实现（基于 C ++14）：

#include <windows.h>
#include <memory>
#include <vector>

class FunctionHook {
public:
    FunctionHook() : m_target(nullptr), m_trampoline(nullptr) {}
    ~FunctionHook() { remove(); }

    bool install(void* target, void* detour) {
        m_target = target;
        m_detour = detour;

        // 备份原指令
        m_trampoline = VirtualAlloc(nullptr, sizeof(Trampoline), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
        if (!m_trampoline) return false;

        memcpy(m_trampoline->original_code, m_target, sizeof(m_trampoline->original_code));

        // 构建跳回指令
        build_jump_back();

        // 写入跳转指令
        DWORD old_protect;
        if (!VirtualProtect(m_target, sizeof(m_trampoline->original_code), PAGE_EXECUTE_READWRITE, &old_protect)) {return false;}

        build_jump(m_target, m_detour);
        VirtualProtect(m_target, sizeof(m_trampoline->original_code), old_protect, &old_protect);

        FlushInstructionCache(GetCurrentProcess(), m_target, sizeof(m_trampoline->original_code));
        return true;
    }

    void remove() {if (m_target && m_trampoline) {
            DWORD old_protect;
            VirtualProtect(m_target, sizeof(m_trampoline->original_code), PAGE_EXECUTE_READWRITE, &old_protect);
            memcpy(m_target, m_trampoline->original_code, sizeof(m_trampoline->original_code));
            VirtualProtect(m_target, sizeof(m_trampoline->original_code), old_protect, &old_protect);
            FlushInstructionCache(GetCurrentProcess(), m_target, sizeof(m_trampoline->original_code));

            VirtualFree(m_trampoline, 0, MEM_RELEASE);
            m_trampoline = nullptr;
            m_target = nullptr;
        }
    }

    template<typename T>
    T original() const {return reinterpret_cast<T>(m_trampoline);
    }

private:
    struct Trampoline {uint8_t original_code[5];
        uint8_t jump_back[14];
    };

    void build_jump(void* from, void* to) {uint8_t* p = static_cast<uint8_t*>(from);
#ifdef _WIN64
        // mov rax, address
        *p++ = 0x48; *p++ = 0xB8;
        *reinterpret_cast<uint64_t*>(p) = reinterpret_cast<uint64_t>(to);
        p += 8;
        // jmp rax
        *p++ = 0xFF; *p++ = 0xE0;
#else
        *p++ = 0xE9;
        *reinterpret_cast<uint32_t*>(p) = reinterpret_cast<uint32_t>(to) - reinterpret_cast<uint32_t>(from) - 5;
#endif
    }

    void build_jump_back() {
        uint8_t* p = m_trampoline->jump_back;
        memcpy(p, m_trampoline->original_code, sizeof(m_trampoline->original_code));
        p += sizeof(m_trampoline->original_code);
        build_jump(p, static_cast<uint8_t*>(m_target) + sizeof(m_trampoline->original_code));
    }

    void* m_target;
    void* m_detour;
    Trampoline* m_trampoline;
};

在修改目标函数指令时，必须确保没有其他线程正在执行该函数。通常可以通过以下方式实现：