walter

Walter is a simple hooking library.

Walter supports both 32 and 64 bit.

View the [examples] on how to hook.

Example hook

[wglswapbuffers] ```rust,ignore mod bindings { windows::include_bindings!(); }

use std::ffi::cvoid; use walter::{ TrampolineHook64, }; use bindings::Windows::Win32::{ System::{ SystemServices::DLLPROCESSATTACH, LibraryLoader::{ GetProcAddress, GetModuleHandleA, }, }, Foundation::{ BOOL, HANDLE, HINSTANCE, }, }; use oncecell::sync::Lazy; use std::sync::Mutex;

static HOOK: Lazy>> = Lazy::new(|| { Mutex::new(None) });

pub extern "stdcall" fn wglswapbuffers(hdc: HANDLE) -> BOOL { let gateway = HOOK .lock() .unwrap() .as_ref() .unwrap() .gateway();

let gateway_call: extern "stdcall" fn (hdc: HANDLE) -> BOOL;
gateway_call = unsafe { std::mem::transmute(gateway) };
gateway_call(hdc);

BOOL::from(true)

}

[no_mangle]

pub extern "stdcall" fn DllMain(module: HINSTANCE, reason: u32, _reserved: *mut cvoid) -> BOOL { match reason { DLLPROCESSATTACH => { let module = unsafe { GetModuleHandleA("opengl32.dll") }; let srcwglswap_buffers = unsafe { GetProcAddress(module, "wglSwapBuffers") }.unwrap();

        let hook = TrampolineHook64::hook(
            src_wgl_swap_buffers as *mut c_void,
            wgl_swap_buffers as *mut c_void,
            20
        ).unwrap();

        *HOOK.lock().unwrap() = Some(hook);
    }
    _ => {}
}

BOOL::from(true)

} ```