Struct Maple 

pub struct Maple;

Main entry point for the maple-rs library.

Provides convenient static methods for loading executables and libraries from memory buffers.

Implementations

impl Maple

pub fn load_library_from_memory(data: &[u8]) -> Result<Box<dyn MemoryModule>>

Loads a DLL/library from a memory buffer.

Arguments

• data - Raw bytes of the PE file to load

Returns

Returns a MemoryModule trait object that can be used to interact with the loaded library, including getting function addresses.

Example

use maple_rs::Maple;
use std::fs;

let dll_data = fs::read("library.dll").unwrap();
let module = Maple::load_library_from_memory(&dll_data).unwrap();
let func = module.get_proc_address("MyFunction").unwrap();

Errors

Returns MapleError if:

• The PE format is invalid
• Memory allocation fails
• Import resolution fails
• Platform is not supported

Examples found in repository

examples/load_demo.rs (line 49)

fn main() -> Result<()> {
    let demo_path = Path::new("test/demo.exe");
    let dll_path = Path::new("test/makcu-cpp.dll");

    if !demo_path.exists() {
        eprintln!("demo.exe not found in test directory");
        return Ok(());
    }

    if !dll_path.exists() {
        eprintln!("makcu-cpp.dll not found in test directory");
        return Ok(());
    }

    println!("First, copy makcu-cpp.dll to current directory so demo.exe can find it...");
    if dll_path.exists() {
        let _ = fs::copy(dll_path, "makcu-cpp.dll");
    }

    println!("Loading demo.exe from memory...");
    let demo_data = fs::read(demo_path)?;

    println!("Creating memory module...");
    match Maple::load_executable_from_memory(&demo_data) {
        Ok(module) => {
            println!("Successfully loaded demo.exe into memory");
            println!("Base address: {:p}", module.base_address());
            println!("Size: {} bytes", module.size());
            println!("Is loaded: {}", module.is_loaded());

            println!("Executing entry point...");
            match module.execute_entry_point() {
                Ok(_) => println!("Entry point executed successfully"),
                Err(e) => eprintln!("Failed to execute entry point: {}", e),
            }
        }
        Err(e) => {
            eprintln!("Failed to load demo.exe: {}", e);
        }
    }

    println!("\nLoading makcu-cpp.dll from memory...");
    let dll_data = fs::read(dll_path)?;

    match Maple::load_library_from_memory(&dll_data) {
        Ok(module) => {
            println!("Successfully loaded makcu-cpp.dll into memory");
            println!("Base address: {:p}", module.base_address());
            println!("Size: {} bytes", module.size());
            println!("Is loaded: {}", module.is_loaded());
        }
        Err(e) => {
            eprintln!("Failed to load makcu-cpp.dll: {}", e);
        }
    }

    // Clean up the copied DLL
    if Path::new("makcu-cpp.dll").exists() {
        println!("\nCleaning up copied DLL...");
        if let Err(e) = fs::remove_file("makcu-cpp.dll") {
            eprintln!("Warning: Failed to clean up makcu-cpp.dll: {}", e);
        } else {
            println!("Cleaned up makcu-cpp.dll");
        }
    }

    Ok(())
}

pub fn load_executable_from_memory(data: &[u8]) -> Result<Box<dyn MemoryModule>>

Loads an executable from a memory buffer.

Arguments

• data - Raw bytes of the PE executable to load

Returns

Returns a MemoryModule trait object that can be used to execute the program’s entry point.

Example

use maple_rs::Maple;
use std::fs;

let exe_data = fs::read("program.exe").unwrap();
let module = Maple::load_executable_from_memory(&exe_data).unwrap();
module.execute_entry_point().unwrap();

Errors

Returns MapleError if:

• The PE format is invalid
• Memory allocation fails
• Import resolution fails
• Platform is not supported

Examples found in repository

examples/load_demo.rs (line 28)

