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
/*
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);
}