hook_king

A low-level automated hooking library providing detours, trampolines, and memory management capabilities. Supports both internal and external process hooking with optional original code preservation.

Features

• Function Hooking: Intercept function calls with detours

• Trampolines: Preserve original function functionality

• Memory Management: Safe memory operations for hooking

• Cross-Process Support: Hook both internal and external processes

• Original Code Preservation: Optional preservation of overwritten instructions

• x86/x64 Support: Works with both 32-bit and 64-bit architectures

  Warning

  Not giving a name or providing an invalid address will result in panicing

  Give the hook a proper name. Name must be no less than 3 characters!

  Example

  use hook_king::*;
  use winapi::um::libloaderapi::GetModuleHandleA;
  
  fn internal_detour() {
   let module_base = unsafe { GetModuleHandleA(std::ptr::null()) } as usize;
   let mut hook_king = HookKing::default();
   let hook_info = HookInfo::new(
     "health",
     module_base + 0x12321,
     HookType::Detour,
     assemble!(
       push rax;
       mov rax,rcx;
       mov byte ptr [rax+50],2;
       mov word ptr [rax+50*4],2;
       mov dword ptr [rax+rax*8+50],2;
       mov qword ptr [rax],2;
       // label:
       mov rsp,rsi;
       mov r12d,4;
       mov r12w,4;
       mov r12b,4;
       mov r12b,4;
       // jmp label;
       movups xmm1,xmm0;
       sub rsp,100;
       call rax;
       call module_base as u64;
       xor al,bl;
       xorps xmm0,xmm10;
       add rsp,100;
       pop rax;
       call module_base as u64 + 0x428C16;
       jmp module_base as u64 + 0x428AAC;
       ret;
       ret;
       ret_1 1;
       mpsadbw xmm0, xmm1, 2;
       vsqrtps ymm10, dword ptr [rcx];
       // label_return:
       ret;
     )
   );
   unsafe { hook_king.hook(hook_info).unwrap() };
  }
  

  Example

  use hook_king::*;
  use winapi::um::libloaderapi::GetModuleHandleA;
  use std::{sync::{Arc, RwLock}, time::Duration, thread::sleep, ptr::null_mut};
  
  fn my_hooks() {
     let hook_king = Arc::new(RwLock::new(HookKing::new(None)));
     let hook_king_c = Arc::clone(&hook_king);
  
     let handle = std::thread::spawn(move || {
       let module_base = unsafe { GetModuleHandleA(null_mut()) } as usize;
       let hook_info = HookInfo::new(
         "Something",
         module_base,
         HookType::Detour,
         assemble!(
           push rax;
           pop rax;
         ),
       );
  
       unsafe { hook_king_c.write().unwrap().hook(hook_info).unwrap() };
  
       let hook_info = HookInfo::new(
         "Something_2",
         module_base + 0x589E50,
         HookType::Detour,
         assemble!(
           mov rax,rcx;
         ),
       );
  
       unsafe { hook_king_c.write().unwrap().hook(hook_info).unwrap() };
  
       let hook_info = HookInfo::new(
         "Something_3",
         module_base + 0x589220,
         HookType::Patch,
         assemble!(
           mov rax,rbx;
         ),
       );
  
       unsafe { hook_king_c.write().unwrap().hook(hook_info).unwrap() };
  
       let hook_info = HookInfo::new(
         "Something_4",
         module_base + 0x124F15,
         HookType::DetourNoOrg,
         assemble!(
           mov r9,r12;
           xor r11,r11;
           add rax,20;
         ),
       );
  
       unsafe { hook_king_c.write().unwrap().hook(hook_info).unwrap() };
  
       hook_king_c
     });
  
     let hook_king_r = handle.join().unwrap();
  
     sleep(Duration::from_secs(10));
  
     let hook = hook_king_r.read().unwrap().get_hook(HookLookup::Name("Something_4".to_string()));
  
     if hook.is_some() {
       println!("Found the hook");
       let mut hook = hook.unwrap();
       sleep(Duration::from_secs(10));
       hook.disable(&hook_king.read().unwrap());
       sleep(Duration::from_secs(10));
       hook.enable(&hook_king.read().unwrap());
     }
   }