Skip to content

This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.

22.1 KB
Raw Blame
/*
This code is meant to analyze the Portable Executable (PE) file format.
    [+] PE Header [ e_lfanew (0x3C) = Contains Offset to NT Header (0x80) ] 
    [+] COFF File Header peHeader, machine, NumberofSections, TimeDateStamp, SizeOfOptionalHeader
    [+] Section Header 
    [+] Export Directory
    [+] RVA & RVAOffset

For More codes: https://github.com/Whitecat18
By @5mukx
*/
use winapi::um::synchapi::WaitForSingleObject;
use winapi::um::{memoryapi::VirtualProtect, minwinbase::LPTHREAD_START_ROUTINE, processthreadsapi::CreateRemoteThread};
mod reflect;
use std::ptr::null_mut;
use winapi::um::winnt::PAGE_EXECUTE_READ;


// use pe_parser::{PeFile, PeResult};

// importing from another image

// use crate::reflect::*;

const MAX_PATH: usize = 260;


fn find_export_directory_info(pointer_to_raw_data: usize, virtual_address_offset: usize, pe_analyzer: &[u8]) -> usize{

    println!("INSIDE FIND EXPORT DIRECTORY !");
    println!(
        "         [-] [0x{:04x}] [exportFlags] : 0x{:02X}{:02X}{:02X}{:02X}",
        pointer_to_raw_data,
        pe_analyzer[pointer_to_raw_data + 3],
        pe_analyzer[pointer_to_raw_data + 2],
        pe_analyzer[pointer_to_raw_data + 1],
        pe_analyzer[pointer_to_raw_data]
    );

    let time_date_stamp_offset = pointer_to_raw_data + 0x4;
    println!(
        "         [-] [0x{:04x}] [Time/DateStamp] : 0x{:02X}{:02X}{:02X}{:02X}",
        time_date_stamp_offset,
        pe_analyzer[time_date_stamp_offset + 3],
        pe_analyzer[time_date_stamp_offset + 2],
        pe_analyzer[time_date_stamp_offset + 1],
        pe_analyzer[time_date_stamp_offset]
    );

    let major_version_offset = time_date_stamp_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [majorVersion] : 0x{:02X}{:02X}",
        major_version_offset,
        pe_analyzer[major_version_offset + 1],
        pe_analyzer[major_version_offset]
    );

    let minor_version_offset = major_version_offset + 0x2;
    println!(
        "         [-] [0x{:04x}] [minorVersion] : 0x{:02X}{:02X}",
        minor_version_offset,
        pe_analyzer[minor_version_offset + 1],
        pe_analyzer[minor_version_offset]
    );

    let name_rva_offset = minor_version_offset + 0x2;
    println!(
        "         [-] [0x{:04x}] [nameRVA] : 0x{:02X}{:02X}{:02X}{:02X} (RVA to PE name)",
        name_rva_offset,
        pe_analyzer[name_rva_offset + 3],
        pe_analyzer[name_rva_offset + 2],
        pe_analyzer[name_rva_offset + 1],
        pe_analyzer[name_rva_offset]
    );

    let ordinal_base_offset = name_rva_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [ordinalBase] : 0x{:02X}{:02X}{:02X}{:02X}",
        ordinal_base_offset,
        pe_analyzer[ordinal_base_offset + 3],
        pe_analyzer[ordinal_base_offset + 2],
        pe_analyzer[ordinal_base_offset + 1],
        pe_analyzer[ordinal_base_offset]
    );

    let address_table_entries_offset = ordinal_base_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [addressTableEntries] : 0x{:02X}{:02X}{:02X}{:02X} (Count of functions in Export Address Table)",
        address_table_entries_offset,
        pe_analyzer[address_table_entries_offset + 3],
        pe_analyzer[address_table_entries_offset + 2],
        pe_analyzer[address_table_entries_offset + 1],
        pe_analyzer[address_table_entries_offset]
    );

    let number_of_name_pointers_offset = address_table_entries_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [numberOfNamePointers] : 0x{:02X}{:02X}{:02X}{:02X} (Count of entries in the name pointer table/ordinal table)",
        number_of_name_pointers_offset,
        pe_analyzer[number_of_name_pointers_offset + 3],
        pe_analyzer[number_of_name_pointers_offset + 2],
        pe_analyzer[number_of_name_pointers_offset + 1],
        pe_analyzer[number_of_name_pointers_offset]
    );

    let export_address_table_rva_offset = number_of_name_pointers_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [exportAddressTableRVA] : 0x{:02X}{:02X}{:02X}{:02X} (RVA of the Export Address Table)",
        export_address_table_rva_offset,
        pe_analyzer[export_address_table_rva_offset + 3],
        pe_analyzer[export_address_table_rva_offset + 2],
        pe_analyzer[export_address_table_rva_offset + 1],
        pe_analyzer[export_address_table_rva_offset]
    );

    let name_pointer_rva_offset = export_address_table_rva_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [namePointerRVA] : 0x{:02X}{:02X}{:02X}{:02X} (RVA of the Export Name Pointer Table)",
        name_pointer_rva_offset,
        pe_analyzer[name_pointer_rva_offset + 3],
        pe_analyzer[name_pointer_rva_offset + 2],
        pe_analyzer[name_pointer_rva_offset + 1],
        pe_analyzer[name_pointer_rva_offset]
    );

    let ordinal_table_rva_offset = name_pointer_rva_offset + 0x4;
    println!(
        "         [-] [0x{:04x}] [ordinalTableRVA] : 0x{:02X}{:02X}{:02X}{:02X} (RVA of the Ordinal Table)",
        ordinal_table_rva_offset,
        pe_analyzer[ordinal_table_rva_offset + 3],
        pe_analyzer[ordinal_table_rva_offset + 2],
        pe_analyzer[ordinal_table_rva_offset + 1],
        pe_analyzer[ordinal_table_rva_offset]
    );

    let export_name_pointer_rva = ((pe_analyzer[name_pointer_rva_offset + 3] as usize) << 24)
        | ((pe_analyzer[name_pointer_rva_offset + 2] as usize) << 16)
        | ((pe_analyzer[name_pointer_rva_offset + 1] as usize) << 8)
        | (pe_analyzer[name_pointer_rva_offset] as usize);

    let edata_virtual_address =
        ((pe_analyzer[virtual_address_offset + 3] as usize) << 24)
            | ((pe_analyzer[virtual_address_offset + 2] as usize) << 16)
            | ((pe_analyzer[virtual_address_offset + 1] as usize) << 8)
            | (pe_analyzer[virtual_address_offset] as usize);

    let export_name_pointer_file_offset =
        (export_name_pointer_rva - edata_virtual_address) + pointer_to_raw_data;

    println!(
        "         [-] [0x{:04x}] [exportNamePointerRVA] : 0x{:02X}{:02X}{:02X}{:02X}",
        export_name_pointer_file_offset,
        pe_analyzer[export_name_pointer_file_offset + 3],
        pe_analyzer[export_name_pointer_file_offset + 2],
        pe_analyzer[export_name_pointer_file_offset + 1],
        pe_analyzer[export_name_pointer_file_offset]
    );

    let symbol_name_rva = ((pe_analyzer[export_name_pointer_file_offset + 3] as usize) << 24)
        | ((pe_analyzer[export_name_pointer_file_offset + 2] as usize) << 16)
        | ((pe_analyzer[export_name_pointer_file_offset + 1] as usize) << 8)
        | (pe_analyzer[export_name_pointer_file_offset] as usize);

    let symbol_file_offset = (symbol_name_rva - edata_virtual_address) + pointer_to_raw_data;
    let mut symbol_name = [0u8; MAX_PATH];
    
    for i in 0..MAX_PATH {
        if pe_analyzer[symbol_file_offset + i] == 0 {
            break;
        }
        symbol_name[i] = pe_analyzer[symbol_file_offset + i];
    }

    let symbol_name_str = String::from_utf8_lossy(&symbol_name[..]);
    println!("         [-] [0x{:04x}] [symbolName] : {}", symbol_file_offset, symbol_name_str);

    let export_address_table_rva = ((pe_analyzer[export_address_table_rva_offset + 3] as usize) << 24)
        | ((pe_analyzer[export_address_table_rva_offset + 2] as usize) << 16)
        | ((pe_analyzer[export_address_table_rva_offset + 1] as usize) << 8)
        | (pe_analyzer[export_address_table_rva_offset] as usize);

    println!(
        "         Calculation = (0x{:X} - 0x{:X}) + 0x{:X}",
        export_address_table_rva, edata_virtual_address, pointer_to_raw_data
    );

    let symbol_rva_offset = (export_address_table_rva - edata_virtual_address) + pointer_to_raw_data;
    let symbol_rva = ((pe_analyzer[symbol_rva_offset + 3] as usize) << 24)
        | ((pe_analyzer[symbol_rva_offset + 2] as usize) << 16)
        | ((pe_analyzer[symbol_rva_offset + 1] as usize) << 8)
        | (pe_analyzer[symbol_rva_offset] as usize);
    println!("         [-] [0x{:04x}] [symbolRVA] : 0x{:08X}", symbol_rva_offset, symbol_rva);
    symbol_rva
}

