Initial commit for GitHub migration based on spice2x-25-03-03

2026-08-02 14:50:41 -07:00 · 2025-03-10 19:16:49 -07:00
parent 94af8d32c9
commit ed8c72852f
1008 changed files with 296815 additions and 0 deletions
@@ -0,0 +1,109 @@
+#pragma once
+
+#include <initializer_list>
+#include <string>
+
+#include <windows.h>
+
+#define VTBL_TYPE(TYPE, MEMBER) decltype(((TYPE *) 0)->lpVtbl->MEMBER)
+
+namespace detour {
+
+    /*
+     * Inline hooks
+     */
+
+    bool inline_hook(void *new_adr, void *address);
+    bool inline_noprotect(void *new_adr, void *address);
+    bool inline_preserve(void *new_adr, void *address, char *data);
+    bool inline_restore(void *address, char *data);
+    bool trampoline(const char *dll, const char *func, void *hook, void **orig);
+    bool trampoline(void *func, void *hook, void **orig);
+    bool trampoline_try(const char *dll, const char *func, void *hook, void **orig);
+    bool trampoline_try(void *func, void *hook, void **orig);
+
+    /*
+     * Inline hook aliases
+     */
+
+    template<typename T, typename U>
+    inline bool inline_hook(T new_adr, U address) {
+        return inline_hook(
+                reinterpret_cast<void *>(new_adr),
+                reinterpret_cast<void *>(address));
+    }
+    template<typename T>
+    inline bool trampoline(const char *dll, const char *func, T hook, T *orig) {
+        return trampoline(
+                dll,
+                func,
+                reinterpret_cast<void *>(hook),
+                reinterpret_cast<void **>(orig));
+    }
+    template<typename T>
+    inline bool trampoline(T func, T hook, T *orig) {
+        return trampoline(
+                reinterpret_cast<void *>(func),
+                reinterpret_cast<void *>(hook),
+                reinterpret_cast<void **>(orig));
+    }
+    template<typename T>
+    inline bool trampoline_try(const char *dll, const char *func, T hook, T *orig) {
+        return trampoline_try(
+                dll,
+                func,
+                reinterpret_cast<void *>(hook),
+                reinterpret_cast<void **>(orig));
+    }
+    template<typename T>
+    inline bool trampoline_try(T func, T hook, T *orig) {
+        return trampoline_try(
+                reinterpret_cast<void *>(func),
+                reinterpret_cast<void *>(hook),
+                reinterpret_cast<void **>(orig));
+    }
+
+    /*
+     * IAT hooks
+     */
+
+    // for finding IAT entries - you probably won't need to use those yourself
+    void **iat_find(const char *function, HMODULE module, const char *iid_name = nullptr);
+    void **iat_find_ordinal(const char *iid_name, DWORD ordinal, HMODULE module);
+    void **iat_find_proc(const char *iid_name, void *proc, HMODULE module);
+
+    // best effort hooks - they will fail silently
+    void *iat_try(const char *function, void *new_func, HMODULE module = nullptr, const char *iid_name = nullptr);
+    void *iat_try_ordinal(const char *iid_name, DWORD ordinal, void *new_func, HMODULE module);
+    void *iat_try_proc(const char *iid_name, void *proc, void *new_func, HMODULE module = nullptr);
+
+    template<typename T>
+    inline T iat_try(const char *function, T new_func, HMODULE module = nullptr, const char *iid_name = nullptr) {
+        return reinterpret_cast<T>(iat_try(function, reinterpret_cast<void *>(new_func), module, iid_name));
+    }
+    template<typename T>
+    inline T iat_try_ordinal(const char *iid_name, DWORD ordinal, T new_func, HMODULE module) {
+        return reinterpret_cast<T>(iat_try_ordinal(iid_name, ordinal, reinterpret_cast<void *>(new_func), module));
+    }
+    template<typename T>
+    inline T iat_try_proc(const char *iid_name, T proc, T new_func, HMODULE module = nullptr) {
+        return reinterpret_cast<T>(iat_try_proc(
+                    iid_name,
+                    reinterpret_cast<void *>(proc),
+                    reinterpret_cast<void *>(new_func),
+                    module));
+    }
+
+    // guaranteed hooks - they will stop the program on failure
+    void *iat(const char *function, void *new_func, HMODULE module = nullptr);
+    void *iat_ordinal(const char *iid_name, DWORD ordinal, void *new_func, HMODULE module);
+
+    template<typename T>
+    inline T iat(const char *iid_name, T new_func, HMODULE module = nullptr) {
+        return reinterpret_cast<T>(iat(iid_name, reinterpret_cast<void *>(new_func), module));
+    }
+    template<typename T>
+    inline T iat_ordinal(const char *iid_name, DWORD ordinal, T new_func, HMODULE module = nullptr) {
+        return reinterpret_cast<T>(iat_ordinal(iid_name, ordinal, reinterpret_cast<void *>(new_func), module));
+    }
+}