prepare

Author: Nyano1337

CMakeLists.txt

@@ -15,15 +15,17 @@ include_directories(
 	./vendor/nlohmann
 	./vendor/fmt/include
 	./vendor/polyhook/include
+	./vendor/safetyhook/include
 	./vendor/zlib/include
 )
 
 file(GLOB SURFTIMER_LIBS 
-    "./vendor/libmem/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    "./vendor/libmodule/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    "./vendor/libhv/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    "./vendor/polyhook/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
-    "./vendor/zlib/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/libmem/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/libmodule/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/libhv/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/polyhook/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/safetyhook/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
+	"./vendor/zlib/lib/*${CMAKE_STATIC_LIBRARY_SUFFIX}"
 )
 
 file(GLOB_RECURSE SDK_SOURCES 

src/cs2surf.cpp

@@ -19,6 +19,8 @@
 
 #include <vendor/MultiAddonManager/public/imultiaddonmanager.h>
 
+#include <safetyhook.hpp>
+
 IMultiAddonManager* g_pMultiAddonManager;
 
 CSurfPlugin g_SurfPlugin;
@@ -29,6 +31,11 @@ CSurfPlugin* SurfPlugin() {
 	return &g_SurfPlugin;
 }
 
+SafetyHookInline g_HkSurfPlugin{};
+CSurfPlugin* HkSurfPlugin() {
+	return g_HkSurfPlugin.call<CSurfPlugin*>();
+}
+
 bool CSurfPlugin::Load(PluginId id, ISmmAPI* ismm, char* error, size_t maxlen, bool late) {
 	PLUGIN_SAVEVARS();
 
@@ -45,6 +52,8 @@ bool CSurfPlugin::Load(PluginId id, ISmmAPI* ismm, char* error, size_t maxlen, b
 
 	g_SMAPI->AddListener(this, this);
 
+	g_HkSurfPlugin = safetyhook::create_inline(SurfPlugin, HkSurfPlugin);
+
 	ADMIN::AddAdmin(76561198083290027, AdminFlag::Root);
 
 	return true;

vendor/safetyhook/include/safetyhook.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "safetyhook/os.hpp"
+#include "safetyhook/easy.hpp"
+#include "safetyhook/inline_hook.hpp"
+#include "safetyhook/mid_hook.hpp"
+#include "safetyhook/vmt_hook.hpp"
+
+using SafetyHookContext = safetyhook::Context;
+using SafetyHookInline = safetyhook::InlineHook;
+using SafetyHookMid = safetyhook::MidHook;
+using SafetyInlineHook [[deprecated("Use SafetyHookInline instead.")]] = safetyhook::InlineHook;
+using SafetyMidHook [[deprecated("Use SafetyHookMid instead.")]] = safetyhook::MidHook;
+using SafetyHookVmt = safetyhook::VmtHook;
+using SafetyHookVm = safetyhook::VmHook;

vendor/safetyhook/include/safetyhook/allocator.hpp

@@ -0,0 +1,133 @@
+/// @file safetyhook/allocator.hpp
+/// @brief Allocator for allocating memory near target addresses.
+
+#pragma once
+
+#ifndef SAFETYHOOK_USE_CXXMODULES
+#include <cstdint>
+#include <expected>
+#include <memory>
+#include <mutex>
+#include <vector>
+#else
+import std.compat;
+#endif
+
+#include "safetyhook/common.hpp"
+
+namespace safetyhook {
+class Allocator;
+
+/// @brief A memory allocation.
+class SAFETYHOOK_API Allocation final {
+public:
+    Allocation() = default;
+    Allocation(const Allocation&) = delete;
+    Allocation(Allocation&& other) noexcept;
+    Allocation& operator=(const Allocation&) = delete;
+    Allocation& operator=(Allocation&& other) noexcept;
+    ~Allocation();
+
+    /// @brief Frees the allocation.
+    /// @note This is called automatically when the Allocation object is destroyed.
+    void free();
+
+    /// @brief Returns a pointer to the data of the allocation.
+    /// @return Pointer to the data of the allocation.
+    [[nodiscard]] uint8_t* data() const noexcept { return m_address; }
+
+    /// @brief Returns the address of the allocation.
+    /// @return The address of the allocation.
+    [[nodiscard]] uintptr_t address() const noexcept { return reinterpret_cast<uintptr_t>(m_address); }
+
+    /// @brief Returns the size of the allocation.
+    /// @return The size of the allocation.
+    [[nodiscard]] size_t size() const noexcept { return m_size; }
+
+    /// @brief Tests if the allocation is valid.
+    /// @return True if the allocation is valid, false otherwise.
+    explicit operator bool() const noexcept { return m_address != nullptr && m_size != 0; }
+
+protected:
+    friend Allocator;
+
+    Allocation(std::shared_ptr<Allocator> allocator, uint8_t* address, size_t size) noexcept;
+
+private:
+    std::shared_ptr<Allocator> m_allocator{};
+    uint8_t* m_address{};
+    size_t m_size{};
+};
+
+/// @brief Allocates memory near target addresses.
+class SAFETYHOOK_API Allocator final : public std::enable_shared_from_this<Allocator> {
+public:
+    /// @brief Returns the global Allocator.
+    /// @return The global Allocator.
+    [[nodiscard]] static std::shared_ptr<Allocator> global();
+
+    /// @brief Creates a new Allocator.
+    /// @return The new Allocator.
+    [[nodiscard]] static std::shared_ptr<Allocator> create();
+
+    Allocator(const Allocator&) = delete;
+    Allocator(Allocator&&) noexcept = delete;
+    Allocator& operator=(const Allocator&) = delete;
+    Allocator& operator=(Allocator&&) noexcept = delete;
+    ~Allocator() = default;
+
+    /// @brief The error type returned by the allocate functions.
+    enum class Error : uint8_t {
+        BAD_VIRTUAL_ALLOC,  ///< VirtualAlloc failed.
+        NO_MEMORY_IN_RANGE, ///< No memory in range.
+    };
+
+    /// @brief Allocates memory.
+    /// @param size The size of the allocation.
+    /// @return The Allocation or an Allocator::Error if the allocation failed.
+    [[nodiscard]] std::expected<Allocation, Error> allocate(size_t size);
+
+    /// @brief Allocates memory near a target address.
+    /// @param desired_addresses The target address.
+    /// @param size The size of the allocation.
+    /// @param max_distance The maximum distance from the target address.
+    /// @return The Allocation or an Allocator::Error if the allocation failed.
+    [[nodiscard]] std::expected<Allocation, Error> allocate_near(
+        const std::vector<uint8_t*>& desired_addresses, size_t size, size_t max_distance = 0x7FFF'FFFF);
+
+protected:
+    friend Allocation;
+
+    void free(uint8_t* address, size_t size);
+
+private:
+    struct FreeNode {
+        std::unique_ptr<FreeNode> next{};
+        uint8_t* start{};
+        uint8_t* end{};
+    };
+
+    struct Memory {
+        uint8_t* address{};
+        size_t size{};
+        std::unique_ptr<FreeNode> freelist{};
+
+        ~Memory();
+    };
+
+    std::vector<std::unique_ptr<Memory>> m_memory{};
+    std::mutex m_mutex{};
+
+    Allocator() = default;
+
+    [[nodiscard]] std::expected<Allocation, Error> internal_allocate_near(
+        const std::vector<uint8_t*>& desired_addresses, size_t size, size_t max_distance = 0x7FFF'FFFF);
+    void internal_free(uint8_t* address, size_t size);
+
+    static void combine_adjacent_freenodes(Memory& memory);
+    [[nodiscard]] static std::expected<uint8_t*, Error> allocate_nearby_memory(
+        const std::vector<uint8_t*>& desired_addresses, size_t size, size_t max_distance);
+    [[nodiscard]] static bool in_range(
+        uint8_t* address, const std::vector<uint8_t*>& desired_addresses, size_t max_distance);
+};
+} // namespace safetyhook

vendor/safetyhook/include/safetyhook/common.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#if defined(_MSC_VER)
+#define SAFETYHOOK_COMPILER_MSVC 1
+#define SAFETYHOOK_COMPILER_GCC 0
+#define SAFETYHOOK_COMPILER_CLANG 0
+#elif defined(__GNUC__)
+#define SAFETYHOOK_COMPILER_MSVC 0
+#define SAFETYHOOK_COMPILER_GCC 1
+#define SAFETYHOOK_COMPILER_CLANG 0
+#elif defined(__clang__)
+#define SAFETYHOOK_COMPILER_MSVC 0
+#define SAFETYHOOK_COMPILER_GCC 0
+#define SAFETYHOOK_COMPILER_CLANG 1
+#else
+#error "Unsupported compiler"
+#endif
+
+#if SAFETYHOOK_COMPILER_MSVC
+#if defined(_M_IX86)
+#define SAFETYHOOK_ARCH_X86_32 1
+#define SAFETYHOOK_ARCH_X86_64 0
+#elif defined(_M_X64)
+#define SAFETYHOOK_ARCH_X86_32 0
+#define SAFETYHOOK_ARCH_X86_64 1
+#else
+#error "Unsupported architecture"
+#endif
+#elif SAFETYHOOK_COMPILER_GCC || SAFETYHOOK_COMPILER_CLANG
+#if defined(__i386__)
+#define SAFETYHOOK_ARCH_X86_32 1
+#define SAFETYHOOK_ARCH_X86_64 0
+#elif defined(__x86_64__)
+#define SAFETYHOOK_ARCH_X86_32 0
+#define SAFETYHOOK_ARCH_X86_64 1
+#else
+#error "Unsupported architecture"
+#endif
+#endif
+
+#if defined(_WIN32)
+#define SAFETYHOOK_OS_WINDOWS 1
+#define SAFETYHOOK_OS_LINUX 0
+#elif defined(__linux__)
+#define SAFETYHOOK_OS_WINDOWS 0
+#define SAFETYHOOK_OS_LINUX 1
+#else
+#error "Unsupported OS"
+#endif
+
+#if SAFETYHOOK_OS_WINDOWS
+#if SAFETYHOOK_COMPILER_MSVC
+#define SAFETYHOOK_CCALL __cdecl
+#define SAFETYHOOK_STDCALL __stdcall
+#define SAFETYHOOK_FASTCALL __fastcall
+#define SAFETYHOOK_THISCALL __thiscall
+#elif SAFETYHOOK_COMPILER_GCC || SAFETYHOOK_COMPILER_CLANG
+#define SAFETYHOOK_CCALL __attribute__((cdecl))
+#define SAFETYHOOK_STDCALL __attribute__((stdcall))
+#define SAFETYHOOK_FASTCALL __attribute__((fastcall))
+#define SAFETYHOOK_THISCALL __attribute__((thiscall))
+#endif
+#else
+#define SAFETYHOOK_CCALL
+#define SAFETYHOOK_STDCALL
+#define SAFETYHOOK_FASTCALL
+#define SAFETYHOOK_THISCALL
+#endif
+
+#if SAFETYHOOK_COMPILER_MSVC
+#define SAFETYHOOK_NOINLINE __declspec(noinline)
+#elif SAFETYHOOK_COMPILER_GCC || SAFETYHOOK_COMPILER_CLANG
+#define SAFETYHOOK_NOINLINE __attribute__((noinline))
+#endif
+
+#if SAFETYHOOK_COMPILER_MSVC
+#define SAFETYHOOK_DLLEXPORT __declspec(dllexport)
+#define SAFETYHOOK_DLLIMPORT __declspec(dllimport)
+#elif SAFETYHOOK_COMPILER_GCC || SAFETYHOOK_COMPILER_CLANG
+#define SAFETYHOOK_DLLEXPORT __attribute__((visibility("default")))
+#define SAFETYHOOK_DLLIMPORT
+#endif
+
+#if SAFETYHOOK_SHARED_LIB && SAFETYHOOK_BUILDING
+#define SAFETYHOOK_API SAFETYHOOK_DLLEXPORT
+#elif SAFETYHOOK_SHARED_LIB
+#define SAFETYHOOK_API SAFETYHOOK_DLLIMPORT
+#else
+#define SAFETYHOOK_API
+#endif

vendor/safetyhook/include/safetyhook/context.hpp

@@ -0,0 +1,57 @@
+/// @file safetyhook/context.hpp
+/// @brief Context structure for MidHook.
+
+#pragma once
+
+#ifndef SAFETYHOOK_USE_CXXMODULES
+#include <cstdint>
+#else
+import std.compat;
+#endif
+
+#include "safetyhook/common.hpp"
+
+namespace safetyhook {
+union Xmm {
+    uint8_t u8[16];
+    uint16_t u16[8];
+    uint32_t u32[4];
+    uint64_t u64[2];
+    float f32[4];
+    double f64[2];
+};
+
+/// @brief Context structure for 64-bit MidHook.
+/// @details This structure is used to pass the context of the hooked function to the destination allowing full access
+/// to the 64-bit registers at the moment the hook is called.
+/// @note rip will point to a trampoline containing the replaced instruction(s).
+/// @note rsp is read-only. Modifying it will have no effect. Use trampoline_rsp to modify rsp if needed but make sure
+/// the top of the stack is the rip you want to resume at.
+struct Context64 {
+    Xmm xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7, xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15;
+    uintptr_t rflags, r15, r14, r13, r12, r11, r10, r9, r8, rdi, rsi, rdx, rcx, rbx, rax, rbp, rsp, trampoline_rsp, rip;
+};
+
+/// @brief Context structure for 32-bit MidHook.
+/// @details This structure is used to pass the context of the hooked function to the destination allowing full access
+/// to the 32-bit registers at the moment the hook is called.
+/// @note eip will point to a trampoline containing the replaced instruction(s).
+/// @note esp is read-only. Modifying it will have no effect. Use trampoline_esp to modify esp if needed but make sure
+/// the top of the stack is the eip you want to resume at.
+struct Context32 {
+    Xmm xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7;
+    uintptr_t eflags, edi, esi, edx, ecx, ebx, eax, ebp, esp, trampoline_esp, eip;
+};
+
+/// @brief Context structure for MidHook.
+/// @details This structure is used to pass the context of the hooked function to the destination allowing full access
+/// to the registers at the moment the hook is called.
+/// @note The structure is different depending on architecture.
+/// @note The structure only provides access to integer registers.
+#if SAFETYHOOK_ARCH_X86_64
+using Context = Context64;
+#elif SAFETYHOOK_ARCH_X86_32
+using Context = Context32;
+#endif
+
+} // namespace safetyhook