fn find_section_headers(first_section_header_offset: usize, no_of_section: usize, pe_analyzer: &[u8]){
    
    println!("\n [Sections headers start at: 0x{:04x}]", first_section_header_offset);
    let mut next_section_header_offset = first_section_header_offset;
    
    for i in 0..no_of_section {
        
        let header_name = String::from_utf8_lossy
            (&pe_analyzer[next_section_header_offset..next_section_header_offset + 8]);

        println!(" [+] [Section Header {}]", i);
        println!("     [+] [0x{:04x}] [Name] : {}", next_section_header_offset, header_name);

        let virtual_size_offset = next_section_header_offset + 0x8;
        println!(
            "     [+] [0x{:04x}] [VirtualSize] : 0x{:02X}{:02X}{:02X}{:02X}",
            virtual_size_offset,
            pe_analyzer[virtual_size_offset + 3],
            pe_analyzer[virtual_size_offset + 2],
            pe_analyzer[virtual_size_offset + 1],
            pe_analyzer[virtual_size_offset]
        );

        let virtual_address_offset = virtual_size_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [VirtualAddress] : 0x{:02X}{:02X}{:02X}{:02X}",
            virtual_address_offset,
            pe_analyzer[virtual_address_offset + 3],
            pe_analyzer[virtual_address_offset + 2],
            pe_analyzer[virtual_address_offset + 1],
            pe_analyzer[virtual_address_offset]
        );

        let size_of_raw_data_offset = virtual_address_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [SizeOfRawData] : 0x{:02X}{:02X}{:02X}{:02X}",
            size_of_raw_data_offset,
            pe_analyzer[size_of_raw_data_offset + 3],
            pe_analyzer[size_of_raw_data_offset + 2],
            pe_analyzer[size_of_raw_data_offset + 1],
            pe_analyzer[size_of_raw_data_offset]
        );

        let pointer_to_raw_data_offset = size_of_raw_data_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [PointerToRawData] : 0x{:02X}{:02X}{:02X}{:02X}",
            pointer_to_raw_data_offset,
            pe_analyzer[pointer_to_raw_data_offset + 3],
            pe_analyzer[pointer_to_raw_data_offset + 2],
            pe_analyzer[pointer_to_raw_data_offset + 1],
            pe_analyzer[pointer_to_raw_data_offset]
        );

        let pointer_to_relocations_offset = pointer_to_raw_data_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [PointerToRelocations] : 0x{:02X}{:02X}{:02X}{:02X}",
            pointer_to_relocations_offset,
            pe_analyzer[pointer_to_relocations_offset + 3],
            pe_analyzer[pointer_to_relocations_offset + 2],
            pe_analyzer[pointer_to_relocations_offset + 1],
            pe_analyzer[pointer_to_relocations_offset]
        );

        let pointer_to_linenumbers_offset = pointer_to_relocations_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [PointerToLinenumbers] : 0x{:02X}{:02X}{:02X}{:02X}",
            pointer_to_linenumbers_offset,
            pe_analyzer[pointer_to_linenumbers_offset + 3],
            pe_analyzer[pointer_to_linenumbers_offset + 2],
            pe_analyzer[pointer_to_linenumbers_offset + 1],
            pe_analyzer[pointer_to_linenumbers_offset]
        );

        let number_of_linenumbers_offset = pointer_to_linenumbers_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [NumberOfLinenumbers] : 0x{:02X}{:02X}{:02X}{:02X}",
            number_of_linenumbers_offset,
            pe_analyzer[number_of_linenumbers_offset + 3],
            pe_analyzer[number_of_linenumbers_offset + 2],
            pe_analyzer[number_of_linenumbers_offset + 1],
            pe_analyzer[number_of_linenumbers_offset]
        );

        let characteristics_offset = number_of_linenumbers_offset + 0x4;
        println!(
            "     [+] [0x{:04x}] [Characteristics] : 0x{:02X}{:02X}{:02X}{:02X}",
            characteristics_offset,
            pe_analyzer[characteristics_offset + 3],
            pe_analyzer[characteristics_offset + 2],
            pe_analyzer[characteristics_offset + 1],
            pe_analyzer[characteristics_offset]
        );

        if header_name.contains(".edata") {
            let first_byte = pe_analyzer[pointer_to_raw_data_offset + 3] as usize;
            let second_byte = pe_analyzer[pointer_to_raw_data_offset + 2] as usize;
            let third_byte = pe_analyzer[pointer_to_raw_data_offset + 1] as usize;
            let fourth_byte = pe_analyzer[pointer_to_raw_data_offset] as usize;

            let pointer_to_raw_data = (first_byte << 24) | (second_byte << 16) | (third_byte << 8) | fourth_byte;
            let symbol_rva = find_export_directory_info(pointer_to_raw_data, virtual_address_offset, pe_analyzer);

            let mut temp_section_header_offset = first_section_header_offset;
            println!("temp_section_header_offset value: {:#?}", temp_section_header_offset);

            for _ in 0..11 {
                let section_virtual_address_offset = first_section_header_offset + 0xC;
                
                let section_virtual_address = ((pe_analyzer[section_virtual_address_offset + 3] as usize) << 24)
                    | ((pe_analyzer[section_virtual_address_offset + 2] as usize) << 16)
                    | ((pe_analyzer[section_virtual_address_offset + 1] as usize) << 8)
                    | (pe_analyzer[section_virtual_address_offset] as usize);
                let section_size_of_raw_data_offset = section_virtual_address_offset + 0x4;
                
                let section_size_of_raw_data = ((pe_analyzer[section_size_of_raw_data_offset + 3] as usize) << 24)
                    | ((pe_analyzer[section_size_of_raw_data_offset + 2] as usize) << 16)
                    | ((pe_analyzer[section_size_of_raw_data_offset + 1] as usize) << 8)
                    | (pe_analyzer[section_size_of_raw_data_offset] as usize);
                let section_pointer_to_raw_data_offset = section_size_of_raw_data_offset + 0x4;
                
                let section_pointer_to_raw_data = ((pe_analyzer[section_pointer_to_raw_data_offset + 3] as usize) << 24)
                    | ((pe_analyzer[section_pointer_to_raw_data_offset + 2] as usize) << 16)
                    | ((pe_analyzer[section_pointer_to_raw_data_offset + 1] as usize) << 8)
                    | (pe_analyzer[section_pointer_to_raw_data_offset] as usize);
                
                    if symbol_rva > section_virtual_address
                    && symbol_rva < section_virtual_address + section_size_of_raw_data
                {
                    let symbol_file_offset = (symbol_rva - section_virtual_address) + section_pointer_to_raw_data;
                    println!("     [*] [0x{:04x}] [symbolFileOffset] : 0x{:08X}", symbol_rva, symbol_file_offset);

                    let mut pe_analyzer_executable_buffer: Vec<u8> =
                        vec![0u8; pe_analyzer.len()];

                    pe_analyzer_executable_buffer
                        .copy_from_slice(&pe_analyzer[..pe_analyzer.len()]);

                    println!("------------------------ boxreflectDllExectuableBuffer: 0x{:x}", pe_analyzer_executable_buffer.as_ptr() as usize);

                    for i in 0..0x84 {
                        if i == 0x3c {
                            continue;
                        }
                        pe_analyzer_executable_buffer[i] = 0;
                    }

                    pe_analyzer_executable_buffer[0x80] = 0x23;
                    pe_analyzer_executable_buffer[0x81] = 0x12;
                    
                    let fl_old_protect:u32 = 0;

                    unsafe {
                        VirtualProtect(
                            pe_analyzer_executable_buffer.as_mut_ptr() as *mut _,
                            pe_analyzer.len(),
                            PAGE_EXECUTE_READ,
                            fl_old_protect.clone() as *mut u32,
                        );
                    }

                    let symbol_executable_address: LPTHREAD_START_ROUTINE = unsafe{
                        std::mem::transmute((pe_analyzer_executable_buffer.as_ptr() as usize + symbol_file_offset) as usize)
                    };

                    
                    let mut lp_thread_id = 0;
                    let h_thread = unsafe{
                        CreateRemoteThread(
                            null_mut(),
                            null_mut(), 1024 * 1024,
                            symbol_executable_address,
                            null_mut(),
                            0,
                            &mut lp_thread_id,
                        )
                    };
                    unsafe{
                        WaitForSingleObject(h_thread, 0xFFFFFFFF);
                    }
                    break;
                }
                temp_section_header_offset += 0x28;
            }
        }
        next_section_header_offset += 0x28;
        println!();
    }
}

