Struct Module 

pub struct Module<'a> {
    pub module_name: &'a str,
    pub module_handle: HMODULE,
    pub module_size: u32,
    pub module_base_address: usize,
}

Fields

module_name: &'a str

module_handle: HMODULE

module_size: u32

module_base_address: usize

Implementations

impl<'a> Module<'a>

pub fn from_module_name(module_name: &'a str) -> Option<Self>

Examples found in repository

examples/in_get_localplayer_health.rs (line 27)

fn hack_main_thread() {
    let module = Module::from_module_name("client.dll").unwrap();
    unsafe {
        //let dw_local_player = memory.read_mut::<LocalPlayer>(0xDA244C);
        loop {
            if let Some(i) = LocalPlayer::from_raw(module.read(DW_LOCAL_PLAYER)) {
                println!("health = {:?}", (*i).get_health());
            };
            if toy_arms::detect_keypress(VirtualKeyCode::VK_INSERT) {
                break;
            }
        }
    }
}

examples/in_pattern_scanning.rs (line 21)

fn hack_main_thread() {
    let mut once = false;

    let client = Module::from_module_name("client.dll").unwrap();

    match client.find_pattern(DW_FORCE_ATTACK_PATTERN) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Pattern not found"),
    }

    match client.pattern_scan(
        DW_FORCE_ATTACK_PATTERN,
        2,
        0,
    ) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Offset not found"),
    }

    loop {
        if !once {
            println!("Press INSERT to exit...");
            once = !once;
        }
        // To exit this hack loop when you input INSEERT KEY
        if detect_keypress(VirtualKeyCode::VK_INSERT) {
            break;
        }
    }
}

pub fn read<T>(&self, address: u32) -> *mut T

read fetches the value that given address is holding.

• base_address - the address that is supposed to have the value you want

Examples found in repository

examples/in_get_localplayer_health.rs (line 31)

fn hack_main_thread() {
    let module = Module::from_module_name("client.dll").unwrap();
    unsafe {
        //let dw_local_player = memory.read_mut::<LocalPlayer>(0xDA244C);
        loop {
            if let Some(i) = LocalPlayer::from_raw(module.read(DW_LOCAL_PLAYER)) {
                println!("health = {:?}", (*i).get_health());
            };
            if toy_arms::detect_keypress(VirtualKeyCode::VK_INSERT) {
                break;
            }
        }
    }
}

pub fn read_string(&self, address: i32) -> Result<String, Utf8Error>

read_string reads the string untill the null terminator that is in the given module

• address - relative address of the head of the string.

pub fn find_pattern(&self, pattern: &str) -> Option<usize>

find_pattern scans over entire module and returns the address if there is matched byte pattern in module.

• pattern - pattern string you’re looking for. format: “8D 34 85 ? ? ? ? 89 15 ? ? ? ? 8B 41 08 8B 48 04 83 F9 FF”

Examples found in repository

examples/in_pattern_scanning.rs (line 23)

fn hack_main_thread() {
    let mut once = false;

    let client = Module::from_module_name("client.dll").unwrap();

    match client.find_pattern(DW_FORCE_ATTACK_PATTERN) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Pattern not found"),
    }

    match client.pattern_scan(
        DW_FORCE_ATTACK_PATTERN,
        2,
        0,
    ) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Offset not found"),
    }

    loop {
        if !once {
            println!("Press INSERT to exit...");
            once = !once;
        }
        // To exit this hack loop when you input INSEERT KEY
        if detect_keypress(VirtualKeyCode::VK_INSERT) {
            break;
        }
    }
}

pub fn pattern_scan( &self, pattern: &str, offset: isize, extra: usize, ) -> Option<usize>

pattern scan basically be for calculating offset of some value. It adds the offset to the pattern-matched address, dereferences, and add the extra.

• pattern - pattern string you’re looking for. format: “8D 34 85 ? ? ? ? 89 15 ? ? ? ? 8B 41 08 8B 48 04 83 F9 FF”
• offset - offset of the address from pattern’s base.
• extra - offset of the address from dereferenced address.

Examples found in repository

examples/in_pattern_scanning.rs (lines 28-32)

fn hack_main_thread() {
    let mut once = false;

    let client = Module::from_module_name("client.dll").unwrap();

    match client.find_pattern(DW_FORCE_ATTACK_PATTERN) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Pattern not found"),
    }

    match client.pattern_scan(
        DW_FORCE_ATTACK_PATTERN,
        2,
        0,
    ) {
        Some(i) => println!("address: 0x{:x}", i),
        None => println!("Offset not found"),
    }

    loop {
        if !once {
            println!("Press INSERT to exit...");
            once = !once;
        }
        // To exit this hack loop when you input INSEERT KEY
        if detect_keypress(VirtualKeyCode::VK_INSERT) {
            break;
        }
    }
}

Trait Implementations

impl<'a> Debug for Module<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Default for Module<'a>

fn default() -> Self

Returns the “default value” for a type.