Polyhook -> safetyhook

narknon · narknon · commit d377423ec5cb · 2024-12-19T16:15:37.000-05:00
fix: safetyhook compilation (localcc)

Add call_hook and call_hook_unsafe helper wrappers for Safetyhook

Add deprecation warning to polyhook_2 xmake file.
diff --git a/UE4SS/include/CrashDumper.hpp b/UE4SS/include/CrashDumper.hpp
@@ -2,10 +2,7 @@
 
 #include <memory>
 
-namespace PLH
-{
-    class IatHook;
-}
+#include <safetyhook.hpp>
 
 namespace RC
 {
@@ -14,8 +11,7 @@ namespace RC
       private:
         bool enabled = false;
         void* m_previous_exception_filter = nullptr;
-        std::unique_ptr<PLH::IatHook> m_set_unhandled_exception_filter_hook;
-        uint64_t m_hook_trampoline_set_unhandled_exception_filter_hook;
+        SafetyHookInline m_set_unhandled_exception_filter_hook;
 
       public:
         CrashDumper();
diff --git a/UE4SS/include/UE4SSProgram.hpp b/UE4SS/include/UE4SSProgram.hpp
@@ -21,6 +21,7 @@
 #include <Unreal/Core/Containers/Array.hpp>
 #include <Unreal/UnrealVersion.hpp>
 
+#include <safetyhook.hpp>
 #include <String/StringType.hpp>
 
 // Used to set up ImGui context and allocator in DLL mods
@@ -133,17 +134,10 @@ namespace RC
         std::mutex m_event_queue_mutex{};
 
       private:
-        std::unique_ptr<PLH::IatHook> m_load_library_a_hook;
-        uint64_t m_hook_trampoline_load_library_a;
-
-        std::unique_ptr<PLH::IatHook> m_load_library_ex_a_hook;
-        uint64_t m_hook_trampoline_load_library_ex_a;
-
-        std::unique_ptr<PLH::IatHook> m_load_library_w_hook;
-        uint64_t m_hook_trampoline_load_library_w;
-
-        std::unique_ptr<PLH::IatHook> m_load_library_ex_w_hook;
-        uint64_t m_hook_trampoline_load_library_ex_w;
+        SafetyHookInline m_load_library_a_hook;
+        SafetyHookInline m_load_library_ex_a_hook;
+        SafetyHookInline m_load_library_w_hook;
+        SafetyHookInline m_load_library_ex_w_hook;
 
       public:
         std::vector<std::unique_ptr<Mod>> m_mods;
diff --git a/UE4SS/src/CrashDumper.cpp b/UE4SS/src/CrashDumper.cpp
@@ -6,7 +6,6 @@
 #include <UE4SSProgram.hpp>
 #include <Unreal/Core/Windows/WindowsHWrapper.hpp>
 
-#include <polyhook2/PE/IatHook.hpp>
 #include <dbghelp.h>
 
 #include <String/StringType.hpp>
@@ -78,21 +77,15 @@ namespace RC
 
     CrashDumper::~CrashDumper()
     {
-        m_set_unhandled_exception_filter_hook->unHook();
+        m_set_unhandled_exception_filter_hook = {};
         SetUnhandledExceptionFilter(reinterpret_cast<LPTOP_LEVEL_EXCEPTION_FILTER>(m_previous_exception_filter));
     }
 
     void CrashDumper::enable()
     {
         SetErrorMode(SEM_FAILCRITICALERRORS);
         m_previous_exception_filter = SetUnhandledExceptionFilter(ExceptionHandler);
-
-        m_set_unhandled_exception_filter_hook = std::make_unique<PLH::IatHook>("kernel32.dll",
-                                                                               "SetUnhandledExceptionFilter",
-                                                                               std::bit_cast<uint64_t>(&HookedSetUnhandledExceptionFilter),
-                                                                               &m_hook_trampoline_set_unhandled_exception_filter_hook,
-                                                                               L"");
-        m_set_unhandled_exception_filter_hook->hook();
+        m_set_unhandled_exception_filter_hook = safetyhook::create_inline(SetUnhandledExceptionFilter, HookedSetUnhandledExceptionFilter);
         this->enabled = true;
     }
 
diff --git a/UE4SS/src/UE4SSProgram.cpp b/UE4SS/src/UE4SSProgram.cpp
@@ -55,8 +55,6 @@
 #include <Unreal/World.hpp>
 #include <UnrealDef.hpp>
 
-#include <polyhook2/PE/IatHook.hpp>
-
 namespace RC
 {
     // Commented out because this system (turn off hotkeys when in-game console is open) it doesn't work properly.
@@ -132,31 +130,31 @@ namespace RC
     void* HookedLoadLibraryA(const char* dll_name)
     {
         UE4SSProgram& program = UE4SSProgram::get_program();
-        HMODULE lib = PLH::FnCast(program.m_hook_trampoline_load_library_a, &LoadLibraryA)(dll_name);
+        HMODULE lib = program.m_load_library_a_hook.call<HMODULE>(dll_name);
         program.fire_dll_load_for_cpp_mods(ensure_str(dll_name));
         return lib;
     }
 
     void* HookedLoadLibraryExA(const char* dll_name, void* file, int32_t flags)
     {
         UE4SSProgram& program = UE4SSProgram::get_program();
-        HMODULE lib = PLH::FnCast(program.m_hook_trampoline_load_library_ex_a, &LoadLibraryExA)(dll_name, file, flags);
+        HMODULE lib = program.m_load_library_ex_a_hook.call<HMODULE>(dll_name, file, flags);
         program.fire_dll_load_for_cpp_mods(ensure_str(dll_name));
         return lib;
     }
 
     void* HookedLoadLibraryW(const wchar_t* dll_name)
     {
         UE4SSProgram& program = UE4SSProgram::get_program();
-        HMODULE lib = PLH::FnCast(program.m_hook_trampoline_load_library_w, &LoadLibraryW)(dll_name);
+        HMODULE lib = program.m_load_library_w_hook.call<HMODULE>(dll_name);
         program.fire_dll_load_for_cpp_mods(ToCharTypePtr(dll_name));
         return lib;
     }
 
     void* HookedLoadLibraryExW(const wchar_t* dll_name, void* file, int32_t flags)
     {
         UE4SSProgram& program = UE4SSProgram::get_program();
-        HMODULE lib = PLH::FnCast(program.m_hook_trampoline_load_library_ex_w, &LoadLibraryExW)(dll_name, file, flags);
+        HMODULE lib = program.m_load_library_ex_w_hook.call<HMODULE>(dll_name, file, flags);
         program.fire_dll_load_for_cpp_mods(ToCharTypePtr(dll_name));
         return lib;
     }
@@ -234,35 +232,10 @@ namespace RC
 #define UE4SS_COMPILER STR("MSVC")
 #endif
 
-            Output::send(STR("UE4SS Build Configuration: {} ({})\n"), ensure_str(UE4SS_CONFIGURATION), UE4SS_COMPILER);
-
-            m_load_library_a_hook = std::make_unique<PLH::IatHook>("kernel32.dll",
-                                                                   "LoadLibraryA",
-                                                                   std::bit_cast<uint64_t>(&HookedLoadLibraryA),
-                                                                   &m_hook_trampoline_load_library_a,
-                                                                   L"");
-            m_load_library_a_hook->hook();
-
-            m_load_library_ex_a_hook = std::make_unique<PLH::IatHook>("kernel32.dll",
-                                                                      "LoadLibraryExA",
-                                                                      std::bit_cast<uint64_t>(&HookedLoadLibraryExA),
-                                                                      &m_hook_trampoline_load_library_ex_a,
-                                                                      L"");
-            m_load_library_ex_a_hook->hook();
-
-            m_load_library_w_hook = std::make_unique<PLH::IatHook>("kernel32.dll",
-                                                                   "LoadLibraryW",
-                                                                   std::bit_cast<uint64_t>(&HookedLoadLibraryW),
-                                                                   &m_hook_trampoline_load_library_w,
-                                                                   L"");
-            m_load_library_w_hook->hook();
-
-            m_load_library_ex_w_hook = std::make_unique<PLH::IatHook>("kernel32.dll",
-                                                                      "LoadLibraryExW",
-                                                                      std::bit_cast<uint64_t>(&HookedLoadLibraryExW),
-                                                                      &m_hook_trampoline_load_library_ex_w,
-                                                                      L"");
-            m_load_library_ex_w_hook->hook();
+            m_load_library_a_hook = safetyhook::create_inline(LoadLibraryA, HookedLoadLibraryA);
+            m_load_library_ex_a_hook = safetyhook::create_inline(LoadLibraryExA, HookedLoadLibraryExA);
+            m_load_library_w_hook = safetyhook::create_inline(LoadLibraryW, HookedLoadLibraryW);
+            m_load_library_ex_w_hook = safetyhook::create_inline(LoadLibraryExW, HookedLoadLibraryExW);
 
             Unreal::UnrealInitializer::SetupUnrealModules();
 
diff --git a/UE4SS/xmake.lua b/UE4SS/xmake.lua
@@ -9,6 +9,7 @@ add_requires("glfw 3.3.9", { debug = is_mode_debug() , configs = {runtimes = get
 add_requires("opengl", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
 add_requires("glaze v2.9.5", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
 add_requires("fmt 10.2.1", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
+add_requires("safetyhook v0.4.1", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
 
 option("ue4ssBetaIsStarted")
     set_default(true)
@@ -79,7 +80,7 @@ target(projectName)
 
     add_packages("imgui", "ImGuiTextEdit", "IconFontCppHeaders", "glfw", "opengl", { public = true })
 
-    add_packages("glaze", "polyhook_2", { public = true })
+    add_packages("glaze", "safetyhook", "polyhook_2", { public = true })
 
     add_links("dbghelp", "psapi", "d3d11", { public = true })
 
diff --git a/deps/first/ASMHelper/include/ASMHelper/ASMHelper.hpp b/deps/first/ASMHelper/include/ASMHelper/ASMHelper.hpp
@@ -9,7 +9,7 @@ namespace RC::ASM
     {
         void* address{};
         ZydisDecodedInstruction raw{};
-        ZydisDecodedOperand* operands{};
+        ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT]{};
     };
 
     RC_ASM_API auto resolve_jmp(void* instruction_ptr) -> void*;
diff --git a/deps/first/ASMHelper/src/ASMHelper.cpp b/deps/first/ASMHelper/src/ASMHelper.cpp
@@ -12,13 +12,13 @@ namespace RC::ASM
         ZydisDecoder decoder{};
         ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_STACK_WIDTH_64);
         ZyanUSize offset = 0;
-        ZydisDecodedInstruction instruction{};
-        ZydisDecodedOperand operands[10]{};
-        while (ZYAN_SUCCESS(ZydisDecoderDecodeFull(&decoder, instruction_ptr + offset, 16 - offset, &instruction, operands)))
+
+        Instruction instruction{in_instruction_ptr, {}, {}};
+        while (ZYAN_SUCCESS(ZydisDecoderDecodeFull(&decoder, instruction_ptr + offset, 16 - offset, &instruction.raw, instruction.operands)))
         {
             break;
         }
-        return {in_instruction_ptr, instruction, operands};
+        return instruction;
     }
 
     auto resolve_absolute_address(void* in_instruction_ptr) -> void*
diff --git a/deps/first/Helpers/include/Helpers/Hook.hpp b/deps/first/Helpers/include/Helpers/Hook.hpp
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <Function/Function.hpp>
+
+#include <safetyhook.hpp>
+
+namespace RC::Helper::Hook
+{
+    template <typename>
+    class call_hook;
+
+    template <typename ReturnType, typename... Params>
+    class call_hook<Function<ReturnType(Params...)>>
+    {
+      public:
+        ReturnType operator()(SafetyHookInline& hook, Params... args)
+        {
+            return hook.call<ReturnType, Params...>(std::forward<Params>(args)...);
+        }
+    };
+
+    template <typename>
+    class call_hook_unsafe;
+    
+    template <typename ReturnType, typename... Params>
+    class call_hook_unsafe<Function<ReturnType(Params...)>>
+    {
+    public:
+        ReturnType operator()(SafetyHookInline& hook, Params... args)
+        {
+            return hook.unsafe_call<ReturnType, Params...>(std::forward<Params>(args)...);
+        }
+    };
+} // namespace RC::Helper::Hook
diff --git a/deps/first/Helpers/xmake.lua b/deps/first/Helpers/xmake.lua
@@ -7,6 +7,7 @@ target(projectName)
     add_rules("ue4ss.dependency")
 
     add_deps("String")
+    add_packages("safetyhook")
     
     add_includedirs("include", { public = true })
     add_headerfiles("include/**.hpp")
diff --git a/deps/first/Unreal b/deps/first/Unreal
@@ -1 +1 @@
-Subproject commit 69a66d2eea439dfe4e493f73105597284afcd93f
+Subproject commit a85db69c5b535d37b603f31a7ba42b4bcc112204
diff --git a/deps/third-repo/packages/p/polyhook_2/xmake.lua b/deps/third-repo/packages/p/polyhook_2/xmake.lua
@@ -2,7 +2,8 @@ package("polyhook_2")
     set_sourcedir(os.scriptdir())
     
     add_deps("cmake", "zydis", "zycore")
-
+    -- Print a deprecation warning
+    print("Warning: The package 'polyhook_2' is deprecated and will be removed in a future release.  If you are using this package please update your code to use 'safetyhook'.")
     on_install(function (package)
         local configs = {}
 
@@ -16,5 +17,6 @@ package("polyhook_2")
 
         import("package.tools.cmake").install(package, configs, { packagedeps = { "zycore", "zydis" } })
         
+        
     end)
 package_end()
diff --git a/deps/third-repo/packages/s/safetyhook/xmake.lua b/deps/third-repo/packages/s/safetyhook/xmake.lua
@@ -0,0 +1,18 @@
+package("safetyhook")
+    add_urls("git@github.com:cursey/safetyhook.git")
+    add_urls("https://github.com/cursey/safetyhook.git")
+
+    add_versions("v0.4.1", "629558c64009a7291ba6ed5cfb49187086a27a47")
+
+    add_deps("cmake", "zydis")
+    
+    on_install(function (package)
+        local configs = {}
+        table.insert(configs, "-DCMAKE_BUILD_TYPE=" .. (package:debug() and "Debug" or "Release"))
+        table.insert(configs, "-DBUILD_SHARED_LIBS=OFF")
+        import("package.tools.cmake").install(package, configs, { packagedeps = {"zydis", "zycore"} })
+
+        os.cp("include/*.hpp", package:installdir("include"))
+        os.cp("include/safetyhook/*.hpp", package:installdir("include/safetyhook"))
+    end)
+package_end()
diff --git a/deps/xmake.lua b/deps/xmake.lua
@@ -8,4 +8,5 @@ add_repositories("third-party deps/third-repo", { rootdir = get_config("ue4ssRoo
 
 add_requires("zycore v1.5.0", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
 add_requires("zydis v4.1.0", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
-add_requires("polyhook_2", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
+add_requires("polyhook_2", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })
+add_requires("safetyhook", { debug = is_mode_debug(), configs = {runtimes = get_mode_runtimes()} })

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace RC::ASM`
`9`	`9`	`{`
`10`	`10`	`void* address{};`
`11`	`11`	`ZydisDecodedInstruction raw{};`
`12`		`- ZydisDecodedOperand* operands{};`
	`12`	`+ ZydisDecodedOperand operands[ZYDIS_MAX_OPERAND_COUNT]{};`
`13`	`13`	`};`
`14`	`14`
`15`	`15`	`RC_ASM_API auto resolve_jmp(void* instruction_ptr) -> void*;`
Original file line number	Diff line number	Diff line change
`@@ -12,13 +12,13 @@ namespace RC::ASM`
`12`	`12`	`ZydisDecoder decoder{};`
`13`	`13`	`ZydisDecoderInit(&decoder, ZYDIS_MACHINE_MODE_LONG_64, ZYDIS_STACK_WIDTH_64);`
`14`	`14`	`ZyanUSize offset = 0;`
`15`		`- ZydisDecodedInstruction instruction{};`
`16`		`- ZydisDecodedOperand operands[10]{};`
`17`		`- while (ZYAN_SUCCESS(ZydisDecoderDecodeFull(&decoder, instruction_ptr + offset, 16 - offset, &instruction, operands)))`
	`15`	`+`
	`16`	`+ Instruction instruction{in_instruction_ptr, {}, {}};`
	`17`	`+ while (ZYAN_SUCCESS(ZydisDecoderDecodeFull(&decoder, instruction_ptr + offset, 16 - offset, &instruction.raw, instruction.operands)))`
`18`	`18`	`{`
`19`	`19`	`break;`
`20`	`20`	`}`
`21`		`- return {in_instruction_ptr, instruction, operands};`
	`21`	`+ return instruction;`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`auto resolve_absolute_address(void* in_instruction_ptr) -> void*`