uniject 0.3.0

Inject and invoke .NET assemblies in Mono-embedded Windows processes
Documentation
use std::collections::HashMap;
use std::mem::size_of;
use std::num::NonZeroUsize;
use std::os::windows::io::{AsHandle, AsRawHandle, BorrowedHandle};

use windows_sys::Win32::Foundation::HANDLE;
use windows_sys::Win32::System::Diagnostics::Debug::{ReadProcessMemory, WriteProcessMemory};
use windows_sys::Win32::System::Memory::{
    MEM_COMMIT, MEM_RELEASE, MEM_RESERVE, PAGE_EXECUTE_READWRITE, VirtualAllocEx, VirtualFreeEx,
};

use crate::error::{Error, Result};

#[inline]
pub(crate) fn checked_add(address: NonZeroUsize, offset: usize) -> Result<NonZeroUsize> {
    address.checked_add(offset).ok_or(Error::AddressOverflow)
}

#[inline]
pub(crate) fn checked_mul(value: usize, multiplier: usize) -> Result<usize> {
    value.checked_mul(multiplier).ok_or(Error::ArithmeticOverflow)
}

pub(crate) struct Memory<H: AsHandle> {
    handle: H,
    allocations: HashMap<NonZeroUsize, NonZeroUsize>,
}

impl<H: AsHandle> Memory<H> {
    pub(crate) fn new(process_handle: H) -> Self {
        Memory { handle: process_handle, allocations: HashMap::new() }
    }

    fn raw_handle(&self) -> HANDLE {
        self.handle.as_handle().as_raw_handle() as HANDLE
    }

    pub(crate) fn read_string(&self, address: NonZeroUsize, length: usize) -> Result<String> {
        let Some(length) = NonZeroUsize::new(length) else {
            return Ok(String::new());
        };

        let mut bytes = self.read_bytes(address, length)?;
        if let Some(null_index) = bytes.iter().position(|&byte| byte == 0) {
            bytes.truncate(null_index);
        }

        Ok(String::from_utf8(bytes)?)
    }

    pub(crate) fn read_int(&self, address: NonZeroUsize) -> Result<i32> {
        let mut bytes = [0; size_of::<i32>()];
        self.read_into(address, &mut bytes)?;
        Ok(i32::from_le_bytes(bytes))
    }

    pub(crate) fn read_uint(&self, address: NonZeroUsize) -> Result<u32> {
        let mut bytes = [0; size_of::<u32>()];
        self.read_into(address, &mut bytes)?;
        Ok(u32::from_le_bytes(bytes))
    }

    pub(crate) fn read_pointer(&self, address: NonZeroUsize, is_64_bit: bool) -> Result<usize> {
        if !is_64_bit {
            return Ok(self.read_uint(address)? as usize);
        }

        let mut bytes = [0; size_of::<u64>()];
        self.read_into(address, &mut bytes)?;
        Ok(usize::try_from(u64::from_le_bytes(bytes))?)
    }

    pub(crate) fn read_bytes(&self, address: NonZeroUsize, size: NonZeroUsize) -> Result<Vec<u8>> {
        let mut buffer = vec![0u8; size.get()];
        self.read_into(address, &mut buffer)?;
        Ok(buffer)
    }

    pub(crate) fn read_into(&self, address: NonZeroUsize, buffer: &mut [u8]) -> Result<()> {
        if unsafe {
            ReadProcessMemory(
                self.raw_handle(),
                address.get() as *const std::ffi::c_void,
                buffer.as_mut_ptr() as *mut std::ffi::c_void,
                buffer.len(),
                std::ptr::null_mut(),
            )
        } != 0
        {
            Ok(())
        } else {
            Err(Error::Windows {
                operation: "failed to read process memory",
                source: std::io::Error::last_os_error(),
            })
        }
    }

    pub(crate) fn allocate_and_write(&mut self, data: &[u8]) -> Result<NonZeroUsize> {
        let size = NonZeroUsize::new(data.len()).ok_or(Error::EmptyBuffer)?;
        let addr = self.allocate(size)?;
        self.write(addr, data)?;
        Ok(addr)
    }

    pub(crate) fn allocate(&mut self, size: NonZeroUsize) -> Result<NonZeroUsize> {
        let addr = unsafe {
            VirtualAllocEx(
                self.raw_handle(),
                std::ptr::null(),
                size.get(),
                MEM_COMMIT | MEM_RESERVE,
                PAGE_EXECUTE_READWRITE,
            )
        } as usize;

        let addr = NonZeroUsize::new(addr).ok_or_else(|| Error::Windows {
            operation: "failed to allocate process memory",
            source: std::io::Error::last_os_error(),
        })?;
        self.allocations.insert(addr, size);
        Ok(addr)
    }

    pub(crate) fn write(&self, address: NonZeroUsize, data: &[u8]) -> Result<()> {
        let Some(size) = NonZeroUsize::new(data.len()) else {
            return Ok(());
        };
        if unsafe {
            WriteProcessMemory(
                self.raw_handle(),
                address.get() as *const std::ffi::c_void,
                data.as_ptr() as *const std::ffi::c_void,
                size.get(),
                std::ptr::null_mut(),
            )
        } != 0
        {
            Ok(())
        } else {
            Err(Error::Windows {
                operation: "failed to write process memory",
                source: std::io::Error::last_os_error(),
            })
        }
    }
}

impl<H: AsHandle> AsHandle for Memory<H> {
    fn as_handle(&self) -> BorrowedHandle<'_> {
        self.handle.as_handle()
    }
}

impl<H: AsHandle> Drop for Memory<H> {
    fn drop(&mut self) {
        for &address in self.allocations.keys() {
            unsafe {
                if VirtualFreeEx(
                    self.raw_handle(),
                    address.get() as *mut std::ffi::c_void,
                    0,
                    MEM_RELEASE,
                ) == 0
                {
                    eprintln!(
                        "Failed to free memory at address {address:X}: {}",
                        std::io::Error::last_os_error()
                    )
                }
            }
        }
        self.allocations.clear();
    }
}