Struct HookHandle 

pub struct HookHandle { /* private fields */ }

Implementations

impl HookHandle

pub fn target_ptr(&self) -> *mut c_void

pub fn detour_ptr(&self) -> *mut c_void

pub fn original_ptr(&self) -> *mut c_void

pub unsafe fn original<T: Copy>(&self) -> T

pub unsafe fn unhook(self) -> Result<()>

Examples found in repository

examples/macros.rs (line 23)

fn main() -> dobby_rs_framework::Result<()> {
    common::init_example_logging();

    // EN: `dobby_hook!` installs a hook using function items.
    // CN: `dobby_hook!` 直接用函数名安装 hook。
    let h = dobby_rs_framework::dobby_hook!(common::target_add, detour_add)?;

    println!("target_add(1) after dobby_hook = {}", common::target_add(1));

    unsafe { h.unhook()? };
    Ok(())
}

examples/symbols_aliases.rs (line 49)

    pub fn run() -> dobby_rs_framework::Result<()> {
        let sym = CString::new("puts").unwrap();
        let img = CString::new(common::LIBC_IMAGE).unwrap();

        // EN: Resolve address and register an alias.
        // CN: 解析地址并注册 alias。
        let addr = resolve_and_register_alias("libc_puts", None, sym.as_c_str())?;
        println!("resolved puts addr = {addr:p}");

        // EN: Resolve with explicit image.
        // CN: 指定 image 名解析。
        let _ = resolve_and_register_alias_in("libc_puts_in", img.as_c_str(), sym.as_c_str())?;
        register_alias_with_symbol_in("libc_puts_meta_in", img.as_c_str(), sym.as_c_str(), addr)?;

        // EN: Hook by symbol (default image search).
        // CN: 按 symbol 安装 hook（默认 image 搜索）。
        let h1 = unsafe {
            hook_symbol_default(
                sym.as_c_str(),
                common::detours::unix::detour_puts as *const () as *mut c_void,
                Some("puts"),
            )?
        };
        unsafe { h1.unhook()? };

        // EN: Fully generic form.
        // CN: 完整通用形式。
        let h2 = unsafe {
            hook_symbol(
                None,
                sym.as_c_str(),
                common::detours::unix::detour_puts as *const () as *mut c_void,
                Some("puts2"),
            )?
        };
        unsafe { h2.unhook()? };

        Ok(())
    }
}

// EN: --- Windows demo: hook a simple kernel32 API by symbol.
// CN: --- Windows 演示：按 symbol hook kernel32 的简单 API。
#[cfg(windows)]
mod windows_demo {
    use super::*;

    pub fn run() -> dobby_rs_framework::Result<()> {
        let image = CString::new("kernel32.dll").unwrap();
        let sym = CString::new("GetTickCount").unwrap();

        let _ = resolve_and_register_alias_in("k32_get_tick", image.as_c_str(), sym.as_c_str())?;
        let h = unsafe {
            hook_symbol_in(
                image.as_c_str(),
                sym.as_c_str(),
                common::detours::windows::detour_get_tick_count as *const () as *mut c_void,
                Some("GetTickCount"),
            )?
        };
        unsafe { h.unhook()? };
        Ok(())
    }
}

fn main() -> dobby_rs_framework::Result<()> {
    common::init_example_logging();

    // EN: Alias registry is just a map: alias -> address (+optional metadata).
    // CN: alias 注册表本质就是：alias -> 地址（以及可选的元信息）。
    let add_addr = common::target_add as *const () as *mut c_void;
    register_alias("demo_add", add_addr)?;
    println!("alias demo_add addr = {:p}", get_alias("demo_add").unwrap());

    // EN: Hook by alias.
    // CN: 按 alias 安装 hook。
    let h = unsafe { hook_alias("demo_add", detour_add as *const () as *mut c_void)? };
    println!("target_add(1) after hook_alias = {}", common::target_add(1));
    unsafe { h.unhook()? };

    // EN/CN: Optional: store richer alias metadata.
    let fake_sym = CString::new("target_add").unwrap();
    register_alias_with_symbol("demo_add_meta", None, fake_sym.as_c_str(), add_addr)?;

    #[cfg(unix)]
    unix_demo::run()?;
    #[cfg(windows)]
    windows_demo::run()?;

    Ok(())
}

examples/install_replace.rs (line 75)

fn main() -> dobby_rs_framework::Result<()> {
    common::init_example_logging();

    // EN: 1) `install` -> typed handle.
    // CN: 1) `install` -> 返回带类型的句柄。
    let h1 = unsafe {
        install(
            common::target_mul as fn(i32) -> i32,
            detour_mul as fn(i32) -> i32,
        )?
    };
    println!("target_mul(3) after install = {}", common::target_mul(3));
    unsafe { h1.unhook()? };

    // EN: 2) `install_addr` -> raw pointer variant.
    // CN: 2) `install_addr` -> 按地址安装（裸指针版本）。
    let h1_addr = unsafe {
        install_addr(
            common::target_mul as *const () as *mut c_void,
            detour_mul as *const () as *mut c_void,
        )?
    };
    println!(
        "target_mul(3) after install_addr = {}",
        common::target_mul(3)
    );
    unsafe { h1_addr.unhook()? };

    // EN: 3) `replace` -> temporary swap, with easy access to original.
    // CN: 3) `replace` -> 临时替换，并且可以拿到 original。
    let r = unsafe {
        replace(
            common::target_sub as fn(i32) -> i32,
            replacement_sub as fn(i32) -> i32,
        )?
    };
    println!("target_sub(10) after replace = {}", common::target_sub(10));
    println!("original target_sub(10) = {}", (r.original())(10));
    unsafe { r.unreplace()? };

    // EN: 4) `install_with` -> before/after callbacks (invoked by detour).
    // CN: 4) `install_with` -> before/after 回调（由 detour 调用）。
    let h2 = unsafe {
        install_with(
            target_with_callbacks as fn(i32) -> i32,
            detour_with_callbacks as fn(i32) -> i32,
            Some(|| log::info!("before (install_with)")),
            Some(|| log::info!("after (install_with)")),
        )?
    };
    println!(
        "target_with_callbacks(1) after install_with = {}",
        target_with_callbacks(1)
    );
    unsafe { h2.unhook()? };

    Ok(())
}