fn main() -> Result<()> {
    let demo_path = Path::new("test/demo.exe");
    let dll_path = Path::new("test/makcu-cpp.dll");

    if !demo_path.exists() {
        eprintln!("demo.exe not found in test directory");
        return Ok(());
    }

    if !dll_path.exists() {
        eprintln!("makcu-cpp.dll not found in test directory");
        return Ok(());
    }

    println!("First, copy makcu-cpp.dll to current directory so demo.exe can find it...");
    if dll_path.exists() {
        let _ = fs::copy(dll_path, "makcu-cpp.dll");
    }

    println!("Loading demo.exe from memory...");
    let demo_data = fs::read(demo_path)?;

    println!("Creating memory module...");
    match Maple::load_executable_from_memory(&demo_data) {
        Ok(module) => {
            println!("Successfully loaded demo.exe into memory");
            println!("Base address: {:p}", module.base_address());
            println!("Size: {} bytes", module.size());
            println!("Is loaded: {}", module.is_loaded());

            println!("Executing entry point...");
            match module.execute_entry_point() {
                Ok(_) => println!("Entry point executed successfully"),
                Err(e) => eprintln!("Failed to execute entry point: {}", e),
            }
        }
        Err(e) => {
            eprintln!("Failed to load demo.exe: {}", e);
        }
    }

    println!("\nLoading makcu-cpp.dll from memory...");
    let dll_data = fs::read(dll_path)?;

    match Maple::load_library_from_memory(&dll_data) {
        Ok(module) => {
            println!("Successfully loaded makcu-cpp.dll into memory");
            println!("Base address: {:p}", module.base_address());
            println!("Size: {} bytes", module.size());
            println!("Is loaded: {}", module.is_loaded());
        }
        Err(e) => {
            eprintln!("Failed to load makcu-cpp.dll: {}", e);
        }
    }

    // Clean up the copied DLL
    if Path::new("makcu-cpp.dll").exists() {
        println!("\nCleaning up copied DLL...");
        if let Err(e) = fs::remove_file("makcu-cpp.dll") {
            eprintln!("Warning: Failed to clean up makcu-cpp.dll: {}", e);
        } else {
            println!("Cleaned up makcu-cpp.dll");
        }
    }

    Ok(())
}

examples/load_focus.rs (line 54)

fn main() -> Result<()> {
    let focus_path = Path::new("test/focus/focus.exe");

    if !focus_path.exists() {
        eprintln!("focus.exe not found in test/focus directory");
        return Ok(());
    }

    // Check if all the required DLLs are present in the focus directory
    let dll_files = [
        "abseil_dll.dll",
        "jpeg62.dll",
        "libcrypto-3-x64.dll",
        "liblzma.dll",
        "libpng16.dll",
        "libprotobuf.dll",
        "libsharpyuv.dll",
        "libwebp.dll",
        "libwebpdecoder.dll",
        "opencv_core4.dll",
        "opencv_dnn4.dll",
        "opencv_highgui4.dll",
        "opencv_imgcodecs4.dll",
        "opencv_imgproc4.dll",
        "opencv_videoio4.dll",
        "tiff.dll",
        "zlib1.dll",
    ];

    println!("Copying required DLLs to current directory...");
    for dll in &dll_files {
        let dll_path = Path::new("test/focus").join(dll);
        if dll_path.exists() {
            if let Err(e) = fs::copy(&dll_path, dll) {
                eprintln!("Warning: Failed to copy {}: {}", dll, e);
            } else {
                println!("Copied {}", dll);
            }
        } else {
            eprintln!("Warning: {} not found", dll);
        }
    }

    println!("\nLoading focus.exe from memory...");
    let focus_data = fs::read(focus_path)?;

    println!("Creating memory module...");
    println!("Focus.exe size: {} bytes", focus_data.len());

    match Maple::load_executable_from_memory(&focus_data) {
        Ok(module) => {
            println!("Successfully loaded focus.exe into memory");
            println!("Base address: {:p}", module.base_address());
            println!("Size: {} bytes", module.size());
            println!("Is loaded: {}", module.is_loaded());

            println!("\nExecuting GUI application entry point...");
            println!("Note: This will launch the focus.exe GUI application from memory!");

            match module.execute_entry_point() {
                Ok(_) => println!("Entry point executed successfully (GUI should have appeared)"),
                Err(e) => eprintln!("Failed to execute entry point: {}", e),
            }
        }
        Err(e) => {
            eprintln!("Failed to load focus.exe: {}", e);
        }
    }

    // Clean up copied DLLs
    println!("\nCleaning up copied DLLs...");
    for dll in &dll_files {
        if Path::new(dll).exists() {
            let _ = fs::remove_file(dll);
        }
    }

    Ok(())
}