// IF you are interested, you can check this out ...
// fn print_base_address(pe_file: &PeFile) {
//     if let Some(optional_header) = &pe_file.optional_header {
//         println!("Base Address: 0x{:x}", optional_header.image_base);
//     } else {
//         println!("Optional header not found.");
//     }
// }

// mod reflect;

// Finding Rich Header ...


// const RICH_HEADER_MAGIC: u32 = 0x68636952;
// fn rich_header(file_path: &str) -> std::io::Result<()> {
//     let mut file = File::open(file_path)?;
//     let file_size = file.metadata()?.len();

//     file.seek(SeekFrom::End(-64))?;

//     let mut buffer = [0; 64];
//     file.read_exact(&mut buffer)?;

//     for i in (0..buffer.len() - 8).step_by(4) {
//         if u32::from_le_bytes([buffer[i], buffer[i + 1], buffer[i + 2], buffer[i + 3]]) == RICH_HEADER_MAGIC {
//             for j in 0..16 {
//                 let offset = file_size - 64 + i as u64 + j;
//                 println!(
//                     " [0x{:X}] [Rich Header] {} : 0x{:02X}",
//                     offset, j, buffer[i + j as usize]
//                 );
//             }
//             break;
//         }
//     }

//     Ok(())
// }

const RICH_HEADER_MAGIC: u32 = 0x68636952;

