use crate::error::{Error, Result};
use crate::{ImportKind, Symbol};
use core::ffi::c_void;
use std::sync::OnceLock;
use windows_sys::Win32::Foundation::{HANDLE, HMODULE};
use windows_sys::Win32::System::LibraryLoader::{
GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
GetModuleFileNameW, GetModuleHandleExW, GetModuleHandleW, GetProcAddress, LoadLibraryW,
};
use windows_sys::Win32::System::Memory::{
MEM_COMMIT, MEM_IMAGE, MEMORY_BASIC_INFORMATION, PAGE_READWRITE, VirtualProtect, VirtualQuery,
};
use windows_sys::Win32::System::ProcessStatus::{
EnumProcessModules, GetModuleInformation, MODULEINFO,
};
use windows_sys::Win32::System::SystemInformation::{GetSystemInfo, SYSTEM_INFO};
fn current_process() -> HANDLE {
usize::MAX as HANDLE
}
fn last_error() -> u32 {
unsafe { windows_sys::Win32::Foundation::GetLastError() }
}
fn wide(s: &str) -> Vec<u16> {
s.encode_utf16().chain(core::iter::once(0)).collect()
}
pub(crate) fn page_size() -> usize {
static PAGE_SIZE: OnceLock<usize> = OnceLock::new();
*PAGE_SIZE.get_or_init(|| {
let mut info: SYSTEM_INFO = unsafe { core::mem::zeroed() };
unsafe { GetSystemInfo(&raw mut info) };
let size = info.dwPageSize as usize;
if size == 0 { 0x1000 } else { size }
})
}
pub(crate) fn module_from_address(address: *const c_void) -> Result<usize> {
let mut handle: HMODULE = core::ptr::null_mut();
let ok = unsafe {
GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
address.cast::<u16>(),
&raw mut handle,
)
};
if ok == 0 || handle.is_null() {
return Err(Error::ModuleNotFound {
reason: "address",
os_error: last_error(),
});
}
Ok(handle as usize)
}
pub(crate) fn module_from_name(name: &str) -> Result<usize> {
let wide = wide(name);
let handle = unsafe { GetModuleHandleW(wide.as_ptr()) };
if handle.is_null() {
return Err(Error::ModuleNotFound {
reason: "name",
os_error: last_error(),
});
}
Ok(handle as usize)
}
pub(crate) fn module_still_loaded(base: usize) -> bool {
let mut handle: HMODULE = core::ptr::null_mut();
let ok = unsafe {
GetModuleHandleExW(
GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT | GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
base as *const u16,
&raw mut handle,
)
};
ok != 0 && handle as usize == base
}
pub(crate) fn image_size(base: usize) -> Result<usize> {
let mut info = MODULEINFO::default();
let ok = unsafe {
GetModuleInformation(
current_process(),
base as HMODULE,
&raw mut info,
u32::try_from(core::mem::size_of::<MODULEINFO>()).unwrap_or(u32::MAX),
)
};
if ok == 0 || info.SizeOfImage == 0 {
return Err(Error::ImageSizeUnknown {
base,
os_error: last_error(),
});
}
Ok(info.SizeOfImage as usize)
}
pub(crate) fn module_path(base: usize) -> String {
let mut buf = vec![0u16; 260];
loop {
let capacity = u32::try_from(buf.len()).unwrap_or(u32::MAX);
let len =
unsafe { GetModuleFileNameW(base as HMODULE, buf.as_mut_ptr(), capacity) as usize };
if len == 0 {
return String::new();
}
if len < buf.len() {
return String::from_utf16_lossy(buf.get(..len).unwrap_or(&buf));
}
if buf.len() >= 1 << 16 {
return String::from_utf16_lossy(&buf);
}
buf.resize(buf.len() * 2, 0);
}
}
pub(crate) fn enumerate_modules() -> Result<Vec<usize>> {
let process = current_process();
let mut needed: u32 = 0;
let ok = unsafe { EnumProcessModules(process, core::ptr::null_mut(), 0, &raw mut needed) };
if ok == 0 {
return Err(Error::ModuleNotFound {
reason: "process module list",
os_error: last_error(),
});
}
let count = needed as usize / core::mem::size_of::<HMODULE>();
let mut modules: Vec<HMODULE> = vec![core::ptr::null_mut(); count.max(1)];
let byte_len =
u32::try_from(modules.len() * core::mem::size_of::<HMODULE>()).unwrap_or(u32::MAX);
let ok =
unsafe { EnumProcessModules(process, modules.as_mut_ptr(), byte_len, &raw mut needed) };
if ok == 0 {
return Err(Error::ModuleNotFound {
reason: "process module list",
os_error: last_error(),
});
}
let returned = (needed as usize / core::mem::size_of::<HMODULE>()).min(modules.len());
Ok(modules
.into_iter()
.take(returned)
.map(|m| m as usize)
.collect())
}
fn proc_address(module: HMODULE, symbol: &Symbol) -> Option<usize> {
let proc = match symbol {
Symbol::Name(name) => {
let mut c_name: Vec<u8> = name.as_bytes().to_vec();
c_name.push(0);
unsafe { GetProcAddress(module, c_name.as_ptr()) }
}
Symbol::Ordinal(ordinal) => {
let by_ordinal = *ordinal as usize as *const u8;
unsafe { GetProcAddress(module, by_ordinal) }
}
};
proc.map(|f| f as usize)
}
pub(crate) fn resolve_export(library: &str, symbol: &Symbol) -> Option<usize> {
let wide = wide(library);
let module = unsafe { GetModuleHandleW(wide.as_ptr()) };
if module.is_null() {
return None;
}
proc_address(module, symbol)
}
pub(crate) fn resolve_delay_export(library: &str, symbol: &Symbol) -> Option<usize> {
let wide = wide(library);
let mut module = unsafe { GetModuleHandleW(wide.as_ptr()) };
if module.is_null() {
module = unsafe { LoadLibraryW(wide.as_ptr()) };
}
if module.is_null() {
return None;
}
proc_address(module, symbol)
}
pub(crate) fn resolve_original(
kind: ImportKind,
library: &str,
symbol: &Symbol,
slot_value: usize,
) -> Option<usize> {
match kind {
ImportKind::Standard => Some(resolve_export(library, symbol).unwrap_or(slot_value)),
ImportKind::DelayLoad => resolve_delay_export(library, symbol),
}
}
pub(crate) unsafe fn make_writable(page: usize) -> Result<u32> {
let mut old: u32 = 0;
let ok = unsafe {
VirtualProtect(
page as *const c_void,
page_size(),
PAGE_READWRITE,
&raw mut old,
)
};
if ok == 0 {
return Err(Error::Protect {
slot: page,
os_error: last_error(),
});
}
Ok(old)
}
pub(crate) unsafe fn restore_protection(page: usize, protection: u32) -> Result<()> {
let mut old: u32 = 0;
let ok =
unsafe { VirtualProtect(page as *const c_void, page_size(), protection, &raw mut old) };
if ok == 0 {
return Err(Error::Protect {
slot: page,
os_error: last_error(),
});
}
Ok(())
}
pub(crate) fn query_protection(address: usize) -> u32 {
let mut info = MEMORY_BASIC_INFORMATION::default();
let written = unsafe {
VirtualQuery(
address as *const c_void,
&raw mut info,
core::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
)
};
if written == 0 { 0 } else { info.Protect }
}
pub(crate) fn slot_belongs_to_module(address: usize, module_base: usize) -> bool {
let mut info = MEMORY_BASIC_INFORMATION::default();
let written = unsafe {
VirtualQuery(
address as *const c_void,
&raw mut info,
core::mem::size_of::<MEMORY_BASIC_INFORMATION>(),
)
};
written != 0
&& info.State == MEM_COMMIT
&& info.Type == MEM_IMAGE
&& info.AllocationBase as usize == module_base
}