main.rs: use disassembler::Disassembler; use graph::cfg::ControlFlowGraph; use…
- User
main.rs: use disassembler::Disassembler; use graph::cfg::ControlFlowGraph; use pe_parser::PEParser; // Added import for PEParser
fn main() { // Entry point of the Socrates binary analyzer
// Initialize PE Parser let mut pe_parser = PEParser::new(); // Load binary data let binary_path = "path_to_binary.exe"; let binary_data = load_binary(binary_path); // Parse PE headers pe_parser.parse(&binary_data); // Initialize Disassembler let mut disassembler = Disassembler::new(); // Perform disassembly starting at offset 0 disassembler.disassemble(&binary_data, 0); // Retrieve decoded instructions let instructions = disassembler.get_instructions(); // Initialize Control Flow Graph let mut cfg = ControlFlowGraph::new(); cfg.build(instructions); // Further analysis... println!("Disassembly and CFG construction completed.");}
fn load_binary(path: &str) -> Vec { // Function to load binary data from a file std::fs::read(path).expect("Failed to read binary file") }
mod disassembler; mod graph; mod pe_parser; // Added pe_parser module
pe_parser.rs: ( you do this one ). in full advanced detail. leave no details out
- Assistant
use std::mem::size_of; pub struct PEParser { dos_header: Option<DOSHeader>, pe_header: Option<PEHeader>, optional_header: Option<OptionalHeader>, section_headers: Vec<SectionHeader>, // Additional fields can be added as needed } impl PEParser { /// Creates a new instance of `PEParser`. pub fn new() -> Self { Self { dos_header: None, pe_header: None, optional_header: None, section_headers: Vec::new(), } } /// Parses the PE headers from the given binary data. /// /// # Arguments /// /// * `data` - A byte slice containing the binary data of the PE file. pub fn parse(&mut self, data: &[u8]) { // Parse DOS Header let dos_header = DOSHeader::parse(data).expect("Failed to parse DOS Header"); self.dos_header = Some(dos_header); // Get the PE header offset from e_lfanew let pe_header_offset = self.dos_header.as_ref().unwrap().e_lfanew as usize; // Parse PE Header (Signature + COFF Header) let pe_header = PEHeader::parse(&data[pe_header_offset..]).expect("Failed to parse PE Header"); self.pe_header = Some(pe_header); // Parse Optional Header let optional_header_offset = pe_header_offset + size_of::<PEHeader>(); let optional_header_size = self.pe_header.as_ref().unwrap().size_of_optional_header as usize; let optional_header_data = &data[optional_header_offset..optional_header_offset + optional_header_size]; let optional_header = OptionalHeader::parse(optional_header_data).expect("Failed to parse Optional Header"); self.optional_header = Some(optional_header); // Parse Section Headers let number_of_sections = self.pe_header.as_ref().unwrap().number_of_sections; let section_headers_offset = optional_header_offset + optional_header_size; let section_headers_size = size_of::<SectionHeader>() * number_of_sections as usize; let section_headers_data = &data[section_headers_offset..section_headers_offset + section_headers_size]; self.section_headers = SectionHeader::parse_all(number_of_sections, section_headers_data) .expect("Failed to parse Section Headers"); // Additional parsing or processing can be added here } // Getter methods can be added here to access parsed header information } // DOS Header Structure #[repr(C)] #[derive(Debug)] struct DOSHeader { e_magic: u16, // Magic number e_cblp: u16, // Bytes on last page of file e_cp: u16, // Pages in file e_crlc: u16, // Relocations e_cparhdr: u16, // Size of header in paragraphs e_minalloc: u16, // Minimum extra paragraphs needed e_maxalloc: u16, // Maximum extra paragraphs needed e_ss: u16, // Initial (relative) SS value e_sp: u16, // Initial SP value e_csum: u16, // Checksum e_ip: u16, // Initial IP value e_cs: u16, // Initial (relative) CS value e_lfarlc: u16, // File address of relocation table e_ovno: u16, // Overlay number e_res: [u16; 4], // Reserved words e_oemid: u16, // OEM identifier (for e_oeminfo) e_oeminfo: u16, // OEM information; e_oemid specific e_res2: [u16; 10],// Reserved words e_lfanew: u32, // File address of new exe header } impl DOSHeader { /// Parses the DOS Header from the given binary data. fn parse(data: &[u8]) -> Option<Self> { // Ensure the data is large enough for the DOS Header if data.len() < 64 { return None; } // Read the magic number and verify it's the 'MZ' header let e_magic = u16::from_le_bytes([data[0], data[1]]); if e_magic != 0x5A4D { // 'MZ' magic number not found return None; } // Read the rest of the DOS Header fields let e_cblp = u16::from_le_bytes([data[2], data[3]]); let e_cp = u16::from_le_bytes([data[4], data[5]]); let e_crlc = u16::from_le_bytes([data[6], data[7]]); let e_cparhdr = u16::from_le_bytes([data[8], data[9]]); let e_minalloc = u16::from_le_bytes([data[10], data[11]]); let e_maxalloc = u16::from_le_bytes([data[12], data[13]]); let e_ss = u16::from_le_bytes([data[14], data[15]]); let e_sp = u16::from_le_bytes([data[16], data[17]]); let e_csum = u16::from_le_bytes([data[18], data[19]]); let e_ip = u16::from_le_bytes([data[20], data[21]]); let e_cs = u16::from_le_bytes([data[22], data[23]]); let e_lfarlc = u16::from_le_bytes([data[24], data[25]]); let e_ovno = u16::from_le_bytes([data[26], data[27]]); let e_res = [ u16::from_le_bytes([data[28], data[29]]), u16::from_le_bytes([data[30], data[31]]), u16::from_le_bytes([data[32], data[33]]), u16::from_le_bytes([data[34], data[35]]), ]; let e_oemid = u16::from_le_bytes([data[36], data[37]]); let e_oeminfo = u16::from_le_bytes([data[38], data[39]]); let e_res2 = [ u16::from_le_bytes([data[40], data[41]]), u16::from_le_bytes([data[42], data[43]]), u16::from_le_bytes([data[44], data[45]]), u16::from_le_bytes([data[46], data[47]]), u16::from_le_bytes([data[48], data[49]]), u16::from_le_bytes([data[50], data[51]]), u16::from_le_bytes([data[52], data[53]]), u16::from_le_bytes([data[54], data[55]]), u16::from_le_bytes([data[56], data[57]]), u16::from_le_bytes([data[58], data[59]]), ]; let e_lfanew = u32::from_le_bytes([data[60], data[61], data[62], data[63]]); Some(Self { e_magic, e_cblp, e_cp, e_crlc, e_cparhdr, e_minalloc, e_maxalloc, e_ss, e_sp, e_csum, e_ip, e_cs, e_lfarlc, e_ovno, e_res, e_oemid, e_oeminfo, e_res2, e_lfanew, }) } } // PE Header (COFF Header) Structure #[repr(C)] #[derive(Debug)] struct PEHeader { signature: u32, machine: u16, number_of_sections: u16, time_date_stamp: u32, pointer_to_symbol_table: u32, number_of_symbols: u32, size_of_optional_header: u16, characteristics: u16, } impl PEHeader { /// Parses the PE Header from the given binary data. fn parse(data: &[u8]) -> Option<Self> { // Ensure the data is large enough for the PE Header if data.len() < 24 { return None; } // Read the signature and verify it's the 'PE\0\0' signature let signature = u32::from_le_bytes([data[0], data[1], data[2], data[3]]); if signature != 0x00004550 { // 'PE\0\0' signature not found return None; } // Read the rest of the PE Header fields let machine = u16::from_le_bytes([data[4], data[5]]); let number_of_sections = u16::from_le_bytes([data[6], data[7]]); let time_date_stamp = u32::from_le_bytes([data[8], data[9], data[10], data[11]]); let pointer_to_symbol_table = u32::from_le_bytes([data[12], data[13], data[14], data[15]]); let number_of_symbols = u32::from_le_bytes([data[16], data[17], data[18], data[19]]); let size_of_optional_header = u16::from_le_bytes([data[20], data[21]]); let characteristics = u16::from_le_bytes([data[22], data[23]]); Some(Self { signature, machine, number_of_sections, time_date_stamp, pointer_to_symbol_table, number_of_symbols, size_of_optional_header, characteristics, }) } } // Optional Header Structure #[repr(C)] #[derive(Debug)] struct OptionalHeader { // Standard fields magic: u16, major_linker_version: u8, minor_linker_version: u8, size_of_code: u32, size_of_initialized_data: u32, size_of_uninitialized_data: u32, address_of_entry_point: u32, base_of_code: u32, base_of_data: Option<u32>, // Present only in PE32; absent in PE32+ // Windows-specific fields image_base: u64, // 32-bit or 64-bit depending on PE format section_alignment: u32, file_alignment: u32, major_os_version: u16, minor_os_version: u16, major_image_version: u16, minor_image_version: u16, major_subsystem_version: u16, minor_subsystem_version: u16, win32_version_value: u32, size_of_image: u32, size_of_headers: u32, checksum: u32, subsystem: u16, dll_characteristics: u16, size_of_stack_reserve: u64, // 32-bit or 64-bit depending on PE format size_of_stack_commit: u64, // 32-bit or 64-bit depending on PE format size_of_heap_reserve: u64, // 32-bit or 64-bit depending on PE format size_of_heap_commit: u64, // 32-bit or 64-bit depending on PE format loader_flags: u32, number_of_rva_and_sizes: u32, data_directories: Vec<DataDirectory>, } impl OptionalHeader { /// Parses the Optional Header from the given binary data. fn parse(data: &[u8]) -> Option<Self> { // Ensure the data is large enough if data.len() < 96 { return None; } // Read the magic number to determine PE format (PE32 or PE32+) let magic = u16::from_le_bytes([data[0], data[1]]); let is_pe32 = magic == 0x10b; let is_pe32_plus = magic == 0x20b; if !is_pe32 && !is_pe32_plus { // Invalid Optional Header magic number return None; } let major_linker_version = data[2]; let minor_linker_version = data[3]; let size_of_code = u32::from_le_bytes([data[4], data[5], data[6], data[7]]); let size_of_initialized_data = u32::from_le_bytes([data[8], data[9], data[10], data[11]]); let size_of_uninitialized_data = u32::from_le_bytes([data[12], data[13], data[14], data[15]]); let address_of_entry_point = u32::from_le_bytes([data[16], data[17], data[18], data[19]]); let base_of_code = u32::from_le_bytes([data[20], data[21], data[22], data[23]]); let mut offset = 24; let base_of_data; let image_base; if is_pe32 { // PE32 format base_of_data = Some(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; image_base = u64::from(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; } else { // PE32+ format base_of_data = None; image_base = u64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); offset += 8; } // Read the rest of the Windows-specific fields let section_alignment = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let file_alignment = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let major_os_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let minor_os_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let major_image_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let minor_image_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let major_subsystem_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let minor_subsystem_version = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let win32_version_value = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let size_of_image = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let size_of_headers = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let checksum = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let subsystem = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let dll_characteristics = u16::from_le_bytes([data[offset], data[offset + 1]]); offset += 2; let size_of_stack_reserve; let size_of_stack_commit; let size_of_heap_reserve; let size_of_heap_commit; if is_pe32 { size_of_stack_reserve = u64::from(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; size_of_stack_commit = u64::from(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; size_of_heap_reserve = u64::from(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; size_of_heap_commit = u64::from(u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]])); offset += 4; } else { size_of_stack_reserve = u64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); offset += 8; size_of_stack_commit = u64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); offset += 8; size_of_heap_reserve = u64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); offset += 8; size_of_heap_commit = u64::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], data[offset + 4], data[offset + 5], data[offset + 6], data[offset + 7], ]); offset += 8; } let loader_flags = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; let number_of_rva_and_sizes = u32::from_le_bytes([data[offset], data[offset + 1], data[offset + 2], data[offset + 3]]); offset += 4; // Parse Data Directories let mut data_directories = Vec::new(); for _ in 0..number_of_rva_and_sizes { if data.len() < offset + 8 { // Not enough data for all data directories break; } let virtual_address = u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; let size = u32::from_le_bytes([ data[offset], data[offset + 1], data[offset + 2], data[offset + 3], ]); offset += 4; data_directories.push(DataDirectory { virtual_address, size, }); } Some(Self { magic, major_linker_version, minor_linker_version, size_of_code, size_of_initialized_data, size_of_uninitialized_data, address_of_entry_point, base_of_code, base_of_data, image_base, section_alignment, file_alignment, major_os_version, minor_os_version, major_image_version, minor_image_version, major_subsystem_version, minor_subsystem_version, win32_version_value, size_of_image, size_of_headers, checksum, subsystem, dll_characteristics, size_of_stack_reserve, size_of_stack_commit, size_of_heap_reserve, size_of_heap_commit, loader_flags, number_of_rva_and_sizes, data_directories, }) } } // Data Directory Structure #[derive(Debug)] struct DataDirectory { virtual_address: u32, size: u32, } // Section Header Structure #[repr(C)] #[derive(Debug)] struct SectionHeader { name: [u8; 8], virtual_size: u32, virtual_address: u32, size_of_raw_data: u32, pointer_to_raw_data: u32, pointer_to_relocations: u32, pointer_to_linenumbers: u32, number_of_relocations: u16, number_of_linenumbers: u16, characteristics: u32, } impl SectionHeader { /// Parses all section headers from the given binary data. /// /// # Arguments /// /// * `number` - The number of section headers to parse. /// * `data` - A byte slice containing the binary data of the section headers. fn parse_all(number: u16, data: &[u8]) -> Option<Vec<Self>> { let mut headers = Vec::new(); let size = size_of::<SectionHeader>(); let total_size = number as usize * size; if data.len() < total_size { return None; } for i in 0..number { let offset = i as usize * size; let header_data = &data[offset..offset + size]; let header = Self::parse(header_data)?; headers.push(header); } Some(headers) } /// Parses a single section header from the given binary data. fn parse(data: &[u8]) -> Option<Self> { if data.len() < 40 { return None; } let mut name = [0u8; 8]; name.copy_from_slice(&data[0..8]); let virtual_size = u32::from_le_bytes([data[8], data[9], data[10], data[11]]); let virtual_address = u32::from_le_bytes([data[12], data[13], data[14], data[15]]); let size_of_raw_data = u32::from_le_bytes([data[16], data[17], data[18], data[19]]); let pointer_to_raw_data = u32::from_le_bytes([data[20], data[21], data[22], data[23]]); let pointer_to_relocations = u32::from_le_bytes([data[24], data[25], data[26], data[27]]); let pointer_to_linenumbers = u32::from_le_bytes([data[28], data[29], data[30], data[31]]); let number_of_relocations = u16::from_le_bytes([data[32], data[33]]); let number_of_linenumbers = u16::from_le_bytes([data[34], data[35]]); let characteristics = u32::from_le_bytes([data[36], data[37], data[38], data[39]]); Some(Self { name, virtual_size, virtual_address, size_of_raw_data, pointer_to_raw_data, pointer_to_relocations, pointer_to_linenumbers, number_of_relocations, number_of_linenumbers, characteristics, }) } }This
pe_parser.rsmodule provides a detailed implementation of a PE (Portable Executable) file parser in Rust. It defines aPEParserstruct with methods to parse the various headers of a PE file, including the DOS header, PE header, optional header, and section headers.The module includes:
- PEParser Struct: The main parser that stores the parsed headers.
- DOSHeader Struct and Parsing: Represents and parses the DOS header at the beginning of the PE file.
- PEHeader Struct and Parsing: Represents and parses the PE header (also known as the COFF header), including validation of the PE signature.
- OptionalHeader Struct and Parsing: Represents and parses the optional header, handling both PE32 and PE32+ formats.
- SectionHeader Struct and Parsing: Represents and parses the section headers of the PE file.
- DataDirectory Struct: Represents the data directories listed in the optional header.
All parsing functions carefully read the binary data, convert it to the correct types, and handle different PE formats (PE32 vs. PE32+). The implementation ensures that all offsets and sizes are correctly calculated, and it provides detailed error checking to ensure that the provided data is sufficient for parsing.
You can now integrate this module into your main program to perform PE parsing as part of your binary analysis workflow.