fn find_rich_header(pe_bytes: &[u8]) -> Option<usize> {
    // Check if the Rich header magic exists in the byte array
    for i in 0..(pe_bytes.len() - 8) {
        if u32::from_le_bytes([
            pe_bytes[i],
            pe_bytes[i + 1],
            pe_bytes[i + 2],
            pe_bytes[i + 3],
        ]) == RICH_HEADER_MAGIC
        {
            return Some(i);
        }
    }
    None
}


fn main() {
    let initial_offset: usize = 0x3c;

    /*
    If you want to analyze an shellcode dll etc.., you can follow the import method , call from the function
    If you want to analyze an file , you can use include_bytes to read from file.
    */


    //                       ---- IMPORT METHOD ----
    
    let pe_analyzer = reflect::boxreflect_dll_shellcode;
    // let pe_analyzer = include_bytes!(bokacode);
    //                    ---- FILE INCLUDE METHOD ----
    // const PATH: &str = "../test.exe"; 
    
    // let pe_analyzer = include_bytes!("../test.exe");
    
    // Sorry guys. i am unable to write code for base addr. i have searched various resources 
    // for it but i can't able to find one 
    
    // For base address i have used an small crate "pe-parser" just to avoud such length verbose code.
    // let base_addr = PeFile::from_file(PATH);


    // but it requires rust 1.74 V
    // println!("pe_analyzer base addr: 0x{:#?}", &base_addr);


    // Calculate peHeaderOffset
    let pe_header_offset: usize = (pe_analyzer[initial_offset + 2] as usize) << 16
        | (pe_analyzer[initial_offset + 1] as usize) << 8
        | pe_analyzer[initial_offset] as usize;
    
    println!(" [0x{:x}] [peHeader offset] : 0x{:x}", initial_offset, pe_header_offset);
    
    println!(
        " [0x{:x}] [peHeader] : {}{}",
        pe_header_offset,
        pe_analyzer[pe_header_offset] as char,
        pe_analyzer[pe_header_offset + 1] as char
        );

    // Calculate machineTypeOffset
    let machine_type_offset: usize = pe_header_offset + 4;
    println!(
        " [0x{:x}] [machineType] : x{:x}{:x}",
        machine_type_offset,
        pe_analyzer[machine_type_offset + 1],
        pe_analyzer[machine_type_offset]
    );


    // Calculate RichHeader
    //                if using shllcode pe means use reference here &-> V
    if let Some(rich_header_offset) = find_rich_header(&pe_analyzer) {
        for i in 0..16 {
            let offset = rich_header_offset + i;
            println!(
                " [0x{:X}] [RichHeader]{} : 0x{:02X}",
                offset, i, pe_analyzer[offset]
            );
        }
    } else {
        println!("[0x84] [RichHeader] Not found");
    }

    // Calculate noOfSectionsOffset and noOfSections
    let no_of_sections_offset: usize = machine_type_offset + 0x2;
    let no_of_sections: u16 = ((pe_analyzer[no_of_sections_offset + 1] as u16) << 8)
        | (pe_analyzer[no_of_sections_offset] as u16);

    println!(
        " [0x{:x}] [noOfSections] : ({}) 0x{:x}",
        no_of_sections_offset, no_of_sections, no_of_sections
    );


    // Calculate timeDateStampOffset
    let time_date_stamp_offset: usize = no_of_sections_offset + 0x2;
    println!(
        " [0x{:x}] [timeDateStamp] : 0x{:x}{:x}{:x}{:x}",
        time_date_stamp_offset,
        pe_analyzer[time_date_stamp_offset + 3],
        pe_analyzer[time_date_stamp_offset + 2],
        pe_analyzer[time_date_stamp_offset + 1],
        pe_analyzer[time_date_stamp_offset]
    );

    // Calculate sizeOfOptionalHeaderOffset and sizeOfOptionalHeader
    let size_of_optional_header_offset: usize =
        time_date_stamp_offset + 0x4 + 0x4 + 0x4;
    let size_of_optional_header: u16 = ((pe_analyzer[size_of_optional_header_offset + 1] as u16) << 8)
        | (pe_analyzer[size_of_optional_header_offset] as u16);
    println!(
        " [0x{:x}] [sizeOfOptionalHeader] : 0x{:x}",
        size_of_optional_header_offset, size_of_optional_header
    );

    // Calculate firstSectionHeaderOffset
    let first_section_header_offset = size_of_optional_header_offset + 0x2 + 0x2 + size_of_optional_header as usize;
                                            // if using shllcode pe means use reference here &-> V
    find_section_headers(first_section_header_offset, no_of_sections as usize, &pe_analyzer);
}