Guide [Source] MemWar — Windows Memory Hacking Library in Rust

[byte_corvus]

Tired of the usual C++ boilerplate for every memory project? Rust is moving into the scene fast, and it's not just for safe web apps anymore. MemWar is a specialized library designed specifically for memory-related tasks on Windows, making it a solid foundation for anyone building external tools.

MemWar handles the tedious parts of memory manipulation — finding processes, grabbing module bases, and following long pointer chains — without the headache of manual WinAPI calls every five seconds. If you're dealing with IL2CPP games where you're constantly digging through GameAssembly.dll, this crate is worth a look.

You cant view this link please login.

Core Features:

1. Process enumeration by name and PID.
2. Process handle management (standard OpenProcess).
3. Module base address retrieval (crucial for Unity/IL2CPP games).
4. Pointer chain dereferencing logic (deref_chain).
5. Standard reading of primitives (read_f32, etc.).

Example Implementation:

use anyhow::{Result, bail, anyhow};

fn sandbox() -> Result<()> {
    let wpinf = match process::get_process_by_name("Game.exe")
        .map_err(|e| anyhow!("Failed to find Game.exe! Last OS error: {e}"))?
    {
        Some((wpinf, _)) => wpinf,
        None => bail!(
            "Failed to get window information! Last OS error: {}",
            GetLastError()
        ),
    };

    let h_process = process::open_process_handle(wpinf.pid())
        .map_err(|e| anyhow!("Failed to open handle to Game.exe! Last OS error: {e}"))?;

    let base_addr = module::get_mod_base(wpinf.pid(), "GameAssembly.dll");

    if base_addr.is_null() {
        bail!("Failed to get GameAssembly.dll base address!")
    }

    let alloc = Allocation::existing(h_process, base_addr);
    let player_speed_addr = alloc
        .deref_chain(offsets::LOCAL_PLAYER, offsets::PLAYER_SPEED)
        .map_err(|e| anyhow!("Failed to dereference pointer chain! Last OS error: {e}"))?;

    let player_speed = alloc
        .read_f32(player_speed_addr)
        .map_err(|e| anyhow!("Failed to read from Game.exe! Last OS error: {e}"))?;

    Ok(())
}

Spoiler: Technical Notes

This library uses standard Windows handles. If you are targeting games protected by EAC or BattlEye, you will need to swap the handle opening logic for a kernel driver or a hijacked handle method. As a base for external projects on unprotected or lowly protected games, it's very clean.

It's a decent alternative to the usual memory crates if you want something leaner. The repository can be found on GitHub by searching for the MemWar crate.

Anyone using this with a custom driver or handle hijacker yet?