wip

Cargo.toml

@@ -11,6 +11,7 @@ description = "todo"
 
 [dependencies]
 rayon = "1.10.0"
+sharded-slab = "0.1.7"
 
 [target.'cfg(windows)'.dependencies.pelite]
 version = "0.10.0"

examples/sections.rs

@@ -1,5 +1,12 @@
-use inka::program;
+use inka::Hook;
 
 fn main() {
-    dbg!(program());
+    unsafe extern "C" fn hook_me() {
+        println!("Original");
+    }
+
+    let _guard = (hook_me as unsafe extern "C" fn()).hook(|| println!("Hooked"));
+    dbg!(_guard);
+
+    unsafe { hook_me() };
 }

src/hook.rs

@@ -0,0 +1,55 @@
+use core::any::Any;
+use sharded_slab::Slab;
+use std::{
+    ptr::NonNull,
+    sync::{LazyLock, Mutex},
+};
+
+static HOOKS: LazyLock<Slab<Mutex<Box<dyn Any + Send>>>> = LazyLock::new(Slab::new);
+
+pub trait Hook<F>: Copy {
+    fn hook(self, f: F) -> HookGuard;
+    fn as_ptr_u8(self) -> NonNull<u8>;
+}
+
+#[derive(Debug)]
+pub struct HookGuard {
+    ptr: NonNull<u8>,
+    bytes: [u8; 10], // used to restore original function prologue
+    index: usize,
+}
+
+impl HookGuard {
+    pub fn unhook(&mut self) {
+        HOOKS.remove(self.index);
+    }
+}
+
+impl Drop for HookGuard {
+    fn drop(&mut self) {
+        self.unhook();
+    }
+}
+
+impl<F> Hook<F> for unsafe extern "C" fn()
+where
+    F: FnMut() + 'static + Send,
+{
+    fn hook(self, f: F) -> HookGuard {
+        let ptr = <unsafe extern "C" fn() as Hook<F>>::as_ptr_u8(self);
+
+        let index = HOOKS
+            .insert(Mutex::new(Box::new(f)))
+            .expect("Max shards reached");
+
+        HookGuard {
+            ptr,
+            bytes: [0; 10],
+            index,
+        }
+    }
+
+    fn as_ptr_u8(self) -> NonNull<u8> {
+        unsafe { NonNull::new_unchecked(self as *mut u8) }
+    }
+}

src/lib.rs

@@ -2,12 +2,14 @@
 
 mod base;
 mod find;
+mod hook;
 mod program;
 mod section;
 mod symbol;
 
 pub use base::Base;
 pub use find::Find;
+pub use hook::{Hook, HookGuard};
 pub use program::{program, Program};
 pub use section::Section;
 pub use symbol::Symbol;