jascha-n / minhook-rs Goto Github PK

static_hooks! {
    // Hook for user32::MessageBoxA.
    pub impl MESSAGE_BOX_A for user32::MessageBoxA: unsafe extern "system" fn(winapi::HWND, winapi::LPCSTR, winapi::LPCSTR, winapi::UINT) -> winapi::c_int;
    // Hook for user32::DialogBoxParamW.
    pub impl DIALOG_BOX_PARAM_W for user32::DialogBoxParamW: unsafe extern "system" fn(winapi::HINSTANCE, winapi::LPCWSTR, winapi::HWND, winapi::DLGPROC, winapi::LPARAM) -> winapi::INT_PTR;
}

fn attach(hinstance: winapi::HINSTANCE) -> Result<()> {
    // Disable thread attach/detach calls.
    if unsafe { kernel32::DisableThreadLibraryCalls(hinstance) } == winapi::FALSE {
        bail!(Error::with_chain(io::Error::last_os_error(),
                                ErrorKind::DisableThreadLibraryCalls));
    }

    // Init hooks.
    unsafe {
        MESSAGE_BOX_A
            .initialize(|wnd, text, _caption, flags| {
                            debug!("MESSAGE_BOX_A");
                            println!("MESSAGE_BOX_A");
                            let caption = b"Hooked caption a ;).\0";
                            MESSAGE_BOX_A.call_real(wnd, text, caption.as_ptr() as winapi::LPCSTR, flags)
                        })?
    };
    unsafe {
        DIALOG_BOX_PARAM_W
            .initialize(|instance, template_name, parent, dialog_func, init_param| {
                            debug!("DIALOG_BOX_PARAM_W");
                            message_box("DIALOG_BOX_PARAM_W", "DIALOG_BOX_PARAM_W.").unwrap();
                            println!("DIALOG_BOX_PARAM_W");
                            DIALOG_BOX_PARAM_W.call_real(instance, template_name, parent, dialog_func, init_param)
                        })?
    };
    debug!("Hooks initialized.");

    // Enable hooks.
    MESSAGE_BOX_A.enable()?;
    DIALOG_BOX_PARAM_W.enable()?;
    debug!("Hooks enabled.");

    // This call hook works.
    {
        let caption = b"Caption.\0";
        let text = b"Text.\0";
        unsafe {
            user32::MessageBoxA(0 as winapi::HWND,
                                text.as_ptr() as winapi::LPCSTR,
                                caption.as_ptr() as winapi::LPCSTR,
                                0)
        };
    }

    message_box("Attach", "Template module attached.")?;
    debug!("Template module attached.");
    Ok(())
}

// send/recv.
unsafe {
    hook::Send
        .initialize(|socket, buffer, length, flags| {
            let buffer = slice::from_raw_parts_mut(buffer as *mut u8, length as usize);
            let mut cursor = Cursor::new(buffer);
            while cursor.position() < length as u64 {
                trace_packet(protocol::Direction::Send, &mut cursor);
            }
            hook::Send.call_real(socket, buffer, length, flags)
        })?
};
unsafe {
    hook::Recv
        .initialize(|socket, buffer, length, flags| {
            let address = buffer;
            let buffer = slice::from_raw_parts_mut(buffer as *mut u8, 7);
            debug!("{} (buffer: {:?}, address: {:#?}, length: {}, flags: {})",
                   protocol::Direction::Receive,
                   buffer,
                   address as *const _,
                   length as usize,
                   flags);
            hook::Recv.call_real(socket, buffer, length, flags)
        })?
};

static_hooks! {
    // ws2_32.dll
    // Hook for ws2_32::send.
    pub impl Send for "send" in "ws2_32.dll": unsafe extern "system" fn(winapi::SOCKET, *const winapi::c_char, winapi::c_int, winapi::c_int) -> winapi::c_int;
    // Hook for ws2_32::recv.
    pub impl Recv for "recv" in "ws2_32.dll": unsafe extern "system" fn(winapi::SOCKET, *mut winapi::c_char, winapi::c_int, winapi::c_int) -> winapi::c_int;
...
}