C++鉤子與內存訪問監控的實現

在C++中，鉤子和內存訪問監控可以通過多種方式實現。這里我們將討論兩種常見的方法：使用函數鉤子和使用內存監視器。

1. 使用函數鉤子

函數鉤子是一種修改函數行為的技術。通過使用C++的函數重載和動態庫技術，我們可以實現函數鉤子。以下是一個簡單的示例：

#include <iostream>
#include <dlfcn.h> // For Linux
#include <windows.h> // For Windows

// 原始函數
int add(int a, int b) {
    return a + b;
}

// 鉤子函數
int add_hooked(int a, int b) {
    std::cout << "Hooked add function called!" << std::endl;
    return add(a, b);
}

// 動態庫入口點
extern "C" int add_wrapper(int a, int b) {
    return add_hooked(a, b);
}

// 加載動態庫并設置鉤子
void install_hook() {
    // Linux
    void* handle = dlopen("libadd_hook.so", RTLD_NOW);
    if (!handle) {
        std::cerr << "Failed to load dynamic library: " << dlerror() << std::endl;
        return;
    }
    auto add_ptr = (int (*)(int, int))dlsym(handle, "_Z12add_wrapperi");
    if (!add_ptr) {
        std::cerr << "Failed to find symbol: " << dlerror() << std::endl;
        dlclose(handle);
        return;
    }
    // Replace the original function with the hooked one
    auto original_add = add;
    add = add_ptr;

    // Windows
    // HMODULE handle = LoadLibraryA("add_hook.dll");
    // if (!handle) {
    //     std::cerr << "Failed to load dynamic library: " << GetLastError() << std::endl;
    //     return;
    // }
    // auto add_ptr = (int (*)(int, int))GetProcAddress(handle, "_Z12add_wrapperi");
    // if (!add_ptr) {
    //     std::cerr << "Failed to find symbol: " << GetLastError() << std::endl;
    //     FreeLibrary(handle);
    //     return;
    // }
    // auto original_add = add;
    // add = add_ptr;
}

int main() {
    install_hook();
    std::cout << "Result: " << add(3, 4) << std::endl;
    return 0;
}

在這個示例中，我們定義了一個原始的add函數和一個鉤子函數add_hooked。我們創建了一個動態庫入口點add_wrapper，它將調用鉤子函數。在install_hook函數中，我們加載動態庫并使用dlopen（Linux）或LoadLibraryA（Windows）來獲取函數指針，并將其替換為鉤子函數。

2. 使用內存監視器

內存監視器是一種監控內存訪問的技術。通過使用C++的虛擬函數表（vtable）和自定義內存分配器，我們可以實現內存監視器。以下是一個簡單的示例：

#include <iostream>
#include <unordered_map>
#include <cstdlib>

// 原始內存分配器
void* original_malloc(size_t size) {
    return std::malloc(size);
}

// 自定義內存分配器
class MemoryMonitor {
public:
    static void* allocate(size_t size) {
        void* ptr = original_malloc(size);
        if (ptr) {
            memory_map[ptr] = size;
        }
        return ptr;
    }

    static void deallocate(void* ptr) {
        if (ptr) {
            memory_map.erase(ptr);
            std::free(ptr);
        }
    }

    static void print_memory_usage() {
        for (const auto& entry : memory_map) {
            std::cout << "Address: " << entry.first << ", Size: " << entry.second << std::endl;
        }
    }

private:
    static std::unordered_map<void*, size_t> memory_map;
};

std::unordered_map<void*, size_t> MemoryMonitor::memory_map;

// 重載全局內存分配函數
void* operator new(size_t size) {
    return MemoryMonitor::allocate(size);
}

void operator delete(void* ptr) noexcept {
    MemoryMonitor::deallocate(ptr);
}

int main() {
    MemoryMonitor::print_memory_usage();
    int* arr = new int[10];
    MemoryMonitor::print_memory_usage();
    delete[] arr;
    MemoryMonitor::print_memory_usage();
    return 0;
}

在這個示例中，我們定義了一個原始的內存分配器original_malloc和一個自定義內存分配器MemoryMonitor。我們重載了全局的new和delete操作符，使其調用自定義內存分配器的allocate和deallocate方法。在MemoryMonitor中，我們使用一個unordered_map來存儲分配的內存地址和大小，并在需要時打印內存使用情況。

這兩種方法都可以實現C++鉤子和內存訪問監控，具體選擇哪種方法取決于你的需求和目標平臺。