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.
JavaScript algorithmsartificial-intelligencebugbountycryptographycyber-threat-intelligencecybersecurity-projectsethical-hackinghacking-toolsmalwarenessusnetwork-monitoringnetwork-securitynmapportscannerpythonpythonprojectsthreat-intelligencevirus-scanning
Create pe_analyzer.rs
Abdul Wahab Junaid14bfc5ed63c9
diff --git a/Rust for Hacking/Analysis/pe_analyzer.rs b/Rust for Hacking/Analysis/pe_analyzer.rsnew file mode 100644index 0000000..31b01a2--- /dev/null+++ b/Rust for Hacking/Analysis/pe_analyzer.rs@@ -0,0 +1,547 @@+/*+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);+}