feat: read notes

- multi-target is now supported.
- open memory is now on the client side instead of simba
- dll version is stored in the memory map as a commit hash

Author: Torwent

.github/workflows/build.yaml

@@ -12,6 +12,25 @@ env:
   NAME_WIN64: waspinput64.dll
 
 jobs:
+  update_version:
+    steps:
+      - name: Get commit hash
+        id: commit-hash
+        run: echo "COMMIT_HASH=$(git rev-parse --short HEAD)" >> $GITHUB_ENV
+      - name: Replace version hash
+        run: |
+          HASH=$(git rev-parse --short HEAD)
+          sed -i "s/^const VERSION: &str = \".*\";/const VERSION: &str = \"${HASH}\";/" src/shared/memory.rs
+      - name: Commit updated version
+        run: |
+          git config --global user.name "Wasp Bot"
+          git config --global user.email "[email protected]"
+          git add src/shared/memory.rs
+          git commit -m "Bump version"
+          git push
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
   build:
     runs-on: windows-latest
     strategy:

src/client/hooks.rs

@@ -12,7 +12,7 @@ use std::char::from_u32;
 use windows::{
     core::{BOOL, PCSTR},
     Win32::{
-        Foundation::{CloseHandle, GetLastError, HWND, LPARAM, LRESULT, WPARAM},
+        Foundation::{GetLastError, HWND, LPARAM, LRESULT, WPARAM},
         Graphics::{
             Gdi::HDC,
             OpenGL::{glGetIntegerv, GL_VIEWPORT},
@@ -39,21 +39,15 @@ use super::graphics::{
 };
 use crate::shared::{
     memory::{MemoryManager, MEMORY_MANAGER},
-    windows::{unload_self_dll, WI_CONSOLE, WI_DETACH, WI_MODIFIERS, WI_REMAP},
+    sync::event_listener,
+    windows::{WI_CONSOLE, WI_DETACH, WI_MODIFIERS},
 };
 
 lazy_static! {
     static ref KEYBOARD_MODIFIERS: Mutex<(bool, bool, bool)> = Mutex::new((false, false, false));
     static ref LAST_CHAR: Mutex<i32> = Mutex::new(0);
 }
 
-pub unsafe extern "system" fn start_thread(lparam: *mut c_void) -> u32 {
-    open_client_console();
-    hook_wndproc(lparam as u64);
-    hook_wgl_swap_buffers();
-    0
-}
-
 pub unsafe fn open_client_console() {
     let hwnd = GetConsoleWindow();
     if hwnd.0 != null_mut() {
@@ -149,15 +143,6 @@ unsafe extern "system" fn hooked_wndproc(
             open_client_console();
             return LRESULT(0);
         }
-        WI_REMAP => {
-            println!("Restarting map.\r\n");
-            let mut mem_manager = MEMORY_MANAGER.lock().unwrap();
-            if mem_manager.is_mapped() {
-                mem_manager.close_map();
-            }
-            *mem_manager = MemoryManager::open_map();
-            return LRESULT(0);
-        }
         WI_MODIFIERS => {
             let mut modifiers = KEYBOARD_MODIFIERS.lock().unwrap();
             let (shift, ctrl, alt) = &mut *modifiers;
@@ -194,15 +179,9 @@ unsafe extern "system" fn hooked_wndproc(
             return LRESULT(0);
         }
         WI_DETACH => {
-            let mut mem_manager = MEMORY_MANAGER.lock().unwrap();
-            unsafe {
-                unhook_wgl_swap_buffers();
-                if mem_manager.is_mapped() {
-                    mem_manager.close_map();
-                }
-                unhook_wndproc();
-            };
-            //unload_self_dll();
+            unhook_wgl_swap_buffers();
+            unhook_wndproc();
+
             return LRESULT(0);
         }
         WM_KEYDOWN => {
@@ -245,7 +224,11 @@ unsafe extern "system" fn hooked_wndproc(
             let x = (lparam.0 & 0xFFFF) as u16 as i32;
             let y = ((lparam.0 >> 16) & 0xFFFF) as u16 as i32;
 
-            let mem_manager = MEMORY_MANAGER.lock().unwrap();
+            let mem_manager = MEMORY_MANAGER
+                .get()
+                .expect("[WaspInput]: Memory manager is not initialized!\r\n")
+                .lock()
+                .unwrap();
             mem_manager.set_mouse_position(x, y);
 
             WM_MOUSEMOVE
@@ -273,9 +256,11 @@ unsafe fn hook_wndproc(hwnd: u64) {
         .enable()
         .expect("[WaspInput]: Failed to enable WndProc hook.\r\n");
 
-    ORIGINAL_WNDPROC
-        .set(detour)
-        .expect("[WaspInput]: Failed to save original WndProc function.\r\n");
+    if ORIGINAL_WNDPROC.get().is_none() {
+        ORIGINAL_WNDPROC
+            .set(detour)
+            .expect("[WaspInput]: Failed to save original WndProc function.\r\n");
+    }
 
     println!("[WaspInput]: WndProc successfully hooked.\r\n");
 }
@@ -297,7 +282,11 @@ static ORIGINAL_WGL_SWAPBUFFERS: OnceLock<GenericDetour<unsafe extern "system" f
     OnceLock::new();
 
 unsafe extern "system" fn hooked_wgl_swap_buffers(hdc: HDC) -> BOOL {
-    let mem_manager = MEMORY_MANAGER.lock().unwrap();
+    let mem_manager = MEMORY_MANAGER
+        .get()
+        .expect("[WaspInput]: Memory manager is not initialized!\r\n")
+        .lock()
+        .unwrap();
     let mut viewport = [0, 0, 0, 0];
     let mouse = mem_manager.get_mouse_position();
 
@@ -350,10 +339,19 @@ unsafe fn hook_wgl_swap_buffers() {
     ORIGINAL_WGL_SWAPBUFFERS
         .set(detour)
         .expect("[WaspInput]: Failed to save original wglSwapBuffers function.\r\n");
+
     println!("[WaspInput]: wglSwapBuffers successfully hooked.\r\n");
 }
 
 pub unsafe fn unhook_wgl_swap_buffers() {
+    let mem_manager = MEMORY_MANAGER
+        .get()
+        .expect("[WaspInput]: Memory manager is not initialized!\r\n")
+        .lock()
+        .unwrap();
+
+    mem_manager.clear_overlay();
+
     let detour = ORIGINAL_WGL_SWAPBUFFERS
         .get()
         .expect("[WaspInput]: wglSwapBuffers hook not found\r\n");
@@ -364,3 +362,31 @@ pub unsafe fn unhook_wgl_swap_buffers() {
 
     println!("[WaspInput]: wglSwapBuffers successfully unhooked.\r\n");
 }
+
+//enable...
+pub unsafe fn reenable_hooks() {
+    let wgl_swapbuffers_detour = ORIGINAL_WGL_SWAPBUFFERS
+        .get()
+        .expect("[WaspInput]: wglSwapBuffers hook not found\r\n");
+
+    wgl_swapbuffers_detour
+        .enable()
+        .expect("[WaspInput]: Failed to enable wglSwapBuffers hook.\r\n");
+
+    let wndproc_detour = ORIGINAL_WNDPROC
+        .get()
+        .expect("[WaspInput]: WndProc hook not found\r\n");
+
+    wndproc_detour
+        .enable()
+        .expect("[WaspInput]: Failed to enable WndProc hook.\r\n");
+}
+pub unsafe extern "system" fn start(lparam: *mut c_void) -> u32 {
+    let _ = MEMORY_MANAGER.set(Mutex::new(MemoryManager::create_map()));
+
+    hook_wndproc(lparam as u64);
+    hook_wgl_swap_buffers();
+
+    event_listener(lparam as u64);
+    0
+}

src/lib.rs

@@ -3,7 +3,7 @@ use std::os::raw::c_char;
 use std::sync::Mutex;
 
 use shared::windows::{get_jagrenderview, inject, is_input_enabled, open_console, toggle_input};
-use simba::target::TARGET;
+use simba::target::{SimbaTarget, TARGETS};
 
 mod client;
 mod shared;
@@ -58,11 +58,17 @@ pub extern "C" fn Inject(path: *const c_char, pid: u32) -> bool {
         }
     };
 
-    let mut target = TARGET.lock().unwrap();
-    target.pid = pid;
-    target.hwnd = hwnd;
+    let new_target = SimbaTarget {
+        pid,
+        hwnd,
+        keyboard: [false; 255],
+        mouse: [false; 3],
+    };
+
+    let mut targets = TARGETS.lock().unwrap();
+    targets.insert(pid, new_target);
 
-    unsafe { inject(module_path, pid, hwnd) }
+    unsafe { inject(module_path, pid) }
 }
 
 #[no_mangle]

src/shared/main.rs

@@ -0,0 +1,104 @@
+use std::{ffi::c_void, ptr::null_mut, sync::OnceLock};
+
+use windows::{
+    core::BOOL,
+    Win32::{
+        Foundation::{FALSE, HINSTANCE, HMODULE, HWND, LPARAM, TRUE, WPARAM},
+        System::{
+            LibraryLoader::{DisableThreadLibraryCalls, GetModuleFileNameW},
+            Threading::{CreateThread, GetCurrentProcessId, THREAD_CREATION_FLAGS},
+        },
+        UI::WindowsAndMessaging::PostMessageW,
+    },
+};
+
+use crate::{
+    client::hooks::start,
+    shared::{memory::MEMORY_MANAGER, sync::close_event},
+    simba::target::TARGETS,
+};
+
+use super::windows::{get_jagrenderview, WI_DETACH};
+
+pub static mut MODULE: HMODULE = HMODULE(null_mut());
+
+fn client_main(hinst_dll: HINSTANCE, hwnd: HWND, reason: u32) -> BOOL {
+    match reason {
+        1 => unsafe {
+            let _ = DisableThreadLibraryCalls(hinst_dll.into());
+
+            let mut buffer = [0u16; 260]; // MAX_PATH
+            let len = GetModuleFileNameW(Some(MODULE), &mut buffer);
+
+            if len > 0 {
+                let path = String::from_utf16_lossy(&buffer[..len as usize]);
+                let _ = DLL_NAME.set(path);
+            }
+
+            let _ = CreateThread(
+                Some(null_mut()),
+                0,
+                Some(start),
+                Some(hwnd.0 as *mut c_void),
+                THREAD_CREATION_FLAGS(0),
+                Some(null_mut()),
+            );
+            return TRUE;
+        },
+        0 => {
+            let mut mem_manager = MEMORY_MANAGER
+                .get()
+                .expect("[WaspInput]: Memory manager is not initialized!\r\n")
+                .lock()
+                .unwrap();
+
+            unsafe { mem_manager.close_map() };
+
+            close_event(hwnd.0 as u64);
+            println!("[WaspInput]: Detached.\r\n");
+            TRUE
+        }
+        _ => FALSE,
+    }
+}
+
+pub static DLL_NAME: OnceLock<String> = OnceLock::new();
+
+fn simba_main(hinst_dll: HINSTANCE, reason: u32) -> BOOL {
+    match reason {
+        1 => {
+            let _ = unsafe { DisableThreadLibraryCalls(hinst_dll.into()) };
+            TRUE
+        }
+        0 => {
+            let targets = TARGETS.lock().unwrap();
+            for target in targets.values() {
+                let hwnd = HWND(target.hwnd as *mut c_void);
+                let _ = unsafe { PostMessageW(Some(hwnd), WI_DETACH, WPARAM(0), LPARAM(0)) };
+            }
+
+            TRUE
+        }
+        _ => FALSE,
+    }
+}
+
+#[no_mangle]
+pub extern "system" fn DllMain(
+    hinst_dll: HINSTANCE,
+    fdw_reason: u32,
+    _lpv_reserved: *mut c_void,
+) -> BOOL {
+    unsafe { MODULE = HMODULE(hinst_dll.0) };
+
+    let pid = unsafe { GetCurrentProcessId() };
+    match get_jagrenderview(pid) {
+        Some(hwnd) => client_main(hinst_dll, hwnd, fdw_reason),
+        None => simba_main(hinst_dll, fdw_reason),
+    }
+}
+
+/* pub fn unload_dll() {
+    let _ = unsafe { FreeLibrary(MODULE) };
+}
+ */