https://github.com/etra0/memory-rs

A little library to make memory injections more easy.
https://github.com/etra0/memory-rs

Last synced: about 1 month ago
JSON representation

A little library to make memory injections more easy.

• Host: GitHub
• URL: https://github.com/etra0/memory-rs
• Owner: etra0
• License: mit
• Created: 2020-04-20T04:49:14.000Z (almost 5 years ago)
• Default Branch: master
• Last Pushed: 2023-03-24T16:15:41.000Z (almost 2 years ago)
• Last Synced: 2024-10-18T01:01:20.680Z (4 months ago)
• Language: Rust
• Homepage:
• Size: 144 KB
• Stars: 43
• Watchers: 4
• Forks: 3
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# memory-rs

**This is a work in progress.**

A library written to facilitate game modding with Rust.

This library has the basics for making code injections, aobscan and code

patching.

# Usage

The example is a little bit extensive but hopefully makes it clear on how

to use it.

```rust

use memory_rs::generate_aob_pattern;

use memory_rs::internal::process_info::ProcessInfo;

use memory_rs::internal::injections::*;

memory_rs::scoped_no_mangle! {

    // In reality, this `my_function_in_assembly` should be an extern to  an

    // asm label which exposes the start of a shellcode, that you'd inject in

    // the future.

    my_function_in_assembly: u8 =  0x0;

    my_function_in_assembly_jmp_back_addr: usize = 0x0;

}

// function wrapper to be called by DllMain

pub unsafe extern "system" fn wrapper(lib: *mut std::ffi::c_void) -> u32 {

  // ...

  match patch() {

    Ok(_) => println!("Everything is OK"),

    Err(e) => println!("Error: {}", e),

  };

  0

}

fn patch() -> Result<(), Box> {

    // Get some basic information of the process (like base address and binary

    // size)

    let proc_inf = ProcessInfo::new(Some("RDR2.exe"))?;

    let mut enable_hots_addr = {

        // Scan for a pattern on the game's memory to get the address of

        // where you want to do some injections

        let memory_pattern = generate_aob_pattern![

            0xFF, 0x90, _, 0x01, 0x00, 0x00, 0x84, 0xC0, 0x74, 0x05, 0x4D,

            0x85, 0xE4

        ];

        let region = &proc_inf.region;

        region.scan_aob(&memory_pattern)?

            .ok_or("Couldn't find enable_hots_addr")? - 0xA

    };

    // We use Detour since it's scope sensitive (if it fails it will deinject

    // automatically

    let mut enable_hots_det = unsafe { Detour::new(

        enable_hots_addr,

        16,

        &my_function_in_assembly as *const u8 as usize,

        Some(&mut my_function_in_assembly_jmp_back_addr))

    };

    enable_hots_det.inject();

    let black_bars_addr = {

        let memory_pattern = generate_aob_pattern![

            0x0F, 0x86, _, _, 0xAA, 0xBB

        ];

        let region = &proc_inf.region;

        region.scan_aob(&memory_pattern)?

            .ok_or("Couldn't find black_bars_addr")?

    };

    // nop 5 bytes, when Injection goes out of scope, it will reinject

    // the original bytes.

    let mut remove_black_bars = Injection::new(black_bars_addr, vec![0x90; 5]);

    remove_black_bars.inject();

    loop {}

}

// This will generate the DllMain required to create a DLL in Windows.

memory_rs::main_dll!(wrapper);

```