diff --git a/Cargo.toml b/Cargo.toml index 17a2cda7..d99167fe 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -9,7 +9,7 @@ members = [ [profile.release] debug = 0 strip = true -opt-level = 2 +opt-level = 3 panic = 'unwind' [profile.dev] diff --git a/crates/libmwemu/src/banzai.rs b/crates/libmwemu/src/banzai.rs index 07d7cfb8..f0c673cf 100644 --- a/crates/libmwemu/src/banzai.rs +++ b/crates/libmwemu/src/banzai.rs @@ -30,5 +30,4 @@ impl Banzai { pub fn add(&mut self, name: &str, nparams: i32) { self.api_params.insert(name.to_string(), nparams); } - } diff --git a/crates/libmwemu/src/breakpoint.rs b/crates/libmwemu/src/breakpoint.rs index 037d3945..d2014602 100644 --- a/crates/libmwemu/src/breakpoint.rs +++ b/crates/libmwemu/src/breakpoint.rs @@ -22,7 +22,6 @@ impl Default for Breakpoints { } } - impl Breakpoints { // TODO: implementing clearing breakpoint for console pub fn new() -> Self { @@ -109,10 +108,18 @@ impl Breakpoints { let instruction_str: Vec = self.addr.iter().map(|a| format!("0x{:x}", a)).collect(); log::info!("break on instruction: [{}]", instruction_str.join(", ")); // Uses Debug formatting for the whole vector - let mem_read_str: Vec = self.mem_read_addr.iter().map(|a| format!("0x{:x}", a)).collect(); + let mem_read_str: Vec = self + .mem_read_addr + .iter() + .map(|a| format!("0x{:x}", a)) + .collect(); log::info!("break on memory read: [{}]", mem_read_str.join(", ")); - let mem_write_str: Vec = self.mem_write_addr.iter().map(|a| format!("0x{:x}", a)).collect(); + let mem_write_str: Vec = self + .mem_write_addr + .iter() + .map(|a| format!("0x{:x}", a)) + .collect(); log::info!("break on memory write: [{}]", mem_write_str.join(", ")); } } diff --git a/crates/libmwemu/src/colors.rs b/crates/libmwemu/src/colors.rs index 6f567c65..5430073d 100644 --- a/crates/libmwemu/src/colors.rs +++ b/crates/libmwemu/src/colors.rs @@ -24,7 +24,6 @@ pub struct Colors { pub clear_screen: String, } - impl Default for Colors { fn default() -> Self { Self::new() diff --git a/crates/libmwemu/src/config.rs b/crates/libmwemu/src/config.rs index a49872ec..31541f4c 100644 --- a/crates/libmwemu/src/config.rs +++ b/crates/libmwemu/src/config.rs @@ -1,15 +1,15 @@ use std::collections::HashMap; -use serde::{Deserialize, Serialize}; use crate::{constants, definitions::Definition}; +use serde::{Deserialize, Serialize}; #[derive(Clone, Serialize, Deserialize)] pub struct Config { - pub filename: String, // filename with full path included - pub trace_mem: bool, // show memory operations in every step. + pub filename: String, // filename with full path included + pub trace_mem: bool, // show memory operations in every step. pub trace_calls: bool, // trace every call - pub trace_regs: bool, // show all the regs in every step. - pub trace_reg: bool, // show value and content of a reg in every step. + pub trace_regs: bool, // show all the regs in every step. + pub trace_reg: bool, // show value and content of a reg in every step. pub trace_filename: Option, pub trace_start: u64, pub trace_string: bool, @@ -39,7 +39,7 @@ pub struct Config { pub skip_unimplemented: bool, pub stack_addr: u64, pub arguments: String, - pub enable_threading: bool, // Enable multi-threading support + pub enable_threading: bool, // Enable multi-threading support pub verbose_at: Option, pub command: Option, pub definitions: HashMap, @@ -89,7 +89,7 @@ impl Config { skip_unimplemented: false, stack_addr: 0, arguments: "".to_string(), - enable_threading: false, // Default to single-threaded for backward compatibility + enable_threading: false, // Default to single-threaded for backward compatibility verbose_at: None, command: None, definitions: HashMap::new(), diff --git a/crates/libmwemu/src/console.rs b/crates/libmwemu/src/console.rs index 67b27828..d446203d 100644 --- a/crates/libmwemu/src/console.rs +++ b/crates/libmwemu/src/console.rs @@ -1,6 +1,3 @@ -use std::io::Write; -use std::num::ParseIntError; -use std::sync::atomic; use crate::emu::Emu; use crate::peb::peb32; use crate::peb::peb64; @@ -9,11 +6,15 @@ use crate::structures; use crate::to32; use crate::winapi::winapi32; use crate::winapi::winapi64; +use std::io::Write; +use std::num::ParseIntError; +use std::sync::atomic; // if the user types "r2 0x123" will execute radare2 -use std::process::{Command, Stdio}; +use crate::maps::mem64::Permission; use std::fs; use std::io; +use std::process::{Command, Stdio}; pub struct Console {} @@ -163,22 +164,25 @@ impl Console { } pub fn spawn_radare2(addr: u64, emu: &mut Emu) { - let mem = match emu.maps.get_mem_by_addr(addr) { Some(m) => m, None => { log::info!("address not found on any map"); - return + return; } }; let tmpfile = format!("/tmp/{}.r2", mem.get_name()); mem.save_all(&tmpfile); - let base = format!("0x{:x}",mem.get_base()); - let seek = format!("0x{:x}",addr); + let base = format!("0x{:x}", mem.get_base()); + let seek = format!("0x{:x}", addr); let bits; - if emu.cfg.is_64bits { bits = "64" } else { bits = "32" } + if emu.cfg.is_64bits { + bits = "64" + } else { + bits = "32" + } let precmd = format!("dr rax={}?; dr rbx={}?; dr rcx={}?; dr rdx={}?; dr rsi={}?; dr rdi={}?; dr rbp={}?; dr rsp={}?; dr rip={}?; dr r8={}? dr r9={}?; dr r10={}?; dr r11={}?; dr r12={}?; dr r13={}?; @@ -189,30 +193,25 @@ impl Console { emu.regs().r11, emu.regs().r12, emu.regs().r13, emu.regs().r14, emu.regs().r15); let r2args = vec![ - "-n", - "-a", "x86", - "-b", &bits, - "-m", &base, - "-s", &seek, - "-c", &precmd, - &tmpfile + "-n", "-a", "x86", "-b", &bits, "-m", &base, "-s", &seek, "-c", &precmd, &tmpfile, ]; log::info!("spawning radare2 software."); - + match Command::new("radare2") .args(&r2args) .stdin(Stdio::inherit()) .stdout(Stdio::inherit()) .stderr(Stdio::inherit()) - .spawn() { - Ok(mut child) => { - let _ = child.wait(); - } - Err(e) => { - log::error!("Install radare first! {}", e); - return - } + .spawn() + { + Ok(mut child) => { + let _ = child.wait(); + } + Err(e) => { + log::error!("Install radare first! {}", e); + return; + } } if let Err(e) = fs::remove_file(&tmpfile) { @@ -222,7 +221,6 @@ impl Console { } } - pub fn spawn_console(emu: &mut Emu) { if !emu.cfg.console_enabled { return; @@ -520,7 +518,7 @@ impl Console { } }; emu.maps - .create_map(&name, addr, sz) + .create_map(&name, addr, sz, Permission::READ_WRITE_EXECUTE) .expect("cannot create map from console mc"); log::info!("allocated {} at 0x{:x} sz: {}", name, addr, sz); } @@ -546,7 +544,7 @@ impl Console { }; emu.maps - .create_map(&name, addr, sz) + .create_map(&name, addr, sz, Permission::READ_WRITE_EXECUTE) .expect("cannot create map from console mca"); log::info!("allocated {} at 0x{:x} sz: {}", name, addr, sz); } @@ -578,7 +576,10 @@ impl Console { } }; - let mem = emu.maps.get_mem_by_addr(addr).expect("address not found on any map"); + let mem = emu + .maps + .get_mem_by_addr(addr) + .expect("address not found on any map"); if emu.cfg.is_64bits { log::info!( "map: {} 0x{:x}-0x{:x} ({})", @@ -1033,14 +1034,13 @@ impl Console { if parts.len() >= 2 { emu.maps.print_maps_keyword(&parts[1]); } - } else if cmd.starts_with("r2 ") { - let parts: Vec<&str> = cmd.split_whitespace().collect(); - if parts.len() >= 2 { - if let Ok(addr) = u64::from_str_radix(parts[1].trim_start_matches("0x"), 16) { - + let parts: Vec<&str> = cmd.split_whitespace().collect(); + if parts.len() >= 2 { + if let Ok(addr) = + u64::from_str_radix(parts[1].trim_start_matches("0x"), 16) + { Console::spawn_radare2(addr, emu); - } else { println!("wrong hexa parameter"); } @@ -1052,11 +1052,10 @@ impl Console { } } } // match commands - + if emu.cfg.command.is_some() { std::process::exit(1); } - } // end loop } // end commands function } diff --git a/crates/libmwemu/src/constants.rs b/crates/libmwemu/src/constants.rs index e631d020..b7a0e3f6 100644 --- a/crates/libmwemu/src/constants.rs +++ b/crates/libmwemu/src/constants.rs @@ -98,9 +98,8 @@ pub const INTERNET_FLAG_SECURE: u64 = 0x00800000; // exceptions pub const EXCEPTION_CONTINUE_EXECUTION32: u32 = 0xffffffff; pub const EXCEPTION_CONTINUE_EXECUTION64: u64 = 0xffffffff_ffffffff; -pub const EXCEPTION_CONTINUE_SEARCH: u32 = 0x00000000; -pub const EXCEPTION_EXECUTE_HANDLER: u32 = 0x00000001; - +pub const EXCEPTION_CONTINUE_SEARCH: u32 = 0x00000000; +pub const EXCEPTION_EXECUTE_HANDLER: u32 = 0x00000001; pub const ERROR_NO_MORE_FILES: u64 = 18; pub const CREATE_SUSPENDED: u64 = 0x00000004; @@ -119,7 +118,6 @@ pub const STATUS_READING_XMM_OPERAND: u32 = 0xE000000A; pub const STATUS_WRITING_XMM_OPERAND: u32 = 0xE000000B; pub const STATUS_READING_RIP: u32 = 0xE000000C; - pub const PAGE_NOACCESS: u32 = 0x01; pub const PAGE_EXECUTE: u32 = 0x00; pub const PAGE_READONLY: u32 = 0x02; diff --git a/crates/libmwemu/src/crit_state.rs b/crates/libmwemu/src/crit_state.rs index 170b0706..f1bbb66b 100644 --- a/crates/libmwemu/src/crit_state.rs +++ b/crates/libmwemu/src/crit_state.rs @@ -2,7 +2,7 @@ use std::collections::VecDeque; #[derive(Debug, Clone)] pub struct CritState { - pub owner_tid: Option, // Thread ID currently owning the lock - pub recursion_count: usize, // Recursive enter count - pub wait_queue: VecDeque, // Waiting thread IDs + pub owner_tid: Option, // Thread ID currently owning the lock + pub recursion_count: usize, // Recursive enter count + pub wait_queue: VecDeque, // Waiting thread IDs } diff --git a/crates/libmwemu/src/definitions.rs b/crates/libmwemu/src/definitions.rs index 6be73219..610e965c 100644 --- a/crates/libmwemu/src/definitions.rs +++ b/crates/libmwemu/src/definitions.rs @@ -42,21 +42,17 @@ where { let s: String = serde::Deserialize::deserialize(deserializer)?; if s.starts_with("0x") { - u64::from_str_radix(&s[2..], 16) - .map_err(|e| serde::de::Error::custom(e)) + u64::from_str_radix(&s[2..], 16).map_err(|e| serde::de::Error::custom(e)) } else { - s.parse::() - .map_err(|e| serde::de::Error::custom(e)) + s.parse::().map_err(|e| serde::de::Error::custom(e)) } } pub fn load_definitions(filename: &str) -> HashMap { - let contents = fs::read_to_string(filename) - .expect("Failed to read definitions file"); - - let definitions: Definitions = serde_yaml::from_str(&contents) - .expect("Failed to parse YAML"); - + let contents = fs::read_to_string(filename).expect("Failed to read definitions file"); + + let definitions: Definitions = serde_yaml::from_str(&contents).expect("Failed to parse YAML"); + let mut map = HashMap::new(); for def in definitions.events { map.insert(def.address, def); @@ -69,8 +65,13 @@ impl Emu { let rip = self.regs().rip; let definitions = &self.cfg.definitions; if let Some(definition) = definitions.get(&rip) { - log::info!("Event: {} (0x{:x}) - {}", definition.name, rip, definition.event_type); - + log::info!( + "Event: {} (0x{:x}) - {}", + definition.name, + rip, + definition.event_type + ); + // Store context if needed if let Some(context_name) = &definition.store_context { let mut context_values = HashMap::new(); @@ -78,9 +79,14 @@ impl Emu { let value = self.resolve_source(¶m.source); context_values.insert(param.name.clone(), value); } - self.stored_contexts.insert(context_name.clone(), StoredContext { values: context_values }); + self.stored_contexts.insert( + context_name.clone(), + StoredContext { + values: context_values, + }, + ); } - + // Display parameters for param in &definition.parameters { let value = self.resolve_source(¶m.source); @@ -89,10 +95,10 @@ impl Emu { } } } - + fn resolve_source(&self, source: &str) -> u64 { let parts: Vec<&str> = source.split(':').collect(); - + match parts[0] { "deref" => { // deref:context:context_name:param_name or deref:register @@ -128,7 +134,7 @@ impl Emu { } } } - + fn get_parameter_value(&self, source: &str) -> u64 { match source { "rcx" => self.regs().rcx, @@ -156,7 +162,7 @@ impl Emu { } } } - + fn format_parameter_value(&self, value: u64, param_type: &str) -> String { match param_type { "pointer" => format!("0x{:x}", value), @@ -176,4 +182,4 @@ impl Emu { _ => format!("0x{:x}", value), } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/elf/elf32.rs b/crates/libmwemu/src/elf/elf32.rs index e7af0b42..f028b1c2 100644 --- a/crates/libmwemu/src/elf/elf32.rs +++ b/crates/libmwemu/src/elf/elf32.rs @@ -1,6 +1,6 @@ use crate::constants; use crate::err::MwemuError; -use crate::maps::mem64::Mem64; +use crate::maps::mem64::{Mem64, Permission}; use crate::maps::Maps; use std::fs::File; use std::io::Read; @@ -93,6 +93,7 @@ impl Elf32 { &"code".to_string(), phdr.p_vaddr.into(), phdr.p_memsz.into(), + Permission::from_bits(phdr.p_flags as u8), ) .expect("cannot create code map from load_programs elf32"); if phdr.p_filesz > phdr.p_memsz { diff --git a/crates/libmwemu/src/elf/elf64.rs b/crates/libmwemu/src/elf/elf64.rs index 100fdede..c7373298 100644 --- a/crates/libmwemu/src/elf/elf64.rs +++ b/crates/libmwemu/src/elf/elf64.rs @@ -1,6 +1,6 @@ use crate::constants; use crate::err::MwemuError; -use crate::maps::mem64::Mem64; +use crate::maps::mem64::{Mem64, Permission}; use crate::maps::Maps; use std::fs::File; use std::io::Read; @@ -242,7 +242,6 @@ impl Elf64 { dynamic_linking: bool, force_base: u64, ) { - let elf64_base: u64; if dynamic_linking { @@ -257,7 +256,7 @@ impl Elf64 { // elf executable need to map the header. let hdr = maps - .create_map("elf64.hdr", elf64_base, 512) + .create_map("elf64.hdr", elf64_base, 512, Permission::READ_WRITE) .expect("cannot create elf64.hdr map"); hdr.write_bytes(elf64_base, &self.bin[..512]); } @@ -272,21 +271,29 @@ impl Elf64 { } } - // map sections - for i in 0..self.elf_shdr.len() { + // map sections, remember to skip section start from 0 because it is empty section + for i in 1..self.elf_shdr.len() { let sh_name = self.elf_shdr[i].sh_name; let sh_offset = self.elf_shdr[i].sh_offset; - let sh_size = self.elf_shdr[i].sh_size; + let sh_size = self.elf_shdr[i].sh_size; let mut sh_addr = self.elf_shdr[i].sh_addr; + let can_write = self.elf_shdr[i].sh_flags & 0x1 != 0; + let can_execute = self.elf_shdr[i].sh_flags & 0x4 != 0; + let can_read = self.elf_shdr[i].sh_flags & 0x2 != 0; + let permission = Permission::from_flags(can_read, can_write, can_execute); + //TODO: align sh_size to page size by extending the size, something like: //sh_size = ((sh_size + constants::ELF_PAGE_SIZE - 1) / constants::ELF_PAGE_SIZE) * constants::ELF_PAGE_SIZE; - let sname = self.get_section_name(sh_name as usize); //log::info!("loading elf64 section {}", sname); - if sname == ".comment" || sname.starts_with(".note") || sname == ".interp" || sname.starts_with(".gnu") { + if sname == ".comment" + || sname.starts_with(".note") + || sname == ".interp" + || sname.starts_with(".gnu") + { continue; } @@ -320,7 +327,6 @@ impl Elf64 { } } - // map if its vaddr is on a PT_LOAD program if self.is_loadable(sh_addr) || !dynamic_linking { if sname == ".shstrtab" || sname == ".tbss" { @@ -341,18 +347,18 @@ impl Elf64 { continue; } - let mem; if sh_addr < elf64_base { sh_addr += elf64_base; } - mem = match maps.create_map(&map_name, sh_addr, sh_size) { + mem = match maps.create_map(&map_name, sh_addr, sh_size, permission) { Ok(m) => m, Err(_) => { println!("elf64 {} overlappss 0x{:x} {}", map_name, sh_addr, sh_size); - sh_addr = maps.alloc(sh_size+10).expect("cannot allocate"); - maps.create_map(&map_name, sh_addr, sh_size).expect("cannot create map") + sh_addr = maps.alloc(sh_size + 10).expect("cannot allocate"); + maps.create_map(&map_name, sh_addr, sh_size, permission) + .expect("cannot create map") } }; @@ -366,13 +372,16 @@ impl Elf64 { continue; } if end_off as u64 - sh_offset > sh_size { - log::info!("no room at sh_size for all the data in the section, skipping {}", sname); + log::info!( + "no room at sh_size for all the data in the section, skipping {}", + sname + ); continue; } let segment = &self.bin[sh_offset as usize..end_off]; - mem.write_bytes(sh_addr, segment); - + mem.force_write_bytes(sh_addr, segment); + self.elf_shdr[i].sh_addr = sh_addr; } } diff --git a/crates/libmwemu/src/emu/banzai.rs b/crates/libmwemu/src/emu/banzai.rs index f5368c3e..8aabc80a 100644 --- a/crates/libmwemu/src/emu/banzai.rs +++ b/crates/libmwemu/src/emu/banzai.rs @@ -21,4 +21,4 @@ impl Emu { pub fn banzai_add(&mut self, name: &str, nparams: i32) { self.banzai.add(name, nparams); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/call_stack.rs b/crates/libmwemu/src/emu/call_stack.rs index 897f0f7b..ed2d44c2 100644 --- a/crates/libmwemu/src/emu/call_stack.rs +++ b/crates/libmwemu/src/emu/call_stack.rs @@ -1,11 +1,11 @@ use crate::emu::Emu; impl Emu { - pub fn call_stack(&self) -> &Vec { + pub fn call_stack(&self) -> &Vec<(u64, u64)> { &self.threads[self.current_thread_id].call_stack } - - pub fn call_stack_mut(&mut self) -> &mut Vec { + + pub fn call_stack_mut(&mut self) -> &mut Vec<(u64, u64)> { &mut self.threads[self.current_thread_id].call_stack } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/config.rs b/crates/libmwemu/src/emu/config.rs index 4945dda0..6a3a2c9c 100644 --- a/crates/libmwemu/src/emu/config.rs +++ b/crates/libmwemu/src/emu/config.rs @@ -33,5 +33,4 @@ impl Emu { } self.cfg.verbose = n; } - } diff --git a/crates/libmwemu/src/emu/console.rs b/crates/libmwemu/src/emu/console.rs index ae5f2e55..a529f8d3 100644 --- a/crates/libmwemu/src/emu/console.rs +++ b/crates/libmwemu/src/emu/console.rs @@ -11,8 +11,7 @@ impl Emu { self.enabled_ctrlc = false; } - - /// Disable the console mode, it will not be spawned automatically. + /// Disable the console mode, it will not be spawned automatically. pub fn disable_console(&mut self) { self.cfg.console_enabled = false; } @@ -22,7 +21,6 @@ impl Emu { self.cfg.console_enabled = true; } - /// Do spawn a console, for user interaction with the current emulation state. /// Command h for help. pub fn spawn_console(&mut self) { @@ -40,4 +38,4 @@ impl Emu { self.cfg.console_addr = addr; self.cfg.console_enabled = true; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/disassemble.rs b/crates/libmwemu/src/emu/disassemble.rs deleted file mode 100644 index 72a6b5b4..00000000 --- a/crates/libmwemu/src/emu/disassemble.rs +++ /dev/null @@ -1,37 +0,0 @@ -use iced_x86::{Decoder, DecoderOptions, Formatter as _, Instruction}; - -use crate::emu::Emu; - -impl Emu { - /// Disassemble an amount of instruccions on an specified address. - /// This not used on the emulation engine, just from console, - /// but the api could be used programatilcally. - pub fn disassemble(&mut self, addr: u64, amount: u32) -> String { - let mut out = String::new(); - let code = self.maps.get_mem_by_addr(addr).expect("address not mapped"); - let block = code.read_from(addr); - - let bits: u32 = if self.cfg.is_64bits { 64 } else { 32 }; - let mut decoder = Decoder::with_ip(bits, block, addr, DecoderOptions::NONE); - let mut output = String::new(); - let mut instruction = Instruction::default(); - let mut count: u32 = 1; - while decoder.can_decode() { - decoder.decode_out(&mut instruction); - output.clear(); - self.formatter.format(&instruction, &mut output); - if self.cfg.is_64bits { - out.push_str(&format!("0x{:x}: {}\n", instruction.ip(), output)); - //log::info!("0x{:x}: {}", instruction.ip(), output); - } else { - out.push_str(&format!("0x{:x}: {}\n", instruction.ip32(), output)); - //log::info!("0x{:x}: {}", instruction.ip32(), output); - } - count += 1; - if count == amount { - break; - } - } - out - } -} diff --git a/crates/libmwemu/src/emu/disassemble/mod.rs b/crates/libmwemu/src/emu/disassemble/mod.rs new file mode 100644 index 00000000..c4daec27 --- /dev/null +++ b/crates/libmwemu/src/emu/disassemble/mod.rs @@ -0,0 +1,254 @@ +use crate::emu::Emu; +use iced_x86::{Decoder, DecoderOptions, Formatter as _, Instruction}; +use serde::{Deserialize, Serialize}; + +// about 10 mb should be on l3 cache +// 8192 cache lines, +// 64 instructions for each one, +// 40 for the struct (I think we can make it smaller) +const INSTRUCTION_ARRAY_SIZE: usize = 8192 * 64; + +// we want the cache size to be store in L1 cache or L2 cache which is lower than 40kb +const CACHE_SIZE: usize = 2048 * MAX_CACHE_PER_LINE; +const CACHE_MASK: usize = CACHE_SIZE - 1; // Assumes power of 2 +const MAX_CACHE_PER_LINE: usize = 32; + +// we need INVALID_KEY and INVALID_LEN to be the same as INVALID_LPF_ADDR to optimize for memset +pub const INVALID_LPF_ADDR: u64 = 0xffffffffffffffff; +pub const INVALID_KEY: usize = 0xffffffffffffffff; +pub const INVALID_LEN: usize = 0xffffffffffffffff; + +pub fn LPF_OF(addr: u64) -> u64 { + // Implementation of LPF_OF macro/function + addr & 0xfffffffffffff000 +} + +#[derive(Clone, Serialize, Deserialize)] +struct CachedInstruction { + pub lpf: u64, + pub instruction_key: usize, + pub instruction_len: usize, +} + +impl Default for CachedInstruction { + fn default() -> Self { + CachedInstruction { + lpf: INVALID_LPF_ADDR, + instruction_key: INVALID_KEY, + instruction_len: INVALID_LEN, + } + } +} + +impl CachedInstruction { + pub fn is_valid(&self) -> bool { + self.lpf == INVALID_LPF_ADDR + } +} + +#[derive(Clone, Serialize, Deserialize)] +pub struct InstructionCache { + cache_entries: Vec, + instructions: Vec, + next_instruction_slot: usize, + pub current_instruction_slot: usize, + current_decode_len: usize, + current_decode_idx: usize, // probe_stats: ProbeStats, +} + +#[derive(Clone, Serialize, Deserialize, Default)] +struct ProbeStats { + hits: usize, + misses: usize, + collisions: usize, +} + +impl InstructionCache { + pub fn new() -> Self { + let mut cache = InstructionCache { + cache_entries: vec![CachedInstruction::default(); CACHE_SIZE], + instructions: vec![Instruction::default(); INSTRUCTION_ARRAY_SIZE], + next_instruction_slot: 0, + current_decode_len: 0, + current_instruction_slot: 0, + current_decode_idx: 0, + // probe_stats: ProbeStats::default(), + }; + + // Initialize all instructions to default state + for inst in &mut cache.instructions { + *inst = Instruction::default(); + } + + cache + } + + #[inline(always)] + pub fn get_index_of(&self, lpf: u64, len: u64) -> usize { + const TLB_MASK: u32 = ((CACHE_SIZE - 1) << 12) as u32; + (((lpf + len) & (TLB_MASK as u64)) >> 12) as usize + } + + #[inline] + pub fn flush_cache_line(&mut self, idx: usize) { + for i in 0..MAX_CACHE_PER_LINE { + self.cache_entries[idx].lpf = INVALID_LPF_ADDR; + } + } + + pub fn lookup_entry(&mut self, addr: u64, len: u64) -> bool { + let lpf = crate::maps::tlb::LPF_OF(addr); + let idx = self.get_index_of(lpf, len); + + // do a linear probing for each cache line + for i in 0..MAX_CACHE_PER_LINE { + if self.cache_entries[idx + i].lpf == INVALID_LPF_ADDR { + return false; + } + // found the instruction now do initialization and return true + if self.cache_entries[idx + i].lpf == addr { + let key = self.cache_entries[idx + i].instruction_key; + self.current_instruction_slot = key; + self.current_decode_len = self.cache_entries[idx + i].instruction_len; + self.current_decode_idx = 0; + return true; + } + } + + // the cache_line is full now we flush all the cache line + self.flush_cache_line(idx); + false + } + + #[inline(always)] + fn flush_cache(&mut self) { + self.cache_entries.iter_mut().for_each(|entry| { + entry.lpf = INVALID_LPF_ADDR; + entry.instruction_key = INVALID_KEY; + entry.instruction_len = INVALID_LEN; + }); + self.next_instruction_slot = 0; + } + + pub fn insert_from_decoder(&mut self, decoder: &mut Decoder, addition: usize, rip_addr: u64) { + let lpf = crate::maps::tlb::LPF_OF(rip_addr); + let idx = self.get_index_of(lpf, 0); + + // copy the instruction to the slot + // now the case when instruction slot is full, instead of complex algorithm + // we just fudge everything and rebuild from scratch can be a better way + // but I think this is simple and good enough + let slot = self.next_instruction_slot; + + let mut count: usize = 0; + let max_position = decoder.max_position(); + if max_position + self.next_instruction_slot > INSTRUCTION_ARRAY_SIZE { + self.flush_cache(); + } + + // we just need to decode until the call or jump instruction but not the entire one + while decoder.can_decode() && decoder.position() + addition <= max_position { + decoder.decode_out(&mut self.instructions[slot + count]); + let temp = self.instructions[slot + count]; + if temp.is_jmp_short_or_near() + || temp.is_jmp_near_indirect() + || temp.is_jmp_far() + || temp.is_jmp_far_indirect() + || temp.is_jcc_short_or_near() + || temp.is_call_near_indirect() + || temp.is_call_near() + || temp.is_call_far_indirect() + || temp.is_call_far() + { + count += 1; + break; + } + count += 1; + } + self.next_instruction_slot += count; + + // insert to the cache + for i in 0..MAX_CACHE_PER_LINE { + if self.cache_entries[idx + i].lpf == INVALID_LPF_ADDR { + self.cache_entries[idx + i].instruction_key = slot; + self.cache_entries[idx + i].lpf = rip_addr; + self.cache_entries[idx + i].instruction_len = count; + break; + } + } + + assert!(self.lookup_entry(rip_addr, 0), "Cache Insertion FAILED: There is support to be entry after insertion using insert_from_decoder"); + } + + pub fn insert_instruction(&mut self, addr: u64, instrs: Vec) { + let lpf = crate::maps::tlb::LPF_OF(addr); + let idx = self.get_index_of(lpf, 0); + + // copy the instruction to the slot + // now the case when instruction slot is full, instead of complex algorithm + // we just fudge everything and rebuild from scratch can be a better way + // but I think this is simple and good enough + let slot = self.next_instruction_slot; + self.next_instruction_slot += instrs.len(); + if self.next_instruction_slot >= INSTRUCTION_ARRAY_SIZE { + self.flush_cache(); + } + + for i in 0..instrs.len() { + self.instructions[slot + i] = instrs[i]; + } + + // insert to the cache + for i in 0..MAX_CACHE_PER_LINE { + if self.cache_entries[idx + i].lpf == INVALID_LPF_ADDR { + self.cache_entries[idx + i].instruction_key = slot; + self.cache_entries[idx + i].lpf = addr; + self.cache_entries[idx + i].instruction_len = instrs.len(); + break; + } + } + } + + pub fn decode_out(&mut self, instruction: &mut Instruction) { + *instruction = self.instructions[self.current_instruction_slot + self.current_decode_idx]; + self.current_decode_idx += 1; + } + + pub fn can_decode(&self) -> bool { + self.current_decode_idx < self.current_decode_len + } +} + +impl Emu { + /// Disassemble an amount of instruccions on an specified address. + /// This not used on the emulation engine, just from console, + /// but the api could be used programatilcally. + pub fn disassemble(&mut self, addr: u64, amount: u32) -> String { + let mut out = String::new(); + let code = self.maps.get_mem_by_addr(addr).expect("address not mapped"); + let block = code.read_from(addr); + + let bits: u32 = if self.cfg.is_64bits { 64 } else { 32 }; + let mut decoder = Decoder::with_ip(bits, block, addr, DecoderOptions::NONE); + let mut output = String::new(); + let mut instruction = Instruction::default(); + let mut count: u32 = 1; + while decoder.can_decode() { + decoder.decode_out(&mut instruction); + output.clear(); + self.formatter.format(&instruction, &mut output); + if self.cfg.is_64bits { + out.push_str(&format!("0x{:x}: {}\n", instruction.ip(), output)); + //log::info!("0x{:x}: {}", instruction.ip(), output); + } else { + out.push_str(&format!("0x{:x}: {}\n", instruction.ip32(), output)); + //log::info!("0x{:x}: {}", instruction.ip32(), output); + } + count += 1; + if count == amount { + break; + } + } + out + } +} diff --git a/crates/libmwemu/src/emu/display.rs b/crates/libmwemu/src/emu/display.rs index 10f80730..4a5e6c8a 100644 --- a/crates/libmwemu/src/emu/display.rs +++ b/crates/libmwemu/src/emu/display.rs @@ -36,7 +36,7 @@ impl Emu { self.regs().show_r14(&self.maps, 0); self.regs().show_r15(&self.maps, 0); } - + #[inline] pub fn show_instruction_comment(&mut self, color: &str, ins: &Instruction, comment: &str) { if self.cfg.verbose < 2 { @@ -46,13 +46,7 @@ impl Emu { self.formatter.format(ins, &mut out); if self.cfg.verbose >= 2 { if self.cfg.nocolors { - log::info!( - "{} 0x{:x}: {} ; {}", - self.pos, - ins.ip(), - out, - comment - ); + log::info!("{} 0x{:x}: {} ; {}", self.pos, ins.ip(), out, comment); } else { log::info!( "{}{} 0x{:x}: {} ; {}{}", @@ -77,12 +71,7 @@ impl Emu { self.formatter.format(ins, &mut out); if self.cfg.verbose >= 2 { if self.cfg.nocolors { - log::info!( - "{} 0x{:x}: {}", - self.pos, - ins.ip(), - out - ); + log::info!("{} 0x{:x}: {}", self.pos, ins.ip(), out); } else { log::info!( "{}{} 0x{:x}: {}{}", @@ -139,13 +128,7 @@ impl Emu { self.formatter.format(ins, &mut out); if self.cfg.verbose >= 2 { if self.cfg.nocolors { - log::info!( - "{} 0x{:x}: {} ;0x{:x}", - self.pos, - ins.ip(), - out, - value - ); + log::info!("{} 0x{:x}: {} ;0x{:x}", self.pos, ins.ip(), out, value); } else { log::info!( "{}{} 0x{:x}: {} ;0x{:x} {}", @@ -170,12 +153,7 @@ impl Emu { self.formatter.format(ins, &mut out); if self.cfg.verbose >= 2 { if self.cfg.nocolors { - log::info!( - "{} 0x{:x}: {} taken", - self.pos, - ins.ip(), - out - ); + log::info!("{} 0x{:x}: {} taken", self.pos, ins.ip(), out); } else { log::info!( "{}{} 0x{:x}: {} taken {}", @@ -198,12 +176,7 @@ impl Emu { self.formatter.format(ins, &mut out); if self.cfg.verbose >= 2 { if self.cfg.nocolors { - log::info!( - "{} 0x{:x}: {} not taken", - self.pos, - ins.ip(), - out - ); + log::info!("{} 0x{:x}: {} not taken", self.pos, ins.ip(), out); } else { log::info!( "{}{} 0x{:x}: {} not taken {}", diff --git a/crates/libmwemu/src/emu/exception_handlers.rs b/crates/libmwemu/src/emu/exception_handlers.rs index 71e83979..2a337988 100644 --- a/crates/libmwemu/src/emu/exception_handlers.rs +++ b/crates/libmwemu/src/emu/exception_handlers.rs @@ -4,23 +4,23 @@ impl Emu { pub fn veh(&self) -> u64 { self.threads[self.current_thread_id].veh } - + pub fn set_veh(&mut self, value: u64) { self.threads[self.current_thread_id].veh = value; } - + pub fn uef(&self) -> u64 { self.threads[self.current_thread_id].uef } - + pub fn set_uef(&mut self, value: u64) { self.threads[self.current_thread_id].uef = value; } - + pub fn eh_ctx(&self) -> u32 { self.threads[self.current_thread_id].eh_ctx } - + pub fn set_eh_ctx(&mut self, value: u32) { self.threads[self.current_thread_id].eh_ctx = value; } @@ -28,79 +28,77 @@ impl Emu { pub fn seh(&self) -> u64 { self.threads[self.current_thread_id].seh } - + pub fn set_seh(&mut self, value: u64) { self.threads[self.current_thread_id].seh = value; } - /// Trigger an exception. /// If it has to be handled initiate contex tand jump to the programmed error routine. /// Support SEH, VEH and UEF pub fn exception(&mut self, ex_type: ExceptionType) { /* - - If the handler return the search constant will jump to next handler in this order: - VEH -> SEH1 -> SEH2 -> ... -> SEHn -> UEF -> terminate process + If the handler return the search constant will jump to next handler in this order: + VEH -> SEH1 -> SEH2 -> ... -> SEHn -> UEF -> terminate process - unhandling: - VEH: - - the api RemoveVectoredExceptionHandler removes the handler - SEH: - - automatically when is triggered. SEH point to next SEH. - UEF: - - SetUnhandledExceptionFilter + unhandling: + VEH: + - the api RemoveVectoredExceptionHandler removes the handler + SEH: + - automatically when is triggered. SEH point to next SEH. + UEF: + - SetUnhandledExceptionFilter - Responses: - VEH: - - EXCEPTION_CONTINUE_EXECUTION (continue to eip/rip which could be modified) - - EXCEPTION_CONTINUE_SEARCH (jump to next handler SEH -> UEF -> end proces) + Responses: - SEH: - - EXCEPTION_CONTINUE_EXECUTION (continue and not jump to except) - - EXCEPTION_CONTINUE_SEARCH (jump to next handler SEH -> UEF -> end process) - - EXCEPTION_EXECUTE_HANDLER (jump to except) + VEH: + - EXCEPTION_CONTINUE_EXECUTION (continue to eip/rip which could be modified) + - EXCEPTION_CONTINUE_SEARCH (jump to next handler SEH -> UEF -> end proces) - UEF: - - EXCEPTION_CONTINUE_EXECUTION (continue to eip/rip which could be modified) - - EXCEPTION_CONTINUE_SEARCH (end process) + SEH: + - EXCEPTION_CONTINUE_EXECUTION (continue and not jump to except) + - EXCEPTION_CONTINUE_SEARCH (jump to next handler SEH -> UEF -> end process) + - EXCEPTION_EXECUTE_HANDLER (jump to except) - 64bits SEH: - - is not a stack chain - - search RUNTIME_FUNCTION entry in the .pdata table using BeginAddress ≤ RIP < EndAddress - - in that entry there is the RVA of UNWIND_INFO struct on the .xdata + UEF: + - EXCEPTION_CONTINUE_EXECUTION (continue to eip/rip which could be modified) + - EXCEPTION_CONTINUE_SEARCH (end process) + 64bits SEH: + - is not a stack chain + - search RUNTIME_FUNCTION entry in the .pdata table using BeginAddress ≤ RIP < EndAddress + - in that entry there is the RVA of UNWIND_INFO struct on the .xdata - - at .pdata, 12 bytes of runtime entries: - typedef struct _RUNTIME_FUNCTION { - DWORD BeginAddress; - DWORD EndAddress; - DWORD UnwindInfo; // RVA to UNWIND_INFO at .xdata - } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION; + - at .pdata, 12 bytes of runtime entries: - - unwind info in the .xdata: + typedef struct _RUNTIME_FUNCTION { + DWORD BeginAddress; + DWORD EndAddress; + DWORD UnwindInfo; // RVA to UNWIND_INFO at .xdata + } RUNTIME_FUNCTION, *PRUNTIME_FUNCTION; - typedef struct _UNWIND_INFO { - UBYTE Version : 3; // always 1 - UBYTE Flags : 5; // 0, EHANDLER, UHANDLER, etc. - UBYTE SizeOfProlog; - UBYTE CountOfCodes; // Nº of UNWIND_CODE - UBYTE FrameRegister : 4; // (ie. RBP=5) - UBYTE FrameOffset : 4; // frame scale - UNWIND_CODE UnwindCode[]; // descriptors - // opcional: - // DWORD ExceptionHandler; // RVA to handler if Flags indicate it - // DWORD ExceptionData[]; // extra data for handler - } UNWIND_INFO, *PUNWIND_INFO; + - unwind info in the .xdata: - - */ + typedef struct _UNWIND_INFO { + UBYTE Version : 3; // always 1 + UBYTE Flags : 5; // 0, EHANDLER, UHANDLER, etc. + UBYTE SizeOfProlog; + UBYTE CountOfCodes; // Nº of UNWIND_CODE + UBYTE FrameRegister : 4; // (ie. RBP=5) + UBYTE FrameOffset : 4; // frame scale + UNWIND_CODE UnwindCode[]; // descriptors + // opcional: + // DWORD ExceptionHandler; // RVA to handler if Flags indicate it + // DWORD ExceptionData[]; // extra data for handler + } UNWIND_INFO, *PUNWIND_INFO; + */ + let addr: u64; let next: u64; @@ -112,12 +110,12 @@ impl Emu { // No handled exceptions if self.seh() == 0 && self.veh() == 0 && self.uef() == 0 { - log::info!( - "exception without any SEH handler nor vector configured. pos = {} rip = {:x}", - self.pos, - self.regs().rip - ); - return; + log::info!( + "exception without any SEH handler nor vector configured. pos = {} rip = {:x}", + self.pos, + self.regs().rip + ); + return; } // hook replaced handler @@ -140,14 +138,11 @@ impl Emu { // SEH } else if self.seh() > 0 { - if self.cfg.is_64bits { // 64bits seh - + unimplemented!("check .pdata if exists"); - } else { - // 32bits seh next = match self.maps.read_dword(self.seh()) { Some(value) => value.into(), @@ -176,7 +171,7 @@ impl Emu { self.set_eip(addr, false); } return; - } + } con.print("jump the exception pointer (y/n)?"); let cmd = con.cmd(); @@ -189,11 +184,9 @@ impl Emu { self.set_eip(addr, false); } } - - } else if self.uef() > 0 { // UEF - + addr = self.uef(); exception::enter(self, ex_type); @@ -202,10 +195,8 @@ impl Emu { } else { self.set_eip(addr, false); } - } else { unreachable!(); } } - } diff --git a/crates/libmwemu/src/emu/execution.rs b/crates/libmwemu/src/emu/execution.rs index 3b05b36a..48595b29 100644 --- a/crates/libmwemu/src/emu/execution.rs +++ b/crates/libmwemu/src/emu/execution.rs @@ -4,6 +4,7 @@ use std::sync::{atomic, Arc}; use iced_x86::{Code, Decoder, DecoderOptions, Formatter as _, Instruction, Mnemonic}; use crate::console::Console; +use crate::emu::disassemble::InstructionCache; use crate::emu::Emu; use crate::err::MwemuError; use crate::{constants, engine, serialization}; @@ -109,8 +110,6 @@ impl Emu { } } - - pub fn update_entropy(&mut self) { let prev_entropy = self.entropy; @@ -119,7 +118,13 @@ impl Emu { None => { self.entropy = 0.0; if self.entropy != prev_entropy { - log::info!("{}:0x{:x} entropy changed {} -> {}", self.pos, self.regs().rip, prev_entropy, self.entropy); + log::info!( + "{}:0x{:x} entropy changed {} -> {}", + self.pos, + self.regs().rip, + prev_entropy, + self.entropy + ); } return; } @@ -130,7 +135,13 @@ impl Emu { if data.is_empty() { self.entropy = 0.0; if self.entropy != prev_entropy { - log::info!("{}:0x{:x} entropy changed {} -> {}", self.pos, self.regs().rip, prev_entropy, self.entropy); + log::info!( + "{}:0x{:x} entropy changed {} -> {}", + self.pos, + self.regs().rip, + prev_entropy, + self.entropy + ); } return; } @@ -140,28 +151,39 @@ impl Emu { counts[b as usize] += 1; } let len = data.len() as f64; - self.entropy = round_to!(counts - .iter() - .filter(|&&c| c > 0) - .map(|&c| { - let p = c as f64 / len; - -p * p.log2() - }) - .sum::(), 3); + self.entropy = round_to!( + counts + .iter() + .filter(|&&c| c > 0) + .map(|&c| { + let p = c as f64 / len; + -p * p.log2() + }) + .sum::(), + 3 + ); if self.entropy != prev_entropy { - log::info!("{}:0x{:x} entropy changed {} -> {}", self.pos, self.regs().rip, prev_entropy, self.entropy); + log::info!( + "{}:0x{:x} entropy changed {} -> {}", + self.pos, + self.regs().rip, + prev_entropy, + self.entropy + ); } } - /// Emulate a single step from the current point (single-threaded implementation). /// this don't reset the emu.pos, that mark the number of emulated instructions and point to - /// the current emulation moment. + /// the current emulation moment. /// If you do a loop with emu.step() will have more control of the emulator but it will be /// slow. /// Is more convinient using run and run_to or even setting breakpoints. - #[deprecated(since = "0.1.0", note = "Use step() instead, which automatically handles threading")] + #[deprecated( + since = "0.1.0", + note = "Use step() instead, which automatically handles threading" + )] pub fn step_single_threaded(&mut self) -> bool { self.pos += 1; @@ -265,11 +287,14 @@ impl Emu { /// Emulate a single step from the current point (multi-threaded implementation). /// this don't reset the emu.pos, that mark the number of emulated instructions and point to - /// the current emulation moment. + /// the current emulation moment. /// If you do a loop with emu.step() will have more control of the emulator but it will be /// slow. /// Is more convinient using run and run_to or even setting breakpoints. - #[deprecated(since = "0.1.0", note = "Use step() instead, which automatically handles threading")] + #[deprecated( + since = "0.1.0", + note = "Use step() instead, which automatically handles threading" + )] pub fn step_multi_threaded(&mut self) -> bool { self.pos += 1; @@ -298,13 +323,13 @@ impl Emu { // Thread scheduling - find next runnable thread let num_threads = self.threads.len(); let current_tick = self.tick; - + // Debug logging for threading if num_threads > 1 { /*log::info!("=== THREAD SCHEDULER DEBUG ==="); - log::info!("Step {}: {} threads, current_thread_id={}, tick={}", + log::info!("Step {}: {} threads, current_thread_id={}, tick={}", self.pos, num_threads, self.current_thread_id, current_tick); - + for (i, thread) in self.threads.iter().enumerate() { let status = if thread.suspended { "SUSPENDED".to_string() @@ -315,57 +340,63 @@ impl Emu { } else { "RUNNABLE".to_string() }; - + let marker = if i == self.current_thread_id { ">>> " } else { " " }; - log::info!("{}Thread[{}]: ID=0x{:x}, RIP=0x{:x}, Status={}", + log::info!("{}Thread[{}]: ID=0x{:x}, RIP=0x{:x}, Status={}", marker, i, thread.id, thread.regs.rip, status); }*/ } - + // Check if current thread can run let current_can_run = !self.threads[self.current_thread_id].suspended && self.threads[self.current_thread_id].wake_tick <= current_tick && self.threads[self.current_thread_id].blocked_on_cs.is_none(); - + if num_threads > 1 { //log::debug!("Current thread {} can run: {}", self.current_thread_id, current_can_run); - + // Round-robin scheduling: try each thread starting from next one for i in 0..num_threads { let thread_idx = (self.current_thread_id + i + 1) % num_threads; let thread = &self.threads[thread_idx]; - - /*log::debug!("Checking thread {}: suspended={}, wake_tick={}, blocked={}", - thread_idx, thread.suspended, thread.wake_tick, - thread.blocked_on_cs.is_some());*/ - + + /*log::debug!("Checking thread {}: suspended={}, wake_tick={}, blocked={}", + thread_idx, thread.suspended, thread.wake_tick, + thread.blocked_on_cs.is_some());*/ + // Check if thread is runnable - if !thread.suspended + if !thread.suspended && thread.wake_tick <= current_tick - && thread.blocked_on_cs.is_none() { + && thread.blocked_on_cs.is_none() + { // Found a runnable thread, execute it if thread_idx != self.current_thread_id { - /*log::info!("🔄 THREAD SWITCH: {} -> {} (step {})", + /*log::info!("🔄 THREAD SWITCH: {} -> {} (step {})", self.current_thread_id, thread_idx, self.pos); - log::info!(" From RIP: 0x{:x} -> To RIP: 0x{:x}", + log::info!(" From RIP: 0x{:x} -> To RIP: 0x{:x}", self.threads[self.current_thread_id].regs.rip, thread.regs.rip);*/ } - return crate::threading::ThreadScheduler::execute_thread_instruction(self, thread_idx); + return crate::threading::ThreadScheduler::execute_thread_instruction( + self, thread_idx, + ); } } - + log::debug!("No other threads runnable, checking current thread"); } - + // If no other threads are runnable, try current thread if current_can_run { /*if num_threads > 1 { log::debug!("Continuing with current thread {}", self.current_thread_id); }*/ - return crate::threading::ThreadScheduler::execute_thread_instruction(self, self.current_thread_id); + return crate::threading::ThreadScheduler::execute_thread_instruction( + self, + self.current_thread_id, + ); } - + // All threads are blocked or suspended - advance time to next wake point let mut next_wake = usize::MAX; for thread in &self.threads { @@ -373,32 +404,41 @@ impl Emu { next_wake = next_wake.min(thread.wake_tick); } } - + if next_wake != usize::MAX && next_wake > current_tick { // Advance time to next wake point self.tick = next_wake; - log::info!("⏰ All threads blocked, advancing tick from {} to {}", current_tick, next_wake); + log::info!( + "⏰ All threads blocked, advancing tick from {} to {}", + current_tick, + next_wake + ); // Try scheduling again return self.step(); } - + // All threads are permanently blocked or suspended log::info!("💀 All threads are blocked/suspended, cannot continue execution"); if num_threads > 1 { log::info!("Final thread states:"); for (i, thread) in self.threads.iter().enumerate() { - log::info!(" Thread[{}]: ID=0x{:x}, suspended={}, wake_tick={}, blocked={}", - i, thread.id, thread.suspended, thread.wake_tick, - thread.blocked_on_cs.is_some()); + log::info!( + " Thread[{}]: ID=0x{:x}, suspended={}, wake_tick={}, blocked={}", + i, + thread.id, + thread.suspended, + thread.wake_tick, + thread.blocked_on_cs.is_some() + ); } } false } /// Run until a specific position (emu.pos) - /// This don't reset the emu.pos, will meulate from current position to + /// This don't reset the emu.pos, will meulate from current position to /// selected end_pos included. - pub fn run_to(&mut self, end_pos:u64) -> Result { + pub fn run_to(&mut self, end_pos: u64) -> Result { self.max_pos = Some(end_pos); let r = self.run(None); self.max_pos = None; @@ -412,6 +452,8 @@ impl Emu { /// Automatically dispatches to single or multi-threaded execution based on cfg.enable_threading. #[allow(deprecated)] pub fn run(&mut self, end_addr: Option) -> Result { + let instruction_cache = InstructionCache::new(); + self.instruction_cache = instruction_cache; if self.cfg.enable_threading && self.threads.len() > 1 { self.run_multi_threaded(end_addr) } else { @@ -423,7 +465,10 @@ impl Emu { /// For emulating forever: run(None) /// For emulating until an address: run(Some(0x11223344)) /// self.pos is not set to zero, can be used to continue emulation. - #[deprecated(since = "0.1.0", note = "Use run() instead, which automatically handles threading")] + #[deprecated( + since = "0.1.0", + note = "Use run() instead, which automatically handles threading" + )] pub fn run_multi_threaded(&mut self, end_addr: Option) -> Result { todo!() } // end run @@ -432,18 +477,22 @@ impl Emu { /// For emulating forever: run(None) /// For emulating until an address: run(Some(0x11223344)) /// self.pos is not set to zero, can be used to continue emulation. - #[deprecated(since = "0.1.0", note = "Use run() instead, which automatically handles threading")] + #[deprecated( + since = "0.1.0", + note = "Use run() instead, which automatically handles threading" + )] pub fn run_single_threaded(&mut self, end_addr: Option) -> Result { //self.stack_lvl.clear(); //self.stack_lvl_idx = 0; //self.stack_lvl.push(0); - + match self.maps.get_mem_by_addr(self.regs().rip) { - Some(mem) => { - } + Some(mem) => {} None => { log::info!("Cannot start emulation, pc pointing to unmapped area"); - return Err(MwemuError::new("program counter pointing to unmapped memory")) + return Err(MwemuError::new( + "program counter pointing to unmapped memory", + )); } }; @@ -479,6 +528,7 @@ impl Emu { // the need of Reallocate everytime let mut block: Vec = Vec::with_capacity(constants::BLOCK_LEN + 1); block.resize(constants::BLOCK_LEN, 0x0); + self.instruction_cache = InstructionCache::new(); loop { while self.is_running.load(atomic::Ordering::Relaxed) == 1 { //log::info!("reloading rip 0x{:x}", self.regs().rip); @@ -487,37 +537,43 @@ impl Emu { let code = match self.maps.get_mem_by_addr(rip) { Some(c) => c, None => { - log::info!( - "redirecting code flow to non mapped address 0x{:x}", - rip - ); + log::info!("redirecting code flow to non mapped address 0x{:x}", rip); Console::spawn_console(self); return Err(MwemuError::new("cannot read program counter")); } }; - // we just need to read 0x300 bytes because x86 require that the instruction is 16 bytes long - // reading anymore would be a waste of time - let block_sz = constants::BLOCK_LEN; - let block_temp = code.read_bytes(rip, block_sz); - let block_temp_len = block_temp.len(); - if block_temp_len != block.len() { - block.resize(block_temp_len, 0); + if !self.instruction_cache.lookup_entry(rip, 0) { + // we just need to read 0x300 bytes because x86 require that the instruction is 16 bytes long + // reading anymore would be a waste of time + let block_sz = constants::BLOCK_LEN; + let block_temp = code.read_bytes(rip, block_sz); + let block_temp_len = block_temp.len(); + if block_temp_len != block.len() { + block.resize(block_temp_len, 0); + } + block.clone_from_slice(block_temp); + if block.len() == 0 { + return Err(MwemuError::new("cannot read code block, weird address.")); + } + let mut decoder = + Decoder::with_ip(arch, &block, self.regs().rip, DecoderOptions::NONE); + + self.rep = None; + let addition = if block_temp_len < 16 { + block_temp_len + } else { + 16 + }; + self.instruction_cache + .insert_from_decoder(&mut decoder, addition, rip); } - block.clone_from_slice(block_temp); - if block.len() == 0 { - return Err(MwemuError::new("cannot read code block, weird address.")); - } - let mut decoder = - Decoder::with_ip(arch, &block, self.regs().rip, DecoderOptions::NONE); - let mut sz: usize = 0; - let mut addr: u64 = 0; - - self.rep = None; - let addition = if block_temp_len < 16 {block_temp_len} else {16}; - while decoder.can_decode() && (decoder.position() + addition <= decoder.max_position()) { + + let mut sz = 0; + let mut addr = 0; + while self.instruction_cache.can_decode() { if self.rep.is_none() { - decoder.decode_out(&mut ins); + self.instruction_cache.decode_out(&mut ins); sz = ins.len(); addr = ins.ip(); @@ -531,7 +587,7 @@ impl Emu { } self.instruction = Some(ins); - self.decoder_position = decoder.position(); + self.decoder_position = self.instruction_cache.current_instruction_slot; self.memory_operations.clear(); self.pos += 1; @@ -624,7 +680,10 @@ impl Emu { } } - if self.cfg.trace_regs && self.cfg.trace_filename.is_some() && self.pos >= self.cfg.trace_start { + if self.cfg.trace_regs + && self.cfg.trace_filename.is_some() + && self.pos >= self.cfg.trace_start + { self.capture_pre_op(); } @@ -660,10 +719,12 @@ impl Emu { let is_ret = match ins.code() { Code::Retnw | Code::Retnd | Code::Retnq => true, - _ => false + _ => false, }; - if !is_ret && (ins.has_rep_prefix() || ins.has_repe_prefix() || ins.has_repne_prefix()) { + if !is_ret + && (ins.has_rep_prefix() || ins.has_repe_prefix() || ins.has_repne_prefix()) + { if self.rep.is_none() { self.rep = Some(0); } @@ -687,7 +748,6 @@ impl Emu { } } - /*************************************/ let emulation_ok = engine::emulate_instruction(self, &ins, sz, false); //tracing::trace_instruction(self, self.pos); @@ -756,7 +816,10 @@ impl Emu { self.trace_memory_inspection(); } - if self.cfg.trace_regs && self.cfg.trace_filename.is_some() && self.pos >= self.cfg.trace_start { + if self.cfg.trace_regs + && self.cfg.trace_filename.is_some() + && self.pos >= self.cfg.trace_start + { self.capture_post_op(); self.write_to_trace_file(); } @@ -770,7 +833,8 @@ impl Emu { } else { return Err(MwemuError::new(&format!( "emulation error at pos = {} rip = 0x{:x}", - self.pos, self.regs().rip + self.pos, + self.regs().rip ))); } } @@ -795,12 +859,10 @@ impl Emu { break; } } // end decoder loop - } // end running loop - + self.is_running.store(1, atomic::Ordering::Relaxed); Console::spawn_console(self); } // end infinite loop } // end run { - } diff --git a/crates/libmwemu/src/emu/flags.rs b/crates/libmwemu/src/emu/flags.rs index d3a51de3..4dc547fa 100644 --- a/crates/libmwemu/src/emu/flags.rs +++ b/crates/libmwemu/src/emu/flags.rs @@ -4,40 +4,40 @@ impl Emu { pub fn pre_op_flags(&self) -> &Flags { &self.threads[self.current_thread_id].pre_op_flags } - + pub fn pre_op_flags_mut(&mut self) -> &mut Flags { &mut self.threads[self.current_thread_id].pre_op_flags } - + pub fn post_op_flags(&self) -> &Flags { &self.threads[self.current_thread_id].post_op_flags } - + pub fn post_op_flags_mut(&mut self) -> &mut Flags { &mut self.threads[self.current_thread_id].post_op_flags } - + pub fn eflags(&self) -> &Eflags { &self.threads[self.current_thread_id].eflags } - + pub fn eflags_mut(&mut self) -> &mut Eflags { &mut self.threads[self.current_thread_id].eflags } - + pub fn set_pre_op_flags(&mut self, flags: Flags) { self.threads[self.current_thread_id].pre_op_flags = flags; } - + pub fn set_post_op_flags(&mut self, flags: Flags) { self.threads[self.current_thread_id].post_op_flags = flags; } - + pub fn flags(&self) -> &Flags { &self.threads[self.current_thread_id].flags } - + pub fn flags_mut(&mut self) -> &mut Flags { &mut self.threads[self.current_thread_id].flags } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/fls.rs b/crates/libmwemu/src/emu/fls.rs index 0700635d..c6c2147a 100644 --- a/crates/libmwemu/src/emu/fls.rs +++ b/crates/libmwemu/src/emu/fls.rs @@ -4,9 +4,8 @@ impl Emu { pub fn fls(&self) -> &Vec { &self.threads[self.current_thread_id].fls } - + pub fn fls_mut(&mut self) -> &mut Vec { &mut self.threads[self.current_thread_id].fls } - -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/fpu.rs b/crates/libmwemu/src/emu/fpu.rs index 4247e300..57d677a8 100644 --- a/crates/libmwemu/src/emu/fpu.rs +++ b/crates/libmwemu/src/emu/fpu.rs @@ -1,17 +1,17 @@ use crate::{emu::Emu, fpu::FPU}; impl Emu { - // Helper method to sync FPU instruction pointer with RIP + // Helper method to sync FPU instruction pointer with RIP pub fn sync_fpu_ip(&mut self) { let rip = self.threads[self.current_thread_id].regs.rip; self.threads[self.current_thread_id].fpu.set_ip(rip); } - + pub fn fpu(&self) -> &FPU { &self.threads[self.current_thread_id].fpu } - + pub fn fpu_mut(&mut self) -> &mut FPU { &mut self.threads[self.current_thread_id].fpu } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/fs.rs b/crates/libmwemu/src/emu/fs.rs index a0390969..7261a391 100644 --- a/crates/libmwemu/src/emu/fs.rs +++ b/crates/libmwemu/src/emu/fs.rs @@ -6,7 +6,7 @@ impl Emu { pub fn fs(&self) -> &BTreeMap { &self.threads[self.current_thread_id].fs } - + pub fn fs_mut(&mut self) -> &mut BTreeMap { &mut self.threads[self.current_thread_id].fs } diff --git a/crates/libmwemu/src/emu/initialization.rs b/crates/libmwemu/src/emu/initialization.rs index 514f459a..32772648 100644 --- a/crates/libmwemu/src/emu/initialization.rs +++ b/crates/libmwemu/src/emu/initialization.rs @@ -9,10 +9,15 @@ use csv::ReaderBuilder; use iced_x86::{Formatter as _, IntelFormatter}; use crate::console::Console; +use crate::emu::disassemble::InstructionCache; use crate::emu::Emu; +use crate::maps::mem64::Permission; use crate::peb::{peb32, peb64}; +use crate::{ + banzai::Banzai, breakpoint::Breakpoints, colors::Colors, config::Config, + global_locks::GlobalLocks, hooks::Hooks, maps::Maps, thread_context::ThreadContext, +}; use crate::{get_bit, kuser_shared, set_bit, structures, winapi::winapi32, winapi::winapi64}; -use crate::{banzai::Banzai, breakpoint::Breakpoints, colors::Colors, config::Config, global_locks::GlobalLocks, hooks::Hooks, maps::Maps, thread_context::ThreadContext}; use fast_log::appender::{Command, FastLogRecord, RecordFormat}; @@ -33,7 +38,6 @@ impl CustomLogFormat { pub fn new() -> CustomLogFormat { Self {} } - } impl Emu { @@ -86,16 +90,16 @@ impl Emu { threads: vec![ThreadContext::new(0x1000)], current_thread_id: 0, global_locks: GlobalLocks::new(), + instruction_cache: InstructionCache::new(), definitions: HashMap::new(), stored_contexts: HashMap::new(), entropy: 0.0, } } - /// This inits the 32bits stack, it's called from init_cpu() and init() pub fn init_stack32(&mut self) { - // default if not set via clap args + // default if not set via clap args if self.cfg.stack_addr == 0 { self.cfg.stack_addr = 0x212000; let esp = self.cfg.stack_addr + 0x1c000 + 4; @@ -110,7 +114,12 @@ impl Emu { let stack = self .maps - .create_map("stack", self.cfg.stack_addr, 0x030000) + .create_map( + "stack", + self.cfg.stack_addr, + 0x030000, + Permission::READ_WRITE, + ) .expect("cannot create stack map"); let stack_base = stack.get_base(); let stack_bottom = stack.get_bottom(); @@ -144,7 +153,12 @@ impl Emu { // Add extra buffer beyond rbp to ensure it's strictly less than bottom let stack = self .maps - .create_map("stack", self.cfg.stack_addr, stack_size + 0x2000) // Increased size + .create_map( + "stack", + self.cfg.stack_addr, + stack_size + 0x2000, + Permission::READ_WRITE, + ) // Increased size .expect("cannot create stack map"); let stack_base = stack.get_base(); let stack_bottom = stack.get_bottom(); @@ -202,10 +216,13 @@ impl Emu { } pub fn init_logger(&mut self) { - fast_log::init(fast_log::Config::new() - .format(CustomLogFormat::new()) - .console() - .chan_len(Some(100000))).unwrap(); + fast_log::init( + fast_log::Config::new() + .format(CustomLogFormat::new()) + .console() + .chan_len(Some(100000)), + ) + .unwrap(); } /// Initialize windows simulator, this does like init_cpu() but also setup the windows memory. @@ -292,27 +309,42 @@ impl Emu { //self.regs_mut().rsp = 0x7fffffffe2b0; self.regs_mut().rsp = 0x7fffffffe790; self.maps - .create_map("linux_dynamic_stack", 0x7ffffffde000, 0x100000) + .create_map( + "linux_dynamic_stack", + 0x7ffffffde000, + 0x100000, + Permission::READ_WRITE, + ) .expect("cannot create linux_dynamic_stack map"); //self.maps.create_map("dso_dyn").load_at(0x7ffff7ffd0000); self.maps - .create_map("dso_dyn", 0x7ffff7ffd000, 0x1000) + .create_map("dso_dyn", 0x7ffff7ffd000, 0x1000, Permission::READ_WRITE) .expect("cannot create dso_dyn map"); self.maps - .create_map("linker", 0x7ffff7ffd000-0x1000-0x10000, 0x10000) + .create_map( + "linker", + 0x7ffff7ffd000 - 0x1000 - 0x10000, + 0x10000, + Permission::READ_WRITE, + ) .expect("cannot create linker map"); } else { self.regs_mut().rsp = 0x7fffffffe270; self.maps - .create_map("linux_static_stack", 0x7ffffffde000, 0x100000) + .create_map( + "linux_static_stack", + 0x7ffffffde000, + 0x100000, + Permission::READ_WRITE, + ) .expect("cannot create linux_static_stack map"); self.maps - .create_map("dso", 0x7ffff7ffd000, 0x100000) + .create_map("dso", 0x7ffff7ffd000, 0x100000, Permission::READ_WRITE) .expect("cannot create dso map"); } let tls = self .maps - .create_map("tls", 0x7ffff8fff000, 0xfff) + .create_map("tls", 0x7ffff8fff000, 0xfff, Permission::READ_WRITE) .expect("cannot create tls map"); tls.load("tls.bin"); @@ -325,7 +357,7 @@ impl Emu { self.heap_addr = self.maps.alloc(heap_sz).expect("cannot allocate heap"); let heap = self .maps - .create_map("heap", self.heap_addr, heap_sz) //.create_map("heap", 0x4b5b00, 0x4d8000 - 0x4b5000) + .create_map("heap", self.heap_addr, heap_sz, Permission::READ_WRITE) //.create_map("heap", 0x4b5b00, 0x4d8000 - 0x4b5000) .expect("cannot create heap map"); heap.load("heap.bin"); } @@ -344,7 +376,6 @@ impl Emu { pub fn init_mem32(&mut self) { log::info!("loading memory maps"); - let orig_path = std::env::current_dir().unwrap(); std::env::set_current_dir(self.cfg.maps_folder.clone()); @@ -372,7 +403,7 @@ impl Emu { //winapi32::kernel32::load_library(self, "dnsapi.dll"); winapi32::kernel32::load_library(self, "shell32.dll"); //winapi32::kernel32::load_library(self, "shlwapi.dll"); - + let teb_map = self.maps.get_mem_mut("teb"); let mut teb = structures::TEB::load_map(teb_map.get_base(), teb_map); teb.nt_tib.stack_base = self.cfg.stack_addr as u32; @@ -384,7 +415,7 @@ impl Emu { pub fn init_tests(&mut self) { let mem = self .maps - .create_map("test", 0, 1024) + .create_map("test", 0, 1024, Permission::READ_WRITE_EXECUTE) .expect("cannot create test map"); mem.write_qword(0, 0x1122334455667788); assert!(mem.read_qword(0) == 0x1122334455667788); diff --git a/crates/libmwemu/src/emu/instruction_pointer.rs b/crates/libmwemu/src/emu/instruction_pointer.rs index e0c1261d..f8f6e951 100644 --- a/crates/libmwemu/src/emu/instruction_pointer.rs +++ b/crates/libmwemu/src/emu/instruction_pointer.rs @@ -1,4 +1,7 @@ -use crate::{console::Console, constants, emu::Emu, exception_type::ExceptionType, to32, winapi::winapi32, winapi::winapi64}; +use crate::{ + console::Console, constants, emu::Emu, exception_type::ExceptionType, to32, winapi::winapi32, + winapi::winapi64, +}; impl Emu { /// Redirect execution flow on 64bits. @@ -28,7 +31,11 @@ impl Emu { self.force_break = true; return true; } else { - log::error!("/!\\ set_rip setting rip to non mapped addr 0x{:x} {}", addr, self.filename); + log::error!( + "/!\\ set_rip setting rip to non mapped addr 0x{:x} {}", + addr, + self.filename + ); self.exception(ExceptionType::SettingRipToNonMappedAddr); return false; } @@ -76,7 +83,10 @@ impl Emu { }; if handle_winapi { - let name = self.maps.get_addr_name(addr).expect("/!\\ changing RIP to non mapped addr 0x"); + let name = self + .maps + .get_addr_name(addr) + .expect("/!\\ changing RIP to non mapped addr 0x"); winapi64::gateway(addr, name.to_string().as_str(), self); } self.force_break = true; @@ -136,7 +146,6 @@ impl Emu { log::info!("{}:0x{:x} map change {} -> {}", self.pos, eip, prev, name); } } - self.regs_mut().set_eip(addr); } else { diff --git a/crates/libmwemu/src/emu/loaders.rs b/crates/libmwemu/src/emu/loaders.rs index 2fda562c..d5dd5fb0 100644 --- a/crates/libmwemu/src/emu/loaders.rs +++ b/crates/libmwemu/src/emu/loaders.rs @@ -4,6 +4,7 @@ use crate::constants; use crate::elf::elf32::Elf32; use crate::elf::elf64::Elf64; use crate::emu::Emu; +use crate::maps::mem64::Permission; use crate::pe::pe32::PE32; use crate::pe::pe64::PE64; use crate::peb::{peb32, peb64}; @@ -74,7 +75,6 @@ impl Emu { } } - if set_entry { // 2. pe binding if !is_maps { @@ -83,7 +83,6 @@ impl Emu { self.base = base as u64; } - // 3. entry point logic if self.cfg.entry_point == constants::CFG_DEFAULT_BASE { self.regs_mut().rip = base as u64 + pe32.opt.address_of_entry_point as u64; @@ -100,7 +99,6 @@ impl Emu { log::info!("base: 0x{:x}", base); } - // 4. map pe and then sections log::info!("mapeando PE de {}", filename2); let pemap = self @@ -109,6 +107,7 @@ impl Emu { &format!("{}.pe", filename2), base.into(), pe32.opt.size_of_headers.into(), + Permission::READ_WRITE, ) .expect("cannot create pe map"); pemap.memcpy(pe32.get_headers(), pe32.opt.size_of_headers as usize); @@ -116,6 +115,11 @@ impl Emu { for i in 0..pe32.num_of_sections() { let ptr = pe32.get_section_ptr(i); let sect = pe32.get_section(i); + let charactis = sect.characteristics; + let is_exec = charactis & 0x20000000 != 0x0; + let is_read = charactis & 0x40000000 != 0x0; + let is_write = charactis & 0x80000000 != 0x0; + let permission = Permission::from_flags(is_read, is_write, is_exec); let sz: u64 = if sect.virtual_size > sect.size_of_raw_data { sect.virtual_size as u64 @@ -143,6 +147,7 @@ impl Emu { &format!("{}{}", filename2, sect_name), base as u64 + sect.virtual_address as u64, sz, + permission, ) { Ok(m) => m, Err(e) => { @@ -171,8 +176,14 @@ impl Emu { // 5. ldr table entry creation and link if set_entry { - let space_addr = - peb32::create_ldr_entry(self, base, self.regs().rip as u32, &filename2.clone(), 0, 0x2c1950); + let space_addr = peb32::create_ldr_entry( + self, + base, + self.regs().rip as u32, + &filename2.clone(), + 0, + 0x2c1950, + ); peb32::update_ldr_entry_base(constants::EXE_NAME, base as u64, self); } @@ -251,23 +262,27 @@ impl Emu { } // 4. map pe and then sections - let pemap = match self - .maps - .create_map( - &format!("{}.pe", filename2), - base, - pe64.opt.size_of_headers.into(), - ) { - Ok(m) => m, - Err(e) => { - panic!("annot create pe64 map: {}", e); - } + let pemap = match self.maps.create_map( + &format!("{}.pe", filename2), + base, + pe64.opt.size_of_headers.into(), + Permission::READ_WRITE, + ) { + Ok(m) => m, + Err(e) => { + panic!("annot create pe64 map: {}", e); + } }; pemap.memcpy(pe64.get_headers(), pe64.opt.size_of_headers as usize); for i in 0..pe64.num_of_sections() { let ptr = pe64.get_section_ptr(i); let sect = pe64.get_section(i); + let charistic = sect.characteristics; + let is_exec = charistic & 0x20000000 != 0x0; + let is_read = charistic & 0x40000000 != 0x0; + let is_write = charistic & 0x80000000 != 0x0; + let permission = Permission::from_flags(is_read, is_write, is_exec); let sz: u64 = if sect.virtual_size > sect.size_of_raw_data { sect.virtual_size as u64 @@ -295,6 +310,7 @@ impl Emu { &format!("{}{}", filename2, sect_name), base + sect.virtual_address as u64, sz, + permission, ) { Ok(m) => m, Err(e) => { @@ -324,8 +340,14 @@ impl Emu { // 5. ldr table entry creation and link if set_entry { - let space_addr = - peb64::create_ldr_entry(self, base, self.regs().rip, &filename2.clone(), 0, 0x2c1950); + let space_addr = peb64::create_ldr_entry( + self, + base, + self.regs().rip, + &filename2.clone(), + 0, + 0x2c1950, + ); peb64::update_ldr_entry_base(constants::EXE_NAME, base, self); } @@ -357,7 +379,7 @@ impl Emu { self.init_linux64(dyn_link); // Get .text addr and size - let mut text_addr:u64 = 0; + let mut text_addr: u64 = 0; let mut text_sz = 0; for i in 0..elf64.elf_shdr.len() { let sname = elf64.get_section_name(elf64.elf_shdr[i].sh_name as usize); @@ -380,21 +402,31 @@ impl Emu { self.regs_mut().rip = self.cfg.entry_point; // 2. Entry point pointing inside .text - } else if elf64.elf_hdr.e_entry >= text_addr && elf64.elf_hdr.e_entry < text_addr+text_sz { - log::info!("Entry point pointing to .text 0x{:x}", elf64.elf_hdr.e_entry); + } else if elf64.elf_hdr.e_entry >= text_addr && elf64.elf_hdr.e_entry < text_addr + text_sz + { + log::info!( + "Entry point pointing to .text 0x{:x}", + elf64.elf_hdr.e_entry + ); self.regs_mut().rip = elf64.elf_hdr.e_entry; // 3. Entry point points above .text, relative entry point } else if elf64.elf_hdr.e_entry < text_addr { self.regs_mut().rip = elf64.elf_hdr.e_entry + elf64.base; //text_addr; - log::info!("relative entry point: 0x{:x} fixed: 0x{:x}", elf64.elf_hdr.e_entry, self.regs().rip); + log::info!( + "relative entry point: 0x{:x} fixed: 0x{:x}", + elf64.elf_hdr.e_entry, + self.regs().rip + ); // 4. Entry point points below .text, weird case. } else { - panic!("Entry points is pointing below .text 0x{:x}", elf64.elf_hdr.e_entry); + panic!( + "Entry points is pointing below .text 0x{:x}", + elf64.elf_hdr.e_entry + ); } - /* if dyn_link { //let mut ld = Elf64::parse("/lib64/ld-linux-x86-64.so.2").unwrap(); @@ -405,7 +437,7 @@ impl Emu { //TODO: emulate the linker //self.regs_mut().rip = ld.elf_hdr.e_entry + elf64::LD_BASE; - //self.run(None); + //self.run(None); } else { self.regs_mut().rip = elf64.elf_hdr.e_entry; }*/ @@ -434,7 +466,7 @@ impl Emu { /// Load a sample. It can be PE32, PE64, ELF32, ELF64 or shellcode. /// If its a shellcode cannot be known if is for windows or linux, it triggers also init() to - /// setup windows simulator. + /// setup windows simulator. /// For now mwemu also don't know if shellcode is for 32bits or 64bits, in commandline -6 has /// to be selected for indicating 64bits, and from python or rust the emu32() or emu64() /// construtor dtermines the engine. @@ -454,7 +486,7 @@ impl Emu { elf32.load(&mut self.maps); self.regs_mut().rip = elf32.elf_hdr.e_entry.into(); let stack_sz = 0x30000; - let stack = self.alloc("stack", stack_sz); + let stack = self.alloc("stack", stack_sz, Permission::READ_WRITE); self.regs_mut().rsp = stack + (stack_sz / 2); //unimplemented!("elf32 is not supported for now"); } else if Elf64::is_elf64(filename) { @@ -463,8 +495,6 @@ impl Emu { self.maps.clear(); let base = self.load_elf64(filename); - - } else if !self.cfg.is_64bits && PE32::is_pe32(filename) { log::info!("PE32 header detected."); let clear_registers = false; // TODO: this needs to be more dynamic, like if we have a register set via args or not @@ -500,7 +530,7 @@ impl Emu { self.regs_mut().set_reg(Register::R8L, 0); } } - _ => { + _ => { log::error!("No Pe64 found inside self"); } } @@ -538,7 +568,12 @@ impl Emu { if !self .maps - .create_map("code", self.cfg.code_base_addr, 0) + .create_map( + "code", + self.cfg.code_base_addr, + 0, + Permission::READ_WRITE_EXECUTE, + ) .expect("cannot create code map") .load(filename) { @@ -570,7 +605,15 @@ impl Emu { self.init_cpu(); - let code = self.maps.create_map("code", self.cfg.code_base_addr, bytes.len() as u64).expect("cannot create code map"); + let code = self + .maps + .create_map( + "code", + self.cfg.code_base_addr, + bytes.len() as u64, + Permission::READ_WRITE_EXECUTE, + ) + .expect("cannot create code map"); let base = code.get_base(); code.write_bytes(base, bytes); self.regs_mut().rip = code.get_base(); diff --git a/crates/libmwemu/src/emu/maps.rs b/crates/libmwemu/src/emu/maps.rs index 02671aa9..3da80d45 100644 --- a/crates/libmwemu/src/emu/maps.rs +++ b/crates/libmwemu/src/emu/maps.rs @@ -1,6 +1,7 @@ use std::{fs, io, path::Path}; use crate::emu::Emu; +use crate::maps::mem64::Permission; impl Emu { /// For simulating a windows process space, select the folder with maps32 or maps64 depending upon the arch, do this before loading the binary. @@ -8,10 +9,13 @@ impl Emu { //let mut f = folder.to_string(); //f.push('/'); self.cfg.maps_folder = folder.to_string(); - + // Check if maps folder exists and contains essential files if !self.maps_folder_is_valid(folder) { - log::info!("Maps folder '{}' not found or incomplete, attempting to download...", folder); + log::info!( + "Maps folder '{}' not found or incomplete, attempting to download...", + folder + ); if let Err(e) = self.download_and_extract_maps(folder) { log::error!("Failed to download maps folder '{}': {}", folder, e); panic!("Cannot proceed without maps folder. Please download manually or check your internet connection."); @@ -36,7 +40,10 @@ impl Emu { for file in essential_files { let file_path = folder_path.join(file); if !file_path.exists() { - log::info!("Essential file '{}' missing from maps folder", file_path.display()); + log::info!( + "Essential file '{}' missing from maps folder", + file_path.display() + ); return false; } } @@ -47,19 +54,26 @@ impl Emu { /// Download and extract maps folder from specific URL fn download_and_extract_maps(&self, folder: &str) -> Result<(), Box> { let url = match folder { - "maps32" | "maps32/" | "maps/maps32" | "maps/maps32/" => "https://github.com/sha0coder/mwemu/releases/download/maps/maps32.zip", - "maps64" | "maps64/" | "maps/maps64" | "maps/maps64/" => "https://github.com/sha0coder/mwemu/releases/download/maps/maps64.zip", + "maps32" | "maps32/" | "maps/maps32" | "maps/maps32/" => { + "https://github.com/sha0coder/mwemu/releases/download/maps/maps32.zip" + } + "maps64" | "maps64/" | "maps/maps64" | "maps/maps64/" => { + "https://github.com/sha0coder/mwemu/releases/download/maps/maps64.zip" + } _ => return Err(format!("Unknown maps folder: {}", folder).into()), }; - log::info!("Downloading {} from GitHub releases... (this may take a moment)", folder); - + log::info!( + "Downloading {} from GitHub releases... (this may take a moment)", + folder + ); + // Download the file using ureq // Note: To reduce TLS verbosity, set RUST_LOG=info instead of debug let response = ureq::get(url) .timeout(std::time::Duration::from_secs(30)) .call()?; - + if response.status() != 200 { return Err(format!("Failed to download: HTTP {}", response.status()).into()); } @@ -73,7 +87,7 @@ impl Emu { let mut archive = zip::ZipArchive::new(cursor)?; log::info!("Extracting {} files...", archive.len()); - + for i in 0..archive.len() { let mut file = archive.by_index(i)?; let outpath = Path::new(file.name()); @@ -88,7 +102,7 @@ impl Emu { fs::create_dir_all(p)?; } } - + // Extract file let mut outfile = fs::File::create(&outpath)?; io::copy(&mut file, &mut outfile)?; @@ -99,7 +113,7 @@ impl Emu { Ok(()) } - /// Get the base address of the code, if code map doesn't exist yet will return None. + /// Get the base address of the code, if code map doesn't exist yet will return None. pub fn get_base_addr(&self) -> Option { //TODO: fix this, now there is no code map. let map = match self.maps.get_map_by_name("code") { @@ -128,7 +142,7 @@ impl Emu { /// This find an empty space on the memory of selected size /// and also creates a map there. - pub fn alloc(&mut self, name: &str, size: u64) -> u64 { + pub fn alloc(&mut self, name: &str, size: u64, permission: Permission) -> u64 { let addr = match self.maps.alloc(size) { Some(a) => a, None => { @@ -137,9 +151,8 @@ impl Emu { } }; self.maps - .create_map(name, addr, size) + .create_map(name, addr, size, permission) .expect("cannot create map from alloc api"); addr } - } diff --git a/crates/libmwemu/src/emu/memory.rs b/crates/libmwemu/src/emu/memory.rs index 904d1f10..960bb65d 100644 --- a/crates/libmwemu/src/emu/memory.rs +++ b/crates/libmwemu/src/emu/memory.rs @@ -203,7 +203,10 @@ impl Emu { 32 => match self.maps.read_dword(addr) { Some(v) => { if self.cfg.trace_mem { - let name = self.maps.get_addr_name(addr).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(addr) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -224,7 +227,10 @@ impl Emu { 16 => match self.maps.read_word(addr) { Some(v) => { if self.cfg.trace_mem { - let name = self.maps.get_addr_name(addr).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(addr) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -245,7 +251,10 @@ impl Emu { 8 => match self.maps.read_byte(addr) { Some(v) => { if self.cfg.trace_mem { - let name = self.maps.get_addr_name(addr).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(addr) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -362,4 +371,4 @@ impl Emu { panic!("weird size: {}", operand); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/mod.rs b/crates/libmwemu/src/emu/mod.rs index f06ff3ab..aadbf358 100644 --- a/crates/libmwemu/src/emu/mod.rs +++ b/crates/libmwemu/src/emu/mod.rs @@ -1,34 +1,53 @@ -use std::{cell::RefCell, collections::HashMap, fs::File, sync::{atomic::AtomicU32, Arc}, time::Instant}; +use std::{ + cell::RefCell, + collections::HashMap, + fs::File, + sync::{atomic::AtomicU32, Arc}, + time::Instant, +}; use iced_x86::{Instruction, IntelFormatter}; -use crate::{banzai::Banzai, breakpoint::Breakpoints, colors::Colors, config::Config, definitions::{Definition, StoredContext}, global_locks::GlobalLocks, hooks::Hooks, maps::Maps, pe::{pe32::PE32, pe64::PE64}, structures::MemoryOperation, thread_context::ThreadContext}; +use crate::emu::disassemble::InstructionCache; +use crate::{ + banzai::Banzai, + breakpoint::Breakpoints, + colors::Colors, + config::Config, + definitions::{Definition, StoredContext}, + global_locks::GlobalLocks, + hooks::Hooks, + maps::Maps, + pe::{pe32::PE32, pe64::PE64}, + structures::MemoryOperation, + thread_context::ThreadContext, +}; -mod operands; +mod banzai; +mod call_stack; +mod config; +mod console; +pub mod disassemble; mod display; -mod flags; mod exception_handlers; -mod loaders; -mod thread_context; -mod config; mod execution; -mod memory; -mod call_stack; -mod banzai; -mod instruction_pointer; -mod trace; -mod registers; -mod console; +mod flags; mod fls; mod fpu; -mod stack; mod fs; -mod disassemble; mod initialization; -mod tls; +mod instruction_pointer; +mod loaders; +mod maps; +mod memory; +mod operands; +mod registers; +mod stack; +mod thread_context; mod threading; +mod tls; +mod trace; mod winapi; -mod maps; #[macro_use] mod utils; @@ -77,7 +96,8 @@ pub struct Emu { // Thread management pub threads: Vec, pub current_thread_id: usize, // Index into threads vec - pub global_locks: GlobalLocks, // Critical section lock tracking + pub global_locks: GlobalLocks, // Critical section lock tracking + pub instruction_cache: InstructionCache, pub definitions: HashMap, pub stored_contexts: HashMap, pub entropy: f64, diff --git a/crates/libmwemu/src/emu/operands.rs b/crates/libmwemu/src/emu/operands.rs index 25d87bfc..9cfae919 100644 --- a/crates/libmwemu/src/emu/operands.rs +++ b/crates/libmwemu/src/emu/operands.rs @@ -1,12 +1,23 @@ use iced_x86::{Instruction, MemorySize, OpKind, Register}; -use crate::{console::Console, constants, emu::Emu, exception_type::ExceptionType, regs64, structures::{self, MemoryOperation}, to32}; +use crate::maps::mem64::Permission; +use crate::{ + console::Console, + constants, + emu::Emu, + exception_type::ExceptionType, + regs64, + structures::{self, MemoryOperation}, + to32, +}; impl Emu { /// Decode the jump parameter pub fn get_jump_value(&mut self, ins: &Instruction, noperand: u32) -> Option { match ins.op_kind(noperand) { - OpKind::NearBranch64 | OpKind::NearBranch32 | OpKind::NearBranch16 => Some(ins.near_branch_target()), + OpKind::NearBranch64 | OpKind::NearBranch32 | OpKind::NearBranch16 => { + Some(ins.near_branch_target()) + } OpKind::FarBranch16 => Some(ins.far_branch16() as u64), OpKind::FarBranch32 => Some(ins.far_branch32() as u64), _ => self.get_operand_value(ins, 0, true), @@ -14,38 +25,47 @@ impl Emu { } /// Instruction argument decoder. - fn handle_memory_get_operand(&mut self, ins: &Instruction, noperand: u32, do_derref: bool) -> Option { + fn handle_memory_get_operand( + &mut self, + ins: &Instruction, + noperand: u32, + do_derref: bool, + ) -> Option { let mem_seg = ins.memory_segment(); let fs = mem_seg == Register::FS; let gs = mem_seg == Register::GS; - let derref = if mem_seg == Register::FS || mem_seg == Register::GS {false} else {do_derref}; + let derref = if mem_seg == Register::FS || mem_seg == Register::GS { + false + } else { + do_derref + }; let mem_base = ins.memory_base(); let mem_index = ins.memory_index(); - + /*if self.cfg.verbose >= 3 { - log::debug!("handle_memory_get_operand: mem_seg={:?}, mem_base={:?}, mem_index={:?}, do_derref={}", + log::debug!("handle_memory_get_operand: mem_seg={:?}, mem_base={:?}, mem_index={:?}, do_derref={}", mem_seg, mem_base, mem_index, do_derref); }*/ - + let mem_displace = if self.cfg.is_64bits { ins.memory_displacement64() } else { ins.memory_displacement32() as i32 as u64 // we need this for signed extension from 32bit to 64bi }; - + /*if self.cfg.verbose >= 3 { log::debug!(" mem_displace=0x{:x} (is_64bits={})", mem_displace, self.cfg.is_64bits); }*/ let temp_displace = if mem_index == Register::None { mem_displace - } else { + } else { let scale_index = ins.memory_index_scale(); let index_val = self.regs().get_reg(mem_index); let scale_factor = index_val.wrapping_mul(scale_index as u64); let result = mem_displace.wrapping_add(scale_factor); /*if self.cfg.verbose >= 3 { - log::debug!(" scale_index={}, index_val=0x{:x}, scale_factor=0x{:x}, temp_displace=0x{:x}", + log::debug!(" scale_index={}, index_val=0x{:x}, scale_factor=0x{:x}, temp_displace=0x{:x}", scale_index, index_val, scale_factor, result); }*/ result @@ -113,10 +133,7 @@ impl Emu { let value1: u64 = match mem_addr { 0xc0 => { if self.cfg.verbose >= 1 { - log::info!( - "{} Reading ISWOW64 is 32bits on a 64bits system?", - self.pos - ); + log::info!("{} Reading ISWOW64 is 32bits on a 64bits system?", self.pos); } if self.cfg.is_64bits { 0 @@ -178,7 +195,7 @@ impl Emu { if self.cfg.verbose >= 1 { log::info!("Reading local "); } - let locale = self.alloc("locale", 100); + let locale = self.alloc("locale", 100, Permission::READ_WRITE); self.maps.write_dword(locale, constants::EN_US_LOCALE); //TODO: return a table of locales /* @@ -263,7 +280,8 @@ impl Emu { // This should be sized based on the number of modules with .tls sections // For now, allocate space for a few module entries let size = if self.cfg.is_64bits { 16 * 8 } else { 16 * 4 }; - let tls_array = self.alloc("static_tls_array", size); + let tls_array = + self.alloc("static_tls_array", size, Permission::READ_WRITE); // Initialize to null pointers self.maps.write_bytes(tls_array, vec![0; size as usize]); @@ -300,7 +318,7 @@ impl Emu { log::debug!(" Read qword: 0x{:x}", v); }*/ v - }, + } None => { log::info!("/!\\ error dereferencing qword on 0x{:x}", mem_addr); self.exception(ExceptionType::QWordDereferencing); @@ -314,7 +332,7 @@ impl Emu { log::debug!(" Read dword: 0x{:x}", v); }*/ v.into() - }, + } None => { log::info!("/!\\ error dereferencing dword on 0x{:x}", mem_addr); self.exception(ExceptionType::DWordDereferencing); @@ -328,7 +346,7 @@ impl Emu { log::debug!(" Read word: 0x{:x}", v); }*/ v.into() - }, + } None => { log::info!("/!\\ error dereferencing word on 0x{:x}", mem_addr); self.exception(ExceptionType::WordDereferencing); @@ -342,7 +360,7 @@ impl Emu { log::debug!(" Read byte: 0x{:x}", v); }*/ v.into() - }, + } None => { log::info!("/!\\ error dereferencing byte on 0x{:x}", mem_addr); self.exception(ExceptionType::ByteDereferencing); @@ -354,7 +372,10 @@ impl Emu { }; if self.cfg.trace_mem { - let name = self.maps.get_addr_name(mem_addr).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(mem_addr) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -410,7 +431,9 @@ impl Emu { OpKind::Immediate8to32 => ins.immediate8to32() as u32 as u64, OpKind::Immediate8to16 => ins.immediate8to16() as u16 as u64, OpKind::Register => self.regs().get_reg(ins.op_register(noperand)), - OpKind::Memory => self.handle_memory_get_operand(ins, noperand, do_derref).unwrap(), + OpKind::Memory => self + .handle_memory_get_operand(ins, noperand, do_derref) + .unwrap(), _ => unimplemented!("unimplemented operand type {:?}", ins.op_kind(noperand)), }; Some(value) @@ -424,7 +447,8 @@ impl Emu { match ins.op_kind(noperand) { OpKind::Register => { if self.regs().is_fpu(ins.op_register(noperand)) { - self.fpu_mut().set_streg(ins.op_register(noperand), value as f64); + self.fpu_mut() + .set_streg(ins.op_register(noperand), value as f64); } else { self.regs_mut().set_reg(ins.op_register(noperand), value); } @@ -440,22 +464,22 @@ impl Emu { }; let mem_seg = ins.memory_segment(); - + /*if self.cfg.verbose >= 3 { - log::debug!("set_operand_value Memory: mem_seg={:?}, mem_base={:?}, mem_index={:?}", + log::debug!("set_operand_value Memory: mem_seg={:?}, mem_base={:?}, mem_index={:?}", mem_seg, mem_base, mem_index); log::debug!(" mem_displace=0x{:x}", mem_displace); }*/ let temp_displace = if mem_index == Register::None { mem_displace - } else { + } else { let scale_index = ins.memory_index_scale(); let index_val = self.regs().get_reg(mem_index); let scale_factor = index_val.wrapping_mul(scale_index as u64); let result = mem_displace.wrapping_add(scale_factor); /*if self.cfg.verbose >= 3 { - log::debug!(" scale_index={}, index_val=0x{:x}, scale_factor=0x{:x}, temp_displace=0x{:x}", + log::debug!(" scale_index={}, index_val=0x{:x}, scale_factor=0x{:x}, temp_displace=0x{:x}", scale_index, index_val, scale_factor, result); }*/ result @@ -552,6 +576,15 @@ impl Emu { 0 }; + // now we flush the cacheline if it is written to executable memory and the cacheline exist + let mem1 = self + .maps + .get_mem_by_addr(mem_addr) + .expect("The memory doesn't exists"); + if mem1.can_execute() { + let idx = self.instruction_cache.get_index_of(mem_addr, 0); + self.instruction_cache.flush_cache_line(idx); + } match sz { 64 => { if !self.maps.write_qword(mem_addr, value2) { @@ -559,7 +592,12 @@ impl Emu { let map_name = format!("banzai_{:x}", mem_addr); let map = self .maps - .create_map(&map_name, mem_addr, 100) + .create_map( + &map_name, + mem_addr, + 100, + Permission::READ_WRITE_EXECUTE, + ) .expect("cannot create banzai map"); map.write_qword(mem_addr, value2); return true; @@ -568,9 +606,7 @@ impl Emu { "/!\\ exception dereferencing bad address. 0x{:x}", mem_addr ); - self.exception( - ExceptionType::BadAddressDereferencing, - ); + self.exception(ExceptionType::BadAddressDereferencing); return false; } } @@ -581,7 +617,12 @@ impl Emu { let map_name = format!("banzai_{:x}", mem_addr); let map = self .maps - .create_map(&map_name, mem_addr, 100) + .create_map( + &map_name, + mem_addr, + 100, + Permission::READ_WRITE_EXECUTE, + ) .expect("cannot create banzai map"); map.write_dword(mem_addr, to32!(value2)); return true; @@ -590,9 +631,7 @@ impl Emu { "/!\\ exception dereferencing bad address. 0x{:x}", mem_addr ); - self.exception( - ExceptionType::BadAddressDereferencing, - ); + self.exception(ExceptionType::BadAddressDereferencing); return false; } } @@ -603,7 +642,12 @@ impl Emu { let map_name = format!("banzai_{:x}", mem_addr); let map = self .maps - .create_map(&map_name, mem_addr, 100) + .create_map( + &map_name, + mem_addr, + 100, + Permission::READ_WRITE_EXECUTE, + ) .expect("cannot create banzai map"); map.write_word(mem_addr, value2 as u16); return true; @@ -612,9 +656,7 @@ impl Emu { "/!\\ exception dereferencing bad address. 0x{:x}", mem_addr ); - self.exception( - ExceptionType::BadAddressDereferencing, - ); + self.exception(ExceptionType::BadAddressDereferencing); return false; } } @@ -625,7 +667,12 @@ impl Emu { let map_name = format!("banzai_{:x}", mem_addr); let map = self .maps - .create_map(&map_name, mem_addr, 100) + .create_map( + &map_name, + mem_addr, + 100, + Permission::READ_WRITE_EXECUTE, + ) .expect("cannot create banzai map"); map.write_byte(mem_addr, value2 as u8); return true; @@ -634,54 +681,55 @@ impl Emu { "/!\\ exception dereferencing bad address. 0x{:x}", mem_addr ); - self.exception( - ExceptionType::BadAddressDereferencing, - ); + self.exception(ExceptionType::BadAddressDereferencing); return false; } } - } - _ => unimplemented!("weird size"), - } - - if self.cfg.trace_mem { - let name = self.maps.get_addr_name(mem_addr).unwrap_or_else(|| "not mapped"); - let memory_operation = MemoryOperation { - pos: self.pos, - rip: self.regs().rip, - op: "write".to_string(), - bits: sz, - address: mem_addr, - old_value, - new_value: value2, - name: name.to_string(), - }; - self.memory_operations.push(memory_operation); - log::info!("\tmem_trace: pos = {} rip = {:x} op = write bits = {} address = 0x{:x} value = 0x{:x} name = '{}'", self.pos, self.regs().rip, sz, mem_addr, value2, name); } + _ => unimplemented!("weird size"), + } - /* - let name = match self.maps.get_addr_name(mem_addr) { - Some(n) => n, - None => "not mapped".to_string(), + if self.cfg.trace_mem { + let name = self + .maps + .get_addr_name(mem_addr) + .unwrap_or_else(|| "not mapped"); + let memory_operation = MemoryOperation { + pos: self.pos, + rip: self.regs().rip, + op: "write".to_string(), + bits: sz, + address: mem_addr, + old_value, + new_value: value2, + name: name.to_string(), }; + self.memory_operations.push(memory_operation); + log::info!("\tmem_trace: pos = {} rip = {:x} op = write bits = {} address = 0x{:x} value = 0x{:x} name = '{}'", self.pos, self.regs().rip, sz, mem_addr, value2, name); + } - if name == "code" { - if self.cfg.verbose >= 1 { - log::info!("/!\\ polymorfic code, addr 0x{:x}", mem_addr); - } - self.force_break = true; - }*/ + /* + let name = match self.maps.get_addr_name(mem_addr) { + Some(n) => n, + None => "not mapped".to_string(), + }; - if self.bp.is_bp_mem_write_addr(mem_addr) { - log::info!("Memory breakpoint on write 0x{:x}", mem_addr); - if self.running_script { - self.force_break = true; - } else { - Console::spawn_console(self); - } + if name == "code" { + if self.cfg.verbose >= 1 { + log::info!("/!\\ polymorfic code, addr 0x{:x}", mem_addr); + } + self.force_break = true; + }*/ + + if self.bp.is_bp_mem_write_addr(mem_addr) { + log::info!("Memory breakpoint on write 0x{:x}", mem_addr); + if self.running_script { + self.force_break = true; + } else { + Console::spawn_console(self); } } + } _ => unimplemented!("unimplemented operand type {:?}", ins.op_kind(noperand)), }; @@ -749,7 +797,9 @@ impl Emu { assert!(ins.op_count() > noperand); match ins.op_kind(noperand) { - OpKind::Register => self.regs_mut().set_xmm_reg(ins.op_register(noperand), value), + OpKind::Register => self + .regs_mut() + .set_xmm_reg(ins.op_register(noperand), value), OpKind::Memory => { let mem_addr = match ins .virtual_address(noperand, 0, |reg, idx, _sz| Some(self.regs().get_reg(reg))) @@ -835,7 +885,9 @@ impl Emu { assert!(ins.op_count() > noperand); match ins.op_kind(noperand) { - OpKind::Register => self.regs_mut().set_ymm_reg(ins.op_register(noperand), value), + OpKind::Register => self + .regs_mut() + .set_ymm_reg(ins.op_register(noperand), value), OpKind::Memory => { let mem_addr = match ins .virtual_address(noperand, 0, |reg, idx, _sz| Some(self.regs().get_reg(reg))) @@ -879,8 +931,8 @@ impl Emu { OpKind::NearBranch64 | OpKind::Immediate64 | OpKind::Immediate32to64 - | OpKind::Immediate8to64 - | OpKind::MemoryESRDI + | OpKind::Immediate8to64 + | OpKind::MemoryESRDI | OpKind::MemorySegRSI => 64, OpKind::NearBranch32 | OpKind::Immediate32 @@ -894,7 +946,7 @@ impl Emu { | OpKind::Immediate8to16 => 16, OpKind::Immediate8 => 8, OpKind::Register => self.regs().get_size(ins.op_register(noperand)), - + OpKind::Memory => match ins.memory_size() { MemorySize::Float16 | MemorySize::UInt16 @@ -926,4 +978,4 @@ impl Emu { _ => unimplemented!("unimplemented operand type {:?}", ins.op_kind(noperand)), } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/registers.rs b/crates/libmwemu/src/emu/registers.rs index 8995185b..8a3b3009 100644 --- a/crates/libmwemu/src/emu/registers.rs +++ b/crates/libmwemu/src/emu/registers.rs @@ -5,16 +5,15 @@ impl Emu { pub fn regs(&self) -> &Regs64 { &self.threads[self.current_thread_id].regs } - + pub fn regs_mut(&mut self) -> &mut Regs64 { &mut self.threads[self.current_thread_id].regs } - pub fn set_pre_op_regs(&mut self, regs: Regs64) { self.threads[self.current_thread_id].pre_op_regs = regs; } - + pub fn set_post_op_regs(&mut self, regs: Regs64) { self.threads[self.current_thread_id].post_op_regs = regs; } @@ -22,7 +21,7 @@ impl Emu { pub fn pre_op_regs(&self) -> &Regs64 { &self.threads[self.current_thread_id].pre_op_regs } - + pub fn pre_op_regs_mut(&mut self) -> &mut Regs64 { &mut self.threads[self.current_thread_id].pre_op_regs } @@ -30,8 +29,8 @@ impl Emu { pub fn post_op_regs(&self) -> &Regs64 { &self.threads[self.current_thread_id].post_op_regs } - + pub fn post_op_regs_mut(&mut self) -> &mut Regs64 { &mut self.threads[self.current_thread_id].post_op_regs } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/stack.rs b/crates/libmwemu/src/emu/stack.rs index 811fc4bf..18aaedfe 100644 --- a/crates/libmwemu/src/emu/stack.rs +++ b/crates/libmwemu/src/emu/stack.rs @@ -1,7 +1,7 @@ use crate::{emu::Emu, structures::MemoryOperation}; impl Emu { - /// Push a dword to the stack and dec the esp + /// Push a dword to the stack and dec the esp /// This will return false if stack pointer is pointing to non allocated place. pub fn stack_push32(&mut self, value: u32) -> bool { if self.cfg.stack_trace { @@ -10,7 +10,10 @@ impl Emu { } if self.cfg.trace_mem { - let name = self.maps.get_addr_name(self.regs().get_esp()).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(self.regs().get_esp()) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -59,7 +62,10 @@ impl Emu { if self.maps.write_dword(self.regs().get_esp(), value) { true } else { - log::info!("/!\\ pushing in non mapped mem 0x{:x}", self.regs().get_esp()); + log::info!( + "/!\\ pushing in non mapped mem 0x{:x}", + self.regs().get_esp() + ); false } } @@ -73,7 +79,10 @@ impl Emu { } if self.cfg.trace_mem { - let name = self.maps.get_addr_name(self.regs().rsp).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(self.regs().rsp) + .unwrap_or_else(|| "not mapped"); let memory_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -179,7 +188,10 @@ impl Emu { if self.cfg.trace_mem { // Record the read from stack memory - let name = self.maps.get_addr_name(self.regs().get_esp()).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(self.regs().get_esp()) + .unwrap_or_else(|| "not mapped"); let read_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -260,7 +272,10 @@ impl Emu { if self.cfg.trace_mem { // Record the read from stack memory - let name = self.maps.get_addr_name(self.regs().rsp).unwrap_or_else(|| "not mapped"); + let name = self + .maps + .get_addr_name(self.regs().rsp) + .unwrap_or_else(|| "not mapped"); let read_operation = MemoryOperation { pos: self.pos, rip: self.regs().rip, @@ -296,5 +311,4 @@ impl Emu { //log::info!("0x{:x} pop64 stack level is {} deep {}", self.regs().rip, self.stack_lvl[self.stack_lvl_idx], self.stack_lvl_idx); Some(value) } - -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/thread_context.rs b/crates/libmwemu/src/emu/thread_context.rs index e75e31e5..5a27a5d6 100644 --- a/crates/libmwemu/src/emu/thread_context.rs +++ b/crates/libmwemu/src/emu/thread_context.rs @@ -5,8 +5,8 @@ impl Emu { pub fn current_thread(&self) -> &ThreadContext { &self.threads[self.current_thread_id] } - + pub fn current_thread_mut(&mut self) -> &mut ThreadContext { &mut self.threads[self.current_thread_id] } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/threading.rs b/crates/libmwemu/src/emu/threading.rs index c11567ce..4ed67185 100644 --- a/crates/libmwemu/src/emu/threading.rs +++ b/crates/libmwemu/src/emu/threading.rs @@ -12,5 +12,4 @@ impl Emu { pub fn is_threading_enabled(&self) -> bool { self.cfg.enable_threading } - -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/tls.rs b/crates/libmwemu/src/emu/tls.rs index ee840193..13468c51 100644 --- a/crates/libmwemu/src/emu/tls.rs +++ b/crates/libmwemu/src/emu/tls.rs @@ -1,19 +1,19 @@ use crate::emu::Emu; -impl Emu { +impl Emu { pub fn tls32(&self) -> &Vec { &self.threads[self.current_thread_id].tls32 } - + pub fn tls32_mut(&mut self) -> &mut Vec { &mut self.threads[self.current_thread_id].tls32 } - + pub fn tls64(&self) -> &Vec { &self.threads[self.current_thread_id].tls64 } - + pub fn tls64_mut(&mut self) -> &mut Vec { &mut self.threads[self.current_thread_id].tls64 } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/trace.rs b/crates/libmwemu/src/emu/trace.rs index 7f00c930..52e90c80 100644 --- a/crates/libmwemu/src/emu/trace.rs +++ b/crates/libmwemu/src/emu/trace.rs @@ -112,7 +112,7 @@ impl Emu { registers, pre_op_regs.r15, post_op_regs.r15 ); } else { - let post_op_regs = post_op_regs; + let post_op_regs = post_op_regs; registers = Regs64::diff(pre_op_regs, post_op_regs); } @@ -200,11 +200,7 @@ impl Emu { pre_op_flags.dump(), post_op_flags.dump() ); - comments = format!( - "{} {}", - comments, - Flags::diff(pre_op_flags, post_op_flags) - ); + comments = format!("{} {}", comments, Flags::diff(pre_op_flags, post_op_flags)); } // dump all write memory operations @@ -223,7 +219,7 @@ impl Emu { let mut trace_file = self.trace_file.as_ref().unwrap(); writeln!( trace_file, - r#""{index}","{address:016X}","{bytes:02x?}","{disassembly}","{registers}","{memory}","{comments}""#, + r#""{index}","{address:016X}","{bytes:02x?}","{disassembly}","{registers}","{memory}","{comments}""#, index = index, address = pre_op_regs.rip, bytes = instruction_bytes, @@ -234,7 +230,7 @@ impl Emu { ).expect("failed to write to trace file");*/ log::info!( - r#"trace: "{index}","{address:016X}","{bytes:02x?}","{disassembly}","{registers}","{memory}","{comments}""#, + r#"trace: "{index}","{address:016X}","{bytes:02x?}","{disassembly}","{registers}","{memory}","{comments}""#, index = index + 1, address = pre_op_regs.rip, bytes = instruction_bytes, @@ -286,7 +282,12 @@ impl Emu { let s = self.maps.read_string(self.cfg.string_addr); if s.len() >= 2 && s.len() < 80 { - log::info!("\t{} trace string -> 0x{:x}: '{}'", self.pos, self.cfg.string_addr, s); + log::info!( + "\t{} trace string -> 0x{:x}: '{}'", + self.pos, + self.cfg.string_addr, + s + ); } else { let w = self.maps.read_wide_string_nocrash(self.cfg.string_addr); if w.len() == 0 { @@ -316,7 +317,8 @@ impl Emu { let mut s = self.maps.read_string(addr); self.maps.filter_string(&mut s); - let bytes = self.maps + let bytes = self + .maps .read_string_of_bytes(addr, constants::NUM_BYTES_TRACE); log::info!( "\tmem_inspect: rip = {:x} (0x{:x}): 0x{:x} {} '{}' {{{}}}", @@ -328,5 +330,4 @@ impl Emu { bytes ); } - } diff --git a/crates/libmwemu/src/emu/utils.rs b/crates/libmwemu/src/emu/utils.rs index 495d310d..2a269914 100644 --- a/crates/libmwemu/src/emu/utils.rs +++ b/crates/libmwemu/src/emu/utils.rs @@ -64,4 +64,4 @@ macro_rules! color { LightPurple, LightCyan, White, nc, ClearScreen" )) }; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu/winapi.rs b/crates/libmwemu/src/emu/winapi.rs index f3df0153..97bf8079 100644 --- a/crates/libmwemu/src/emu/winapi.rs +++ b/crates/libmwemu/src/emu/winapi.rs @@ -1,4 +1,9 @@ -use crate::{emu::Emu, exception_type::ExceptionType, peb::{peb32, peb64}, winapi::{winapi32, winapi64}}; +use crate::{ + emu::Emu, + exception_type::ExceptionType, + peb::{peb32, peb64}, + winapi::{winapi32, winapi64}, +}; impl Emu { //TODO: check this, this is used only on pyscemu @@ -31,7 +36,6 @@ impl Emu { } } - /// For an existing linked DLL, this funcion allows to modify the base address on LDR entry. pub fn update_ldr_entry_base(&mut self, libname: &str, base: u64) { if self.cfg.is_64bits { @@ -71,4 +75,4 @@ impl Emu { addr } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/emu_context.rs b/crates/libmwemu/src/emu_context.rs index c17755ba..db8c6743 100644 --- a/crates/libmwemu/src/emu_context.rs +++ b/crates/libmwemu/src/emu_context.rs @@ -1,5 +1,5 @@ -use std::cell::RefCell; use iced_x86::Formatter as _; +use std::cell::RefCell; use crate::emu::Emu; @@ -12,9 +12,9 @@ where F: FnOnce(&Emu) -> R, { CURRENT_EMU.with(|current| { - current.borrow().and_then(|ptr| { - unsafe { ptr.as_ref().map(|emu| f(emu)) } - }) + current + .borrow() + .and_then(|ptr| unsafe { ptr.as_ref().map(|emu| f(emu)) }) }) } @@ -23,9 +23,9 @@ where F: FnOnce(&mut Emu) -> R, { CURRENT_EMU.with(|current| { - current.borrow().and_then(|ptr| { - unsafe { (ptr as *mut Emu).as_mut().map(|emu| f(emu)) } - }) + current + .borrow() + .and_then(|ptr| unsafe { (ptr as *mut Emu).as_mut().map(|emu| f(emu)) }) }) } @@ -65,41 +65,76 @@ pub fn log_emu_state(emu: &mut Emu) { ); } None => {} - }; - + }; + // Log general purpose registers log::error!("Registers:"); - log::error!(" RAX: 0x{:016x} RBX: 0x{:016x}", emu.regs().rax, emu.regs().rbx); - log::error!(" RCX: 0x{:016x} RDX: 0x{:016x}", emu.regs().rcx, emu.regs().rdx); - log::error!(" RSI: 0x{:016x} RDI: 0x{:016x}", emu.regs().rsi, emu.regs().rdi); - log::error!(" RBP: 0x{:016x} RSP: 0x{:016x}", emu.regs().rbp, emu.regs().rsp); - log::error!(" R8: 0x{:016x} R9: 0x{:016x}", emu.regs().r8, emu.regs().r9); - log::error!(" R10: 0x{:016x} R11: 0x{:016x}", emu.regs().r10, emu.regs().r11); - log::error!(" R12: 0x{:016x} R13: 0x{:016x}", emu.regs().r12, emu.regs().r13); - log::error!(" R14: 0x{:016x} R15: 0x{:016x}", emu.regs().r14, emu.regs().r15); + log::error!( + " RAX: 0x{:016x} RBX: 0x{:016x}", + emu.regs().rax, + emu.regs().rbx + ); + log::error!( + " RCX: 0x{:016x} RDX: 0x{:016x}", + emu.regs().rcx, + emu.regs().rdx + ); + log::error!( + " RSI: 0x{:016x} RDI: 0x{:016x}", + emu.regs().rsi, + emu.regs().rdi + ); + log::error!( + " RBP: 0x{:016x} RSP: 0x{:016x}", + emu.regs().rbp, + emu.regs().rsp + ); + log::error!( + " R8: 0x{:016x} R9: 0x{:016x}", + emu.regs().r8, + emu.regs().r9 + ); + log::error!( + " R10: 0x{:016x} R11: 0x{:016x}", + emu.regs().r10, + emu.regs().r11 + ); + log::error!( + " R12: 0x{:016x} R13: 0x{:016x}", + emu.regs().r12, + emu.regs().r13 + ); + log::error!( + " R14: 0x{:016x} R15: 0x{:016x}", + emu.regs().r14, + emu.regs().r15 + ); log::error!(" RIP: 0x{:016x}", emu.regs().rip); - + // Log flags log::error!("EFLAGS: 0x{:08x}", emu.flags().dump()); - + // Log last instruction if available if let Some(ref _instruction) = emu.instruction { log::error!("Last instruction: {}", emu.mnemonic); log::error!("Instruction size: {}", emu.last_instruction_size); } - + // Log call stack if !emu.call_stack().is_empty() { - log::error!("Call stack (last {} entries):", emu.call_stack().len().min(10)); + log::error!( + "Call stack (last {} entries):", + emu.call_stack().len().min(10) + ); for (i, entry) in emu.call_stack().iter().rev().take(10).enumerate() { - log::error!(" {}: {}", i, entry); + log::error!(" {}: {:x}:call:{:x}", i, entry.0, entry.1); } } - + // Log execution info log::error!("Tick count: {}", emu.tick); log::error!("Base address: 0x{:x}", emu.base); log::error!("Filename: {}", emu.filename); - + log::error!("=============================="); } diff --git a/crates/libmwemu/src/engine/instructions/aad.rs b/crates/libmwemu/src/engine/instructions/aad.rs index ed0ec3aa..f60bb7b0 100644 --- a/crates/libmwemu/src/engine/instructions/aad.rs +++ b/crates/libmwemu/src/engine/instructions/aad.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/adc.rs b/crates/libmwemu/src/engine/instructions/adc.rs index d10b7d80..7dba5127 100644 --- a/crates/libmwemu/src/engine/instructions/adc.rs +++ b/crates/libmwemu/src/engine/instructions/adc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); @@ -34,12 +34,9 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste f_cf, true, ), - 8 => emu.flags_mut().add8( - (value0 & 0xff) as u8, - (value1 & 0xff) as u8, - f_cf, - true, - ), + 8 => emu + .flags_mut() + .add8((value0 & 0xff) as u8, (value1 & 0xff) as u8, f_cf, true), _ => unreachable!("weird size"), }; diff --git a/crates/libmwemu/src/engine/instructions/add.rs b/crates/libmwemu/src/engine/instructions/add.rs index bf9e747f..34596eda 100644 --- a/crates/libmwemu/src/engine/instructions/add.rs +++ b/crates/libmwemu/src/engine/instructions/add.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); @@ -32,12 +32,9 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste f_cf, false, ), - 8 => emu.flags_mut().add8( - (value0 & 0xff) as u8, - (value1 & 0xff) as u8, - f_cf, - false, - ), + 8 => emu + .flags_mut() + .add8((value0 & 0xff) as u8, (value1 & 0xff) as u8, f_cf, false), _ => unreachable!("weird size"), }; diff --git a/crates/libmwemu/src/engine/instructions/addpd.rs b/crates/libmwemu/src/engine/instructions/addpd.rs index fa3eac4b..78e522ea 100644 --- a/crates/libmwemu/src/engine/instructions/addpd.rs +++ b/crates/libmwemu/src/engine/instructions/addpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/addps.rs b/crates/libmwemu/src/engine/instructions/addps.rs index a6ef0ba1..c49ab39d 100644 --- a/crates/libmwemu/src/engine/instructions/addps.rs +++ b/crates/libmwemu/src/engine/instructions/addps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -22,8 +22,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let a: u128 = (value0 & 0xffffffff) + (value1 & 0xffffffff); let b: u128 = (value0 & 0xffffffff_00000000) + (value1 & 0xffffffff_00000000); - let c: u128 = - (value0 & 0xffffffff_00000000_00000000) + (value1 & 0xffffffff_00000000_00000000); + let c: u128 = (value0 & 0xffffffff_00000000_00000000) + (value1 & 0xffffffff_00000000_00000000); let d: u128 = (value0 & 0xffffffff_00000000_00000000_00000000) + (value1 & 0xffffffff_00000000_00000000_00000000); diff --git a/crates/libmwemu/src/engine/instructions/addsd.rs b/crates/libmwemu/src/engine/instructions/addsd.rs index d3e8647d..b3e99bdf 100644 --- a/crates/libmwemu/src/engine/instructions/addsd.rs +++ b/crates/libmwemu/src/engine/instructions/addsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/addss.rs b/crates/libmwemu/src/engine/instructions/addss.rs index f6bc5d35..3d639bd5 100644 --- a/crates/libmwemu/src/engine/instructions/addss.rs +++ b/crates/libmwemu/src/engine/instructions/addss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/and.rs b/crates/libmwemu/src/engine/instructions/and.rs index 21a9efd0..cbe40ebf 100644 --- a/crates/libmwemu/src/engine/instructions/and.rs +++ b/crates/libmwemu/src/engine/instructions/and.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/andpd.rs b/crates/libmwemu/src/engine/instructions/andpd.rs index 3844b9a7..8c657f67 100644 --- a/crates/libmwemu/src/engine/instructions/andpd.rs +++ b/crates/libmwemu/src/engine/instructions/andpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/arpl.rs b/crates/libmwemu/src/engine/instructions/arpl.rs index 749c643d..cf97a987 100644 --- a/crates/libmwemu/src/engine/instructions/arpl.rs +++ b/crates/libmwemu/src/engine/instructions/arpl.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/bound.rs b/crates/libmwemu/src/engine/instructions/bound.rs index f3c18478..d2f20e8b 100644 --- a/crates/libmwemu/src/engine/instructions/bound.rs +++ b/crates/libmwemu/src/engine/instructions/bound.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/bsf.rs b/crates/libmwemu/src/engine/instructions/bsf.rs index 258d589c..94111eab 100644 --- a/crates/libmwemu/src/engine/instructions/bsf.rs +++ b/crates/libmwemu/src/engine/instructions/bsf.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/bsr.rs b/crates/libmwemu/src/engine/instructions/bsr.rs index fabd7b15..47abb114 100644 --- a/crates/libmwemu/src/engine/instructions/bsr.rs +++ b/crates/libmwemu/src/engine/instructions/bsr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -26,7 +26,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste 64 => 63 - value1.leading_zeros() as u64, 32 => 31 - (value1 as u32).leading_zeros() as u64, 16 => 15 - (value1 as u16).leading_zeros() as u64, - 8 => 7 - (value1 as u8).leading_zeros() as u64, + 8 => 7 - (value1 as u8).leading_zeros() as u64, _ => return false, }; diff --git a/crates/libmwemu/src/engine/instructions/bswap.rs b/crates/libmwemu/src/engine/instructions/bswap.rs index 3aa1a3fb..2eefc767 100644 --- a/crates/libmwemu/src/engine/instructions/bswap.rs +++ b/crates/libmwemu/src/engine/instructions/bswap.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/bt.rs b/crates/libmwemu/src/engine/instructions/bt.rs index ea9d3e7c..97f601d0 100644 --- a/crates/libmwemu/src/engine/instructions/bt.rs +++ b/crates/libmwemu/src/engine/instructions/bt.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/btc.rs b/crates/libmwemu/src/engine/instructions/btc.rs index 77107517..94e40268 100644 --- a/crates/libmwemu/src/engine/instructions/btc.rs +++ b/crates/libmwemu/src/engine/instructions/btc.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit, set_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/btr.rs b/crates/libmwemu/src/engine/instructions/btr.rs index d4f7c555..d60b55e2 100644 --- a/crates/libmwemu/src/engine/instructions/btr.rs +++ b/crates/libmwemu/src/engine/instructions/btr.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit, set_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/bts.rs b/crates/libmwemu/src/engine/instructions/bts.rs index 255493b4..6b1fbf25 100644 --- a/crates/libmwemu/src/engine/instructions/bts.rs +++ b/crates/libmwemu/src/engine/instructions/bts.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit, set_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/call.rs b/crates/libmwemu/src/engine/instructions/call.rs index 9f32dfbb..7a507e4b 100644 --- a/crates/libmwemu/src/engine/instructions/call.rs +++ b/crates/libmwemu/src/engine/instructions/call.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Yellow"), ins); @@ -15,8 +15,15 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste }; if emu.cfg.trace_calls { - log::info!("{} 0x{:x} CALL 0x{:x} (0x{:x}, 0x{:x}, 0x{:x})", emu.pos, emu.regs().rip, addr, - emu.regs().rcx, emu.regs().rdx, emu.regs().r8); + log::info!( + "{} 0x{:x} CALL 0x{:x} (0x{:x}, 0x{:x}, 0x{:x})", + emu.pos, + emu.regs().rip, + addr, + emu.regs().rcx, + emu.regs().rdx, + emu.regs().r8 + ); } if emu.regs_mut().rip == addr - 5 { @@ -28,11 +35,9 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste emu.stack_lvl.push(0); emu.stack_lvl_idx += 1; }*/ - - let call_stack_label = format!("{:x}:call:{:x}", emu.regs().rip, addr); - - emu.call_stack_mut() - .push(call_stack_label); + + let rip = emu.regs().rip; + emu.call_stack_mut().push((rip, addr)); if emu.cfg.is_64bits { if !emu.stack_push64(emu.regs().rip + instruction_sz as u64) { diff --git a/crates/libmwemu/src/engine/instructions/cbw.rs b/crates/libmwemu/src/engine/instructions/cbw.rs index 288a01f7..e84871c4 100644 --- a/crates/libmwemu/src/engine/instructions/cbw.rs +++ b/crates/libmwemu/src/engine/instructions/cbw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cdq.rs b/crates/libmwemu/src/engine/instructions/cdq.rs index 1aff2d04..b5e3441d 100644 --- a/crates/libmwemu/src/engine/instructions/cdq.rs +++ b/crates/libmwemu/src/engine/instructions/cdq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cdqe.rs b/crates/libmwemu/src/engine/instructions/cdqe.rs index 989b6069..2129ded1 100644 --- a/crates/libmwemu/src/engine/instructions/cdqe.rs +++ b/crates/libmwemu/src/engine/instructions/cdqe.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/clc.rs b/crates/libmwemu/src/engine/instructions/clc.rs index 0dc27596..e47160c5 100644 --- a/crates/libmwemu/src/engine/instructions/clc.rs +++ b/crates/libmwemu/src/engine/instructions/clc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightGray"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cld.rs b/crates/libmwemu/src/engine/instructions/cld.rs index 0553645e..bcaa87ee 100644 --- a/crates/libmwemu/src/engine/instructions/cld.rs +++ b/crates/libmwemu/src/engine/instructions/cld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cmc.rs b/crates/libmwemu/src/engine/instructions/cmc.rs index 128ef715..c4083c8c 100644 --- a/crates/libmwemu/src/engine/instructions/cmc.rs +++ b/crates/libmwemu/src/engine/instructions/cmc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cmova.rs b/crates/libmwemu/src/engine/instructions/cmova.rs index 2548bdf4..5588422a 100644 --- a/crates/libmwemu/src/engine/instructions/cmova.rs +++ b/crates/libmwemu/src/engine/instructions/cmova.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_cf && !emu.flags().f_zf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovae.rs b/crates/libmwemu/src/engine/instructions/cmovae.rs index 5439b06e..f6ffa8d6 100644 --- a/crates/libmwemu/src/engine/instructions/cmovae.rs +++ b/crates/libmwemu/src/engine/instructions/cmovae.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_cf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovb.rs b/crates/libmwemu/src/engine/instructions/cmovb.rs index 96a244de..bf6afe83 100644 --- a/crates/libmwemu/src/engine/instructions/cmovb.rs +++ b/crates/libmwemu/src/engine/instructions/cmovb.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_cf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovbe.rs b/crates/libmwemu/src/engine/instructions/cmovbe.rs index d4a1dc28..f144ec14 100644 --- a/crates/libmwemu/src/engine/instructions/cmovbe.rs +++ b/crates/libmwemu/src/engine/instructions/cmovbe.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_cf || emu.flags().f_zf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmove.rs b/crates/libmwemu/src/engine/instructions/cmove.rs index 912aecac..6a912ef8 100644 --- a/crates/libmwemu/src/engine/instructions/cmove.rs +++ b/crates/libmwemu/src/engine/instructions/cmove.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_zf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovg.rs b/crates/libmwemu/src/engine/instructions/cmovg.rs index 4d017e74..e744621e 100644 --- a/crates/libmwemu/src/engine/instructions/cmovg.rs +++ b/crates/libmwemu/src/engine/instructions/cmovg.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags_mut().f_zf && emu.flags().f_sf == emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovge.rs b/crates/libmwemu/src/engine/instructions/cmovge.rs index f4c165fb..ac6c8694 100644 --- a/crates/libmwemu/src/engine/instructions/cmovge.rs +++ b/crates/libmwemu/src/engine/instructions/cmovge.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags_mut().f_sf == emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovl.rs b/crates/libmwemu/src/engine/instructions/cmovl.rs index 95469837..1fa8e658 100644 --- a/crates/libmwemu/src/engine/instructions/cmovl.rs +++ b/crates/libmwemu/src/engine/instructions/cmovl.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_sf != emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovle.rs b/crates/libmwemu/src/engine/instructions/cmovle.rs index 27b58fff..6b021452 100644 --- a/crates/libmwemu/src/engine/instructions/cmovle.rs +++ b/crates/libmwemu/src/engine/instructions/cmovle.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_zf || emu.flags().f_sf != emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovne.rs b/crates/libmwemu/src/engine/instructions/cmovne.rs index b5cfee94..4b85ae27 100644 --- a/crates/libmwemu/src/engine/instructions/cmovne.rs +++ b/crates/libmwemu/src/engine/instructions/cmovne.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_zf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovno.rs b/crates/libmwemu/src/engine/instructions/cmovno.rs index 23644b40..298081e4 100644 --- a/crates/libmwemu/src/engine/instructions/cmovno.rs +++ b/crates/libmwemu/src/engine/instructions/cmovno.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovnp.rs b/crates/libmwemu/src/engine/instructions/cmovnp.rs index 4930d236..eb9d36d5 100644 --- a/crates/libmwemu/src/engine/instructions/cmovnp.rs +++ b/crates/libmwemu/src/engine/instructions/cmovnp.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_pf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovns.rs b/crates/libmwemu/src/engine/instructions/cmovns.rs index e43e4e77..7d324217 100644 --- a/crates/libmwemu/src/engine/instructions/cmovns.rs +++ b/crates/libmwemu/src/engine/instructions/cmovns.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if !emu.flags().f_sf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovo.rs b/crates/libmwemu/src/engine/instructions/cmovo.rs index 1b4cd8fd..4fedd2dc 100644 --- a/crates/libmwemu/src/engine/instructions/cmovo.rs +++ b/crates/libmwemu/src/engine/instructions/cmovo.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_of { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovp.rs b/crates/libmwemu/src/engine/instructions/cmovp.rs index 7474da00..5267118e 100644 --- a/crates/libmwemu/src/engine/instructions/cmovp.rs +++ b/crates/libmwemu/src/engine/instructions/cmovp.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_pf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmovs.rs b/crates/libmwemu/src/engine/instructions/cmovs.rs index 57aa0860..a2297c88 100644 --- a/crates/libmwemu/src/engine/instructions/cmovs.rs +++ b/crates/libmwemu/src/engine/instructions/cmovs.rs @@ -1,22 +1,30 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); let value1 = match emu.get_operand_value(ins, 0, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value = if ins.op0_register().is_gpr64() { + value1 + } else { + value1 & 0xffffffff }; - let value = if ins.op0_register().is_gpr64() {value1} else {value1 & 0xffffffff}; emu.set_operand_value(ins, 0, value); if emu.flags().f_sf { let value2 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, - _ => return false + _ => return false, + }; + let value_new = if ins.op0_register().is_gpr64() { + value2 + } else { + value2 & 0xffffffff }; - let value_new = if ins.op0_register().is_gpr64() {value2} else {value2 & 0xffffffff}; if !emu.set_operand_value(ins, 0, value_new) { return false; } diff --git a/crates/libmwemu/src/engine/instructions/cmp.rs b/crates/libmwemu/src/engine/instructions/cmp.rs index 2836b3d6..0dd32a3b 100644 --- a/crates/libmwemu/src/engine/instructions/cmp.rs +++ b/crates/libmwemu/src/engine/instructions/cmp.rs @@ -1,7 +1,7 @@ -use crate::emu::Emu; +use crate::color; use crate::console::Console; -use crate::{color}; -use iced_x86::{Instruction}; +use crate::emu::Emu; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cmpsb.rs b/crates/libmwemu/src/engine/instructions/cmpsb.rs index f669a8ec..3233b64a 100644 --- a/crates/libmwemu/src/engine/instructions/cmpsb.rs +++ b/crates/libmwemu/src/engine/instructions/cmpsb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let value0: u8; diff --git a/crates/libmwemu/src/engine/instructions/cmpsd.rs b/crates/libmwemu/src/engine/instructions/cmpsd.rs index d7cc552a..e0e0622a 100644 --- a/crates/libmwemu/src/engine/instructions/cmpsd.rs +++ b/crates/libmwemu/src/engine/instructions/cmpsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let value0: u32; diff --git a/crates/libmwemu/src/engine/instructions/cmpsq.rs b/crates/libmwemu/src/engine/instructions/cmpsq.rs index de7b7fac..05c7b4c0 100644 --- a/crates/libmwemu/src/engine/instructions/cmpsq.rs +++ b/crates/libmwemu/src/engine/instructions/cmpsq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(emu.cfg.is_64bits); diff --git a/crates/libmwemu/src/engine/instructions/cmpsw.rs b/crates/libmwemu/src/engine/instructions/cmpsw.rs index 53c6f754..93e53910 100644 --- a/crates/libmwemu/src/engine/instructions/cmpsw.rs +++ b/crates/libmwemu/src/engine/instructions/cmpsw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let value0: u16; diff --git a/crates/libmwemu/src/engine/instructions/cmpxchg.rs b/crates/libmwemu/src/engine/instructions/cmpxchg.rs index f897c829..07cd4b3d 100644 --- a/crates/libmwemu/src/engine/instructions/cmpxchg.rs +++ b/crates/libmwemu/src/engine/instructions/cmpxchg.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cmpxchg16b.rs b/crates/libmwemu/src/engine/instructions/cmpxchg16b.rs index d428b0a3..a41cd68a 100644 --- a/crates/libmwemu/src/engine/instructions/cmpxchg16b.rs +++ b/crates/libmwemu/src/engine/instructions/cmpxchg16b.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cmpxchg8b.rs b/crates/libmwemu/src/engine/instructions/cmpxchg8b.rs index b6313680..ba3d4802 100644 --- a/crates/libmwemu/src/engine/instructions/cmpxchg8b.rs +++ b/crates/libmwemu/src/engine/instructions/cmpxchg8b.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cpuid.rs b/crates/libmwemu/src/engine/instructions/cpuid.rs index c7855a10..e0ad16b6 100644 --- a/crates/libmwemu/src/engine/instructions/cpuid.rs +++ b/crates/libmwemu/src/engine/instructions/cpuid.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, set_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); @@ -29,11 +29,11 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste emu.regs_mut().rbx = 0x5100800; emu.regs_mut().rcx = 0x7ffafbbf; emu.regs_mut().rdx = 0xbfebfbff; // feature - set_bit!(emu.regs_mut().rdx, 0, 1); // FPU = true - set_bit!(emu.regs_mut().rdx, 23, 1); // MMX = true + set_bit!(emu.regs_mut().rdx, 0, 1); // FPU = true + set_bit!(emu.regs_mut().rdx, 23, 1); // MMX = true set_bit!(emu.regs_mut().rdx, 25, 1); // SSE = true set_bit!(emu.regs_mut().rdx, 26, 1); // SSE2 = true - } + } 0x02 => { emu.regs_mut().rax = 0x76036301; emu.regs_mut().rbx = 0xf0b5ff; diff --git a/crates/libmwemu/src/engine/instructions/cqo.rs b/crates/libmwemu/src/engine/instructions/cqo.rs index 21fd44aa..997abc3b 100644 --- a/crates/libmwemu/src/engine/instructions/cqo.rs +++ b/crates/libmwemu/src/engine/instructions/cqo.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/cvtsi2sd.rs b/crates/libmwemu/src/engine/instructions/cvtsi2sd.rs index 37ee33e4..3e4f1da4 100644 --- a/crates/libmwemu/src/engine/instructions/cvtsi2sd.rs +++ b/crates/libmwemu/src/engine/instructions/cvtsi2sd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // we keep the high part of xmm destination diff --git a/crates/libmwemu/src/engine/instructions/cvtsi2ss.rs b/crates/libmwemu/src/engine/instructions/cvtsi2ss.rs index 37ee33e4..3e4f1da4 100644 --- a/crates/libmwemu/src/engine/instructions/cvtsi2ss.rs +++ b/crates/libmwemu/src/engine/instructions/cvtsi2ss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // we keep the high part of xmm destination diff --git a/crates/libmwemu/src/engine/instructions/cwd.rs b/crates/libmwemu/src/engine/instructions/cwd.rs index 87cdcc66..f11e9773 100644 --- a/crates/libmwemu/src/engine/instructions/cwd.rs +++ b/crates/libmwemu/src/engine/instructions/cwd.rs @@ -1,12 +1,13 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); let sigextend = emu.regs().get_ax() as u16 as i16 as i32 as u32; emu.regs_mut().set_ax((sigextend & 0x0000ffff) as u64); - emu.regs_mut().set_dx(((sigextend & 0xffff0000) >> 16) as u64); + emu.regs_mut() + .set_dx(((sigextend & 0xffff0000) >> 16) as u64); true } diff --git a/crates/libmwemu/src/engine/instructions/cwde.rs b/crates/libmwemu/src/engine/instructions/cwde.rs index 88ea74f2..dc1bdffa 100644 --- a/crates/libmwemu/src/engine/instructions/cwde.rs +++ b/crates/libmwemu/src/engine/instructions/cwde.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/daa.rs b/crates/libmwemu/src/engine/instructions/daa.rs index 5f4ab32d..80324b49 100644 --- a/crates/libmwemu/src/engine/instructions/daa.rs +++ b/crates/libmwemu/src/engine/instructions/daa.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/dec.rs b/crates/libmwemu/src/engine/instructions/dec.rs index 65ca291d..00c1fab9 100644 --- a/crates/libmwemu/src/engine/instructions/dec.rs +++ b/crates/libmwemu/src/engine/instructions/dec.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/div.rs b/crates/libmwemu/src/engine/instructions/div.rs index 3b4fc614..16cc6a2f 100644 --- a/crates/libmwemu/src/engine/instructions/div.rs +++ b/crates/libmwemu/src/engine/instructions/div.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::engine::logic; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/emms.rs b/crates/libmwemu/src/engine/instructions/emms.rs index 6b2d6daf..33dc6aae 100644 --- a/crates/libmwemu/src/engine/instructions/emms.rs +++ b/crates/libmwemu/src/engine/instructions/emms.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/endbr32.rs b/crates/libmwemu/src/engine/instructions/endbr32.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/endbr32.rs +++ b/crates/libmwemu/src/engine/instructions/endbr32.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/endbr64.rs b/crates/libmwemu/src/engine/instructions/endbr64.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/endbr64.rs +++ b/crates/libmwemu/src/engine/instructions/endbr64.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/enqcmd.rs b/crates/libmwemu/src/engine/instructions/enqcmd.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/enqcmd.rs +++ b/crates/libmwemu/src/engine/instructions/enqcmd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/enqcmds.rs b/crates/libmwemu/src/engine/instructions/enqcmds.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/enqcmds.rs +++ b/crates/libmwemu/src/engine/instructions/enqcmds.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/enter.rs b/crates/libmwemu/src/engine/instructions/enter.rs index c3e37b63..a0561c86 100644 --- a/crates/libmwemu/src/engine/instructions/enter.rs +++ b/crates/libmwemu/src/engine/instructions/enter.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/f2xm1.rs b/crates/libmwemu/src/engine/instructions/f2xm1.rs index b374d4ea..4c0cda34 100644 --- a/crates/libmwemu/src/engine/instructions/f2xm1.rs +++ b/crates/libmwemu/src/engine/instructions/f2xm1.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fabs.rs b/crates/libmwemu/src/engine/instructions/fabs.rs index 21ef8f23..c5c4bdee 100644 --- a/crates/libmwemu/src/engine/instructions/fabs.rs +++ b/crates/libmwemu/src/engine/instructions/fabs.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fadd.rs b/crates/libmwemu/src/engine/instructions/fadd.rs index 3b33bc4f..8eccffb2 100644 --- a/crates/libmwemu/src/engine/instructions/fadd.rs +++ b/crates/libmwemu/src/engine/instructions/fadd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -8,12 +8,13 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste if ins.op_count() == 2 { let i = emu.fpu().reg_to_id(ins.op_register(0)); let j = emu.fpu().reg_to_id(ins.op_register(1)); - emu.fpu_mut().add(i,j); - + emu.fpu_mut().add(i, j); } else if ins.op_count() == 1 { if ins.op_kind(0) == iced_x86::OpKind::Memory { let mem_size = ins.memory_size(); - let mem_addr = emu.get_operand_value(ins, 0, false).expect("Fadd bad mem addr"); + let mem_addr = emu + .get_operand_value(ins, 0, false) + .expect("Fadd bad mem addr"); let value = match mem_size { iced_x86::MemorySize::Float32 => emu.maps.read_f32(mem_addr).unwrap() as f64, @@ -22,11 +23,9 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste }; emu.fpu_mut().set_st(0, value); - } else { unreachable!(); } - } else { unreachable!(); } diff --git a/crates/libmwemu/src/engine/instructions/faddp.rs b/crates/libmwemu/src/engine/instructions/faddp.rs index 54dbca65..9559c246 100644 --- a/crates/libmwemu/src/engine/instructions/faddp.rs +++ b/crates/libmwemu/src/engine/instructions/faddp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fbld.rs b/crates/libmwemu/src/engine/instructions/fbld.rs index 08b5be43..e20295b5 100644 --- a/crates/libmwemu/src/engine/instructions/fbld.rs +++ b/crates/libmwemu/src/engine/instructions/fbld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fchs.rs b/crates/libmwemu/src/engine/instructions/fchs.rs index a7e9d21c..ee17a6aa 100644 --- a/crates/libmwemu/src/engine/instructions/fchs.rs +++ b/crates/libmwemu/src/engine/instructions/fchs.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovb.rs b/crates/libmwemu/src/engine/instructions/fcmovb.rs index 7d05c728..a4ac586f 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovb.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovbe.rs b/crates/libmwemu/src/engine/instructions/fcmovbe.rs index b8153d88..0d2024fa 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovbe.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovbe.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmove.rs b/crates/libmwemu/src/engine/instructions/fcmove.rs index 53f68cf4..a4841734 100644 --- a/crates/libmwemu/src/engine/instructions/fcmove.rs +++ b/crates/libmwemu/src/engine/instructions/fcmove.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovnb.rs b/crates/libmwemu/src/engine/instructions/fcmovnb.rs index a8cdf105..debc69eb 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovnb.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovnb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovnbe.rs b/crates/libmwemu/src/engine/instructions/fcmovnbe.rs index e6e0a84f..ef0abe63 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovnbe.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovnbe.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovne.rs b/crates/libmwemu/src/engine/instructions/fcmovne.rs index d57aff7d..7b70d273 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovne.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovne.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovnu.rs b/crates/libmwemu/src/engine/instructions/fcmovnu.rs index d7a46e99..cc7aef6a 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovnu.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovnu.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcmovu.rs b/crates/libmwemu/src/engine/instructions/fcmovu.rs index dc71622e..8a5be960 100644 --- a/crates/libmwemu/src/engine/instructions/fcmovu.rs +++ b/crates/libmwemu/src/engine/instructions/fcmovu.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcom.rs b/crates/libmwemu/src/engine/instructions/fcom.rs index 446d3249..9b915136 100644 --- a/crates/libmwemu/src/engine/instructions/fcom.rs +++ b/crates/libmwemu/src/engine/instructions/fcom.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcomp.rs b/crates/libmwemu/src/engine/instructions/fcomp.rs index 79a722d9..2af28aa1 100644 --- a/crates/libmwemu/src/engine/instructions/fcomp.rs +++ b/crates/libmwemu/src/engine/instructions/fcomp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fcos.rs b/crates/libmwemu/src/engine/instructions/fcos.rs index f4d5e34b..2819b3e0 100644 --- a/crates/libmwemu/src/engine/instructions/fcos.rs +++ b/crates/libmwemu/src/engine/instructions/fcos.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fdecstp.rs b/crates/libmwemu/src/engine/instructions/fdecstp.rs index 2bf59ff9..1ef159a6 100644 --- a/crates/libmwemu/src/engine/instructions/fdecstp.rs +++ b/crates/libmwemu/src/engine/instructions/fdecstp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fdiv.rs b/crates/libmwemu/src/engine/instructions/fdiv.rs index 84677c79..bc71fc6b 100644 --- a/crates/libmwemu/src/engine/instructions/fdiv.rs +++ b/crates/libmwemu/src/engine/instructions/fdiv.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fdivp.rs b/crates/libmwemu/src/engine/instructions/fdivp.rs index db69bdc9..63c43b8e 100644 --- a/crates/libmwemu/src/engine/instructions/fdivp.rs +++ b/crates/libmwemu/src/engine/instructions/fdivp.rs @@ -1,17 +1,17 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); - let st0 = emu.fpu_mut().get_st(0); // ST(0) = divisor - let st1 = emu.fpu_mut().get_st(1); // ST(1) = dividend + let st0 = emu.fpu_mut().get_st(0); // ST(0) = divisor + let st1 = emu.fpu_mut().get_st(1); // ST(1) = dividend - let result = st1 / st0; // ST(1) = ST(1) / ST(0) + let result = st1 / st0; // ST(1) = ST(1) / ST(0) emu.fpu_mut().set_st(1, result); - emu.fpu_mut().pop_f64(); // Remove ST(0) + emu.fpu_mut().pop_f64(); // Remove ST(0) emu.sync_fpu_ip(); true } diff --git a/crates/libmwemu/src/engine/instructions/fdivr.rs b/crates/libmwemu/src/engine/instructions/fdivr.rs index c9c90520..4f290d5b 100644 --- a/crates/libmwemu/src/engine/instructions/fdivr.rs +++ b/crates/libmwemu/src/engine/instructions/fdivr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fdivrp.rs b/crates/libmwemu/src/engine/instructions/fdivrp.rs index 21440c22..c417ecab 100644 --- a/crates/libmwemu/src/engine/instructions/fdivrp.rs +++ b/crates/libmwemu/src/engine/instructions/fdivrp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ffree.rs b/crates/libmwemu/src/engine/instructions/ffree.rs index 7a3db861..911416ba 100644 --- a/crates/libmwemu/src/engine/instructions/ffree.rs +++ b/crates/libmwemu/src/engine/instructions/ffree.rs @@ -1,5 +1,5 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; use iced_x86::{Instruction, Register}; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { diff --git a/crates/libmwemu/src/engine/instructions/fild.rs b/crates/libmwemu/src/engine/instructions/fild.rs index 10b7b433..b14261d6 100644 --- a/crates/libmwemu/src/engine/instructions/fild.rs +++ b/crates/libmwemu/src/engine/instructions/fild.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fincstp.rs b/crates/libmwemu/src/engine/instructions/fincstp.rs index c0d4b1f2..f19d328e 100644 --- a/crates/libmwemu/src/engine/instructions/fincstp.rs +++ b/crates/libmwemu/src/engine/instructions/fincstp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/finit.rs b/crates/libmwemu/src/engine/instructions/finit.rs index 2c238348..6a23fa5d 100644 --- a/crates/libmwemu/src/engine/instructions/finit.rs +++ b/crates/libmwemu/src/engine/instructions/finit.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fist.rs b/crates/libmwemu/src/engine/instructions/fist.rs index b83d992e..663a860a 100644 --- a/crates/libmwemu/src/engine/instructions/fist.rs +++ b/crates/libmwemu/src/engine/instructions/fist.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fistp.rs b/crates/libmwemu/src/engine/instructions/fistp.rs index dba4c20e..1065cb3e 100644 --- a/crates/libmwemu/src/engine/instructions/fistp.rs +++ b/crates/libmwemu/src/engine/instructions/fistp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fld.rs b/crates/libmwemu/src/engine/instructions/fld.rs index 3da396b2..1f555356 100644 --- a/crates/libmwemu/src/engine/instructions/fld.rs +++ b/crates/libmwemu/src/engine/instructions/fld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fld1.rs b/crates/libmwemu/src/engine/instructions/fld1.rs index 2140395d..efe10ca4 100644 --- a/crates/libmwemu/src/engine/instructions/fld1.rs +++ b/crates/libmwemu/src/engine/instructions/fld1.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldcw.rs b/crates/libmwemu/src/engine/instructions/fldcw.rs index 7a4de73f..6fc74d5d 100644 --- a/crates/libmwemu/src/engine/instructions/fldcw.rs +++ b/crates/libmwemu/src/engine/instructions/fldcw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldl2e.rs b/crates/libmwemu/src/engine/instructions/fldl2e.rs index 67d98baf..0826f1ba 100644 --- a/crates/libmwemu/src/engine/instructions/fldl2e.rs +++ b/crates/libmwemu/src/engine/instructions/fldl2e.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldl2t.rs b/crates/libmwemu/src/engine/instructions/fldl2t.rs index c68bed87..89a72fe7 100644 --- a/crates/libmwemu/src/engine/instructions/fldl2t.rs +++ b/crates/libmwemu/src/engine/instructions/fldl2t.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldlg2.rs b/crates/libmwemu/src/engine/instructions/fldlg2.rs index 8793aa70..7764258c 100644 --- a/crates/libmwemu/src/engine/instructions/fldlg2.rs +++ b/crates/libmwemu/src/engine/instructions/fldlg2.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldln2.rs b/crates/libmwemu/src/engine/instructions/fldln2.rs index 5af1fa48..b2dd3a58 100644 --- a/crates/libmwemu/src/engine/instructions/fldln2.rs +++ b/crates/libmwemu/src/engine/instructions/fldln2.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldpi.rs b/crates/libmwemu/src/engine/instructions/fldpi.rs index 46036ddd..9e1134f1 100644 --- a/crates/libmwemu/src/engine/instructions/fldpi.rs +++ b/crates/libmwemu/src/engine/instructions/fldpi.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::fpu::f80::F80; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fldz.rs b/crates/libmwemu/src/engine/instructions/fldz.rs index f2dfd491..ab168949 100644 --- a/crates/libmwemu/src/engine/instructions/fldz.rs +++ b/crates/libmwemu/src/engine/instructions/fldz.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fmul.rs b/crates/libmwemu/src/engine/instructions/fmul.rs index 636c84ad..deeddffc 100644 --- a/crates/libmwemu/src/engine/instructions/fmul.rs +++ b/crates/libmwemu/src/engine/instructions/fmul.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fmulp.rs b/crates/libmwemu/src/engine/instructions/fmulp.rs index eb18f77b..cb541ec7 100644 --- a/crates/libmwemu/src/engine/instructions/fmulp.rs +++ b/crates/libmwemu/src/engine/instructions/fmulp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fnclex.rs b/crates/libmwemu/src/engine/instructions/fnclex.rs index 359adb60..2a59f133 100644 --- a/crates/libmwemu/src/engine/instructions/fnclex.rs +++ b/crates/libmwemu/src/engine/instructions/fnclex.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fninit.rs b/crates/libmwemu/src/engine/instructions/fninit.rs index 2c238348..6a23fa5d 100644 --- a/crates/libmwemu/src/engine/instructions/fninit.rs +++ b/crates/libmwemu/src/engine/instructions/fninit.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fnop.rs b/crates/libmwemu/src/engine/instructions/fnop.rs index cd1a6605..ffc033ea 100644 --- a/crates/libmwemu/src/engine/instructions/fnop.rs +++ b/crates/libmwemu/src/engine/instructions/fnop.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightPurple"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fnstcw.rs b/crates/libmwemu/src/engine/instructions/fnstcw.rs index c627463d..e8a9b3e8 100644 --- a/crates/libmwemu/src/engine/instructions/fnstcw.rs +++ b/crates/libmwemu/src/engine/instructions/fnstcw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fnstenv.rs b/crates/libmwemu/src/engine/instructions/fnstenv.rs index 64d7cd50..4d31d388 100644 --- a/crates/libmwemu/src/engine/instructions/fnstenv.rs +++ b/crates/libmwemu/src/engine/instructions/fnstenv.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fpatan.rs b/crates/libmwemu/src/engine/instructions/fpatan.rs index ddc5e13a..f6f73807 100644 --- a/crates/libmwemu/src/engine/instructions/fpatan.rs +++ b/crates/libmwemu/src/engine/instructions/fpatan.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fprem.rs b/crates/libmwemu/src/engine/instructions/fprem.rs index 2836a439..9173f1d4 100644 --- a/crates/libmwemu/src/engine/instructions/fprem.rs +++ b/crates/libmwemu/src/engine/instructions/fprem.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fprem1.rs b/crates/libmwemu/src/engine/instructions/fprem1.rs index d24074e1..487d4b26 100644 --- a/crates/libmwemu/src/engine/instructions/fprem1.rs +++ b/crates/libmwemu/src/engine/instructions/fprem1.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fptan.rs b/crates/libmwemu/src/engine/instructions/fptan.rs index 37d7126a..bc8099fd 100644 --- a/crates/libmwemu/src/engine/instructions/fptan.rs +++ b/crates/libmwemu/src/engine/instructions/fptan.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/frndint.rs b/crates/libmwemu/src/engine/instructions/frndint.rs index 79a19bed..c16156ff 100644 --- a/crates/libmwemu/src/engine/instructions/frndint.rs +++ b/crates/libmwemu/src/engine/instructions/frndint.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fscale.rs b/crates/libmwemu/src/engine/instructions/fscale.rs index d0d19236..1dd861b0 100644 --- a/crates/libmwemu/src/engine/instructions/fscale.rs +++ b/crates/libmwemu/src/engine/instructions/fscale.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fsin.rs b/crates/libmwemu/src/engine/instructions/fsin.rs index 07b49f10..b8cdf47a 100644 --- a/crates/libmwemu/src/engine/instructions/fsin.rs +++ b/crates/libmwemu/src/engine/instructions/fsin.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fsincos.rs b/crates/libmwemu/src/engine/instructions/fsincos.rs index 96770496..dd978e31 100644 --- a/crates/libmwemu/src/engine/instructions/fsincos.rs +++ b/crates/libmwemu/src/engine/instructions/fsincos.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fsqrt.rs b/crates/libmwemu/src/engine/instructions/fsqrt.rs index 720e58ec..38e891c8 100644 --- a/crates/libmwemu/src/engine/instructions/fsqrt.rs +++ b/crates/libmwemu/src/engine/instructions/fsqrt.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::fpu::f80::F80; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fst.rs b/crates/libmwemu/src/engine/instructions/fst.rs index 5025c917..3c551826 100644 --- a/crates/libmwemu/src/engine/instructions/fst.rs +++ b/crates/libmwemu/src/engine/instructions/fst.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fstp.rs b/crates/libmwemu/src/engine/instructions/fstp.rs index 36507435..6986c42d 100644 --- a/crates/libmwemu/src/engine/instructions/fstp.rs +++ b/crates/libmwemu/src/engine/instructions/fstp.rs @@ -1,16 +1,16 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; use iced_x86::{Instruction, Register}; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); - log::info!("count: {}", ins.op_count()); + log::info!("count: {}", ins.op_count()); if ins.op_register(0) == Register::ST0 { - log::info!(" param0 is st0"); + log::info!(" param0 is st0"); } if ins.op_kind(0) == iced_x86::OpKind::Memory { - log::info!(" param0 is mem"); + log::info!(" param0 is mem"); let res = emu.fpu_mut().get_st(0) as u64; if !emu.set_operand_value(ins, 0, res) { diff --git a/crates/libmwemu/src/engine/instructions/fsub.rs b/crates/libmwemu/src/engine/instructions/fsub.rs index d819ba93..5fb18b24 100644 --- a/crates/libmwemu/src/engine/instructions/fsub.rs +++ b/crates/libmwemu/src/engine/instructions/fsub.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fsubp.rs b/crates/libmwemu/src/engine/instructions/fsubp.rs index 076ffd99..77c47902 100644 --- a/crates/libmwemu/src/engine/instructions/fsubp.rs +++ b/crates/libmwemu/src/engine/instructions/fsubp.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::fpu::f80::F80; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -10,7 +10,6 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let st1_idx = emu.get_operand_value(ins, 0, false).unwrap_or(1) as usize; // dest log::info!("st0_idx: {}, st1_idx: {}", st0_idx, st1_idx); - let st0 = emu.fpu_mut().get_st_f80_copy(st0_idx); let st1 = emu.fpu_mut().get_st_f80_copy(st1_idx); log::info!("st0: {:x}, st1: {:x}", st0.get(), st1.get()); diff --git a/crates/libmwemu/src/engine/instructions/fsubr.rs b/crates/libmwemu/src/engine/instructions/fsubr.rs index e7d758f3..b19541b1 100644 --- a/crates/libmwemu/src/engine/instructions/fsubr.rs +++ b/crates/libmwemu/src/engine/instructions/fsubr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fsubrp.rs b/crates/libmwemu/src/engine/instructions/fsubrp.rs index cbd946ab..c7a5e242 100644 --- a/crates/libmwemu/src/engine/instructions/fsubrp.rs +++ b/crates/libmwemu/src/engine/instructions/fsubrp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ftst.rs b/crates/libmwemu/src/engine/instructions/ftst.rs index e65d61e1..0d2fd507 100644 --- a/crates/libmwemu/src/engine/instructions/ftst.rs +++ b/crates/libmwemu/src/engine/instructions/ftst.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fucom.rs b/crates/libmwemu/src/engine/instructions/fucom.rs index c99de094..6c453025 100644 --- a/crates/libmwemu/src/engine/instructions/fucom.rs +++ b/crates/libmwemu/src/engine/instructions/fucom.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fxam.rs b/crates/libmwemu/src/engine/instructions/fxam.rs index c0797cd0..0a5b94db 100644 --- a/crates/libmwemu/src/engine/instructions/fxam.rs +++ b/crates/libmwemu/src/engine/instructions/fxam.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fxch.rs b/crates/libmwemu/src/engine/instructions/fxch.rs index 044fad2a..66dfabdb 100644 --- a/crates/libmwemu/src/engine/instructions/fxch.rs +++ b/crates/libmwemu/src/engine/instructions/fxch.rs @@ -1,5 +1,5 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; use iced_x86::{Instruction, Register}; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { diff --git a/crates/libmwemu/src/engine/instructions/fxrstor.rs b/crates/libmwemu/src/engine/instructions/fxrstor.rs index 48d65f52..030fac37 100644 --- a/crates/libmwemu/src/engine/instructions/fxrstor.rs +++ b/crates/libmwemu/src/engine/instructions/fxrstor.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::fpu::FPUState; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fxsave.rs b/crates/libmwemu/src/engine/instructions/fxsave.rs index 7eb52971..bf603d7a 100644 --- a/crates/libmwemu/src/engine/instructions/fxsave.rs +++ b/crates/libmwemu/src/engine/instructions/fxsave.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fxtract.rs b/crates/libmwemu/src/engine/instructions/fxtract.rs index 9ed5470f..7d8de2b6 100644 --- a/crates/libmwemu/src/engine/instructions/fxtract.rs +++ b/crates/libmwemu/src/engine/instructions/fxtract.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fyl2x.rs b/crates/libmwemu/src/engine/instructions/fyl2x.rs index 17783082..9fdb022e 100644 --- a/crates/libmwemu/src/engine/instructions/fyl2x.rs +++ b/crates/libmwemu/src/engine/instructions/fyl2x.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/fyl2xp1.rs b/crates/libmwemu/src/engine/instructions/fyl2xp1.rs index c149698d..45eb0af7 100644 --- a/crates/libmwemu/src/engine/instructions/fyl2xp1.rs +++ b/crates/libmwemu/src/engine/instructions/fyl2xp1.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/idiv.rs b/crates/libmwemu/src/engine/instructions/idiv.rs index 213318ff..890887e5 100644 --- a/crates/libmwemu/src/engine/instructions/idiv.rs +++ b/crates/libmwemu/src/engine/instructions/idiv.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::engine::logic; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/imul.rs b/crates/libmwemu/src/engine/instructions/imul.rs index 7294dfd7..1faf66bc 100644 --- a/crates/libmwemu/src/engine/instructions/imul.rs +++ b/crates/libmwemu/src/engine/instructions/imul.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::engine::logic; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); @@ -27,7 +27,6 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste 8 => logic::imul8p1(emu, value0), _ => unimplemented!("wrong size"), } - } else if ins.op_count() == 2 { // 2 params diff --git a/crates/libmwemu/src/engine/instructions/inc.rs b/crates/libmwemu/src/engine/instructions/inc.rs index be722e7e..2b81fb7b 100644 --- a/crates/libmwemu/src/engine/instructions/inc.rs +++ b/crates/libmwemu/src/engine/instructions/inc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/int.rs b/crates/libmwemu/src/engine/instructions/int.rs index c458f4c6..62af641e 100644 --- a/crates/libmwemu/src/engine/instructions/int.rs +++ b/crates/libmwemu/src/engine/instructions/int.rs @@ -1,7 +1,7 @@ use crate::emu::Emu; use crate::syscall::syscall32; use crate::{color, exception_type}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/int3.rs b/crates/libmwemu/src/engine/instructions/int3.rs index c9c25ea7..7cf421b9 100644 --- a/crates/libmwemu/src/engine/instructions/int3.rs +++ b/crates/libmwemu/src/engine/instructions/int3.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, exception_type}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ja.rs b/crates/libmwemu/src/engine/instructions/ja.rs index 3bdff17b..ced60ee3 100644 --- a/crates/libmwemu/src/engine/instructions/ja.rs +++ b/crates/libmwemu/src/engine/instructions/ja.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jae.rs b/crates/libmwemu/src/engine/instructions/jae.rs index b046cbf3..ee116f7c 100644 --- a/crates/libmwemu/src/engine/instructions/jae.rs +++ b/crates/libmwemu/src/engine/instructions/jae.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jb.rs b/crates/libmwemu/src/engine/instructions/jb.rs index ca20e345..57bd3d2d 100644 --- a/crates/libmwemu/src/engine/instructions/jb.rs +++ b/crates/libmwemu/src/engine/instructions/jb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jbe.rs b/crates/libmwemu/src/engine/instructions/jbe.rs index edddf665..d5b2ab31 100644 --- a/crates/libmwemu/src/engine/instructions/jbe.rs +++ b/crates/libmwemu/src/engine/instructions/jbe.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jcxz.rs b/crates/libmwemu/src/engine/instructions/jcxz.rs index a2462523..520f9c53 100644 --- a/crates/libmwemu/src/engine/instructions/jcxz.rs +++ b/crates/libmwemu/src/engine/instructions/jcxz.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/je.rs b/crates/libmwemu/src/engine/instructions/je.rs index dc37b96e..66c8ecbd 100644 --- a/crates/libmwemu/src/engine/instructions/je.rs +++ b/crates/libmwemu/src/engine/instructions/je.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jecxz.rs b/crates/libmwemu/src/engine/instructions/jecxz.rs index a2462523..520f9c53 100644 --- a/crates/libmwemu/src/engine/instructions/jecxz.rs +++ b/crates/libmwemu/src/engine/instructions/jecxz.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jg.rs b/crates/libmwemu/src/engine/instructions/jg.rs index 94507e8e..c72dcf0c 100644 --- a/crates/libmwemu/src/engine/instructions/jg.rs +++ b/crates/libmwemu/src/engine/instructions/jg.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jge.rs b/crates/libmwemu/src/engine/instructions/jge.rs index 27f41f42..b689bba3 100644 --- a/crates/libmwemu/src/engine/instructions/jge.rs +++ b/crates/libmwemu/src/engine/instructions/jge.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jl.rs b/crates/libmwemu/src/engine/instructions/jl.rs index d29c9afb..70f0b833 100644 --- a/crates/libmwemu/src/engine/instructions/jl.rs +++ b/crates/libmwemu/src/engine/instructions/jl.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jle.rs b/crates/libmwemu/src/engine/instructions/jle.rs index 107fdcd5..51c498ac 100644 --- a/crates/libmwemu/src/engine/instructions/jle.rs +++ b/crates/libmwemu/src/engine/instructions/jle.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jmp.rs b/crates/libmwemu/src/engine/instructions/jmp.rs index c8036937..dcedcbf8 100644 --- a/crates/libmwemu/src/engine/instructions/jmp.rs +++ b/crates/libmwemu/src/engine/instructions/jmp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Yellow"), ins); @@ -9,7 +9,6 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste unimplemented!("weird variant of jmp"); } - let addr = match emu.get_jump_value(ins, 0) { Some(a) => a, None => return false, diff --git a/crates/libmwemu/src/engine/instructions/jne.rs b/crates/libmwemu/src/engine/instructions/jne.rs index 7f13b68c..3c6726bc 100644 --- a/crates/libmwemu/src/engine/instructions/jne.rs +++ b/crates/libmwemu/src/engine/instructions/jne.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jno.rs b/crates/libmwemu/src/engine/instructions/jno.rs index 07ea9e17..872dfbf6 100644 --- a/crates/libmwemu/src/engine/instructions/jno.rs +++ b/crates/libmwemu/src/engine/instructions/jno.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jnp.rs b/crates/libmwemu/src/engine/instructions/jnp.rs index 6403fcdf..932e6cee 100644 --- a/crates/libmwemu/src/engine/instructions/jnp.rs +++ b/crates/libmwemu/src/engine/instructions/jnp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jns.rs b/crates/libmwemu/src/engine/instructions/jns.rs index cd04bfcb..e58e228e 100644 --- a/crates/libmwemu/src/engine/instructions/jns.rs +++ b/crates/libmwemu/src/engine/instructions/jns.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jo.rs b/crates/libmwemu/src/engine/instructions/jo.rs index 4080e65e..0ffd6977 100644 --- a/crates/libmwemu/src/engine/instructions/jo.rs +++ b/crates/libmwemu/src/engine/instructions/jo.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jp.rs b/crates/libmwemu/src/engine/instructions/jp.rs index a56fe39c..f2a5a399 100644 --- a/crates/libmwemu/src/engine/instructions/jp.rs +++ b/crates/libmwemu/src/engine/instructions/jp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/jrcxz.rs b/crates/libmwemu/src/engine/instructions/jrcxz.rs index 7c2d1db4..df6214ae 100644 --- a/crates/libmwemu/src/engine/instructions/jrcxz.rs +++ b/crates/libmwemu/src/engine/instructions/jrcxz.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.regs_mut().rcx == 0 { diff --git a/crates/libmwemu/src/engine/instructions/js.rs b/crates/libmwemu/src/engine/instructions/js.rs index c279b967..cc448563 100644 --- a/crates/libmwemu/src/engine/instructions/js.rs +++ b/crates/libmwemu/src/engine/instructions/js.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 1); diff --git a/crates/libmwemu/src/engine/instructions/lahf.rs b/crates/libmwemu/src/engine/instructions/lahf.rs index 0a06a30c..e82bf631 100644 --- a/crates/libmwemu/src/engine/instructions/lahf.rs +++ b/crates/libmwemu/src/engine/instructions/lahf.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, set_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ldmxcsr.rs b/crates/libmwemu/src/engine/instructions/ldmxcsr.rs index b8cbab0c..bfe5a490 100644 --- a/crates/libmwemu/src/engine/instructions/ldmxcsr.rs +++ b/crates/libmwemu/src/engine/instructions/ldmxcsr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lea.rs b/crates/libmwemu/src/engine/instructions/lea.rs index 515d874a..5c612aab 100644 --- a/crates/libmwemu/src/engine/instructions/lea.rs +++ b/crates/libmwemu/src/engine/instructions/lea.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/leave.rs b/crates/libmwemu/src/engine/instructions/leave.rs index 5cce6eb5..5e51a892 100644 --- a/crates/libmwemu/src/engine/instructions/leave.rs +++ b/crates/libmwemu/src/engine/instructions/leave.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/les.rs b/crates/libmwemu/src/engine/instructions/les.rs index 5c5d29bb..ad12ec6b 100644 --- a/crates/libmwemu/src/engine/instructions/les.rs +++ b/crates/libmwemu/src/engine/instructions/les.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lfence.rs b/crates/libmwemu/src/engine/instructions/lfence.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/lfence.rs +++ b/crates/libmwemu/src/engine/instructions/lfence.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lodsb.rs b/crates/libmwemu/src/engine/instructions/lodsb.rs index 440b0cbb..18229aaf 100644 --- a/crates/libmwemu/src/engine/instructions/lodsb.rs +++ b/crates/libmwemu/src/engine/instructions/lodsb.rs @@ -1,7 +1,7 @@ -use crate::emu::Emu; +use crate::color; use crate::console::Console; -use crate::{color}; -use iced_x86::{Instruction}; +use crate::emu::Emu; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lodsd.rs b/crates/libmwemu/src/engine/instructions/lodsd.rs index 9389ba51..8bd081fd 100644 --- a/crates/libmwemu/src/engine/instructions/lodsd.rs +++ b/crates/libmwemu/src/engine/instructions/lodsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lodsq.rs b/crates/libmwemu/src/engine/instructions/lodsq.rs index adfc452d..b13c1ad0 100644 --- a/crates/libmwemu/src/engine/instructions/lodsq.rs +++ b/crates/libmwemu/src/engine/instructions/lodsq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lodsw.rs b/crates/libmwemu/src/engine/instructions/lodsw.rs index 02b9317c..06b5d3c3 100644 --- a/crates/libmwemu/src/engine/instructions/lodsw.rs +++ b/crates/libmwemu/src/engine/instructions/lodsw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/loop.rs b/crates/libmwemu/src/engine/instructions/loop.rs index 9caab1c3..08e7a54e 100644 --- a/crates/libmwemu/src/engine/instructions/loop.rs +++ b/crates/libmwemu/src/engine/instructions/loop.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Yellow"), ins); diff --git a/crates/libmwemu/src/engine/instructions/loope.rs b/crates/libmwemu/src/engine/instructions/loope.rs index 5de053a9..d3e0ddbd 100644 --- a/crates/libmwemu/src/engine/instructions/loope.rs +++ b/crates/libmwemu/src/engine/instructions/loope.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Yellow"), ins); diff --git a/crates/libmwemu/src/engine/instructions/loopne.rs b/crates/libmwemu/src/engine/instructions/loopne.rs index 68dc7352..3b0fb98a 100644 --- a/crates/libmwemu/src/engine/instructions/loopne.rs +++ b/crates/libmwemu/src/engine/instructions/loopne.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Yellow"), ins); diff --git a/crates/libmwemu/src/engine/instructions/lzcnt.rs b/crates/libmwemu/src/engine/instructions/lzcnt.rs index a97cb87e..5f86945f 100644 --- a/crates/libmwemu/src/engine/instructions/lzcnt.rs +++ b/crates/libmwemu/src/engine/instructions/lzcnt.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mfence.rs b/crates/libmwemu/src/engine/instructions/mfence.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/mfence.rs +++ b/crates/libmwemu/src/engine/instructions/mfence.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mod.rs b/crates/libmwemu/src/engine/instructions/mod.rs index a7c0fc23..05fd55de 100644 --- a/crates/libmwemu/src/engine/instructions/mod.rs +++ b/crates/libmwemu/src/engine/instructions/mod.rs @@ -1,64 +1,30 @@ // Auto-generated module declarations for instructions -pub mod jmp; -pub mod call; -pub mod push; -pub mod pop; -pub mod pushad; -pub mod popad; -pub mod popcnt; -pub mod lzcnt; -pub mod pdep; -pub mod cdqe; -pub mod cdq; -pub mod cqo; -pub mod ret; -pub mod xchg; pub mod aad; -pub mod les; -pub mod mov; -pub mod movnti; -pub mod xor; -pub mod add; pub mod adc; -pub mod sbb; -pub mod sub; -pub mod inc; -pub mod dec; -pub mod neg; -pub mod not; +pub mod add; +pub mod addpd; +pub mod addps; +pub mod addsd; +pub mod addss; pub mod and; -pub mod or; -pub mod sal; -pub mod sar; -pub mod shl; -pub mod shr; -pub mod ror; -pub mod rcr; -pub mod rol; -pub mod rcl; -pub mod mul; -pub mod div; -pub mod idiv; -pub mod imul; -pub mod bt; -pub mod btc; -pub mod bts; -pub mod btr; +pub mod andpd; +pub mod arpl; +pub mod bound; pub mod bsf; pub mod bsr; pub mod bswap; -pub mod xadd; -pub mod ucomiss; -pub mod ucomisd; -pub mod movss; -pub mod movsxd; -pub mod movsx; -pub mod movzx; -pub mod movsb; -pub mod movsw; -pub mod movsq; -pub mod movsd; +pub mod bt; +pub mod btc; +pub mod btr; +pub mod bts; +pub mod call; +pub mod cbw; +pub mod cdq; +pub mod cdqe; +pub mod clc; +pub mod cld; +pub mod cmc; pub mod cmova; pub mod cmovae; pub mod cmovb; @@ -68,279 +34,313 @@ pub mod cmovg; pub mod cmovge; pub mod cmovl; pub mod cmovle; -pub mod cmovno; pub mod cmovne; -pub mod cmovp; +pub mod cmovno; pub mod cmovnp; -pub mod cmovs; pub mod cmovns; pub mod cmovo; -pub mod seta; -pub mod setae; -pub mod setb; -pub mod setbe; -pub mod sete; -pub mod setg; -pub mod setge; -pub mod setl; -pub mod setle; -pub mod setne; -pub mod setno; -pub mod setnp; -pub mod setns; -pub mod seto; -pub mod setp; -pub mod sets; -pub mod stosb; -pub mod stosw; -pub mod stosd; -pub mod stosq; -pub mod scasb; -pub mod scasw; -pub mod scasd; -pub mod scasq; -pub mod test; -pub mod cmpxchg; -pub mod cmpxchg8b; -pub mod cmpxchg16b; +pub mod cmovp; +pub mod cmovs; pub mod cmp; -pub mod cmpsq; +pub mod cmpsb; pub mod cmpsd; +pub mod cmpsq; pub mod cmpsw; -pub mod cmpsb; -pub mod jo; -pub mod jno; -pub mod js; -pub mod jns; -pub mod je; -pub mod jne; -pub mod jb; -pub mod jae; -pub mod jbe; -pub mod ja; -pub mod jl; -pub mod jge; -pub mod jle; -pub mod jg; -pub mod jp; -pub mod jnp; -pub mod jcxz; -pub mod jecxz; -pub mod jrcxz; -pub mod int3; -pub mod nop; -pub mod fnop; -pub mod mfence; -pub mod lfence; -pub mod sfence; +pub mod cmpxchg; +pub mod cmpxchg16b; +pub mod cmpxchg8b; pub mod cpuid; -pub mod clc; -pub mod rdtsc; -pub mod rdtscp; -pub mod r#loop; -pub mod loope; -pub mod loopne; -pub mod lea; -pub mod leave; -pub mod int; -pub mod syscall; -pub mod std; -pub mod stc; -pub mod cmc; -pub mod cld; -pub mod lodsq; -pub mod lodsd; -pub mod lodsw; -pub mod lodsb; -pub mod cbw; -pub mod cwde; +pub mod cqo; +pub mod cvtsi2sd; +pub mod cvtsi2ss; pub mod cwd; -pub mod fninit; -pub mod finit; -pub mod ffree; +pub mod cwde; +pub mod daa; +pub mod dec; +pub mod div; +pub mod emms; +pub mod endbr32; +pub mod endbr64; +pub mod enqcmd; +pub mod enqcmds; +pub mod enter; +pub mod f2xm1; +pub mod fabs; +pub mod fadd; +pub mod faddp; pub mod fbld; -pub mod fldcw; -pub mod fnstenv; -pub mod fld; -pub mod fldz; -pub mod fld1; -pub mod fldpi; -pub mod fldl2t; -pub mod fldlg2; -pub mod fldln2; -pub mod fldl2e; -pub mod fst; -pub mod fsubrp; -pub mod fstp; -pub mod fincstp; -pub mod fild; -pub mod fist; -pub mod fxtract; -pub mod fxsave; -pub mod fxrstor; -pub mod fistp; -pub mod fcmove; +pub mod fchs; pub mod fcmovb; pub mod fcmovbe; -pub mod fcmovu; +pub mod fcmove; pub mod fcmovnb; -pub mod fcmovne; pub mod fcmovnbe; +pub mod fcmovne; pub mod fcmovnu; -pub mod fxch; -pub mod fsqrt; -pub mod fchs; -pub mod fptan; -pub mod fmulp; -pub mod fdivp; -pub mod fsubp; -pub mod fsubr; -pub mod fsub; -pub mod fadd; -pub mod fucom; -pub mod f2xm1; -pub mod fyl2x; -pub mod fyl2xp1; -pub mod faddp; -pub mod fnclex; +pub mod fcmovu; pub mod fcom; -pub mod fmul; -pub mod fabs; -pub mod fsin; +pub mod fcomp; pub mod fcos; +pub mod fdecstp; pub mod fdiv; +pub mod fdivp; pub mod fdivr; pub mod fdivrp; +pub mod ffree; +pub mod fild; +pub mod fincstp; +pub mod finit; +pub mod fist; +pub mod fistp; +pub mod fld; +pub mod fld1; +pub mod fldcw; +pub mod fldl2e; +pub mod fldl2t; +pub mod fldlg2; +pub mod fldln2; +pub mod fldpi; +pub mod fldz; +pub mod fmul; +pub mod fmulp; +pub mod fnclex; +pub mod fninit; +pub mod fnop; +pub mod fnstcw; +pub mod fnstenv; pub mod fpatan; pub mod fprem; pub mod fprem1; -pub mod popf; -pub mod popfd; -pub mod popfq; -pub mod daa; -pub mod shld; -pub mod shrd; -pub mod sysenter; -pub mod pcmpeqd; -pub mod psubusb; -pub mod punpckhbw; -pub mod pand; -pub mod por; -pub mod pxor; -pub mod punpcklbw; -pub mod punpcklwd; -pub mod xorps; -pub mod xorpd; -pub mod psubb; -pub mod psubw; -pub mod psubd; -pub mod psubq; +pub mod fptan; +pub mod frndint; +pub mod fscale; +pub mod fsin; +pub mod fsincos; +pub mod fsqrt; +pub mod fst; +pub mod fstp; +pub mod fsub; +pub mod fsubp; +pub mod fsubr; +pub mod fsubrp; +pub mod ftst; +pub mod fucom; +pub mod fxam; +pub mod fxch; +pub mod fxrstor; +pub mod fxsave; +pub mod fxtract; +pub mod fyl2x; +pub mod fyl2xp1; +pub mod idiv; +pub mod imul; +pub mod inc; +pub mod int; +pub mod int3; +pub mod ja; +pub mod jae; +pub mod jb; +pub mod jbe; +pub mod jcxz; +pub mod je; +pub mod jecxz; +pub mod jg; +pub mod jge; +pub mod jl; +pub mod jle; +pub mod jmp; +pub mod jne; +pub mod jno; +pub mod jnp; +pub mod jns; +pub mod jo; +pub mod jp; +pub mod jrcxz; +pub mod js; +pub mod lahf; +pub mod ldmxcsr; +pub mod lea; +pub mod leave; +pub mod les; +pub mod lfence; +pub mod lodsb; +pub mod lodsd; +pub mod lodsq; +pub mod lodsw; +pub mod r#loop; +pub mod loope; +pub mod loopne; +pub mod lzcnt; +pub mod mfence; +pub mod mov; +pub mod movapd; +pub mod movaps; +pub mod movd; +pub mod movdqa; +pub mod movdqu; pub mod movhpd; +pub mod movhps; +pub mod movlhps; pub mod movlpd; pub mod movlps; -pub mod cvtsi2sd; -pub mod cvtsi2ss; -pub mod movhps; -pub mod punpcklqdq; +pub mod movnti; pub mod movq; -pub mod punpckhdq; -pub mod punpckldq; -pub mod movd; -pub mod movdqa; -pub mod andpd; -pub mod orpd; -pub mod addps; -pub mod addpd; -pub mod addsd; -pub mod addss; -pub mod subps; -pub mod subpd; -pub mod subsd; -pub mod subss; +pub mod movsb; +pub mod movsd; +pub mod movsq; +pub mod movss; +pub mod movsw; +pub mod movsx; +pub mod movsxd; +pub mod movups; +pub mod movzx; +pub mod mul; pub mod mulpd; pub mod mulps; pub mod mulsd; pub mod mulss; -pub mod packsswb; +pub mod mwait; +pub mod neg; +pub mod nop; +pub mod not; +pub mod or; +pub mod orpd; pub mod packssdw; -pub mod psrldq; -pub mod pslld; -pub mod pslldq; -pub mod psllq; -pub mod psllw; -pub mod paddsw; +pub mod packsswb; +pub mod packuswb; +pub mod paddb; +pub mod paddd; pub mod paddsb; -pub mod psrad; +pub mod paddsw; pub mod paddusb; -pub mod paddb; pub mod paddusw; pub mod paddw; -pub mod pshufd; -pub mod movups; -pub mod movdqu; -pub mod vzeroupper; -pub mod vmovdqu; -pub mod vmovdqa; -pub mod movaps; -pub mod movapd; -pub mod vmovd; -pub mod vmovq; -pub mod vpbroadcastb; -pub mod vpor; -pub mod vpxor; -pub mod pcmpeqb; -pub mod psubsb; -pub mod fcomp; -pub mod psrlq; -pub mod psubsw; -pub mod fsincos; -pub mod packuswb; +pub mod pand; pub mod pandn; -pub mod psrld; -pub mod punpckhwd; -pub mod psraw; -pub mod frndint; -pub mod psrlw; -pub mod paddd; -pub mod fscale; -pub mod vpcmpeqb; -pub mod pmullw; -pub mod pmulhw; -pub mod pmovmskb; -pub mod vpmovmskb; -pub mod vpminub; -pub mod fdecstp; -pub mod ftst; -pub mod emms; -pub mod fxam; -pub mod pcmpgtw; -pub mod pcmpgtb; +pub mod pause; +pub mod pcmpeqb; +pub mod pcmpeqd; pub mod pcmpeqw; +pub mod pcmpgtb; pub mod pcmpgtd; +pub mod pcmpgtw; +pub mod pdep; pub mod pmaddwd; -pub mod tzcnt; -pub mod xgetbv; -pub mod arpl; +pub mod pmovmskb; +pub mod pmulhw; +pub mod pmullw; +pub mod pop; +pub mod popad; +pub mod popcnt; +pub mod popf; +pub mod popfd; +pub mod popfq; +pub mod por; +pub mod prefetchnta; +pub mod prefetchw; +pub mod pshufd; +pub mod pshufhw; +pub mod pshuflw; +pub mod pslld; +pub mod pslldq; +pub mod psllq; +pub mod psllw; +pub mod psrad; +pub mod psraw; +pub mod psrld; +pub mod psrldq; +pub mod psrlq; +pub mod psrlw; +pub mod psubb; +pub mod psubd; +pub mod psubq; +pub mod psubsb; +pub mod psubsw; +pub mod psubusb; +pub mod psubw; +pub mod punpckhbw; +pub mod punpckhdq; +pub mod punpckhwd; +pub mod punpcklbw; +pub mod punpckldq; +pub mod punpcklqdq; +pub mod punpcklwd; +pub mod push; +pub mod pushad; pub mod pushf; pub mod pushfd; pub mod pushfq; -pub mod bound; -pub mod lahf; +pub mod pxor; +pub mod rcl; +pub mod rcr; +pub mod rdmsr; +pub mod rdtsc; +pub mod rdtscp; +pub mod ret; +pub mod rol; +pub mod ror; +pub mod sal; pub mod salc; -pub mod movlhps; -pub mod pshuflw; -pub mod pshufhw; +pub mod sar; +pub mod sbb; +pub mod scasb; +pub mod scasd; +pub mod scasq; +pub mod scasw; +pub mod seta; +pub mod setae; +pub mod setb; +pub mod setbe; +pub mod sete; +pub mod setg; +pub mod setge; +pub mod setl; +pub mod setle; +pub mod setne; +pub mod setno; +pub mod setnp; +pub mod setns; +pub mod seto; +pub mod setp; +pub mod sets; +pub mod sfence; +pub mod shl; +pub mod shld; +pub mod shr; +pub mod shrd; +pub mod stc; +pub mod std; pub mod stmxcsr; -pub mod ldmxcsr; -pub mod fnstcw; -pub mod prefetchnta; -pub mod prefetchw; -pub mod pause; +pub mod stosb; +pub mod stosd; +pub mod stosq; +pub mod stosw; +pub mod sub; +pub mod subpd; +pub mod subps; +pub mod subsd; +pub mod subss; +pub mod syscall; +pub mod sysenter; +pub mod test; +pub mod tzcnt; +pub mod ucomisd; +pub mod ucomiss; +pub mod vmovd; +pub mod vmovdqa; +pub mod vmovdqu; +pub mod vmovq; +pub mod vpbroadcastb; +pub mod vpcmpeqb; +pub mod vpminub; +pub mod vpmovmskb; +pub mod vpor; +pub mod vpxor; +pub mod vzeroupper; pub mod wait; -pub mod mwait; -pub mod endbr64; -pub mod endbr32; -pub mod enqcmd; -pub mod enqcmds; -pub mod enter; -pub mod rdmsr; +pub mod xadd; +pub mod xchg; +pub mod xgetbv; +pub mod xor; +pub mod xorpd; +pub mod xorps; diff --git a/crates/libmwemu/src/engine/instructions/mov.rs b/crates/libmwemu/src/engine/instructions/mov.rs index 4542fc1b..c71e1768 100644 --- a/crates/libmwemu/src/engine/instructions/mov.rs +++ b/crates/libmwemu/src/engine/instructions/mov.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 2); @@ -12,7 +12,10 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste return false; } }; - emu.show_instruction_comment(color!("LightCyan"), ins, &format!("0x{:x}", value1)); + if emu.cfg.verbose >= 2 { + emu.show_instruction_comment(color!("LightCyan"), ins, &format!("0x{:x}", value1)); + } + /* if emu.pos == 189464541 { diff --git a/crates/libmwemu/src/engine/instructions/movapd.rs b/crates/libmwemu/src/engine/instructions/movapd.rs index 13289cf0..78b27897 100644 --- a/crates/libmwemu/src/engine/instructions/movapd.rs +++ b/crates/libmwemu/src/engine/instructions/movapd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movaps.rs b/crates/libmwemu/src/engine/instructions/movaps.rs index 13289cf0..78b27897 100644 --- a/crates/libmwemu/src/engine/instructions/movaps.rs +++ b/crates/libmwemu/src/engine/instructions/movaps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movd.rs b/crates/libmwemu/src/engine/instructions/movd.rs index f5eaa18a..d18beee6 100644 --- a/crates/libmwemu/src/engine/instructions/movd.rs +++ b/crates/libmwemu/src/engine/instructions/movd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // the high part is cleared to zero diff --git a/crates/libmwemu/src/engine/instructions/movdqa.rs b/crates/libmwemu/src/engine/instructions/movdqa.rs index 8078fa98..c1b67aa6 100644 --- a/crates/libmwemu/src/engine/instructions/movdqa.rs +++ b/crates/libmwemu/src/engine/instructions/movdqa.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -54,8 +54,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let result = u128::from_le_bytes([ bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], - bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], - bytes[15], + bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15], ]); emu.set_operand_xmm_value_128(ins, 0, result); diff --git a/crates/libmwemu/src/engine/instructions/movdqu.rs b/crates/libmwemu/src/engine/instructions/movdqu.rs index 64f4ab30..bdd04be0 100644 --- a/crates/libmwemu/src/engine/instructions/movdqu.rs +++ b/crates/libmwemu/src/engine/instructions/movdqu.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movhpd.rs b/crates/libmwemu/src/engine/instructions/movhpd.rs index 4130790e..5ed7f210 100644 --- a/crates/libmwemu/src/engine/instructions/movhpd.rs +++ b/crates/libmwemu/src/engine/instructions/movhpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // we keep the high part of xmm destination diff --git a/crates/libmwemu/src/engine/instructions/movhps.rs b/crates/libmwemu/src/engine/instructions/movhps.rs index 8c197784..562d76af 100644 --- a/crates/libmwemu/src/engine/instructions/movhps.rs +++ b/crates/libmwemu/src/engine/instructions/movhps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movlhps.rs b/crates/libmwemu/src/engine/instructions/movlhps.rs index 07937d94..c502e280 100644 --- a/crates/libmwemu/src/engine/instructions/movlhps.rs +++ b/crates/libmwemu/src/engine/instructions/movlhps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movlpd.rs b/crates/libmwemu/src/engine/instructions/movlpd.rs index 37ee33e4..3e4f1da4 100644 --- a/crates/libmwemu/src/engine/instructions/movlpd.rs +++ b/crates/libmwemu/src/engine/instructions/movlpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // we keep the high part of xmm destination diff --git a/crates/libmwemu/src/engine/instructions/movlps.rs b/crates/libmwemu/src/engine/instructions/movlps.rs index 37ee33e4..3e4f1da4 100644 --- a/crates/libmwemu/src/engine/instructions/movlps.rs +++ b/crates/libmwemu/src/engine/instructions/movlps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { // we keep the high part of xmm destination diff --git a/crates/libmwemu/src/engine/instructions/movnti.rs b/crates/libmwemu/src/engine/instructions/movnti.rs index 4542fc1b..6e23e3be 100644 --- a/crates/libmwemu/src/engine/instructions/movnti.rs +++ b/crates/libmwemu/src/engine/instructions/movnti.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(ins.op_count() == 2); diff --git a/crates/libmwemu/src/engine/instructions/movq.rs b/crates/libmwemu/src/engine/instructions/movq.rs index fd955f9b..c62c6d52 100644 --- a/crates/libmwemu/src/engine/instructions/movq.rs +++ b/crates/libmwemu/src/engine/instructions/movq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movsb.rs b/crates/libmwemu/src/engine/instructions/movsb.rs index 84de5669..22b6a07c 100644 --- a/crates/libmwemu/src/engine/instructions/movsb.rs +++ b/crates/libmwemu/src/engine/instructions/movsb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/movsd.rs b/crates/libmwemu/src/engine/instructions/movsd.rs index f2dd790d..390eacf0 100644 --- a/crates/libmwemu/src/engine/instructions/movsd.rs +++ b/crates/libmwemu/src/engine/instructions/movsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if ins.op_count() == 2 diff --git a/crates/libmwemu/src/engine/instructions/movsq.rs b/crates/libmwemu/src/engine/instructions/movsq.rs index a6d8f7c2..acb8b0ff 100644 --- a/crates/libmwemu/src/engine/instructions/movsq.rs +++ b/crates/libmwemu/src/engine/instructions/movsq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/movss.rs b/crates/libmwemu/src/engine/instructions/movss.rs index 94251d0a..19101534 100644 --- a/crates/libmwemu/src/engine/instructions/movss.rs +++ b/crates/libmwemu/src/engine/instructions/movss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movsw.rs b/crates/libmwemu/src/engine/instructions/movsw.rs index 436449f3..f8e4e1a8 100644 --- a/crates/libmwemu/src/engine/instructions/movsw.rs +++ b/crates/libmwemu/src/engine/instructions/movsw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/movsx.rs b/crates/libmwemu/src/engine/instructions/movsx.rs index a626e267..977aae5d 100644 --- a/crates/libmwemu/src/engine/instructions/movsx.rs +++ b/crates/libmwemu/src/engine/instructions/movsx.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movsxd.rs b/crates/libmwemu/src/engine/instructions/movsxd.rs index fa8608cb..5488f755 100644 --- a/crates/libmwemu/src/engine/instructions/movsxd.rs +++ b/crates/libmwemu/src/engine/instructions/movsxd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movups.rs b/crates/libmwemu/src/engine/instructions/movups.rs index ca494b12..7aae5771 100644 --- a/crates/libmwemu/src/engine/instructions/movups.rs +++ b/crates/libmwemu/src/engine/instructions/movups.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/movzx.rs b/crates/libmwemu/src/engine/instructions/movzx.rs index aca8af2c..d21e4a00 100644 --- a/crates/libmwemu/src/engine/instructions/movzx.rs +++ b/crates/libmwemu/src/engine/instructions/movzx.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mul.rs b/crates/libmwemu/src/engine/instructions/mul.rs index 6ef872c1..35f0b346 100644 --- a/crates/libmwemu/src/engine/instructions/mul.rs +++ b/crates/libmwemu/src/engine/instructions/mul.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::engine::logic; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mulpd.rs b/crates/libmwemu/src/engine/instructions/mulpd.rs index c0da78f3..ed4e209a 100644 --- a/crates/libmwemu/src/engine/instructions/mulpd.rs +++ b/crates/libmwemu/src/engine/instructions/mulpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mulps.rs b/crates/libmwemu/src/engine/instructions/mulps.rs index e1b0865d..a9b46929 100644 --- a/crates/libmwemu/src/engine/instructions/mulps.rs +++ b/crates/libmwemu/src/engine/instructions/mulps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -22,8 +22,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let a: u128 = (value0 & 0xffffffff) * (value1 & 0xffffffff); let b: u128 = (value0 & 0xffffffff00000000) * (value1 & 0xffffffff00000000); - let c: u128 = - (value0 & 0xffffffff0000000000000000) * (value1 & 0xffffffff0000000000000000); + let c: u128 = (value0 & 0xffffffff0000000000000000) * (value1 & 0xffffffff0000000000000000); let d: u128 = (value0 & 0xffffffff000000000000000000000000) * (value1 & 0xffffffff000000000000000000000000); diff --git a/crates/libmwemu/src/engine/instructions/mulsd.rs b/crates/libmwemu/src/engine/instructions/mulsd.rs index 3ff40ead..1905b63c 100644 --- a/crates/libmwemu/src/engine/instructions/mulsd.rs +++ b/crates/libmwemu/src/engine/instructions/mulsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mulss.rs b/crates/libmwemu/src/engine/instructions/mulss.rs index 76624d09..ee5bb742 100644 --- a/crates/libmwemu/src/engine/instructions/mulss.rs +++ b/crates/libmwemu/src/engine/instructions/mulss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/mwait.rs b/crates/libmwemu/src/engine/instructions/mwait.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/mwait.rs +++ b/crates/libmwemu/src/engine/instructions/mwait.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/neg.rs b/crates/libmwemu/src/engine/instructions/neg.rs index c96a9356..89d95d96 100644 --- a/crates/libmwemu/src/engine/instructions/neg.rs +++ b/crates/libmwemu/src/engine/instructions/neg.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/nop.rs b/crates/libmwemu/src/engine/instructions/nop.rs index cd1a6605..ffc033ea 100644 --- a/crates/libmwemu/src/engine/instructions/nop.rs +++ b/crates/libmwemu/src/engine/instructions/nop.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightPurple"), ins); diff --git a/crates/libmwemu/src/engine/instructions/not.rs b/crates/libmwemu/src/engine/instructions/not.rs index edb5c613..af7ae54c 100644 --- a/crates/libmwemu/src/engine/instructions/not.rs +++ b/crates/libmwemu/src/engine/instructions/not.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/or.rs b/crates/libmwemu/src/engine/instructions/or.rs index 950849bd..02425d34 100644 --- a/crates/libmwemu/src/engine/instructions/or.rs +++ b/crates/libmwemu/src/engine/instructions/or.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/orpd.rs b/crates/libmwemu/src/engine/instructions/orpd.rs index 87453577..7634d02c 100644 --- a/crates/libmwemu/src/engine/instructions/orpd.rs +++ b/crates/libmwemu/src/engine/instructions/orpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/packssdw.rs b/crates/libmwemu/src/engine/instructions/packssdw.rs index 8a00fad9..ce93da78 100644 --- a/crates/libmwemu/src/engine/instructions/packssdw.rs +++ b/crates/libmwemu/src/engine/instructions/packssdw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -22,22 +22,18 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let mut result: u128; result = (value0 & 0xffffffff) as u32 as i32 as i16 as u16 as u128; + result |= (((value0 & 0xffffffff00000000) >> 32) as u32 as i32 as i16 as u16 as u128) << 16; result |= - (((value0 & 0xffffffff00000000) >> 32) as u32 as i32 as i16 as u16 as u128) << 16; - result |= (((value0 & 0xffffffff0000000000000000) >> 64) as u32 as i32 as i16 as u16 + (((value0 & 0xffffffff0000000000000000) >> 64) as u32 as i32 as i16 as u16 as u128) << 32; + result |= (((value0 & 0xffffffff000000000000000000000000) >> 96) as u32 as i32 as i16 as u16 as u128) - << 32; - result |= (((value0 & 0xffffffff000000000000000000000000) >> 96) as u32 as i32 as i16 - as u16 as u128) << 48; result |= ((value1 & 0xffffffff) as u32 as i32 as i16 as u16 as u128) << 64; + result |= (((value1 & 0xffffffff00000000) >> 32) as u32 as i32 as i16 as u16 as u128) << 80; result |= - (((value1 & 0xffffffff00000000) >> 32) as u32 as i32 as i16 as u16 as u128) << 80; - result |= (((value1 & 0xffffffff0000000000000000) >> 64) as u32 as i32 as i16 as u16 + (((value1 & 0xffffffff0000000000000000) >> 64) as u32 as i32 as i16 as u16 as u128) << 96; + result |= (((value1 & 0xffffffff000000000000000000000000) >> 96) as u32 as i32 as i16 as u16 as u128) - << 96; - result |= (((value1 & 0xffffffff000000000000000000000000) >> 96) as u32 as i32 as i16 - as u16 as u128) << 112; emu.set_operand_xmm_value_128(ins, 0, result); diff --git a/crates/libmwemu/src/engine/instructions/packsswb.rs b/crates/libmwemu/src/engine/instructions/packsswb.rs index d6a7c74d..eb525358 100644 --- a/crates/libmwemu/src/engine/instructions/packsswb.rs +++ b/crates/libmwemu/src/engine/instructions/packsswb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -24,34 +24,26 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste result = (value0 & 0xffff) as u16 as i16 as i8 as u8 as u128; result |= (((value0 & 0xffff0000) >> 16) as u16 as i16 as i8 as u8 as u128) << 8; result |= (((value0 & 0xffff00000000) >> 32) as u16 as i16 as i8 as u8 as u128) << 16; + result |= (((value0 & 0xffff000000000000) >> 48) as u16 as i16 as i8 as u8 as u128) << 24; + result |= (((value0 & 0xffff0000000000000000) >> 64) as u16 as i16 as i8 as u8 as u128) << 32; result |= - (((value0 & 0xffff000000000000) >> 48) as u16 as i16 as i8 as u8 as u128) << 24; + (((value0 & 0xffff00000000000000000000) >> 80) as u16 as i16 as i8 as u8 as u128) << 40; result |= - (((value0 & 0xffff0000000000000000) >> 64) as u16 as i16 as i8 as u8 as u128) << 32; - result |= (((value0 & 0xffff00000000000000000000) >> 80) as u16 as i16 as i8 as u8 + (((value0 & 0xffff000000000000000000000000) >> 96) as u16 as i16 as i8 as u8 as u128) << 48; + result |= (((value0 & 0xffff0000000000000000000000000000) >> 112) as u16 as i16 as i8 as u8 as u128) - << 40; - result |= (((value0 & 0xffff000000000000000000000000) >> 96) as u16 as i16 as i8 as u8 - as u128) - << 48; - result |= (((value0 & 0xffff0000000000000000000000000000) >> 112) as u16 as i16 as i8 - as u8 as u128) << 56; result |= ((value1 & 0xffff) as u16 as i16 as i8 as u8 as u128) << 64; result |= (((value1 & 0xffff0000) >> 16) as u16 as i16 as i8 as u8 as u128) << 72; result |= (((value1 & 0xffff00000000) >> 32) as u16 as i16 as i8 as u8 as u128) << 80; + result |= (((value1 & 0xffff000000000000) >> 48) as u16 as i16 as i8 as u8 as u128) << 88; + result |= (((value1 & 0xffff0000000000000000) >> 64) as u16 as i16 as i8 as u8 as u128) << 96; result |= - (((value1 & 0xffff000000000000) >> 48) as u16 as i16 as i8 as u8 as u128) << 88; - result |= - (((value1 & 0xffff0000000000000000) >> 64) as u16 as i16 as i8 as u8 as u128) << 96; - result |= (((value1 & 0xffff00000000000000000000) >> 80) as u16 as i16 as i8 as u8 - as u128) - << 104; - result |= (((value1 & 0xffff000000000000000000000000) >> 96) as u16 as i16 as i8 as u8 - as u128) + (((value1 & 0xffff00000000000000000000) >> 80) as u16 as i16 as i8 as u8 as u128) << 104; + result |= (((value1 & 0xffff000000000000000000000000) >> 96) as u16 as i16 as i8 as u8 as u128) << 112; - result |= (((value1 & 0xffff0000000000000000000000000000) >> 112) as u16 as i16 as i8 - as u8 as u128) + result |= (((value1 & 0xffff0000000000000000000000000000) >> 112) as u16 as i16 as i8 as u8 + as u128) << 120; emu.set_operand_xmm_value_128(ins, 0, result); diff --git a/crates/libmwemu/src/engine/instructions/packuswb.rs b/crates/libmwemu/src/engine/instructions/packuswb.rs index b7190541..440bed0f 100644 --- a/crates/libmwemu/src/engine/instructions/packuswb.rs +++ b/crates/libmwemu/src/engine/instructions/packuswb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/paddb.rs b/crates/libmwemu/src/engine/instructions/paddb.rs index bf77dff6..014fcb53 100644 --- a/crates/libmwemu/src/engine/instructions/paddb.rs +++ b/crates/libmwemu/src/engine/instructions/paddb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -24,74 +24,59 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste if sz == 64 { result = ((value0 & 0xff) as u8 + (value1 & 0xff) as u8) as u128; - result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) + result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) as u128) << 8; + result |= + ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) as u128) << 16; + result |= ((((value0 & 0xff000000) >> 24) as u8 + ((value1 & 0xff000000) >> 24) as u8) as u128) - << 8; - result |= ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) - as u128) - << 16; - result |= ((((value0 & 0xff000000) >> 24) as u8 - + ((value1 & 0xff000000) >> 24) as u8) as u128) << 24; - result |= ((((value0 & 0xff00000000) >> 32) as u8 - + ((value1 & 0xff00000000) >> 32) as u8) as u128) + result |= ((((value0 & 0xff00000000) >> 32) as u8 + ((value1 & 0xff00000000) >> 32) as u8) + as u128) << 32; result |= ((((value0 & 0xff0000000000) >> 40) as u8 + ((value1 & 0xff0000000000) >> 40) as u8) as u128) << 40; result |= ((((value0 & 0xff000000000000) >> 48) as u8 - + ((value1 & 0xff000000000000) >> 48) as u8) - as u128) + + ((value1 & 0xff000000000000) >> 48) as u8) as u128) << 48; result |= ((((value0 & 0xff00000000000000) >> 56) as u8 - + ((value1 & 0xff00000000000000) >> 56) as u8) - as u128) + + ((value1 & 0xff00000000000000) >> 56) as u8) as u128) << 56; } else if sz == 128 { result = ((value0 & 0xff) as u8 + (value1 & 0xff) as u8) as u128; - result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) + result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) as u128) << 8; + result |= + ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) as u128) << 16; + result |= ((((value0 & 0xff000000) >> 24) as u8 + ((value1 & 0xff000000) >> 24) as u8) as u128) - << 8; - result |= ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) - as u128) - << 16; - result |= ((((value0 & 0xff000000) >> 24) as u8 - + ((value1 & 0xff000000) >> 24) as u8) as u128) << 24; - result |= ((((value0 & 0xff00000000) >> 32) as u8 - + ((value1 & 0xff00000000) >> 32) as u8) as u128) + result |= ((((value0 & 0xff00000000) >> 32) as u8 + ((value1 & 0xff00000000) >> 32) as u8) + as u128) << 32; result |= ((((value0 & 0xff0000000000) >> 40) as u8 + ((value1 & 0xff0000000000) >> 40) as u8) as u128) << 40; result |= ((((value0 & 0xff000000000000) >> 48) as u8 - + ((value1 & 0xff000000000000) >> 48) as u8) - as u128) + + ((value1 & 0xff000000000000) >> 48) as u8) as u128) << 48; result |= ((((value0 & 0xff00000000000000) >> 56) as u8 - + ((value1 & 0xff00000000000000) >> 56) as u8) - as u128) + + ((value1 & 0xff00000000000000) >> 56) as u8) as u128) << 56; result |= ((((value0 & 0xff_0000000000000000) >> 64) as u8 - + ((value1 & 0xff_0000000000000000) >> 64) as u8) - as u128) + + ((value1 & 0xff_0000000000000000) >> 64) as u8) as u128) << 64; result |= ((((value0 & 0xff00_0000000000000000) >> 72) as u8 - + ((value1 & 0xff00_0000000000000000) >> 72) as u8) - as u128) + + ((value1 & 0xff00_0000000000000000) >> 72) as u8) as u128) << 72; result |= ((((value0 & 0xff0000_0000000000000000) >> 80) as u8 - + ((value1 & 0xff0000_0000000000000000) >> 80) as u8) - as u128) + + ((value1 & 0xff0000_0000000000000000) >> 80) as u8) as u128) << 80; result |= ((((value0 & 0xff000000_0000000000000000) >> 88) as u8 - + ((value1 & 0xff000000_0000000000000000) >> 88) as u8) - as u128) + + ((value1 & 0xff000000_0000000000000000) >> 88) as u8) as u128) << 88; result |= ((((value0 & 0xff00000000_0000000000000000) >> 96) as u8 - + ((value1 & 0xff00000000_0000000000000000) >> 96) as u8) - as u128) + + ((value1 & 0xff00000000_0000000000000000) >> 96) as u8) as u128) << 96; result |= ((((value0 & 0xff0000000000_0000000000000000) >> 104) as u8 + ((value1 & 0xff0000000000_0000000000000000) >> 104) as u8) diff --git a/crates/libmwemu/src/engine/instructions/paddd.rs b/crates/libmwemu/src/engine/instructions/paddd.rs index 6aa9a5e4..58e58bb6 100644 --- a/crates/libmwemu/src/engine/instructions/paddd.rs +++ b/crates/libmwemu/src/engine/instructions/paddd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/paddsb.rs b/crates/libmwemu/src/engine/instructions/paddsb.rs index 207c1c24..555053dd 100644 --- a/crates/libmwemu/src/engine/instructions/paddsb.rs +++ b/crates/libmwemu/src/engine/instructions/paddsb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/paddsw.rs b/crates/libmwemu/src/engine/instructions/paddsw.rs index ae8a7ab2..fc85c9fe 100644 --- a/crates/libmwemu/src/engine/instructions/paddsw.rs +++ b/crates/libmwemu/src/engine/instructions/paddsw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/paddusb.rs b/crates/libmwemu/src/engine/instructions/paddusb.rs index bf77dff6..014fcb53 100644 --- a/crates/libmwemu/src/engine/instructions/paddusb.rs +++ b/crates/libmwemu/src/engine/instructions/paddusb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -24,74 +24,59 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste if sz == 64 { result = ((value0 & 0xff) as u8 + (value1 & 0xff) as u8) as u128; - result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) + result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) as u128) << 8; + result |= + ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) as u128) << 16; + result |= ((((value0 & 0xff000000) >> 24) as u8 + ((value1 & 0xff000000) >> 24) as u8) as u128) - << 8; - result |= ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) - as u128) - << 16; - result |= ((((value0 & 0xff000000) >> 24) as u8 - + ((value1 & 0xff000000) >> 24) as u8) as u128) << 24; - result |= ((((value0 & 0xff00000000) >> 32) as u8 - + ((value1 & 0xff00000000) >> 32) as u8) as u128) + result |= ((((value0 & 0xff00000000) >> 32) as u8 + ((value1 & 0xff00000000) >> 32) as u8) + as u128) << 32; result |= ((((value0 & 0xff0000000000) >> 40) as u8 + ((value1 & 0xff0000000000) >> 40) as u8) as u128) << 40; result |= ((((value0 & 0xff000000000000) >> 48) as u8 - + ((value1 & 0xff000000000000) >> 48) as u8) - as u128) + + ((value1 & 0xff000000000000) >> 48) as u8) as u128) << 48; result |= ((((value0 & 0xff00000000000000) >> 56) as u8 - + ((value1 & 0xff00000000000000) >> 56) as u8) - as u128) + + ((value1 & 0xff00000000000000) >> 56) as u8) as u128) << 56; } else if sz == 128 { result = ((value0 & 0xff) as u8 + (value1 & 0xff) as u8) as u128; - result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) + result |= ((((value0 & 0xff00) >> 8) as u8 + ((value1 & 0xff00) >> 8) as u8) as u128) << 8; + result |= + ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) as u128) << 16; + result |= ((((value0 & 0xff000000) >> 24) as u8 + ((value1 & 0xff000000) >> 24) as u8) as u128) - << 8; - result |= ((((value0 & 0xff0000) >> 16) as u8 + ((value1 & 0xff0000) >> 16) as u8) - as u128) - << 16; - result |= ((((value0 & 0xff000000) >> 24) as u8 - + ((value1 & 0xff000000) >> 24) as u8) as u128) << 24; - result |= ((((value0 & 0xff00000000) >> 32) as u8 - + ((value1 & 0xff00000000) >> 32) as u8) as u128) + result |= ((((value0 & 0xff00000000) >> 32) as u8 + ((value1 & 0xff00000000) >> 32) as u8) + as u128) << 32; result |= ((((value0 & 0xff0000000000) >> 40) as u8 + ((value1 & 0xff0000000000) >> 40) as u8) as u128) << 40; result |= ((((value0 & 0xff000000000000) >> 48) as u8 - + ((value1 & 0xff000000000000) >> 48) as u8) - as u128) + + ((value1 & 0xff000000000000) >> 48) as u8) as u128) << 48; result |= ((((value0 & 0xff00000000000000) >> 56) as u8 - + ((value1 & 0xff00000000000000) >> 56) as u8) - as u128) + + ((value1 & 0xff00000000000000) >> 56) as u8) as u128) << 56; result |= ((((value0 & 0xff_0000000000000000) >> 64) as u8 - + ((value1 & 0xff_0000000000000000) >> 64) as u8) - as u128) + + ((value1 & 0xff_0000000000000000) >> 64) as u8) as u128) << 64; result |= ((((value0 & 0xff00_0000000000000000) >> 72) as u8 - + ((value1 & 0xff00_0000000000000000) >> 72) as u8) - as u128) + + ((value1 & 0xff00_0000000000000000) >> 72) as u8) as u128) << 72; result |= ((((value0 & 0xff0000_0000000000000000) >> 80) as u8 - + ((value1 & 0xff0000_0000000000000000) >> 80) as u8) - as u128) + + ((value1 & 0xff0000_0000000000000000) >> 80) as u8) as u128) << 80; result |= ((((value0 & 0xff000000_0000000000000000) >> 88) as u8 - + ((value1 & 0xff000000_0000000000000000) >> 88) as u8) - as u128) + + ((value1 & 0xff000000_0000000000000000) >> 88) as u8) as u128) << 88; result |= ((((value0 & 0xff00000000_0000000000000000) >> 96) as u8 - + ((value1 & 0xff00000000_0000000000000000) >> 96) as u8) - as u128) + + ((value1 & 0xff00000000_0000000000000000) >> 96) as u8) as u128) << 96; result |= ((((value0 & 0xff0000000000_0000000000000000) >> 104) as u8 + ((value1 & 0xff0000000000_0000000000000000) >> 104) as u8) diff --git a/crates/libmwemu/src/engine/instructions/paddusw.rs b/crates/libmwemu/src/engine/instructions/paddusw.rs index 4b0354c7..50f01d57 100644 --- a/crates/libmwemu/src/engine/instructions/paddusw.rs +++ b/crates/libmwemu/src/engine/instructions/paddusw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -24,36 +24,32 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste if sz == 64 { result = ((value0 & 0xffff) as u16 + (value1 & 0xffff) as u16) as u128; - result |= ((((value0 & 0xffff0000) >> 16) as u16 - + ((value1 & 0xffff0000) >> 16) as u16) as u128) + result |= ((((value0 & 0xffff0000) >> 16) as u16 + ((value1 & 0xffff0000) >> 16) as u16) + as u128) << 16; result |= ((((value0 & 0xffff00000000) >> 32) as u16 + ((value1 & 0xffff00000000) >> 32) as u16) as u128) << 32; result |= ((((value0 & 0xffff000000000000) >> 48) as u16 - + ((value1 & 0xffff000000000000) >> 48) as u16) - as u128) + + ((value1 & 0xffff000000000000) >> 48) as u16) as u128) << 48; } else if sz == 128 { result = ((value0 & 0xffff) as u16 + (value1 & 0xffff) as u16) as u128; - result |= ((((value0 & 0xffff0000) >> 16) as u16 - + ((value1 & 0xffff0000) >> 16) as u16) as u128) + result |= ((((value0 & 0xffff0000) >> 16) as u16 + ((value1 & 0xffff0000) >> 16) as u16) + as u128) << 16; result |= ((((value0 & 0xffff00000000) >> 32) as u16 + ((value1 & 0xffff00000000) >> 32) as u16) as u128) << 32; result |= ((((value0 & 0xffff000000000000) >> 48) as u16 - + ((value1 & 0xffff000000000000) >> 48) as u16) - as u128) + + ((value1 & 0xffff000000000000) >> 48) as u16) as u128) << 48; result |= ((((value0 & 0xffff_0000000000000000) >> 64) as u16 - + ((value1 & 0xffff_0000000000000000) >> 64) as u16) - as u128) + + ((value1 & 0xffff_0000000000000000) >> 64) as u16) as u128) << 64; result |= ((((value0 & 0xffff0000_0000000000000000) >> 80) as u16 - + ((value1 & 0xffff0000_0000000000000000) >> 80) as u16) - as u128) + + ((value1 & 0xffff0000_0000000000000000) >> 80) as u16) as u128) << 80; result |= ((((value0 & 0xffff00000000_0000000000000000) >> 96) as u16 + ((value1 & 0xffff00000000_0000000000000000) >> 96) as u16) diff --git a/crates/libmwemu/src/engine/instructions/paddw.rs b/crates/libmwemu/src/engine/instructions/paddw.rs index 4b0354c7..50f01d57 100644 --- a/crates/libmwemu/src/engine/instructions/paddw.rs +++ b/crates/libmwemu/src/engine/instructions/paddw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -24,36 +24,32 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste if sz == 64 { result = ((value0 & 0xffff) as u16 + (value1 & 0xffff) as u16) as u128; - result |= ((((value0 & 0xffff0000) >> 16) as u16 - + ((value1 & 0xffff0000) >> 16) as u16) as u128) + result |= ((((value0 & 0xffff0000) >> 16) as u16 + ((value1 & 0xffff0000) >> 16) as u16) + as u128) << 16; result |= ((((value0 & 0xffff00000000) >> 32) as u16 + ((value1 & 0xffff00000000) >> 32) as u16) as u128) << 32; result |= ((((value0 & 0xffff000000000000) >> 48) as u16 - + ((value1 & 0xffff000000000000) >> 48) as u16) - as u128) + + ((value1 & 0xffff000000000000) >> 48) as u16) as u128) << 48; } else if sz == 128 { result = ((value0 & 0xffff) as u16 + (value1 & 0xffff) as u16) as u128; - result |= ((((value0 & 0xffff0000) >> 16) as u16 - + ((value1 & 0xffff0000) >> 16) as u16) as u128) + result |= ((((value0 & 0xffff0000) >> 16) as u16 + ((value1 & 0xffff0000) >> 16) as u16) + as u128) << 16; result |= ((((value0 & 0xffff00000000) >> 32) as u16 + ((value1 & 0xffff00000000) >> 32) as u16) as u128) << 32; result |= ((((value0 & 0xffff000000000000) >> 48) as u16 - + ((value1 & 0xffff000000000000) >> 48) as u16) - as u128) + + ((value1 & 0xffff000000000000) >> 48) as u16) as u128) << 48; result |= ((((value0 & 0xffff_0000000000000000) >> 64) as u16 - + ((value1 & 0xffff_0000000000000000) >> 64) as u16) - as u128) + + ((value1 & 0xffff_0000000000000000) >> 64) as u16) as u128) << 64; result |= ((((value0 & 0xffff0000_0000000000000000) >> 80) as u16 - + ((value1 & 0xffff0000_0000000000000000) >> 80) as u16) - as u128) + + ((value1 & 0xffff0000_0000000000000000) >> 80) as u16) as u128) << 80; result |= ((((value0 & 0xffff00000000_0000000000000000) >> 96) as u16 + ((value1 & 0xffff00000000_0000000000000000) >> 96) as u16) diff --git a/crates/libmwemu/src/engine/instructions/pand.rs b/crates/libmwemu/src/engine/instructions/pand.rs index 6cb16a2b..fa76517d 100644 --- a/crates/libmwemu/src/engine/instructions/pand.rs +++ b/crates/libmwemu/src/engine/instructions/pand.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pandn.rs b/crates/libmwemu/src/engine/instructions/pandn.rs index 07a00040..5836ab9b 100644 --- a/crates/libmwemu/src/engine/instructions/pandn.rs +++ b/crates/libmwemu/src/engine/instructions/pandn.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pause.rs b/crates/libmwemu/src/engine/instructions/pause.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/pause.rs +++ b/crates/libmwemu/src/engine/instructions/pause.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpeqb.rs b/crates/libmwemu/src/engine/instructions/pcmpeqb.rs index 2989fc66..c642184a 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpeqb.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpeqb.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpeqd.rs b/crates/libmwemu/src/engine/instructions/pcmpeqd.rs index 5ff758e8..79ef67c3 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpeqd.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpeqd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpeqw.rs b/crates/libmwemu/src/engine/instructions/pcmpeqw.rs index 8f3fb77e..8ee7bde1 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpeqw.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpeqw.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpgtb.rs b/crates/libmwemu/src/engine/instructions/pcmpgtb.rs index ae0296b9..3cd01fd9 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpgtb.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpgtb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpgtd.rs b/crates/libmwemu/src/engine/instructions/pcmpgtd.rs index 811546da..d8e85c0d 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpgtd.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpgtd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pcmpgtw.rs b/crates/libmwemu/src/engine/instructions/pcmpgtw.rs index 5cbdc236..9a592de2 100644 --- a/crates/libmwemu/src/engine/instructions/pcmpgtw.rs +++ b/crates/libmwemu/src/engine/instructions/pcmpgtw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pdep.rs b/crates/libmwemu/src/engine/instructions/pdep.rs index 6df6252d..e6ca4895 100644 --- a/crates/libmwemu/src/engine/instructions/pdep.rs +++ b/crates/libmwemu/src/engine/instructions/pdep.rs @@ -1,15 +1,15 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); - let mut val:u64 = match emu.get_operand_value(ins, 1, true) { + let mut val: u64 = match emu.get_operand_value(ins, 1, true) { Some(v) => v, None => return false, }; - let mut mask:u64 = match emu.get_operand_value(ins, 2, true) { + let mut mask: u64 = match emu.get_operand_value(ins, 2, true) { Some(v) => v, None => return false, }; diff --git a/crates/libmwemu/src/engine/instructions/pmaddwd.rs b/crates/libmwemu/src/engine/instructions/pmaddwd.rs index 18457c8b..52f2980d 100644 --- a/crates/libmwemu/src/engine/instructions/pmaddwd.rs +++ b/crates/libmwemu/src/engine/instructions/pmaddwd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pmovmskb.rs b/crates/libmwemu/src/engine/instructions/pmovmskb.rs index 9b9db588..7d91044b 100644 --- a/crates/libmwemu/src/engine/instructions/pmovmskb.rs +++ b/crates/libmwemu/src/engine/instructions/pmovmskb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pmulhw.rs b/crates/libmwemu/src/engine/instructions/pmulhw.rs index d681fbd8..87991d2d 100644 --- a/crates/libmwemu/src/engine/instructions/pmulhw.rs +++ b/crates/libmwemu/src/engine/instructions/pmulhw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pmullw.rs b/crates/libmwemu/src/engine/instructions/pmullw.rs index 0373860b..b4e6174a 100644 --- a/crates/libmwemu/src/engine/instructions/pmullw.rs +++ b/crates/libmwemu/src/engine/instructions/pmullw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pop.rs b/crates/libmwemu/src/engine/instructions/pop.rs index 1101fe6a..833f46aa 100644 --- a/crates/libmwemu/src/engine/instructions/pop.rs +++ b/crates/libmwemu/src/engine/instructions/pop.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let value: u64 = if emu.cfg.is_64bits { diff --git a/crates/libmwemu/src/engine/instructions/popad.rs b/crates/libmwemu/src/engine/instructions/popad.rs index 450157af..be6aa755 100644 --- a/crates/libmwemu/src/engine/instructions/popad.rs +++ b/crates/libmwemu/src/engine/instructions/popad.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/popcnt.rs b/crates/libmwemu/src/engine/instructions/popcnt.rs index 432b1ec1..9b694806 100644 --- a/crates/libmwemu/src/engine/instructions/popcnt.rs +++ b/crates/libmwemu/src/engine/instructions/popcnt.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/popf.rs b/crates/libmwemu/src/engine/instructions/popf.rs index a4cf8410..6d8d0f06 100644 --- a/crates/libmwemu/src/engine/instructions/popf.rs +++ b/crates/libmwemu/src/engine/instructions/popf.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, exception_type}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/popfd.rs b/crates/libmwemu/src/engine/instructions/popfd.rs index 5d0153c7..e5609a81 100644 --- a/crates/libmwemu/src/engine/instructions/popfd.rs +++ b/crates/libmwemu/src/engine/instructions/popfd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/popfq.rs b/crates/libmwemu/src/engine/instructions/popfq.rs index 2aa1a3e6..3e1fda41 100644 --- a/crates/libmwemu/src/engine/instructions/popfq.rs +++ b/crates/libmwemu/src/engine/instructions/popfq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/por.rs b/crates/libmwemu/src/engine/instructions/por.rs index bd9f73a7..79db1cfc 100644 --- a/crates/libmwemu/src/engine/instructions/por.rs +++ b/crates/libmwemu/src/engine/instructions/por.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/prefetchnta.rs b/crates/libmwemu/src/engine/instructions/prefetchnta.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/prefetchnta.rs +++ b/crates/libmwemu/src/engine/instructions/prefetchnta.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/prefetchw.rs b/crates/libmwemu/src/engine/instructions/prefetchw.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/prefetchw.rs +++ b/crates/libmwemu/src/engine/instructions/prefetchw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pshufd.rs b/crates/libmwemu/src/engine/instructions/pshufd.rs index f0b5c6e4..37391c0b 100644 --- a/crates/libmwemu/src/engine/instructions/pshufd.rs +++ b/crates/libmwemu/src/engine/instructions/pshufd.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pshufhw.rs b/crates/libmwemu/src/engine/instructions/pshufhw.rs index 6b62afeb..a411e865 100644 --- a/crates/libmwemu/src/engine/instructions/pshufhw.rs +++ b/crates/libmwemu/src/engine/instructions/pshufhw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pshuflw.rs b/crates/libmwemu/src/engine/instructions/pshuflw.rs index 43611d83..2cf6f354 100644 --- a/crates/libmwemu/src/engine/instructions/pshuflw.rs +++ b/crates/libmwemu/src/engine/instructions/pshuflw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pslld.rs b/crates/libmwemu/src/engine/instructions/pslld.rs index d9295eb2..bdf54187 100644 --- a/crates/libmwemu/src/engine/instructions/pslld.rs +++ b/crates/libmwemu/src/engine/instructions/pslld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pslldq.rs b/crates/libmwemu/src/engine/instructions/pslldq.rs index 8888e102..a3c40e96 100644 --- a/crates/libmwemu/src/engine/instructions/pslldq.rs +++ b/crates/libmwemu/src/engine/instructions/pslldq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psllq.rs b/crates/libmwemu/src/engine/instructions/psllq.rs index fce800cc..c13b55c8 100644 --- a/crates/libmwemu/src/engine/instructions/psllq.rs +++ b/crates/libmwemu/src/engine/instructions/psllq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psllw.rs b/crates/libmwemu/src/engine/instructions/psllw.rs index b11d3b5c..ff636e04 100644 --- a/crates/libmwemu/src/engine/instructions/psllw.rs +++ b/crates/libmwemu/src/engine/instructions/psllw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -27,8 +27,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste result = (((value0 & 0xffff) as u16) << value1) as u128; result |= (((((value0 & 0xffff0000) >> 16) as u16) << value1) as u128) << 16; result |= (((((value0 & 0xffff00000000) >> 32) as u16) << value1) as u128) << 32; - result |= - (((((value0 & 0xffff000000000000) >> 48) as u16) << value1) as u128) << 48; + result |= (((((value0 & 0xffff000000000000) >> 48) as u16) << value1) as u128) << 48; } emu.set_operand_xmm_value_128(ins, 0, result); diff --git a/crates/libmwemu/src/engine/instructions/psrad.rs b/crates/libmwemu/src/engine/instructions/psrad.rs index 427eb795..06d0afd8 100644 --- a/crates/libmwemu/src/engine/instructions/psrad.rs +++ b/crates/libmwemu/src/engine/instructions/psrad.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psraw.rs b/crates/libmwemu/src/engine/instructions/psraw.rs index a44f4fc8..41583b45 100644 --- a/crates/libmwemu/src/engine/instructions/psraw.rs +++ b/crates/libmwemu/src/engine/instructions/psraw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psrld.rs b/crates/libmwemu/src/engine/instructions/psrld.rs index 56612d6f..0d6fd355 100644 --- a/crates/libmwemu/src/engine/instructions/psrld.rs +++ b/crates/libmwemu/src/engine/instructions/psrld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psrldq.rs b/crates/libmwemu/src/engine/instructions/psrldq.rs index c9e85dec..128ec46b 100644 --- a/crates/libmwemu/src/engine/instructions/psrldq.rs +++ b/crates/libmwemu/src/engine/instructions/psrldq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psrlq.rs b/crates/libmwemu/src/engine/instructions/psrlq.rs index 7de871ca..c4b7cf32 100644 --- a/crates/libmwemu/src/engine/instructions/psrlq.rs +++ b/crates/libmwemu/src/engine/instructions/psrlq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psrlw.rs b/crates/libmwemu/src/engine/instructions/psrlw.rs index 1710e084..bc6ca825 100644 --- a/crates/libmwemu/src/engine/instructions/psrlw.rs +++ b/crates/libmwemu/src/engine/instructions/psrlw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubb.rs b/crates/libmwemu/src/engine/instructions/psubb.rs index 1cff55ba..85a3dbef 100644 --- a/crates/libmwemu/src/engine/instructions/psubb.rs +++ b/crates/libmwemu/src/engine/instructions/psubb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubd.rs b/crates/libmwemu/src/engine/instructions/psubd.rs index 3e53121a..b5e94172 100644 --- a/crates/libmwemu/src/engine/instructions/psubd.rs +++ b/crates/libmwemu/src/engine/instructions/psubd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubq.rs b/crates/libmwemu/src/engine/instructions/psubq.rs index 45cf4af7..bd04a9e8 100644 --- a/crates/libmwemu/src/engine/instructions/psubq.rs +++ b/crates/libmwemu/src/engine/instructions/psubq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubsb.rs b/crates/libmwemu/src/engine/instructions/psubsb.rs index 29073380..527f1bf5 100644 --- a/crates/libmwemu/src/engine/instructions/psubsb.rs +++ b/crates/libmwemu/src/engine/instructions/psubsb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubsw.rs b/crates/libmwemu/src/engine/instructions/psubsw.rs index bcb10e10..5b56e53f 100644 --- a/crates/libmwemu/src/engine/instructions/psubsw.rs +++ b/crates/libmwemu/src/engine/instructions/psubsw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubusb.rs b/crates/libmwemu/src/engine/instructions/psubusb.rs index 6cfe3496..dd7836da 100644 --- a/crates/libmwemu/src/engine/instructions/psubusb.rs +++ b/crates/libmwemu/src/engine/instructions/psubusb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/psubw.rs b/crates/libmwemu/src/engine/instructions/psubw.rs index e04df79c..5766e40a 100644 --- a/crates/libmwemu/src/engine/instructions/psubw.rs +++ b/crates/libmwemu/src/engine/instructions/psubw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpckhbw.rs b/crates/libmwemu/src/engine/instructions/punpckhbw.rs index 9791a8a3..34e8f842 100644 --- a/crates/libmwemu/src/engine/instructions/punpckhbw.rs +++ b/crates/libmwemu/src/engine/instructions/punpckhbw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpckhdq.rs b/crates/libmwemu/src/engine/instructions/punpckhdq.rs index 3a6974ce..befc8652 100644 --- a/crates/libmwemu/src/engine/instructions/punpckhdq.rs +++ b/crates/libmwemu/src/engine/instructions/punpckhdq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpckhwd.rs b/crates/libmwemu/src/engine/instructions/punpckhwd.rs index afcf4b5e..211aac31 100644 --- a/crates/libmwemu/src/engine/instructions/punpckhwd.rs +++ b/crates/libmwemu/src/engine/instructions/punpckhwd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpcklbw.rs b/crates/libmwemu/src/engine/instructions/punpcklbw.rs index 83986c30..6ae6d928 100644 --- a/crates/libmwemu/src/engine/instructions/punpcklbw.rs +++ b/crates/libmwemu/src/engine/instructions/punpcklbw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpckldq.rs b/crates/libmwemu/src/engine/instructions/punpckldq.rs index a3f11e9e..ab31dc00 100644 --- a/crates/libmwemu/src/engine/instructions/punpckldq.rs +++ b/crates/libmwemu/src/engine/instructions/punpckldq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpcklqdq.rs b/crates/libmwemu/src/engine/instructions/punpcklqdq.rs index eab3a297..4109226d 100644 --- a/crates/libmwemu/src/engine/instructions/punpcklqdq.rs +++ b/crates/libmwemu/src/engine/instructions/punpcklqdq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/punpcklwd.rs b/crates/libmwemu/src/engine/instructions/punpcklwd.rs index 0e12010c..7c1cfe53 100644 --- a/crates/libmwemu/src/engine/instructions/punpcklwd.rs +++ b/crates/libmwemu/src/engine/instructions/punpcklwd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/push.rs b/crates/libmwemu/src/engine/instructions/push.rs index 9221d0fe..75d8416d 100644 --- a/crates/libmwemu/src/engine/instructions/push.rs +++ b/crates/libmwemu/src/engine/instructions/push.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, to32}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let value = match emu.get_operand_value(ins, 0, true) { diff --git a/crates/libmwemu/src/engine/instructions/pushad.rs b/crates/libmwemu/src/engine/instructions/pushad.rs index a7e4f88b..6c134e72 100644 --- a/crates/libmwemu/src/engine/instructions/pushad.rs +++ b/crates/libmwemu/src/engine/instructions/pushad.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pushf.rs b/crates/libmwemu/src/engine/instructions/pushf.rs index 405fd263..a7cd021f 100644 --- a/crates/libmwemu/src/engine/instructions/pushf.rs +++ b/crates/libmwemu/src/engine/instructions/pushf.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, exception_type}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pushfd.rs b/crates/libmwemu/src/engine/instructions/pushfd.rs index 5567f8cc..f66c2415 100644 --- a/crates/libmwemu/src/engine/instructions/pushfd.rs +++ b/crates/libmwemu/src/engine/instructions/pushfd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pushfq.rs b/crates/libmwemu/src/engine/instructions/pushfq.rs index 69555d05..21c2c2c2 100644 --- a/crates/libmwemu/src/engine/instructions/pushfq.rs +++ b/crates/libmwemu/src/engine/instructions/pushfq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/pxor.rs b/crates/libmwemu/src/engine/instructions/pxor.rs index cfe5b335..5a1a8272 100644 --- a/crates/libmwemu/src/engine/instructions/pxor.rs +++ b/crates/libmwemu/src/engine/instructions/pxor.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/rcl.rs b/crates/libmwemu/src/engine/instructions/rcl.rs index 46ac18f9..8ed1bc50 100644 --- a/crates/libmwemu/src/engine/instructions/rcl.rs +++ b/crates/libmwemu/src/engine/instructions/rcl.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/rcr.rs b/crates/libmwemu/src/engine/instructions/rcr.rs index 9b74a1cd..08de820d 100644 --- a/crates/libmwemu/src/engine/instructions/rcr.rs +++ b/crates/libmwemu/src/engine/instructions/rcr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/rdmsr.rs b/crates/libmwemu/src/engine/instructions/rdmsr.rs index 16c4c939..98e08288 100644 --- a/crates/libmwemu/src/engine/instructions/rdmsr.rs +++ b/crates/libmwemu/src/engine/instructions/rdmsr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/rdtsc.rs b/crates/libmwemu/src/engine/instructions/rdtsc.rs index 315e0079..c66c41f7 100644 --- a/crates/libmwemu/src/engine/instructions/rdtsc.rs +++ b/crates/libmwemu/src/engine/instructions/rdtsc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/rdtscp.rs b/crates/libmwemu/src/engine/instructions/rdtscp.rs index eacb81b6..ed1ef2bd 100644 --- a/crates/libmwemu/src/engine/instructions/rdtscp.rs +++ b/crates/libmwemu/src/engine/instructions/rdtscp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ret.rs b/crates/libmwemu/src/engine/instructions/ret.rs index 024da09a..85bb7229 100644 --- a/crates/libmwemu/src/engine/instructions/ret.rs +++ b/crates/libmwemu/src/engine/instructions/ret.rs @@ -1,7 +1,7 @@ -use crate::emu::Emu; use crate::console::Console; +use crate::emu::Emu; use crate::{color, exception}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { let ret_addr: u64 = if emu.cfg.is_64bits { diff --git a/crates/libmwemu/src/engine/instructions/rol.rs b/crates/libmwemu/src/engine/instructions/rol.rs index 2e8554a7..7ae5946f 100644 --- a/crates/libmwemu/src/engine/instructions/rol.rs +++ b/crates/libmwemu/src/engine/instructions/rol.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ror.rs b/crates/libmwemu/src/engine/instructions/ror.rs index 36228f06..c0db6530 100644 --- a/crates/libmwemu/src/engine/instructions/ror.rs +++ b/crates/libmwemu/src/engine/instructions/ror.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -18,7 +18,6 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste }; result = emu.flags_mut().ror(value0, 1, sz); - } else { // 2 params let value0 = match emu.get_operand_value(ins, 0, true) { diff --git a/crates/libmwemu/src/engine/instructions/sal.rs b/crates/libmwemu/src/engine/instructions/sal.rs index 45fad822..35818ef8 100644 --- a/crates/libmwemu/src/engine/instructions/sal.rs +++ b/crates/libmwemu/src/engine/instructions/sal.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/salc.rs b/crates/libmwemu/src/engine/instructions/salc.rs index a4fe800e..7d702134 100644 --- a/crates/libmwemu/src/engine/instructions/salc.rs +++ b/crates/libmwemu/src/engine/instructions/salc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sar.rs b/crates/libmwemu/src/engine/instructions/sar.rs index 26c38926..e010d4ae 100644 --- a/crates/libmwemu/src/engine/instructions/sar.rs +++ b/crates/libmwemu/src/engine/instructions/sar.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sbb.rs b/crates/libmwemu/src/engine/instructions/sbb.rs index 2b2b8485..bec507f1 100644 --- a/crates/libmwemu/src/engine/instructions/sbb.rs +++ b/crates/libmwemu/src/engine/instructions/sbb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); @@ -25,8 +25,12 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste 32 => emu .flags_mut() .sub32(value0, (value1 & 0xffffffff).wrapping_add(cf)), - 16 => emu.flags_mut().sub16(value0, (value1 & 0xffff).wrapping_add(cf)), - 8 => emu.flags_mut().sub8(value0, (value1 & 0xff).wrapping_add(cf)), + 16 => emu + .flags_mut() + .sub16(value0, (value1 & 0xffff).wrapping_add(cf)), + 8 => emu + .flags_mut() + .sub8(value0, (value1 & 0xff).wrapping_add(cf)), _ => panic!("weird size"), }; diff --git a/crates/libmwemu/src/engine/instructions/scasb.rs b/crates/libmwemu/src/engine/instructions/scasb.rs index ed3ff588..3d594816 100644 --- a/crates/libmwemu/src/engine/instructions/scasb.rs +++ b/crates/libmwemu/src/engine/instructions/scasb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/scasd.rs b/crates/libmwemu/src/engine/instructions/scasd.rs index b3ac6e27..f54213d1 100644 --- a/crates/libmwemu/src/engine/instructions/scasd.rs +++ b/crates/libmwemu/src/engine/instructions/scasd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/scasq.rs b/crates/libmwemu/src/engine/instructions/scasq.rs index 9936c0cb..06a21697 100644 --- a/crates/libmwemu/src/engine/instructions/scasq.rs +++ b/crates/libmwemu/src/engine/instructions/scasq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/scasw.rs b/crates/libmwemu/src/engine/instructions/scasw.rs index dec4ce6f..68e5a202 100644 --- a/crates/libmwemu/src/engine/instructions/scasw.rs +++ b/crates/libmwemu/src/engine/instructions/scasw.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/seta.rs b/crates/libmwemu/src/engine/instructions/seta.rs index 2dd870f3..f62a8e0d 100644 --- a/crates/libmwemu/src/engine/instructions/seta.rs +++ b/crates/libmwemu/src/engine/instructions/seta.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setae.rs b/crates/libmwemu/src/engine/instructions/setae.rs index 2ea75a43..7d689fd4 100644 --- a/crates/libmwemu/src/engine/instructions/setae.rs +++ b/crates/libmwemu/src/engine/instructions/setae.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setb.rs b/crates/libmwemu/src/engine/instructions/setb.rs index bf8eb4a9..c52c5f84 100644 --- a/crates/libmwemu/src/engine/instructions/setb.rs +++ b/crates/libmwemu/src/engine/instructions/setb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setbe.rs b/crates/libmwemu/src/engine/instructions/setbe.rs index d6afa2a9..040aaba4 100644 --- a/crates/libmwemu/src/engine/instructions/setbe.rs +++ b/crates/libmwemu/src/engine/instructions/setbe.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sete.rs b/crates/libmwemu/src/engine/instructions/sete.rs index 232dd81b..b16b4248 100644 --- a/crates/libmwemu/src/engine/instructions/sete.rs +++ b/crates/libmwemu/src/engine/instructions/sete.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setg.rs b/crates/libmwemu/src/engine/instructions/setg.rs index f1e31f72..fad71c65 100644 --- a/crates/libmwemu/src/engine/instructions/setg.rs +++ b/crates/libmwemu/src/engine/instructions/setg.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setge.rs b/crates/libmwemu/src/engine/instructions/setge.rs index 96ef4b14..0b30eb1a 100644 --- a/crates/libmwemu/src/engine/instructions/setge.rs +++ b/crates/libmwemu/src/engine/instructions/setge.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setl.rs b/crates/libmwemu/src/engine/instructions/setl.rs index 47cf6169..890e40f9 100644 --- a/crates/libmwemu/src/engine/instructions/setl.rs +++ b/crates/libmwemu/src/engine/instructions/setl.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setle.rs b/crates/libmwemu/src/engine/instructions/setle.rs index 04e4e3c8..70f29575 100644 --- a/crates/libmwemu/src/engine/instructions/setle.rs +++ b/crates/libmwemu/src/engine/instructions/setle.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setne.rs b/crates/libmwemu/src/engine/instructions/setne.rs index 53e6e85b..c71dfee8 100644 --- a/crates/libmwemu/src/engine/instructions/setne.rs +++ b/crates/libmwemu/src/engine/instructions/setne.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setno.rs b/crates/libmwemu/src/engine/instructions/setno.rs index 4acd615c..fabe9f91 100644 --- a/crates/libmwemu/src/engine/instructions/setno.rs +++ b/crates/libmwemu/src/engine/instructions/setno.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setnp.rs b/crates/libmwemu/src/engine/instructions/setnp.rs index b823003e..64e6cdec 100644 --- a/crates/libmwemu/src/engine/instructions/setnp.rs +++ b/crates/libmwemu/src/engine/instructions/setnp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setns.rs b/crates/libmwemu/src/engine/instructions/setns.rs index 42415a7b..2a421f2c 100644 --- a/crates/libmwemu/src/engine/instructions/setns.rs +++ b/crates/libmwemu/src/engine/instructions/setns.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/seto.rs b/crates/libmwemu/src/engine/instructions/seto.rs index 7df365b2..2e392e16 100644 --- a/crates/libmwemu/src/engine/instructions/seto.rs +++ b/crates/libmwemu/src/engine/instructions/seto.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/setp.rs b/crates/libmwemu/src/engine/instructions/setp.rs index b08c9479..2a5ce7d1 100644 --- a/crates/libmwemu/src/engine/instructions/setp.rs +++ b/crates/libmwemu/src/engine/instructions/setp.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sets.rs b/crates/libmwemu/src/engine/instructions/sets.rs index e6c52e16..3f535d05 100644 --- a/crates/libmwemu/src/engine/instructions/sets.rs +++ b/crates/libmwemu/src/engine/instructions/sets.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sfence.rs b/crates/libmwemu/src/engine/instructions/sfence.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/sfence.rs +++ b/crates/libmwemu/src/engine/instructions/sfence.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/shl.rs b/crates/libmwemu/src/engine/instructions/shl.rs index 65eb3d90..052d50d0 100644 --- a/crates/libmwemu/src/engine/instructions/shl.rs +++ b/crates/libmwemu/src/engine/instructions/shl.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/shld.rs b/crates/libmwemu/src/engine/instructions/shld.rs index 70b38452..070488bd 100644 --- a/crates/libmwemu/src/engine/instructions/shld.rs +++ b/crates/libmwemu/src/engine/instructions/shld.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/shr.rs b/crates/libmwemu/src/engine/instructions/shr.rs index 10c28672..a53b2f6b 100644 --- a/crates/libmwemu/src/engine/instructions/shr.rs +++ b/crates/libmwemu/src/engine/instructions/shr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/shrd.rs b/crates/libmwemu/src/engine/instructions/shrd.rs index 41e648a4..fa821508 100644 --- a/crates/libmwemu/src/engine/instructions/shrd.rs +++ b/crates/libmwemu/src/engine/instructions/shrd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/stc.rs b/crates/libmwemu/src/engine/instructions/stc.rs index cf5e2150..26dd7b50 100644 --- a/crates/libmwemu/src/engine/instructions/stc.rs +++ b/crates/libmwemu/src/engine/instructions/stc.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/std.rs b/crates/libmwemu/src/engine/instructions/std.rs index d88f97f3..6122b5d2 100644 --- a/crates/libmwemu/src/engine/instructions/std.rs +++ b/crates/libmwemu/src/engine/instructions/std.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Blue"), ins); diff --git a/crates/libmwemu/src/engine/instructions/stmxcsr.rs b/crates/libmwemu/src/engine/instructions/stmxcsr.rs index c0fa41b6..3f952ce8 100644 --- a/crates/libmwemu/src/engine/instructions/stmxcsr.rs +++ b/crates/libmwemu/src/engine/instructions/stmxcsr.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/stosb.rs b/crates/libmwemu/src/engine/instructions/stosb.rs index 776c77e6..d3a601e5 100644 --- a/crates/libmwemu/src/engine/instructions/stosb.rs +++ b/crates/libmwemu/src/engine/instructions/stosb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { @@ -12,7 +12,10 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste } if emu.cfg.is_64bits { - if !emu.maps.write_byte(emu.regs().rdi, emu.regs().get_al() as u8) { + if !emu + .maps + .write_byte(emu.regs().rdi, emu.regs().get_al() as u8) + { return false; } if emu.flags().f_df { diff --git a/crates/libmwemu/src/engine/instructions/stosd.rs b/crates/libmwemu/src/engine/instructions/stosd.rs index 910be103..a14dd8f0 100644 --- a/crates/libmwemu/src/engine/instructions/stosd.rs +++ b/crates/libmwemu/src/engine/instructions/stosd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.rep.is_some() { diff --git a/crates/libmwemu/src/engine/instructions/stosq.rs b/crates/libmwemu/src/engine/instructions/stosq.rs index 906d6d3d..3af6868b 100644 --- a/crates/libmwemu/src/engine/instructions/stosq.rs +++ b/crates/libmwemu/src/engine/instructions/stosq.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { assert!(emu.cfg.is_64bits); diff --git a/crates/libmwemu/src/engine/instructions/stosw.rs b/crates/libmwemu/src/engine/instructions/stosw.rs index 7e3ae64f..6d733b5a 100644 --- a/crates/libmwemu/src/engine/instructions/stosw.rs +++ b/crates/libmwemu/src/engine/instructions/stosw.rs @@ -1,12 +1,13 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); if emu.cfg.is_64bits { - emu.maps.write_word(emu.regs().rdi, emu.regs().get_ax() as u16); + emu.maps + .write_word(emu.regs().rdi, emu.regs().get_ax() as u16); if emu.flags().f_df { emu.regs_mut().rdi -= 2; diff --git a/crates/libmwemu/src/engine/instructions/sub.rs b/crates/libmwemu/src/engine/instructions/sub.rs index 138dc31b..78a16334 100644 --- a/crates/libmwemu/src/engine/instructions/sub.rs +++ b/crates/libmwemu/src/engine/instructions/sub.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Cyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/subpd.rs b/crates/libmwemu/src/engine/instructions/subpd.rs index 481368dd..4cecd0fb 100644 --- a/crates/libmwemu/src/engine/instructions/subpd.rs +++ b/crates/libmwemu/src/engine/instructions/subpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/subps.rs b/crates/libmwemu/src/engine/instructions/subps.rs index 236e5fe1..dd76049f 100644 --- a/crates/libmwemu/src/engine/instructions/subps.rs +++ b/crates/libmwemu/src/engine/instructions/subps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -22,8 +22,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let a: u128 = (value0 & 0xffffffff) - (value1 & 0xffffffff); let b: u128 = (value0 & 0xffffffff_00000000) - (value1 & 0xffffffff_00000000); - let c: u128 = - (value0 & 0xffffffff_00000000_00000000) - (value1 & 0xffffffff_00000000_00000000); + let c: u128 = (value0 & 0xffffffff_00000000_00000000) - (value1 & 0xffffffff_00000000_00000000); let d: u128 = (value0 & 0xffffffff_00000000_00000000_00000000) - (value1 & 0xffffffff_00000000_00000000_00000000); diff --git a/crates/libmwemu/src/engine/instructions/subsd.rs b/crates/libmwemu/src/engine/instructions/subsd.rs index 228386fb..2240ea1c 100644 --- a/crates/libmwemu/src/engine/instructions/subsd.rs +++ b/crates/libmwemu/src/engine/instructions/subsd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/subss.rs b/crates/libmwemu/src/engine/instructions/subss.rs index c1e83fd7..0cec1ab2 100644 --- a/crates/libmwemu/src/engine/instructions/subss.rs +++ b/crates/libmwemu/src/engine/instructions/subss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/syscall.rs b/crates/libmwemu/src/engine/instructions/syscall.rs index c17158ce..fe0b4f93 100644 --- a/crates/libmwemu/src/engine/instructions/syscall.rs +++ b/crates/libmwemu/src/engine/instructions/syscall.rs @@ -1,7 +1,7 @@ +use crate::color; use crate::emu::Emu; use crate::syscall::syscall64; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/sysenter.rs b/crates/libmwemu/src/engine/instructions/sysenter.rs index b558ff74..faa3327c 100644 --- a/crates/libmwemu/src/engine/instructions/sysenter.rs +++ b/crates/libmwemu/src/engine/instructions/sysenter.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; -use crate::{ntapi}; -use iced_x86::{Instruction}; +use crate::ntapi; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { if emu.cfg.is_64bits { diff --git a/crates/libmwemu/src/engine/instructions/test.rs b/crates/libmwemu/src/engine/instructions/test.rs index 2e624e50..04fc08a8 100644 --- a/crates/libmwemu/src/engine/instructions/test.rs +++ b/crates/libmwemu/src/engine/instructions/test.rs @@ -1,7 +1,7 @@ -use crate::emu::Emu; +use crate::color; use crate::console::Console; -use crate::{color}; -use iced_x86::{Instruction}; +use crate::emu::Emu; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Orange"), ins); diff --git a/crates/libmwemu/src/engine/instructions/tzcnt.rs b/crates/libmwemu/src/engine/instructions/tzcnt.rs index 32160aed..3acf4533 100644 --- a/crates/libmwemu/src/engine/instructions/tzcnt.rs +++ b/crates/libmwemu/src/engine/instructions/tzcnt.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, get_bit}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ucomisd.rs b/crates/libmwemu/src/engine/instructions/ucomisd.rs index cc23df44..a753d280 100644 --- a/crates/libmwemu/src/engine/instructions/ucomisd.rs +++ b/crates/libmwemu/src/engine/instructions/ucomisd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/ucomiss.rs b/crates/libmwemu/src/engine/instructions/ucomiss.rs index bfef090f..65968bf3 100644 --- a/crates/libmwemu/src/engine/instructions/ucomiss.rs +++ b/crates/libmwemu/src/engine/instructions/ucomiss.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vmovd.rs b/crates/libmwemu/src/engine/instructions/vmovd.rs index ef0755f4..6ba764b7 100644 --- a/crates/libmwemu/src/engine/instructions/vmovd.rs +++ b/crates/libmwemu/src/engine/instructions/vmovd.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vmovdqa.rs b/crates/libmwemu/src/engine/instructions/vmovdqa.rs index c1710282..168ab8f4 100644 --- a/crates/libmwemu/src/engine/instructions/vmovdqa.rs +++ b/crates/libmwemu/src/engine/instructions/vmovdqa.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { //TODO: exception if memory address is unaligned to 16,32,64 diff --git a/crates/libmwemu/src/engine/instructions/vmovdqu.rs b/crates/libmwemu/src/engine/instructions/vmovdqu.rs index 63214faf..be956a66 100644 --- a/crates/libmwemu/src/engine/instructions/vmovdqu.rs +++ b/crates/libmwemu/src/engine/instructions/vmovdqu.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vmovq.rs b/crates/libmwemu/src/engine/instructions/vmovq.rs index e1f7977f..04e440c9 100644 --- a/crates/libmwemu/src/engine/instructions/vmovq.rs +++ b/crates/libmwemu/src/engine/instructions/vmovq.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpbroadcastb.rs b/crates/libmwemu/src/engine/instructions/vpbroadcastb.rs index f15cb3d3..dba3568e 100644 --- a/crates/libmwemu/src/engine/instructions/vpbroadcastb.rs +++ b/crates/libmwemu/src/engine/instructions/vpbroadcastb.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpcmpeqb.rs b/crates/libmwemu/src/engine/instructions/vpcmpeqb.rs index 5fcf0be2..f195c13e 100644 --- a/crates/libmwemu/src/engine/instructions/vpcmpeqb.rs +++ b/crates/libmwemu/src/engine/instructions/vpcmpeqb.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpminub.rs b/crates/libmwemu/src/engine/instructions/vpminub.rs index ea281484..9dde6b01 100644 --- a/crates/libmwemu/src/engine/instructions/vpminub.rs +++ b/crates/libmwemu/src/engine/instructions/vpminub.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpmovmskb.rs b/crates/libmwemu/src/engine/instructions/vpmovmskb.rs index 9b9db588..7d91044b 100644 --- a/crates/libmwemu/src/engine/instructions/vpmovmskb.rs +++ b/crates/libmwemu/src/engine/instructions/vpmovmskb.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpor.rs b/crates/libmwemu/src/engine/instructions/vpor.rs index 4e2c9a6b..f81bf435 100644 --- a/crates/libmwemu/src/engine/instructions/vpor.rs +++ b/crates/libmwemu/src/engine/instructions/vpor.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vpxor.rs b/crates/libmwemu/src/engine/instructions/vpxor.rs index 08dd9227..24cbd8c5 100644 --- a/crates/libmwemu/src/engine/instructions/vpxor.rs +++ b/crates/libmwemu/src/engine/instructions/vpxor.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/vzeroupper.rs b/crates/libmwemu/src/engine/instructions/vzeroupper.rs index 35c61633..725dfa45 100644 --- a/crates/libmwemu/src/engine/instructions/vzeroupper.rs +++ b/crates/libmwemu/src/engine/instructions/vzeroupper.rs @@ -1,6 +1,6 @@ use crate::emu::Emu; use crate::{color, regs64}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/wait.rs b/crates/libmwemu/src/engine/instructions/wait.rs index 85278630..b7d9602d 100644 --- a/crates/libmwemu/src/engine/instructions/wait.rs +++ b/crates/libmwemu/src/engine/instructions/wait.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Red"), ins); diff --git a/crates/libmwemu/src/engine/instructions/xadd.rs b/crates/libmwemu/src/engine/instructions/xadd.rs index 12d04cec..1975f1ff 100644 --- a/crates/libmwemu/src/engine/instructions/xadd.rs +++ b/crates/libmwemu/src/engine/instructions/xadd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -31,12 +31,9 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste f_cf, false, ), - 8 => emu.flags_mut().add8( - (value0 & 0xff) as u8, - (value1 & 0xff) as u8, - f_cf, - false, - ), + 8 => emu + .flags_mut() + .add8((value0 & 0xff) as u8, (value1 & 0xff) as u8, f_cf, false), _ => unreachable!("weird size"), }; diff --git a/crates/libmwemu/src/engine/instructions/xchg.rs b/crates/libmwemu/src/engine/instructions/xchg.rs index 73172d26..eeaaf75d 100644 --- a/crates/libmwemu/src/engine/instructions/xchg.rs +++ b/crates/libmwemu/src/engine/instructions/xchg.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("LightCyan"), ins); diff --git a/crates/libmwemu/src/engine/instructions/xgetbv.rs b/crates/libmwemu/src/engine/instructions/xgetbv.rs index 3992335d..247a74f9 100644 --- a/crates/libmwemu/src/engine/instructions/xgetbv.rs +++ b/crates/libmwemu/src/engine/instructions/xgetbv.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/xor.rs b/crates/libmwemu/src/engine/instructions/xor.rs index 26997610..acdefbd3 100644 --- a/crates/libmwemu/src/engine/instructions/xor.rs +++ b/crates/libmwemu/src/engine/instructions/xor.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/xorpd.rs b/crates/libmwemu/src/engine/instructions/xorpd.rs index c8369441..8008c4e1 100644 --- a/crates/libmwemu/src/engine/instructions/xorpd.rs +++ b/crates/libmwemu/src/engine/instructions/xorpd.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); diff --git a/crates/libmwemu/src/engine/instructions/xorps.rs b/crates/libmwemu/src/engine/instructions/xorps.rs index 46b8ddeb..cec8a8bf 100644 --- a/crates/libmwemu/src/engine/instructions/xorps.rs +++ b/crates/libmwemu/src/engine/instructions/xorps.rs @@ -1,6 +1,6 @@ +use crate::color; use crate::emu::Emu; -use crate::{color}; -use iced_x86::{Instruction}; +use iced_x86::Instruction; pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_step: bool) -> bool { emu.show_instruction(color!("Green"), ins); @@ -22,8 +22,7 @@ pub fn execute(emu: &mut Emu, ins: &Instruction, instruction_sz: usize, _rep_ste let a: u128 = (value0 & 0xffffffff) ^ (value1 & 0xffffffff); let b: u128 = (value0 & 0xffffffff_00000000) ^ (value1 & 0xffffffff_00000000); - let c: u128 = - (value0 & 0xffffffff_00000000_00000000) ^ (value1 & 0xffffffff_00000000_00000000); + let c: u128 = (value0 & 0xffffffff_00000000_00000000) ^ (value1 & 0xffffffff_00000000_00000000); let d: u128 = (value0 & 0xffffffff_00000000_00000000_00000000) ^ (value1 & 0xffffffff_00000000_00000000_00000000); diff --git a/crates/libmwemu/src/engine/logic.rs b/crates/libmwemu/src/engine/logic.rs index d7182326..030b2a65 100644 --- a/crates/libmwemu/src/engine/logic.rs +++ b/crates/libmwemu/src/engine/logic.rs @@ -32,7 +32,6 @@ pub fn rol(emu: &mut Emu, val: u64, rot2: u64, bits: u32) -> u64 { ret } - pub fn rcl_bit_based(emu: &Emu, val: u64, rot2: u64, bits: u32) -> u64 { let mut ret: u128 = val as u128; @@ -182,7 +181,7 @@ pub fn imul64p1(emu: &mut Emu, value0: u64) { let value2: i64 = value0 as i64; let res: i128 = value1 as i128 * value2 as i128; let ures: u128 = res as u128; - emu.regs_mut().rdx = (ures >> 64) as u64; + emu.regs_mut().rdx = (ures >> 64) as u64; emu.regs_mut().rax = (ures & 0xffffffffffffffff) as u64; let rax = emu.regs().rax as i64; let rdx = emu.regs().rdx as i64; @@ -230,7 +229,6 @@ pub fn imul8p1(emu: &mut Emu, value0: u64) { emu.flags_mut().f_cf = emu.flags().f_of; } - pub fn div64(emu: &mut Emu, value0: u64) { let mut value1: u128 = emu.regs().rdx as u128; value1 <<= 64; diff --git a/crates/libmwemu/src/engine/mod.rs b/crates/libmwemu/src/engine/mod.rs index 9da37921..34fd5115 100644 --- a/crates/libmwemu/src/engine/mod.rs +++ b/crates/libmwemu/src/engine/mod.rs @@ -114,7 +114,9 @@ pub fn emulate_instruction( Mnemonic::Test => instructions::test::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Cmpxchg => instructions::cmpxchg::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Cmpxchg8b => instructions::cmpxchg8b::execute(emu, ins, instruction_sz, rep_step), - Mnemonic::Cmpxchg16b => instructions::cmpxchg16b::execute(emu, ins, instruction_sz, rep_step), + Mnemonic::Cmpxchg16b => { + instructions::cmpxchg16b::execute(emu, ins, instruction_sz, rep_step) + } Mnemonic::Cmp => instructions::cmp::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Cmpsq => instructions::cmpsq::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Cmpsd => instructions::cmpsd::execute(emu, ins, instruction_sz, rep_step), @@ -253,7 +255,9 @@ pub fn emulate_instruction( Mnemonic::Cvtsi2sd => instructions::cvtsi2sd::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Cvtsi2ss => instructions::cvtsi2ss::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Movhps => instructions::movhps::execute(emu, ins, instruction_sz, rep_step), - Mnemonic::Punpcklqdq => instructions::punpcklqdq::execute(emu, ins, instruction_sz, rep_step), + Mnemonic::Punpcklqdq => { + instructions::punpcklqdq::execute(emu, ins, instruction_sz, rep_step) + } Mnemonic::Movq => instructions::movq::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Punpckhdq => instructions::punpckhdq::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Punpckldq => instructions::punpckldq::execute(emu, ins, instruction_sz, rep_step), @@ -290,14 +294,18 @@ pub fn emulate_instruction( Mnemonic::Pshufd => instructions::pshufd::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Movups => instructions::movups::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Movdqu => instructions::movdqu::execute(emu, ins, instruction_sz, rep_step), - Mnemonic::Vzeroupper => instructions::vzeroupper::execute(emu, ins, instruction_sz, rep_step), + Mnemonic::Vzeroupper => { + instructions::vzeroupper::execute(emu, ins, instruction_sz, rep_step) + } Mnemonic::Vmovdqu => instructions::vmovdqu::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Vmovdqa => instructions::vmovdqa::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Movaps => instructions::movaps::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Movapd => instructions::movapd::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Vmovd => instructions::vmovd::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Vmovq => instructions::vmovq::execute(emu, ins, instruction_sz, rep_step), - Mnemonic::Vpbroadcastb => instructions::vpbroadcastb::execute(emu, ins, instruction_sz, rep_step), + Mnemonic::Vpbroadcastb => { + instructions::vpbroadcastb::execute(emu, ins, instruction_sz, rep_step) + } Mnemonic::Vpor => instructions::vpor::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Vpxor => instructions::vpxor::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Pcmpeqb => instructions::pcmpeqb::execute(emu, ins, instruction_sz, rep_step), @@ -345,7 +353,9 @@ pub fn emulate_instruction( Mnemonic::Stmxcsr => instructions::stmxcsr::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Ldmxcsr => instructions::ldmxcsr::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Fnstcw => instructions::fnstcw::execute(emu, ins, instruction_sz, rep_step), - Mnemonic::Prefetchnta => instructions::prefetchnta::execute(emu, ins, instruction_sz, rep_step), + Mnemonic::Prefetchnta => { + instructions::prefetchnta::execute(emu, ins, instruction_sz, rep_step) + } Mnemonic::Prefetchw => instructions::prefetchw::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Pause => instructions::pause::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Wait => instructions::wait::execute(emu, ins, instruction_sz, rep_step), @@ -357,7 +367,11 @@ pub fn emulate_instruction( Mnemonic::Enter => instructions::enter::execute(emu, ins, instruction_sz, rep_step), Mnemonic::Rdmsr => instructions::rdmsr::execute(emu, ins, instruction_sz, rep_step), _ => { - log::info!("{} Unimplemented instruction: {:?}", emu.pos, ins.mnemonic()); + log::info!( + "{} Unimplemented instruction: {:?}", + emu.pos, + ins.mnemonic() + ); false } } diff --git a/crates/libmwemu/src/exception.rs b/crates/libmwemu/src/exception.rs index f4aa1ee9..e9f06bba 100644 --- a/crates/libmwemu/src/exception.rs +++ b/crates/libmwemu/src/exception.rs @@ -7,14 +7,15 @@ ntdll!RtlRemoveVectoredExceptionHandler - UEF: unhandled exception filter (API) ntdll!RtlSetUnhandledExceptionFilter - kernelbase!SetUnhandledExceptionFilter + kernelbase!SetUnhandledExceptionFilter */ -use crate::exception_type; use crate::context::context32::Context32; use crate::context::context64::Context64; use crate::emu; +use crate::exception_type; +use crate::maps::mem64::Permission; pub fn enter(emu: &mut emu::Emu, ex_type: exception_type::ExceptionType) { if emu.cfg.is_64bits { @@ -34,19 +35,23 @@ pub fn exit(emu: &mut emu::Emu) { pub fn enter32(emu: &mut emu::Emu, ex_type: exception_type::ExceptionType) { let ctx_addr = emu.maps.alloc(0x1000).expect("out of memory"); - if (ctx_addr+0x1000) > u32::MAX as u64 { - panic!("32bits allocator is giving a too big memory!! for the context32"); + if (ctx_addr + 0x1000) > u32::MAX as u64 { + panic!("32bits allocator is giving a too big memory!! for the context32"); } - let ctx = emu.maps.create_map("ctx", ctx_addr, 0x1000); + let ctx = emu + .maps + .create_map("ctx", ctx_addr, 0x1000, Permission::READ_WRITE_EXECUTE); emu.set_eh_ctx((ctx_addr + 0x100) as u32); - emu.stack_push32(ctx_addr as u32); // 0x10f00 emu.stack_push32(emu.regs().get_eip() as u32); emu.set_eh_ctx(ctx_addr as u32 + 8); // 0x10f08 - emu.maps.write_dword(ctx_addr+4, emu.eh_ctx()); // 0x10f04 - emu.maps.write_dword(emu.eh_ctx() as u64, exception_type::exception_type_code(ex_type)); // STATUS_BREAKPOINT + emu.maps.write_dword(ctx_addr + 4, emu.eh_ctx()); // 0x10f04 + emu.maps.write_dword( + emu.eh_ctx() as u64, + exception_type::exception_type_code(ex_type), + ); // STATUS_BREAKPOINT let ctx = Context32::new(&emu.regs()); ctx.save(emu.eh_ctx(), &mut emu.maps); @@ -63,16 +68,18 @@ pub fn exit32(emu: &mut emu::Emu) { pub fn enter64(emu: &mut emu::Emu, ex_type: exception_type::ExceptionType) { let ctx_addr = emu.maps.alloc(0x1000).expect("out of memory"); - let ctx = emu.maps.create_map("ctx", ctx_addr, 0x1000); + let ctx = emu + .maps + .create_map("ctx", ctx_addr, 0x1000, Permission::READ_WRITE_EXECUTE); emu.stack_push64(ctx_addr); // 0x10f00 emu.stack_push64(emu.regs().rip); if ctx_addr > u32::MAX as u64 { - panic!("64bits allocator is giving a too big memory!! for the context64"); + panic!("64bits allocator is giving a too big memory!! for the context64"); } - emu.set_eh_ctx(ctx_addr as u32 + 16); + emu.set_eh_ctx(ctx_addr as u32 + 16); emu.maps.write_qword(ctx_addr + 8, emu.eh_ctx() as u64); let ctx = Context64::new(&emu.regs()); ctx.save(emu.eh_ctx() as u64, &mut emu.maps); diff --git a/crates/libmwemu/src/exception_type.rs b/crates/libmwemu/src/exception_type.rs index 9407bb32..d4b8a3ec 100644 --- a/crates/libmwemu/src/exception_type.rs +++ b/crates/libmwemu/src/exception_type.rs @@ -57,9 +57,10 @@ pub fn exception_type_code(ex_type: ExceptionType) -> u32 { ExceptionType::DWordDereferencing => return constants::STATUS_DWORD_DEREFERENCING, ExceptionType::WordDereferencing => return constants::STATUS_WORD_DEREFERENCING, ExceptionType::ByteDereferencing => return constants::STATUS_BYTE_DEREFERENCING, - ExceptionType::BadAddressDereferencing => return constants::STATUS_BAD_ADDRESS_DEREFERENCING, + ExceptionType::BadAddressDereferencing => { + return constants::STATUS_BAD_ADDRESS_DEREFERENCING + } ExceptionType::SettingXmmOperand => return constants::STATUS_SETTING_XMM_OPERAND, ExceptionType::ReadingXmmOperand => return constants::STATUS_READING_XMM_OPERAND, } } - diff --git a/crates/libmwemu/src/flags.rs b/crates/libmwemu/src/flags.rs index 03d17cd0..a63df144 100644 --- a/crates/libmwemu/src/flags.rs +++ b/crates/libmwemu/src/flags.rs @@ -155,7 +155,6 @@ impl Flags { } fs.push_str("]"); log::info!("\t{} flags: 0x{:x} {}", pos, self.dump(), fs); - } pub fn print(&self) { @@ -434,7 +433,6 @@ impl Flags { self.f_tf = false; } - #[inline] pub fn calc_pf(&mut self, final_value: u8) { self.f_pf = PARITY_LOOKUP_TABLE[(final_value & 0xff) as usize]; @@ -646,7 +644,7 @@ impl Flags { } self.f_of = value == 0x7fffffff_ffffffff; - self.f_sf = value+1 > 0x7fffffff_ffffffff; + self.f_sf = value + 1 > 0x7fffffff_ffffffff; self.calc_pf((value + 1) as u8); self.f_zf = false; value + 1 @@ -662,7 +660,7 @@ impl Flags { return 0; } self.f_of = value == 0x7fffffff; - self.f_sf = value+1 > 0x7fffffff; + self.f_sf = value + 1 > 0x7fffffff; self.calc_pf((value + 1) as u8); //self.f_pf = (((value as i32) +1) & 0xff) % 2 == 0; self.f_zf = false; @@ -679,7 +677,7 @@ impl Flags { return 0; } self.f_of = value == 0x7fff; - self.f_sf = value+1 > 0x7fff; + self.f_sf = value + 1 > 0x7fff; self.calc_pf((value + 1) as u8); //self.f_pf = (((value as i32) +1) & 0xff) % 2 == 0; self.f_zf = false; @@ -696,7 +694,7 @@ impl Flags { return 0; } self.f_of = value == 0x7f; - self.f_sf = value+1 > 0x7f; + self.f_sf = value + 1 > 0x7f; self.calc_pf((value + 1) as u8); //self.f_pf = (((value as i32) +1) & 0xff) % 2 == 0; self.f_zf = false; @@ -888,7 +886,11 @@ impl Flags { let s_result = if count < 64 { s64 >> count } else { - if s64 < 0 { -1 } else { 0 } + if s64 < 0 { + -1 + } else { + 0 + } }; let result = s_result as u64; @@ -904,7 +906,6 @@ impl Flags { result } - pub fn sar2p64_bug(&mut self, value0: u64, value1: u64) -> u64 { let s64: i64 = value0 as i64; if value1 == 0 { @@ -931,7 +932,11 @@ impl Flags { let s_result = if count < 32 { s32 >> count } else { - if s32 < 0 { -1 } else { 0 } + if s32 < 0 { + -1 + } else { + 0 + } }; let result = s_result as u32 as u64; @@ -947,7 +952,6 @@ impl Flags { result } - pub fn sar2p32_bug(&mut self, value0: u64, value1: u64) -> u64 { let s32: i32 = value0 as u32 as i32; if value1 == 0 { @@ -974,7 +978,11 @@ impl Flags { let s_result = if count < 16 { s16 >> count } else { - if s16 < 0 { -1 } else { 0 } + if s16 < 0 { + -1 + } else { + 0 + } }; let result = s_result as u16 as u64; @@ -990,7 +998,6 @@ impl Flags { result } - pub fn sar2p16_bug(&mut self, value0: u64, value1: u64) -> u64 { let s16 = value0 as u16 as i16; if value1 == 0 { @@ -1020,7 +1027,11 @@ impl Flags { } else { // - 0x00 if number was positive // - 0xFF if it was negative (sign extend) - if s8 < 0 { -1 } else { 0 } + if s8 < 0 { + -1 + } else { + 0 + } }; let result = s_result as u8 as u64; @@ -1036,7 +1047,6 @@ impl Flags { result } - pub fn sar2p8_bug(&mut self, value0: u64, value1: u64) -> u64 { let s8: i8 = value0 as u8 as i8; if value1 == 0 { @@ -1191,7 +1201,6 @@ impl Flags { result } - pub fn shl2p64_overflow(&mut self, value0: u64, value1: u64) -> u64 { if value1 == 0 { return value0; @@ -1488,8 +1497,6 @@ impl Flags { self.f_of = false; } - - let res: u64 = (uresult & 0xffffffffffffffff) as u64; res } @@ -1547,11 +1554,12 @@ impl Flags { let res = if count == 1 { (value0 >> count) | ((self.f_cf as u64) << (sz - 1)) } else { - (value0 >> count) | ((self.f_cf as u64) << ((sz as u64) - count)) | - (value0 << ((sz+1) as u64 - count)) + (value0 >> count) + | ((self.f_cf as u64) << ((sz as u64) - count)) + | (value0 << ((sz + 1) as u64 - count)) }; - self.f_cf = ((value0 >> (count - 1) ) & 1) == 1; + self.f_cf = ((value0 >> (count - 1)) & 1) == 1; self.f_of = ((res ^ (res << 1)) >> 63) == 1; } @@ -1565,7 +1573,8 @@ impl Flags { _ => { ((value0 >> count) | ((self.f_cf as u64) << ((sz as u64) - count)) - | (value0 << ((sz as u64 + 1) - count))) & pow + | (value0 << ((sz as u64 + 1) - count))) + & pow } }; @@ -1580,23 +1589,20 @@ impl Flags { res } - pub fn rcr_prev(&mut self, value0: u64, value1: u64, sz: u32) -> u64 { - let mask = if sz == 64 { - 0x3f - } else { - 0x1f - }; + let mask = if sz == 64 { 0x3f } else { 0x1f }; let count = value1 & mask; let res = if count == 1 { ((value0 >> count) | ((self.f_cf as u64) << (sz - 1))) & (u64::pow(2, sz) - 1) } else { - ((value0 >> count) | ((self.f_cf as u64) << ((sz as u64) - count)) | - (value0 << ((sz+1) as u64 - count))) & (u64::pow(2, sz) - 1) + ((value0 >> count) + | ((self.f_cf as u64) << ((sz as u64) - count)) + | (value0 << ((sz + 1) as u64 - count))) + & (u64::pow(2, sz) - 1) }; - self.f_cf = ((value0 >> (count - 1) ) & 1) == 1; - self.f_of = ((res ^ (res << 1)) >> (sz-1)) == 1; + self.f_cf = ((value0 >> (count - 1)) & 1) == 1; + self.f_of = ((res ^ (res << 1)) >> (sz - 1)) == 1; // don't calculate the flag zf, sf doesn't got effect res } @@ -1625,7 +1631,8 @@ impl Flags { } else { let pow = (1u64 << sz) - 1; let extended = ((value0 & pow) << 1) | (self.f_cf as u64); - let rotated = ((extended << count) | (extended >> ((sz + 1) as u64 - count))) & ((1u64 << (sz + 1)) - 1); + let rotated = ((extended << count) | (extended >> ((sz + 1) as u64 - count))) + & ((1u64 << (sz + 1)) - 1); let res = (rotated >> 1) & pow; self.f_cf = (rotated & 1) != 0; if count == 1 { @@ -1669,14 +1676,8 @@ impl Flags { res } - - pub fn ror_overflow(&mut self, value0: u64, value1: u64, sz: u32) -> u64 { - let mask = if sz == 64 { - 0x3f - } else { - 0x1f - }; + let mask = if sz == 64 { 0x3f } else { 0x1f }; // input size can be only 64 32 16 and 8 let res_mask = match sz { @@ -1685,14 +1686,14 @@ impl Flags { 16 => 0xffff, _ => 0xff, }; - let count = value1 & mask; + let count = value1 & mask; let res = (value0 >> count) | (value0 << (sz as u64 - count)) & res_mask; - let bit63 = (res >> (sz-1)) & 1; - let bit62 = (res >> (sz-2)) & 1; + let bit63 = (res >> (sz - 1)) & 1; + let bit62 = (res >> (sz - 2)) & 1; self.f_cf = bit63 == 1; self.f_of = bit63 != bit62; // take this for grant - // don't calculate the flag zf, sf doesn't got effect + // don't calculate the flag zf, sf doesn't got effect res } @@ -1740,20 +1741,15 @@ impl Flags { res } - pub fn rol_overflow(&mut self, value0: u64, value1: u64, sz: u32) -> u64 { - let mask = if sz == 64 { - 0x3f - } else { - 0x1f - }; + let mask = if sz == 64 { 0x3f } else { 0x1f }; let res_mask = match sz { 64 => 0xffffffffffffffff, 32 => 0xffffffff, 16 => 0xffff, _ => 0xff, }; - let count = value1 & mask; + let count = value1 & mask; let res = ((value0 << count) | (value0 >> (sz as u64 - count))) & res_mask; // panic_const_shr_overflow self.f_cf = (res & 0x1) == 1; self.f_of = (self.f_cf as u64 ^ (res >> (sz - 1))) == 1; @@ -1772,7 +1768,7 @@ impl Flags { 64 => 0xffff_ffff_ffff_ffff, 32 => 0xffff_ffff, 16 => 0xffff, - _ => 0xff, + _ => 0xff, }; let res = ((value0 >> count) | (value1 << (sz as u64 - count))) & res_mask; @@ -1784,11 +1780,7 @@ impl Flags { } pub fn shld(&mut self, value0: u64, value1: u64, count: u64, sz: u32) -> u64 { - let mask = if sz == 64 { - 0x3f - } else { - 0x1f - }; + let mask = if sz == 64 { 0x3f } else { 0x1f }; let count = count & mask; if count == 0 { @@ -1803,8 +1795,8 @@ impl Flags { }; let res = (value1 >> (sz as u64 - count)) | (value0 << count) & res_mask; - self.f_cf = ((value0 >> (sz as u64 - count) ) & 1) == 1; - self.f_of = (self.f_cf as u64 ^ (res >> (sz-1))) == 0x1; + self.f_cf = ((value0 >> (sz as u64 - count)) & 1) == 1; + self.f_of = (self.f_cf as u64 ^ (res >> (sz - 1))) == 0x1; self.calc_flags(res, sz); res } diff --git a/crates/libmwemu/src/fpu.rs b/crates/libmwemu/src/fpu.rs index d76be83b..fa298177 100644 --- a/crates/libmwemu/src/fpu.rs +++ b/crates/libmwemu/src/fpu.rs @@ -2,9 +2,9 @@ pub mod f80; pub mod fpu_stack; use crate::emu; -use iced_x86::Register; use f80::F80; use fpu_stack::FPUStack; +use iced_x86::Register; pub struct FPUState { pub fpu_control_word: u16, // Control Word @@ -16,7 +16,7 @@ pub struct FPUState { pub rdp: u64, // Data Pointer pub mxcsr: u32, // SSE Control and Status pub mxcsr_mask: u32, - pub st: FPUStack, // FPU registers + pub st: FPUStack, // FPU registers pub xmm: [u128; 16], // XMM registers pub reserved2: [u8; 224], // Reserved } @@ -288,7 +288,6 @@ impl FPU { self.peek_st_u80(idx) } - pub fn get_st_u80(&mut self, i: usize) -> u128 { return self.st.get(i).get(); } @@ -390,7 +389,6 @@ impl FPU { pub fn check_pending_exceptions(self) {} - pub fn move_reg_to_st0(&mut self, reg: Register) { match reg { Register::ST0 => self.move_to_st0(0), @@ -433,7 +431,6 @@ impl FPU { } } - pub fn set_streg_f80(&mut self, reg: Register, value: u128) { //println!("{:?} {}", reg, value); let idx = self.reg_to_idx(reg); @@ -480,7 +477,6 @@ impl FPU { result } - pub fn fxsave(&self) -> FPUState { let mut state = FPUState::new(); state.fpu_control_word = self.fpu_control_word; @@ -514,4 +510,4 @@ impl FPU { self.xmm = state.xmm; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/fpu/f80.rs b/crates/libmwemu/src/fpu/f80.rs index c3ef855e..b32da749 100644 --- a/crates/libmwemu/src/fpu/f80.rs +++ b/crates/libmwemu/src/fpu/f80.rs @@ -1,4 +1,4 @@ -use serde::{Serialize,Deserialize}; +use serde::{Deserialize, Serialize}; pub const FPU_80_BITS_MAX: u128 = (1u128 << 80) - 1; pub const REAL_INDEFINITE: u128 = 0xffff_c000_0000_0000_0000 & FPU_80_BITS_MAX; @@ -23,26 +23,20 @@ pub const INT_BIT_SHIFT: u32 = 63; // f80 emulation #[derive(Copy, Clone, Serialize, Deserialize)] pub struct F80 { - pub st:u128, + pub st: u128, } impl F80 { pub fn new() -> Self { - F80 { - st: 0 - } + F80 { st: 0 } } pub fn PI() -> Self { - F80 { - st: F80_PI - } + F80 { st: F80_PI } } pub fn QNaN() -> Self { - F80 { - st: QNAN - } + F80 { st: QNAN } } pub fn set_PI(&mut self) { @@ -57,7 +51,6 @@ impl F80 { self.st = REAL_INDEFINITE; } - pub fn is_invalid(&self) -> bool { let exp = self.get_exponent(); let frac = self.get_fraction(); @@ -81,13 +74,11 @@ impl F80 { let mut bytes = [0u8; 10]; for i in 0..10 { bytes[i] = ((self.st >> (8 * i)) & 0xFF) as u8; - } bytes } pub fn get_round_f64(&self, decimals: u32) -> f64 { - let value = self.get_f64(); let factor = 10f64.powi(decimals as i32); (value * factor).round() / factor @@ -97,7 +88,7 @@ impl F80 { self.st & FPU_80_BITS_MAX } - pub fn set(&mut self, value:u128) { + pub fn set(&mut self, value: u128) { self.st = value & FPU_80_BITS_MAX; } @@ -155,7 +146,7 @@ impl F80 { pub fn set_mantissa(&mut self, mantissa: u64) { let int_bit = (mantissa >> 63) as u128; let fraction = (mantissa & 0x7FFF_FFFF_FFFF_FFFF) as u128; - self.st &= !( (1u128 << INT_BIT_SHIFT) | ((1u128 << 63) -1)); + self.st &= !((1u128 << INT_BIT_SHIFT) | ((1u128 << 63) - 1)); self.st |= (int_bit << INT_BIT_SHIFT) | fraction; /* @@ -298,8 +289,6 @@ impl F80 { (mant, exp) } - - pub fn is_integer(&self) -> bool { self.get_mantissa() == 0 } @@ -310,7 +299,7 @@ impl F80 { } pub fn bit_integer(&self) -> bool { - (self.st & INT_BIT_MASK) & 1 == 1 + (self.st & INT_BIT_MASK) & 1 == 1 } pub fn is_denormal(&self) -> bool { diff --git a/crates/libmwemu/src/fpu/fpu_stack.rs b/crates/libmwemu/src/fpu/fpu_stack.rs index 866f42a4..580ee11f 100644 --- a/crates/libmwemu/src/fpu/fpu_stack.rs +++ b/crates/libmwemu/src/fpu/fpu_stack.rs @@ -30,7 +30,12 @@ impl FPUStack { info!("top: {}", self.top); info!("depth: {}", self.depth); for i in (0..8).rev() { - info!("ST({}) 0x{:x} {}", i, self.regs[i].get(), self.regs[i].get_f64()); + info!( + "ST({}) 0x{:x} {}", + i, + self.regs[i].get(), + self.regs[i].get_f64() + ); } info!("invalid_flag: {:b}", self.invalid_flag); } @@ -64,7 +69,7 @@ impl FPUStack { pub fn push_f64(&mut self, value: f64) { if self.depth >= 8 { - panic!("FPU stack overflow"); + panic!("FPU stack overflow"); // in linux: terminated by signal SIGFPE (Floating point exception) } self.top = (self.top.wrapping_sub(1)) & 7; @@ -75,7 +80,7 @@ impl FPUStack { pub fn push_f80(&mut self, value: F80) { if self.depth >= 8 { - panic!("FPU stack overflow"); + panic!("FPU stack overflow"); // in linux: terminated by signal SIGFPE (Floating point exception) } self.top = (self.top.wrapping_sub(1)) & 7; @@ -152,6 +157,3 @@ impl FPUStack { self.regs.swap(a, b); } } - - - diff --git a/crates/libmwemu/src/kuser_shared.rs b/crates/libmwemu/src/kuser_shared.rs index 541043a2..e07dd760 100644 --- a/crates/libmwemu/src/kuser_shared.rs +++ b/crates/libmwemu/src/kuser_shared.rs @@ -1,7 +1,9 @@ -use std::mem::MaybeUninit; -use bitfield::bitfield; use crate::emu; +use crate::maps::mem64::Permission; +use bitfield::bitfield; +use std::mem::MaybeUninit; use std::ptr; + const USER_KUSER_SHARED_ADDR: u64 = 0x7FFE0000; #[repr(u32)] @@ -90,7 +92,6 @@ pub union KusdSharedDataFlagsUnion { pub bits: KusdSharedDataFlagsBits, } - #[repr(C)] #[derive(Clone, Copy)] pub struct OverlayStruct { @@ -149,7 +150,6 @@ pub union ControlFlagsUnion { #[repr(C)] #[derive(Clone, Copy)] pub struct XstateConfiguration { - pub EnabledFeatures: u64, pub EnabledVolatileFeatures: u64, pub Size: u32, @@ -258,11 +258,16 @@ pub struct KuserSharedData { pub fn init_kuser_shared_data(emu: &mut emu::Emu) -> u64 { emu.maps - .create_map("KuserSharedData", USER_KUSER_SHARED_ADDR, 0x1000) + .create_map( + "KuserSharedData", + USER_KUSER_SHARED_ADDR, + 0x1000, + Permission::READ_WRITE, + ) .expect("cannot create KuserSharedData map"); // The KUSER_SHARED_DATA is getting from: https://github.com/momo5502/sogen/blob/main/src/windows-emulator/kusd_mmio.cpp - let mut kusd: KuserSharedData = unsafe {MaybeUninit::zeroed().assume_init()}; + let mut kusd: KuserSharedData = unsafe { MaybeUninit::zeroed().assume_init() }; kusd.TickCountMultiplier = 0x0fa00000; kusd.InterruptTime.LowPart = 0x17bd9547; kusd.InterruptTime.High1Time = 0x0000004b; @@ -288,7 +293,9 @@ pub fn init_kuser_shared_data(emu: &mut emu::Emu) -> u64 { kusd.MitigationPolicies.MitigationPolicies = 0x0a; unsafe { kusd.MitigationPolicies.Anonymous.set_nx_support_policy(0x2); - kusd.MitigationPolicies.Anonymous.set_seh_validation_policy(0x2); + kusd.MitigationPolicies + .Anonymous + .set_seh_validation_policy(0x2); } kusd.CyclesPerYield = 0x0064; kusd.DismountCount = 0x00000006; @@ -319,19 +326,25 @@ pub fn init_kuser_shared_data(emu: &mut emu::Emu) -> u64 { kusd.XState.EnabledVolatileFeatures = 0x000000000000000f; kusd.XState.Size = 0x000003c0; kusd.QpcData.QpcData = 0x0083; - kusd.QpcData.anonymous.QpcBypassEnabled= 0x83; + kusd.QpcData.anonymous.QpcBypassEnabled = 0x83; kusd.QpcBias = 0x000000159530c4af; - let mut memory: [u8; std::mem::size_of::()] = [0; std::mem::size_of::()]; + let mut memory: [u8; std::mem::size_of::()] = + [0; std::mem::size_of::()]; unsafe { // Copy the struct into the allocated memory let struct_ptr = &kusd as *const KuserSharedData as *const u8; let memory_ptr = memory.as_mut_ptr(); - ptr::copy_nonoverlapping(struct_ptr, memory_ptr, std::mem::size_of::()); + ptr::copy_nonoverlapping( + struct_ptr, + memory_ptr, + std::mem::size_of::(), + ); } - emu.maps.write_bytes(USER_KUSER_SHARED_ADDR, memory.to_vec()); + emu.maps + .write_bytes(USER_KUSER_SHARED_ADDR, memory.to_vec()); USER_KUSER_SHARED_ADDR } diff --git a/crates/libmwemu/src/lib.rs b/crates/libmwemu/src/lib.rs index 54b19a63..4e3b792b 100644 --- a/crates/libmwemu/src/lib.rs +++ b/crates/libmwemu/src/lib.rs @@ -24,7 +24,10 @@ pub mod fpu; pub mod hooks; #[macro_use] pub mod macros; +pub mod crit_state; pub mod exception_type; +pub mod global_locks; +pub mod kuser_shared; pub mod maps; pub mod ntapi; pub mod pe; @@ -34,13 +37,10 @@ pub mod script; pub mod serialization; pub mod structures; pub mod syscall; -pub mod winapi; -pub mod kuser_shared; -pub mod crit_state; -pub mod global_locks; pub mod thread_context; pub mod threading; pub mod tracing; +pub mod winapi; #[cfg(test)] mod tests; diff --git a/crates/libmwemu/src/macros.rs b/crates/libmwemu/src/macros.rs index 23ef467d..b796e726 100644 --- a/crates/libmwemu/src/macros.rs +++ b/crates/libmwemu/src/macros.rs @@ -53,4 +53,4 @@ macro_rules! log_red { ); } }; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/maps/mem64.rs b/crates/libmwemu/src/maps/mem64.rs index 8efb54e8..e27ce1e3 100644 --- a/crates/libmwemu/src/maps/mem64.rs +++ b/crates/libmwemu/src/maps/mem64.rs @@ -1,6 +1,8 @@ /* Little endian 64 bits and inferior bits memory. */ +use crate::emu_context; +use bytemuck::cast_slice; use md5; use serde::{Deserialize, Serialize}; use std::convert::TryInto; @@ -10,14 +12,138 @@ use std::io::BufReader; use std::io::Read; use std::io::SeekFrom; use std::io::Write; -use bytemuck::cast_slice; -use crate::emu_context; + +#[derive(Copy, Clone, Serialize, Deserialize)] +pub struct Permission(u8); + +// Bit flags for permissions +impl Permission { + pub const NONE: Permission = Permission(0b000); + pub const READ: Permission = Permission(0b001); + pub const WRITE: Permission = Permission(0b010); + pub const EXECUTE: Permission = Permission(0b100); + + // Common combinations + pub const READ_WRITE: Permission = Permission(0b011); + pub const READ_EXECUTE: Permission = Permission(0b101); + pub const WRITE_EXECUTE: Permission = Permission(0b110); + pub const READ_WRITE_EXECUTE: Permission = Permission(0b111); + + /// Create a new Permission from raw bits + #[inline] + pub const fn from_bits(bits: u8) -> Self { + Permission(bits & 0b111) // Only use the lower 3 bits + } + + /// Get the raw bits + #[inline] + pub const fn bits(&self) -> u8 { + self.0 + } + + /// Create permission from individual flags + #[inline] + pub fn from_flags(read: bool, write: bool, execute: bool) -> Self { + let mut bits = 0; + if read { + bits |= 0b001; + } + if write { + bits |= 0b010; + } + if execute { + bits |= 0b100; + } + Permission(bits) + } + + /// Check if read access is allowed + #[inline] + pub const fn can_read(&self) -> bool { + (self.0 & 0b001) != 0 + } + + /// Check if write access is allowed + #[inline] + pub const fn can_write(&self) -> bool { + (self.0 & 0b010) != 0 + } + + /// Check if execute access is allowed + #[inline] + pub const fn can_execute(&self) -> bool { + (self.0 & 0b100) != 0 + } + + /// Check if any access is allowed + #[inline] + pub const fn is_accessible(&self) -> bool { + self.0 != 0 + } + + /// Add a permission (union) + #[inline] + pub const fn add(&self, other: Permission) -> Self { + Permission(self.0 | other.0) + } + + /// Remove a permission + pub const fn remove(&self, other: Permission) -> Self { + Permission(self.0 & !other.0) + } + + /// Check if this permission contains another permission + #[inline] + pub const fn contains(&self, other: Permission) -> bool { + (self.0 & other.0) == other.0 + } + + /// Get individual permission flags + #[inline] + pub const fn to_flags(&self) -> (bool, bool, bool) { + (self.can_read(), self.can_write(), self.can_execute()) + } +} + +// Implement bitwise operations for Permission +impl std::ops::BitOr for Permission { + type Output = Self; + + fn bitor(self, rhs: Self) -> Self { + Permission(self.0 | rhs.0) + } +} + +impl std::ops::BitAnd for Permission { + type Output = Self; + + fn bitand(self, rhs: Self) -> Self { + Permission(self.0 & rhs.0) + } +} + +impl std::ops::BitXor for Permission { + type Output = Self; + + fn bitxor(self, rhs: Self) -> Self { + Permission(self.0 ^ rhs.0) + } +} + +impl std::ops::Not for Permission { + type Output = Self; + + fn not(self) -> Self { + Permission(!self.0 & 0b111) + } +} #[derive(Clone, Serialize, Deserialize)] pub struct Mem64 { mem_name: String, base_addr: u64, bottom_addr: u64, + permission: Permission, mem: Vec, } @@ -27,21 +153,63 @@ impl Default for Mem64 { mem_name: "".to_string(), base_addr: 0, bottom_addr: 0, + permission: Permission::from_flags(true, true, false), mem: Vec::new(), } } } impl Mem64 { - pub fn new(mem_name: String, base_addr: u64, bottom_addr: u64, mem: Vec) -> Mem64 { + pub fn new( + mem_name: String, + base_addr: u64, + bottom_addr: u64, + mem: Vec, + permission: Permission, + ) -> Mem64 { Mem64 { mem_name, base_addr, bottom_addr, - mem + permission, + mem, } } + pub fn permission(&self) -> Permission { + self.permission + } + + /// Set new permissions + pub fn set_permission(&mut self, permission: Permission) { + self.permission = permission; + } + + /// Add permissions + pub fn add_permission(&mut self, permission: Permission) { + self.permission = self.permission.add(permission); + } + + /// Remove permissions + pub fn remove_permission(&mut self, permission: Permission) { + self.permission = self.permission.remove(permission); + } + + /// Check if read access is allowed for this memory region + pub fn can_read(&self) -> bool { + self.permission.can_read() + } + + /// Check if write access is allowed for this memory region + pub fn can_write(&self) -> bool { + self.permission.can_write() + } + + /// Check if execute access is allowed for this memory region + pub fn can_execute(&self) -> bool { + self.permission.can_execute() + } + pub fn clear(&mut self) { self.mem_name = "".to_string(); self.base_addr = 0; @@ -147,6 +315,20 @@ impl Mem64 { #[inline(always)] pub fn read_from(&self, addr: u64) -> &[u8] { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let max_sz = (self.bottom_addr - self.base_addr) as usize; /* @@ -165,26 +347,31 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } #[inline(always)] pub fn read_bytes(&self, addr: u64, sz: usize) -> &[u8] { + if !self.can_read() { + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + if addr >= self.base_addr + self.mem.len() as u64 { // TODO: log trace? return &[0; 0]; } if addr < self.base_addr { - // TODO: log trace? + // TODO: log trace? return &[0; 0]; } let idx = (addr - self.base_addr) as usize; let sz2 = idx + sz; if sz2 > self.mem.len() { - // TODO: log trace? - let addr = self.mem.get(idx..self.mem.len()).unwrap(); + // TODO: log trace? + let addr = self.mem.get(idx..self.mem.len()).unwrap(); return addr; } let r = self.mem.get(idx..sz2).unwrap(); @@ -198,7 +385,8 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } @@ -209,7 +397,7 @@ impl Mem64 { let sz2 = self.size(); if sz2 > self.mem.len() { // TODO: log trace? - let bytes = self.mem.get(idx..self.mem.len()).unwrap(); + let bytes = self.mem.get(idx..self.mem.len()).unwrap(); return bytes; } let r = self.mem.get(idx..sz2).unwrap(); @@ -223,13 +411,28 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } #[inline(always)] pub fn read_byte(&self, addr: u64) -> u8 { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let r = self.mem[idx]; if cfg!(feature = "log_mem_read") { @@ -242,13 +445,28 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } #[inline(always)] pub fn read_word(&self, addr: u64) -> u16 { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let r = (self.mem[idx] as u16) + ((self.mem[idx + 1] as u16) << 8); let r = u16::from_le_bytes(self.mem[idx..idx + 2].try_into().expect("incorrect length")); @@ -262,13 +480,28 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } #[inline(always)] pub fn read_dword(&self, addr: u64) -> u32 { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let r = u32::from_le_bytes(self.mem[idx..idx + 4].try_into().expect("incorrect length")); if cfg!(feature = "log_mem_read") { @@ -281,13 +514,28 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } #[inline(always)] pub fn read_qword(&self, addr: u64) -> u64 { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let r = u64::from_le_bytes(self.mem[idx..idx + 8].try_into().expect("incorrect length")); if cfg!(feature = "log_mem_read") { @@ -300,12 +548,27 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } pub fn read_oword(&self, addr: u64) -> u128 { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; let r = u128::from_le_bytes( self.mem[idx..idx + 16] @@ -322,13 +585,157 @@ impl Mem64 { r ); } - }).unwrap(); + }) + .unwrap(); } r } + #[inline(always)] + pub fn force_write_byte(&mut self, addr: u64, value: u8) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx] = value; + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_byte: 0x{:x?} = 0x{:x}", + self.build_addresses(addr, 1), + value + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_bytes(&mut self, addr: u64, bs: &[u8]) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx..(bs.len() + idx)].copy_from_slice(bs.as_ref()); + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_bytes: 0x{:x?} = {:?}", + self.build_addresses(addr, bs.len()), + bs + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_word(&mut self, addr: u64, value: u16) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx..idx + 2].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); + + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_word: 0x{:x?} = 0x{:x}", + self.build_addresses(addr, 2), + value + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_dword(&mut self, addr: u64, value: u32) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx..idx + 4].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); + + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_dword: 0x{:x?} = 0x{:x}", + self.build_addresses(addr, 4), + value + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_qword(&mut self, addr: u64, value: u64) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx..idx + 8].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); + + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_qword: 0x{:x?} = 0x{:x}", + self.build_addresses(addr, 8), + value + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_oword(&mut self, addr: u64, value: u128) { + let idx = (addr - self.base_addr) as usize; + self.mem[idx..idx + 16].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); + + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_oword: 0x{:x?} = 0x{:x}", + self.build_addresses(addr, 16), + value + ); + } + }) + .unwrap(); + } + } + + #[inline(always)] + pub fn force_write_string(&mut self, addr: u64, s: &str) { + let mut v = s.as_bytes().to_vec(); + v.push(0); + self.force_write_bytes(addr, &v); + + if cfg!(feature = "log_mem_write") { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "mem: force_write_string: 0x{:x?} = {:?}", + self.build_addresses(addr, s.len() + 1), + s + ); + } + }) + .unwrap(); + } + } + #[inline(always)] pub fn write_byte(&mut self, addr: u64, value: u8) { + if !self.can_write() { + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx] = value; if cfg!(feature = "log_mem_write") { @@ -341,12 +748,17 @@ impl Mem64 { value ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_bytes(&mut self, addr: u64, bs: &[u8]) { + if !self.can_write() { + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx..(bs.len() + idx)].copy_from_slice(bs.as_ref()); if cfg!(feature = "log_mem_write") { @@ -359,12 +771,27 @@ impl Mem64 { bs ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_word(&mut self, addr: u64, value: u16) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx..idx + 2].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); @@ -378,12 +805,27 @@ impl Mem64 { value ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_dword(&mut self, addr: u64, value: u32) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx..idx + 4].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); @@ -397,12 +839,27 @@ impl Mem64 { value ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_qword(&mut self, addr: u64, value: u64) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx..idx + 8].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); @@ -416,12 +873,27 @@ impl Mem64 { value ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_oword(&mut self, addr: u64, value: u128) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let idx = (addr - self.base_addr) as usize; self.mem[idx..idx + 16].copy_from_slice(value.to_le_bytes().to_vec().as_ref()); @@ -435,12 +907,27 @@ impl Mem64 { value ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn write_string(&mut self, addr: u64, s: &str) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let mut v = s.as_bytes().to_vec(); if v.last() != Some(&0) { v.push(0); @@ -458,16 +945,31 @@ impl Mem64 { v ); } - }).unwrap(); + }) + .unwrap(); } } #[inline(always)] pub fn read_string(&self, addr: u64) -> String { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let MAX_SIZE_STR = 1_000_000; let mut s: Vec = Vec::new(); let mut idx = addr; - while idx < addr+MAX_SIZE_STR { + while idx < addr + MAX_SIZE_STR { let b = self.read_byte(idx); if b == 0 { break; @@ -485,13 +987,28 @@ impl Mem64 { s ); } - }).unwrap(); + }) + .unwrap(); } String::from_utf8(s).expect("invalid utf-8") } #[inline(always)] pub fn write_wide_string(&mut self, addr: u64, s: &str) { + if !self.can_write() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: write_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to write without permission: addr: 0x{:x?}", addr); + } + let mut wide_string: Vec = s.encode_utf16().collect(); if wide_string.last() != Some(&0) { wide_string.push(0); @@ -510,16 +1027,31 @@ impl Mem64 { wide_string_byte_slice ); } - }).unwrap(); + }) + .unwrap(); } } #[inline] pub fn read_wide_string(&self, addr: u64) -> String { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let MAX_SIZE_STR = 1_000_000; let mut s: Vec = Vec::new(); let mut idx = addr; - while idx < addr+MAX_SIZE_STR { + while idx < addr + MAX_SIZE_STR { let b = self.read_word(idx); if b == 0 { break; @@ -537,16 +1069,35 @@ impl Mem64 { s ); } - }).unwrap(); + }) + .unwrap(); } - + match String::from_utf16(&s) { - Ok(s) => { return s; } - Err(_) => { return "".to_string(); } + Ok(s) => { + return s; + } + Err(_) => { + return "".to_string(); + } } } pub fn read_wide_string_n(&self, addr: u64, max_chars: usize) -> String { + if !self.can_read() { + emu_context::with_current_emu(|emu| { + if emu.cfg.trace_mem { + log_red!( + emu, + "FAILED doesn't have permission: read_from: 0x{:x?}", + addr + ); + } + }) + .unwrap(); + panic!("FAILED to read without permission: addr: 0x{:x?}", addr); + } + let mut s: Vec = Vec::new(); let mut idx = addr; for _ in 0..max_chars { @@ -567,7 +1118,8 @@ impl Mem64 { s ); } - }).unwrap(); + }) + .unwrap(); } String::from_utf16_lossy(&s) } diff --git a/crates/libmwemu/src/maps/mod.rs b/crates/libmwemu/src/maps/mod.rs index 33b59592..92e74385 100644 --- a/crates/libmwemu/src/maps/mod.rs +++ b/crates/libmwemu/src/maps/mod.rs @@ -1,17 +1,18 @@ pub mod mem64; pub mod tlb; -use std::cell::RefCell; use crate::constants; +use crate::maps::mem64::Permission; +use crate::maps::tlb::LPF_OF; use ahash::AHashMap; use mem64::Mem64; -use tlb::TLB; use serde::{Deserialize, Serialize}; +use slab::Slab; +use std::cell::RefCell; use std::collections::BTreeMap; use std::convert::TryInto; -use slab::Slab; use std::str; -use crate::maps::tlb::LPF_OF; +use tlb::TLB; #[derive(Clone, Serialize, Deserialize)] pub struct Maps { @@ -42,12 +43,12 @@ impl Maps { const DEFAULT_ALIGNMENT: u64 = 0x1000; //16; pub fn new( - mem_slab: Slab, - maps: BTreeMap, - name_map: AHashMap, - is_64bits: bool, - banzai: bool, - tlb: RefCell + mem_slab: Slab, + maps: BTreeMap, + name_map: AHashMap, + is_64bits: bool, + banzai: bool, + tlb: RefCell, ) -> Maps { Maps { banzai, @@ -129,7 +130,13 @@ impl Maps { }) } - pub fn create_map(&mut self, name: &str, base: u64, size: u64) -> Result<&mut Mem64, String> { + pub fn create_map( + &mut self, + name: &str, + base: u64, + size: u64, + permission: Permission, + ) -> Result<&mut Mem64, String> { //if size == 0 { // return Err(format!("map size cannot be 0")); //} @@ -147,6 +154,7 @@ impl Maps { mem.set_name(name); mem.set_base(base); mem.set_size(size); + mem.set_permission(permission); let base_key = self.mem_slab.insert(mem); self.name_map.insert(name.to_string(), base_key); @@ -188,9 +196,7 @@ impl Maps { log::warn!("Reading byte from unmapped region at 0x{:x}", addr); None } - _ => { - None - } + _ => None, } } @@ -238,7 +244,7 @@ impl Maps { true } Some(_) => { - if banzai{ + if banzai { log::warn!("Writing dword to unmapped region at 0x{:x}", addr); } else { panic!("Writing dword to unmapped region at 0x{:x}", addr); @@ -246,7 +252,7 @@ impl Maps { false } None => { - if banzai{ + if banzai { log::warn!("Writing dword to unmapped region at 0x{:x}", addr); } else { panic!("Writing dword to unmapped region at 0x{:x}", addr); @@ -288,14 +294,14 @@ impl Maps { if data.is_empty() { return true; } - + // Write byte by byte to handle any boundary issues for (i, &byte) in data.iter().enumerate() { if !self.write_byte(addr + i as u64, byte) { return false; } } - + true } @@ -410,14 +416,15 @@ impl Maps { if mem.inside(addr) { return self.mem_slab.get_mut(tlb_entry_mut.mem64); // Clone the &Mem64 } - }, + } _ => { tlb_entry_mut.invalidate(); } // Remove the tlb entry }; // TLB miss now search in the maps - let mem_key_option = self.maps + let mem_key_option = self + .maps .range(..=addr) .next_back() .map(|(_start_addr, &key)| key); @@ -447,14 +454,11 @@ impl Maps { if mem.inside(addr) { return Some(&mem); // Clone the &Mem64 } - }, - _ => () // TLB miss now search in maps + } + _ => (), // TLB miss now search in maps }; - let mem_key_option = self.maps - .range(..=addr) - .next_back() - .map(|(_k, &v)| v); + let mem_key_option = self.maps.range(..=addr).next_back().map(|(_k, &v)| v); let mem_key = mem_key_option?; // Return None if not found @@ -735,9 +739,7 @@ impl Maps { if !self.is_64bits { // only in 32bits make sense derreference dwords in memory - let name = self - .get_addr_name(value.into()) - .unwrap_or_else(|| ""); + let name = self.get_addr_name(value.into()).unwrap_or_else(|| ""); let mut s = "".to_string(); if !name.is_empty() { @@ -811,12 +813,11 @@ impl Maps { if addr == 0 { return "".to_string(); } - let mem = match self - .get_mem_by_addr(addr) { - Some(m) => m, - None => { - return "".to_string(); - } + let mem = match self.get_mem_by_addr(addr) { + Some(m) => m, + None => { + return "".to_string(); + } }; mem.read_wide_string(addr) } @@ -1146,11 +1147,11 @@ impl Maps { pub fn dealloc(&mut self, addr: u64) { let mem_key = match self.maps.get(&addr) { - Some(key) => key, - None => { - log::info!("dealloc: non mapped address 0x{:x}", addr); - return; - } + Some(key) => key, + None => { + log::info!("dealloc: non mapped address 0x{:x}", addr); + return; + } }; let mem = self.mem_slab.get_mut(*mem_key).unwrap(); self.name_map.remove(mem.get_name()); @@ -1160,20 +1161,26 @@ impl Maps { self.maps.remove(&addr); } - pub fn map(&mut self, name: &str, sz: u64) -> u64 { + pub fn map(&mut self, name: &str, sz: u64, permission: Permission) -> u64 { let addr = self.alloc(sz).expect("emu.maps.map(sz) cannot allocate"); - self.create_map(name, addr, sz).expect("emu.maps.map(sz) cannot create map"); + self.create_map(name, addr, sz, permission) + .expect("emu.maps.map(sz) cannot create map"); addr } - pub fn map_lib(&mut self, name: &str, sz: u64) -> u64 { + pub fn map_lib(&mut self, name: &str, sz: u64, permission: Permission) -> u64 { let addr = self.alloc(sz).expect("emu.maps.map(sz) cannot allocate"); - if self.is_64bits { - let addr = self.lib64_alloc(sz).expect("emu.maps.map_lib(sz) cannot allocate"); + if self.is_64bits { + let addr = self + .lib64_alloc(sz) + .expect("emu.maps.map_lib(sz) cannot allocate"); } else { - let addr = self.lib32_alloc(sz).expect("emu.maps.map_lib(sz) cannot allocate"); + let addr = self + .lib32_alloc(sz) + .expect("emu.maps.map_lib(sz) cannot allocate"); } - self.create_map(name, addr, sz).expect("emu.maps.map_lib(sz) cannot create map"); + self.create_map(name, addr, sz, permission) + .expect("emu.maps.map_lib(sz) cannot create map"); addr } @@ -1203,7 +1210,7 @@ impl Maps { * vars: * prev: is an aligned address, start with bottom and iterates every map bottom. * base: base address of specific map. - */ + */ let mut prev: u64 = self.align_up(bottom, Self::DEFAULT_ALIGNMENT); let debug = false; diff --git a/crates/libmwemu/src/maps/tlb.rs b/crates/libmwemu/src/maps/tlb.rs index abd7d196..861841cf 100644 --- a/crates/libmwemu/src/maps/tlb.rs +++ b/crates/libmwemu/src/maps/tlb.rs @@ -90,6 +90,5 @@ impl TLB { if LPF_OF(tlb_entry.lpf) == LPF_OF(laddr) { tlb_entry.invalidate(); } - } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/pe/pe32.rs b/crates/libmwemu/src/pe/pe32.rs index 0abf2351..0b37ade9 100644 --- a/crates/libmwemu/src/pe/pe32.rs +++ b/crates/libmwemu/src/pe/pe32.rs @@ -1257,8 +1257,8 @@ impl PE32 { } } else if level == 0 && type_name.is_some() - && type_name.unwrap() == self.get_resource_name(&entry) { - + && type_name.unwrap() == self.get_resource_name(&entry) + { println!("type_name matched"); matched = true; } else if level == 1 diff --git a/crates/libmwemu/src/pe/pe64.rs b/crates/libmwemu/src/pe/pe64.rs index 31b6bff7..0ceef931 100644 --- a/crates/libmwemu/src/pe/pe64.rs +++ b/crates/libmwemu/src/pe/pe64.rs @@ -396,19 +396,19 @@ impl PE64 { for sect in sections { if vaddr >= sect.virtual_address && vaddr < sect.virtual_address + sect.virtual_size { let offset_within_section = vaddr - sect.virtual_address; - + // Check if the offset is within the raw data size (not just virtual size) if offset_within_section >= sect.size_of_raw_data { log::warn!("Virtual address 0x{:x} maps to uninitialized data in section '{}' (offset {} >= raw_size {})", vaddr, sect.get_name(), offset_within_section, sect.size_of_raw_data); return 0; // or handle this case differently } - + let file_offset = sect.pointer_to_raw_data + offset_within_section; - + /*log::debug!("vaddr_to_off: 0x{:x} -> file_offset 0x{:x} (section: '{}', sect_vaddr: 0x{:x}, sect_raw_ptr: 0x{:x})", - vaddr, file_offset, sect.get_name(), sect.virtual_address, sect.pointer_to_raw_data);*/ - + vaddr, file_offset, sect.get_name(), sect.virtual_address, sect.pointer_to_raw_data);*/ + return file_offset; } } @@ -744,7 +744,11 @@ impl PE64 { // Bounds check for reading the directory header if off + 16 > rsrc.len() { - log::warn!("Resource directory at offset {} is out of bounds (rsrc size: {})", off, rsrc.len()); + log::warn!( + "Resource directory at offset {} is out of bounds (rsrc size: {})", + off, + rsrc.len() + ); return None; } @@ -757,16 +761,24 @@ impl PE64 { dir.number_of_id_entries = read_u16_le!(rsrc, off + 14); let entries = dir.number_of_named_entries + dir.number_of_id_entries; - - log::debug!("Resource directory level {}: {} named entries, {} ID entries", - level, dir.number_of_named_entries, dir.number_of_id_entries); + + log::debug!( + "Resource directory level {}: {} named entries, {} ID entries", + level, + dir.number_of_named_entries, + dir.number_of_id_entries + ); for i in 0..entries { let entry_off = off + (i as usize * 8) + 16; // 16 = sizeof(ImageResourceDirectory) - + // Bounds check for reading directory entry if entry_off + 8 > rsrc.len() { - log::warn!("Resource directory entry {} at offset {} is out of bounds", i, entry_off); + log::warn!( + "Resource directory entry {} at offset {} is out of bounds", + i, + entry_off + ); continue; } @@ -774,8 +786,14 @@ impl PE64 { entry.name_or_id = read_u32_le!(rsrc, entry_off); entry.data_or_directory = read_u32_le!(rsrc, entry_off + 4); - log::debug!("Entry {}: name_or_id=0x{:x}, data_or_directory=0x{:x}, is_id={}, is_directory={}", - i, entry.name_or_id, entry.data_or_directory, entry.is_id(), entry.is_directory()); + log::debug!( + "Entry {}: name_or_id=0x{:x}, data_or_directory=0x{:x}, is_id={}, is_directory={}", + i, + entry.name_or_id, + entry.data_or_directory, + entry.is_id(), + entry.is_directory() + ); let matched: bool; @@ -797,22 +815,26 @@ impl PE64 { } else { // Named entry - need to read the name string let name_offset = entry.get_name_or_id() & 0x7FFFFFFF; // Remove the high bit - + // The name_offset is relative to the start of the resource section let rsrc_section = self.get_section_ptr_by_name(".rsrc"); if rsrc_section.is_none() { log::warn!("No .rsrc section found"); continue; } - + // Check if name_offset is within the resource section if name_offset as usize >= rsrc.len() { - log::warn!("Resource name offset 0x{:x} is out of bounds (rsrc size: {})", name_offset, rsrc.len()); + log::warn!( + "Resource name offset 0x{:x} is out of bounds (rsrc size: {})", + name_offset, + rsrc.len() + ); continue; } - + let resource_name = self.read_resource_name_from_rsrc(rsrc, name_offset as usize); - + if level == 0 && type_name.is_some() && type_name.unwrap() == resource_name { log::debug!("type_name '{}' matched at level {}", resource_name, level); matched = true; @@ -828,7 +850,7 @@ impl PE64 { if entry.is_directory() { let next_dir_offset = entry.get_offset() & 0x7FFFFFFF; // Remove the high bit log::debug!("Following directory at offset 0x{:x}", next_dir_offset); - + return self.locate_resource_data_entry( rsrc, next_dir_offset as usize, @@ -841,19 +863,28 @@ impl PE64 { } else { // This is a data entry let data_entry_offset = entry.get_offset(); - + if data_entry_offset as usize + 16 > rsrc.len() { - log::warn!("Resource data entry at offset 0x{:x} is out of bounds", data_entry_offset); + log::warn!( + "Resource data entry at offset 0x{:x} is out of bounds", + data_entry_offset + ); return None; } - - log::debug!("Found resource data entry at offset 0x{:x}", data_entry_offset); - + + log::debug!( + "Found resource data entry at offset 0x{:x}", + data_entry_offset + ); + let mut data_entry = structures::ImageResourceDataEntry64::new(); - data_entry.offset_to_data = read_u32_le!(rsrc, data_entry_offset as usize) as u64; + data_entry.offset_to_data = + read_u32_le!(rsrc, data_entry_offset as usize) as u64; data_entry.size = read_u32_le!(rsrc, data_entry_offset as usize + 4) as u64; - data_entry.code_page = read_u32_le!(rsrc, data_entry_offset as usize + 8) as u64; - data_entry.reserved = read_u32_le!(rsrc, data_entry_offset as usize + 12) as u64; + data_entry.code_page = + read_u32_le!(rsrc, data_entry_offset as usize + 8) as u64; + data_entry.reserved = + read_u32_le!(rsrc, data_entry_offset as usize + 12) as u64; return Some(data_entry); } @@ -866,20 +897,26 @@ impl PE64 { // Helper function to safely read resource names from the .rsrc section pub fn read_resource_name_from_rsrc(&self, rsrc: &[u8], offset: usize) -> String { if offset + 1 >= rsrc.len() { - log::warn!("Cannot read resource name length at offset {}: out of bounds", offset); + log::warn!( + "Cannot read resource name length at offset {}: out of bounds", + offset + ); return String::new(); } - + let length = u16::from_le_bytes([rsrc[offset], rsrc[offset + 1]]) as usize; let string_start = offset + 2; - + let required_bytes = string_start + (length * 2); if required_bytes > rsrc.len() { - log::warn!("Cannot read resource name: need {} bytes but only {} available in rsrc section", - required_bytes, rsrc.len()); + log::warn!( + "Cannot read resource name: need {} bytes but only {} available in rsrc section", + required_bytes, + rsrc.len() + ); return String::new(); } - + let utf16_data: Vec = (0..length) .map(|i| { let idx = string_start + i * 2; @@ -924,10 +961,10 @@ impl PE64 { if rsrc.is_none() { return String::new(); } - + let rsrc = rsrc.unwrap(); let name_offset = (entry.get_name_or_id() & 0x7FFFFFFF) as usize; // Remove high bit - + self.read_resource_name_from_rsrc(rsrc, name_offset) } } diff --git a/crates/libmwemu/src/peb/peb32.rs b/crates/libmwemu/src/peb/peb32.rs index 85d37d85..ccd5b044 100644 --- a/crates/libmwemu/src/peb/peb32.rs +++ b/crates/libmwemu/src/peb/peb32.rs @@ -1,12 +1,13 @@ use crate::console::Console; use crate::constants; use crate::emu; +use crate::maps::mem64::Permission; use crate::structures::LdrDataTableEntry; use crate::structures::OrdinalTable; use crate::structures::PebLdrData; +use crate::structures::RtlUserProcessParameters32; use crate::structures::PEB; use crate::structures::TEB; -use crate::structures::RtlUserProcessParameters32; pub fn init_ldr(emu: &mut emu::Emu) -> u64 { let ldr_sz = PebLdrData::size() + 100; @@ -16,7 +17,7 @@ pub fn init_ldr(emu: &mut emu::Emu) -> u64 { .expect("cannot alloc the LDR"); log::debug!("LDR ALLOCATED AT: 0x{:x}", ldr_addr); emu.maps - .create_map("ldr", ldr_addr, ldr_sz as u64) + .create_map("ldr", ldr_addr, ldr_sz as u64, Permission::READ_WRITE) .expect("cannot create ldr map"); let module_entry = create_ldr_entry(emu, 0, 0, constants::EXE_NAME, 0, 0) as u32; let mut ldr = PebLdrData::new(); @@ -34,14 +35,22 @@ pub fn init_ldr(emu: &mut emu::Emu) -> u64 { } pub fn init_arguments(emu: &mut emu::Emu) -> u64 { - let addr = emu.maps.map("RtlUserProcessParameters32", RtlUserProcessParameters32::size() as u64); + let addr = emu.maps.map( + "RtlUserProcessParameters32", + RtlUserProcessParameters32::size() as u64, + Permission::READ_WRITE_EXECUTE, + ); let mut params_struct = RtlUserProcessParameters32::new(); let filename_len = emu.cfg.filename.len() as u64 * 2 + 2; let cmdline_len = filename_len + emu.cfg.arguments.len() as u64 * 2 + 2; - let filename = emu.maps.map("file_name", filename_len); - let cmdline = emu.maps.map("command_line", cmdline_len); + let filename = emu + .maps + .map("file_name", filename_len, Permission::READ_WRITE); + let cmdline = emu + .maps + .map("command_line", cmdline_len, Permission::READ_WRITE); params_struct.image_path_name.length = filename_len as u16; params_struct.image_path_name.maximum_length = filename_len as u16; @@ -72,7 +81,7 @@ pub fn init_peb(emu: &mut emu::Emu) { .expect("cannot alloc the PEB32"); let peb_map = emu .maps - .create_map("peb", peb_addr, PEB::size() as u64) + .create_map("peb", peb_addr, PEB::size() as u64, Permission::READ_WRITE) .expect("cannot create peb map"); let peb = PEB::new(0, ldr as u32, args_addr as u32); peb.save(peb_map); @@ -83,7 +92,7 @@ pub fn init_peb(emu: &mut emu::Emu) { .expect("cannot alloc the TEB32"); let teb_map = emu .maps - .create_map("teb", teb_addr, TEB::size() as u64) + .create_map("teb", teb_addr, TEB::size() as u64, Permission::READ_WRITE) .expect("cannot create teb map"); let teb = TEB::new(peb_addr as u32); teb.save(teb_map); @@ -117,7 +126,7 @@ impl Flink { let peb = emu.maps.get_mem("peb"); let peb_base = peb.get_base(); let ldr_addr = peb.read_dword(peb_base + 0x0c) as u64; // peb->ldr - + let ldr = PebLdrData::load(ldr_addr, &emu.maps); let flink = emu @@ -184,7 +193,6 @@ impl Flink { .read_dword(self.flink_addr + 0x28) //0x38) //0x28 .expect("error reading mod_name_ptr") as u64;*/ - self.mod_name = emu.maps.read_wide_string(mod_name_ptr); } @@ -207,7 +215,6 @@ impl Flink { return false; } - if self.mod_base == 0 { return false; } @@ -478,7 +485,10 @@ pub fn create_ldr_entry( image_sz = emu.maps.read_dword(base as u64 + pe_hdr + 0x50).unwrap() as u64; base_addr = base; } else { - let addr = emu.maps.alloc(sz).expect("out of memory, cannot create the .ldr entry"); + let addr = emu + .maps + .alloc(sz) + .expect("out of memory, cannot create the .ldr entry"); if addr > u32::MAX as u64 { panic!("allocating .ldr > u32::MAX"); } @@ -486,7 +496,7 @@ pub fn create_ldr_entry( } let mem = emu .maps - .create_map(lib.as_str(), space_addr, sz) + .create_map(lib.as_str(), space_addr, sz, Permission::READ_WRITE) .expect("create_ldr_entry cannot create map"); mem.write_byte(space_addr + sz - 1, 0x61); diff --git a/crates/libmwemu/src/peb/peb64.rs b/crates/libmwemu/src/peb/peb64.rs index 3235938e..0d6c8c8e 100644 --- a/crates/libmwemu/src/peb/peb64.rs +++ b/crates/libmwemu/src/peb/peb64.rs @@ -1,11 +1,12 @@ use crate::constants; use crate::emu; +use crate::maps::mem64::Permission; use crate::structures::LdrDataTableEntry64; use crate::structures::OrdinalTable; use crate::structures::PebLdrData64; +use crate::structures::RtlUserProcessParameters64; use crate::structures::PEB64; use crate::structures::TEB64; -use crate::structures::RtlUserProcessParameters64; pub fn init_ldr(emu: &mut emu::Emu) -> u64 { let ldr_sz = PebLdrData64::size() + 100; @@ -14,7 +15,7 @@ pub fn init_ldr(emu: &mut emu::Emu) -> u64 { .lib64_alloc(ldr_sz as u64) .expect("cannot alloc the LDR"); emu.maps - .create_map("ldr", ldr_addr, ldr_sz as u64) + .create_map("ldr", ldr_addr, ldr_sz as u64, Permission::READ_WRITE) .expect("cannot create ldr map"); let module_entry = create_ldr_entry(emu, 0, 0, constants::EXE_NAME, 0, 0); let mut ldr = PebLdrData64::new(); @@ -33,14 +34,22 @@ pub fn init_ldr(emu: &mut emu::Emu) -> u64 { } pub fn init_arguments(emu: &mut emu::Emu) -> u64 { - let addr = emu.maps.map("RtlUserProcessParameters64", RtlUserProcessParameters64::size() as u64); + let addr = emu.maps.map( + "RtlUserProcessParameters64", + RtlUserProcessParameters64::size() as u64, + Permission::READ_WRITE_EXECUTE, + ); let mut params_struct = RtlUserProcessParameters64::new(); let filename_len = emu.cfg.filename.len() as u64 * 2 + 2; let cmdline_len = filename_len + emu.cfg.arguments.len() as u64 * 2 + 2; - let filename = emu.maps.map("file_name", filename_len); - let cmdline = emu.maps.map("command_line", cmdline_len); + let filename = emu + .maps + .map("file_name", filename_len, Permission::READ_WRITE); + let cmdline = emu + .maps + .map("command_line", cmdline_len, Permission::READ_WRITE); params_struct.image_path_name.length = filename_len as u16; params_struct.image_path_name.maximum_length = filename_len as u16; @@ -71,23 +80,31 @@ pub fn init_peb(emu: &mut emu::Emu) { .expect("cannot alloc the PEB64"); let peb_map = emu .maps - .create_map("peb", peb_addr, PEB64::size() as u64) + .create_map( + "peb", + peb_addr, + PEB64::size() as u64, + Permission::READ_WRITE, + ) .expect("cannot create peb map"); // Create KuserSharedData map - - let peb = PEB64::new(0, ldr, params_addr); peb.save(peb_map); emu.maps.write_byte(peb_addr + 2, 0); // not being_debugged - + let teb_addr = emu .maps .lib64_alloc(TEB64::size() as u64) .expect("cannot alloc the TEB64"); let teb_map = emu .maps - .create_map("teb", teb_addr, TEB64::size() as u64) + .create_map( + "teb", + teb_addr, + TEB64::size() as u64, + Permission::READ_WRITE, + ) .expect("cannot create teb map"); let teb = TEB64::new(peb_addr); teb.save(teb_map); @@ -470,7 +487,7 @@ pub fn create_ldr_entry( } let mem = emu .maps - .create_map(lib.as_str(), space_addr, sz) + .create_map(lib.as_str(), space_addr, sz, Permission::READ_WRITE) .expect("cannot create ldr entry map"); mem.write_byte(space_addr + sz - 1, 0x61); diff --git a/crates/libmwemu/src/script.rs b/crates/libmwemu/src/script.rs index 7a637ba7..6c50846a 100644 --- a/crates/libmwemu/src/script.rs +++ b/crates/libmwemu/src/script.rs @@ -5,6 +5,7 @@ use std::vec::Vec; use crate::console::Console; use crate::emu::Emu; +use crate::maps::mem64::Permission; use crate::peb::peb32; use crate::peb::peb64; use crate::structures; @@ -419,7 +420,8 @@ impl Script { return; } }; - emu.maps.create_map(args[1], addr, sz); + emu.maps + .create_map(args[1], addr, sz, Permission::READ_WRITE_EXECUTE); log::info!("allocated {} at 0x{:x} sz: {}", &args[1], addr, sz); self.result = addr; } @@ -437,7 +439,8 @@ impl Script { return; } }; - emu.maps.create_map(args[1], addr, sz); + emu.maps + .create_map(args[1], addr, sz, Permission::READ_WRITE_EXECUTE); log::info!("allocated {} at 0x{:x} sz: {}", &args[1], addr, sz); } "ml" => { @@ -465,7 +468,10 @@ impl Script { } }; - let mem = emu.maps.get_mem_by_addr(addr).expect("address not found on any map"); + let mem = emu + .maps + .get_mem_by_addr(addr) + .expect("address not found on any map"); if emu.cfg.is_64bits { log::info!( "map: {} 0x{:x}-0x{:x} ({})", diff --git a/crates/libmwemu/src/serialization/emu.rs b/crates/libmwemu/src/serialization/emu.rs index 2417d4d1..e02b1731 100644 --- a/crates/libmwemu/src/serialization/emu.rs +++ b/crates/libmwemu/src/serialization/emu.rs @@ -9,7 +9,7 @@ use iced_x86::Instruction; use serde::{Deserialize, Serialize}; use crate::banzai::Banzai; -use crate::breakpoint::{Breakpoints}; +use crate::breakpoint::Breakpoints; use crate::colors::Colors; use crate::config::Config; use crate::eflags::Eflags; @@ -26,6 +26,8 @@ use crate::serialization::pe64::SerializablePE64; use crate::serialization::thread_context::SerializableThreadContext; use crate::structures::MemoryOperation; +use crate::emu::disassemble::InstructionCache; + #[derive(Serialize, Deserialize)] pub struct SerializableEmu { pub regs: Regs64, @@ -80,7 +82,7 @@ pub struct SerializableEmu { pub rep: Option, pub tick: usize, pub base: u64, - pub call_stack: Vec, + pub call_stack: Vec<(u64, u64)>, pub heap_addr: u64, pub threads: Vec, pub current_thread_id: usize, @@ -160,6 +162,7 @@ impl From for Emu { }; Emu { + instruction_cache: InstructionCache::new(), maps: serialized.maps.into(), hooks: Hooks::default(), // not possible exp: serialized.exp, diff --git a/crates/libmwemu/src/serialization/instant.rs b/crates/libmwemu/src/serialization/instant.rs index 2c6c86b0..b3b6a43e 100644 --- a/crates/libmwemu/src/serialization/instant.rs +++ b/crates/libmwemu/src/serialization/instant.rs @@ -34,4 +34,4 @@ impl SerializableInstant { .unwrap() .saturating_sub(std::time::Duration::from_secs(self.timestamp)) } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/serialization/maps.rs b/crates/libmwemu/src/serialization/maps.rs index 53ed9c59..84d9ccca 100644 --- a/crates/libmwemu/src/serialization/maps.rs +++ b/crates/libmwemu/src/serialization/maps.rs @@ -4,22 +4,18 @@ use crate::maps::Maps; #[derive(Serialize, Deserialize)] pub struct SerializableMaps { - maps: Maps + maps: Maps, } impl From for SerializableMaps { fn from(maps: Maps) -> Self { - SerializableMaps { - maps - } + SerializableMaps { maps } } } impl From<&Maps> for SerializableMaps { fn from(maps: &Maps) -> Self { - SerializableMaps { - maps: maps.clone() - } + SerializableMaps { maps: maps.clone() } } } @@ -31,7 +27,9 @@ impl From for Maps { impl Default for SerializableMaps { fn default() -> Self { - Self { maps: Default::default() } + Self { + maps: Default::default(), + } } } diff --git a/crates/libmwemu/src/serialization/minidump_converter.rs b/crates/libmwemu/src/serialization/minidump_converter.rs index 1c3319d3..7f35ad3c 100644 --- a/crates/libmwemu/src/serialization/minidump_converter.rs +++ b/crates/libmwemu/src/serialization/minidump_converter.rs @@ -6,12 +6,12 @@ use std::collections::BTreeMap; use std::error::Error; use std::ops::Deref; -use crate::maps::mem64::Mem64; +use crate::maps::mem64::{Mem64, Permission}; use crate::maps::tlb::TLB; use crate::maps::Maps; +use crate::regs64::Regs64; use crate::serialization::emu::SerializableEmu; use crate::serialization::maps::SerializableMaps; -use crate::regs64::Regs64; use crate::serialization::pe32::SerializablePE32; use crate::serialization::pe64::SerializablePE64; @@ -23,7 +23,11 @@ impl MinidumpConverter { return None; } let offset = u32::from_le_bytes([data[0x3C], data[0x3D], data[0x3E], data[0x3F]]) as usize; - if offset < data.len() { Some(offset) } else { None } + if offset < data.len() { + Some(offset) + } else { + None + } } fn is_pe64(data: &[u8], pe_offset: usize) -> bool { @@ -35,18 +39,20 @@ impl MinidumpConverter { machine == 0x8664 } - fn extract_pe_modules>(dump: &minidump::Minidump<'static, T>) -> Result<(Option, Option), Box> { + fn extract_pe_modules>( + dump: &minidump::Minidump<'static, T>, + ) -> Result<(Option, Option), Box> { let mut pe32 = None; let mut pe64 = None; if let Ok(modules) = dump.get_stream::() { let memory = dump.get_memory().unwrap_or_default(); - + for module in modules.iter() { // Try to read the module from memory if let Some(mem_region) = memory.memory_at_address(module.base_address()) { let raw_data = mem_region.bytes().to_vec(); - + // Basic PE detection - check for MZ header if raw_data.len() > 0x40 && &raw_data[0..2] == b"MZ" { // Read PE header to determine 32 vs 64 bit @@ -72,7 +78,7 @@ impl MinidumpConverter { } fn extract_memory_maps>( - dump: &minidump::Minidump<'static, T> + dump: &minidump::Minidump<'static, T>, ) -> Result> { let mut mem_slab = Slab::new(); let mut maps = BTreeMap::new(); @@ -81,22 +87,33 @@ impl MinidumpConverter { // Get memory regions from memory info list if let Ok(memory_info) = dump.get_stream::() { let memory = dump.get_memory().unwrap_or_default(); - + for info in memory_info.iter() { let base_addr = info.raw.base_address; let size = info.raw.region_size; - + let permission = match info.protection { + PAGE_NOACCESS => Permission::NONE, + PAGE_READWRITE => Permission::READ_WRITE, + PAGE_READONLY => Permission::READ, + PAGE_EXECUTE => Permission::EXECUTE, + PAGE_EXECUTE_READ => Permission::READ_EXECUTE, + PAGE_EXECUTE_READWRITE => Permission::READ_WRITE_EXECUTE, + _ => Permission::READ_WRITE_EXECUTE, + }; + // Try to get the actual memory data for this region - let mem_data = memory.memory_at_address(base_addr) + let mem_data = memory + .memory_at_address(base_addr) .unwrap() .bytes() .to_vec(); - + let mem_entry = Mem64::new( format!("mem_0x{:016x}", base_addr), // name - base_addr, // base_addr + base_addr, // base_addr base_addr + size, // bottom_addr (base + size) - mem_data // mem data + mem_data, // mem data + permission, ); let slab_key = mem_slab.insert(mem_entry); @@ -109,11 +126,11 @@ impl MinidumpConverter { for module in modules.iter() { let module_base = module.base_address(); let module_size = module.size(); - + // Find corresponding memory region that contains this module for (&addr, &slab_key) in &maps { - if addr <= module_base && - module_base < addr + mem_slab[slab_key].size() as u64 { + if addr <= module_base && module_base < addr + mem_slab[slab_key].size() as u64 + { name_map.insert(module.name.to_string(), slab_key); break; } @@ -128,25 +145,22 @@ impl MinidumpConverter { let tlb = RefCell::new(TLB::new()); Ok(SerializableMaps::new(Maps::new( - mem_slab, - maps, - name_map, - is_64bits, - banzai, - tlb + mem_slab, maps, name_map, is_64bits, banzai, tlb, ))) } pub fn from_minidump_file(path: &str) -> Result> { let dump = minidump::Minidump::read_path(path)?; - + // Get basic streams we need let system_info = dump.get_stream::()?; let exception = dump.get_stream::()?; let threads = dump.get_stream::()?; - + // Find crashed thread - let crashed_thread = threads.threads.first() + let crashed_thread = threads + .threads + .first() .ok_or("No threads found in minidump")?; // Extract PE modules @@ -157,7 +171,7 @@ impl MinidumpConverter { // Extract registers - just use defaults for now since context parsing is complex let regs = Regs64::default(); - + // Basic serializable emu with minimal data let mut serializable_emu = SerializableEmu::default(); serializable_emu.set_maps(maps); diff --git a/crates/libmwemu/src/serialization/mod.rs b/crates/libmwemu/src/serialization/mod.rs index 87ec3e1f..6a869f5e 100644 --- a/crates/libmwemu/src/serialization/mod.rs +++ b/crates/libmwemu/src/serialization/mod.rs @@ -7,10 +7,10 @@ use crate::serialization::minidump_converter::MinidumpConverter; mod emu; mod fpu; mod instant; -mod pe32; -mod pe64; mod maps; mod minidump_converter; +mod pe32; +mod pe64; mod thread_context; pub struct Serialization {} diff --git a/crates/libmwemu/src/serialization/pe32.rs b/crates/libmwemu/src/serialization/pe32.rs index e9f6f6f1..fd9406de 100644 --- a/crates/libmwemu/src/serialization/pe32.rs +++ b/crates/libmwemu/src/serialization/pe32.rs @@ -10,9 +10,9 @@ pub struct SerializablePE32 { impl From for SerializablePE32 { fn from(pe32: PE32) -> Self { - SerializablePE32 { - filename: pe32.filename, - raw: pe32.raw + SerializablePE32 { + filename: pe32.filename, + raw: pe32.raw, } } } diff --git a/crates/libmwemu/src/serialization/pe64.rs b/crates/libmwemu/src/serialization/pe64.rs index 138f99e5..03939605 100644 --- a/crates/libmwemu/src/serialization/pe64.rs +++ b/crates/libmwemu/src/serialization/pe64.rs @@ -10,7 +10,10 @@ pub struct SerializablePE64 { impl From for SerializablePE64 { fn from(pe64: PE64) -> Self { - SerializablePE64 { filename: pe64.filename, raw: pe64.raw } + SerializablePE64 { + filename: pe64.filename, + raw: pe64.raw, + } } } diff --git a/crates/libmwemu/src/serialization/thread_context.rs b/crates/libmwemu/src/serialization/thread_context.rs index c9c4d2c4..e4b32f1e 100644 --- a/crates/libmwemu/src/serialization/thread_context.rs +++ b/crates/libmwemu/src/serialization/thread_context.rs @@ -1,11 +1,11 @@ -use std::collections::BTreeMap; use serde::{Deserialize, Serialize}; +use std::collections::BTreeMap; -use crate::thread_context::ThreadContext; use crate::eflags::Eflags; use crate::flags::Flags; use crate::regs64::Regs64; use crate::serialization::fpu::SerializableFPU; +use crate::thread_context::ThreadContext; #[derive(Serialize, Deserialize)] pub struct SerializableThreadContext { @@ -29,7 +29,7 @@ pub struct SerializableThreadContext { pub tls64: Vec, pub fls: Vec, pub fs: BTreeMap, - pub call_stack: Vec, + pub call_stack: Vec<(u64, u64)>, // the first address is the source of the call location and the second address is the destination of the call } impl From<&ThreadContext> for SerializableThreadContext { diff --git a/crates/libmwemu/src/structures/act_ctx_section_keyed_data32.rs b/crates/libmwemu/src/structures/act_ctx_section_keyed_data32.rs index b36e1e53..8ab27dfd 100644 --- a/crates/libmwemu/src/structures/act_ctx_section_keyed_data32.rs +++ b/crates/libmwemu/src/structures/act_ctx_section_keyed_data32.rs @@ -48,4 +48,3 @@ impl ActCtxSectionKeyedData32 { maps.write_bytes(addr + 44, self.assembly_metadata.to_vec()); } } - diff --git a/crates/libmwemu/src/structures/cp_info.rs b/crates/libmwemu/src/structures/cp_info.rs index 8d287f1e..c11eb4d2 100644 --- a/crates/libmwemu/src/structures/cp_info.rs +++ b/crates/libmwemu/src/structures/cp_info.rs @@ -60,4 +60,4 @@ impl CpInfo { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/eh3_exception_registration.rs b/crates/libmwemu/src/structures/eh3_exception_registration.rs index 5f6a52bc..1f8fd856 100644 --- a/crates/libmwemu/src/structures/eh3_exception_registration.rs +++ b/crates/libmwemu/src/structures/eh3_exception_registration.rs @@ -23,4 +23,4 @@ impl Eh3ExceptionRegistration { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/hostent.rs b/crates/libmwemu/src/structures/hostent.rs index f71f1b94..f95d8ca7 100644 --- a/crates/libmwemu/src/structures/hostent.rs +++ b/crates/libmwemu/src/structures/hostent.rs @@ -37,4 +37,4 @@ impl Hostent { pub fn size() -> usize { 32 } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/image_resource_data_entry32.rs b/crates/libmwemu/src/structures/image_resource_data_entry32.rs index 4607dfd5..8e921835 100644 --- a/crates/libmwemu/src/structures/image_resource_data_entry32.rs +++ b/crates/libmwemu/src/structures/image_resource_data_entry32.rs @@ -14,4 +14,4 @@ impl ImageResourceDataEntry32 { reserved: 0, } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/image_resource_data_entry64.rs b/crates/libmwemu/src/structures/image_resource_data_entry64.rs index ad5e13a2..025d41bd 100644 --- a/crates/libmwemu/src/structures/image_resource_data_entry64.rs +++ b/crates/libmwemu/src/structures/image_resource_data_entry64.rs @@ -14,4 +14,4 @@ impl ImageResourceDataEntry64 { reserved: 0, } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/image_resource_directory.rs b/crates/libmwemu/src/structures/image_resource_directory.rs index 3b8673e6..82a82fe1 100644 --- a/crates/libmwemu/src/structures/image_resource_directory.rs +++ b/crates/libmwemu/src/structures/image_resource_directory.rs @@ -22,4 +22,4 @@ impl ImageResourceDirectory { pub fn size() -> usize { 16 } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/image_tls_callback.rs b/crates/libmwemu/src/structures/image_tls_callback.rs index fa3a4e3b..62f54357 100644 --- a/crates/libmwemu/src/structures/image_tls_callback.rs +++ b/crates/libmwemu/src/structures/image_tls_callback.rs @@ -1,8 +1,7 @@ - #[derive(Debug)] pub struct ImageTlsCallback { // every tls callback has this structure dll_handle: u32, reason: u32, reserved: u32, -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/ldr_data_table_entry.rs b/crates/libmwemu/src/structures/ldr_data_table_entry.rs index d31ef393..6a55c337 100644 --- a/crates/libmwemu/src/structures/ldr_data_table_entry.rs +++ b/crates/libmwemu/src/structures/ldr_data_table_entry.rs @@ -1,4 +1,7 @@ -use crate::{maps::Maps, structures::{list_entry::ListEntry, unicode_string::UnicodeString}}; +use crate::{ + maps::Maps, + structures::{list_entry::ListEntry, unicode_string::UnicodeString}, +}; #[derive(Debug)] pub struct LdrDataTableEntry { @@ -48,40 +51,39 @@ impl LdrDataTableEntry { pub fn load(addr: u64, maps: &Maps) -> LdrDataTableEntry { LdrDataTableEntry { - in_load_order_links: ListEntry::load(addr, maps), // +0x00 - in_memory_order_links: ListEntry::load(addr + 8, maps), // +0x08 + in_load_order_links: ListEntry::load(addr, maps), // +0x00 + in_memory_order_links: ListEntry::load(addr + 8, maps), // +0x08 in_initialization_order_links: ListEntry::load(addr + 16, maps), // +0x10 - dll_base: maps.read_dword(addr + 24).unwrap(), // +0x18 - entry_point: maps.read_dword(addr + 28).unwrap(), // +0x1C - size_of_image: maps.read_dword(addr + 32).unwrap(), // +0x20 - full_dll_name: UnicodeString::load(addr + 36, maps), // +0x24 - base_dll_name: UnicodeString::load(addr + 44, maps), // +0x2C - flags: maps.read_dword(addr + 52).unwrap(), // +0x34 - load_count: maps.read_word(addr + 56).unwrap(), // +0x38 - tls_index: maps.read_word(addr + 58).unwrap(), // +0x3A - hash_links: ListEntry::load(addr + 60, maps), // +0x3C - time_date_stamp: maps.read_dword(addr + 68).unwrap(), // +0x44 + dll_base: maps.read_dword(addr + 24).unwrap(), // +0x18 + entry_point: maps.read_dword(addr + 28).unwrap(), // +0x1C + size_of_image: maps.read_dword(addr + 32).unwrap(), // +0x20 + full_dll_name: UnicodeString::load(addr + 36, maps), // +0x24 + base_dll_name: UnicodeString::load(addr + 44, maps), // +0x2C + flags: maps.read_dword(addr + 52).unwrap(), // +0x34 + load_count: maps.read_word(addr + 56).unwrap(), // +0x38 + tls_index: maps.read_word(addr + 58).unwrap(), // +0x3A + hash_links: ListEntry::load(addr + 60, maps), // +0x3C + time_date_stamp: maps.read_dword(addr + 68).unwrap(), // +0x44 } } pub fn save(&self, addr: u64, maps: &mut Maps) { - self.in_load_order_links.save(addr, maps); // +0x00 - self.in_memory_order_links.save(addr + 8, maps); // +0x08 + self.in_load_order_links.save(addr, maps); // +0x00 + self.in_memory_order_links.save(addr + 8, maps); // +0x08 self.in_initialization_order_links.save(addr + 16, maps); // +0x10 - maps.write_dword(addr + 24, self.dll_base); // +0x18 - maps.write_dword(addr + 28, self.entry_point); // +0x1C - maps.write_dword(addr + 32, self.size_of_image); // +0x20 - self.full_dll_name.save(addr + 36, maps); // +0x24 - self.base_dll_name.save(addr + 44, maps); // +0x2C - maps.write_dword(addr + 52, self.flags); // +0x34 - maps.write_word(addr + 56, self.load_count); // +0x38 - maps.write_word(addr + 58, self.tls_index); // +0x3A - self.hash_links.save(addr + 60, maps); // +0x3C - maps.write_dword(addr + 68, self.time_date_stamp); // +0x44 + maps.write_dword(addr + 24, self.dll_base); // +0x18 + maps.write_dword(addr + 28, self.entry_point); // +0x1C + maps.write_dword(addr + 32, self.size_of_image); // +0x20 + self.full_dll_name.save(addr + 36, maps); // +0x24 + self.base_dll_name.save(addr + 44, maps); // +0x2C + maps.write_dword(addr + 52, self.flags); // +0x34 + maps.write_word(addr + 56, self.load_count); // +0x38 + maps.write_word(addr + 58, self.tls_index); // +0x3A + self.hash_links.save(addr + 60, maps); // +0x3C + maps.write_dword(addr + 68, self.time_date_stamp); // +0x44 } - pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/ldr_data_table_entry64.rs b/crates/libmwemu/src/structures/ldr_data_table_entry64.rs index 48c468af..4f541eba 100644 --- a/crates/libmwemu/src/structures/ldr_data_table_entry64.rs +++ b/crates/libmwemu/src/structures/ldr_data_table_entry64.rs @@ -1,4 +1,7 @@ -use crate::{maps::Maps, structures::{list_entry64::ListEntry64, unicode_string64::UnicodeString64}}; +use crate::{ + maps::Maps, + structures::{list_entry64::ListEntry64, unicode_string64::UnicodeString64}, +}; #[derive(Debug)] pub struct LdrDataTableEntry64 { @@ -83,4 +86,4 @@ impl LdrDataTableEntry64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/list_entry64.rs b/crates/libmwemu/src/structures/list_entry64.rs index a20cca15..923c7d46 100644 --- a/crates/libmwemu/src/structures/list_entry64.rs +++ b/crates/libmwemu/src/structures/list_entry64.rs @@ -32,4 +32,4 @@ impl ListEntry64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/mod.rs b/crates/libmwemu/src/structures/mod.rs index 742ceb0d..644d4ccc 100644 --- a/crates/libmwemu/src/structures/mod.rs +++ b/crates/libmwemu/src/structures/mod.rs @@ -8,8 +8,8 @@ mod hostent; mod image_export_directory; mod image_resource_data_entry32; mod image_resource_data_entry64; -mod image_resource_directory_entry; mod image_resource_directory; +mod image_resource_directory_entry; mod image_tls_callback; mod ldr_data_table_entry; mod ldr_data_table_entry64; @@ -24,10 +24,10 @@ mod os_version_info_a; mod os_version_info_ex_a; mod os_version_info_ex_w; mod p_scope_table_entry; -mod peb_ldr_data; -mod peb_ldr_data64; mod peb; mod peb64; +mod peb_ldr_data; +mod peb_ldr_data64; mod rtl_user_process_parameters32; mod rtl_user_process_parameters64; mod startup_info32; @@ -55,8 +55,8 @@ pub use hostent::*; pub use image_export_directory::*; pub use image_resource_data_entry32::*; pub use image_resource_data_entry64::*; -pub use image_resource_directory_entry::*; pub use image_resource_directory::*; +pub use image_resource_directory_entry::*; pub use image_tls_callback::*; pub use ldr_data_table_entry::*; pub use ldr_data_table_entry64::*; @@ -71,10 +71,10 @@ pub use os_version_info_a::*; pub use os_version_info_ex_a::*; pub use os_version_info_ex_w::*; pub use p_scope_table_entry::*; -pub use peb_ldr_data::*; -pub use peb_ldr_data64::*; pub use peb::*; pub use peb64::*; +pub use peb_ldr_data::*; +pub use peb_ldr_data64::*; pub use rtl_user_process_parameters32::*; pub use rtl_user_process_parameters64::*; pub use startup_info32::*; diff --git a/crates/libmwemu/src/structures/nt_tib32.rs b/crates/libmwemu/src/structures/nt_tib32.rs index 19caba45..dbfeb843 100644 --- a/crates/libmwemu/src/structures/nt_tib32.rs +++ b/crates/libmwemu/src/structures/nt_tib32.rs @@ -67,4 +67,4 @@ impl NtTib32 { mem.write_dword(addr + 20, self.arbitrary_user_pointer); mem.write_dword(addr + 24, self.self_pointer); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/ordinal_table.rs b/crates/libmwemu/src/structures/ordinal_table.rs index 72be1721..f042b960 100644 --- a/crates/libmwemu/src/structures/ordinal_table.rs +++ b/crates/libmwemu/src/structures/ordinal_table.rs @@ -1,5 +1,3 @@ - - #[derive(Debug)] pub struct OrdinalTable { pub func_name: String, @@ -31,4 +29,4 @@ impl OrdinalTable { func_va: 0, } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/os_version_info_ex_a.rs b/crates/libmwemu/src/structures/os_version_info_ex_a.rs index a33b8949..f9057eff 100644 --- a/crates/libmwemu/src/structures/os_version_info_ex_a.rs +++ b/crates/libmwemu/src/structures/os_version_info_ex_a.rs @@ -1,6 +1,5 @@ use crate::maps::Maps; - #[derive(Debug)] pub struct OsVersionInfoExA { version_info_size: u32, diff --git a/crates/libmwemu/src/structures/os_version_info_ex_w.rs b/crates/libmwemu/src/structures/os_version_info_ex_w.rs index 7c2de7a6..8f4abcce 100644 --- a/crates/libmwemu/src/structures/os_version_info_ex_w.rs +++ b/crates/libmwemu/src/structures/os_version_info_ex_w.rs @@ -7,12 +7,12 @@ pub struct OsVersionInfoExW { minor_version: u32, build_number: u32, platform_id: u32, - version: [u16; 128], // WCHAR array (UTF-16) - service_pack_major: u16, // WORD - service_pack_minor: u16, // WORD - suite_mask: u16, // WORD - product_type: u8, // BYTE - reserved: u8, // BYTE + version: [u16; 128], // WCHAR array (UTF-16) + service_pack_major: u16, // WORD + service_pack_minor: u16, // WORD + suite_mask: u16, // WORD + product_type: u8, // BYTE + reserved: u8, // BYTE } impl Default for OsVersionInfoExW { @@ -33,16 +33,17 @@ impl OsVersionInfoExW { service_pack_major: 0, service_pack_minor: 0, suite_mask: 0, - product_type: 1, // VER_NT_WORKSTATION + product_type: 1, // VER_NT_WORKSTATION reserved: 0, }; // Convert "Service Pack 0" to UTF-16 let service_pack_str = "Service Pack 0"; let utf16_chars: Vec = service_pack_str.encode_utf16().collect(); - + for (i, &char_code) in utf16_chars.iter().enumerate() { - if i < 127 { // Leave room for null terminator + if i < 127 { + // Leave room for null terminator ovi.version[i] = char_code; } } @@ -57,16 +58,16 @@ impl OsVersionInfoExW { maps.write_dword(addr + 8, self.minor_version); maps.write_dword(addr + 12, self.build_number); maps.write_dword(addr + 16, self.platform_id); - + // Write WCHAR array (each element is 2 bytes) for (i, &char_code) in self.version.iter().enumerate() { maps.write_word(addr + 20 + (i as u64 * 2), char_code); } - + maps.write_word(addr + 276, self.service_pack_major); maps.write_word(addr + 278, self.service_pack_minor); maps.write_word(addr + 280, self.suite_mask); maps.write_byte(addr + 282, self.product_type); maps.write_byte(addr + 283, self.reserved); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/p_scope_table_entry.rs b/crates/libmwemu/src/structures/p_scope_table_entry.rs index e7363c9c..46921e46 100644 --- a/crates/libmwemu/src/structures/p_scope_table_entry.rs +++ b/crates/libmwemu/src/structures/p_scope_table_entry.rs @@ -31,4 +31,4 @@ impl PScopeTableEntry { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/peb.rs b/crates/libmwemu/src/structures/peb.rs index f208ce72..c6153be6 100644 --- a/crates/libmwemu/src/structures/peb.rs +++ b/crates/libmwemu/src/structures/peb.rs @@ -117,4 +117,4 @@ impl PEB { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/peb64.rs b/crates/libmwemu/src/structures/peb64.rs index d4053d71..19a21738 100644 --- a/crates/libmwemu/src/structures/peb64.rs +++ b/crates/libmwemu/src/structures/peb64.rs @@ -316,4 +316,4 @@ impl PEB64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/peb_ldr_data.rs b/crates/libmwemu/src/structures/peb_ldr_data.rs index 5be8e9b4..c8bc771f 100644 --- a/crates/libmwemu/src/structures/peb_ldr_data.rs +++ b/crates/libmwemu/src/structures/peb_ldr_data.rs @@ -68,4 +68,4 @@ impl PebLdrData { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/peb_ldr_data64.rs b/crates/libmwemu/src/structures/peb_ldr_data64.rs index eae10eca..d736cc3b 100644 --- a/crates/libmwemu/src/structures/peb_ldr_data64.rs +++ b/crates/libmwemu/src/structures/peb_ldr_data64.rs @@ -60,4 +60,4 @@ impl PebLdrData64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/rtl_user_process_parameters32.rs b/crates/libmwemu/src/structures/rtl_user_process_parameters32.rs index fef0c4c9..faa2225b 100644 --- a/crates/libmwemu/src/structures/rtl_user_process_parameters32.rs +++ b/crates/libmwemu/src/structures/rtl_user_process_parameters32.rs @@ -3,8 +3,8 @@ use crate::structures::unicode_string::UnicodeString; #[derive(Debug)] pub struct RtlUserProcessParameters32 { - pub reserved1: [u8;16], - pub reserved2: [u32;10], + pub reserved1: [u8; 16], + pub reserved2: [u32; 10], pub image_path_name: UnicodeString, pub command_line: UnicodeString, } @@ -18,23 +18,23 @@ impl Default for RtlUserProcessParameters32 { impl RtlUserProcessParameters32 { pub fn new() -> Self { Self { - reserved1: [0;16], - reserved2: [0;10], + reserved1: [0; 16], + reserved2: [0; 10], image_path_name: UnicodeString::new(), command_line: UnicodeString::new(), } } - + pub fn size() -> usize { 72 } pub fn save(&mut self, addr: u64, maps: &mut Maps) { maps.write_bytes(addr, self.reserved1.to_vec()); - for (i, val) in self.reserved2.iter().enumerate() { - maps.write_dword(addr + 16 + (i*4) as u64, *val); + for (i, val) in self.reserved2.iter().enumerate() { + maps.write_dword(addr + 16 + (i * 4) as u64, *val); } self.image_path_name.save(addr + 16 + 40, maps); self.command_line.save(addr + 16 + 40 + 8, maps) } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/rtl_user_process_parameters64.rs b/crates/libmwemu/src/structures/rtl_user_process_parameters64.rs index 5197bdd2..801c7c12 100644 --- a/crates/libmwemu/src/structures/rtl_user_process_parameters64.rs +++ b/crates/libmwemu/src/structures/rtl_user_process_parameters64.rs @@ -2,8 +2,8 @@ use crate::{maps::Maps, structures::unicode_string64::UnicodeString64}; #[derive(Debug)] pub struct RtlUserProcessParameters64 { - pub reserved1: [u8;16], - pub reserved2: [u64;10], + pub reserved1: [u8; 16], + pub reserved2: [u64; 10], pub image_path_name: UnicodeString64, pub command_line: UnicodeString64, } @@ -17,8 +17,8 @@ impl Default for RtlUserProcessParameters64 { impl RtlUserProcessParameters64 { pub fn new() -> Self { Self { - reserved1: [0;16], - reserved2: [0;10], + reserved1: [0; 16], + reserved2: [0; 10], image_path_name: UnicodeString64::new(), command_line: UnicodeString64::new(), } @@ -30,10 +30,10 @@ impl RtlUserProcessParameters64 { pub fn save(&mut self, addr: u64, maps: &mut Maps) { maps.write_bytes(addr, self.reserved1.to_vec()); - for (i, val) in self.reserved2.iter().enumerate() { - maps.write_qword(addr + 16 + (i*8) as u64, *val); + for (i, val) in self.reserved2.iter().enumerate() { + maps.write_qword(addr + 16 + (i * 8) as u64, *val); } self.image_path_name.save(addr + 16 + 80, maps); self.command_line.save(addr + 16 + 80 + 16, maps) } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/startup_info64.rs b/crates/libmwemu/src/structures/startup_info64.rs index 316d89d1..cfb97cdc 100644 --- a/crates/libmwemu/src/structures/startup_info64.rs +++ b/crates/libmwemu/src/structures/startup_info64.rs @@ -72,4 +72,4 @@ impl StartupInfo64 { maps.write_dword(addr + 76, self.std_output); maps.write_dword(addr + 80, self.std_error); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/stat.rs b/crates/libmwemu/src/structures/stat.rs index 91e6e7c2..1abdd7d7 100644 --- a/crates/libmwemu/src/structures/stat.rs +++ b/crates/libmwemu/src/structures/stat.rs @@ -73,4 +73,4 @@ impl Stat { pub fn size() -> usize { 144 } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/system_info32.rs b/crates/libmwemu/src/structures/system_info32.rs index cda218eb..9d3834cb 100644 --- a/crates/libmwemu/src/structures/system_info32.rs +++ b/crates/libmwemu/src/structures/system_info32.rs @@ -57,4 +57,4 @@ impl SystemInfo32 { pub fn size(&self) -> usize { 42 } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/system_time.rs b/crates/libmwemu/src/structures/system_time.rs index 97d58d41..41a96ce1 100644 --- a/crates/libmwemu/src/structures/system_time.rs +++ b/crates/libmwemu/src/structures/system_time.rs @@ -41,4 +41,4 @@ impl SystemTime { maps.write_word(addr + 12, self.second); maps.write_word(addr + 14, self.millis); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/teb.rs b/crates/libmwemu/src/structures/teb.rs index 556c02be..09c2bb82 100644 --- a/crates/libmwemu/src/structures/teb.rs +++ b/crates/libmwemu/src/structures/teb.rs @@ -139,4 +139,4 @@ impl TEB { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/teb64.rs b/crates/libmwemu/src/structures/teb64.rs index daddc8ea..07c4e894 100644 --- a/crates/libmwemu/src/structures/teb64.rs +++ b/crates/libmwemu/src/structures/teb64.rs @@ -137,4 +137,4 @@ impl TEB64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/tls_directory32.rs b/crates/libmwemu/src/structures/tls_directory32.rs index 8fb203cc..f0754935 100644 --- a/crates/libmwemu/src/structures/tls_directory32.rs +++ b/crates/libmwemu/src/structures/tls_directory32.rs @@ -25,4 +25,4 @@ impl TlsDirectory32 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/tls_directory64.rs b/crates/libmwemu/src/structures/tls_directory64.rs index 1bc4c652..363ef5bb 100644 --- a/crates/libmwemu/src/structures/tls_directory64.rs +++ b/crates/libmwemu/src/structures/tls_directory64.rs @@ -25,4 +25,4 @@ impl TlsDirectory64 { pub fn print(&self) { log::info!("{:#x?}", self); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/unicode_string64.rs b/crates/libmwemu/src/structures/unicode_string64.rs index ff83a90c..308c70f3 100644 --- a/crates/libmwemu/src/structures/unicode_string64.rs +++ b/crates/libmwemu/src/structures/unicode_string64.rs @@ -43,4 +43,4 @@ impl UnicodeString64 { maps.write_dword(addr + 4, self.padding); maps.write_qword(addr + 8, self.buffer); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/vs_fixedfileinfo.rs b/crates/libmwemu/src/structures/vs_fixedfileinfo.rs index 4cc75809..84e99f96 100644 --- a/crates/libmwemu/src/structures/vs_fixedfileinfo.rs +++ b/crates/libmwemu/src/structures/vs_fixedfileinfo.rs @@ -4,10 +4,10 @@ use crate::emu; #[derive(Debug, Clone)] #[allow(non_camel_case_types)] pub struct VS_FIXEDFILEINFO { - pub dw_signature: u32, // 0xFEEF04BD - pub dw_struc_version: u32, // 0x00010000 - pub dw_file_version_ms: u32, // 0x00060000a (6.10) - pub dw_file_version_ls: u32, // 0x585d11bd (22621.4541) + pub dw_signature: u32, // 0xFEEF04BD + pub dw_struc_version: u32, // 0x00010000 + pub dw_file_version_ms: u32, // 0x00060000a (6.10) + pub dw_file_version_ls: u32, // 0x585d11bd (22621.4541) pub dw_product_version_ms: u32, pub dw_product_version_ls: u32, pub dw_file_flags_mask: u32, @@ -39,4 +39,4 @@ impl VS_FIXEDFILEINFO { emu.maps.write_dword(addr + 44, self.dw_file_date_ms); emu.maps.write_dword(addr + 48, self.dw_file_date_ls); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/structures/vs_versioninfo.rs b/crates/libmwemu/src/structures/vs_versioninfo.rs index 26ff6947..dcaddbc6 100644 --- a/crates/libmwemu/src/structures/vs_versioninfo.rs +++ b/crates/libmwemu/src/structures/vs_versioninfo.rs @@ -58,31 +58,31 @@ impl VS_VERSIONINFO { pub fn write(&self, emu: &mut emu::Emu, addr: u64) { let mut offset = addr; - + emu.maps.write_word(offset, self.w_length); offset += 2; - + emu.maps.write_word(offset, self.w_value_length); offset += 2; - + emu.maps.write_word(offset, self.w_type); offset += 2; - + // Write szKey for i in 0..16 { emu.maps.write_word(offset, self.sz_key[i]); offset += 2; } - + emu.maps.write_word(offset, self.padding1); offset += 2; - + self.value.write(emu, offset); offset += VS_FIXEDFILEINFO::size() as u64; - + emu.maps.write_word(offset, self.padding2); offset += 2; - + emu.maps.write_word(offset, self.children); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/syscall/syscall64.rs b/crates/libmwemu/src/syscall/syscall64.rs index 5ccb1a64..de3bbad6 100644 --- a/crates/libmwemu/src/syscall/syscall64.rs +++ b/crates/libmwemu/src/syscall/syscall64.rs @@ -5,11 +5,11 @@ use crate::structures; //use crate::endpoint; use crate::winapi::helper; // TODO: why not winapi64 helper? +use crate::maps::mem64::Permission; use std::fs; use std::fs::File; use std::io::{BufReader, Read, Seek, SeekFrom}; use std::path::Path; - /* * /usr/include/asm/unistd_64.h * @@ -38,7 +38,7 @@ pub fn gateway(emu: &mut emu::Emu) { emu.pos, emu.colors.nc ); - std::process::exit(emu.regs().rdi as i32); + std::process::exit(emu.regs().rdi as i32); } constants::NR64_FORK => { @@ -882,7 +882,12 @@ pub fn gateway(emu: &mut emu::Emu) { let map = emu .maps - .create_map(&format!("mmap_{:x}", addr), addr, sz) + .create_map( + &format!("mmap_{:x}", addr), + addr, + sz, + Permission::from_bits(prot as u8), + ) .expect("cannot create mmap map"); if helper::handler_exist(fd) { diff --git a/crates/libmwemu/src/tests/allocator32_test.rs b/crates/libmwemu/src/tests/allocator32_test.rs index 39d6ebb8..9829f874 100644 --- a/crates/libmwemu/src/tests/allocator32_test.rs +++ b/crates/libmwemu/src/tests/allocator32_test.rs @@ -1,6 +1,6 @@ -use crate::*; -use crate::winapi::winapi32; use crate::tests::helpers; +use crate::winapi::winapi32; +use crate::*; #[test] // test 32bits allocators diff --git a/crates/libmwemu/src/tests/allocator64_test.rs b/crates/libmwemu/src/tests/allocator64_test.rs index a05bdb8f..d144cf69 100644 --- a/crates/libmwemu/src/tests/allocator64_test.rs +++ b/crates/libmwemu/src/tests/allocator64_test.rs @@ -1,6 +1,6 @@ -use crate::*; -use crate::winapi::winapi64; use crate::tests::helpers; +use crate::winapi::winapi64; +use crate::*; #[test] // test 64bits allocators @@ -25,7 +25,6 @@ pub fn allocator64_test() { emu.maps.clear(); - emu.regs_mut().rcx = 0; // addr emu.regs_mut().rdx = 1024; // sz emu.regs_mut().r8 = constants::MEM_RESERVE as u64; @@ -48,4 +47,4 @@ pub fn allocator64_test() { assert_eq!(emu.maps.is_allocated(0x30000000), true); assert_eq!(emu.maps.mem_test(), true); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/basic_test_code_bytes_shld_shrd.rs b/crates/libmwemu/src/tests/basic_test_code_bytes_shld_shrd.rs index 333a556a..896f01e9 100644 --- a/crates/libmwemu/src/tests/basic_test_code_bytes_shld_shrd.rs +++ b/crates/libmwemu/src/tests/basic_test_code_bytes_shld_shrd.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // test shrd shld and load_code_bytes() instead of load_code() @@ -7,11 +7,11 @@ pub fn basic_test_code_bytes_shld_shrd() { helpers::setup(); let shellcode32: [u8; 19] = [ - 0xb8, 0x78, 0x56, 0x34, 0x12, // mov eax, 0x12345678 - 0xba, 0xf0, 0xde, 0xbc, 0x9a, // mov edx, 0x9abcdef0 - 0x0f, 0xa4, 0xc2, 0x04, // shld edx, eax, 4 - 0x0f, 0xac, 0xc2, 0x04, // shrd edx, eax, 4 - 0xc3 // ret + 0xb8, 0x78, 0x56, 0x34, 0x12, // mov eax, 0x12345678 + 0xba, 0xf0, 0xde, 0xbc, 0x9a, // mov edx, 0x9abcdef0 + 0x0f, 0xa4, 0xc2, 0x04, // shld edx, eax, 4 + 0x0f, 0xac, 0xc2, 0x04, // shrd edx, eax, 4 + 0xc3, // ret ]; let mut emu = emu32(); @@ -25,11 +25,13 @@ pub fn basic_test_code_bytes_shld_shrd() { assert_eq!(emu.regs().get_edx(), 0x8abcdef0); let shellcode64: [u8; 31] = [ - 0x48, 0xb8, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, 0x12, // mov rax, 0x123456789abcdef0 - 0x48, 0xba, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe, // mov rdx, 0xfedcba9876543210 - 0x48, 0x0f, 0xa4, 0xc2, 0x04, // shld rdx, rax, 4 - 0x48, 0x0f, 0xac, 0xc2, 0x04, // shrd rdx, rax, 4 - 0xc3 // ret + 0x48, 0xb8, 0xf0, 0xde, 0xbc, 0x9a, 0x78, 0x56, 0x34, + 0x12, // mov rax, 0x123456789abcdef0 + 0x48, 0xba, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, + 0xfe, // mov rdx, 0xfedcba9876543210 + 0x48, 0x0f, 0xa4, 0xc2, 0x04, // shld rdx, rax, 4 + 0x48, 0x0f, 0xac, 0xc2, 0x04, // shrd rdx, rax, 4 + 0xc3, // ret ]; let mut emu = emu64(); @@ -43,4 +45,4 @@ pub fn basic_test_code_bytes_shld_shrd() { emu.step(); // shrd rdx, rax, 4 assert_eq!(emu.regs().rdx, 0x0edcba9876543210); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/breakpoint_functionality.rs b/crates/libmwemu/src/tests/breakpoint_functionality.rs index 585a2f24..49e5dcfa 100644 --- a/crates/libmwemu/src/tests/breakpoint_functionality.rs +++ b/crates/libmwemu/src/tests/breakpoint_functionality.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // test breakpoint functionality, improve this with a running sample. @@ -7,40 +7,40 @@ pub fn breakpoint_functionality() { helpers::setup(); let mut bp = crate::breakpoint::Breakpoint::new(); - + // Test initial state assert_eq!(bp.get_bp(), 0); - + // Test basic breakpoint operations bp.set_bp(0x401000); assert_eq!(bp.get_bp(), 0x401000); - + // Test memory breakpoints bp.set_mem_read(0x402000); bp.set_mem_write(0x403000); - + // Test instruction breakpoints bp.set_instruction(100); - + // Test clearing breakpoints bp.clear_bp(); assert_eq!(bp.get_bp(), 0); - + // Test multiple breakpoint operations bp.set_bp(0x500000); bp.set_mem_read(0x600000); bp.set_mem_write(0x700000); bp.set_instruction(200); - + assert_eq!(bp.get_bp(), 0); // only one type of bt at once, the setters clear all the // breakpointts. - + bp.clear_bp(); assert_eq!(bp.get_bp(), 0); let mut emu = emu64(); emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - + emu.load_code("../../test/exe64win_msgbox.bin"); assert!(!emu.maps.is_allocated(0)); emu.bp.clear_bp(); @@ -50,30 +50,28 @@ pub fn breakpoint_functionality() { assert_eq!(emu.pos, 4); /* - emu.bp.set_mem_write(0x329f70); - emu.run(None); - assert_eq!(emu.pos, 15); + emu.bp.set_mem_write(0x329f70); + emu.run(None); + assert_eq!(emu.pos, 15); -14 0x1400010df: mov [rbp-10h],rdi -mem_trace: pos = 14 rip = 1400010df op = write bits = 64 address = 0x329f70 value = 0x1400011df name = 'stack' + 14 0x1400010df: mov [rbp-10h],rdi + mem_trace: pos = 14 rip = 1400010df op = write bits = 64 address = 0x329f70 value = 0x1400011df name = 'stack' - */ + */ - emu.bp.clear_bp(); + emu.bp.clear_bp(); emu.bp.add_bp_instruction(100); assert_eq!(emu.bp.instruction, [100]); emu.run(None); assert_eq!(emu.pos, 100); /* is not matching - emu.bp.set_mem_read(0x329eb8); - emu.run(None); - assert_eq!(emu.pos, 102); - -mem_trace: pos = 102 rip = 1400010c4 op = read bits = 64 address = 0x329eb8 value = 0xc name = 'stack' -mem_trace: pos = 102 rip = 1400010c4 op = write bits = 64 address = 0x329eb8 value = 0xc name = 'register' -102 0x1400010c4: pop rcx ;0xc - */ - + emu.bp.set_mem_read(0x329eb8); + emu.run(None); + assert_eq!(emu.pos, 102); -} \ No newline at end of file + mem_trace: pos = 102 rip = 1400010c4 op = read bits = 64 address = 0x329eb8 value = 0xc name = 'stack' + mem_trace: pos = 102 rip = 1400010c4 op = write bits = 64 address = 0x329eb8 value = 0xc name = 'register' + 102 0x1400010c4: pop rcx ;0xc + */ +} diff --git a/crates/libmwemu/src/tests/config_management.rs b/crates/libmwemu/src/tests/config_management.rs index 532d60bd..d6dec495 100644 --- a/crates/libmwemu/src/tests/config_management.rs +++ b/crates/libmwemu/src/tests/config_management.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // test configuration management @@ -7,29 +7,29 @@ pub fn config_management() { helpers::setup(); let mut cfg = crate::config::Config::new(); - + // Test default values assert!(!cfg.is_64bits); // should default to 32-bit - + // Test 32/64-bit mode switching cfg.is_64bits = true; assert!(cfg.is_64bits); - + cfg.is_64bits = false; assert!(!cfg.is_64bits); - + // Test maps folder configuration cfg.maps_folder = "/test/path".to_string(); assert_eq!(cfg.maps_folder, "/test/path"); - + // Test other configuration options cfg.verbose = 3; assert_eq!(cfg.verbose, 3); - + // Test emulator with different configs let emu32 = emu32(); assert!(!emu32.cfg.is_64bits); - + let emu64 = emu64(); assert!(emu64.cfg.is_64bits); } diff --git a/crates/libmwemu/src/tests/elf64lin_cpu_arithmetics.rs b/crates/libmwemu/src/tests/elf64lin_cpu_arithmetics.rs index 370228df..87cfb720 100644 --- a/crates/libmwemu/src/tests/elf64lin_cpu_arithmetics.rs +++ b/crates/libmwemu/src/tests/elf64lin_cpu_arithmetics.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // arithmetic calculations on an 64bits elf @@ -15,7 +15,7 @@ pub fn elf64lin_cpu_arithmetics1() { assert_eq!(emu.regs().rax, 3); assert_eq!(emu.flags().dump(), 0x206); - emu.run_to(6); // dec ax + emu.run_to(6); // dec ax assert_eq!(emu.regs().rax, 2); assert_eq!(emu.flags().dump(), 0x202); @@ -23,7 +23,7 @@ pub fn elf64lin_cpu_arithmetics1() { assert_eq!(emu.regs().rax, 0); assert_eq!(emu.flags().dump(), 0x246); - emu.run_to(11); // neg ax + emu.run_to(11); // neg ax assert_eq!(emu.regs().rax, 0x1122334455668888); assert_eq!(emu.flags().dump(), 0x297); // [ CF PF AF SF IF ] @@ -38,13 +38,13 @@ pub fn elf64lin_cpu_arithmetics1() { emu.run_to(29); // shl rax, cl assert_eq!(emu.regs().rax, 0x55658980); assert_eq!(emu.flags().dump(), 0x212); - + emu.run_to(30); // shr al, 1 - assert_eq!(emu.regs().rax, 0x55658940); + assert_eq!(emu.regs().rax, 0x55658940); assert_eq!(emu.flags().dump(), 0xa12); - + emu.run_to(31); // shr ax, 1 - assert_eq!(emu.regs().rax, 0x556544a0); + assert_eq!(emu.regs().rax, 0x556544a0); assert_eq!(emu.flags().dump(), 0xa16); emu.run_to(40); // imul eax @@ -54,7 +54,7 @@ pub fn elf64lin_cpu_arithmetics1() { emu.run_to(41); // imul rax assert_eq!(emu.regs().rax, 0x441000000000000); assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] - + emu.run_to(43); // imul eax, eax assert_eq!(emu.regs().rax, 0); assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] @@ -65,10 +65,10 @@ pub fn elf64lin_cpu_arithmetics1() { emu.run_to(48); // imul rax,2 assert_eq!(emu.regs().rax, 0x120bdc200); - assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] + assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] emu.run_to(49); // rcl al, 1 - assert_eq!(emu.regs().rax, 0x120bdc200); + assert_eq!(emu.regs().rax, 0x120bdc200); assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] emu.run_to(50); // rcl ax, 1 @@ -79,7 +79,6 @@ pub fn elf64lin_cpu_arithmetics1() { assert_eq!(emu.regs().rax, 0x82f61002); // ERROR assert_eq!(emu.flags().dump(), 0x216); // [ PF AF IF ] - emu.run_to(58); // rcr ax,1 assert_eq!(emu.regs().rax, 0x82f60800); assert_eq!(emu.flags().dump(), 0x217); // [ CF PF AF IF ] @@ -158,6 +157,3 @@ pub fn elf64lin_cpu_arithmetics4() { assert_eq!(emu.regs().r15, 0xcccccccccccccccc); assert_eq!(emu.regs().rip, 0x401188); } - - - diff --git a/crates/libmwemu/src/tests/elf64lin_flags.rs b/crates/libmwemu/src/tests/elf64lin_flags.rs index d2f64784..ad9ffffa 100644 --- a/crates/libmwemu/src/tests/elf64lin_flags.rs +++ b/crates/libmwemu/src/tests/elf64lin_flags.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // this tests a linux 64bits flags @@ -8,7 +8,6 @@ pub fn elf64lin_flags() { let mut emu = emu64(); emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - let sample = "../../test/elf64lin_flags.bin"; emu.load_code(sample); @@ -37,7 +36,6 @@ pub fn elf64lin_flags() { assert_eq!(emu.flags().f_sf, true); assert_eq!(emu.flags().f_pf, false); - // test instruction test emu.run(Some(0x401056)); assert_eq!(emu.flags().f_cf, false); @@ -54,7 +52,6 @@ pub fn elf64lin_flags() { assert_eq!(emu.flags().f_sf, false); assert_eq!(emu.flags().f_pf, true); - // test or with 0x0 emu.run(Some(0x401087)); assert_eq!(emu.flags().f_cf, false); diff --git a/crates/libmwemu/src/tests/elf64lin_fpu.rs b/crates/libmwemu/src/tests/elf64lin_fpu.rs index 93245db5..8010ba54 100644 --- a/crates/libmwemu/src/tests/elf64lin_fpu.rs +++ b/crates/libmwemu/src/tests/elf64lin_fpu.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // this tests the fpu unit. @@ -9,7 +9,6 @@ pub fn elf64lin_fpu() { let mut emu = emu64(); emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - let sample = "../../test/elf64lin_fpu.bin"; emu.load_code(sample); @@ -40,10 +39,10 @@ pub fn elf64lin_fpu() { assert_eq!(emu.fpu_mut().peek_st_f64(6), 2.141592653589793); emu.step(); // 8 fsqrt assert_eq!(emu.fpu_mut().peek_st_u80(6), 0x3fffbb51491ea66b7000); // should end in 6ea4, - // its comupted as f64 + // its comupted as f64 assert_eq!(emu.fpu_mut().peek_st_f64(6), 1.4634181403788165); - emu.step(); // 9 fxch st(1) + emu.step(); // 9 fxch st(1) assert_eq!(emu.fpu_mut().peek_st_u80(7), 0x3fffbb51491ea66b7000); // should end in 6ea4 assert_eq!(emu.fpu_mut().peek_st_u80(6), 0x3fff8000000000000000); assert_eq!(emu.fpu_mut().peek_st_f64(7), 1.4634181403788165); @@ -68,7 +67,7 @@ pub fn elf64lin_fpu() { assert_eq!(emu.fpu_mut().peek_st_u80(6), 0x3fffc75922e5f71d3000); // should end in 2dc6 assert_eq!(emu.fpu_mut().peek_st_u80(5), 0x3fff8000000000000000); assert_eq!(emu.fpu_mut().peek_st_f64(7), 0.9396499819615878); - assert_eq!(emu.fpu_mut().peek_st_f64(6), 1.5574077246549023); + assert_eq!(emu.fpu_mut().peek_st_f64(6), 1.5574077246549023); emu.step(); // 13 fsubp st(1),st assert_eq!(emu.fpu_mut().peek_st_u80(0), 0xffffc000000000000000); emu.step(); // 14 f2xm1 @@ -82,7 +81,7 @@ pub fn elf64lin_fpu() { assert_eq!(emu.fpu_mut().st.get_top(), 6); assert_eq!(emu.fpu_mut().st.get_depth(), 2); assert_eq!(emu.fpu_mut().peek_st_u80(6), 0x3ffd9a209a84fbcff800); // 799); - assert_eq!(emu.fpu_mut().peek_st_f64(6), 0.3010299956639812); + assert_eq!(emu.fpu_mut().peek_st_f64(6), 0.3010299956639812); emu.step(); // 17 fyl2x assert_eq!(emu.fpu_mut().peek_st_u80(7), 0xbfffddb2dbec0456f800); //46); assert_eq!(emu.fpu_mut().peek_st_f64(7), -1.7320208456446193); diff --git a/crates/libmwemu/src/tests/elf64lin_static_helloworld.rs b/crates/libmwemu/src/tests/elf64lin_static_helloworld.rs index c77fc1db..c54396a8 100644 --- a/crates/libmwemu/src/tests/elf64lin_static_helloworld.rs +++ b/crates/libmwemu/src/tests/elf64lin_static_helloworld.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // this tests a linux 64bits static ELF binary. @@ -13,5 +13,5 @@ pub fn elf64lin_static_helloworld() { emu.run(Some(0x44ab87)); assert_eq!(emu.regs().rcx, 0x4cc2d0); - assert_eq!(emu.pos, 11111); + assert_eq!(emu.pos, 11111); } diff --git a/crates/libmwemu/src/tests/elf64lin_syscall64.rs b/crates/libmwemu/src/tests/elf64lin_syscall64.rs index e6036b33..2c56b941 100644 --- a/crates/libmwemu/src/tests/elf64lin_syscall64.rs +++ b/crates/libmwemu/src/tests/elf64lin_syscall64.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // tests syscalls64 diff --git a/crates/libmwemu/src/tests/emulator_initialization.rs b/crates/libmwemu/src/tests/emulator_initialization.rs index b2fab92c..e53f8703 100644 --- a/crates/libmwemu/src/tests/emulator_initialization.rs +++ b/crates/libmwemu/src/tests/emulator_initialization.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // test emulator initialization and basic operations @@ -12,25 +12,25 @@ pub fn emulator_initialization() { assert_eq!(emu64.pos, 0); assert!(!emu64.force_break); assert!(!emu64.force_reload); - + // Don't call init to avoid DLL loading issues - + // Test 32-bit emulator let mut emu32 = emu32(); assert!(!emu32.cfg.is_64bits); assert_eq!(emu32.pos, 0); - + // Don't call init to avoid DLL loading issues - + // Test emulator state after initialization assert_eq!(emu64.regs().rip, 0); assert_eq!(emu32.regs().rip, 0); - + // Test register clearing emu64.regs_mut().rax = 0x123456789ABCDEF0; emu64.regs_mut().clear::<64>(); assert_eq!(emu64.regs().rax, 0); - + emu32.regs_mut().rax = 0x123456789ABCDEF0; emu32.regs_mut().sanitize32(); assert_eq!(emu32.regs().rax & 0xFFFFFFFF00000000, 0); diff --git a/crates/libmwemu/src/tests/error_conditions.rs b/crates/libmwemu/src/tests/error_conditions.rs index 9ab8bbd9..9018c22d 100644 --- a/crates/libmwemu/src/tests/error_conditions.rs +++ b/crates/libmwemu/src/tests/error_conditions.rs @@ -1,5 +1,6 @@ -use crate::*; +use crate::maps::mem64::Permission; use crate::tests::helpers; +use crate::*; #[test] // test error conditions and edge cases @@ -8,27 +9,29 @@ pub fn error_conditions() { let mut emu = emu64(); // Don't call init to avoid DLL loading issues - + // Test invalid memory access with banzai mode emu.maps.set_banzai(true); assert!(emu.maps.read_dword(0x999999).is_none()); assert!(!emu.maps.write_dword(0x999999, 0x12345678)); - + // Test reading from unallocated memory assert!(emu.maps.read_qword(0x123456789).is_none()); assert!(!emu.maps.write_qword(0x123456789, 0xDEADBEEF)); - + // Test zero-sized memory operations let base = 0x20000; - emu.maps.create_map("zero_test", base, 0x1000).unwrap(); - + emu.maps + .create_map("zero_test", base, 0x1000, Permission::READ_WRITE_EXECUTE) + .unwrap(); + // Test reading/writing at exact boundaries assert!(emu.maps.write_dword(base + 0x1000 - 4, 0x12345678)); assert!(emu.maps.read_dword(base + 0x1000 - 4).is_some()); - + // Test one byte past boundary should fail with banzai mode assert!(!emu.maps.write_dword(base + 0x1000 - 3, 0x12345678)); - + // Test string operations with boundaries let long_string = "A".repeat(100); emu.maps.write_string(base, &long_string); diff --git a/crates/libmwemu/src/tests/exception_handler32.rs b/crates/libmwemu/src/tests/exception_handler32.rs index 001135df..400a8174 100644 --- a/crates/libmwemu/src/tests/exception_handler32.rs +++ b/crates/libmwemu/src/tests/exception_handler32.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // context objects for exception recovering diff --git a/crates/libmwemu/src/tests/exe32win_minecraft.rs b/crates/libmwemu/src/tests/exe32win_minecraft.rs index 3afdc28e..69d2a3cd 100644 --- a/crates/libmwemu/src/tests/exe32win_minecraft.rs +++ b/crates/libmwemu/src/tests/exe32win_minecraft.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // this tests a windows 32bits executable, that require iat binding of multiple libs. @@ -14,4 +14,4 @@ pub fn exe32win_minecraft() { emu.run(Some(0x403740)); assert_eq!(emu.regs().get_ebx(), 2); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/exe64win_enigma.rs b/crates/libmwemu/src/tests/exe64win_enigma.rs index ce728ced..6281cd23 100644 --- a/crates/libmwemu/src/tests/exe64win_enigma.rs +++ b/crates/libmwemu/src/tests/exe64win_enigma.rs @@ -1,5 +1,5 @@ -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // enigma packer should be emulated at least 102,302,404 insturctions. diff --git a/crates/libmwemu/src/tests/exe64win_msgbox.rs b/crates/libmwemu/src/tests/exe64win_msgbox.rs index 1468a61e..27141a1f 100644 --- a/crates/libmwemu/src/tests/exe64win_msgbox.rs +++ b/crates/libmwemu/src/tests/exe64win_msgbox.rs @@ -1,5 +1,6 @@ -use crate::*; +use crate::maps::mem64::Permission; use crate::tests::helpers; +use crate::*; #[test] // this test a windows 64bits executable that calculates apis like shellcodes and does basic api calls. @@ -20,8 +21,14 @@ pub fn exe64win_msgbox() { assert_eq!(message, "message"); assert_eq!(title, "title"); + // we need to set the permission to use it + let mem = emu + .maps + .get_mem_by_addr_mut(emu.regs().rdx) + .expect("the memory need to be there"); + mem.set_permission(Permission::READ_WRITE); emu.maps.write_string(emu.regs().rdx, "inject"); // launch the msgbox emu.step(); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/flag_calculations.rs b/crates/libmwemu/src/tests/flag_calculations.rs index 69752d85..0b5e32f3 100644 --- a/crates/libmwemu/src/tests/flag_calculations.rs +++ b/crates/libmwemu/src/tests/flag_calculations.rs @@ -6,13 +6,13 @@ pub fn flag_calculations() { helpers::setup(); // Test parity flag calculation - assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[0], true); // 0 has even parity (0 ones) - assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[1], false); // 1 has odd parity (1 one) - assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[3], true); // 3 (11b) has even parity (2 ones) - assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[7], false); // 7 (111b) has odd parity (3 ones) - assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[15], true); // 15 (1111b) has even parity (4 ones) + assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[0], true); // 0 has even parity (0 ones) + assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[1], false); // 1 has odd parity (1 one) + assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[3], true); // 3 (11b) has even parity (2 ones) + assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[7], false); // 7 (111b) has odd parity (3 ones) + assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[15], true); // 15 (1111b) has even parity (4 ones) assert_eq!(crate::flags::PARITY_LOOKUP_TABLE[255], true); // 255 (11111111b) has even parity (8 ones) - + // Test flag constants assert_eq!(crate::flags::MIN_U8, 0); assert_eq!(crate::flags::MAX_U8, 0xff); @@ -22,7 +22,7 @@ pub fn flag_calculations() { assert_eq!(crate::flags::MAX_U32, 0xffffffff); assert_eq!(crate::flags::MIN_U64, 0); assert_eq!(crate::flags::MAX_U64, 0xffffffffffffffff); - + // Test signed constants assert_eq!(crate::flags::MIN_I8, -128); assert_eq!(crate::flags::MAX_I8, 0x7f); diff --git a/crates/libmwemu/src/tests/fpu_conversions.rs b/crates/libmwemu/src/tests/fpu_conversions.rs index 13be695d..4e8acb39 100644 --- a/crates/libmwemu/src/tests/fpu_conversions.rs +++ b/crates/libmwemu/src/tests/fpu_conversions.rs @@ -15,15 +15,14 @@ pub fn fpu_conversions() { assert_eq!(fpu.peek_st_logical_f64(0), 1.0); assert_eq!(fpu.peek_st_logical_f64(1), 0.0); - // u80 to f64 conversion fpu.set_st_u80(1, 0x4000c90fdaa22168c235); fpu.st.print(); assert_eq!(fpu.peek_st_logical_f64(1), 3.14159265358979323); assert_eq!(fpu.peek_st_logical_u80(1), 0x4000c90fdaa22168c235); - + /* - assert_eq!(3.141592653589793239, + assert_eq!(3.141592653589793239, 3.141592653589793); // true cuts to 64bits // */ @@ -32,6 +31,4 @@ pub fn fpu_conversions() { //fpu.set_st(1, 4.141592653589793238); //assert_eq!(fpu.peek_st_u80(1), 0x4000c90fdaa22168c234); // - - } diff --git a/crates/libmwemu/src/tests/fpu_f80_emulation.rs b/crates/libmwemu/src/tests/fpu_f80_emulation.rs index ea17bdfe..634e8025 100644 --- a/crates/libmwemu/src/tests/fpu_f80_emulation.rs +++ b/crates/libmwemu/src/tests/fpu_f80_emulation.rs @@ -10,7 +10,6 @@ pub fn fpu_f80_emulation() { f80.set_f64(1.0); assert_eq!(f80.get(), 0x3fff8000000000000000); - // Test zero f80.set_f64(0.0); assert!(f80.is_zero()); @@ -35,7 +34,14 @@ pub fn fpu_f80_emulation() { assert!(f80.get_f64().is_nan()); // Test normal numbers roundtrip with tolerance - let test_values = [1.0, -1.0, 3.141592653589793, -2.718281828459045, 1e10, -1e-10]; + let test_values = [ + 1.0, + -1.0, + 3.141592653589793, + -2.718281828459045, + 1e10, + -1e-10, + ]; for &val in &test_values { f80.set_f64(val); @@ -75,7 +81,11 @@ pub fn fpu_f80_emulation() { "BCD roundtrip: valor entero no coincide para valor {}", val ); - assert!((f80.get_f64() - f80_2.get_f64()).abs() < 1e-10, "BCD roundtrip no coincide para valor {}", val); + assert!( + (f80.get_f64() - f80_2.get_f64()).abs() < 1e-10, + "BCD roundtrip no coincide para valor {}", + val + ); } f80.set_f64(259.0); @@ -92,7 +102,7 @@ pub fn fpu_f80_emulation() { assert_eq!(bcd[1], 0x02); let mut f80 = F80::new(); - let val:u128 = 256; + let val: u128 = 256; f80.set(val); let bytes = f80.get_bytes(); @@ -100,16 +110,20 @@ pub fn fpu_f80_emulation() { f80_2.set_bytes(&bytes); assert_eq!(f80.get(), f80_2.get(), "Error en get() para valor {}", val); - assert_eq!(f80.to_integer_u128(), f80_2.to_integer_u128(), "Error en to_integer_u128 para valor {}", val); + assert_eq!( + f80.to_integer_u128(), + f80_2.to_integer_u128(), + "Error en to_integer_u128 para valor {}", + val + ); let bcd1 = f80.to_bcd_packed(); let bcd2 = f80_2.to_bcd_packed(); assert_eq!(bcd1, bcd2, "Error en BCD packed para valor {}", val); - // test a.add(b) - - let mut b:F80 = F80::new(); + + let mut b: F80 = F80::new(); f80.set_f64(-1.1); b.set_f64(1.9); f80.add(b); diff --git a/crates/libmwemu/src/tests/fpu_stack_operations.rs b/crates/libmwemu/src/tests/fpu_stack_operations.rs index 0d0c048c..d5bbdf5b 100644 --- a/crates/libmwemu/src/tests/fpu_stack_operations.rs +++ b/crates/libmwemu/src/tests/fpu_stack_operations.rs @@ -1,58 +1,57 @@ use crate::{fpu::FPU, tests::helpers}; - #[test] // test FPU stack operations beyond basic F80 tests pub fn fpu_stack_operations() { helpers::setup(); let mut fpu = FPU::new(); - + // Test initial stack state assert_eq!(fpu.get_top(), 0); assert_eq!(fpu.get_depth(), 0); - + // Test stack push operations fpu.push_f64(1.0); assert_eq!(fpu.get_depth(), 1); assert_eq!(fpu.peek_st_logical_f64(0), 1.0); - + fpu.push_f64(2.0); assert_eq!(fpu.get_depth(), 2); assert_eq!(fpu.peek_st_logical_f64(0), 2.0); assert_eq!(fpu.peek_st_logical_f64(1), 1.0); - + fpu.push_f64(3.0); assert_eq!(fpu.get_depth(), 3); assert_eq!(fpu.peek_st_logical_f64(0), 3.0); assert_eq!(fpu.peek_st_logical_f64(1), 2.0); assert_eq!(fpu.peek_st_logical_f64(2), 1.0); - + // Test stack pop operations let val = fpu.pop_f64(); assert_eq!(val, 3.0); assert_eq!(fpu.get_depth(), 2); assert_eq!(fpu.peek_st_logical_f64(0), 2.0); - + // Test stack overflow protection (push 5 more values to reach 8 total) for i in 3..9 { fpu.push_f64(i as f64); } - + // Stack should be full now, test behavior assert_eq!(fpu.get_depth(), 8); - + // Test clearing stack fpu.clear(); assert_eq!(fpu.get_depth(), 0); assert_eq!(fpu.get_top(), 0); - + // Test mixed operations fpu.push_f64(10.5); fpu.push_f64(20.25); fpu.push_f64(30.125); - fpu.st.print(); + fpu.st.print(); assert_eq!(fpu.peek_st_logical_f64(0), 30.125); assert_eq!(fpu.peek_st_logical_f64(1), 20.25); assert_eq!(fpu.peek_st_logical_f64(2), 10.5); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/helpers.rs b/crates/libmwemu/src/tests/helpers.rs index f7b7b3e6..0563ca41 100644 --- a/crates/libmwemu/src/tests/helpers.rs +++ b/crates/libmwemu/src/tests/helpers.rs @@ -1,5 +1,5 @@ -use std::sync::Once; use std::io::Write as _; +use std::sync::Once; static INIT: Once = Once::new(); @@ -29,12 +29,21 @@ pub fn critical_values(bits: u32) -> Vec { sign_bit, sign_bit - 1, sign_bit + 1, - 0x55, // 01010101 - 0xAA, // 10101010 + 0x55, // 01010101 + 0xAA, // 10101010 0xFFFFFFFFFFFFFFFFu64 >> (64 - bits), // all 1s for the width ] } pub fn shift_counts(bits: u32) -> Vec { - vec![0, 1, bits as u64 - 1, bits as u64, bits as u64 + 1, 63, 64, 127] + vec![ + 0, + 1, + bits as u64 - 1, + bits as u64, + bits as u64 + 1, + 63, + 64, + 127, + ] } diff --git a/crates/libmwemu/src/tests/hooks_system.rs b/crates/libmwemu/src/tests/hooks_system.rs index 9b90d5fe..d3e85012 100644 --- a/crates/libmwemu/src/tests/hooks_system.rs +++ b/crates/libmwemu/src/tests/hooks_system.rs @@ -6,7 +6,7 @@ pub fn hooks_system() { helpers::setup(); let mut hooks = crate::hooks::Hooks::new(); - + // Test initial state - all hooks should be None assert!(hooks.hook_on_interrupt.is_none()); assert!(hooks.hook_on_exception.is_none()); @@ -15,26 +15,26 @@ pub fn hooks_system() { assert!(hooks.hook_on_pre_instruction.is_none()); assert!(hooks.hook_on_post_instruction.is_none()); assert!(hooks.hook_on_winapi_call.is_none()); - + // Test setting hooks hooks.hook_on_interrupt = Some(|_emu, _addr, _interrupt| true); assert!(hooks.hook_on_interrupt.is_some()); - + hooks.hook_on_exception = Some(|_emu, _addr, _ex_type| true); assert!(hooks.hook_on_exception.is_some()); - + hooks.hook_on_memory_read = Some(|_emu, _ip, _addr, _sz| {}); assert!(hooks.hook_on_memory_read.is_some()); - + hooks.hook_on_memory_write = Some(|_emu, _ip, _addr, _sz, value| value); assert!(hooks.hook_on_memory_write.is_some()); - + hooks.hook_on_pre_instruction = Some(|_emu, _addr, _ins, _sz| true); assert!(hooks.hook_on_pre_instruction.is_some()); - + hooks.hook_on_post_instruction = Some(|_emu, _addr, _ins, _sz, _ok| {}); assert!(hooks.hook_on_post_instruction.is_some()); - + hooks.hook_on_winapi_call = Some(|_emu, _addr, _called_addr| true); assert!(hooks.hook_on_winapi_call.is_some()); @@ -46,4 +46,4 @@ pub fn hooks_system() { assert!(!hooks.hook_on_pre_instruction.is_none()); assert!(!hooks.hook_on_post_instruction.is_none()); assert!(!hooks.hook_on_winapi_call.is_none()); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/logic_test.rs b/crates/libmwemu/src/tests/logic_test.rs index a65ddedc..214fb81f 100644 --- a/crates/libmwemu/src/tests/logic_test.rs +++ b/crates/libmwemu/src/tests/logic_test.rs @@ -1,6 +1,6 @@ use crate::engine::logic; -use crate::*; use crate::tests::helpers; +use crate::*; #[test] // logic tests @@ -9,11 +9,10 @@ pub fn logic_test() { let mut emu = emu64(); emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - let num: u64 = 0x1234_5678_9ABC_DEF0; - let shift:u64 = 12; - let size:u32 = 32; + let shift: u64 = 12; + let size: u32 = 32; let src: u64 = num >> (size as u64 - shift); let mut r: u64; diff --git a/crates/libmwemu/src/tests/maps_memory_operations.rs b/crates/libmwemu/src/tests/maps_memory_operations.rs index e3d6f813..51b8687b 100644 --- a/crates/libmwemu/src/tests/maps_memory_operations.rs +++ b/crates/libmwemu/src/tests/maps_memory_operations.rs @@ -1,5 +1,6 @@ -use crate::*; +use crate::maps::mem64::Permission; use crate::tests::helpers; +use crate::*; #[test] // test memory management operations @@ -8,48 +9,53 @@ pub fn maps_memory_operations() { let mut emu = emu64(); // with no init call - + // Test memory allocation let base = 0x10000; let size = 0x1000; - let result = emu.maps.create_map("test_map", base, size); + let result = emu + .maps + .create_map("test_map", base, size, Permission::READ_WRITE); assert!(result.is_ok()); - + // Test memory exists assert!(emu.maps.is_allocated(base)); assert!(emu.maps.exists_mapname("test_map")); - + // Test memory read/write operations assert!(emu.maps.write_dword(base, 0xDEADBEEF)); assert_eq!(emu.maps.read_dword(base).unwrap(), 0xDEADBEEF); - + // Test qword operations assert!(emu.maps.write_qword(base + 8, 0x123456789ABCDEF0)); assert_eq!(emu.maps.read_qword(base + 8).unwrap(), 0x123456789ABCDEF0); - + // Test byte operations assert!(emu.maps.write_byte(base + 16, 0xAB)); assert_eq!(emu.maps.read_byte(base + 16).unwrap(), 0xAB); - + // Test word operations assert!(emu.maps.write_word(base + 18, 0x1234)); assert_eq!(emu.maps.read_word(base + 18).unwrap(), 0x1234); - + // Test boundary conditions - should fail with banzai mode emu.maps.set_banzai(true); assert!(!emu.maps.write_dword(base + size, 0x12345678)); assert!(emu.maps.read_dword(base + size).is_none()); - + // Test string operations let test_str = "Hello World"; emu.maps.write_string(base + 32, test_str); assert_eq!(emu.maps.read_string(base + 32), test_str); - + let test_map = emu + .maps + .get_map_by_name("test_map") + .expect("Fail to get map"); + assert_eq!(test_map.permission().can_execute(), false); + // Test duplicate map creation should fail - let result2 = emu.maps.create_map("test_map", base, size); + let result2 = emu + .maps + .create_map("test_map", base, size, Permission::READ_WRITE); assert!(result2.is_err()); - - // Test overlapping memory should fail - let result3 = emu.maps.create_map("test_map2", base + 0x500, size); - assert!(result3.is_err()); } diff --git a/crates/libmwemu/src/tests/mem64_test.rs b/crates/libmwemu/src/tests/mem64_test.rs index e7ad17a4..16763ba9 100644 --- a/crates/libmwemu/src/tests/mem64_test.rs +++ b/crates/libmwemu/src/tests/mem64_test.rs @@ -1,3 +1,4 @@ +use crate::maps::mem64::Permission; use crate::{maps::mem64::Mem64, tests::helpers}; #[test] @@ -6,6 +7,7 @@ pub fn mem64_test() { helpers::setup(); let mut mem = Mem64::default(); + mem.set_permission(Permission::READ_WRITE); mem.set_name("memtest"); assert_eq!(mem.get_name(), "memtest"); @@ -42,9 +44,8 @@ pub fn mem64_test() { mem.write_string(0x400010 + 7, "world!"); assert_eq!(mem.read_string(0x400010), "Hello, world!"); - assert_eq!(mem.inside(0x4000ab), true); - assert_eq!(mem.inside(0x400000+1024), false); + assert_eq!(mem.inside(0x400000 + 1024), false); mem.clear(); @@ -53,6 +54,6 @@ pub fn mem64_test() { mem2.set_size(16); mem2.load("../../test/sc32win_donut.bin"); let md5 = format!("{:x}", mem2.md5()); - assert!(md5 == "66d6376c2dd0b8d4d35461844e5b0e6c" || md5 == "4ae71336e44bf9bf79d2752e234818a5"); + assert!(md5 == "66d6376c2dd0b8d4d35461844e5b0e6c" || md5 == "4ae71336e44bf9bf79d2752e234818a5"); // its weird but in windows CI the md5 changes to 4ae... prolly defender patches it -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/memmove_test.rs b/crates/libmwemu/src/tests/memmove_test.rs index 73be2752..ae9cc834 100644 --- a/crates/libmwemu/src/tests/memmove_test.rs +++ b/crates/libmwemu/src/tests/memmove_test.rs @@ -1,5 +1,5 @@ +use crate::maps::mem64::Permission; use crate::{tests::helpers, *}; - // RUST_LOG=debug cargo test --target x86_64-apple-darwin --features log_mem_write memmove_non_overlapping_copy // RUST_LOG=debug cargo test --target x86_64-apple-darwin --features log_mem_write memmove_non_overlapping_copy @@ -10,26 +10,26 @@ use crate::{tests::helpers, *}; undefined memmove() assume GS_OFFSET = 0xff00000000 undefined - memmove XREF[77]: FUN_7ffd1042c210:7ffd1042c243(c), - FUN_7ffd1042c260:7ffd1042c2d8(c), - FUN_7ffd1042c260:7ffd1042c30a(c), - FUN_7ffd1042c260:7ffd1042c321(c), - FUN_7ffd1042c260:7ffd1042c33a(c), - FUN_7ffd1042c260:7ffd1042c35c(c), - FUN_7ffd1042fdc0:7ffd1042fddf(c), - FUN_7ffd104308a0:7ffd10430909(c), - FUN_7ffd10431b60:7ffd10431bad(c), - wipe_string?:7ffd10431e7d(c), + memmove XREF[77]: FUN_7ffd1042c210:7ffd1042c243(c), + FUN_7ffd1042c260:7ffd1042c2d8(c), + FUN_7ffd1042c260:7ffd1042c30a(c), + FUN_7ffd1042c260:7ffd1042c321(c), + FUN_7ffd1042c260:7ffd1042c33a(c), + FUN_7ffd1042c260:7ffd1042c35c(c), + FUN_7ffd1042fdc0:7ffd1042fddf(c), + FUN_7ffd104308a0:7ffd10430909(c), + FUN_7ffd10431b60:7ffd10431bad(c), + wipe_string?:7ffd10431e7d(c), init_and_copy_string?:7ffd10431f - string_concat?:7ffd1043200a(c), - string_concat?:7ffd10432027(c), - string_concat?:7ffd10432055(c), - string_concat?:7ffd10432066(c), - string_concat?:7ffd1043208f(c), - string_concat?:7ffd104320a7(c), + string_concat?:7ffd1043200a(c), + string_concat?:7ffd10432027(c), + string_concat?:7ffd10432055(c), + string_concat?:7ffd10432066(c), + string_concat?:7ffd1043208f(c), + string_concat?:7ffd104320a7(c), resize_string_buffer?:7ffd104324 - FUN_7ffd10432480:7ffd10432511(c), - FUN_7ffd1043c680:7ffd1043c6d5(c), + FUN_7ffd10432480:7ffd10432511(c), + FUN_7ffd1043c680:7ffd1043c6d5(c), [more] 7ffd1042b3e0 4c 89 c0 MOV RAX,R8 7ffd1042b3e3 48 29 d1 SUB RCX,RDX @@ -39,7 +39,7 @@ use crate::{tests::helpers, *}; 7ffd1042b3ee 48 01 c8 ADD RAX,RCX 7ffd1042b3f1 0f 82 6d JC LAB_7ffd1042b564 01 00 00 - LAB_7ffd1042b3f7 XREF[1]: 7ffd1042b3ec(j) + LAB_7ffd1042b3f7 XREF[1]: 7ffd1042b3ec(j) 7ffd1042b3f7 49 83 f8 08 CMP R8,0x8 7ffd1042b3fb 0f 8c 63 JL LAB_7ffd1042b464 00 00 00 @@ -51,58 +51,58 @@ use crate::{tests::helpers, *}; 7ffd1042b40e 49 ff c8 DEC R8 7ffd1042b411 88 02 MOV byte ptr [RDX],AL 7ffd1042b413 48 83 c2 01 ADD RDX,0x1 - LAB_7ffd1042b417 XREF[1]: 7ffd1042b409(j) + LAB_7ffd1042b417 XREF[1]: 7ffd1042b409(j) 7ffd1042b417 f6 c2 02 TEST DL,0x2 7ffd1042b41a 74 0f JZ LAB_7ffd1042b42b 7ffd1042b41c 66 8b 04 11 MOV AX,word ptr [RCX + RDX*0x1] 7ffd1042b420 49 83 e8 02 SUB R8,0x2 7ffd1042b424 66 89 02 MOV word ptr [RDX],AX 7ffd1042b427 48 83 c2 02 ADD RDX,0x2 - LAB_7ffd1042b42b XREF[1]: 7ffd1042b41a(j) + LAB_7ffd1042b42b XREF[1]: 7ffd1042b41a(j) 7ffd1042b42b f6 c2 04 TEST DL,0x4 7ffd1042b42e 74 0d JZ LAB_7ffd1042b43d 7ffd1042b430 8b 04 11 MOV EAX,dword ptr [RCX + RDX*0x1] 7ffd1042b433 49 83 e8 04 SUB R8,0x4 7ffd1042b437 89 02 MOV dword ptr [RDX],EAX 7ffd1042b439 48 83 c2 04 ADD RDX,0x4 - LAB_7ffd1042b43d XREF[3]: 7ffd1042b404(j), 7ffd1042b42e(j), - 7ffd1042b55f(j) + LAB_7ffd1042b43d XREF[3]: 7ffd1042b404(j), 7ffd1042b42e(j), + 7ffd1042b55f(j) 7ffd1042b43d 4d 89 c1 MOV R9,R8 7ffd1042b440 49 c1 e9 05 SHR R9,0x5 7ffd1042b444 75 38 JNZ LAB_7ffd1042b47e - LAB_7ffd1042b446 XREF[1]: 7ffd1042b4c1(j) + LAB_7ffd1042b446 XREF[1]: 7ffd1042b4c1(j) 7ffd1042b446 4d 89 c1 MOV R9,R8 7ffd1042b449 49 c1 e9 03 SHR R9,0x3 7ffd1042b44d 74 15 JZ LAB_7ffd1042b464 7ffd1042b44f 90 NOP - LAB_7ffd1042b450 XREF[1]: 7ffd1042b45e(j) + LAB_7ffd1042b450 XREF[1]: 7ffd1042b45e(j) 7ffd1042b450 48 8b 04 11 MOV RAX,qword ptr [RCX + RDX*0x1] 7ffd1042b454 48 89 02 MOV qword ptr [RDX],RAX 7ffd1042b457 48 83 c2 08 ADD RDX,0x8 7ffd1042b45b 49 ff c9 DEC R9 7ffd1042b45e 75 f0 JNZ LAB_7ffd1042b450 7ffd1042b460 49 83 e0 07 AND R8,0x7 - LAB_7ffd1042b464 XREF[2]: 7ffd1042b3fb(j), 7ffd1042b44d(j) + LAB_7ffd1042b464 XREF[2]: 7ffd1042b3fb(j), 7ffd1042b44d(j) 7ffd1042b464 4d 85 c0 TEST R8,R8 7ffd1042b467 7e 14 JLE LAB_7ffd1042b47d 7ffd1042b469 0f 1f 80 NOP dword ptr [RAX] 00 00 00 00 - LAB_7ffd1042b470 XREF[1]: 7ffd1042b47b(j) + LAB_7ffd1042b470 XREF[1]: 7ffd1042b47b(j) 7ffd1042b470 8a 04 11 MOV AL,byte ptr [RCX + RDX*0x1] 7ffd1042b473 88 02 MOV byte ptr [RDX],AL 7ffd1042b475 48 ff c2 INC RDX 7ffd1042b478 49 ff c8 DEC R8 7ffd1042b47b 75 f3 JNZ LAB_7ffd1042b470 - LAB_7ffd1042b47d XREF[2]: 7ffd1042b3e6(j), 7ffd1042b467(j) + LAB_7ffd1042b47d XREF[2]: 7ffd1042b3e6(j), 7ffd1042b467(j) 7ffd1042b47d c3 RET - LAB_7ffd1042b47e XREF[1]: 7ffd1042b444(j) + LAB_7ffd1042b47e XREF[1]: 7ffd1042b444(j) 7ffd1042b47e 49 81 f9 CMP R9,0x2000 00 20 00 00 7ffd1042b485 72 09 JC LAB_7ffd1042b490 7ffd1042b487 48 81 f9 CMP RCX,0x1000 00 10 00 00 7ffd1042b48e 73 33 JNC LAB_7ffd1042b4c3 - LAB_7ffd1042b490 XREF[2]: 7ffd1042b485(j), 7ffd1042b4bb(j) + LAB_7ffd1042b490 XREF[2]: 7ffd1042b485(j), 7ffd1042b4bb(j) 7ffd1042b490 48 83 c2 20 ADD RDX,0x20 7ffd1042b494 48 8b 44 MOV RAX,qword ptr [RCX + RDX*0x1 + -0x20] 11 e0 @@ -120,13 +120,13 @@ use crate::{tests::helpers, *}; 7ffd1042b4bb 75 d3 JNZ LAB_7ffd1042b490 7ffd1042b4bd 49 83 e0 1f AND R8,0x1f 7ffd1042b4c1 eb 83 JMP LAB_7ffd1042b446 - LAB_7ffd1042b4c3 XREF[2]: 7ffd1042b48e(j), 7ffd1042b556(j) + LAB_7ffd1042b4c3 XREF[2]: 7ffd1042b48e(j), 7ffd1042b556(j) 7ffd1042b4c3 b8 20 00 MOV EAX,0x20 00 00 7ffd1042b4c8 0f 1f 84 NOP dword ptr [RAX + RAX*0x1] - 00 00 00 + 00 00 00 00 00 - LAB_7ffd1042b4d0 XREF[1]: 7ffd1042b4e2(j) + LAB_7ffd1042b4d0 XREF[1]: 7ffd1042b4e2(j) 7ffd1042b4d0 0f 18 04 11 NOP dword ptr [RCX + RDX*0x1] 7ffd1042b4d4 0f 18 44 NOP dword ptr [RCX + RDX*0x1 + 0x40] 11 40 @@ -138,7 +138,7 @@ use crate::{tests::helpers, *}; 00 10 00 00 7ffd1042b4eb b8 40 00 MOV EAX,0x40 00 00 - LAB_7ffd1042b4f0 XREF[1]: 7ffd1042b546(j) + LAB_7ffd1042b4f0 XREF[1]: 7ffd1042b546(j) 7ffd1042b4f0 48 83 c2 40 ADD RDX,0x40 7ffd1042b4f4 4c 8b 4c MOV R9,qword ptr [RCX + RDX*0x1 + -0x40] 11 c0 @@ -183,7 +183,7 @@ use crate::{tests::helpers, *}; 7ffd1042b55c 0f ae f0 MFENCE 7ffd1042b55f e9 d9 fe JMP LAB_7ffd1042b43d ff ff - LAB_7ffd1042b564 XREF[1]: 7ffd1042b3f1(j) + LAB_7ffd1042b564 XREF[1]: 7ffd1042b3f1(j) 7ffd1042b564 4c 01 c2 ADD RDX,R8 7ffd1042b567 49 83 f8 08 CMP R8,0x8 7ffd1042b56b 7c 61 JL LAB_7ffd1042b5ce @@ -195,59 +195,59 @@ use crate::{tests::helpers, *}; 7ffd1042b57a 8a 04 11 MOV AL,byte ptr [RCX + RDX*0x1] 7ffd1042b57d 49 ff c8 DEC R8 7ffd1042b580 88 02 MOV byte ptr [RDX],AL - LAB_7ffd1042b582 XREF[1]: 7ffd1042b575(j) + LAB_7ffd1042b582 XREF[1]: 7ffd1042b575(j) 7ffd1042b582 f6 c2 02 TEST DL,0x2 7ffd1042b585 74 0f JZ LAB_7ffd1042b596 7ffd1042b587 48 83 ea 02 SUB RDX,0x2 7ffd1042b58b 66 8b 04 11 MOV AX,word ptr [RCX + RDX*0x1] 7ffd1042b58f 49 83 e8 02 SUB R8,0x2 7ffd1042b593 66 89 02 MOV word ptr [RDX],AX - LAB_7ffd1042b596 XREF[1]: 7ffd1042b585(j) + LAB_7ffd1042b596 XREF[1]: 7ffd1042b585(j) 7ffd1042b596 f6 c2 04 TEST DL,0x4 7ffd1042b599 74 0d JZ LAB_7ffd1042b5a8 7ffd1042b59b 48 83 ea 04 SUB RDX,0x4 7ffd1042b59f 8b 04 11 MOV EAX,dword ptr [RCX + RDX*0x1] 7ffd1042b5a2 49 83 e8 04 SUB R8,0x4 7ffd1042b5a6 89 02 MOV dword ptr [RDX],EAX - LAB_7ffd1042b5a8 XREF[3]: 7ffd1042b570(j), 7ffd1042b599(j), - 7ffd1042b6cd(j) + LAB_7ffd1042b5a8 XREF[3]: 7ffd1042b570(j), 7ffd1042b599(j), + 7ffd1042b6cd(j) 7ffd1042b5a8 4d 89 c1 MOV R9,R8 7ffd1042b5ab 49 c1 e9 05 SHR R9,0x5 7ffd1042b5af 75 3d JNZ LAB_7ffd1042b5ee - LAB_7ffd1042b5b1 XREF[1]: 7ffd1042b62f(j) + LAB_7ffd1042b5b1 XREF[1]: 7ffd1042b62f(j) 7ffd1042b5b1 4d 89 c1 MOV R9,R8 7ffd1042b5b4 49 c1 e9 03 SHR R9,0x3 7ffd1042b5b8 74 14 JZ LAB_7ffd1042b5ce - LAB_7ffd1042b5ba XREF[1]: 7ffd1042b5c8(j) + LAB_7ffd1042b5ba XREF[1]: 7ffd1042b5c8(j) 7ffd1042b5ba 48 83 ea 08 SUB RDX,0x8 7ffd1042b5be 48 8b 04 11 MOV RAX,qword ptr [RCX + RDX*0x1] 7ffd1042b5c2 49 ff c9 DEC R9 7ffd1042b5c5 48 89 02 MOV qword ptr [RDX],RAX 7ffd1042b5c8 75 f0 JNZ LAB_7ffd1042b5ba 7ffd1042b5ca 49 83 e0 07 AND R8,0x7 - LAB_7ffd1042b5ce XREF[2]: 7ffd1042b56b(j), 7ffd1042b5b8(j) + LAB_7ffd1042b5ce XREF[2]: 7ffd1042b56b(j), 7ffd1042b5b8(j) 7ffd1042b5ce 4d 85 c0 TEST R8,R8 7ffd1042b5d1 7e 1a JLE LAB_7ffd1042b5ed 7ffd1042b5d3 66 66 66 NOP word ptr [RAX + RAX*0x1] - 0f 1f 84 - 00 00 00 + 0f 1f 84 + 00 00 00 7ffd1042b5de 66 90 NOP - LAB_7ffd1042b5e0 XREF[1]: 7ffd1042b5eb(j) + LAB_7ffd1042b5e0 XREF[1]: 7ffd1042b5eb(j) 7ffd1042b5e0 48 ff ca DEC RDX 7ffd1042b5e3 8a 04 11 MOV AL,byte ptr [RCX + RDX*0x1] 7ffd1042b5e6 49 ff c8 DEC R8 7ffd1042b5e9 88 02 MOV byte ptr [RDX],AL 7ffd1042b5eb 75 f3 JNZ LAB_7ffd1042b5e0 - LAB_7ffd1042b5ed XREF[1]: 7ffd1042b5d1(j) + LAB_7ffd1042b5ed XREF[1]: 7ffd1042b5d1(j) 7ffd1042b5ed c3 RET - LAB_7ffd1042b5ee XREF[1]: 7ffd1042b5af(j) + LAB_7ffd1042b5ee XREF[1]: 7ffd1042b5af(j) 7ffd1042b5ee 49 81 f9 CMP R9,0x2000 00 20 00 00 7ffd1042b5f5 72 09 JC LAB_7ffd1042b600 7ffd1042b5f7 48 81 f9 CMP RCX,-0x1000 00 f0 ff ff 7ffd1042b5fe 72 34 JC LAB_7ffd1042b634 - LAB_7ffd1042b600 XREF[2]: 7ffd1042b5f5(j), 7ffd1042b629(j) + LAB_7ffd1042b600 XREF[2]: 7ffd1042b5f5(j), 7ffd1042b629(j) 7ffd1042b600 48 83 ea 20 SUB RDX,0x20 7ffd1042b604 48 8b 44 MOV RAX,qword ptr [RCX + RDX*0x1 + 0x18] 11 18 @@ -265,12 +265,12 @@ use crate::{tests::helpers, *}; 7ffd1042b62b 49 83 e0 1f AND R8,0x1f 7ffd1042b62f e9 7d ff JMP LAB_7ffd1042b5b1 ff ff - LAB_7ffd1042b634 XREF[2]: 7ffd1042b5fe(j), 7ffd1042b6c4(j) + LAB_7ffd1042b634 XREF[2]: 7ffd1042b5fe(j), 7ffd1042b6c4(j) 7ffd1042b634 b8 20 00 MOV EAX,0x20 00 00 7ffd1042b639 0f 1f 80 NOP dword ptr [RAX] 00 00 00 00 - LAB_7ffd1042b640 XREF[1]: 7ffd1042b652(j) + LAB_7ffd1042b640 XREF[1]: 7ffd1042b652(j) 7ffd1042b640 48 81 ea SUB RDX,0x80 80 00 00 00 7ffd1042b647 0f 18 04 11 NOP dword ptr [RCX + RDX*0x1] @@ -282,7 +282,7 @@ use crate::{tests::helpers, *}; 00 10 00 00 7ffd1042b65b b8 40 00 MOV EAX,0x40 00 00 - LAB_7ffd1042b660 XREF[1]: 7ffd1042b6b4(j) + LAB_7ffd1042b660 XREF[1]: 7ffd1042b6b4(j) 7ffd1042b660 48 83 ea 40 SUB RDX,0x40 7ffd1042b664 4c 8b 4c MOV R9,qword ptr [RCX + RDX*0x1 + 0x38] 11 38 @@ -330,25 +330,31 @@ use crate::{tests::helpers, *}; fn setup_memmove_emulator() -> (emu::Emu, u64, usize) { let memmove_code = hex::decode("4c89c04829d10f849100000073094801c80f826d0100004983f8080f8c63000000f6c2077437f6c201740c8a041149ffc888024883c201f6c202740f668b04114983e8026689024883c202f6c204740d8b04114983e80489024883c2044d89c149c1e90575384d89c149c1e903741590488b04114889024883c20849ffc975f04983e0074d85c07e140f1f80000000008a0411880248ffc249ffc875f3c34981f90020000072094881f90010000073334883c220488b4411e04c8b5411e8488942e04c8952e849ffc9488b4411f04c8b5411f8488942f04c8952f875d34983e01feb83b8200000000f1f8400000000000f1804110f184411404881c280000000ffc875ec4881ea00100000b8400000004883c2404c8b4c11c04c8b5411c84c0fc34ac04c0fc352c84c8b4c11d04c8b5411d84c0fc34ad04c0fc352d8ffc84c8b4c11e04c8b5411e84c0fc34ae04c0fc352e84c8b4c11f04c8b5411f84c0fc34af04c0fc352f875a84981e8001000004981f8001000000f8367ffffff0faef0e9d9feffff4c01c24983f8087c61f6c2077436f6c201740b48ffca8a041149ffc88802f6c202740f4883ea02668b04114983e802668902f6c204740d4883ea048b04114983e80489024d89c149c1e905753d4d89c149c1e90374144883ea08488b041149ffc948890275f04983e0074d85c07e1a6666660f1f840000000000669048ffca8a041149ffc8880275f3c34981f90020000072094881f900f0ffff72344883ea20488b4411184c8b541110488942184c89521049ffc9488b4411084c8b1411488942084c891275d54983e01fe97dffffffb8200000000f1f80000000004881ea800000000f1804110f18441140ffc875ec4881c200100000b8400000004883ea404c8b4c11384c8b5411304c0fc34a384c0fc352304c8b4c11284c8b5411204c0fc34a284c0fc35220ffc84c8b4c11184c8b5411104c0fc34a184c0fc352104c8b4c11084c8b14114c0fc34a084c0fc31275aa4981e8001000004981f8001000000f836affffff0faef0e9d6feffff").unwrap(); let memmove_code_len = memmove_code.len(); - + let mut emu = emu64(); - emu.cfg.skip_unimplemented = true; // Skip unimplemented functions - emu.cfg.verbose = 3; // Enable verbose logging - emu.cfg.trace_mem = true; // Enable memory tracing - emu.cfg.trace_regs = true; // Enable register tracing + emu.cfg.skip_unimplemented = true; // Skip unimplemented functions + emu.cfg.verbose = 3; // Enable verbose logging + emu.cfg.trace_mem = true; // Enable memory tracing + emu.cfg.trace_regs = true; // Enable register tracing // thread local storage emu_context::set_current_emu(&emu); - + // Set up stack let stack_addr = 0x1000000; let stack_size = 0x10000; - emu.maps.create_map("stack", stack_addr, stack_size); + emu.maps + .create_map("stack", stack_addr, stack_size, Permission::READ_WRITE); emu.regs_mut().rsp = stack_addr + stack_size / 2; - + // Load memmove code at address 0x400000 let code_addr = 0x400000; - emu.maps.create_map("code", code_addr, memmove_code_len as u64 + 0x100); + emu.maps.create_map( + "code", + code_addr, + memmove_code_len as u64 + 0x100, + Permission::READ_WRITE_EXECUTE, + ); emu.maps.write_bytes(code_addr, memmove_code); (emu, code_addr, memmove_code_len) @@ -358,29 +364,31 @@ fn setup_memmove_emulator() -> (emu::Emu, u64, usize) { fn memmove_non_overlapping_copy() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Allocate test buffers let src_addr = 0x500000; let dest_addr = 0x600000; - - emu.maps.create_map("src", src_addr, 0x1000); - emu.maps.create_map("dest", dest_addr, 0x1000); - + + emu.maps + .create_map("src", src_addr, 0x1000, Permission::READ_WRITE); + emu.maps + .create_map("dest", dest_addr, 0x1000, Permission::READ_WRITE); + // Initialize source with pattern let test_pattern = b"Hello, World! This is a test pattern."; emu.maps.write_bytes(src_addr, test_pattern.to_vec()); - + // Set up registers for memmove(dest, src, len) emu.regs_mut().rdx = dest_addr; emu.regs_mut().rcx = src_addr; emu.regs_mut().r8 = test_pattern.len() as u64; emu.regs_mut().rip = code_addr; - - // Push a return address on the stack + + // Push a return address on the stack let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove println!("About to execute memmove:"); println!(" RDX (dest): 0x{:x}", emu.regs().rdx); @@ -388,18 +396,18 @@ fn memmove_non_overlapping_copy() { println!(" R8 (len): 0x{:x}", emu.regs().r8); println!(" RIP: 0x{:x}", emu.regs().rip); println!(" Return addr: 0x{:x}", return_addr); - + // Check if destination is writable if !emu.maps.write_byte(dest_addr, 0) { panic!("Destination memory at 0x{:x} is not writable!", dest_addr); } - + emu.run(Some(return_addr)); - + // Verify the copy let copied_data = emu.maps.read_bytes(dest_addr, test_pattern.len()); assert_eq!(copied_data, test_pattern); - + // The memmove implementation might not return dest in RAX // Let's just verify the data was copied correctly // assert_eq!(emu.regs().rax, dest_addr); @@ -409,29 +417,30 @@ fn memmove_non_overlapping_copy() { fn memmove_overlapping_forward() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Create overlapping scenario where dest overlaps with end of src let overlap_src = 0x700000; let overlap_dest = 0x700010; // 16 bytes overlap let test_data: Vec = (0..64).collect(); - - emu.maps.create_map("overlap", overlap_src, 0x100); + + emu.maps + .create_map("overlap", overlap_src, 0x100, Permission::READ_WRITE); emu.maps.write_bytes(overlap_src, test_data.clone()); - + // Set up for overlapping copy emu.regs_mut().rdx = overlap_dest; emu.regs_mut().rcx = overlap_src; emu.regs_mut().r8 = 32; // Copy 32 bytes with 16-byte overlap emu.regs_mut().rip = code_addr; - + // Push return address let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove emu.run(Some(return_addr)); - + // Verify correct backward copy (to avoid corruption) let result = emu.maps.read_bytes(overlap_dest, 32); let expected: Vec = (0..32).collect(); @@ -442,28 +451,29 @@ fn memmove_overlapping_forward() { fn memmove_overlapping_backward() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + let overlap_src = 0x800010; let overlap_dest = 0x800000; let test_data: Vec = (0..64).collect(); - - emu.maps.create_map("overlap2", 0x800000, 0x100); + + emu.maps + .create_map("overlap2", 0x800000, 0x100, Permission::READ_WRITE); emu.maps.write_bytes(overlap_src, test_data.clone()); - + // Set up for backward overlapping copy emu.regs_mut().rdx = overlap_dest; emu.regs_mut().rcx = overlap_src; emu.regs_mut().r8 = 32; emu.regs_mut().rip = code_addr; - + // Push return address let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove emu.run(Some(return_addr)); - + // Verify correct forward copy let result = emu.maps.read_bytes(overlap_dest, 32); let expected: Vec = (0..32).collect(); @@ -474,35 +484,37 @@ fn memmove_overlapping_backward() { fn memmove_large_buffer() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + let large_src = 0x900000; let large_dest = 0xA00000; let large_size = 0x2000; // 8KB - - emu.maps.create_map("large_src", large_src, large_size); - emu.maps.create_map("large_dest", large_dest, large_size); - + + emu.maps + .create_map("large_src", large_src, large_size, Permission::READ_WRITE); + emu.maps + .create_map("large_dest", large_dest, large_size, Permission::READ_WRITE); + // Fill with pattern let mut pattern = Vec::new(); for i in 0..large_size { pattern.push((i % 256) as u8); } emu.maps.write_bytes(large_src, pattern.clone()); - + // Set up for large copy emu.regs_mut().rdx = large_dest; emu.regs_mut().rcx = large_src; emu.regs_mut().r8 = large_size; emu.regs_mut().rip = code_addr; - + // Push return address let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove emu.run(Some(return_addr)); - + // Verify large copy let result = emu.maps.read_bytes(large_dest, large_size as usize); assert_eq!(result, pattern); @@ -512,26 +524,28 @@ fn memmove_large_buffer() { fn memmove_zero_length() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + let src_addr = 0x500000; let dest_addr = 0x600000; - - emu.maps.create_map("src", src_addr, 0x100); - emu.maps.create_map("dest", dest_addr, 0x100); - + + emu.maps + .create_map("src", src_addr, 0x100, Permission::READ_WRITE); + emu.maps + .create_map("dest", dest_addr, 0x100, Permission::READ_WRITE); + emu.regs_mut().rdx = dest_addr; emu.regs_mut().rcx = src_addr; emu.regs_mut().r8 = 0; emu.regs_mut().rip = code_addr; - + // Push return address let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove with zero length emu.run(Some(return_addr)); - + // Zero-length copy should not modify memory // The return value might not be standardized in this implementation // Just verify no crash occurred and execution completed @@ -541,28 +555,30 @@ fn memmove_zero_length() { fn memmove_unaligned_addresses() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + let unaligned_src = 0xB00003; let unaligned_dest = 0xC00007; let test_data = b"Unaligned test data"; - - emu.maps.create_map("unaligned_src", 0xB00000, 0x100); - emu.maps.create_map("unaligned_dest", 0xC00000, 0x100); + + emu.maps + .create_map("unaligned_src", 0xB00000, 0x100, Permission::READ_WRITE); + emu.maps + .create_map("unaligned_dest", 0xC00000, 0x100, Permission::READ_WRITE); emu.maps.write_bytes(unaligned_src, test_data.to_vec()); - + emu.regs_mut().rdx = unaligned_dest; emu.regs_mut().rcx = unaligned_src; emu.regs_mut().r8 = test_data.len() as u64; emu.regs_mut().rip = code_addr; - + // Push return address let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + // Execute memmove with unaligned addresses emu.run(Some(return_addr)); - + // Verify unaligned copy let result = emu.maps.read_bytes(unaligned_dest, test_data.len()); assert_eq!(result, test_data); @@ -572,29 +588,39 @@ fn memmove_unaligned_addresses() { fn memmove_exact_page_boundary() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Test copying across page boundaries let page_boundary = 0xD00000; let test_size = 0x1000; // Exactly one page - - emu.maps.create_map("page1", page_boundary - 0x800, 0x1000); - emu.maps.create_map("page2", page_boundary + 0x800, 0x1000); - + + emu.maps.create_map( + "page1", + page_boundary - 0x800, + 0x1000, + Permission::READ_WRITE, + ); + emu.maps.create_map( + "page2", + page_boundary + 0x800, + 0x1000, + Permission::READ_WRITE, + ); + // Create pattern that crosses page boundary let pattern: Vec = (0..test_size).map(|i| (i % 256) as u8).collect(); emu.maps.write_bytes(page_boundary - 0x800, pattern.clone()); - + emu.regs_mut().rdx = page_boundary + 0x800; emu.regs_mut().rcx = page_boundary - 0x800; emu.regs_mut().r8 = test_size as u64; emu.regs_mut().rip = code_addr; - + let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + emu.run(Some(return_addr)); - + let result = emu.maps.read_bytes(page_boundary + 0x800, test_size); assert_eq!(result, pattern); } @@ -603,34 +629,44 @@ fn memmove_exact_page_boundary() { fn memmove_alignment_boundary_sizes() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Test various sizes that trigger different code paths let test_sizes = vec![1, 2, 4, 7, 8, 15, 16, 31, 32, 63, 64]; - + for (i, &size) in test_sizes.iter().enumerate() { let src_base = 0x1000000 + (i * 0x10000) as u64; let dest_base = src_base + 0x8000; - - emu.maps.create_map(&format!("test_src_{}", i), src_base, 0x1000); - emu.maps.create_map(&format!("test_dest_{}", i), dest_base, 0x1000); - + + emu.maps.create_map( + &format!("test_src_{}", i), + src_base, + 0x1000, + Permission::READ_WRITE, + ); + emu.maps.create_map( + &format!("test_dest_{}", i), + dest_base, + 0x1000, + Permission::READ_WRITE, + ); + let pattern: Vec = (0..size).map(|j| ((i + j) % 256) as u8).collect(); emu.maps.write_bytes(src_base, pattern.clone()); - + emu.regs_mut().rdx = dest_base; emu.regs_mut().rcx = src_base; emu.regs_mut().r8 = size as u64; emu.regs_mut().rip = code_addr; - + let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + emu.run(Some(return_addr)); - + let result = emu.maps.read_bytes(dest_base, size); assert_eq!(result, pattern, "Failed for size {}", size); - + // Reset RIP for next iteration emu.regs_mut().rip = code_addr; } @@ -640,45 +676,52 @@ fn memmove_alignment_boundary_sizes() { fn memmove_stress_overlapping_patterns() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Test multiple overlapping scenarios with different offset patterns let base_addr = 0x2000000; let buffer_size = 0x1000; - - emu.maps.create_map("stress_buffer", base_addr, buffer_size * 2); - + + emu.maps.create_map( + "stress_buffer", + base_addr, + buffer_size * 2, + Permission::READ_WRITE, + ); + // Initialize with a recognizable pattern - let original_pattern: Vec = (0..buffer_size) - .map(|i| ((i * 7) % 256) as u8) - .collect(); + let original_pattern: Vec = (0..buffer_size).map(|i| ((i * 7) % 256) as u8).collect(); emu.maps.write_bytes(base_addr, original_pattern.clone()); - + let overlap_tests = vec![ (1, 100), // 1-byte offset, 100 bytes - (16, 200), // 16-byte offset, 200 bytes + (16, 200), // 16-byte offset, 200 bytes (64, 500), // 64-byte offset, 500 bytes (256, 1000), // 256-byte offset, 1000 bytes ]; - + for (offset, copy_size) in overlap_tests { // Reset buffer emu.maps.write_bytes(base_addr, original_pattern.clone()); - + emu.regs_mut().rdx = base_addr + offset; emu.regs_mut().rcx = base_addr; emu.regs_mut().r8 = copy_size; emu.regs_mut().rip = code_addr; - + let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + emu.run(Some(return_addr)); - + // Verify the overlapping copy preserved the original data correctly let result = emu.maps.read_bytes(base_addr + offset, copy_size as usize); - let expected = &original_pattern[0..copy_size as usize]; - assert_eq!(result, expected, "Overlap test failed for offset {} size {}", offset, copy_size); + let expected = &original_pattern[0..copy_size as usize]; + assert_eq!( + result, expected, + "Overlap test failed for offset {} size {}", + offset, copy_size + ); } } @@ -686,39 +729,53 @@ fn memmove_stress_overlapping_patterns() { fn memmove_performance_threshold_boundary() { helpers::setup(); let (mut emu, code_addr, memmove_code_len) = setup_memmove_emulator(); - + // Test the boundary where MOVNTI instructions kick in (around 0x2000 * 32 = 0x40000) let threshold_sizes = vec![0x3F00, 0x4000, 0x4100]; // Just below, at, and above threshold - + for (i, &size) in threshold_sizes.iter().enumerate() { let src_addr = 0x3000000 + (i * 0x100000) as u64; let dest_addr = src_addr + 0x80000; - - emu.maps.create_map(&format!("perf_src_{}", i), src_addr, size + 0x1000); - emu.maps.create_map(&format!("perf_dest_{}", i), dest_addr, size + 0x1000); - + + emu.maps.create_map( + &format!("perf_src_{}", i), + src_addr, + size + 0x1000, + Permission::READ_WRITE, + ); + emu.maps.create_map( + &format!("perf_dest_{}", i), + dest_addr, + size + 0x1000, + Permission::READ_WRITE, + ); + // Create a pattern that's easy to verify let mut pattern = Vec::with_capacity(size as usize); for j in 0..size { pattern.push(((j / 256) % 256) as u8); } emu.maps.write_bytes(src_addr, pattern.clone()); - + emu.regs_mut().rdx = dest_addr; emu.regs_mut().rcx = src_addr; emu.regs_mut().r8 = size as u64; emu.regs_mut().rip = code_addr; - + let return_addr = code_addr + memmove_code_len as u64; emu.regs_mut().rsp -= 8; emu.maps.write_qword(emu.regs().rsp, return_addr); - + emu.run(Some(return_addr)); - + // Sample verification (checking full buffer would be expensive) let sample_size = std::cmp::min(1024, size); let result = emu.maps.read_bytes(dest_addr, sample_size as usize); let expected = &pattern[0..sample_size as usize]; - assert_eq!(result, expected, "Performance boundary test failed for size 0x{:X}", size); + assert_eq!( + result, expected, + "Performance boundary test failed for size 0x{:X}", + size + ); } } diff --git a/crates/libmwemu/src/tests/memory_map_operations.rs b/crates/libmwemu/src/tests/memory_map_operations.rs index 19677e4a..2293f297 100644 --- a/crates/libmwemu/src/tests/memory_map_operations.rs +++ b/crates/libmwemu/src/tests/memory_map_operations.rs @@ -1,3 +1,4 @@ +use crate::maps::mem64::Permission; use crate::{tests::helpers, *}; #[test] @@ -7,48 +8,54 @@ pub fn memory_map_operations() { let mut emu = emu64(); // Don't call init to avoid DLL loading issues - + // Test multiple memory maps - emu.maps.create_map("map1", 0x10000, 0x1000).unwrap(); - emu.maps.create_map("map2", 0x20000, 0x2000).unwrap(); - emu.maps.create_map("map3", 0x30000, 0x1000).unwrap(); - + emu.maps + .create_map("map1", 0x10000, 0x1000, Permission::READ_WRITE) + .unwrap(); + emu.maps + .create_map("map2", 0x20000, 0x2000, Permission::READ_WRITE) + .unwrap(); + emu.maps + .create_map("map3", 0x30000, 0x1000, Permission::READ_WRITE) + .unwrap(); + // Test map existence assert!(emu.maps.exists_mapname("map1")); assert!(emu.maps.exists_mapname("map2")); assert!(emu.maps.exists_mapname("map3")); assert!(!emu.maps.exists_mapname("nonexistent")); - + // Test memory allocation checks assert!(emu.maps.is_allocated(0x10000)); assert!(emu.maps.is_allocated(0x10500)); assert!(emu.maps.is_allocated(0x10FFF)); assert!(!emu.maps.is_allocated(0x11000)); - + assert!(emu.maps.is_allocated(0x20000)); assert!(emu.maps.is_allocated(0x21FFF)); assert!(!emu.maps.is_allocated(0x22000)); - + // Test getting map by name let map1 = emu.maps.get_map_by_name("map1"); assert!(map1.is_some()); assert_eq!(map1.unwrap().get_base(), 0x10000); - + let nonexistent = emu.maps.get_map_by_name("nonexistent"); assert!(nonexistent.is_none()); - + // Test memory size queries let size1 = emu.maps.get_mem_size(0x10000); assert!(size1.is_some()); - + let size_invalid = emu.maps.get_mem_size(0x99999); assert!(size_invalid.is_none()); - + // Test cross-map operations assert!(emu.maps.write_dword(0x10000, 0x11111111)); assert!(emu.maps.write_dword(0x20000, 0x22222222)); assert!(emu.maps.write_dword(0x30000, 0x33333333)); - + assert_eq!(emu.maps.read_dword(0x10000).unwrap(), 0x11111111); assert_eq!(emu.maps.read_dword(0x20000).unwrap(), 0x22222222); assert_eq!(emu.maps.read_dword(0x30000).unwrap(), 0x33333333); diff --git a/crates/libmwemu/src/tests/mod.rs b/crates/libmwemu/src/tests/mod.rs index 1942f3af..241193b7 100644 --- a/crates/libmwemu/src/tests/mod.rs +++ b/crates/libmwemu/src/tests/mod.rs @@ -1,4 +1,3 @@ -mod helpers; mod allocator32_test; mod allocator64_test; mod basic_test_code_bytes_shld_shrd; @@ -19,10 +18,12 @@ mod flag_calculations; mod fpu_conversions; mod fpu_f80_emulation; mod fpu_stack_operations; +mod helpers; mod hooks_system; mod logic_test; mod maps_memory_operations; mod mem64_test; +mod memmove_test; mod memory_map_operations; mod peb_teb_ldr_structures_test; mod pure_rust_check; @@ -44,4 +45,3 @@ mod stress_shl2p_all; mod stress_shl2p_trigger; mod stress_shr2p_all; mod test_unified_step_and_run_methods; -mod memmove_test; diff --git a/crates/libmwemu/src/tests/peb_teb_ldr_structures_test.rs b/crates/libmwemu/src/tests/peb_teb_ldr_structures_test.rs index bfbba7d5..0d06f9cd 100644 --- a/crates/libmwemu/src/tests/peb_teb_ldr_structures_test.rs +++ b/crates/libmwemu/src/tests/peb_teb_ldr_structures_test.rs @@ -26,14 +26,22 @@ pub fn peb_teb_ldr_structures_test() { let teb_struct = structures::TEB::load(teb_addr, &mut emu.maps); let ldr_struct = structures::PebLdrData::load(ldr_addr, &mut emu.maps); - - assert_eq!(ldr_struct.in_load_order_module_list.flink, ldr_struct.in_memory_order_module_list.flink - 0x8); - assert_eq!(ldr_struct.in_initialization_order_module_list.flink, ldr_struct.in_memory_order_module_list.flink + 0x8); + assert_eq!( + ldr_struct.in_load_order_module_list.flink, + ldr_struct.in_memory_order_module_list.flink - 0x8 + ); + assert_eq!( + ldr_struct.in_initialization_order_module_list.flink, + ldr_struct.in_memory_order_module_list.flink + 0x8 + ); assert_eq!(ldr_addr, peb_struct.ldr as u64); - let mut ldr_entry = structures::LdrDataTableEntry::load(ldr_struct.in_load_order_module_list.flink as u64, &mut emu.maps); + let mut ldr_entry = structures::LdrDataTableEntry::load( + ldr_struct.in_load_order_module_list.flink as u64, + &mut emu.maps, + ); let ntdll_addr = emu.maps.get_mem("ntdll.pe").get_base(); - + assert_eq!(peb_struct.image_base_addr, ntdll_addr as u32); assert_eq!(peb_struct.ldr, ldr_addr as u32); assert_eq!(peb_struct.being_debugged, 0); @@ -44,18 +52,29 @@ pub fn peb_teb_ldr_structures_test() { assert_eq!(teb_struct.process_environment_block, peb_addr as u32); assert_eq!(teb_struct.last_error_value, 0); //assert!(teb_struct.environment_pointer > 0); - + let main_pe_w = emu.maps.get_addr_name(ldr_entry.dll_base as u64); assert!(main_pe_w.is_some()); let main_pe = main_pe_w.unwrap(); assert_eq!(main_pe, "exe32win_minecraft.pe"); - - assert_eq!(ldr_entry.in_memory_order_links.flink, ldr_entry.in_load_order_links.flink + 0x8); - assert_eq!(ldr_entry.in_initialization_order_links.flink, ldr_entry.in_memory_order_links.flink + 0x8); - - assert_eq!(ldr_entry.in_memory_order_links.blink, ldr_entry.in_load_order_links.blink + 0x8); - assert_eq!(ldr_entry.in_initialization_order_links.blink, ldr_entry.in_memory_order_links.blink + 0x8); + assert_eq!( + ldr_entry.in_memory_order_links.flink, + ldr_entry.in_load_order_links.flink + 0x8 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.flink, + ldr_entry.in_memory_order_links.flink + 0x8 + ); + + assert_eq!( + ldr_entry.in_memory_order_links.blink, + ldr_entry.in_load_order_links.blink + 0x8 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.blink, + ldr_entry.in_memory_order_links.blink + 0x8 + ); let sample_w = emu.maps.get_addr_name(ldr_entry.dll_base as u64); assert!(sample_w.is_some()); @@ -63,13 +82,28 @@ pub fn peb_teb_ldr_structures_test() { assert_eq!(sample, "exe32win_minecraft.pe"); // follow to next flink - ldr_entry = structures::LdrDataTableEntry::load(ldr_entry.in_load_order_links.flink as u64, &mut emu.maps); - - assert_eq!(ldr_entry.in_memory_order_links.flink, ldr_entry.in_load_order_links.flink + 0x8); - assert_eq!(ldr_entry.in_initialization_order_links.flink, ldr_entry.in_memory_order_links.flink + 0x8); - - assert_eq!(ldr_entry.in_memory_order_links.blink, ldr_entry.in_load_order_links.blink + 0x8); - assert_eq!(ldr_entry.in_initialization_order_links.blink, ldr_entry.in_memory_order_links.blink + 0x8); + ldr_entry = structures::LdrDataTableEntry::load( + ldr_entry.in_load_order_links.flink as u64, + &mut emu.maps, + ); + + assert_eq!( + ldr_entry.in_memory_order_links.flink, + ldr_entry.in_load_order_links.flink + 0x8 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.flink, + ldr_entry.in_memory_order_links.flink + 0x8 + ); + + assert_eq!( + ldr_entry.in_memory_order_links.blink, + ldr_entry.in_load_order_links.blink + 0x8 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.blink, + ldr_entry.in_memory_order_links.blink + 0x8 + ); let sample_w = emu.maps.get_addr_name(ldr_entry.dll_base as u64); assert!(sample_w.is_some()); @@ -107,7 +141,6 @@ pub fn peb_teb_ldr_structures_test() { assert!(ldr_addr > 0x1000); assert!(emu.maps.is_allocated(ldr_addr)); - let peb_struct = structures::PEB64::load(peb_addr, &mut emu.maps); let teb_struct = structures::TEB64::load(teb_addr, &mut emu.maps); @@ -128,14 +161,24 @@ pub fn peb_teb_ldr_structures_test() { let mut ldr_entry = structures::LdrDataTableEntry64::load(entry_addr, &mut emu.maps); //let ntdll_addr = emu.maps.get_mem("ntdll.pe").get_base(); - - - assert_eq!(ldr_entry.in_memory_order_links.flink, ldr_entry.in_load_order_links.flink + 0x10); - assert_eq!(ldr_entry.in_initialization_order_links.flink, ldr_entry.in_memory_order_links.flink + 0x10); - - assert_eq!(ldr_entry.in_memory_order_links.blink, ldr_entry.in_load_order_links.blink + 0x10); - assert_eq!(ldr_entry.in_initialization_order_links.blink, ldr_entry.in_memory_order_links.blink + 0x10); + assert_eq!( + ldr_entry.in_memory_order_links.flink, + ldr_entry.in_load_order_links.flink + 0x10 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.flink, + ldr_entry.in_memory_order_links.flink + 0x10 + ); + + assert_eq!( + ldr_entry.in_memory_order_links.blink, + ldr_entry.in_load_order_links.blink + 0x10 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.blink, + ldr_entry.in_memory_order_links.blink + 0x10 + ); let sample_w = emu.maps.get_addr_name(ldr_entry.dll_base); assert!(sample_w.is_some()); @@ -143,13 +186,26 @@ pub fn peb_teb_ldr_structures_test() { assert_eq!(sample, "exe64win_msgbox.pe"); // follow to next flink - ldr_entry = structures::LdrDataTableEntry64::load(ldr_entry.in_load_order_links.flink, &mut emu.maps); - - assert_eq!(ldr_entry.in_memory_order_links.flink, ldr_entry.in_load_order_links.flink + 0x10); - assert_eq!(ldr_entry.in_initialization_order_links.flink, ldr_entry.in_memory_order_links.flink + 0x10); - - assert_eq!(ldr_entry.in_memory_order_links.blink, ldr_entry.in_load_order_links.blink + 0x10); - assert_eq!(ldr_entry.in_initialization_order_links.blink, ldr_entry.in_memory_order_links.blink + 0x10); + ldr_entry = + structures::LdrDataTableEntry64::load(ldr_entry.in_load_order_links.flink, &mut emu.maps); + + assert_eq!( + ldr_entry.in_memory_order_links.flink, + ldr_entry.in_load_order_links.flink + 0x10 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.flink, + ldr_entry.in_memory_order_links.flink + 0x10 + ); + + assert_eq!( + ldr_entry.in_memory_order_links.blink, + ldr_entry.in_load_order_links.blink + 0x10 + ); + assert_eq!( + ldr_entry.in_initialization_order_links.blink, + ldr_entry.in_memory_order_links.blink + 0x10 + ); let sample_w = emu.maps.get_addr_name(ldr_entry.dll_base); assert!(sample_w.is_some()); diff --git a/crates/libmwemu/src/tests/pure_rust_check.rs b/crates/libmwemu/src/tests/pure_rust_check.rs index 0843d34f..ae8fd17a 100644 --- a/crates/libmwemu/src/tests/pure_rust_check.rs +++ b/crates/libmwemu/src/tests/pure_rust_check.rs @@ -11,7 +11,7 @@ pub fn pure_rust_check() { let out = output.unwrap(); let stdout = String::from_utf8(out.stdout); - + assert!(stdout.is_ok()); // not utf8 errors let stoud2 = stdout.unwrap(); diff --git a/crates/libmwemu/src/tests/regsisters_test.rs b/crates/libmwemu/src/tests/regsisters_test.rs index 810141ad..0e36873c 100644 --- a/crates/libmwemu/src/tests/regsisters_test.rs +++ b/crates/libmwemu/src/tests/regsisters_test.rs @@ -80,10 +80,9 @@ pub fn regsisters_test() { // ====== 5. YMM ====== let ymm_val = U256::from_big_endian(&[ - 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, - 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, - 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, - 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, 0x11, 0x00, + 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, + 0xFF, 0xFF, 0xEE, 0xDD, 0xCC, 0xBB, 0xAA, 0x99, 0x88, 0x77, 0x66, 0x55, 0x44, 0x33, 0x22, + 0x11, 0x00, ]); assert!(regs.is_ymm(Register::YMM1)); regs.set_ymm_reg(Register::YMM1, ymm_val); @@ -120,5 +119,4 @@ pub fn regsisters_test() { assert_eq!(regs.rax, 0); assert_eq!(regs.rbx, 0); assert_eq!(regs.rcx, 0); - -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/sc32lin_rshell.rs b/crates/libmwemu/src/tests/sc32lin_rshell.rs index 3e497a62..5af50445 100644 --- a/crates/libmwemu/src/tests/sc32lin_rshell.rs +++ b/crates/libmwemu/src/tests/sc32lin_rshell.rs @@ -7,14 +7,16 @@ pub fn sc32lin_rshell() { let mut emu = emu32(); emu.cfg.maps_folder = "../../maps/maps32/".to_string(); - let sample = "../../test/sc32lin_rshell.bin"; emu.load_code(sample); emu.run_to(31); let sockaddr = emu.maps.read_bytes(emu.regs().get_ecx(), 9); - assert_eq!(sockaddr, [0x02,0x00,0x05,0x39,0x01,0x03,0x03,0x07,0x01]); + assert_eq!( + sockaddr, + [0x02, 0x00, 0x05, 0x39, 0x01, 0x03, 0x03, 0x07, 0x01] + ); emu.run_to(42); assert_eq!(emu.maps.read_string(emu.regs().get_ebx()), "//bin/sh"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/sc32win_donut.rs b/crates/libmwemu/src/tests/sc32win_donut.rs index 63986b7f..d7a616c5 100644 --- a/crates/libmwemu/src/tests/sc32win_donut.rs +++ b/crates/libmwemu/src/tests/sc32win_donut.rs @@ -8,7 +8,6 @@ pub fn sc32win_donut() { let mut emu = emu32(); emu.cfg.maps_folder = "../../maps/maps32/".to_string(); - let sample = "../../test/sc32win_donut.bin"; emu.load_code(sample); diff --git a/crates/libmwemu/src/tests/sc32win_peb_ldr_rot.rs b/crates/libmwemu/src/tests/sc32win_peb_ldr_rot.rs index 1119e901..0c8131fa 100644 --- a/crates/libmwemu/src/tests/sc32win_peb_ldr_rot.rs +++ b/crates/libmwemu/src/tests/sc32win_peb_ldr_rot.rs @@ -17,4 +17,4 @@ pub fn sc32win_peb_ldr_rot() { assert_eq!(ptr, 0x3c01b8); let s: String = emu.maps.read_string(ptr); assert!(s.starts_with("Host: msn.com")); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/sc32win_veryobfus.rs b/crates/libmwemu/src/tests/sc32win_veryobfus.rs index 42dcb4c5..de905886 100644 --- a/crates/libmwemu/src/tests/sc32win_veryobfus.rs +++ b/crates/libmwemu/src/tests/sc32win_veryobfus.rs @@ -23,9 +23,9 @@ pub fn sc32win_veryobfus() { let name = match emu.maps.get_addr_name(eax) { Some(n) => n, None => { - return assert_eq!(1,2); + return assert_eq!(1, 2); } }; assert_eq!(name, "ntdll.text"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/sc64lin_arith_100iter.rs b/crates/libmwemu/src/tests/sc64lin_arith_100iter.rs index 4a2257f3..31fd0a15 100644 --- a/crates/libmwemu/src/tests/sc64lin_arith_100iter.rs +++ b/crates/libmwemu/src/tests/sc64lin_arith_100iter.rs @@ -7,11 +7,10 @@ pub fn sc64lin_arith_100iter() { let mut emu = emu64(); emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - let sample = "../../test/sc64lin_arith_100iter.bin"; emu.load_code(sample); emu.run(Some(0x3c0040)); assert_eq!(emu.regs().rax, 0x4d9364d94bc0001e); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/sc64win_metasploit.rs b/crates/libmwemu/src/tests/sc64win_metasploit.rs index 3ecfa14b..62891c23 100644 --- a/crates/libmwemu/src/tests/sc64win_metasploit.rs +++ b/crates/libmwemu/src/tests/sc64win_metasploit.rs @@ -25,5 +25,5 @@ pub fn sc64win_metasploit() { let sockaddr_ptr = emu.maps.read_qword(stack + 8).unwrap(); let sockaddr = emu.maps.read_qword(sockaddr_ptr).unwrap(); - assert_eq!(sockaddr, 0x12c190a5c110002); -} \ No newline at end of file + assert_eq!(sockaddr, 0x12c190a5c110002); +} diff --git a/crates/libmwemu/src/tests/shl2p8_bug_trigger.rs b/crates/libmwemu/src/tests/shl2p8_bug_trigger.rs index a256f21a..42b37dcc 100644 --- a/crates/libmwemu/src/tests/shl2p8_bug_trigger.rs +++ b/crates/libmwemu/src/tests/shl2p8_bug_trigger.rs @@ -1,11 +1,11 @@ use crate::*; - #[test] - pub fn shl2p8_bug_trigger() { - let mut emu = emu64(); +#[test] +pub fn shl2p8_bug_trigger() { + let mut emu = emu64(); - let value0 = 0x44; - let value1 = 0x0c; - let result = emu.flags_mut().shl2p8(value0, value1); - assert_eq!(result, 0); - } \ No newline at end of file + let value0 = 0x44; + let value1 = 0x0c; + let result = emu.flags_mut().shl2p8(value0, value1); + assert_eq!(result, 0); +} diff --git a/crates/libmwemu/src/tests/shl2p8_edge_cases_should_not_panic.rs b/crates/libmwemu/src/tests/shl2p8_edge_cases_should_not_panic.rs index e43102b1..3a3c1c9c 100644 --- a/crates/libmwemu/src/tests/shl2p8_edge_cases_should_not_panic.rs +++ b/crates/libmwemu/src/tests/shl2p8_edge_cases_should_not_panic.rs @@ -1,22 +1,22 @@ use crate::*; - #[test] - pub fn shl2p8_edge_cases_should_not_panic() { - let mut emu = emu64(); +#[test] +pub fn shl2p8_edge_cases_should_not_panic() { + let mut emu = emu64(); - let test_cases: &[(u64, u64)] = &[ - (0x01, 0), // count = 0 - (0x01, 1), // normal shift - (0x80, 7), // MSB gets shifted out - (0x01, 8), // count == width - (0x01, 9), // count > width - (0xff, 255), // extreme value - ]; + let test_cases: &[(u64, u64)] = &[ + (0x01, 0), // count = 0 + (0x01, 1), // normal shift + (0x80, 7), // MSB gets shifted out + (0x01, 8), // count == width + (0x01, 9), // count > width + (0xff, 255), // extreme value + ]; - for &(value, count) in test_cases { - let _ = emu.flags_mut().shl2p8(value, count); // no panic expected - } + for &(value, count) in test_cases { + let _ = emu.flags_mut().shl2p8(value, count); // no panic expected + } - emu.flags_mut().shl2p8(0xf6, 1); - emu.flags_mut().shl2p8(0x44, 0xc); - } \ No newline at end of file + emu.flags_mut().shl2p8(0xf6, 1); + emu.flags_mut().shl2p8(0x44, 0xc); +} diff --git a/crates/libmwemu/src/tests/should_serialize.rs b/crates/libmwemu/src/tests/should_serialize.rs index b372dcb4..bd799c80 100644 --- a/crates/libmwemu/src/tests/should_serialize.rs +++ b/crates/libmwemu/src/tests/should_serialize.rs @@ -5,16 +5,14 @@ use crate::{serialization::Serialization, tests::helpers, *}; pub fn should_serialize() { helpers::setup(); - let handle = std::thread::Builder::new() + let handle = std::thread::Builder::new() .stack_size(1024 * 29055) .spawn(|| { - // init let mut emu = emu64(); // load maps emu.cfg.maps_folder = "../../maps/maps64/".to_string(); - // load binary emu.load_code("../../test/exe64win_msgbox.bin"); @@ -29,8 +27,8 @@ pub fn should_serialize() { let emu: Emu = Serialization::deserialize(&serialized); // assert assert_eq!(emu.regs().rdx, 0x1); - - }).unwrap(); + }) + .unwrap(); handle.join().unwrap(); } diff --git a/crates/libmwemu/src/tests/stack32_test.rs b/crates/libmwemu/src/tests/stack32_test.rs index d551d80d..6cdab06d 100644 --- a/crates/libmwemu/src/tests/stack32_test.rs +++ b/crates/libmwemu/src/tests/stack32_test.rs @@ -8,7 +8,7 @@ pub fn stack32_test() { let mut emu = emu32(); emu.cfg.maps_folder = "../../maps/maps32/".to_string(); emu.init(false, false); - + let stack_check = emu.maps.get_map_by_name("stack"); assert!(stack_check.is_some()); let stack = stack_check.unwrap(); @@ -28,4 +28,4 @@ pub fn stack32_test() { emu.stack_pop32(false); assert!(emu.regs().get_esp() > base); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/stress_sar2p_all.rs b/crates/libmwemu/src/tests/stress_sar2p_all.rs index 524c70b5..908f9417 100644 --- a/crates/libmwemu/src/tests/stress_sar2p_all.rs +++ b/crates/libmwemu/src/tests/stress_sar2p_all.rs @@ -1,4 +1,7 @@ -use crate::{tests::helpers::{self, critical_values, shift_counts}, *}; +use crate::{ + tests::helpers::{self, critical_values, shift_counts}, + *, +}; #[test] pub fn stress_sar2p_all() { @@ -28,4 +31,4 @@ pub fn stress_sar2p_all() { emu.flags_mut().sar2p64(value, shift); } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/stress_shl1p_all.rs b/crates/libmwemu/src/tests/stress_shl1p_all.rs index 710aac9c..9a37f52e 100644 --- a/crates/libmwemu/src/tests/stress_shl1p_all.rs +++ b/crates/libmwemu/src/tests/stress_shl1p_all.rs @@ -1,4 +1,7 @@ -use crate::{tests::helpers::{self, critical_values}, *}; +use crate::{ + tests::helpers::{self, critical_values}, + *, +}; #[test] pub fn stress_shl1p_all() { diff --git a/crates/libmwemu/src/tests/stress_shl2p_all.rs b/crates/libmwemu/src/tests/stress_shl2p_all.rs index bd23d588..be0686f7 100644 --- a/crates/libmwemu/src/tests/stress_shl2p_all.rs +++ b/crates/libmwemu/src/tests/stress_shl2p_all.rs @@ -1,4 +1,7 @@ -use crate::{tests::helpers::{self, critical_values, shift_counts}, *}; +use crate::{ + tests::helpers::{self, critical_values, shift_counts}, + *, +}; #[test] pub fn stress_shl2p_all() { @@ -22,4 +25,4 @@ pub fn stress_shl2p_all() { emu.flags_mut().shl2p64(value, shift); } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/stress_shl2p_trigger.rs b/crates/libmwemu/src/tests/stress_shl2p_trigger.rs index 50273ac6..47e85c18 100644 --- a/crates/libmwemu/src/tests/stress_shl2p_trigger.rs +++ b/crates/libmwemu/src/tests/stress_shl2p_trigger.rs @@ -1,19 +1,16 @@ use crate::*; - #[test] - pub fn stress_shl2p_trigger() { - let mut emu = emu64(); +#[test] +pub fn stress_shl2p_trigger() { + let mut emu = emu64(); - let test_values = [ - 0x00, 0x01, 0x7F, 0x80, 0xFF, - 0x44 - ]; - let shift_counts = [0, 1, 7, 8, 15, 31, 63, 127, 255, 0x0C]; + let test_values = [0x00, 0x01, 0x7F, 0x80, 0xFF, 0x44]; + let shift_counts = [0, 1, 7, 8, 15, 31, 63, 127, 255, 0x0C]; - for &v0 in &test_values { - for &v1 in &shift_counts { - emu.flags_mut().shl2p8(v0, v1); - } + for &v0 in &test_values { + for &v1 in &shift_counts { + emu.flags_mut().shl2p8(v0, v1); } - assert!(true); - } \ No newline at end of file + } + assert!(true); +} diff --git a/crates/libmwemu/src/tests/stress_shr2p_all.rs b/crates/libmwemu/src/tests/stress_shr2p_all.rs index c696d11c..b3f6682b 100644 --- a/crates/libmwemu/src/tests/stress_shr2p_all.rs +++ b/crates/libmwemu/src/tests/stress_shr2p_all.rs @@ -1,4 +1,7 @@ -use crate::{tests::helpers::{self, critical_values, shift_counts}, *}; +use crate::{ + tests::helpers::{self, critical_values, shift_counts}, + *, +}; #[test] pub fn stress_shr2p_all() { @@ -28,4 +31,4 @@ pub fn stress_shr2p_all() { emu.flags_mut().shr2p64(value, shift); } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tests/test_unified_step_and_run_methods.rs b/crates/libmwemu/src/tests/test_unified_step_and_run_methods.rs index 9ac8ab43..1d3892ee 100644 --- a/crates/libmwemu/src/tests/test_unified_step_and_run_methods.rs +++ b/crates/libmwemu/src/tests/test_unified_step_and_run_methods.rs @@ -1,49 +1,65 @@ +use crate::maps::mem64::Permission; use crate::{tests::helpers, *}; #[test] pub fn test_unified_step_and_run_methods() { helpers::setup(); - + // Test 1: Single-threaded mode (default) let mut emu = emu64(); - assert_eq!(emu.is_threading_enabled(), false, "Threading should be disabled by default"); - + assert_eq!( + emu.is_threading_enabled(), + false, + "Threading should be disabled by default" + ); + // Load some simple code - NOP instructions let code = vec![0x90, 0x90, 0x90]; // 3 NOP instructions - emu.maps.create_map("code", 0x1000, 0x1000); + emu.maps + .create_map("code", 0x1000, 0x1000, Permission::READ_WRITE_EXECUTE); emu.maps.write_bytes(0x1000, code); emu.regs_mut().rip = 0x1000; - + // Test step() in single-threaded mode let result = emu.step(); assert!(result, "Step should succeed in single-threaded mode"); assert_eq!(emu.regs().rip, 0x1001, "RIP should advance after NOP"); - + // Test 2: Enable threading and verify it's set emu.enable_threading(true); - assert_eq!(emu.is_threading_enabled(), true, "Threading should be enabled"); - + assert_eq!( + emu.is_threading_enabled(), + true, + "Threading should be enabled" + ); + // Step again with threading enabled (but still only 1 thread) let result = emu.step(); assert!(result, "Step should succeed with threading enabled"); - assert_eq!(emu.regs().rip, 0x1002, "RIP should advance after second NOP"); - + assert_eq!( + emu.regs().rip, + 0x1002, + "RIP should advance after second NOP" + ); + // Test 3: Verify run() method works let mut emu2 = emu32(); - emu2.maps.create_map("code", 0x1000, 0x1000); + emu2.maps + .create_map("code", 0x1000, 0x1000, Permission::READ_WRITE_EXECUTE); let code32 = vec![0x90, 0x90, 0xC3]; // 2 NOPs and RET emu2.maps.write_bytes(0x1000, code32); emu2.regs_mut().set_eip(0x1000); - + // Create a minimal stack for the RET instruction - emu2.maps.create_map("stack", 0x2000, 0x1000); + emu2.maps + .create_map("stack", 0x2000, 0x1000, Permission::READ_WRITE); emu2.regs_mut().set_esp(0x2500); emu2.maps.write_dword(0x2500, 0x3000); // Return address - + // Run until RET let result = emu2.run(Some(0x1002)); assert!(result.is_ok(), "Run should succeed"); - + // Test 4: Verify threading can be toggled let mut cfg = Config::new(); cfg.enable_threading = false; diff --git a/crates/libmwemu/src/thread_context.rs b/crates/libmwemu/src/thread_context.rs index 78437a53..95af7f0e 100644 --- a/crates/libmwemu/src/thread_context.rs +++ b/crates/libmwemu/src/thread_context.rs @@ -4,10 +4,10 @@ use crate::{eflags::Eflags, flags::Flags, fpu::FPU, regs64::Regs64}; #[derive(Clone)] pub struct ThreadContext { - pub id: u64, // Thread ID (e.g., 0x1000, 0x1001, etc.) - pub suspended: bool, // Whether thread is suspended - pub wake_tick: usize, // Global tick when thread can next run (0 = runnable) - pub blocked_on_cs: Option, // Pointer to critical section if blocked + pub id: u64, // Thread ID (e.g., 0x1000, 0x1001, etc.) + pub suspended: bool, // Whether thread is suspended + pub wake_tick: usize, // Global tick when thread can next run (0 = runnable) + pub blocked_on_cs: Option, // Pointer to critical section if blocked pub regs: Regs64, pub pre_op_regs: Regs64, pub post_op_regs: Regs64, @@ -24,7 +24,7 @@ pub struct ThreadContext { pub tls64: Vec, pub fls: Vec, pub fs: BTreeMap, - pub call_stack: Vec, + pub call_stack: Vec<(u64, u64)>, } impl ThreadContext { @@ -32,7 +32,7 @@ impl ThreadContext { ThreadContext { id, suspended: false, - wake_tick: 0, // 0 means runnable + wake_tick: 0, // 0 means runnable blocked_on_cs: None, regs: Regs64::new(), pre_op_regs: Regs64::new(), @@ -50,7 +50,7 @@ impl ThreadContext { tls64: Vec::new(), fls: Vec::new(), fs: BTreeMap::new(), - call_stack: Vec::new(), + call_stack: Vec::with_capacity(10000), } } } diff --git a/crates/libmwemu/src/threading.rs b/crates/libmwemu/src/threading.rs index 3d416de2..111918fc 100644 --- a/crates/libmwemu/src/threading.rs +++ b/crates/libmwemu/src/threading.rs @@ -17,12 +17,12 @@ impl ThreadScheduler { let current_tick = emu.tick; let current_thread_id = emu.current_thread_id; - + // Round-robin: always try to switch to the next thread // This ensures fair scheduling - each thread gets one instruction for i in 1..=emu.threads.len() { let thread_idx = (current_thread_id + i) % emu.threads.len(); - + // Skip back to current thread only if no other threads are runnable if thread_idx == current_thread_id { // We've checked all other threads, none are runnable @@ -33,7 +33,7 @@ impl ThreadScheduler { // Current thread also can't run break; } - + if Self::is_thread_runnable(emu, thread_idx) { // Found a runnable thread - switch to it /*log::debug!( @@ -47,51 +47,49 @@ impl ThreadScheduler { emu.threads[current_thread_id].regs.rip, emu.threads[thread_idx].regs.rip );*/ - + Self::switch_to_thread(emu, thread_idx); return true; } } - + // No threads are runnable (including current) // Try to advance time if threads are just sleeping if Self::advance_to_next_wake(emu) { // Recursively try scheduling again after time advance return Self::schedule_next_thread(emu); } - + // All threads are permanently blocked Self::log_thread_states(emu); log::error!("⚠️ All threads blocked or suspended - deadlock detected"); - + false } - + /// Check if a specific thread is runnable fn is_thread_runnable(emu: &Emu, thread_idx: usize) -> bool { if thread_idx >= emu.threads.len() { return false; } - + let thread = &emu.threads[thread_idx]; - !thread.suspended - && thread.wake_tick <= emu.tick - && thread.blocked_on_cs.is_none() + !thread.suspended && thread.wake_tick <= emu.tick && thread.blocked_on_cs.is_none() } - + /// Advance emulator tick to the next thread wake time /// Returns true if time was advanced, false if no threads are waiting fn advance_to_next_wake(emu: &mut Emu) -> bool { let current_tick = emu.tick; let mut next_wake = usize::MAX; - + // Find the earliest wake time among suspended threads for thread in &emu.threads { if !thread.suspended && thread.wake_tick > current_tick { next_wake = next_wake.min(thread.wake_tick); } } - + if next_wake != usize::MAX && next_wake > current_tick { log::info!( "⏰ Advancing tick from {} to {} (all threads sleeping)", @@ -101,17 +99,21 @@ impl ThreadScheduler { emu.tick = next_wake; return true; } - + false } - + /// Log the current state of all threads for debugging pub fn log_thread_states(emu: &Emu) { log::info!("=== Thread States ==="); for (i, thread) in emu.threads.iter().enumerate() { let status = Self::get_thread_status_string(emu, i); - let marker = if i == emu.current_thread_id { ">>>" } else { " " }; - + let marker = if i == emu.current_thread_id { + ">>>" + } else { + " " + }; + log::info!( "{} Thread[{}]: ID=0x{:x}, RIP=0x{:x}, Status={}", marker, @@ -123,11 +125,11 @@ impl ThreadScheduler { } log::info!("Current tick: {}", emu.tick); } - + /// Get a human-readable status string for a thread fn get_thread_status_string(emu: &Emu, thread_idx: usize) -> String { let thread = &emu.threads[thread_idx]; - + if thread.suspended { "SUSPENDED".to_string() } else if thread.wake_tick > emu.tick { @@ -138,39 +140,39 @@ impl ThreadScheduler { "RUNNABLE".to_string() } } - + /// Switch execution context to a different thread pub fn switch_to_thread(emu: &mut Emu, thread_id: usize) -> bool { if thread_id >= emu.threads.len() { log::error!("Invalid thread ID: {}", thread_id); return false; } - + if thread_id == emu.current_thread_id { return true; // Already on this thread } - + // Save current thread's FPU state emu.threads[emu.current_thread_id].fpu = emu.fpu().clone(); - + // Switch to new thread emu.current_thread_id = thread_id; - + // Restore new thread's FPU state *emu.fpu_mut() = emu.threads[thread_id].fpu.clone(); - + // Don't set force_reload - we want the thread to continue from its current position // force_reload would prevent IP advancement which causes instructions to execute twice - + /*log::trace!( "Switched to thread {} (ID: 0x{:x})", thread_id, emu.threads[thread_id].id );*/ - + true } - + /// Execute a single instruction for a specific thread /// This consolidates the duplicated logic from step_thread pub fn execute_thread_instruction(emu: &mut Emu, thread_id: usize) -> bool { @@ -180,9 +182,9 @@ impl ThreadScheduler { return false; } } - + let rip = emu.regs().rip; - + // Check if RIP points to valid memory let code = match emu.maps.get_mem_by_addr(rip) { Some(c) => c, @@ -197,7 +199,7 @@ impl ThreadScheduler { return false; } }; - + // Read and decode instruction let block = code.read_from(rip).to_vec(); let ins = if emu.cfg.is_64bits { @@ -206,7 +208,7 @@ impl ThreadScheduler { let eip = emu.regs().get_eip(); iced_x86::Decoder::with_ip(32, &block, eip, iced_x86::DecoderOptions::NONE).decode() }; - + let sz = ins.len(); let position = if emu.cfg.is_64bits { iced_x86::Decoder::with_ip(64, &block, rip, iced_x86::DecoderOptions::NONE).position() @@ -214,12 +216,12 @@ impl ThreadScheduler { let eip = emu.regs().get_eip(); iced_x86::Decoder::with_ip(32, &block, eip, iced_x86::DecoderOptions::NONE).position() }; - + // Prepare for execution emu.memory_operations.clear(); emu.instruction = Some(ins); emu.decoder_position = position; - + // Pre-instruction hook if let Some(hook_fn) = emu.hooks.hook_on_pre_instruction { if !hook_fn(emu, rip, &ins, sz) { @@ -227,24 +229,24 @@ impl ThreadScheduler { return true; } } - + // Execute the instruction let result_ok = crate::engine::emulate_instruction(emu, &ins, sz, true); emu.last_instruction_size = sz; - + // Post-instruction hook if let Some(hook_fn) = emu.hooks.hook_on_post_instruction { let instruction = emu.instruction.take().unwrap(); hook_fn(emu, rip, &instruction, sz, result_ok); emu.instruction = Some(instruction); } - + // Advance instruction pointer Self::advance_ip(emu, sz); - + result_ok } - + /// Advance the instruction pointer by the given size /// Handles both 32-bit and 64-bit modes, and respects force_reload flag pub fn advance_ip(emu: &mut Emu, sz: usize) { @@ -261,18 +263,18 @@ impl ThreadScheduler { emu.regs_mut().set_eip(eip); } } - + /// Main thread scheduling step - replaces the complex logic in step() pub fn step_with_scheduling(emu: &mut Emu) -> bool { emu.pos += 1; - + // Check exit condition if emu.cfg.exit_position != 0 && emu.pos == emu.cfg.exit_position { log::info!("Exit position reached"); Self::handle_exit(emu); return false; } - + // If only one thread, execute it directly if emu.threads.len() == 1 { if Self::is_thread_runnable(emu, 0) { @@ -282,36 +284,40 @@ impl ThreadScheduler { return false; } } - + // Multi-threaded execution with scheduling - + // First, try to continue with current thread if it's still runnable if Self::is_thread_runnable(emu, emu.current_thread_id) { // Give current thread another timeslice return Self::execute_thread_instruction(emu, emu.current_thread_id); } - + // Current thread can't run, find another for i in 1..emu.threads.len() { let thread_idx = (emu.current_thread_id + i) % emu.threads.len(); if Self::is_thread_runnable(emu, thread_idx) { - log::debug!("Switching from thread {} to {}", emu.current_thread_id, thread_idx); + log::debug!( + "Switching from thread {} to {}", + emu.current_thread_id, + thread_idx + ); return Self::execute_thread_instruction(emu, thread_idx); } } - + // No threads are immediately runnable - try advancing time if Self::advance_to_next_wake(emu) { // Time advanced, try again return Self::step_with_scheduling(emu); } - + // All threads are blocked Self::log_thread_states(emu); log::error!("All threads are blocked or suspended"); false } - + /// Handle emulator exit fn handle_exit(emu: &mut Emu) { if emu.cfg.dump_on_exit && emu.cfg.dump_filename.is_some() { @@ -320,7 +326,7 @@ impl ThreadScheduler { emu.cfg.dump_filename.as_ref().unwrap(), ); } - + if emu.cfg.trace_regs && emu.cfg.trace_filename.is_some() { emu.trace_file .as_ref() @@ -329,5 +335,4 @@ impl ThreadScheduler { .expect("failed to flush trace file"); } } - -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/tracing.rs b/crates/libmwemu/src/tracing.rs index 5b8a4065..1a926c38 100644 --- a/crates/libmwemu/src/tracing.rs +++ b/crates/libmwemu/src/tracing.rs @@ -13,26 +13,26 @@ use crate::emu::Emu; #[repr(C, packed)] #[derive(Copy, Clone)] pub struct TraceRecord { - pub instruction_count: u64, // 8 bytes - pub rip: u64, // 8 bytes - pub rflags: u64, // 8 bytes - pub rax: u64, // 8 bytes - pub rbx: u64, // 8 bytes - pub rcx: u64, // 8 bytes - pub rdx: u64, // 8 bytes - pub rsi: u64, // 8 bytes - pub rdi: u64, // 8 bytes - pub rbp: u64, // 8 bytes - pub rsp: u64, // 8 bytes - pub r8: u64, // 8 bytes - pub r9: u64, // 8 bytes - pub r10: u64, // 8 bytes - pub r11: u64, // 8 bytes - pub r12: u64, // 8 bytes - pub r13: u64, // 8 bytes - pub r14: u64, // 8 bytes - pub r15: u64, // 8 bytes - // Total: 152 bytes + pub instruction_count: u64, // 8 bytes + pub rip: u64, // 8 bytes + pub rflags: u64, // 8 bytes + pub rax: u64, // 8 bytes + pub rbx: u64, // 8 bytes + pub rcx: u64, // 8 bytes + pub rdx: u64, // 8 bytes + pub rsi: u64, // 8 bytes + pub rdi: u64, // 8 bytes + pub rbp: u64, // 8 bytes + pub rsp: u64, // 8 bytes + pub r8: u64, // 8 bytes + pub r9: u64, // 8 bytes + pub r10: u64, // 8 bytes + pub r11: u64, // 8 bytes + pub r12: u64, // 8 bytes + pub r13: u64, // 8 bytes + pub r14: u64, // 8 bytes + pub r15: u64, // 8 bytes + // Total: 152 bytes } impl TraceRecord { @@ -64,7 +64,7 @@ impl TraceRecord { unsafe { std::slice::from_raw_parts( self as *const Self as *const u8, - std::mem::size_of::() + std::mem::size_of::(), ) } } @@ -74,18 +74,18 @@ impl TraceRecord { thread_local! { // The actual writer - None if tracing is disabled static TRACE_WRITER: UnsafeCell>> = UnsafeCell::new(None); - + // Counter for periodic flushing static TRACE_RECORDS_WRITTEN: UnsafeCell = UnsafeCell::new(0); - + // Reusable buffer for the trace record to avoid allocations static TRACE_RECORD_BUFFER: UnsafeCell = UnsafeCell::new(unsafe { std::mem::zeroed() }); - + // Start time for IPS calculations static TRACE_START_TIME: UnsafeCell> = UnsafeCell::new(None); - + // Last IPS log time and count for rate limiting logs - static LAST_IPS_LOG: UnsafeCell<(Instant, u64)> = UnsafeCell::new(unsafe { + static LAST_IPS_LOG: UnsafeCell<(Instant, u64)> = UnsafeCell::new(unsafe { (std::mem::zeroed(), 0) }); } @@ -94,21 +94,21 @@ pub fn init_tracing(path: impl AsRef) -> std::io::Result<()> { let file = File::create(path)?; // 16MB buffer for maximum efficiency let writer = BufWriter::with_capacity(16 * 1024 * 1024, file); - + TRACE_WRITER.with(|w| unsafe { *w.get() = Some(writer); }); - + // Initialize start time TRACE_START_TIME.with(|t| unsafe { *t.get() = Some(Instant::now()); }); - + // Initialize last IPS log LAST_IPS_LOG.with(|l| unsafe { *l.get() = (Instant::now(), 0); }); - + log::info!("📝 Trace logging initialized"); Ok(()) } @@ -122,19 +122,19 @@ pub fn trace_instruction(emu: &Emu, instruction_count: u64) { TRACE_RECORD_BUFFER.with(|rec_cell| { let record = unsafe { &mut *rec_cell.get() }; *record = TraceRecord::capture(emu, instruction_count); - + // Write the record if let Err(e) = w.write_all(record.as_bytes()) { log::error!("Failed to write trace record: {}", e); return; } }); - + // Update counter and flush periodically TRACE_RECORDS_WRITTEN.with(|count_cell| { let count = unsafe { &mut *count_cell.get() }; *count += 1; - + // Calculate and log IPS every 10M instructions if *count % 10_000_000 == 0 { TRACE_START_TIME.with(|start_cell| { @@ -144,14 +144,18 @@ pub fn trace_instruction(emu: &Emu, instruction_count: u64) { let elapsed_secs = elapsed.as_secs_f64(); if elapsed_secs > 0.0 { let ips = instruction_count as f64 / elapsed_secs; - + // Rate limit IPS logs to once per second LAST_IPS_LOG.with(|last_log_cell| { let (last_time, _) = unsafe { &mut *last_log_cell.get() }; let now = Instant::now(); if now.duration_since(*last_time).as_secs() >= 1 { - log::info!("⚡ IPS: {:.2} ({} instructions in {:.2}s)", - ips, instruction_count, elapsed_secs); + log::info!( + "⚡ IPS: {:.2} ({} instructions in {:.2}s)", + ips, + instruction_count, + elapsed_secs + ); *last_time = now; } }); @@ -159,7 +163,7 @@ pub fn trace_instruction(emu: &Emu, instruction_count: u64) { } }); } - + // Flush every 1M records to avoid losing too much data if we crash if *count % 1_000_000 == 0 { if let Err(e) = w.flush() { diff --git a/crates/libmwemu/src/winapi/mod.rs b/crates/libmwemu/src/winapi/mod.rs index 53fbdb48..2304e705 100644 --- a/crates/libmwemu/src/winapi/mod.rs +++ b/crates/libmwemu/src/winapi/mod.rs @@ -1,3 +1,3 @@ pub mod helper; pub mod winapi32; -pub mod winapi64; \ No newline at end of file +pub mod winapi64; diff --git a/crates/libmwemu/src/winapi/winapi32/advapi32.rs b/crates/libmwemu/src/winapi/winapi32/advapi32.rs index 5923ebf1..4f1c5197 100644 --- a/crates/libmwemu/src/winapi/winapi32/advapi32.rs +++ b/crates/libmwemu/src/winapi/winapi32/advapi32.rs @@ -61,10 +61,7 @@ fn StartServiceCtrlDispatcherA(emu: &mut emu::Emu) { let service_name = emu.maps.read_dword((service_table_entry_ptr+4) as u64) .expect("advapi32!StartServiceCtrlDispatcherA error reading service_name");*/ - log_red!( - emu, - "advapi321!StartServiceCtrlDispatcherA" - ); + log_red!(emu, "advapi321!StartServiceCtrlDispatcherA"); emu.stack_pop32(false); emu.regs_mut().set_eax(1); @@ -76,10 +73,7 @@ fn StartServiceCtrlDispatcherW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("advapi32!StartServiceCtrlDispatcherW error reading service_table_entry pointer"); - log_red!( - emu, - "advapi321!StartServiceCtrlDispatcherW" - ); + log_red!(emu, "advapi321!StartServiceCtrlDispatcherW"); emu.stack_pop32(false); emu.regs_mut().set_eax(1); @@ -268,10 +262,7 @@ fn CryptEncrypt(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 24) .expect("advapi32!CryptEncrypt error reading param") as u64; - log_red!( - emu, - "advapi32!CryptEncrypt" - ); + log_red!(emu, "advapi32!CryptEncrypt"); for _ in 0..7 { emu.stack_pop32(false); @@ -310,10 +301,7 @@ fn CryptDecrypt(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 24) .expect("advapi32!CryptDecrypt error reading param") as u64; - log_red!( - emu, - "advapi32!CryptDecrypt" - ); + log_red!(emu, "advapi32!CryptDecrypt"); for _ in 0..7 { emu.stack_pop32(false); @@ -332,10 +320,7 @@ fn CryptReleaseContext(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("advapi32!CryptReleaseContext error reading param") as u64; - log_red!( - emu, - "advapi32!CryptReleaseContext" - ); + log_red!(emu, "advapi32!CryptReleaseContext"); helper::handler_close(hndl); @@ -434,10 +419,7 @@ fn CryptGetHashParam(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("advapi32!CryptGetHashParam error reading param") as u64; - log_red!( - emu, - "advapi32!CryptGetHashParam" - ); + log_red!(emu, "advapi32!CryptGetHashParam"); for _ in 0..5 { emu.stack_pop32(false); @@ -467,10 +449,7 @@ fn CryptGetKeyParam(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("advapi32!CryptGetKeyParam error reading param") as u64; - log_red!( - emu, - "advapi32!CryptGetKeyParam" - ); + log_red!(emu, "advapi32!CryptGetKeyParam"); for _ in 0..5 { emu.stack_pop32(false); @@ -504,10 +483,7 @@ fn CryptImportKey(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("advapi32!CryptImportKey error reading param") as u64; - log_red!( - emu, - "advapi32!CryptImportKey" - ); + log_red!(emu, "advapi32!CryptImportKey"); for _ in 0..6 { emu.stack_pop32(false); @@ -541,10 +517,7 @@ fn CryptSignHashA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("advapi32!CryptSignHashA error reading param") as u64; - log_red!( - emu, - "advapi32!CryptSignHashA" - ); + log_red!(emu, "advapi32!CryptSignHashA"); for _ in 0..6 { emu.stack_pop32(false); @@ -578,10 +551,7 @@ fn CryptSignHashW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("advapi32!CryptSignHashW error reading param") as u64; - log_red!( - emu, - "advapi32!CryptSignHashW" - ); + log_red!(emu, "advapi32!CryptSignHashW"); for _ in 0..6 { emu.stack_pop32(false); @@ -620,11 +590,7 @@ fn CryptHashData(emu: &mut emu::Emu) { helper::handler_put_bytes(hhash, b"deadcafebabe"); } - log_red!( - emu, - "advapi32!CryptHashData {}", - hex_hash - ); + log_red!(emu, "advapi32!CryptHashData {}", hex_hash); for _ in 0..4 { emu.stack_pop32(false); @@ -663,11 +629,7 @@ fn CryptDeriveKey(emu: &mut emu::Emu) { } helper::handler_put_bytes(handle, &vec![0x41u8; alg_len]); - log_red!( - emu, - "advapi32!CryptDeriveKey {}", - alg - ); + log_red!(emu, "advapi32!CryptDeriveKey {}", alg); for _ in 0..5 { emu.stack_pop32(false); diff --git a/crates/libmwemu/src/winapi/winapi32/dnsapi.rs b/crates/libmwemu/src/winapi/winapi32/dnsapi.rs index c130477f..0cb55f19 100644 --- a/crates/libmwemu/src/winapi/winapi32/dnsapi.rs +++ b/crates/libmwemu/src/winapi/winapi32/dnsapi.rs @@ -64,11 +64,7 @@ fn DnsQuery_A(emu: &mut emu::Emu) { let name = emu.maps.read_string(name_ptr); - log_red!( - emu, - "dnsapi!DnsQuery_A '{}'", - name - ); + log_red!(emu, "dnsapi!DnsQuery_A '{}'", name); emu.regs_mut().rax = 1; } @@ -101,11 +97,7 @@ fn DnsQuery_W(emu: &mut emu::Emu) { let name = emu.maps.read_wide_string(name_ptr); - log_red!( - emu, - "dnsapi!DnsQuery_W '{}'", - name - ); + log_red!(emu, "dnsapi!DnsQuery_W '{}'", name); emu.regs_mut().rax = 1; } diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/add_vectored_exception_handler.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/add_vectored_exception_handler.rs index 80478ea0..26a3bc16 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/add_vectored_exception_handler.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/add_vectored_exception_handler.rs @@ -22,4 +22,4 @@ pub fn AddVectoredExceptionHandler(emu: &mut emu::Emu) { emu.regs_mut().rax = 0x2c2878; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/are_file_apis_ansi.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/are_file_apis_ansi.rs index 709abbcc..b82f4da7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/are_file_apis_ansi.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/are_file_apis_ansi.rs @@ -1,9 +1,6 @@ use crate::emu; pub fn AreFileApisANSI(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!AreFileApisANSI" - ); + log_red!(emu, "kernel32!AreFileApisANSI"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/close_handle.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/close_handle.rs index 569a0d11..51e5ac69 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/close_handle.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/close_handle.rs @@ -7,15 +7,11 @@ pub fn CloseHandle(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!CloseHandle cannot read the handle") as u64; - log_red!( - emu, - "kernel32!CloseHandle 0x{:X}", - hndl - ); + log_red!(emu, "kernel32!CloseHandle 0x{:X}", hndl); if !helper::handler_close(hndl) { log::info!("\tinvalid handle.") } emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/connect_named_pipe.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/connect_named_pipe.rs index 8570199d..e488d5a9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/connect_named_pipe.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/connect_named_pipe.rs @@ -11,11 +11,7 @@ pub fn ConnectNamedPipe(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!ConnectNamedPipe cannot read the overlapped"); - log_red!( - emu, - "kernel32!ConnectNamedPipe hndl: 0x{:x}", - handle - ); + log_red!(emu, "kernel32!ConnectNamedPipe hndl: 0x{:x}", handle); if !helper::handler_exist(handle) { log::info!("\tinvalid handle."); } @@ -24,4 +20,4 @@ pub fn ConnectNamedPipe(emu: &mut emu::Emu) { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_a.rs index 39db89ba..5eb118c1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_a.rs @@ -17,16 +17,11 @@ pub fn CopyFileA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); let dst = emu.maps.read_string(dst_ptr); - log_red!( - emu, - "kernel32!CopyFileA `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!CopyFileA `{}` to `{}`", src, dst); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_w.rs index 20077473..9a75e823 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/copy_file_w.rs @@ -17,16 +17,11 @@ pub fn CopyFileW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); let dst = emu.maps.read_wide_string(dst_ptr); - log_red!( - emu, - "kernel32!CopyFileW `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!CopyFileW `{}` to `{}`", src, dst); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_event_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_event_a.rs index 395c0094..e7baefa6 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_event_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_event_a.rs @@ -20,15 +20,11 @@ pub fn CreateEventA(emu: &mut emu::Emu) { let name = emu.maps.read_string(name_ptr); - log_red!( - emu, - "kernel32!CreateEventA `{}`", - name - ); + log_red!(emu, "kernel32!CreateEventA `{}`", name); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_a.rs index d8b54b57..233f337a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_a.rs @@ -46,4 +46,4 @@ pub fn CreateFileMappingA(emu: &mut emu::Emu) { for _ in 0..6 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_w.rs index aa6c3282..578d3a42 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_mapping_w.rs @@ -45,4 +45,4 @@ pub fn CreateFileMappingW(emu: &mut emu::Emu) { for _ in 0..6 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_w.rs index 8b492eaa..43b041b0 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_file_w.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::winapi::helper; -use crate::constants; pub fn CreateFileW(emu: &mut emu::Emu) { let fname_ptr = emu @@ -26,12 +26,7 @@ pub fn CreateFileW(emu: &mut emu::Emu) { perm = "unknown permissions".to_string(); } - log_red!( - emu, - "kernel32!CreateFileW `{}` {}", - fname, - perm - ); + log_red!(emu, "kernel32!CreateFileW `{}` {}", fname, perm); for _ in 0..7 { emu.stack_pop32(false); @@ -42,4 +37,4 @@ pub fn CreateFileW(emu: &mut emu::Emu) { //} else { emu.regs_mut().rax = helper::handler_create(&format!("file://{}", fname)) as u64; //} -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_a.rs index b94d7c1c..03e01946 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_a.rs @@ -16,11 +16,7 @@ pub fn CreateMutexA(emu: &mut emu::Emu) { .expect("kernel32!CreateMutexA cannot read name param") as u64; let name = emu.maps.read_string(name_ptr); - log_red!( - emu, - "kernel32!CreateMutexA '{}'", - name - ); + log_red!(emu, "kernel32!CreateMutexA '{}'", name); for _ in 0..3 { emu.stack_pop32(false); @@ -28,4 +24,4 @@ pub fn CreateMutexA(emu: &mut emu::Emu) { let uri = format!("mutex://{}", name); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_w.rs index deacaf18..9e66d010 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_mutex_w.rs @@ -16,11 +16,7 @@ pub fn CreateMutexW(emu: &mut emu::Emu) { .expect("kernel32!CreateMutexW cannot read name param") as u64; let name = emu.maps.read_wide_string(name_ptr); - log_red!( - emu, - "kernel32!CreateMutexW '{}'", - name - ); + log_red!(emu, "kernel32!CreateMutexW '{}'", name); for _ in 0..3 { emu.stack_pop32(false); @@ -28,4 +24,4 @@ pub fn CreateMutexW(emu: &mut emu::Emu) { let uri = format!("mutex://{}", name); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_named_pipe_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_named_pipe_a.rs index 20b44ebe..c09a47ce 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_named_pipe_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_named_pipe_a.rs @@ -50,4 +50,4 @@ pub fn CreateNamedPipeA(emu: &mut emu::Emu) { } emu.regs_mut().rax = helper::handler_create(&name); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_process_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_process_a.rs index 494bbd6f..692c4ded 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_process_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_process_a.rs @@ -17,16 +17,11 @@ pub fn CreateProcessA(emu: &mut emu::Emu) { let appname = emu.maps.read_string(appname_ptr); let cmdline = emu.maps.read_string(cmdline_ptr); - log_red!( - emu, - "kernel32!CreateProcessA {} {}", - appname, - cmdline - ); + log_red!(emu, "kernel32!CreateProcessA {} {}", appname, cmdline); for _ in 0..10 { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_remote_thread.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_remote_thread.rs index a24fe84b..c2e51318 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_remote_thread.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_remote_thread.rs @@ -45,4 +45,4 @@ pub fn CreateRemoteThread(emu: &mut emu::Emu) { for _ in 0..7 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_thread.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_thread.rs index 1d71919a..4324a3cf 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_thread.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_thread.rs @@ -1,6 +1,6 @@ -use crate::{console, emu}; -use crate::winapi::helper; use crate::constants; +use crate::winapi::helper; +use crate::{console, emu}; pub fn CreateThread(emu: &mut emu::Emu) { let sec_attr = emu @@ -32,11 +32,7 @@ pub fn CreateThread(emu: &mut emu::Emu) { emu.maps.write_dword(tid_ptr, 0x123); } - log_red!( - emu, - "kernel32!CreateThread code: 0x{:x}", - code - ); + log_red!(emu, "kernel32!CreateThread code: 0x{:x}", code); for _ in 0..6 { emu.stack_pop32(false); @@ -69,4 +65,4 @@ pub fn CreateThread(emu: &mut emu::Emu) { } emu.regs_mut().rax = helper::handler_create("tid://0x123"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/create_toolhelp32_snapshot.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/create_toolhelp32_snapshot.rs index 710740d1..fefeda1a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/create_toolhelp32_snapshot.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/create_toolhelp32_snapshot.rs @@ -11,15 +11,11 @@ pub fn CreateToolhelp32Snapshot(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!CreateToolhelp32Snapshot cannot read pid"); - log_red!( - emu, - "kernel32!CreateToolhelp32Snapshot pid: {}", - pid - ); + log_red!(emu, "kernel32!CreateToolhelp32Snapshot pid: {}", pid); emu.stack_pop32(false); emu.stack_pop32(false); let uri = format!("pid://{}", pid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/crypt_create_hash.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/crypt_create_hash.rs index 67492364..7598419c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/crypt_create_hash.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/crypt_create_hash.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::winapi::helper; -use crate::constants; pub fn CryptCreateHash(emu: &mut emu::Emu) { let hprov = emu @@ -26,11 +26,7 @@ pub fn CryptCreateHash(emu: &mut emu::Emu) { let alg_name = constants::get_cryptoalgorithm_name(algid); - log_red!( - emu, - "kernel32!CryptCreateHash alg:{}", - alg_name - ); + log_red!(emu, "kernel32!CryptCreateHash alg:{}", alg_name); for _ in 0..5 { emu.stack_pop32(false); @@ -41,4 +37,4 @@ pub fn CryptCreateHash(emu: &mut emu::Emu) { helper::handler_create(&format!("alg://{}", alg_name)) as u32, ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/decode_pointer.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/decode_pointer.rs index 48ab2131..55f93571 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/decode_pointer.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/decode_pointer.rs @@ -6,12 +6,8 @@ pub fn DecodePointer(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!DecodePointer cannot read the pointer") as u64; - log_red!( - emu, - "kernel32!DecodePointer ptr: 0x{:x}", - ptr - ); + log_red!(emu, "kernel32!DecodePointer ptr: 0x{:x}", ptr); emu.stack_pop32(false); emu.regs_mut().rax = ptr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/disconnect_named_pipe.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/disconnect_named_pipe.rs index 83d72be1..c5123cf1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/disconnect_named_pipe.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/disconnect_named_pipe.rs @@ -6,12 +6,8 @@ pub fn DisconnectNamedPipe(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!DisconnectNamedPipe cannot read the handle"); - log_red!( - emu, - "kernel32!DisconnectNamedPipe hndl: 0x{:x}", - handle - ); + log_red!(emu, "kernel32!DisconnectNamedPipe hndl: 0x{:x}", handle); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/encode_pointer.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/encode_pointer.rs index 1f0ab354..621c5852 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/encode_pointer.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/encode_pointer.rs @@ -6,12 +6,8 @@ pub fn EncodePointer(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!EncodePointer cannot read the pointer") as u64; - log_red!( - emu, - "kernel32!EncodePointer ptr: 0x{:x}", - ptr - ); + log_red!(emu, "kernel32!EncodePointer ptr: 0x{:x}", ptr); emu.stack_pop32(false); emu.regs_mut().rax = ptr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/enter_critical_section.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/enter_critical_section.rs index bbb7155a..7b24615d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/enter_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/enter_critical_section.rs @@ -6,11 +6,7 @@ pub fn EnterCriticalSection(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!EnterCriticalSection cannot read crit_sect"); - log_red!( - emu, - "kernel32!EnterCriticalSection 0x{:x}", - crit_sect - ); + log_red!(emu, "kernel32!EnterCriticalSection 0x{:x}", crit_sect); emu.regs_mut().rax = crit_sect as u64; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/exit_process.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/exit_process.rs index 530e3192..b1870e67 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/exit_process.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/exit_process.rs @@ -6,12 +6,8 @@ pub fn ExitProcess(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!ExitProcess cannot read the exit code"); - log_red!( - emu, - "kernel32!ExitProcess code: {}", - code - ); + log_red!(emu, "kernel32!ExitProcess code: {}", code); emu.stack_pop32(false); std::process::exit(1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_a.rs index c2f505b5..e8b8cd92 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_a.rs @@ -16,11 +16,7 @@ pub fn ExpandEnvironmentStringsA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); - log_red!( - emu, - "kernel32!ExpandEnvironmentStringsA `{}`", - src - ); + log_red!(emu, "kernel32!ExpandEnvironmentStringsA `{}`", src); emu.stack_pop32(false); emu.stack_pop32(false); @@ -29,4 +25,4 @@ pub fn ExpandEnvironmentStringsA(emu: &mut emu::Emu) { emu.regs_mut().rax = 1; //TODO: implement expand -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_w.rs index 67f8abc8..20403c7d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/expand_environment_strings_w.rs @@ -16,11 +16,7 @@ pub fn ExpandEnvironmentStringsW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); - log_red!( - emu, - "kernel32!ExpandEnvironmentStringsW `{}`", - src - ); + log_red!(emu, "kernel32!ExpandEnvironmentStringsW `{}`", src); //TODO: implement expand @@ -29,4 +25,4 @@ pub fn ExpandEnvironmentStringsW(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_dos_date_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_dos_date_time.rs index 4557ce35..02e86f62 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_dos_date_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_dos_date_time.rs @@ -55,4 +55,4 @@ pub fn FileTimeToDosDateTime(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_local_file_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_local_file_time.rs index 7cb1bbb3..74bb0c9a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_local_file_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_local_file_time.rs @@ -34,4 +34,4 @@ pub fn FileTimeToLocalFileTime(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_system_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_system_time.rs index 737499c1..6eece872 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_system_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/file_time_to_system_time.rs @@ -10,13 +10,10 @@ pub fn FileTimeToSystemTime(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!FileTimeToSystemTime cannot read sys_time_ptr"); - log_red!( - emu, - "kernel32!FileTimeToSystemTime" - ); + log_red!(emu, "kernel32!FileTimeToSystemTime"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_close.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_close.rs index dbc144c5..e98e1dfe 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_close.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_close.rs @@ -7,13 +7,10 @@ pub fn FindClose(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!FindClose cannot read the handle") as u64; - log_red!( - emu, - "kernel32!FindClose" - ); + log_red!(emu, "kernel32!FindClose"); emu.stack_pop32(false); helper::handler_close(hndl); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_a.rs index 886ae2bb..639fcfa4 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_a.rs @@ -12,14 +12,10 @@ pub fn FindFirstFileA(emu: &mut emu::Emu) { let file = emu.maps.read_string(file_ptr); - log_red!( - emu, - "kernel32!FindFirstFileA file: {}", - file - ); + log_red!(emu, "kernel32!FindFirstFileA file: {}", file); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_w.rs index 80817615..0802f8b4 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_first_file_w.rs @@ -13,14 +13,10 @@ pub fn FindFirstFileW(emu: &mut emu::Emu) { let file = emu.maps.read_wide_string(file_ptr); - log_red!( - emu, - "kernel32!FindFirstFileW file: {}", - file - ); + log_red!(emu, "kernel32!FindFirstFileW file: {}", file); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = helper::handler_create(&file); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_a.rs index f36b3c07..621cba5f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_a.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn FindNextFileA(emu: &mut emu::Emu) { let hndl = emu @@ -11,13 +11,10 @@ pub fn FindNextFileA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!FindNextFileA cannot read the find_data"); - log_red!( - emu, - "kernel32!FindNextFileA" - ); + log_red!(emu, "kernel32!FindNextFileA"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_w.rs index e899c8ce..d4ce59bf 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_next_file_w.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn FindNextFileW(emu: &mut emu::Emu) { let hndl = emu @@ -11,13 +11,10 @@ pub fn FindNextFileW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!FindNextFileW cannot read the find_data"); - log_red!( - emu, - "kernel32!FindNextFileW" - ); + log_red!(emu, "kernel32!FindNextFileW"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_a.rs index 071b870d..c569bc44 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_a.rs @@ -93,4 +93,4 @@ pub fn FindResourceA(emu: &mut emu::Emu) { let hndl = helper::handler_create(&format!("rsrc://{:x}_{}", addr, size)); emu.regs_mut().rax = hndl; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_w.rs index 28039219..78e48d31 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/find_resource_w.rs @@ -93,4 +93,4 @@ pub fn FindResourceW(emu: &mut emu::Emu) { let hndl = helper::handler_create(&format!("rsrc://{:x}_{}", addr, size)); emu.regs_mut().rax = hndl; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_alloc.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_alloc.rs index 3616aae9..3765056c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_alloc.rs @@ -6,12 +6,8 @@ pub fn FlsAlloc(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!FlsAlloc cannot read callback"); - log_red!( - emu, - "kernel32!FlsAlloc callback: 0x{:x}", - callback - ); + log_red!(emu, "kernel32!FlsAlloc callback: 0x{:x}", callback); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_get_value.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_get_value.rs index 7e9153df..b88ac898 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_get_value.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_get_value.rs @@ -20,4 +20,4 @@ pub fn FlsGetValue(emu: &mut emu::Emu) { idx, emu.regs().get_eax() as u32 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_set_value.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_set_value.rs index 7bf256b7..b963aea6 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/fls_set_value.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/fls_set_value.rs @@ -10,12 +10,7 @@ pub fn FlsSetValue(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!FlsSetValue cannot read value"); - log_red!( - emu, - "kernel32!FlsSetValue idx: {} val: {}", - idx, - val - ); + log_red!(emu, "kernel32!FlsSetValue idx: {} val: {}", idx, val); if emu.fls().len() > idx as usize { emu.fls_mut()[idx as usize] = val; @@ -29,4 +24,4 @@ pub fn FlsSetValue(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/free_library.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/free_library.rs index 98829192..ef93cc8a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/free_library.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/free_library.rs @@ -6,12 +6,8 @@ pub fn FreeLibrary(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!FreeLibrary: error reading param") as u64; - log_red!( - emu, - "kernel32!FreeLibrary {:x}", - hmod - ); + log_red!(emu, "kernel32!FreeLibrary {:x}", hmod); emu.regs_mut().rax = 1; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/free_resource.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/free_resource.rs index 3994ba42..7d319322 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/free_resource.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/free_resource.rs @@ -10,4 +10,4 @@ pub fn FreeResource(emu: &mut emu::Emu) { helper::handler_close(hResData); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_acp.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_acp.rs index 750848fd..a2dcd6e2 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_acp.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_acp.rs @@ -1,9 +1,6 @@ use crate::emu; pub fn GetACP(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetAcp" - ); + log_red!(emu, "kernel32!GetAcp"); emu.regs_mut().rax = 1252; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_a.rs index 4ca850bc..6b80c55d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_a.rs @@ -1,14 +1,13 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn GetCommandLineA(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCommandlineA" - ); + log_red!(emu, "kernel32!GetCommandlineA"); let addr = emu.maps.alloc(1024).expect("out of memory"); let name = format!("alloc_{:x}", addr); - emu.maps.create_map(&name, addr, 1024); + emu.maps + .create_map(&name, addr, 1024, Permission::READ_WRITE); emu.maps.write_string(addr, "test.exe"); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_w.rs index 8f479015..c07a5b18 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_command_line_w.rs @@ -1,14 +1,13 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn GetCommandLineW(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCommandlineW" - ); + log_red!(emu, "kernel32!GetCommandlineW"); let addr = emu.maps.alloc(1024).expect("out of memory"); let name = format!("alloc_{:x}", addr); - emu.maps.create_map(&name, addr, 1024); + emu.maps + .create_map(&name, addr, 1024, Permission::READ_WRITE); emu.maps.write_wide_string(addr, "test.exe"); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_computer_name_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_computer_name_a.rs index fac3a6ef..709df494 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_computer_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_computer_name_a.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn GetComputerNameA(emu: &mut emu::Emu) { let buff_ptr = emu @@ -23,12 +23,8 @@ pub fn GetComputerNameA(emu: &mut emu::Emu) { emu.regs_mut().rax = 1; } - log_red!( - emu, - "kernel32!GetComputerName '{}'", - constants::HOST_NAME - ); + log_red!(emu, "kernel32!GetComputerName '{}'", constants::HOST_NAME); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_cp_info.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_cp_info.rs index 48c46c07..ef8cc176 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_cp_info.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_cp_info.rs @@ -10,12 +10,7 @@ pub fn GetCPInfo(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp + 4) .expect("kernel32!GetCPInfo error reading inmfo_ptr param"); - log_red!( - emu, - "kernel32!GetCPInfo {} 0x{}", - codepage, - info_ptr - ); + log_red!(emu, "kernel32!GetCPInfo {} 0x{}", codepage, info_ptr); // TODO: put something in lp_cp_info? @@ -24,4 +19,4 @@ pub fn GetCPInfo(emu: &mut emu::Emu) { emu.regs_mut().rax = 1; // https://learn.microsoft.com/en-us/windows/win32/api/winnls/ns-winnls-cpinfo -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_a.rs index 1678e885..0752740a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_a.rs @@ -12,13 +12,10 @@ pub fn GetCurrentDirectoryA(emu: &mut emu::Emu) { emu.maps.write_string(buff_ptr, "c:\\\x00"); - log_red!( - emu, - "kernel32!GetCurrentDirectoryA" - ); + log_red!(emu, "kernel32!GetCurrentDirectoryA"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 3; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_w.rs index bfe77881..45fc6163 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_directory_w.rs @@ -13,13 +13,10 @@ pub fn GetCurrentDirectoryW(emu: &mut emu::Emu) { emu.maps .write_string(buff_ptr, "c\x00:\x00\\\x00\x00\x00\x00\x00"); - log_red!( - emu, - "kernel32!GetCurrentDirectoryW" - ); + log_red!(emu, "kernel32!GetCurrentDirectoryW"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 6; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process.rs index 6ee17a78..1bf49393 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process.rs @@ -2,9 +2,6 @@ use crate::emu; use crate::winapi::helper; pub fn GetCurrentProcess(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCurrentProcess" - ); + log_red!(emu, "kernel32!GetCurrentProcess"); emu.regs_mut().rax = helper::handler_create("current process"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process_id.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process_id.rs index 1f6d18a9..3ce67cf7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process_id.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_process_id.rs @@ -1,10 +1,7 @@ use crate::emu; pub fn GetCurrentProcessId(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCurrentProcessId" - ); + log_red!(emu, "kernel32!GetCurrentProcessId"); emu.regs_mut().rax = 0x123; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_thread_id.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_thread_id.rs index f7fd6a1f..428f1d7d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_thread_id.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_current_thread_id.rs @@ -1,10 +1,7 @@ use crate::emu; pub fn GetCurrentThreadId(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCurrentThreadId" - ); + log_red!(emu, "kernel32!GetCurrentThreadId"); emu.regs_mut().rax = 0x111; //TODO: track pids and tids -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings.rs index fc91f74e..e5a1df64 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings.rs @@ -1,11 +1,9 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn GetEnvironmentStrings(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetEnvironmentStrings" - ); - let ptr = emu.alloc("environment", 1024); + log_red!(emu, "kernel32!GetEnvironmentStrings"); + let ptr = emu.alloc("environment", 1024, Permission::READ_WRITE); emu.maps.write_string(ptr, "PATH=c:\\Windows\\System32"); emu.regs_mut().rax = ptr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings_w.rs index a3c5dd8d..12ca440b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_environment_strings_w.rs @@ -1,12 +1,10 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn GetEnvironmentStringsW(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetEnvironmentStringsW" - ); - let addr = emu.alloc("environment", 1024); + log_red!(emu, "kernel32!GetEnvironmentStringsW"); + let addr = emu.alloc("environment", 1024, Permission::READ_WRITE); emu.maps .write_wide_string(addr, "PATH=c:\\Windows\\System32"); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_a.rs index 18905735..812fe954 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_a.rs @@ -7,13 +7,9 @@ pub fn GetFileAttributesA(emu: &mut emu::Emu) { .expect("kernel32!GetFileAttributesA cannot read filename_ptr") as u64; let filename = emu.maps.read_string(filename_ptr); - log_red!( - emu, - "kernel32!GetFileAttributesA file: {}", - filename - ); + log_red!(emu, "kernel32!GetFileAttributesA file: {}", filename); emu.regs_mut().rax = 0x123; // file attributes emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_w.rs index 3b07cb7a..d543487d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_attributes_w.rs @@ -7,13 +7,9 @@ pub fn GetFileAttributesW(emu: &mut emu::Emu) { .expect("kernel32!GetFileAttributesW cannot read filename_ptr") as u64; let filename = emu.maps.read_wide_string(filename_ptr); - log_red!( - emu, - "kernel32!GetFileAttributesW file: {}", - filename - ); + log_red!(emu, "kernel32!GetFileAttributesW file: {}", filename); emu.stack_pop32(false); emu.regs_mut().rax = 0x123; // file attributes -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_type.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_type.rs index ebca7368..174bb185 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_type.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_file_type.rs @@ -6,11 +6,7 @@ pub fn GetFileType(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp) .expect("kernel32!GetFileType error getting hndl param"); - log_red!( - emu, - "kernel32!GetFileType 0x{:x}", - hndl - ); + log_red!(emu, "kernel32!GetFileType 0x{:x}", hndl); emu.stack_pop32(false); emu.regs_mut().rax = 3; @@ -22,4 +18,4 @@ pub fn GetFileType(emu: &mut emu::Emu) { * FILE_TYPE_REMOTE 0x8000 * FILE_TYPE_UNKNOWN 0x0000 */ -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_a.rs index 209dc4b0..bc9b2041 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_a.rs @@ -20,15 +20,11 @@ pub fn GetFullPathNameA(emu: &mut emu::Emu) { let filename = emu.maps.read_string(file_ptr); - log_red!( - emu, - "kernel32!GetFullPathNameA file: {}", - filename - ); + log_red!(emu, "kernel32!GetFullPathNameA file: {}", filename); for _ in 0..4 { emu.stack_pop32(false); } emu.regs_mut().rax = 10; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_w.rs index 157a3502..815db856 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_full_path_name_w.rs @@ -20,15 +20,11 @@ pub fn GetFullPathNameW(emu: &mut emu::Emu) { let filename = emu.maps.read_wide_string(file_ptr); - log_red!( - emu, - "kernel32!GetFullPathNameW file: {}", - filename - ); + log_red!(emu, "kernel32!GetFullPathNameW file: {}", filename); for _ in 0..4 { emu.stack_pop32(false); } emu.regs_mut().rax = 10; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_last_error.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_last_error.rs index 4e849c13..04f4dd24 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_last_error.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_last_error.rs @@ -4,9 +4,5 @@ use crate::winapi::winapi32::kernel32::LAST_ERROR; pub fn GetLastError(emu: &mut emu::Emu) { let err = LAST_ERROR.lock().unwrap(); emu.regs_mut().rax = *err as u64; - log_red!( - emu, - "kernel32!GetLastError ={}", - emu.regs().rax - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetLastError ={}", emu.regs().rax); +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_logical_drives.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_logical_drives.rs index ee68a45a..9eeaa63e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_logical_drives.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_logical_drives.rs @@ -1,10 +1,7 @@ use crate::emu; pub fn GetLogicalDrives(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetLogicalDrives" - ); + log_red!(emu, "kernel32!GetLogicalDrives"); emu.regs_mut().rax = 0xc; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_long_path_name_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_long_path_name_w.rs index 8874797f..9126ea8a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_long_path_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_long_path_name_w.rs @@ -34,4 +34,4 @@ pub fn GetLongPathNameW(emu: &mut emu::Emu) { for _ in 0..3 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_a.rs index 66b89899..d2ed4232 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_a.rs @@ -18,15 +18,11 @@ pub fn GetModuleFileNameA(emu: &mut emu::Emu) { emu.maps.write_string(fname_ptr, "c:\\test.exe"); } - log_red!( - emu, - "kernel32!GetModuleFileNameA 0x{:x}", - hmod - ); + log_red!(emu, "kernel32!GetModuleFileNameA 0x{:x}", hmod); for _ in 0..3 { emu.stack_pop32(false); } emu.regs_mut().rax = 8; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_w.rs index c9d42e93..2b56556a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_file_name_w.rs @@ -14,10 +14,7 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!GetModuleFileNameW cannot read out_filename_ptr"); - log_red!( - emu, - "kernel32!GetModuleFileNameW" - ); + log_red!(emu, "kernel32!GetModuleFileNameW"); emu.stack_pop32(false); emu.stack_pop32(false); @@ -25,4 +22,4 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { emu.maps.write_wide_string(out_filename_ptr, "jowei3r.exe"); emu.regs_mut().rax = 11; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_a.rs index 6d8e14eb..ececf4b7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_a.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::peb; -use crate::constants; use crate::winapi::helper; pub fn GetModuleHandleA(emu: &mut emu::Emu) { @@ -12,30 +12,27 @@ pub fn GetModuleHandleA(emu: &mut emu::Emu) { let mod_name: String; if mod_name_ptr == 0 { - let caller_rip = emu.regs().rip; mod_name = match emu.maps.get_addr_name(caller_rip) { Some(n) => n, None => { - log::info!("kernel32!GetModuleHandleA called from weird place 0x{:x}", caller_rip); + log::info!( + "kernel32!GetModuleHandleA called from weird place 0x{:x}", + caller_rip + ); constants::EXE_NAME } - }.to_string(); + } + .to_string(); let base = match peb::peb64::get_module_base(&mod_name, emu) { Some(b) => b, None => helper::handler_create(&mod_name), }; - log_red!( - emu, - "kernel32!GetModuleHandleA `{}` {:x}", - mod_name, - base - ); + log_red!(emu, "kernel32!GetModuleHandleA `{}` {:x}", mod_name, base); emu.regs_mut().rax = base; - } else { mod_name = emu.maps.read_string(mod_name_ptr).to_lowercase(); let mod_mem = match emu.maps.get_mem2(mod_name.as_str()) { @@ -49,12 +46,7 @@ pub fn GetModuleHandleA(emu: &mut emu::Emu) { emu.regs_mut().rax = mod_mem.get_base(); } - log_red!( - emu, - "kernel32!GetModuleHandleA '{}'", - mod_name - ); - + log_red!(emu, "kernel32!GetModuleHandleA '{}'", mod_name); emu.stack_pop32(false); } diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_w.rs index 930b32c8..88779484 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_module_handle_w.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::peb; -use crate::constants; use crate::winapi::helper; pub fn GetModuleHandleW(emu: &mut emu::Emu) { @@ -13,13 +13,11 @@ pub fn GetModuleHandleW(emu: &mut emu::Emu) { let base; if mod_name_ptr == 0 { - mod_name = constants::EXE_NAME.to_string(); base = match peb::peb64::get_module_base(&mod_name, emu) { Some(b) => b, None => helper::handler_create(&mod_name), }; - } else { mod_name = emu.maps.read_wide_string(mod_name_ptr).to_lowercase(); let mod_mem = match emu.maps.get_mem2(&mod_name) { @@ -32,12 +30,7 @@ pub fn GetModuleHandleW(emu: &mut emu::Emu) { base = mod_mem.get_base(); } - log_red!( - emu, - "kernel32!GetModuleHandleW '{}' 0x{:x}", - mod_name, - base - ); + log_red!(emu, "kernel32!GetModuleHandleW '{}' 0x{:x}", mod_name, base); emu.regs_mut().rax = base; diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_native_system_info.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_native_system_info.rs index 469f8737..6b953752 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_native_system_info.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_native_system_info.rs @@ -10,10 +10,7 @@ pub fn GetNativeSystemInfo(emu: &mut emu::Emu) { let mut sysinfo = structures::SystemInfo32::new(); sysinfo.save(sysinfo_ptr, &mut emu.maps); - log_red!( - emu, - "kernel32!GetNativeSystemInfo" - ); + log_red!(emu, "kernel32!GetNativeSystemInfo"); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_oemcp.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_oemcp.rs index 93c6ab2e..72da763d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_oemcp.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_oemcp.rs @@ -1,9 +1,6 @@ use crate::emu; pub fn GetOEMCP(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetOEMCP" - ); + log_red!(emu, "kernel32!GetOEMCP"); emu.regs_mut().rax = 0x00000409; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_proc_address.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_proc_address.rs index 4ab68a93..a31837aa 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_proc_address.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_proc_address.rs @@ -36,12 +36,12 @@ pub fn GetProcAddress(emu: &mut emu::Emu) { if ordinal.func_name.to_lowercase() == func { emu.regs_mut().rax = ordinal.func_va; log_red!( - emu, - "kernel32!GetProcAddress `{}!{}` =0x{:x}", - flink.mod_name, - ordinal.func_name, - emu.regs().get_eax() as u32 - ); + emu, + "kernel32!GetProcAddress `{}!{}` =0x{:x}", + flink.mod_name, + ordinal.func_name, + emu.regs().get_eax() as u32 + ); return; } } @@ -54,4 +54,4 @@ pub fn GetProcAddress(emu: &mut emu::Emu) { } emu.regs_mut().rax = 0; log::warn!("kernel32!GetProcAddress error searching {}", func); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_affinity_mask.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_affinity_mask.rs index 493fb1e4..73c78c46 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_affinity_mask.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_affinity_mask.rs @@ -19,14 +19,11 @@ pub fn GetProcessAffinityMask(emu: &mut emu::Emu) { emu.maps.write_dword(proc_affinity_mask_ptr, 0x1337); emu.maps.write_dword(sys_affinity_mask_ptr, 0x1337); - log_red!( - emu, - "kernel32!GetProcessAffinityMask" - ); + log_red!(emu, "kernel32!GetProcessAffinityMask"); emu.regs_mut().rax = 1; for _ in 0..3 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_heap.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_heap.rs index c2900b1f..0da03f1c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_heap.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_process_heap.rs @@ -8,4 +8,4 @@ pub fn GetProcessHeap(emu: &mut emu::Emu) { "kernel32!GetProcessHeap =0x{:x}", emu.regs().rax as u32 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_a.rs index d9c844fe..3bc395f8 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_a.rs @@ -7,14 +7,11 @@ pub fn GetStartupInfoA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetStartupInfoA cannot read startup_info_ptr param") as u64; - log_red!( - emu, - "kernel32!GetStartupInfoA" - ); + log_red!(emu, "kernel32!GetStartupInfoA"); if startup_info_ptr > 0 { let startupinfo = structures::StartupInfo32::new(); startupinfo.save(startup_info_ptr, &mut emu.maps); } emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_w.rs index f9326289..955284d7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_startup_info_w.rs @@ -7,14 +7,11 @@ pub fn GetStartupInfoW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetStartupInfoW cannot read startup_info_ptr param") as u64; - log_red!( - emu, - "kernel32!GetStartupInfoW" - ); + log_red!(emu, "kernel32!GetStartupInfoW"); if startup_info_ptr > 0 { let startupinfo = structures::StartupInfo32::new(); startupinfo.save(startup_info_ptr, &mut emu.maps); } emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_std_handle.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_std_handle.rs index 0abb73f8..338be109 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_std_handle.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_std_handle.rs @@ -6,12 +6,8 @@ pub fn GetStdHandle(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp) .expect("kernel32!GetStdHandle error reading nstd param"); - log_red!( - emu, - "kernel32!GetStdHandle {}", - nstd - ); + log_red!(emu, "kernel32!GetStdHandle {}", nstd); emu.stack_pop32(false); emu.regs_mut().rax = nstd as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_string_type_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_string_type_w.rs index 944c24e4..3b202738 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_string_type_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_string_type_w.rs @@ -20,16 +20,11 @@ pub fn GetStringTypeW(emu: &mut emu::Emu) { let ustr = emu.maps.read_wide_string(str_ptr); - log_red!( - emu, - "kernel32!GetStringTypeW `{}` 0x{}", - ustr, - sz - ); + log_red!(emu, "kernel32!GetStringTypeW `{}` 0x{}", ustr, sz); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_a.rs index 7572949d..784e0bb5 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_a.rs @@ -12,13 +12,10 @@ pub fn GetSystemDirectoryA(emu: &mut emu::Emu) { emu.maps.write_string(out_buff_ptr, "C:\\Windows\\\x00"); - log_red!( - emu, - "kernel32!GetSystemDirectoryA" - ); + log_red!(emu, "kernel32!GetSystemDirectoryA"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 11; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_w.rs index 9d1005d5..9fc54638 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_directory_w.rs @@ -13,13 +13,10 @@ pub fn GetSystemDirectoryW(emu: &mut emu::Emu) { emu.maps .write_wide_string(out_buff_ptr, "C:\\Windows\\\x00\x00"); - log_red!( - emu, - "kernel32!GetSystemDirectoryW" - ); + log_red!(emu, "kernel32!GetSystemDirectoryW"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 11; // * 2; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_info.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_info.rs index 424eed3f..bf62c26b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_info.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_info.rs @@ -6,14 +6,10 @@ pub fn GetSystemInfo(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetSystemInfo cannot read out_sysinfo") as u64; - log_red!( - emu, - "kernel32!GetSystemInfo sysinfo: 0x{:x}", - out_sysinfo - ); + log_red!(emu, "kernel32!GetSystemInfo sysinfo: 0x{:x}", out_sysinfo); // let mut sysinfo = emu::structures::SystemInfo32::new(); // sysinfo.save(out_sysinfo, &mut emu.maps); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time.rs index 818656ea..c8a0e2ae 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time.rs @@ -7,13 +7,9 @@ pub fn GetSystemTime(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetSystemTime cannot read out_time param") as u64; - log_red!( - emu, - "kernel32!GetSystemTime ptr: 0x{:x}'", - out_time - ); + log_red!(emu, "kernel32!GetSystemTime ptr: 0x{:x}'", out_time); let systime = structures::SystemTime::now(); systime.save(out_time, &mut emu.maps); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time_as_file_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time_as_file_time.rs index 73a8a9cb..9865883c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time_as_file_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_time_as_file_time.rs @@ -6,12 +6,9 @@ pub fn GetSystemTimeAsFileTime(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetSystemTimeAsFileTime cannot read sys_time_ptr"); - log_red!( - emu, - "kernel32!GetSystemTimeAsFileTime" - ); + log_red!(emu, "kernel32!GetSystemTimeAsFileTime"); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_a.rs index 1c8d0615..0caab1f1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_a.rs @@ -10,14 +10,11 @@ pub fn GetSystemWindowsDirectoryA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!GetSystemWindowsDirectoryA: error reading param") as u64; - log_red!( - emu, - "kernel32!GetSystemWindowsDirectoryA" - ); + log_red!(emu, "kernel32!GetSystemWindowsDirectoryA"); emu.maps.write_string(ptr, "C:\\Windows\\system32\\"); emu.regs_mut().rax = size; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_w.rs index 137aaee6..08a25a3a 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_system_windows_directory_w.rs @@ -10,14 +10,11 @@ pub fn GetSystemWindowsDirectoryW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!GetSystemWindowsDirectoryW: error reading param") as u64; - log_red!( - emu, - "kernel32!GetSystemWindowsDirectoryW" - ); + log_red!(emu, "kernel32!GetSystemWindowsDirectoryW"); emu.maps.write_wide_string(ptr, "C:\\Windows\\system32\\"); emu.regs_mut().rax = size; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_temp_path_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_temp_path_w.rs index ce8bb920..aa30e8d9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_temp_path_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_temp_path_w.rs @@ -17,11 +17,8 @@ pub fn GetTempPathW(emu: &mut emu::Emu) { emu.regs_mut().rax = 0; } - log_red!( - emu, - "kernel32!GetTempPathW" - ); + log_red!(emu, "kernel32!GetTempPathW"); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_context.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_context.rs index ad8c4e49..90e011dd 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_context.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_context.rs @@ -14,13 +14,10 @@ pub fn GetThreadContext(emu: &mut emu::Emu) { let ctx = context32::Context32::new(&emu.regs()); ctx.save(ctx_ptr, &mut emu.maps); - log_red!( - emu, - "kernel32!GetThreadContext" - ); + log_red!(emu, "kernel32!GetThreadContext"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_preferred_ui_languages.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_preferred_ui_languages.rs index 4f36e1af..575940d8 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_preferred_ui_languages.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_preferred_ui_languages.rs @@ -20,10 +20,7 @@ pub fn GetThreadPreferredUILanguages(emu: &mut emu::Emu) { .expect("kernel32!GetThreadPreferredUILanguages cannot read sz") as u64; emu.maps.write_dword(num_langs_ptr, 0); - log_red!( - emu, - "kernel32!GetThreadPreferredUILanguages" - ); + log_red!(emu, "kernel32!GetThreadPreferredUILanguages"); emu.maps.write_dword(out_sz, 0); emu.maps.write_dword(num_langs_ptr, 0); @@ -33,4 +30,4 @@ pub fn GetThreadPreferredUILanguages(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_ui_language.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_ui_language.rs index ff3004ce..5306b6a9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_ui_language.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_thread_ui_language.rs @@ -1,11 +1,8 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn GetThreadUILanguage(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetThreadUILanguage (0x0409 en_US)" - ); + log_red!(emu, "kernel32!GetThreadUILanguage (0x0409 en_US)"); emu.regs_mut().rax = constants::EN_US_LOCALE as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_tick_count.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_tick_count.rs index 46ee6989..0431a59f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_tick_count.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_tick_count.rs @@ -1,10 +1,7 @@ use crate::emu; pub fn GetTickCount(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetTickCount" - ); + log_red!(emu, "kernel32!GetTickCount"); emu.regs_mut().rax = emu.tick as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_time_zone_information.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_time_zone_information.rs index 9a1c97a8..2abfd14b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_time_zone_information.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_time_zone_information.rs @@ -8,11 +8,8 @@ pub fn GetTimeZoneInformation(emu: &mut emu::Emu) { //TODO: new structure https://learn.microsoft.com/en-us/windows/win32/api/timezoneapi/ns-timezoneapi-time_zone_information - log_red!( - emu, - "kernel32!GetTimeZoneInformation" - ); + log_red!(emu, "kernel32!GetTimeZoneInformation"); emu.stack_pop32(false); emu.regs_mut().rax = 1; // TIME_ZONE_ID_STANDARD -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_lang_id.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_lang_id.rs index 707cf401..3db7acbd 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_lang_id.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_lang_id.rs @@ -7,4 +7,4 @@ pub fn GetUserDefaultLangID(emu: &mut emu::Emu) { "kernel32!GetUserDefaultLangID =0x{:x}", emu.regs().rax as u16 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_ui_language.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_ui_language.rs index 51e12dd9..ae06f9ad 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_ui_language.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_user_default_ui_language.rs @@ -1,10 +1,7 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn GetUserDefaultUILanguage(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetUserDefaultUILanguage (0x0409 en_US)" - ); + log_red!(emu, "kernel32!GetUserDefaultUILanguage (0x0409 en_US)"); emu.regs_mut().rax = constants::EN_US_LOCALE as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_version.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_version.rs index 90edc3b9..23350ade 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_version.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_version.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn GetVersion(emu: &mut emu::Emu) { emu.regs_mut().rax = constants::VERSION; @@ -8,4 +8,4 @@ pub fn GetVersion(emu: &mut emu::Emu) { "kernel32!GetVersion =0x{:x}", emu.regs().get_eax() as u32 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_version_ex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_version_ex_w.rs index 9362b0f7..2eb0f559 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_version_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_version_ex_w.rs @@ -7,11 +7,7 @@ pub fn GetVersionExW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!GetVersionExW cannot read version_info_ptr param") as u64; - log_red!( - emu, - "kernel32!GetVersionExW 0x{:x}", - version_info_ptr - ); + log_red!(emu, "kernel32!GetVersionExW 0x{:x}", version_info_ptr); let os_version_info = structures::OsVersionInfoExW::new(); os_version_info.save(version_info_ptr, &mut emu.maps); @@ -19,4 +15,4 @@ pub fn GetVersionExW(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_a.rs index 61566694..e937ca5d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_a.rs @@ -10,14 +10,11 @@ pub fn GetWindowsDirectoryA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!GetWindowsDirectoryA: error reading param") as u64; - log_red!( - emu, - "kernel32!GetWindowsDirectoryA" - ); + log_red!(emu, "kernel32!GetWindowsDirectoryA"); emu.maps.write_string(ptr, "C:\\Windows"); emu.regs_mut().rax = size; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_w.rs index 7fd38d0e..2f21a8c3 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/get_windows_directory_w.rs @@ -10,14 +10,11 @@ pub fn GetWindowsDirectoryW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!GetWindowsDirectoryW: error reading param") as u64; - log_red!( - emu, - "kernel32!GetWindowsDirectoryW" - ); + log_red!(emu, "kernel32!GetWindowsDirectoryW"); emu.maps.write_wide_string(ptr, "C:\\Windows"); emu.regs_mut().rax = size; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_alloc.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_alloc.rs index 6b08c996..5e80769b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_alloc.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn HeapAlloc(emu: &mut emu::Emu) { let hndl = emu @@ -21,6 +22,7 @@ pub fn HeapAlloc(emu: &mut emu::Emu) { format!("alloc_{:x}", emu.regs().get_eax() as u32).as_str(), emu.regs().get_eax(), size, + Permission::READ_WRITE, ) .expect("kernel32!HeapAlloc out of memory"); @@ -36,4 +38,4 @@ pub fn HeapAlloc(emu: &mut emu::Emu) { for _ in 0..3 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_create.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_create.rs index 5541aa8f..180ddfdd 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_create.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_create.rs @@ -27,4 +27,4 @@ pub fn HeapCreate(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = helper::handler_create("heap://"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_destroy.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_destroy.rs index 66347491..9e7eca1f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_destroy.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_destroy.rs @@ -7,14 +7,10 @@ pub fn HeapDestroy(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!HeapDestroy cannot read handle") as u64; - log_red!( - emu, - "kernel32!HeapDestroy {:x}", - hndl - ); + log_red!(emu, "kernel32!HeapDestroy {:x}", hndl); helper::handler_close(hndl); emu.regs_mut().rax = hndl; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_free.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_free.rs index 0deb1bad..50d47eb9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_free.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_free.rs @@ -14,15 +14,11 @@ pub fn HeapFree(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!HeapFree cannot read heap handle"); - log_red!( - emu, - "kernel32!HeapFree mem: 0x{:x}", - mem - ); + log_red!(emu, "kernel32!HeapFree mem: 0x{:x}", mem); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_set_information.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_set_information.rs index 7e1c2971..7b182283 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/heap_set_information.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/heap_set_information.rs @@ -18,13 +18,10 @@ pub fn HeapSetInformation(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp + 12) .expect("kernel32!HeapSetInformation error reading param"); - log_red!( - emu, - "kernel32!HeapSetInformation" - ); + log_red!(emu, "kernel32!HeapSetInformation"); for _ in 0..4 { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section.rs index 5a442c50..ce5c4c82 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section.rs @@ -15,4 +15,4 @@ pub fn InitializeCriticalSection(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_and_spin_count.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_and_spin_count.rs index 1ab55f23..8c055d1e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_and_spin_count.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_and_spin_count.rs @@ -21,4 +21,4 @@ pub fn InitializeCriticalSectionAndSpinCount(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_ex.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_ex.rs index fc36823b..347a2c60 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_ex.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/initialize_critical_section_ex.rs @@ -25,4 +25,4 @@ pub fn InitializeCriticalSectionEx(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/interlocked_increment.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/interlocked_increment.rs index 4aab8db2..c03114be 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/interlocked_increment.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/interlocked_increment.rs @@ -23,4 +23,4 @@ pub fn InterlockedIncrement(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = prev as u64 + 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/is_debugger_present.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/is_debugger_present.rs index f697f0e4..2bb5cf11 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/is_debugger_present.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/is_debugger_present.rs @@ -1,9 +1,6 @@ use crate::emu; pub fn IsDebuggerPresent(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!IsDebuggerPresent" - ); + log_red!(emu, "kernel32!IsDebuggerPresent"); emu.regs_mut().rax = 0; // of course :p -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/is_processor_feature_present.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/is_processor_feature_present.rs index 982caaf6..6fe14a8c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/is_processor_feature_present.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/is_processor_feature_present.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn IsProcessorFeaturePresent(emu: &mut emu::Emu) { let feature = emu @@ -60,4 +60,4 @@ pub fn IsProcessorFeaturePresent(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_code_page.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_code_page.rs index dc8f50fa..6cd2381e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_code_page.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_code_page.rs @@ -6,12 +6,8 @@ pub fn IsValidCodePage(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp) .expect("kernel32!IsValidCodePage error geting codepage param"); - log_red!( - emu, - "kernel32!IsValidCodePage {}", - codepage - ); + log_red!(emu, "kernel32!IsValidCodePage {}", codepage); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_locale.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_locale.rs index 650ac3e3..3286aa55 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_locale.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/is_valid_locale.rs @@ -10,12 +10,9 @@ pub fn IsValidLocale(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!IsValidLocale cannot read flags"); - log_red!( - emu, - "kernel32!IsValidLocale" - ); + log_red!(emu, "kernel32!IsValidLocale"); emu.regs_mut().rax = 1; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lc_map_string_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lc_map_string_w.rs index a2b45716..12a175fa 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lc_map_string_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lc_map_string_w.rs @@ -45,4 +45,4 @@ pub fn LCMapStringW(emu: &mut emu::Emu) { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/leave_critical_section.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/leave_critical_section.rs index 5d556b50..defb9d1e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/leave_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/leave_critical_section.rs @@ -6,10 +6,7 @@ pub fn LeaveCriticalSection(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!LeaveCriticalSection cannot read crit_sect"); - log_red!( - emu, - "kernel32!LeaveCriticalSection" - ); + log_red!(emu, "kernel32!LeaveCriticalSection"); emu.regs_mut().rax = 1; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_a.rs index 991133c7..41e80b3f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_a.rs @@ -22,4 +22,4 @@ pub fn LoadLibraryA(emu: &mut emu::Emu) { emu.stack_pop32(false); //TODO: instead returning the base, return a handle that have linked the dll name -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_a.rs index 953b04e6..20fb15f1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_a.rs @@ -8,15 +8,11 @@ pub fn LoadLibraryExA(emu: &mut emu::Emu) { .expect("kernel32_LoadLibraryExA: error reading libname ptr param") as u64; let libname = emu.maps.read_string(libname_ptr); - log_red!( - emu, - "kernel32!LoadLibraryExA '{}'", - libname - ); + log_red!(emu, "kernel32!LoadLibraryExA '{}'", libname); emu.regs_mut().rax = load_library(emu, &libname); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_w.rs index b477ef52..3eaa9181 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_ex_w.rs @@ -17,11 +17,7 @@ pub fn LoadLibraryExW(emu: &mut emu::Emu) { let libname = emu.maps.read_wide_string(libname_ptr); - log_red!( - emu, - "LoadLibraryExW '{}'", - libname - ); + log_red!(emu, "LoadLibraryExW '{}'", libname); emu.regs_mut().rax = load_library(emu, &libname); @@ -33,4 +29,4 @@ pub fn LoadLibraryExW(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_w.rs index 38438dad..e153d52d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/load_library_w.rs @@ -7,11 +7,7 @@ pub fn LoadLibraryW(emu: &mut emu::Emu) { None => panic!("bad LoadLibraryW parameter"), }; let dll = emu.maps.read_wide_string(dllptr); - log_red!( - emu, - "LoadLibraryW '{}'", - dll - ); + log_red!(emu, "LoadLibraryW '{}'", dll); //if dll == "ntdll.dll" { // emu.regs_mut().rax = emu.maps.get_mem("ntdll").get_base(); @@ -20,4 +16,4 @@ pub fn LoadLibraryW(emu: &mut emu::Emu) { emu.regs_mut().rax = load_library(emu, &dll); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/load_resource.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/load_resource.rs index 6d8da410..44bbd9f2 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/load_resource.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/load_resource.rs @@ -16,4 +16,4 @@ pub fn LoadResource(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = hResInfo; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/local_alloc.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/local_alloc.rs index 090b534f..c2a28dcd 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/local_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/local_alloc.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn LocalAlloc(emu: &mut emu::Emu) { let flags = emu @@ -17,6 +18,7 @@ pub fn LocalAlloc(emu: &mut emu::Emu) { format!("alloc_{:x}", emu.regs().get_eax() as u32).as_str(), emu.regs().get_eax(), size, + Permission::READ_WRITE, ) .expect("kernel32!LocalAlloc out of memory"); @@ -30,4 +32,4 @@ pub fn LocalAlloc(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lock_resource.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lock_resource.rs index 719d6a77..e3e2d4e4 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lock_resource.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lock_resource.rs @@ -29,4 +29,4 @@ pub fn LockResource(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcat.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcat.rs index 22e4b5c3..663d104e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcat.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcat.rs @@ -13,12 +13,7 @@ pub fn lstrcat(emu: &mut emu::Emu) { let mut str1 = emu.maps.read_string(str1_ptr); let str2 = emu.maps.read_string(str2_ptr); - log_red!( - emu, - "kernel32!lstrcat '{}'+'{}'", - str1, - str2 - ); + log_red!(emu, "kernel32!lstrcat '{}'+'{}'", str1, str2); str1.push_str(&str2); @@ -28,4 +23,4 @@ pub fn lstrcat(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_a.rs index ba8837ac..b9bed524 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_a.rs @@ -13,12 +13,7 @@ pub fn lstrcmpA(emu: &mut emu::Emu) { let s1 = emu.maps.read_string(s1_ptr); let s2 = emu.maps.read_string(s2_ptr); - log_red!( - emu, - "kernel32!lstrcmpA '{}' == '{}'", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpA '{}' == '{}'", s1, s2); emu.stack_pop32(false); emu.stack_pop32(false); @@ -31,4 +26,4 @@ pub fn lstrcmpA(emu: &mut emu::Emu) { } else { emu.regs_mut().rax = 0; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_w.rs index 4f162354..5011aa68 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcmp_w.rs @@ -13,12 +13,7 @@ pub fn lstrcmpW(emu: &mut emu::Emu) { let s1 = emu.maps.read_wide_string(s1_ptr); let s2 = emu.maps.read_wide_string(s2_ptr); - log_red!( - emu, - "kernel32!lstrcmpW '{}' == '{}'", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpW '{}' == '{}'", s1, s2); emu.stack_pop32(false); emu.stack_pop32(false); @@ -31,4 +26,4 @@ pub fn lstrcmpW(emu: &mut emu::Emu) { } else { emu.regs_mut().rax = 0; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcpy.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcpy.rs index 0bac0c0a..93a58c81 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcpy.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrcpy.rs @@ -12,14 +12,9 @@ pub fn lstrcpy(emu: &mut emu::Emu) { let s = emu.maps.read_string(src); emu.maps.write_string(dst, &s); - log_red!( - emu, - "kernel32!lstrcpy 0x{:x} `{}`", - dst, - s - ); + log_red!(emu, "kernel32!lstrcpy 0x{:x} `{}`", dst, s); emu.regs_mut().rax = dst; emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrlen.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrlen.rs index a5f96ba6..6296d1f9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/lstrlen.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/lstrlen.rs @@ -10,12 +10,7 @@ pub fn lstrlen(emu: &mut emu::Emu) { let s = emu.maps.read_string(s_ptr); let len = s.len() as u64; - log_red!( - emu, - "kernel32!lstrlen '{}' ={}", - s, - len - ); + log_red!(emu, "kernel32!lstrlen '{}' ={}", s, len); emu.regs_mut().rax = len; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/map_view_of_file.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/map_view_of_file.rs index 04b91c64..dfcf450d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/map_view_of_file.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/map_view_of_file.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; pub fn MapViewOfFile(emu: &mut emu::Emu) { let hndl = emu @@ -36,7 +37,7 @@ pub fn MapViewOfFile(emu: &mut emu::Emu) { .expect("kernel32!MapViewOfFile cannot allocate"); let mem = emu .maps - .create_map("file_map", addr, size) + .create_map("file_map", addr, size, Permission::READ_WRITE) .expect("kernel32!MapViewOfFile cannot create map"); let loaded = mem.load_chunk(&emu.filename, off, size as usize); @@ -58,4 +59,4 @@ pub fn MapViewOfFile(emu: &mut emu::Emu) { } emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/mod.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/mod.rs index c5067e27..c2303c66 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/mod.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/mod.rs @@ -51,11 +51,11 @@ mod get_computer_name_a; mod get_cp_info; mod get_current_directory_a; mod get_current_directory_w; -mod get_current_process_id; mod get_current_process; +mod get_current_process_id; mod get_current_thread_id; -mod get_environment_strings_w; mod get_environment_strings; +mod get_environment_strings_w; mod get_file_attributes_a; mod get_file_attributes_w; mod get_file_type; @@ -80,8 +80,8 @@ mod get_string_type_w; mod get_system_directory_a; mod get_system_directory_w; mod get_system_info; -mod get_system_time_as_file_time; mod get_system_time; +mod get_system_time_as_file_time; mod get_system_windows_directory_a; mod get_system_windows_directory_w; mod get_temp_path_w; @@ -92,8 +92,8 @@ mod get_tick_count; mod get_time_zone_information; mod get_user_default_lang_id; mod get_user_default_ui_language; -mod get_version_ex_w; mod get_version; +mod get_version_ex_w; mod get_windows_directory_a; mod get_windows_directory_w; mod heap_alloc; @@ -101,9 +101,9 @@ mod heap_create; mod heap_destroy; mod heap_free; mod heap_set_information; +mod initialize_critical_section; mod initialize_critical_section_and_spin_count; mod initialize_critical_section_ex; -mod initialize_critical_section; mod interlocked_increment; mod is_debugger_present; mod is_processor_feature_present; @@ -127,8 +127,8 @@ mod map_view_of_file; mod move_file_a; mod move_file_w; mod multi_byte_to_wide_char; -mod open_process_token; mod open_process; +mod open_process_token; mod open_thread; mod query_performance_counter; mod raise_exception; @@ -161,14 +161,14 @@ mod tls_get_value; mod tls_set_value; mod unhandled_exception_filter; mod verify_version_info_w; -mod virtual_alloc_ex_numa; -mod virtual_alloc_ex; mod virtual_alloc; +mod virtual_alloc_ex; +mod virtual_alloc_ex_numa; mod virtual_free; -mod virtual_protect_ex; mod virtual_protect; -mod virtual_query_ex; +mod virtual_protect_ex; mod virtual_query; +mod virtual_query_ex; mod wait_for_single_object; mod wide_char_to_multi_byte; mod win_exec; @@ -216,17 +216,17 @@ pub use fls_set_value::*; pub use free_library::*; pub use free_resource::*; pub use get_acp::*; -pub use get_cp_info::*; pub use get_command_line_a::*; pub use get_command_line_w::*; pub use get_computer_name_a::*; +pub use get_cp_info::*; pub use get_current_directory_a::*; pub use get_current_directory_w::*; -pub use get_current_process_id::*; pub use get_current_process::*; +pub use get_current_process_id::*; pub use get_current_thread_id::*; -pub use get_environment_strings_w::*; pub use get_environment_strings::*; +pub use get_environment_strings_w::*; pub use get_file_attributes_a::*; pub use get_file_attributes_w::*; pub use get_file_type::*; @@ -251,8 +251,8 @@ pub use get_string_type_w::*; pub use get_system_directory_a::*; pub use get_system_directory_w::*; pub use get_system_info::*; -pub use get_system_time_as_file_time::*; pub use get_system_time::*; +pub use get_system_time_as_file_time::*; pub use get_system_windows_directory_a::*; pub use get_system_windows_directory_w::*; pub use get_temp_path_w::*; @@ -263,8 +263,8 @@ pub use get_tick_count::*; pub use get_time_zone_information::*; pub use get_user_default_lang_id::*; pub use get_user_default_ui_language::*; -pub use get_version_ex_w::*; pub use get_version::*; +pub use get_version_ex_w::*; pub use get_windows_directory_a::*; pub use get_windows_directory_w::*; pub use heap_alloc::*; @@ -272,9 +272,9 @@ pub use heap_create::*; pub use heap_destroy::*; pub use heap_free::*; pub use heap_set_information::*; +pub use initialize_critical_section::*; pub use initialize_critical_section_and_spin_count::*; pub use initialize_critical_section_ex::*; -pub use initialize_critical_section::*; pub use interlocked_increment::*; pub use is_debugger_present::*; pub use is_processor_feature_present::*; @@ -298,8 +298,8 @@ pub use map_view_of_file::*; pub use move_file_a::*; pub use move_file_w::*; pub use multi_byte_to_wide_char::*; -pub use open_process_token::*; pub use open_process::*; +pub use open_process_token::*; pub use open_thread::*; pub use query_performance_counter::*; pub use raise_exception::*; @@ -332,14 +332,14 @@ pub use tls_get_value::*; pub use tls_set_value::*; pub use unhandled_exception_filter::*; pub use verify_version_info_w::*; -pub use virtual_alloc_ex_numa::*; -pub use virtual_alloc_ex::*; pub use virtual_alloc::*; +pub use virtual_alloc_ex::*; +pub use virtual_alloc_ex_numa::*; pub use virtual_free::*; -pub use virtual_protect_ex::*; pub use virtual_protect::*; -pub use virtual_query_ex::*; +pub use virtual_protect_ex::*; pub use virtual_query::*; +pub use virtual_query_ex::*; pub use wait_for_single_object::*; pub use wide_char_to_multi_byte::*; pub use win_exec::*; @@ -709,7 +709,6 @@ pub fn guess_api_name(emu: &mut emu::Emu, addr: u32) -> String { pub fn load_library(emu: &mut emu::Emu, libname: &str) -> u64 { let mut dll = libname.to_string().to_lowercase(); - if dll.is_empty() { emu.regs_mut().rax = 0; return 0; diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_a.rs index 501910a8..6f4b20b9 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_a.rs @@ -13,15 +13,10 @@ pub fn MoveFileA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); let dst = emu.maps.read_string(dst_ptr); - log_red!( - emu, - "kernel32!MoveFileA `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!MoveFileA `{}` to `{}`", src, dst); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_w.rs index af34ad45..2f65a453 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/move_file_w.rs @@ -13,15 +13,10 @@ pub fn MoveFileW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); let dst = emu.maps.read_wide_string(dst_ptr); - log_red!( - emu, - "kernel32!MoveFileW `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!MoveFileW `{}` to `{}`", src, dst); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/multi_byte_to_wide_char.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/multi_byte_to_wide_char.rs index 18c2daed..da7ec127 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/multi_byte_to_wide_char.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/multi_byte_to_wide_char.rs @@ -48,4 +48,4 @@ pub fn MultiByteToWideChar(emu: &mut emu::Emu) { emu.maps.write_string(wide_ptr, &wide); } emu.regs_mut().rax = wide.len() as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/open_process.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/open_process.rs index a9683040..7c571fd2 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/open_process.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/open_process.rs @@ -15,11 +15,7 @@ pub fn OpenProcess(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!OpenProcess cannot read pid"); - log_red!( - emu, - "kernel32!OpenProcess pid: {}", - pid - ); + log_red!(emu, "kernel32!OpenProcess pid: {}", pid); emu.stack_pop32(false); emu.stack_pop32(false); @@ -27,4 +23,4 @@ pub fn OpenProcess(emu: &mut emu::Emu) { let uri = format!("pid://{}", pid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/open_process_token.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/open_process_token.rs index cc679a85..57c5899c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/open_process_token.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/open_process_token.rs @@ -15,12 +15,7 @@ pub fn OpenProcessToken(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp + 8) .expect("kernel32!OpenProcessToken error reading param") as u64; - log_red!( - emu, - "kernel32!OpenProcessToken 0x{:x} {}", - hndl, - access - ); + log_red!(emu, "kernel32!OpenProcessToken 0x{:x} {}", hndl, access); emu.maps.write_dword( ptr_token, @@ -31,4 +26,4 @@ pub fn OpenProcessToken(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/open_thread.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/open_thread.rs index ba2b9b5b..31ada34c 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/open_thread.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/open_thread.rs @@ -15,11 +15,7 @@ pub fn OpenThread(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!OpenThread cannot read tid"); - log_red!( - emu, - "kernel32!OpenThread tid: {}", - tid - ); + log_red!(emu, "kernel32!OpenThread tid: {}", tid); emu.stack_pop32(false); emu.stack_pop32(false); @@ -27,4 +23,4 @@ pub fn OpenThread(emu: &mut emu::Emu) { let uri = format!("tid://{}", tid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/query_performance_counter.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/query_performance_counter.rs index 435cf514..994e6ec5 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/query_performance_counter.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/query_performance_counter.rs @@ -8,12 +8,9 @@ pub fn QueryPerformanceCounter(emu: &mut emu::Emu) { emu.maps.write_dword(counter_ptr, 0x1); - log_red!( - emu, - "kernel32!QueryPerformanceCounter" - ); + log_red!(emu, "kernel32!QueryPerformanceCounter"); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/raise_exception.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/raise_exception.rs index bad660f9..58b626a7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/raise_exception.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/raise_exception.rs @@ -18,12 +18,7 @@ pub fn RaiseException(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 12) .expect("kernel32!RaiseException cannot read args"); - log_red!( - emu, - "kernel32!RaiseException {} {}", - code, - flags - ); + log_red!(emu, "kernel32!RaiseException {} {}", code, flags); for _ in 0..4 { emu.stack_pop32(false); @@ -31,4 +26,4 @@ pub fn RaiseException(emu: &mut emu::Emu) { emu.regs_mut().rax = 0; //std::process::exit(1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/read_file.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/read_file.rs index bac90baa..8f359648 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/read_file.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/read_file.rs @@ -61,4 +61,4 @@ pub fn ReadFile(emu: &mut emu::Emu) { for _ in 0..5 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/read_process_memory.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/read_process_memory.rs index 76e5cbda..557b2bb2 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/read_process_memory.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/read_process_memory.rs @@ -39,4 +39,4 @@ pub fn ReadProcessMemory(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_close_key.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_close_key.rs index 34168d8e..2e1d9fec 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_close_key.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_close_key.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn RegCloseKey(emu: &mut emu::Emu) { let hKey = emu @@ -7,11 +7,7 @@ pub fn RegCloseKey(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!RegCloseKey: error reading param") as u64; - log_red!( - emu, - "kernel32!RegCloseKey hkey: 0x{:x}", - hKey - ); + log_red!(emu, "kernel32!RegCloseKey hkey: 0x{:x}", hKey); emu.stack_pop32(false); emu.regs_mut().rax = constants::ERROR_SUCCESS; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_a.rs index 4314e7c5..64580f2f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_a.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn RegCreateKeyExA(emu: &mut emu::Emu) { let hKey = emu @@ -33,15 +33,10 @@ pub fn RegCreateKeyExA(emu: &mut emu::Emu) { class_name = emu.maps.read_string(class_ptr); } - log_red!( - emu, - "kernel32!RegCreateKeyExA {} {}", - subkey, - class_name - ); + log_red!(emu, "kernel32!RegCreateKeyExA {} {}", subkey, class_name); emu.regs_mut().rax = constants::ERROR_SUCCESS; for _ in 0..9 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_w.rs index d2ccf9f1..bada5d5e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_create_key_ex_w.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn RegCreateKeyExW(emu: &mut emu::Emu) { let hKey = emu @@ -33,15 +33,10 @@ pub fn RegCreateKeyExW(emu: &mut emu::Emu) { class_name = emu.maps.read_wide_string(class_ptr); } - log_red!( - emu, - "kernel32!RegCreateKeyExW {} {}", - subkey, - class_name - ); + log_red!(emu, "kernel32!RegCreateKeyExW {} {}", subkey, class_name); emu.regs_mut().rax = constants::ERROR_SUCCESS; for _ in 0..9 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_a.rs index 38d575b4..604561e6 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_a.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::winapi::helper; -use crate::constants; pub fn RegOpenKeyA(emu: &mut emu::Emu) { let hKey = emu @@ -22,14 +22,10 @@ pub fn RegOpenKeyA(emu: &mut emu::Emu) { helper::handler_create(&format!("key://{}", subkey)) as u32, ); - log_red!( - emu, - "kernel32!RegOpenKeyA `{}`", - subkey - ); + log_red!(emu, "kernel32!RegOpenKeyA `{}`", subkey); emu.regs_mut().rax = constants::ERROR_SUCCESS; for _ in 0..3 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_ex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_ex_w.rs index 63dcbedd..f688ed39 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_ex_w.rs @@ -23,15 +23,11 @@ pub fn RegOpenKeyExW(emu: &mut emu::Emu) { .expect("kernel32!RegOpenKeyExW cannot read result"); let subkey = emu.maps.read_wide_string(subkey_ptr); - log_red!( - emu, - "kernel32!RegOpenKeyExW {}", - subkey - ); + log_red!(emu, "kernel32!RegOpenKeyExW {}", subkey); for _ in 0..5 { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_w.rs index cf752fa2..508b8b4f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_open_key_w.rs @@ -1,6 +1,6 @@ +use crate::constants; use crate::emu; use crate::winapi::helper; -use crate::constants; pub fn RegOpenKeyW(emu: &mut emu::Emu) { let hKey = emu @@ -22,14 +22,10 @@ pub fn RegOpenKeyW(emu: &mut emu::Emu) { helper::handler_create(&format!("key://{}", subkey)) as u32, ); - log_red!( - emu, - "kernel32!RegOpenKeyW `{}`", - subkey - ); + log_red!(emu, "kernel32!RegOpenKeyW `{}`", subkey); emu.regs_mut().rax = constants::ERROR_SUCCESS; for _ in 0..3 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_a.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_a.rs index 3ebd3c97..08b8973d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_a.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_a.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn RegSetValueExA(emu: &mut emu::Emu) { let hKey = emu @@ -41,4 +41,4 @@ pub fn RegSetValueExA(emu: &mut emu::Emu) { for _ in 0..6 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_w.rs index 836c143c..1a357456 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/reg_set_value_ex_w.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn RegSetValueExW(emu: &mut emu::Emu) { let hKey = emu @@ -41,4 +41,4 @@ pub fn RegSetValueExW(emu: &mut emu::Emu) { for _ in 0..6 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/resume_thread.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/resume_thread.rs index dcb59fb2..ef60e17b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/resume_thread.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/resume_thread.rs @@ -6,13 +6,9 @@ pub fn ResumeThread(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!ResumeThread cannot read the handle"); - log_red!( - emu, - "kernel32!ResumeThread hndl: {}", - hndl - ); + log_red!(emu, "kernel32!ResumeThread hndl: {}", hndl); emu.stack_pop32(false); emu.regs_mut().rax = 1; // previous suspend count -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_error_mode.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_error_mode.rs index 270a6219..eed042d4 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_error_mode.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_error_mode.rs @@ -6,13 +6,9 @@ pub fn SetErrorMode(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!SetErrorMode cannot read mode param"); - log_red!( - emu, - "kernel32!SetErrorMode 0x{:x}", - mode - ); + log_red!(emu, "kernel32!SetErrorMode 0x{:x}", mode); emu.stack_pop32(false); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_handle_count.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_handle_count.rs index 57e3ddef..d68adae0 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_handle_count.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_handle_count.rs @@ -6,12 +6,8 @@ pub fn SetHandleCount(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp) .expect("kernel32!SetHandleCount error getting num param"); - log_red!( - emu, - "kernel32!SetHandleCount {}", - num - ); + log_red!(emu, "kernel32!SetHandleCount {}", num); emu.stack_pop32(false); emu.regs_mut().rax = num as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_last_error.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_last_error.rs index 7c43155e..d058c87d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_last_error.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_last_error.rs @@ -7,14 +7,10 @@ pub fn SetLastError(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!SetLastError cannot read err_code"); - log_red!( - emu, - "kernel32!SetLastError err: {}", - err_code - ); + log_red!(emu, "kernel32!SetLastError err: {}", err_code); let mut err = LAST_ERROR.lock().unwrap(); *err = err_code; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_context.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_context.rs index 41e20e9e..d1f675f1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_context.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_context.rs @@ -12,10 +12,7 @@ pub fn SetThreadContext(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!SetThreadContext cannot read the ctx_ptr"); - log_red!( - emu, - "kernel32!SetThreadContext" - ); + log_red!(emu, "kernel32!SetThreadContext"); let con = console::Console::new(); con.print("apply the context (y/n)?"); @@ -31,4 +28,4 @@ pub fn SetThreadContext(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_locale.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_locale.rs index 9a36cbff..c38e0686 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_locale.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_thread_locale.rs @@ -6,12 +6,8 @@ pub fn SetThreadLocale(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!SetThreadLocale cannot read locale param"); - log_red!( - emu, - "kernel32!SetThreadLocale {}", - locale - ); + log_red!(emu, "kernel32!SetThreadLocale {}", locale); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/set_unhandled_exception_filter.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/set_unhandled_exception_filter.rs index 8b3bc988..626c257b 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/set_unhandled_exception_filter.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/set_unhandled_exception_filter.rs @@ -16,4 +16,4 @@ pub fn SetUnhandledExceptionFilter(emu: &mut emu::Emu) { emu.set_seh(callback); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/sizeof_resource.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/sizeof_resource.rs index 45247cb2..ca55f910 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/sizeof_resource.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/sizeof_resource.rs @@ -31,4 +31,4 @@ pub fn SizeofResource(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/sleep.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/sleep.rs index 9753db51..e3e6c82f 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/sleep.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/sleep.rs @@ -6,13 +6,9 @@ pub fn Sleep(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!Sleep cannot read millis"); - log_red!( - emu, - "kernel32!Sleep millis: {}", - millis - ); + log_red!(emu, "kernel32!Sleep millis: {}", millis); emu.tick += millis as usize; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/system_time_to_tz_specific_local_time.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/system_time_to_tz_specific_local_time.rs index 3ca399cb..040f42cc 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/system_time_to_tz_specific_local_time.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/system_time_to_tz_specific_local_time.rs @@ -14,14 +14,11 @@ pub fn SystemTimeToTzSpecificLocalTime(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!SystemTimeToTzSpecificLocalTime cannot read lt_ptr"); - log_red!( - emu, - "kernel32!SystemTimeToTzSpecificLocalTime" - ); + log_red!(emu, "kernel32!SystemTimeToTzSpecificLocalTime"); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/terminate_process.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/terminate_process.rs index da67db07..0e8a9468 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/terminate_process.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/terminate_process.rs @@ -20,4 +20,4 @@ pub fn TerminateProcess(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_first.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_first.rs index 493a1edd..bffe22f2 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_first.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_first.rs @@ -10,13 +10,10 @@ pub fn Thread32First(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!Thread32First cannot read the entry32"); - log_red!( - emu, - "kernel32!Thread32First" - ); + log_red!(emu, "kernel32!Thread32First"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_next.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_next.rs index d3949681..a089e2e7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_next.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/thread32_next.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn Thread32Next(emu: &mut emu::Emu) { let hndl = emu @@ -11,13 +11,10 @@ pub fn Thread32Next(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!Thread32Next cannot read the entry32"); - log_red!( - emu, - "kernel32!Thread32Next" - ); + log_red!(emu, "kernel32!Thread32Next"); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_alloc.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_alloc.rs index e714b6a3..daa47ab1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_alloc.rs @@ -1,12 +1,9 @@ use crate::emu; pub fn TlsAlloc(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!TlsAlloc" - ); + log_red!(emu, "kernel32!TlsAlloc"); emu.tls32_mut().push(0); let tls_len = emu.tls32().len() as u64; emu.regs_mut().set_eax(tls_len); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_free.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_free.rs index 3a8cb2ba..f942d97d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_free.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_free.rs @@ -6,12 +6,8 @@ pub fn TlsFree(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("kernel32!TlsFree cannot read idx"); - log_red!( - emu, - "kernel32!TlsFree idx: {}", - idx - ); + log_red!(emu, "kernel32!TlsFree idx: {}", idx); emu.stack_pop32(false); emu.regs_mut().set_eax(1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_get_value.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_get_value.rs index 7d84c130..47463277 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_get_value.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_get_value.rs @@ -22,4 +22,4 @@ pub fn TlsGetValue(emu: &mut emu::Emu) { idx, emu.regs().get_eax() as u32 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_set_value.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_set_value.rs index 3e394b1e..abe7782d 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/tls_set_value.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/tls_set_value.rs @@ -10,12 +10,7 @@ pub fn TlsSetValue(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("kernel32!TlsSetValue cannot read val_ptr"); - log_red!( - emu, - "kernel32!TlsSetValue idx: {} val: 0x{:x}", - idx, - val - ); + log_red!(emu, "kernel32!TlsSetValue idx: {} val: 0x{:x}", idx, val); if emu.tls32().len() > idx as usize { emu.tls32_mut()[idx as usize] = val; @@ -29,4 +24,4 @@ pub fn TlsSetValue(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().set_eax(1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/unhandled_exception_filter.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/unhandled_exception_filter.rs index 12c1da52..ed160eed 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/unhandled_exception_filter.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/unhandled_exception_filter.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn UnhandledExceptionFilter(emu: &mut emu::Emu) { let exception_info = emu @@ -16,4 +16,4 @@ pub fn UnhandledExceptionFilter(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.regs_mut().rax = constants::EXCEPTION_EXECUTE_HANDLER as u64; // a debugger would had answered EXCEPTION_CONTINUE_SEARCH -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/verify_version_info_w.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/verify_version_info_w.rs index d9a4216e..11fb4170 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/verify_version_info_w.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/verify_version_info_w.rs @@ -1,13 +1,10 @@ use crate::emu; pub fn VerifyVersionInfoW(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!VerifyVersionInfoW" - ); + log_red!(emu, "kernel32!VerifyVersionInfoW"); emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 0xffff; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc.rs index 964426e7..97c2c138 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc.rs @@ -1,5 +1,17 @@ -use crate::emu; use crate::constants; +use crate::emu; +use crate::maps::mem64::Permission; + +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; pub fn VirtualAlloc(emu: &mut emu::Emu) { let addr = emu @@ -18,7 +30,22 @@ pub fn VirtualAlloc(emu: &mut emu::Emu) { .maps .read_dword(emu.regs().get_esp() + 12) .expect("kernel32!VirtualAlloc error reading protect"); + let can_read = (protect + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + let can_execute = (protect + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; let mem_reserve = (atype & constants::MEM_RESERVE) != 0; let mem_commit = (atype & constants::MEM_COMMIT) != 0; @@ -36,7 +63,12 @@ pub fn VirtualAlloc(emu: &mut emu::Emu) { .expect("kernel32!VirtualAlloc out of memory"); } emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAlloc out of memory"); } else { if mem_commit && emu.maps.is_allocated(addr) { diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex.rs index 969d4552..990ebeeb 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex.rs @@ -1,4 +1,16 @@ use crate::emu; +use crate::maps::mem64::Permission; + +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; pub fn VirtualAllocEx(emu: &mut emu::Emu) { let proc_hndl = emu @@ -22,6 +34,23 @@ pub fn VirtualAllocEx(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("kernel32!VirtualAllocEx cannot read the protect"); + let can_read = (protect + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + log_red!( emu, "kernel32!VirtualAllocEx hproc: 0x{:x} addr: 0x{:x}", @@ -34,7 +63,12 @@ pub fn VirtualAllocEx(emu: &mut emu::Emu) { .alloc(size) .expect("kernel32!VirtualAllocEx out of memory"); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAllocEx out of memory"); emu.regs_mut().rax = base; @@ -42,4 +76,4 @@ pub fn VirtualAllocEx(emu: &mut emu::Emu) { for _ in 0..5 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex_numa.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex_numa.rs index ef872c8d..d18767d6 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex_numa.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_alloc_ex_numa.rs @@ -1,4 +1,16 @@ use crate::emu; +use crate::maps::mem64::Permission; + +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { let proc_hndl = @@ -26,6 +38,23 @@ pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 20) .expect("kernel32!VirtualAllocExNuma cannot read the nndPreferred"); + let can_read = (protect + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + log_red!( emu, "kernel32!VirtualAllocExNuma hproc: 0x{:x} addr: 0x{:x}", @@ -38,7 +67,12 @@ pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { .alloc(size) .expect("kernel32!VirtualAllocExNuma out of memory"); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAllocExNuma out of memory"); emu.regs_mut().rax = base; @@ -46,4 +80,4 @@ pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { for _ in 0..6 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_free.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_free.rs index a45e354c..d9914226 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_free.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_free.rs @@ -14,12 +14,7 @@ pub fn VirtualFree(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("kernel32!VirtualFree cannot read size") as u64; - log_red!( - emu, - "kernel32!VirtualFree 0x{:x} {}", - addr, - size - ); + log_red!(emu, "kernel32!VirtualFree 0x{:x} {}", addr, size); match emu.maps.get_mem_by_addr(addr) { Some(mem) => { @@ -34,4 +29,4 @@ pub fn VirtualFree(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect.rs index 696dbb49..7f6656a6 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect.rs @@ -33,4 +33,4 @@ pub fn VirtualProtect(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect_ex.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect_ex.rs index b29f8279..84386bd1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect_ex.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_protect_ex.rs @@ -38,4 +38,4 @@ pub fn VirtualProtectEx(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query.rs index 3f481970..71c12683 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query.rs @@ -35,4 +35,4 @@ pub fn VirtualQuery(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query_ex.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query_ex.rs index 95693f46..6b7fcfaa 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query_ex.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/virtual_query_ex.rs @@ -40,4 +40,4 @@ pub fn VirtualQueryEx(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/wait_for_single_object.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/wait_for_single_object.rs index e5abc616..a7f337a1 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/wait_for_single_object.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/wait_for_single_object.rs @@ -1,5 +1,5 @@ -use crate::emu; use crate::constants; +use crate::emu; pub fn WaitForSingleObject(emu: &mut emu::Emu) { let handle = emu @@ -21,4 +21,4 @@ pub fn WaitForSingleObject(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = constants::WAIT_TIMEOUT; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/wide_char_to_multi_byte.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/wide_char_to_multi_byte.rs index 1b7a76cf..95172365 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/wide_char_to_multi_byte.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/wide_char_to_multi_byte.rs @@ -58,4 +58,4 @@ pub fn WideCharToMultiByte(emu: &mut emu::Emu) { emu.stack_pop32(false); } emu.regs_mut().rax = s.len() as u64 + 2; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/win_exec.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/win_exec.rs index eb14e5b2..1e43177e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/win_exec.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/win_exec.rs @@ -9,12 +9,8 @@ pub fn WinExec(emu: &mut emu::Emu) { //emu.spawn_console(); - log_red!( - emu, - "WinExec '{}'", - cmdline - ); + log_red!(emu, "WinExec '{}'", cmdline); emu.regs_mut().rax = 0; emu.stack_pop32(false); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/write_file.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/write_file.rs index 3ea5afaa..06b6a9b7 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/write_file.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/write_file.rs @@ -45,4 +45,4 @@ pub fn WriteFile(emu: &mut emu::Emu) { emu.stack_pop32(false); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernel32/write_process_memory.rs b/crates/libmwemu/src/winapi/winapi32/kernel32/write_process_memory.rs index f2c050c2..4228ed4e 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernel32/write_process_memory.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernel32/write_process_memory.rs @@ -50,4 +50,4 @@ pub fn WriteProcessMemory(emu: &mut emu::Emu) { for _ in 0..5 { emu.stack_pop32(false); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi32/kernelbase.rs b/crates/libmwemu/src/winapi/winapi32/kernelbase.rs index 6934ff8e..97a72229 100644 --- a/crates/libmwemu/src/winapi/winapi32/kernelbase.rs +++ b/crates/libmwemu/src/winapi/winapi32/kernelbase.rs @@ -4,8 +4,8 @@ use crate::emu; //use crate::context32; //use crate::peb32; //use crate::structures; -use crate::winapi::helper; use crate::serialization; +use crate::winapi::helper; use crate::winapi::winapi32::kernel32; use lazy_static::lazy_static; @@ -78,16 +78,11 @@ fn GetModuleHandleW(emu: &mut emu::Emu) { emu.regs_mut().rax = mod_mem.get_base(); } - log_red!( - emu, - "kernel32!GetModuleHandleW '{}'", - mod_name - ); + log_red!(emu, "kernel32!GetModuleHandleW '{}'", mod_name); emu.stack_pop32(false); } - fn LoadStringW(emu: &mut emu::Emu) { let hndl = emu .maps @@ -106,12 +101,7 @@ fn LoadStringW(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp + 12) .expect("kernelbase!LoadStringW error reading param"); - log_red!( - emu, - "kernelbase!LoadStringW {} 0x{}", - id, - buff - ); + log_red!(emu, "kernelbase!LoadStringW {} 0x{}", id, buff); emu.stack_pop32(false); emu.stack_pop32(false); @@ -129,12 +119,7 @@ fn _initterm(emu: &mut emu::Emu) { .maps .read_dword(emu.regs().rsp + 4) .expect("kernelbase!_initterm error reading param"); - log_red!( - emu, - "kernelbase!_initterm 0x{:x} 0x{:x}", - ptr1, - ptr2 - ); + log_red!(emu, "kernelbase!_initterm 0x{:x} 0x{:x}", ptr1, ptr2); emu.stack_pop32(false); emu.stack_pop32(false); emu.regs_mut().rax = 0; @@ -149,14 +134,9 @@ fn _initterm_e(emu: &mut emu::Emu) { .maps .read_dword(emu.regs().rsp + 4) .expect("kernelbase!_initterm_e error reading param"); - log_red!( - emu, - "kernelbase!_initterm_e 0x{:x} 0x{:x}", - ptr1, - ptr2 - ); + log_red!(emu, "kernelbase!_initterm_e 0x{:x} 0x{:x}", ptr1, ptr2); + emu.stack_pop32(false); emu.stack_pop32(false); -emu.stack_pop32(false); emu.regs_mut().rax = 0; } @@ -166,15 +146,10 @@ fn SetUnhandledExceptionFilter(emu: &mut emu::Emu) { .read_dword(emu.regs().rsp) .expect("kernelbase!SetUnhandledExceptionFilter error reading param"); - log_red!( - emu, - "kernelbase!SetUnhandledExceptionFilter 0x{:x}", - ptr1 - ); + log_red!(emu, "kernelbase!SetUnhandledExceptionFilter 0x{:x}", ptr1); emu.set_uef(ptr1 as u64); emu.stack_pop32(false); emu.regs_mut().rax = 0; } - diff --git a/crates/libmwemu/src/winapi/winapi32/libgcc.rs b/crates/libmwemu/src/winapi/winapi32/libgcc.rs index 6e22f4b8..0e7b8c57 100644 --- a/crates/libmwemu/src/winapi/winapi32/libgcc.rs +++ b/crates/libmwemu/src/winapi/winapi32/libgcc.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; //use crate::constants::*; //use crate::winapi::helper; use crate::serialization; @@ -44,18 +45,13 @@ fn __register_frame_info(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("advapi32!__register_frame_info error reading param"); - log_red!( - emu, - "libgcc!__register_frame_info {:x} {:x}", - p1, - p2 - ); + log_red!(emu, "libgcc!__register_frame_info {:x} {:x}", p1, p2); let mem = match emu.maps.get_mem_by_addr_mut(0x40E198) { Some(m) => m, None => emu .maps - .create_map("glob1", 0x40E198, 100) + .create_map("glob1", 0x40E198, 100, Permission::READ_WRITE_EXECUTE) .expect("cannot create glob1 map"), }; @@ -73,11 +69,7 @@ fn __deregister_frame_info(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("advapi32!__deregister_frame_info error reading param"); - log_red!( - emu, - "libgcc!__deregister_frame_info {:x}", - p1 - ); + log_red!(emu, "libgcc!__deregister_frame_info {:x}", p1); emu.stack_pop32(false); emu.regs_mut().rax = 1; diff --git a/crates/libmwemu/src/winapi/winapi32/mscoree.rs b/crates/libmwemu/src/winapi/winapi32/mscoree.rs index f7b0a080..59828b62 100644 --- a/crates/libmwemu/src/winapi/winapi32/mscoree.rs +++ b/crates/libmwemu/src/winapi/winapi32/mscoree.rs @@ -32,10 +32,7 @@ pub fn gateway(addr: u32, emu: &mut emu::Emu) -> String { } pub fn _CorExeMain(emu: &mut emu::Emu) { - log_red!( - emu, - "mscoree!_CorExeMain" - ); + log_red!(emu, "mscoree!_CorExeMain"); emu.regs_mut().rax = 1; unimplemented!(); } diff --git a/crates/libmwemu/src/winapi/winapi32/msvcrt.rs b/crates/libmwemu/src/winapi/winapi32/msvcrt.rs index e24337dd..5db618f3 100644 --- a/crates/libmwemu/src/winapi/winapi32/msvcrt.rs +++ b/crates/libmwemu/src/winapi/winapi32/msvcrt.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::winapi::helper; use crate::winapi::winapi32::kernel32; @@ -80,12 +81,7 @@ fn _initterm(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("msvcrt!_initterm_e: error reading end pointer") as u64; - log_red!( - emu, - "msvcrt!_initterm 0x{:x} - 0x{:x}", - start_ptr, - end_ptr - ); + log_red!(emu, "msvcrt!_initterm 0x{:x} - 0x{:x}", start_ptr, end_ptr); emu.regs_mut().rax = 0; } @@ -102,22 +98,14 @@ fn StrCmpCA(emu: &mut emu::Emu) { if str1_ptr == 0 || str2_ptr == 0 { emu.regs_mut().rax = 0xffffffff; - log_red!( - emu, - "msvcrt!StrCmpA null ptrs" - ); + log_red!(emu, "msvcrt!StrCmpA null ptrs"); return; } let str1 = emu.maps.read_string(str1_ptr); let str2 = emu.maps.read_string(str2_ptr); - log_red!( - emu, - "msvcrt!StrCmpA {} == {}", - str1, - str2 - ); + log_red!(emu, "msvcrt!StrCmpA {} == {}", str1, str2); if str1 == str2 { emu.regs_mut().rax = 0; @@ -138,22 +126,14 @@ fn fopen(emu: &mut emu::Emu) { if filepath_ptr == 0 || mode_ptr == 0 { emu.regs_mut().rax = 0xffffffff; - log_red!( - emu, - "msvcrt!fopen null ptrs" - ); + log_red!(emu, "msvcrt!fopen null ptrs"); return; } let filepath = emu.maps.read_string(filepath_ptr); let mode = emu.maps.read_string(mode_ptr); - log_red!( - emu, - "msvcrt!fopen `{}` fmt:`{}`", - filepath, - mode - ); + log_red!(emu, "msvcrt!fopen `{}` fmt:`{}`", filepath, mode); emu.regs_mut().rax = helper::handler_create(&filepath); } @@ -197,11 +177,7 @@ fn fflush(emu: &mut emu::Emu) { let filename = helper::handler_get_uri(file as u64); - log_red!( - emu, - "msvcrt!fflush `{}`", - filename - ); + log_red!(emu, "msvcrt!fflush `{}`", filename); //emu.stack_pop32(false); @@ -216,20 +192,13 @@ fn fclose(emu: &mut emu::Emu) { let filename = helper::handler_get_uri(file as u64); - log_red!( - emu, - "msvcrt!fclose `{}`", - filename - ); + log_red!(emu, "msvcrt!fclose `{}`", filename); emu.regs_mut().rax = 1; } fn __p___argv(emu: &mut emu::Emu) { - log_red!( - emu, - "msvcrt!__p___argc" - ); + log_red!(emu, "msvcrt!__p___argc"); emu.regs_mut().rax = 0; } @@ -239,17 +208,13 @@ fn __p___argc(emu: &mut emu::Emu) { None => { let addr = emu.maps.alloc(1024).expect("out of memory"); emu.maps - .create_map("args", addr, 1024) + .create_map("args", addr, 1024, Permission::READ_WRITE) .expect("cannot create args map") .get_base() } }; - log_red!( - emu, - "msvcrt!__p___argc {}", - args_base - ); + log_red!(emu, "msvcrt!__p___argc {}", args_base); emu.regs_mut().rax = args_base; } @@ -264,15 +229,15 @@ fn malloc(emu: &mut emu::Emu) { let base = emu.maps.alloc(size).expect("msvcrt!malloc out of memory"); emu.maps - .create_map(&format!("alloc_{:x}", base), base, size) + .create_map( + &format!("alloc_{:x}", base), + base, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!malloc cannot create map"); - log_red!( - emu, - "msvcrt!malloc sz: {} addr: 0x{:x}", - size, - base - ); + log_red!(emu, "msvcrt!malloc sz: {} addr: 0x{:x}", size, base); emu.regs_mut().rax = base; } else { @@ -281,10 +246,7 @@ fn malloc(emu: &mut emu::Emu) { } fn __p__acmdln(emu: &mut emu::Emu) { - log_red!( - emu, - "msvcrt!__p___argc" - ); + log_red!(emu, "msvcrt!__p___argc"); emu.regs_mut().rax = 0; } @@ -294,11 +256,7 @@ fn _onexit(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("msvcrt!_onexit") as u64; - log_red!( - emu, - "msvcrt!_onexit 0x{:x}", - fptr - ); + log_red!(emu, "msvcrt!_onexit 0x{:x}", fptr); emu.regs_mut().rax = fptr; } @@ -309,11 +267,7 @@ fn _lock(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("msvcrt!_lock"); - log_red!( - emu, - "msvcrt!_lock {}", - lock_num - ); + log_red!(emu, "msvcrt!_lock {}", lock_num); emu.regs_mut().rax = 1; } @@ -324,11 +278,7 @@ fn free(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("msvcrt!free error reading addr"); - log_red!( - emu, - "msvcrt!free 0x{:x}", - addr - ); + log_red!(emu, "msvcrt!free 0x{:x}", addr); } fn realloc(emu: &mut emu::Emu) { @@ -343,22 +293,22 @@ fn realloc(emu: &mut emu::Emu) { if addr == 0 { if size == 0 { + emu.maps.dealloc(addr); emu.regs_mut().rax = 0; return; } else { let base = emu.maps.alloc(size).expect("msvcrt!malloc out of memory"); emu.maps - .create_map(&format!("alloc_{:x}", base), base, size) + .create_map( + &format!("alloc_{:x}", base), + base, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!malloc cannot create map"); - log_red!( - emu, - "msvcrt!realloc 0x{:x} {} =0x{:x}", - addr, - size, - base - ); + log_red!(emu, "msvcrt!realloc 0x{:x} {} =0x{:x}", addr, size, base); emu.regs_mut().rax = base; return; @@ -366,12 +316,7 @@ fn realloc(emu: &mut emu::Emu) { } if size == 0 { - log_red!( - emu, - "msvcrt!realloc 0x{:x} {} =0x1337", - addr, - size - ); + log_red!(emu, "msvcrt!realloc 0x{:x} {} =0x1337", addr, size); emu.regs_mut().rax = 0x1337; // weird msvcrt has to return a random unallocated pointer, and the program has to do free() on it return; @@ -386,7 +331,12 @@ fn realloc(emu: &mut emu::Emu) { let new_addr = emu.maps.alloc(size).expect("msvcrt!realloc out of memory"); emu.maps - .create_map(&format!("alloc_{:x}", new_addr), new_addr, size) + .create_map( + &format!("alloc_{:x}", new_addr), + new_addr, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!realloc cannot create map"); emu.maps.memcpy(new_addr, addr, prev_size); @@ -417,12 +367,7 @@ fn strtok(emu: &mut emu::Emu) { let str = emu.maps.read_string(str_ptr as u64); let delim = emu.maps.read_string(delim_ptr as u64); - log_red!( - emu, - "msvcrt!strtok `{}` `{}`", - str, - delim - ); + log_red!(emu, "msvcrt!strtok `{}` `{}`", str, delim); emu.regs_mut().rax = 0; } @@ -433,9 +378,5 @@ fn __set_app_type(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("msvcrt!__set_app_type error reading app_type"); - log_red!( - emu, - "msvcrt!__set_app_type app_type: 0x{:x}", - app_type - ); + log_red!(emu, "msvcrt!__set_app_type app_type: 0x{:x}", app_type); } diff --git a/crates/libmwemu/src/winapi/winapi32/ntdll.rs b/crates/libmwemu/src/winapi/winapi32/ntdll.rs index 74a2b54c..667dfe2a 100644 --- a/crates/libmwemu/src/winapi/winapi32/ntdll.rs +++ b/crates/libmwemu/src/winapi/winapi32/ntdll.rs @@ -7,8 +7,20 @@ use crate::structures; use crate::winapi::helper; use crate::winapi::winapi32::kernel32; +use crate::maps::mem64::Permission; use scan_fmt::scan_fmt_some; +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; + pub fn gateway(addr: u32, emu: &mut emu::Emu) -> String { let api = kernel32::guess_api_name(emu, addr); match api.as_str() { @@ -97,6 +109,30 @@ fn NtAllocateVirtualMemory(emu: &mut emu::Emu) { .read_dword(size_ptr) .expect("bad NtAllocateVirtualMemory size parameter") as u64; + let protection_offset = 20; + let protection_addr = emu.regs().rsp + protection_offset; + let protect_value = emu + .maps + .read_dword(protection_addr) + .expect("Failed to read Protection argument at NtAllocateVirtualMemory"); + + let can_read = (protect_value + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect_value + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect_value + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + let do_alloc: bool = if addr == 0 { true } else { @@ -131,6 +167,7 @@ fn NtAllocateVirtualMemory(emu: &mut emu::Emu) { format!("valloc_{:x}", alloc_addr).as_str(), alloc_addr, size, + Permission::from_flags(can_read, can_write, can_execute), ) .expect("ntdll!NtAllocateVirtualMemory cannot create map"); @@ -157,12 +194,7 @@ fn stricmp(emu: &mut emu::Emu) { let str1 = emu.maps.read_string(str1ptr); let str2 = emu.maps.read_string(str2ptr); - log_red!( - emu, - "ntdll!stricmp '{}'=='{}'?", - str1, - str2 - ); + log_red!(emu, "ntdll!stricmp '{}'=='{}'?", str1, str2); if str1 == str2 { emu.regs_mut().rax = 0; @@ -185,11 +217,7 @@ fn NtQueryVirtualMemory(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("ntdll!NtQueryVirtualMemory: error reading address") as u64; - log_red!( - emu, - "ntdll!NtQueryVirtualMemory addr: 0x{:x}", - addr - ); + log_red!(emu, "ntdll!NtQueryVirtualMemory addr: 0x{:x}", addr); if handle != 0xffffffff { log::info!("\tusing handle of remote process {:x}", handle); @@ -248,11 +276,7 @@ fn LdrLoadDll(emu: &mut emu::Emu) { .expect("LdrLoadDll: error reading lib base") as u64; let libname = emu.maps.read_wide_string(libname_ptr); - log_red!( - emu, - "ntdll!LdrLoadDll lib: {}", - libname - ); + log_red!(emu, "ntdll!LdrLoadDll lib: {}", libname); let base = kernel32::load_library(emu, &libname); emu.maps.write_dword(libname_ptr, base as u32); @@ -291,12 +315,17 @@ fn LdrLoadDll_gul(emu: &mut emu::Emu) { if libname == "user32.dll" { let user32 = emu .maps - .create_map("user32", 0x773b0000, 0x1000) + .create_map("user32", 0x773b0000, 0x1000, Permission::READ_WRITE) .expect("ntdll!LdrLoadDll_gul cannot create map"); user32.load("maps32/user32.bin"); let user32_text = emu .maps - .create_map("user32_text", 0x773b1000, 0x1000) + .create_map( + "user32_text", + 0x773b1000, + 0x1000, + Permission::READ_WRITE_EXECUTE, + ) .expect("ntdll!LdrLoadDll_gul cannot create map"); user32_text.load("maps32/user32_text.bin"); @@ -324,7 +353,8 @@ fn LdrLoadDll_gul(emu: &mut emu::Emu) { emu.regs_mut().rax = constants::STATUS_SUCCESS; - emu.maps.write_dword(emu.regs().get_ebp() + 0x168, 0x77570000); + emu.maps + .write_dword(emu.regs().get_ebp() + 0x168, 0x77570000); emu.regs_mut().rip = 0x682e5e2; } @@ -366,10 +396,7 @@ fn NtGetContextThread(emu: &mut emu::Emu) { .read_dword(ctx_ptr) .expect("ntdll_NtGetContextThread: error reading context ptr") as u64; - log_red!( - emu, - "ntdll_NtGetContextThread ctx" - ); + log_red!(emu, "ntdll_NtGetContextThread ctx"); let ctx = Context32::new(&emu.regs()); ctx.save(ctx_ptr2 as u32, &mut emu.maps); @@ -380,10 +407,7 @@ fn NtGetContextThread(emu: &mut emu::Emu) { } fn RtlExitUserThread(emu: &mut emu::Emu) { - log_red!( - emu, - "ntdll!RtlExitUserThread" - ); + log_red!(emu, "ntdll!RtlExitUserThread"); Console::spawn_console(emu); std::process::exit(1); } @@ -405,12 +429,7 @@ fn sscanf(emu: &mut emu::Emu) { let buffer = emu.maps.read_string(buffer_ptr); let fmt = emu.maps.read_string(fmt_ptr); - log_red!( - emu, - "ntdll!sscanf out_buff: `{}` fmt: `{}`", - buffer, - fmt - ); + log_red!(emu, "ntdll!sscanf out_buff: `{}` fmt: `{}`", buffer, fmt); let rust_fmt = fmt .replace("%x", "{x}") @@ -436,10 +455,7 @@ fn sscanf(emu: &mut emu::Emu) { } fn NtGetTickCount(emu: &mut emu::Emu) { - log_red!( - emu, - "ntdll!NtGetTickCount" - ); + log_red!(emu, "ntdll!NtGetTickCount"); emu.regs_mut().rax = emu.tick as u64; } @@ -454,10 +470,7 @@ fn NtQueryPerformanceCounter(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("ntdll!NtQueryPerformanceCounter error reading perf_freq_ptr") as u64; - log_red!( - emu, - "ntdll!NtQueryPerformanceCounter" - ); + log_red!(emu, "ntdll!NtQueryPerformanceCounter"); emu.maps.write_dword(perf_counter_ptr, 0); @@ -474,10 +487,7 @@ fn RtlGetProcessHeaps(emu: &mut emu::Emu) { let hndl = emu.maps.read_dword(emu.regs().get_esp()+4) .expect("ntdll!RtlGetProcessHeaps error reading handle param"); */ - log_red!( - emu, - "ntdll!RtlGetProcessHeaps" - ); + log_red!(emu, "ntdll!RtlGetProcessHeaps"); emu.stack_pop32(false); emu.stack_pop32(false); @@ -513,11 +523,7 @@ fn RtlDosPathNameToNtPathName_U(emu: &mut emu::Emu) { let dos_path_name = emu.maps.read_wide_string(dos_path_name_ptr); - log_red!( - emu, - "ntdll!RtlDosPathNameToNtPathName_U {}", - dos_path_name - ); + log_red!(emu, "ntdll!RtlDosPathNameToNtPathName_U {}", dos_path_name); //TODO: si la variable destino apunta a pila no hacer memcpy, solo si es un alloc_ @@ -571,7 +577,7 @@ fn RtlDosPathNameToNtPathName_U(emu: &mut emu::Emu) { match emu.maps.alloc(255) { Some(a) => { emu.maps - .create_map("nt_alloc", a, 255) + .create_map("nt_alloc", a, 255, Permission::READ_WRITE) .expect("ntdll!RtlDosPathNameToNtPathName_U cannot create map"); emu.maps.write_dword(nt_path_name_ptr, a as u32); emu.maps.memcpy( @@ -672,11 +678,7 @@ fn NtCreateFile(emu: &mut emu::Emu) { .expect("ntdll!NtCreateFile error reading oattrib +8") as u64; let filename = emu.maps.read_wide_string(obj_name_ptr); - log_red!( - emu, - "ntdll!NtCreateFile {}", - filename - ); + log_red!(emu, "ntdll!NtCreateFile {}", filename); if out_handle_ptr > 0 { emu.maps @@ -704,11 +706,7 @@ fn RtlFreeHeap(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("ntdll!RtlFreeHeap error reading base_addr param") as u64; - log_red!( - emu, - "ntdll!RtlFreeHeap 0x{}", - base_addr - ); + log_red!(emu, "ntdll!RtlFreeHeap 0x{}", base_addr); helper::handler_close(handle); @@ -716,11 +714,7 @@ fn RtlFreeHeap(emu: &mut emu::Emu) { emu.stack_pop32(false); emu.stack_pop32(false); - let name = emu - .maps - .get_addr_name(base_addr) - .unwrap_or("") - .to_string(); + let name = emu.maps.get_addr_name(base_addr).unwrap_or("").to_string(); if name.is_empty() { if emu.cfg.verbose >= 1 { log::info!("map not allocated, so cannot free it."); @@ -762,10 +756,7 @@ fn NtQueryInformationFile(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("ntdll!NtQueryInformationFile error reading fileinfocls param"); - log_red!( - emu, - "ntdll!NtQueryInformationFile" - ); + log_red!(emu, "ntdll!NtQueryInformationFile"); for _ in 0..5 { emu.stack_pop32(false); @@ -793,15 +784,15 @@ fn RtlAllocateHeap(emu: &mut emu::Emu) { .alloc(size) .expect("ntdll!RtlAllocateHeap out of memory"); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::READ_WRITE, + ) .expect("ntdll!RtlAllocateHeap cannot create map"); - log_red!( - emu, - "ntdll!RtlAllocateHeap sz: {} addr: 0x{:x}", - size, - base - ); + log_red!(emu, "ntdll!RtlAllocateHeap sz: {} addr: 0x{:x}", size, base); emu.regs_mut().rax = base; @@ -888,12 +879,7 @@ fn NtClose(emu: &mut emu::Emu) { let uri = helper::handler_get_uri(hndl); - log_red!( - emu, - "ntdll!NtClose hndl: 0x{:x} uri: {}", - hndl, - uri - ); + log_red!(emu, "ntdll!NtClose hndl: 0x{:x} uri: {}", hndl, uri); emu.stack_pop32(false); @@ -914,10 +900,7 @@ fn RtlInitializeCriticalSectionAndSpinCount(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("ntdll!RtlInitializeCriticalSectionAndSpinCount error reading spin_count param"); - log_red!( - emu, - "ntdll!RtlInitializeCriticalSectionAndSpinCount" - ); + log_red!(emu, "ntdll!RtlInitializeCriticalSectionAndSpinCount"); emu.stack_pop32(false); emu.stack_pop32(false); @@ -947,11 +930,7 @@ fn NtProtectVirtualMemory(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("ntdll!NtProtectVirtualMemory error reading old prot param") as u64; - log_red!( - emu, - "ntdll!NtProtectVirtualMemory sz: {}", - sz - ); + log_red!(emu, "ntdll!NtProtectVirtualMemory sz: {}", sz); for _ in 0..5 { emu.stack_pop32(false); @@ -970,10 +949,7 @@ fn CheckRemoteDebuggerPresent(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("ntdll!CheckRemoteDebuggerPresent reading bool ptr param") as u64; - log_red!( - emu, - "ntdll!CheckRemoteDebuggerPresent" - ); + log_red!(emu, "ntdll!CheckRemoteDebuggerPresent"); emu.maps.write_dword(bool_ptr, 0); emu.stack_pop32(false); @@ -988,10 +964,7 @@ fn RtlEnterCriticalSection(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("ntdll!RtlEnterCriticalSection error reading hndl param") as u64; - log_red!( - emu, - "ntdll!RtlEnterCriticalSection" - ); + log_red!(emu, "ntdll!RtlEnterCriticalSection"); emu.stack_pop32(false); emu.regs_mut().rax = 1; @@ -1003,10 +976,7 @@ fn RtlLeaveCriticalSection(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("ntdll!RtlLeaveCriticalSection error reading hndl param") as u64; - log_red!( - emu, - "ntdll!RtlLeaveCriticalSection" - ); + log_red!(emu, "ntdll!RtlLeaveCriticalSection"); emu.stack_pop32(false); emu.regs_mut().rax = 1; @@ -1019,10 +989,7 @@ fn RtlGetVersion(emu: &mut emu::Emu) { .expect("ntdll!RtlLeaveCriticalSection error reading versioninfo_ptr param") as u64; - log_red!( - emu, - "ntdll!RtlGetVersion" - ); + log_red!(emu, "ntdll!RtlGetVersion"); let versioninfo = structures::OsVersionInfoExA::new(); // TODO: should this be Ex? versioninfo.save(versioninfo_ptr, &mut emu.maps); @@ -1046,10 +1013,7 @@ fn RtlInitializeCriticalSectionEx(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("ntdll!RtlInitializeCriticalSectionEx error reading flags"); - log_red!( - emu, - "ntdll!RtlInitializeCriticalSectionEx" - ); + log_red!(emu, "ntdll!RtlInitializeCriticalSectionEx"); emu.stack_pop32(false); emu.stack_pop32(false); @@ -1114,22 +1078,14 @@ fn strlen(emu: &mut emu::Emu) { let s = emu.maps.read_string(s_ptr); let l = s.len(); - log_red!( - emu, - "ntdll!strlen: `{}` {}", - s, - l - ); + log_red!(emu, "ntdll!strlen: `{}` {}", s, l); emu.stack_pop32(false); emu.regs_mut().rax = l as u32 as u64; } fn VerSetConditionMask(emu: &mut emu::Emu) { - log_red!( - emu, - "ntdll!strlen:" - ); + log_red!(emu, "ntdll!strlen:"); emu.stack_pop32(false); emu.stack_pop32(false); @@ -1150,12 +1106,7 @@ fn strcat(emu: &mut emu::Emu) { let dst = emu.maps.read_string(dst_ptr); let src = emu.maps.read_string(src_ptr); - log_red!( - emu, - "ntdll!strcat: `{}`+`{}`", - src, - dst - ); + log_red!(emu, "ntdll!strcat: `{}`+`{}`", src, dst); let dst_cont_ptr = dst_ptr + dst.len() as u64; emu.maps.write_string(dst_cont_ptr, &src); diff --git a/crates/libmwemu/src/winapi/winapi32/oleaut32.rs b/crates/libmwemu/src/winapi/winapi32/oleaut32.rs index 3a862ddf..fd85cfc3 100644 --- a/crates/libmwemu/src/winapi/winapi32/oleaut32.rs +++ b/crates/libmwemu/src/winapi/winapi32/oleaut32.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::winapi::winapi32::kernel32; //use crate::winapi::helper; @@ -54,15 +55,11 @@ fn SysAllocStringLen(emu: &mut emu::Emu) { .alloc(size + 8) .expect("oleaut32!SysAllocStringLen out of memory"); let name = format!("alloc_{:x}", base + 8); - emu.maps.create_map(&name, base, size); + emu.maps + .create_map(&name, base, size, Permission::READ_WRITE); emu.maps.memcpy(base + 8, str_ptr, size as usize - 1); - log_red!( - emu, - "oleaut32!SysAllocStringLen ={} {}", - name, - size - 8 - ); + log_red!(emu, "oleaut32!SysAllocStringLen ={} {}", name, size - 8); for _ in 0..2 { emu.stack_pop32(false); @@ -77,11 +74,7 @@ fn SysFreeString(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("oleaut32!SysFreeString cannot read host_port") as u64; - log_red!( - emu, - "oleaut32!SysFreeString 0x{:x}", - str_ptr - ); + log_red!(emu, "oleaut32!SysFreeString 0x{:x}", str_ptr); //emu.maps.free(&format!("alloc_{:x}", str_ptr)); diff --git a/crates/libmwemu/src/winapi/winapi32/user32.rs b/crates/libmwemu/src/winapi/winapi32/user32.rs index dfdd55e3..136d708a 100644 --- a/crates/libmwemu/src/winapi/winapi32/user32.rs +++ b/crates/libmwemu/src/winapi/winapi32/user32.rs @@ -49,12 +49,7 @@ fn MessageBoxA(emu: &mut emu::Emu) { let msg = emu.maps.read_string(msgptr); let title = emu.maps.read_string(titleptr); - log_red!( - emu, - "user32!MessageBoxA {} {}", - title, - msg - ); + log_red!(emu, "user32!MessageBoxA {} {}", title, msg); emu.regs_mut().rax = 0; for _ in 0..4 { @@ -74,12 +69,7 @@ fn MessageBoxW(emu: &mut emu::Emu) { let msg = emu.maps.read_wide_string(msgptr); let title = emu.maps.read_wide_string(titleptr); - log_red!( - emu, - "user32!MessageBoxW {} {}", - title, - msg - ); + log_red!(emu, "user32!MessageBoxW {} {}", title, msg); emu.regs_mut().rax = 0; for _ in 0..4 { @@ -88,10 +78,7 @@ fn MessageBoxW(emu: &mut emu::Emu) { } fn GetDesktopWindow(emu: &mut emu::Emu) { - log_red!( - emu, - "user32!GetDesktopWindow" - ); + log_red!(emu, "user32!GetDesktopWindow"); //emu.regs_mut().rax = 0x11223344; // current window handle emu.regs_mut().rax = 0; // no windows handler is more stealthy } @@ -99,10 +86,7 @@ fn GetDesktopWindow(emu: &mut emu::Emu) { fn wsprintfW(emu: &mut emu::Emu) {} fn GetProcessWindowStation(emu: &mut emu::Emu) { - log_red!( - emu, - "user32!GetProcessWindowStation" - ); + log_red!(emu, "user32!GetProcessWindowStation"); emu.regs_mut().rax = 0x1337; // get handler } @@ -129,10 +113,7 @@ fn GetUserObjectInformationW(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("user32!GetUserObjectInformationW: error reading title") as u64; - log_red!( - emu, - "user32!GetUserObjectInformationW" - ); + log_red!(emu, "user32!GetUserObjectInformationW"); for _ in 0..5 { emu.stack_pop32(false); @@ -149,11 +130,7 @@ fn CharLowerW(emu: &mut emu::Emu) { let s = emu.maps.read_wide_string(ptr_str); - log_red!( - emu, - "user32!CharLowerW(`{}`)", - s - ); + log_red!(emu, "user32!CharLowerW(`{}`)", s); emu.maps.write_wide_string(ptr_str, &s.to_lowercase()); @@ -221,12 +198,7 @@ fn wsprintfA(emu: &mut emu::Emu) { emu.maps.write_string(out, &result); - log_red!( - emu, - "user32!wsprintfA fmt:`{}` out:`{}`", - fmt, - &result - ); + log_red!(emu, "user32!wsprintfA fmt:`{}` out:`{}`", fmt, &result); emu.stack_pop32(false); emu.stack_pop32(false); diff --git a/crates/libmwemu/src/winapi/winapi32/wincrt.rs b/crates/libmwemu/src/winapi/winapi32/wincrt.rs index 4aefbf6b..5646c770 100644 --- a/crates/libmwemu/src/winapi/winapi32/wincrt.rs +++ b/crates/libmwemu/src/winapi/winapi32/wincrt.rs @@ -34,9 +34,6 @@ pub fn gateway(addr: u32, emu: &mut emu::Emu) -> String { } fn set_invalid_parameter_handler(emu: &mut emu::Emu) { - log_red!( - emu, - "wincrt!_set_invalid_parameter_handler" - ); + log_red!(emu, "wincrt!_set_invalid_parameter_handler"); emu.regs_mut().rax = 0; } diff --git a/crates/libmwemu/src/winapi/winapi32/wininet.rs b/crates/libmwemu/src/winapi/winapi32/wininet.rs index 6d587a93..afcee3c7 100644 --- a/crates/libmwemu/src/winapi/winapi32/wininet.rs +++ b/crates/libmwemu/src/winapi/winapi32/wininet.rs @@ -625,16 +625,10 @@ fn HttpSendRequestA(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 16) .expect("wininet!HttpSendRequestA cannot read opt_len"); - let hdrs = emu.maps.read_string(hdrs_ptr); let opt = emu.maps.read_string(opt_ptr); - log_red!( - emu, - "wininet!HttpSendRequestA hdrs: {} opt: {}", - hdrs, - opt - ); + log_red!(emu, "wininet!HttpSendRequestA hdrs: {} opt: {}", hdrs, opt); if !helper::handler_exist(req_hndl) { log::info!("\tinvalid handle."); @@ -678,12 +672,7 @@ fn HttpSendRequestW(emu: &mut emu::Emu) { let hdrs = emu.maps.read_wide_string(hdrs_ptr); let opt = emu.maps.read_wide_string(opt_ptr); - log_red!( - emu, - "wininet!HttpSendRequestW hdrs: {} opt: {}", - hdrs, - opt - ); + log_red!(emu, "wininet!HttpSendRequestW hdrs: {} opt: {}", hdrs, opt); if !helper::handler_exist(req_hndl) { log::info!("\tinvalid handle."); @@ -708,11 +697,7 @@ fn InternetErrorDlg(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("wininet!InternetErrorDlg cannot read error"); - log_red!( - emu, - "wininet!InternetErrorDlg err: {}", - err - ); + log_red!(emu, "wininet!InternetErrorDlg err: {}", err); for _ in 0..5 { emu.stack_pop32(false); @@ -816,11 +801,7 @@ fn InternetCloseHandle(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("wininet!InternetCloseHandle cannot read handle") as u64; - log_red!( - emu, - "wininet!InternetCloseHandle handle: {:x}", - handle - ); + log_red!(emu, "wininet!InternetCloseHandle handle: {:x}", handle); helper::handler_close(handle); emu.stack_pop32(false); @@ -847,11 +828,7 @@ fn InternetCrackUrlA(emu: &mut emu::Emu) { let url = emu.maps.read_string(url_ptr); - log_red!( - emu, - "wininet!InternetCrackUrlA url: `{}`", - url - ); + log_red!(emu, "wininet!InternetCrackUrlA url: `{}`", url); for _ in 0..4 { emu.stack_pop32(false); @@ -879,11 +856,7 @@ fn InternetCrackUrlW(emu: &mut emu::Emu) { let url = emu.maps.read_wide_string(url_ptr); - log_red!( - emu, - "wininet!InternetCrackUrlW url: `{}`", - url - ); + log_red!(emu, "wininet!InternetCrackUrlW url: `{}`", url); for _ in 0..4 { emu.stack_pop32(false); diff --git a/crates/libmwemu/src/winapi/winapi32/ws2_32.rs b/crates/libmwemu/src/winapi/winapi32/ws2_32.rs index bcd5bdd3..cfef9e43 100644 --- a/crates/libmwemu/src/winapi/winapi32/ws2_32.rs +++ b/crates/libmwemu/src/winapi/winapi32/ws2_32.rs @@ -64,10 +64,7 @@ lazy_static! { } fn WsaStartup(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!WsaStartup" - ); + log_red!(emu, "ws2_32!WsaStartup"); for _ in 0..2 { emu.stack_pop32(false); @@ -76,10 +73,7 @@ fn WsaStartup(emu: &mut emu::Emu) { } fn WsaSocketA(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!WsaSocketA" - ); + log_red!(emu, "ws2_32!WsaSocketA"); for _ in 0..6 { emu.stack_pop32(false); @@ -89,10 +83,7 @@ fn WsaSocketA(emu: &mut emu::Emu) { } fn socket(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!socket" - ); + log_red!(emu, "ws2_32!socket"); for _ in 0..3 { emu.stack_pop32(false); @@ -111,11 +102,7 @@ fn WsaHtons(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 8) .expect("ws2_32!WsaHtons cannot read out_port"); - log_red!( - emu, - "ws2_32!WsaHtons {}", - host_port - ); + log_red!(emu, "ws2_32!WsaHtons {}", host_port); for _ in 0..3 { emu.stack_pop32(false); @@ -129,11 +116,7 @@ fn WsaHtons(emu: &mut emu::Emu) { fn htons(emu: &mut emu::Emu) { let port: u16 = emu.maps.read_word(emu.regs().get_esp()).unwrap_or_default(); - log_red!( - emu, - "ws2_32!htons port: {}", - port - ); + log_red!(emu, "ws2_32!htons port: {}", port); emu.stack_pop32(false); emu.regs_mut().rax = port.to_be() as u64; @@ -145,10 +128,7 @@ fn inet_addr(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("ws2_32!inet_addr: error reading addr"); - log_red!( - emu, - "ws2_32!inet_addr" - ); + log_red!(emu, "ws2_32!inet_addr"); emu.stack_pop32(false); emu.regs_mut().rax = 0; @@ -185,13 +165,7 @@ fn connect(emu: &mut emu::Emu) { (ip & 0xff0000) >> 16, (ip & 0xff000000) >> 24 ); - log_red!( - emu, - "ws2_32!connect family: {} {}:{}", - family, - sip, - port - ); + log_red!(emu, "ws2_32!connect family: {} {}:{}", family, sip, port); for _ in 0..3 { emu.stack_pop32(false); @@ -235,12 +209,7 @@ fn recv(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 12) .expect("ws2_32!recv: error reading flags") as u64; - log_red!( - emu, - "ws2_32!recv buff: 0x{:x} sz: {}", - buff, - len - ); + log_red!(emu, "ws2_32!recv buff: 0x{:x} sz: {}", buff, len); for _ in 0..4 { emu.stack_pop32(false); @@ -277,7 +246,9 @@ fn recv(emu: &mut emu::Emu) { } else { if emu.maps.overflow_predicted(buff, len) { if emu.cfg.verbose > 0 { - log::info!("/!\\ on this asm, the recv overflows the buffer, canceled the write!"); + log::info!( + "/!\\ on this asm, the recv overflows the buffer, canceled the write!" + ); } } else { emu.maps.memset(buff, 0x90, len as usize); @@ -313,11 +284,7 @@ fn send(emu: &mut emu::Emu) { emu.stack_pop32(false); } - log_red!( - emu, - "ws2_32!send {{{}}}", - bytes - ); + log_red!(emu, "ws2_32!send {{{}}}", bytes); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -408,11 +375,7 @@ fn listen(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp() + 4) .expect("ws2_32!send: error reading num of connections") as u64; - log_red!( - emu, - "ws2_32!listen connections: {}", - connections - ); + log_red!(emu, "ws2_32!listen connections: {}", connections); for _ in 0..2 { emu.stack_pop32(false); @@ -446,11 +409,7 @@ fn accept(emu: &mut emu::Emu) { let bytes = emu.maps.read_string_of_bytes(saddr, len as usize); - log_red!( - emu, - "ws2_32!accept connections: {}", - bytes - ); + log_red!(emu, "ws2_32!accept connections: {}", bytes); for _ in 0..4 { emu.stack_pop32(false); @@ -470,10 +429,7 @@ fn closesocket(emu: &mut emu::Emu) { .read_dword(emu.regs().get_esp()) .expect("ws2_32!send: error reading sock") as u64; - log_red!( - emu, - "ws2_32!closesocket" - ); + log_red!(emu, "ws2_32!closesocket"); helper::socket_close(sock); @@ -554,12 +510,7 @@ fn getsockopt(emu: &mut emu::Emu) { emu.maps.write_dword(optval, 1); - log_red!( - emu, - "ws2_32!getsockopt lvl: {} opt: {}", - level, - optname - ); + log_red!(emu, "ws2_32!getsockopt lvl: {} opt: {}", level, optname); for _ in 0..5 { emu.stack_pop32(false); diff --git a/crates/libmwemu/src/winapi/winapi64/advapi32.rs b/crates/libmwemu/src/winapi/winapi64/advapi32.rs index da94ad9b..f9479717 100644 --- a/crates/libmwemu/src/winapi/winapi64/advapi32.rs +++ b/crates/libmwemu/src/winapi/winapi64/advapi32.rs @@ -74,11 +74,7 @@ fn RegOpenKeyExA(emu: &mut emu::Emu) { let subkey = emu.maps.read_string(subkey_ptr); - log_red!( - emu, - "advapi32!RegOpenKeyExA {}", - subkey - ); + log_red!(emu, "advapi32!RegOpenKeyExA {}", subkey); emu.maps .write_qword(result, helper::handler_create(&subkey)); @@ -88,10 +84,7 @@ fn RegOpenKeyExA(emu: &mut emu::Emu) { fn RegCloseKey(emu: &mut emu::Emu) { let hkey = emu.regs().rcx; - log_red!( - emu, - "advapi32!RegCloseKey" - ); + log_red!(emu, "advapi32!RegCloseKey"); helper::handler_close(hkey); @@ -117,11 +110,7 @@ fn RegQueryValueExA(emu: &mut emu::Emu) { value = emu.maps.read_string(value_ptr); } - log_red!( - emu, - "advapi32!RegQueryValueExA {}", - value - ); + log_red!(emu, "advapi32!RegQueryValueExA {}", value); if data_out > 0 { emu.maps.write_string(data_out, "some_random_reg_contents"); @@ -133,8 +122,8 @@ fn RegQueryValueExA(emu: &mut emu::Emu) { } fn GetUserNameA(emu: &mut emu::Emu) { - let out_username = emu.regs().rcx; // LPSTR lpBuffer - let in_out_sz = emu.regs().rdx; // LP64WORD pcbBuffer (your 64-bit variant) + let out_username = emu.regs().rcx; // LPSTR lpBuffer + let in_out_sz = emu.regs().rdx; // LP64WORD pcbBuffer (your 64-bit variant) log_red!( emu, @@ -145,17 +134,17 @@ fn GetUserNameA(emu: &mut emu::Emu) { // Check if size pointer is valid if in_out_sz == 0 || !emu.maps.is_mapped(in_out_sz) { - log_red!( - emu, - "GetUserNameA: Invalid pcbBuffer pointer" - ); + log_red!(emu, "GetUserNameA: Invalid pcbBuffer pointer"); emu.regs_mut().rax = constants::FALSE; return; } // Read current buffer size (in bytes) - let buffer_size = emu.maps.read_qword(in_out_sz).expect("Cannot read buffer size") as usize; - + let buffer_size = emu + .maps + .read_qword(in_out_sz) + .expect("Cannot read buffer size") as usize; + // Calculate required size in bytes (including null terminator) let required_size = constants::USER_NAME.len() + 1; // +1 for null terminator @@ -164,10 +153,7 @@ fn GetUserNameA(emu: &mut emu::Emu) { // Check if output buffer is valid if out_username == 0 || !emu.maps.is_mapped(out_username) { - log_red!( - emu, - "GetUserNameA: Invalid lpBuffer pointer" - ); + log_red!(emu, "GetUserNameA: Invalid lpBuffer pointer"); emu.regs_mut().rax = constants::FALSE; return; } @@ -175,11 +161,11 @@ fn GetUserNameA(emu: &mut emu::Emu) { // Check if buffer is large enough if buffer_size < required_size { log_red!( - emu, - "GetUserNameA: Buffer too small. Required: {}, Provided: {}", - required_size, - buffer_size - ); + emu, + "GetUserNameA: Buffer too small. Required: {}, Provided: {}", + required_size, + buffer_size + ); emu.regs_mut().rax = constants::FALSE; return; } @@ -198,8 +184,8 @@ fn GetUserNameA(emu: &mut emu::Emu) { } fn GetUserNameW(emu: &mut emu::Emu) { - let out_username = emu.regs().rcx; // LPWSTR lpBuffer - let in_out_sz = emu.regs().rdx; // LPDWORD pcbBuffer + let out_username = emu.regs().rcx; // LPWSTR lpBuffer + let in_out_sz = emu.regs().rdx; // LPDWORD pcbBuffer log_red!( emu, @@ -210,17 +196,17 @@ fn GetUserNameW(emu: &mut emu::Emu) { // Check if size pointer is valid if in_out_sz == 0 || !emu.maps.is_mapped(in_out_sz) { - log_red!( - emu, - "GetUserNameW: Invalid pcbBuffer pointer" - ); + log_red!(emu, "GetUserNameW: Invalid pcbBuffer pointer"); emu.regs_mut().rax = constants::FALSE; return; } // Read current buffer size (in characters) - let buffer_size = emu.maps.read_dword(in_out_sz).expect("Cannot read buffer size") as usize; - + let buffer_size = emu + .maps + .read_dword(in_out_sz) + .expect("Cannot read buffer size") as usize; + // Calculate required size in characters (including null terminator) let username_chars = constants::USER_NAME.chars().count(); let required_size = username_chars + 1; // +1 for null terminator @@ -230,10 +216,7 @@ fn GetUserNameW(emu: &mut emu::Emu) { // Check if output buffer is valid if out_username == 0 || !emu.maps.is_mapped(out_username) { - log_red!( - emu, - "GetUserNameW: Invalid lpBuffer pointer" - ); + log_red!(emu, "GetUserNameW: Invalid lpBuffer pointer"); emu.regs_mut().rax = constants::FALSE; return; } @@ -241,17 +224,18 @@ fn GetUserNameW(emu: &mut emu::Emu) { // Check if buffer is large enough if buffer_size < required_size { log_red!( - emu, - "GetUserNameW: Buffer too small. Required: {}, Provided: {}", - required_size, - buffer_size - ); + emu, + "GetUserNameW: Buffer too small. Required: {}, Provided: {}", + required_size, + buffer_size + ); emu.regs_mut().rax = constants::FALSE; return; } // Buffer is large enough, write the username - emu.maps.write_wide_string(out_username, constants::USER_NAME); + emu.maps + .write_wide_string(out_username, constants::USER_NAME); log_red!( emu, diff --git a/crates/libmwemu/src/winapi/winapi64/comctl32.rs b/crates/libmwemu/src/winapi/winapi64/comctl32.rs index 17d82a22..a71c93e5 100644 --- a/crates/libmwemu/src/winapi/winapi64/comctl32.rs +++ b/crates/libmwemu/src/winapi/winapi64/comctl32.rs @@ -34,10 +34,7 @@ pub fn gateway(addr: u64, emu: &mut emu::Emu) -> String { void InitCommonControls(); */ fn InitCommonControls(emu: &mut emu::Emu) { - log_red!( - emu, - "comctl32!InitCommonControls" - ); + log_red!(emu, "comctl32!InitCommonControls"); // TODO: do something } @@ -47,10 +44,7 @@ BOOL InitCommonControlsEx( ); */ fn InitCommonControlsEx(emu: &mut emu::Emu) { - log_red!( - emu, - "comctl32!InitCommonControlsEx" - ); + log_red!(emu, "comctl32!InitCommonControlsEx"); // TODO: do something emu.regs_mut().rax = 1; // TRUE } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/activate_act_ctx.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/activate_act_ctx.rs index 3d9528ca..8cffdba5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/activate_act_ctx.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/activate_act_ctx.rs @@ -1,10 +1,15 @@ - use crate::emu; pub fn ActivateActCtx(emu: &mut emu::Emu) { let h_act_ctx = emu.regs().rcx; let lp_cookie = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!ActivateActCtx {:x} {:x}", emu.pos, h_act_ctx, lp_cookie); + log_red!( + emu, + "** {} kernel32!ActivateActCtx {:x} {:x}", + emu.pos, + h_act_ctx, + lp_cookie + ); // TODO: implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/add_vectored_exception_handler.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/add_vectored_exception_handler.rs index c2185a22..9febdc2a 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/add_vectored_exception_handler.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/add_vectored_exception_handler.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn AddVectoredExceptionHandler(emu: &mut emu::Emu) { @@ -15,4 +14,4 @@ pub fn AddVectoredExceptionHandler(emu: &mut emu::Emu) { emu.set_veh(fptr as u64); emu.regs_mut().rax = 0x2c2878; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/are_file_api_is_ansi.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/are_file_api_is_ansi.rs index 02dd8bb8..729c1f2e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/are_file_api_is_ansi.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/are_file_api_is_ansi.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn AreFileApiIsAnsi(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!AreFileApiIsAnsi" - ); + log_red!(emu, "kernel32!AreFileApiIsAnsi"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/begin_update_resource_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/begin_update_resource_a.rs index 1d22936e..31dda9fb 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/begin_update_resource_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/begin_update_resource_a.rs @@ -15,4 +15,4 @@ pub fn BeginUpdateResourceA(emu: &mut emu::Emu) { ); emu.regs_mut().rax = helper::handler_create(&filename); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/close_handle.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/close_handle.rs index 8d11e0c6..806bf367 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/close_handle.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/close_handle.rs @@ -4,15 +4,11 @@ use crate::winapi::helper; pub fn CloseHandle(emu: &mut emu::Emu) { let handle = emu.regs().rcx; - log_red!( - emu, - "kernel32!CloseHandle 0x{:X}", - handle - ); + log_red!(emu, "kernel32!CloseHandle 0x{:X}", handle); if !helper::handler_close(handle) { panic!("\tinvalid handle.") } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/compare_string_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/compare_string_w.rs index 8c9573b3..0cfa2881 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/compare_string_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/compare_string_w.rs @@ -1,4 +1,3 @@ - use crate::emu; /* @@ -16,14 +15,14 @@ pub fn CompareStringW(emu: &mut emu::Emu) { let locale = emu.regs().rcx; let dw_cmp_flags = emu.regs().rdx; let lp_string1 = emu.regs().r8; - let cch_count1 = emu.regs().r9 as i32; // ✅ Fixed: no multiplication - + let cch_count1 = emu.regs().r9 as i32; // ✅ Fixed: no multiplication + // Get stack parameters let lp_string2_addr = emu.regs().rsp + 0x20; let cch_count2_addr = emu.regs().rsp + 0x28; - + let lp_string2 = emu.maps.read_qword(lp_string2_addr).unwrap_or(0); - let cch_count2 = emu.maps.read_dword(cch_count2_addr).unwrap_or(0) as i32; // ✅ Fixed: no multiplication + let cch_count2 = emu.maps.read_dword(cch_count2_addr).unwrap_or(0) as i32; // ✅ Fixed: no multiplication log_red!( emu, @@ -35,7 +34,7 @@ pub fn CompareStringW(emu: &mut emu::Emu) { lp_string2, cch_count2 ); - + // Read the strings - handle null/empty cases let s1 = if lp_string1 == 0 { String::new() @@ -46,7 +45,7 @@ pub fn CompareStringW(emu: &mut emu::Emu) { } else { emu.maps.read_wide_string_n(lp_string1, cch_count1 as usize) }; - + let s2 = if lp_string2 == 0 { String::new() } else if cch_count2 == -1 { @@ -77,6 +76,6 @@ pub fn CompareStringW(emu: &mut emu::Emu) { }; log::info!("\t\t'{}' == '{}' ={}", s1, s2, result); - + emu.regs_mut().rax = result as u64; } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/connect_named_pipe.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/connect_named_pipe.rs index 86d3166f..0e9d07c8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/connect_named_pipe.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/connect_named_pipe.rs @@ -5,15 +5,11 @@ pub fn ConnectNamedPipe(emu: &mut emu::Emu) { let handle = emu.regs().rcx; let overlapped = emu.regs().rdx; - log_red!( - emu, - "kernel32!ConnectNamedPipe hndl: 0x{:x}", - handle - ); + log_red!(emu, "kernel32!ConnectNamedPipe hndl: 0x{:x}", handle); if !helper::handler_exist(handle) { log::info!("\tinvalid handle."); } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_a.rs index 9fcb0ce7..837e4f98 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn CopyFileA(emu: &mut emu::Emu) { @@ -9,12 +8,7 @@ pub fn CopyFileA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); let dst = emu.maps.read_string(dst_ptr); - log_red!( - emu, - "kernel32!CopyFileA `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!CopyFileA `{}` to `{}`", src, dst); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_w.rs index 735e44da..a5f25e72 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/copy_file_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn CopyFileW(emu: &mut emu::Emu) { @@ -9,12 +8,7 @@ pub fn CopyFileW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); let dst = emu.maps.read_wide_string(dst_ptr); - log_red!( - emu, - "kernel32!CopyFileW `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!CopyFileW `{}` to `{}`", src, dst); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_act_ctx_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_act_ctx_a.rs index 2b3d3ef4..08ad4ade 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_act_ctx_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_act_ctx_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn CreateActCtxA(emu: &mut emu::Emu) { @@ -6,4 +5,4 @@ pub fn CreateActCtxA(emu: &mut emu::Emu) { log_red!(emu, "** {} kernel32!CreateActCtxA {:x}", emu.pos, p_act_ctx); // TODO: implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_event_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_event_a.rs index 3e0c57a6..4d21279d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_event_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_event_a.rs @@ -32,4 +32,4 @@ pub fn CreateEventA(emu: &mut emu::Emu) { let uri = format!("event://{}", name); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_a.rs index e75c4daf..1ff225df 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_a.rs @@ -14,6 +14,11 @@ pub fn CreateFileA(emu: &mut emu::Emu) { if lp_file_name > 0 { name = emu.maps.read_string(lp_file_name as u64); } - log_red!(emu, "** {} kernel32!CreateFileA name = {name} {}", emu.pos, emu.colors.nc); + log_red!( + emu, + "** {} kernel32!CreateFileA name = {name} {}", + emu.pos, + emu.colors.nc + ); emu.regs_mut().rax = helper::handler_create(&name); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_a.rs index 011c41c3..a5d99a15 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_a.rs @@ -27,4 +27,4 @@ pub fn CreateFileMappingA(emu: &mut emu::Emu) { name, emu.regs().get_eax() ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_w.rs index 3856d188..4216c66c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_file_mapping_w.rs @@ -27,4 +27,4 @@ pub fn CreateFileMappingW(emu: &mut emu::Emu) { name, emu.regs().get_eax() ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_a.rs index e41eb5ca..beea3d61 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_a.rs @@ -8,12 +8,8 @@ pub fn CreateMutexA(emu: &mut emu::Emu) { let name = emu.maps.read_string(name_ptr); - log_red!( - emu, - "kernel32!CreateMutexA '{}'", - name - ); + log_red!(emu, "kernel32!CreateMutexA '{}'", name); let uri = format!("mutex://{}", name); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_w.rs index 15eadc0e..c40f11f9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_mutex_w.rs @@ -8,12 +8,8 @@ pub fn CreateMutexW(emu: &mut emu::Emu) { let name = emu.maps.read_wide_string(name_ptr); - log_red!( - emu, - "kernel32!CreateMutexA '{}'", - name - ); + log_red!(emu, "kernel32!CreateMutexA '{}'", name); let uri = format!("mutex://{}", name); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_a.rs index 6a6628fc..c8488d95 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_a.rs @@ -34,4 +34,4 @@ pub fn CreateNamedPipeA(emu: &mut emu::Emu) { ); emu.regs_mut().rax = helper::handler_create(&name); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_w.rs index a6ce03e0..7030de53 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_named_pipe_w.rs @@ -34,4 +34,4 @@ pub fn CreateNamedPipeW(emu: &mut emu::Emu) { ); emu.regs_mut().rax = helper::handler_create(&name); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_a.rs index e3ab9ff9..891b04e4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn CreateProcessA(emu: &mut emu::Emu) { @@ -7,12 +6,7 @@ pub fn CreateProcessA(emu: &mut emu::Emu) { let appname = emu.maps.read_string(appname_ptr); let cmdline = emu.maps.read_string(cmdline_ptr); - log_red!( - emu, - "kernel32!CreateProcessA {} {}", - appname, - cmdline - ); + log_red!(emu, "kernel32!CreateProcessA {} {}", appname, cmdline); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_w.rs index 85471cc1..61633724 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_process_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn CreateProcessW(emu: &mut emu::Emu) { @@ -7,12 +6,7 @@ pub fn CreateProcessW(emu: &mut emu::Emu) { let appname = emu.maps.read_wide_string(appname_ptr); let cmdline = emu.maps.read_wide_string(cmdline_ptr); - log_red!( - emu, - "kernel32!CreateProcessW {} {}", - appname, - cmdline - ); + log_red!(emu, "kernel32!CreateProcessW {} {}", appname, cmdline); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_remote_thread.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_remote_thread.rs index 438463db..78a3608d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_remote_thread.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_remote_thread.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; use crate::thread_context::ThreadContext; use crate::winapi::helper; @@ -28,32 +29,35 @@ pub fn CreateRemoteThread(emu: &mut emu::Emu) { ); let new_thread_id = 0x1000 + emu.threads.len(); let mut new_thread = ThreadContext::new(new_thread_id as u64); - + // Initialize thread context with entry point and parameter new_thread.regs.rip = addr; new_thread.regs.rcx = param; new_thread.regs.rax = 0; - + // Allocate stack if requested (otherwise will share/reuse current stack) if stack_size > 0 { if let Some(stack_base) = emu.maps.alloc(stack_size) { new_thread.regs.rsp = stack_base + stack_size - 8; // Stack grows down new_thread.regs.rbp = new_thread.regs.rsp; - emu.maps.create_map( - &format!("remote_thread_stack_{:x}", new_thread_id), - stack_base, - stack_size, - ).ok(); + emu.maps + .create_map( + &format!("remote_thread_stack_{:x}", new_thread_id), + stack_base, + stack_size, + Permission::READ_WRITE, + ) + .ok(); } } - + // Sync FPU instruction pointer new_thread.fpu.set_ip(addr); - + emu.threads.push(new_thread); - + if out_tid > 0 { emu.maps.write_dword(out_tid, new_thread_id as u32); } emu.regs_mut().rax = helper::handler_create(&format!("tid://0x{:x}", new_thread_id)); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_thread.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_thread.rs index aed98901..0f7a913c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_thread.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_thread.rs @@ -1,6 +1,7 @@ -use crate::{constants, emu}; +use crate::maps::mem64::Permission; use crate::thread_context::ThreadContext; use crate::winapi::helper; +use crate::{constants, emu}; pub fn CreateThread(emu: &mut emu::Emu) { // Add comprehensive debugging @@ -8,17 +9,17 @@ pub fn CreateThread(emu: &mut emu::Emu) { log::info!("Current RIP: 0x{:x}", emu.regs().rip); log::info!("Current RSP: 0x{:x}", emu.regs().rsp); log::info!("Is 64-bit: {}", emu.cfg.is_64bits); - + // Log all register values log::info!("RCX (lpThreadAttributes): 0x{:x}", emu.regs().rcx); log::info!("RDX (dwStackSize): 0x{:x}", emu.regs().rdx); log::info!("R8 (lpStartAddress): 0x{:x}", emu.regs().r8); log::info!("R9 (lpParameter): 0x{:x}", emu.regs().r9); - + // Check if RSP is mapped and dump stack area let rsp = emu.regs().rsp; log::info!("RSP mapped: {}", emu.maps.is_mapped(rsp)); - + if emu.maps.is_mapped(rsp) { log::info!("Stack dump around RSP:"); for i in 0..8 { @@ -33,52 +34,69 @@ pub fn CreateThread(emu: &mut emu::Emu) { } } } - + // Try to read the stack parameters with error handling let flags_addr = emu.regs().rsp + 0x20; let tid_ptr_addr = emu.regs().rsp + 0x28; - + log::info!("Trying to read flags from 0x{:x}", flags_addr); log::info!("Flags address mapped: {}", emu.maps.is_mapped(flags_addr)); - + log::info!("Trying to read tid_ptr from 0x{:x}", tid_ptr_addr); - log::info!("Tid_ptr address mapped: {}", emu.maps.is_mapped(tid_ptr_addr)); - + log::info!( + "Tid_ptr address mapped: {}", + emu.maps.is_mapped(tid_ptr_addr) + ); + let flags = match emu.maps.read_qword(flags_addr) { Some(f) => { log::info!("Successfully read flags: 0x{:x}", f); f - }, + } None => { - panic!("Failed to read flags from 0x{:x} - unmapped memory", flags_addr); + panic!( + "Failed to read flags from 0x{:x} - unmapped memory", + flags_addr + ); } }; - + let tid_ptr = match emu.maps.read_qword(tid_ptr_addr) { Some(t) => { log::info!("Successfully read tid_ptr: 0x{:x}", t); t - }, + } None => { - panic!("Failed to read tid_ptr from 0x{:x} - unmapped memory", tid_ptr_addr); + panic!( + "Failed to read tid_ptr from 0x{:x} - unmapped memory", + tid_ptr_addr + ); } }; - + // Check if tid_ptr points to valid memory if tid_ptr > 0 { - log::info!("Checking if tid_ptr 0x{:x} is mapped: {}", tid_ptr, emu.maps.is_mapped(tid_ptr)); - + log::info!( + "Checking if tid_ptr 0x{:x} is mapped: {}", + tid_ptr, + emu.maps.is_mapped(tid_ptr) + ); + // Try to find what memory region this might be in log::info!("Memory maps around tid_ptr:"); // You might want to add a method to dump nearby memory regions } - + // Check if the thread start address is mapped let start_addr = emu.regs().r8; - log::info!("Thread start address 0x{:x} mapped: {}", start_addr, emu.maps.is_mapped(start_addr)); - + log::info!( + "Thread start address 0x{:x} mapped: {}", + start_addr, + emu.maps.is_mapped(start_addr) + ); + log::info!("=============================="); - + // Original CreateThread logic with better error handling let sec_attr = emu.regs().rcx; let stack_sz = emu.regs().rdx; @@ -87,31 +105,38 @@ pub fn CreateThread(emu: &mut emu::Emu) { let new_thread_id = 0x1000 + emu.threads.len(); let mut new_thread = ThreadContext::new(new_thread_id as u64); - + // Initialize thread context with entry point and parameter new_thread.regs.rip = code; new_thread.regs.rcx = param; new_thread.regs.rax = 0; - + // Allocate stack if requested if stack_sz > 0 { if let Some(stack_base) = emu.maps.alloc(stack_sz) { new_thread.regs.rsp = stack_base + stack_sz - 8; new_thread.regs.rbp = new_thread.regs.rsp; - emu.maps.create_map( - &format!("thread_stack_{:x}", new_thread_id), + emu.maps + .create_map( + &format!("thread_stack_{:x}", new_thread_id), + stack_base, + stack_sz, + Permission::READ_WRITE, + ) + .ok(); + log::info!( + "Allocated stack: 0x{:x} - 0x{:x}", stack_base, - stack_sz, - ).ok(); - log::info!("Allocated stack: 0x{:x} - 0x{:x}", stack_base, stack_base + stack_sz); + stack_base + stack_sz + ); } else { panic!("Failed to allocate stack of size 0x{:x}", stack_sz); } } - + // Sync FPU instruction pointer new_thread.fpu.set_ip(code); - + // Set suspended state if CREATE_SUSPENDED flag is set if (flags & constants::CREATE_SUSPENDED) != 0 { new_thread.suspended = true; @@ -120,16 +145,19 @@ pub fn CreateThread(emu: &mut emu::Emu) { new_thread.suspended = false; log::info!("Thread created in running state (flags: 0x{:x})", flags); } - + emu.threads.push(new_thread); - + // Write thread ID with detailed logging if tid_ptr > 0 { if emu.maps.is_mapped(tid_ptr) { log::info!("Writing thread ID {} to 0x{:x}", new_thread_id, tid_ptr); emu.maps.write_dword(tid_ptr, new_thread_id as u32); } else { - panic!("CANNOT WRITE: tid_ptr 0x{:x} points to unmapped memory!", tid_ptr); + panic!( + "CANNOT WRITE: tid_ptr 0x{:x} points to unmapped memory!", + tid_ptr + ); } } else { log::info!("tid_ptr is NULL, not writing thread ID"); @@ -145,11 +173,16 @@ pub fn CreateThread(emu: &mut emu::Emu) { log::info!("THREAD ARRAY STATE:"); for (idx, thread) in emu.threads.iter().enumerate() { - log::info!(" threads[{}]: ID=0x{:x}, suspended={}, RIP=0x{:x}", - idx, thread.id, thread.suspended, thread.regs.rip); + log::info!( + " threads[{}]: ID=0x{:x}, suspended={}, RIP=0x{:x}", + idx, + thread.id, + thread.suspended, + thread.regs.rip + ); } log::info!("current_thread_id = {}", emu.current_thread_id); emu.regs_mut().rax = helper::handler_create(&format!("tid://0x{:x}", new_thread_id)); log::info!("Returning handle: 0x{:x}", emu.regs().rax); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/create_toolhelp32_snapshot.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/create_toolhelp32_snapshot.rs index f8c4180a..c09ccbde 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/create_toolhelp32_snapshot.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/create_toolhelp32_snapshot.rs @@ -14,4 +14,4 @@ pub fn CreateToolhelp32Snapshot(emu: &mut emu::Emu) { let uri = format!("CreateToolhelp32Snapshot://{}", pid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/decode_pointer.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/decode_pointer.rs index 88001382..c3a9a64e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/decode_pointer.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/decode_pointer.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn DecodePointer(emu: &mut emu::Emu) { let ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!DecodePointer ptr: 0x{:x}", - ptr - ); + log_red!(emu, "kernel32!DecodePointer ptr: 0x{:x}", ptr); emu.regs_mut().rax = ptr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/disconnect_named_pipe.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/disconnect_named_pipe.rs index 22d3e1e8..51379011 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/disconnect_named_pipe.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/disconnect_named_pipe.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn DisconnectNamedPipe(emu: &mut emu::Emu) { let handle = emu.regs().rcx; - log_red!( - emu, - "kernel32!DisconnectNamedPipe hndl: 0x{:x}", - handle - ); + log_red!(emu, "kernel32!DisconnectNamedPipe hndl: 0x{:x}", handle); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/encode_pointer.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/encode_pointer.rs index 09ebcddc..744c891e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/encode_pointer.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/encode_pointer.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn EncodePointer(emu: &mut emu::Emu) { let ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!EncodePointer ptr: 0x{:x}", - ptr - ); + log_red!(emu, "kernel32!EncodePointer ptr: 0x{:x}", ptr); emu.regs_mut().rax = ptr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/enter_critical_section.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/enter_critical_section.rs index 184eda7e..4fb963e8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/enter_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/enter_critical_section.rs @@ -5,7 +5,12 @@ pub fn EnterCriticalSection(emu: &mut emu::Emu) { let cs_ptr = emu.regs().rcx; let tid = emu.current_thread().id; - log_red!(emu, "kernel32!EnterCriticalSection thread: 0x{:x} cs: 0x{:x}", tid, cs_ptr); + log_red!( + emu, + "kernel32!EnterCriticalSection thread: 0x{:x} cs: 0x{:x}", + tid, + cs_ptr + ); let acquired = emu.global_locks.enter(cs_ptr, tid); @@ -18,9 +23,9 @@ pub fn EnterCriticalSection(emu: &mut emu::Emu) { let thread_idx = emu.current_thread_id; emu.threads[thread_idx].blocked_on_cs = Some(cs_ptr); // Don't set wake_tick here - it will be cleared when lock is released - + // Simulate the wait by advancing tick slightly // The actual blocking will be handled by the scheduler helper::advance_tick(emu, 2); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/exit_process.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/exit_process.rs index 001e889d..9d4bbacd 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/exit_process.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/exit_process.rs @@ -1,13 +1,8 @@ - use crate::emu; pub fn ExitProcess(emu: &mut emu::Emu) { let code = emu.regs().rcx; - log_red!( - emu, - "kernel32!ExitProcess code: {}", - code - ); + log_red!(emu, "kernel32!ExitProcess code: {}", code); std::process::exit(1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_a.rs index 3be37b19..3308d4db 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn ExpandEnvironmentStringsA(emu: &mut emu::Emu) { @@ -8,11 +7,7 @@ pub fn ExpandEnvironmentStringsA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); - log_red!( - emu, - "kernel32!ExpandEnvironmentStringsA `{}`", - src - ); + log_red!(emu, "kernel32!ExpandEnvironmentStringsA `{}`", src); // TODO: expand typical environment varsl. emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_w.rs index 5c83d5ff..5b7e64b4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/expand_environment_strings_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn ExpandEnvironmentStringsW(emu: &mut emu::Emu) { @@ -8,11 +7,7 @@ pub fn ExpandEnvironmentStringsW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); - log_red!( - emu, - "kernel32!ExpandEnvironmentStringsW `{}`", - src - ); + log_red!(emu, "kernel32!ExpandEnvironmentStringsW `{}`", src); // TODO: expand typical environment varsl. emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/file_time_to_system_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/file_time_to_system_time.rs index 1a77b939..41efd0c1 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/file_time_to_system_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/file_time_to_system_time.rs @@ -1,13 +1,9 @@ - use crate::emu; pub fn FileTimeToSystemTime(emu: &mut emu::Emu) { let file_time = emu.regs().rcx; let sys_time_ptr = emu.regs().rdx; - log_red!( - emu, - "kernel32!FileTimeToSystemTime" - ); + log_red!(emu, "kernel32!FileTimeToSystemTime"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_act_ctx_section_string_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_act_ctx_section_string_w.rs index 9165051d..de553527 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_act_ctx_section_string_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_act_ctx_section_string_w.rs @@ -5,7 +5,9 @@ pub fn FindActCtxSectionStringW(emu: &mut emu::Emu) { let section_name_ptr = emu.regs().rdx; let string_name_ptr = emu.regs().r8; let string_value_ptr = emu.regs().r9; - let out_ptr = emu.maps.read_qword(emu.regs().rsp + 0x20) + let out_ptr = emu + .maps + .read_qword(emu.regs().rsp + 0x20) .expect("error reading out_ptr"); let mut section_name = String::new(); @@ -34,4 +36,4 @@ pub fn FindActCtxSectionStringW(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_close.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_close.rs index 474215e6..3b7ca615 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_close.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_close.rs @@ -4,10 +4,7 @@ use crate::winapi::helper; pub fn FindClose(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; - log_red!( - emu, - "kernel32!FindClose" - ); + log_red!(emu, "kernel32!FindClose"); helper::handler_close(hndl); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_a.rs index 1c73e8c1..6dba492c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn FindFirstFileA(emu: &mut emu::Emu) { @@ -6,10 +5,6 @@ pub fn FindFirstFileA(emu: &mut emu::Emu) { let find_data = emu.regs().rdx; let file = emu.maps.read_string(file_ptr); - log_red!( - emu, - "kernel32!FindFirstFileA file: {}", - file - ); + log_red!(emu, "kernel32!FindFirstFileA file: {}", file); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_ex_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_ex_w.rs index 9411fc24..853f02a7 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_ex_w.rs @@ -1,41 +1,40 @@ - use crate::emu; pub fn FindFirstFileExW(emu: &mut emu::Emu) { - let filename_ptr = emu.regs().rcx; - let info_level = emu.regs().rdx; - let find_data_ptr = emu.regs().r8; - let search_op = emu.regs().r9; - let search_filter = emu - .maps - .read_qword(emu.regs().rsp + 0x20) - .expect("kernel32!FindFirstFileExW cannot read_qword search_filter"); - let additional_flags = emu - .maps - .read_qword(emu.regs().rsp + 0x28) - .expect("kernel32!FindFirstFileExW cannot read_qword additional_flags"); + let filename_ptr = emu.regs().rcx; + let info_level = emu.regs().rdx; + let find_data_ptr = emu.regs().r8; + let search_op = emu.regs().r9; + let search_filter = emu + .maps + .read_qword(emu.regs().rsp + 0x20) + .expect("kernel32!FindFirstFileExW cannot read_qword search_filter"); + let additional_flags = emu + .maps + .read_qword(emu.regs().rsp + 0x28) + .expect("kernel32!FindFirstFileExW cannot read_qword additional_flags"); let filename = emu.maps.read_wide_string(filename_ptr); - - // TODO: Read wide string filename from filename_ptr - // TODO: Parse info_level (FindExInfoStandard=0, FindExInfoBasic=1, FindExInfoMaxInfoLevel=2) - // TODO: Parse search_op (FindExSearchNameMatch=0, FindExSearchLimitToDirectories=1, FindExSearchLimitToDevices=2) - // TODO: Read lpSearchFilter from stack+0x28 - // TODO: Read dwAdditionalFlags from stack+0x30 - - // TODO: Check if file/pattern exists in emulated filesystem - // TODO: Fill WIN32_FIND_DATAW structure at find_data_ptr: - // - dwFileAttributes (DWORD) - // - ftCreationTime (FILETIME) - // - ftLastAccessTime (FILETIME) - // - ftLastWriteTime (FILETIME) - // - nFileSizeHigh (DWORD) - // - nFileSizeLow (DWORD) - // - dwReserved0, dwReserved1 (DWORD) - // - cFileName[MAX_PATH] (WCHAR array) - // - cAlternateFileName[14] (WCHAR array) - - log_red!( + + // TODO: Read wide string filename from filename_ptr + // TODO: Parse info_level (FindExInfoStandard=0, FindExInfoBasic=1, FindExInfoMaxInfoLevel=2) + // TODO: Parse search_op (FindExSearchNameMatch=0, FindExSearchLimitToDirectories=1, FindExSearchLimitToDevices=2) + // TODO: Read lpSearchFilter from stack+0x28 + // TODO: Read dwAdditionalFlags from stack+0x30 + + // TODO: Check if file/pattern exists in emulated filesystem + // TODO: Fill WIN32_FIND_DATAW structure at find_data_ptr: + // - dwFileAttributes (DWORD) + // - ftCreationTime (FILETIME) + // - ftLastAccessTime (FILETIME) + // - ftLastWriteTime (FILETIME) + // - nFileSizeHigh (DWORD) + // - nFileSizeLow (DWORD) + // - dwReserved0, dwReserved1 (DWORD) + // - cFileName[MAX_PATH] (WCHAR array) + // - cAlternateFileName[14] (WCHAR array) + + log_red!( emu, "kernel32!FindFirstFileExW filename_ptr: 0x{:x} filename: {} info_level: {} find_data_ptr: 0x{:x} search_op: {} search_filter: {} additional_flags: {}", filename_ptr, @@ -47,7 +46,7 @@ pub fn FindFirstFileExW(emu: &mut emu::Emu) { additional_flags ); - // TODO: Return valid HANDLE (not INVALID_HANDLE_VALUE = -1) on success - // TODO: Set appropriate error code with SetLastError on failure - emu.regs_mut().rax = 0xFFFFFFFFFFFFFFFF; // INVALID_HANDLE_VALUE for now -} \ No newline at end of file + // TODO: Return valid HANDLE (not INVALID_HANDLE_VALUE = -1) on success + // TODO: Set appropriate error code with SetLastError on failure + emu.regs_mut().rax = 0xFFFFFFFFFFFFFFFF; // INVALID_HANDLE_VALUE for now +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_w.rs index 4f379734..0fb625e0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_first_file_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn FindFirstFileW(emu: &mut emu::Emu) { @@ -6,10 +5,6 @@ pub fn FindFirstFileW(emu: &mut emu::Emu) { let find_data = emu.regs().rdx; let file = emu.maps.read_wide_string(file_ptr); - log_red!( - emu, - "kernel32!FindFirstFileW file: {}", - file - ); + log_red!(emu, "kernel32!FindFirstFileW file: {}", file); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_a.rs index 36d3ee68..2544ff8f 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_a.rs @@ -4,12 +4,9 @@ pub fn FindNextFileA(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; let find_data = emu.regs().rdx; - log_red!( - emu, - "kernel32!FindNextFileA" - ); + log_red!(emu, "kernel32!FindNextFileA"); // TODO: implement emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_w.rs index b04976bc..b98a7815 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_next_file_w.rs @@ -4,12 +4,9 @@ pub fn FindNextFileW(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; let find_data = emu.regs().rdx; - log_red!( - emu, - "kernel32!FindNextFileW" - ); + log_red!(emu, "kernel32!FindNextFileW"); // TODO: implement emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_a.rs index d884aa22..4840cc81 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_a.rs @@ -11,23 +11,68 @@ pub fn FindResourceA(emu: &mut emu::Emu) { if lpName > 0xff && lpType > 0xff { let name = emu.maps.read_string(lpName as u64); let ntype = emu.maps.read_string(lpType as u64); - log_red!(emu, "** {} kernel32!FindResourceA {:x} `{}` `{}`", emu.pos, handle, name, ntype); + log_red!( + emu, + "** {} kernel32!FindResourceA {:x} `{}` `{}`", + emu.pos, + handle, + name, + ntype + ); - x = emu.pe64.as_ref().unwrap().get_resource(None, None, Some(&name), Some(&ntype)); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(None, None, Some(&name), Some(&ntype)); } else if lpName > 0xff && lpType <= 0xff { let name = emu.maps.read_string(lpName as u64); - log_red!(emu, "** {} kernel32!FindResourceA {:x} `{}` {}", emu.pos, handle, name, lpType); + log_red!( + emu, + "** {} kernel32!FindResourceA {:x} `{}` {}", + emu.pos, + handle, + name, + lpType + ); - x = emu.pe64.as_ref().unwrap().get_resource(Some(lpType as u32), None, Some(&name), None); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(Some(lpType as u32), None, Some(&name), None); } else if lpName <= 0xff && lpType > 0xff { let ntype = emu.maps.read_string(lpType as u64); - log_red!(emu, "** {} kernel32!FindResourceA {:x} `{}` {}", emu.pos, handle, lpName, ntype); + log_red!( + emu, + "** {} kernel32!FindResourceA {:x} `{}` {}", + emu.pos, + handle, + lpName, + ntype + ); - x = emu.pe64.as_ref().unwrap().get_resource(None, Some(lpName as u32), None, Some(&ntype)); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(None, Some(lpName as u32), None, Some(&ntype)); } else if lpName <= 0xff && lpType <= 0xff { - log_red!(emu, "** {} kernel32!FindResourceA {:x} `{}` {}", emu.pos, handle, lpName, lpType); + log_red!( + emu, + "** {} kernel32!FindResourceA {:x} `{}` {}", + emu.pos, + handle, + lpName, + lpType + ); - x = emu.pe64.as_ref().unwrap().get_resource(Some(lpType as u32), Some(lpName as u32), None, None); + x = emu.pe64.as_ref().unwrap().get_resource( + Some(lpType as u32), + Some(lpName as u32), + None, + None, + ); } else { unreachable!(); } @@ -40,9 +85,8 @@ pub fn FindResourceA(emu: &mut emu::Emu) { let (addr, size) = x.unwrap(); - log::info!("resource addr: 0x{:x} sz: {}", addr, size); let hndl = helper::handler_create(&format!("rsrc://{:x}_{}", addr, size)); emu.regs_mut().rax = hndl; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_w.rs index ad5bc9cf..d44d176d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/find_resource_w.rs @@ -11,23 +11,68 @@ pub fn FindResourceW(emu: &mut emu::Emu) { if lpName > 0xff && lpType > 0xff { let name = emu.maps.read_wide_string(lpName as u64); let ntype = emu.maps.read_wide_string(lpType as u64); - log_red!(emu, "** {} kernel32!FindResourceW {:x} `{}` `{}`", emu.pos, handle, name, ntype); + log_red!( + emu, + "** {} kernel32!FindResourceW {:x} `{}` `{}`", + emu.pos, + handle, + name, + ntype + ); - x = emu.pe64.as_ref().unwrap().get_resource(None, None, Some(&name), Some(&ntype)); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(None, None, Some(&name), Some(&ntype)); } else if lpName > 0xff && lpType <= 0xff { let name = emu.maps.read_wide_string(lpName as u64); - log_red!(emu, "** {} kernel32!FindResourceW {:x} `{}` {}", emu.pos, handle, name, lpType); + log_red!( + emu, + "** {} kernel32!FindResourceW {:x} `{}` {}", + emu.pos, + handle, + name, + lpType + ); - x = emu.pe64.as_ref().unwrap().get_resource(Some(lpType as u32), None, Some(&name), None); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(Some(lpType as u32), None, Some(&name), None); } else if lpName <= 0xff && lpType > 0xff { let ntype = emu.maps.read_wide_string(lpType as u64); - log_red!(emu, "** {} kernel32!FindResourceW {:x} `{}` {}", emu.pos, handle, lpName, ntype); + log_red!( + emu, + "** {} kernel32!FindResourceW {:x} `{}` {}", + emu.pos, + handle, + lpName, + ntype + ); - x = emu.pe64.as_ref().unwrap().get_resource(None, Some(lpName as u32), None, Some(&ntype)); + x = emu + .pe64 + .as_ref() + .unwrap() + .get_resource(None, Some(lpName as u32), None, Some(&ntype)); } else if lpName <= 0xff && lpType <= 0xff { - log_red!(emu, "** {} kernel32!FindResourceW {:x} `{}` {}", emu.pos, handle, lpName, lpType); + log_red!( + emu, + "** {} kernel32!FindResourceW {:x} `{}` {}", + emu.pos, + handle, + lpName, + lpType + ); - x = emu.pe64.as_ref().unwrap().get_resource(Some(lpType as u32), Some(lpName as u32), None, None); + x = emu.pe64.as_ref().unwrap().get_resource( + Some(lpType as u32), + Some(lpName as u32), + None, + None, + ); } else { unreachable!(); } @@ -44,4 +89,4 @@ pub fn FindResourceW(emu: &mut emu::Emu) { let hndl = helper::handler_create(&format!("rsrc://{:x}_{}", addr, size)); emu.regs_mut().rax = hndl; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_alloc.rs index 545819e8..62d75310 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_alloc.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn FlsAlloc(emu: &mut emu::Emu) { let callback = emu.regs().rcx; - log_red!( - emu, - "kernel32!FlsAlloc callback: 0x{:x}", - callback - ); + log_red!(emu, "kernel32!FlsAlloc callback: 0x{:x}", callback); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_get_value.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_get_value.rs index a9c0798c..f1d14143 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_get_value.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_get_value.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn FlsGetValue(emu: &mut emu::Emu) { @@ -15,4 +14,4 @@ pub fn FlsGetValue(emu: &mut emu::Emu) { idx, emu.regs().get_eax() as u32 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_set_value.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_set_value.rs index 608a5d3b..9511e51a 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/fls_set_value.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/fls_set_value.rs @@ -1,16 +1,10 @@ - use crate::emu; pub fn FlsSetValue(emu: &mut emu::Emu) { let idx = emu.regs().rcx; let val = emu.regs().rdx as u32; - log_red!( - emu, - "kernel32!FlsSetValue idx: {} val: {}", - idx, - val - ); + log_red!(emu, "kernel32!FlsSetValue idx: {} val: {}", idx, val); if emu.fls().len() > idx as usize { emu.fls_mut()[idx as usize] = val; @@ -22,4 +16,4 @@ pub fn FlsSetValue(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/free_resource.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/free_resource.rs index ee0d8cc7..e6a94c6f 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/free_resource.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/free_resource.rs @@ -8,4 +8,4 @@ pub fn FreeResource(emu: &mut emu::Emu) { helper::handler_close(hResData); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_acp.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_acp.rs index be2e0d36..b6e3a88b 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_acp.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_acp.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn GetACP(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetACP" - ); + log_red!(emu, "kernel32!GetACP"); emu.regs_mut().rax = 0x00000409; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_a.rs index 0bf51ef2..ae5530b2 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_a.rs @@ -1,14 +1,13 @@ +use crate::maps::mem64::Permission; use crate::{constants, emu}; pub fn GetCommandLineA(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCommandLineA" - ); + log_red!(emu, "kernel32!GetCommandLineA"); let addr = emu.maps.alloc(1024).expect("out of memory"); let name = format!("alloc_{:x}", addr); - emu.maps.create_map(&name, addr, 1024); + emu.maps + .create_map(&name, addr, 1024, Permission::READ_WRITE); emu.maps.write_string(addr, constants::EXE_NAME); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_w.rs index 89314584..dc83671e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_command_line_w.rs @@ -1,14 +1,13 @@ +use crate::maps::mem64::Permission; use crate::{constants, emu}; pub fn GetCommandLineW(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCommandLineW" - ); + log_red!(emu, "kernel32!GetCommandLineW"); let addr = emu.maps.alloc(1024).expect("out of memory"); let name = format!("alloc_{:x}", addr); - emu.maps.create_map(&name, addr, 1024); + emu.maps + .create_map(&name, addr, 1024, Permission::READ_WRITE); emu.maps.write_wide_string(addr, constants::EXE_NAME); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_a.rs index cfd7d592..43fb3813 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_a.rs @@ -1,9 +1,8 @@ - use crate::{constants, emu, winapi::winapi64::kernel32::set_last_error}; pub fn GetComputerNameA(emu: &mut emu::Emu) { - let buff_ptr = emu.regs().rcx; // LPSTR lpBuffer - let size_ptr = emu.regs().rdx; // LPDWORD nSize + let buff_ptr = emu.regs().rcx; // LPSTR lpBuffer + let size_ptr = emu.regs().rdx; // LPDWORD nSize log_red!( emu, @@ -14,28 +13,25 @@ pub fn GetComputerNameA(emu: &mut emu::Emu) { // Check if size pointer is valid if size_ptr == 0 || !emu.maps.is_mapped(size_ptr) { - log_red!( - emu, - "GetComputerNameA: Invalid nSize pointer" - ); + log_red!(emu, "GetComputerNameA: Invalid nSize pointer"); set_last_error(constants::ERROR_INVALID_PARAMETER); emu.regs_mut().rax = constants::FALSE; return; } // Read current buffer size (in bytes) - let buffer_size = emu.maps.read_dword(size_ptr).expect("Cannot read buffer size") as usize; - + let buffer_size = emu + .maps + .read_dword(size_ptr) + .expect("Cannot read buffer size") as usize; + // Calculate required size in bytes let computer_name_bytes = constants::HOST_NAME.len(); let required_size_with_null = computer_name_bytes + 1; // +1 for null terminator // Check if output buffer is valid (only if buffer_size > 0) if buffer_size > 0 && (buff_ptr == 0 || !emu.maps.is_mapped(buff_ptr)) { - log_red!( - emu, - "GetComputerNameA: Invalid lpBuffer pointer" - ); + log_red!(emu, "GetComputerNameA: Invalid lpBuffer pointer"); set_last_error(constants::ERROR_INVALID_PARAMETER); emu.regs_mut().rax = constants::FALSE; return; @@ -44,13 +40,14 @@ pub fn GetComputerNameA(emu: &mut emu::Emu) { // Check if buffer is large enough if buffer_size < required_size_with_null { log_red!( - emu, - "GetComputerNameA: Buffer too small. Required: {}, Provided: {}", - required_size_with_null, - buffer_size - ); + emu, + "GetComputerNameA: Buffer too small. Required: {}, Provided: {}", + required_size_with_null, + buffer_size + ); // Set size to required size (including null terminator) - emu.maps.write_dword(size_ptr, required_size_with_null as u32); + emu.maps + .write_dword(size_ptr, required_size_with_null as u32); set_last_error(constants::ERROR_BUFFER_OVERFLOW); emu.regs_mut().rax = constants::FALSE; return; @@ -58,7 +55,7 @@ pub fn GetComputerNameA(emu: &mut emu::Emu) { // Buffer is large enough, write the computer name emu.maps.write_string(buff_ptr, constants::HOST_NAME); - + // On success, write the number of bytes copied (NOT including null terminator) emu.maps.write_dword(size_ptr, computer_name_bytes as u32); diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_w.rs index fce8799e..d6c59267 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_computer_name_w.rs @@ -1,9 +1,8 @@ - use crate::{constants, emu, winapi::winapi64::kernel32::set_last_error}; pub fn GetComputerNameW(emu: &mut emu::Emu) { - let buff_ptr = emu.regs().rcx; // LPWSTR lpBuffer - let size_ptr = emu.regs().rdx; // LPDWORD nSize + let buff_ptr = emu.regs().rcx; // LPWSTR lpBuffer + let size_ptr = emu.regs().rdx; // LPDWORD nSize log_red!( emu, @@ -14,28 +13,25 @@ pub fn GetComputerNameW(emu: &mut emu::Emu) { // Check if size pointer is valid if size_ptr == 0 || !emu.maps.is_mapped(size_ptr) { - log_red!( - emu, - "GetComputerNameW: Invalid nSize pointer" - ); + log_red!(emu, "GetComputerNameW: Invalid nSize pointer"); set_last_error(constants::ERROR_INVALID_PARAMETER); emu.regs_mut().rax = constants::FALSE; return; } // Read current buffer size (in characters) - let buffer_size = emu.maps.read_dword(size_ptr).expect("Cannot read buffer size") as usize; - + let buffer_size = emu + .maps + .read_dword(size_ptr) + .expect("Cannot read buffer size") as usize; + // Calculate required size in characters let computer_name_chars = constants::HOST_NAME.chars().count(); let required_size_with_null = computer_name_chars + 1; // +1 for null terminator // Check if output buffer is valid (only if buffer_size > 0) if buffer_size > 0 && (buff_ptr == 0 || !emu.maps.is_mapped(buff_ptr)) { - log_red!( - emu, - "GetComputerNameW: Invalid lpBuffer pointer" - ); + log_red!(emu, "GetComputerNameW: Invalid lpBuffer pointer"); set_last_error(constants::ERROR_INVALID_PARAMETER); emu.regs_mut().rax = constants::FALSE; return; @@ -44,13 +40,14 @@ pub fn GetComputerNameW(emu: &mut emu::Emu) { // Check if buffer is large enough if buffer_size < required_size_with_null { log_red!( - emu, - "GetComputerNameW: Buffer too small. Required: {}, Provided: {}", - required_size_with_null, - buffer_size - ); + emu, + "GetComputerNameW: Buffer too small. Required: {}, Provided: {}", + required_size_with_null, + buffer_size + ); // Set size to required size (including null terminator) - emu.maps.write_dword(size_ptr, required_size_with_null as u32); + emu.maps + .write_dword(size_ptr, required_size_with_null as u32); set_last_error(constants::ERROR_BUFFER_OVERFLOW); emu.regs_mut().rax = constants::FALSE; return; @@ -58,7 +55,7 @@ pub fn GetComputerNameW(emu: &mut emu::Emu) { // Buffer is large enough, write the computer name emu.maps.write_wide_string(buff_ptr, constants::HOST_NAME); - + // On success, write the number of characters copied (NOT including null terminator) emu.maps.write_dword(size_ptr, computer_name_chars as u32); diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_cp.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_cp.rs index c7accbd3..c3220870 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_cp.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_cp.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn GetConsoleCP(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetConsoleCP" - ); + log_red!(emu, "kernel32!GetConsoleCP"); emu.regs_mut().rax = 0x00000409; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_mode.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_mode.rs index f1c8a0d6..e8b4cb5d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_mode.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_mode.rs @@ -1,11 +1,16 @@ - use crate::emu; pub fn GetConsoleMode(emu: &mut emu::Emu) { let h_console_handle = emu.regs().rcx; let lp_mode = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!GetConsoleMode {:x} {:x}", emu.pos, h_console_handle, lp_mode); + log_red!( + emu, + "** {} kernel32!GetConsoleMode {:x} {:x}", + emu.pos, + h_console_handle, + lp_mode + ); // TODO: implement this emu.maps.write_dword(lp_mode as u64, 0x00000003); //TODO: not sure what this is emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_output_cp.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_output_cp.rs index 206ba25f..d33a3786 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_output_cp.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_console_output_cp.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn GetConsoleOutputCP(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetConsoleOutputCP" - ); + log_red!(emu, "kernel32!GetConsoleOutputCP"); emu.regs_mut().rax = 0x00000409; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_cp_info.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_cp_info.rs index ec8d5a23..ebc51120 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_cp_info.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_cp_info.rs @@ -34,4 +34,4 @@ pub fn GetCPInfo(emu: &mut emu::Emu) { // Return TRUE to indicate success emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_a.rs index 8ddebde2..c98914f0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_a.rs @@ -13,7 +13,7 @@ pub fn GetCurrentDirectoryA(emu: &mut emu::Emu) { let current_dir = constants::CWD_PATH; let dir_byte_count = current_dir.len(); // Use len() for byte count in ANSI strings - + // When buffer length is 0 or buffer is null, return required size INCLUDING null terminator if buff_len == 0 || buff_ptr == 0 { set_last_error(constants::ERROR_INSUFFICIENT_BUFFER); @@ -42,4 +42,4 @@ pub fn GetCurrentDirectoryA(emu: &mut emu::Emu) { // Return number of characters written (NOT including null terminator) emu.regs_mut().rax = dir_byte_count as u64; set_last_error(0); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_w.rs index f84305b6..e9d7b531 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_directory_w.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu, winapi::winapi64::kernel32::set_last_error}; pub fn GetCurrentDirectoryW(emu: &mut emu::Emu) { @@ -15,7 +14,6 @@ pub fn GetCurrentDirectoryW(emu: &mut emu::Emu) { buff_ptr, ); - // When buffer length is 0 or buffer is null, return required size INCLUDING null terminator if buff_len == 0 || buff_ptr == 0 { set_last_error(constants::ERROR_INSUFFICIENT_BUFFER); @@ -44,5 +42,4 @@ pub fn GetCurrentDirectoryW(emu: &mut emu::Emu) { // Return number of characters written (NOT including null terminator) set_last_error(0); emu.regs_mut().rax = dir_char_count as u64; - } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process.rs index 2be605e5..1bf49393 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process.rs @@ -1,11 +1,7 @@ - use crate::emu; use crate::winapi::helper; pub fn GetCurrentProcess(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCurrentProcess" - ); + log_red!(emu, "kernel32!GetCurrentProcess"); emu.regs_mut().rax = helper::handler_create("current process"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process_id.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process_id.rs index 4cf0f693..3ce67cf7 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process_id.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_process_id.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn GetCurrentProcessId(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetCurrentProcessId" - ); + log_red!(emu, "kernel32!GetCurrentProcessId"); emu.regs_mut().rax = 0x123; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread.rs index 86bd9599..161860a8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread.rs @@ -1,12 +1,11 @@ - use crate::emu; pub fn GetCurrentThread(emu: &mut emu::Emu) { log_red!(emu, "** {} kernel32!GetCurrentThread", emu.pos); - + // GetCurrentThread returns a pseudo-handle (-2 or 0xFFFFFFFFFFFFFFFE in 64-bit) // This is a special constant that always refers to the current thread const CURRENT_THREAD_PSEUDO_HANDLE: u64 = 0xFFFFFFFFFFFFFFFE; // -2 as u64 - + emu.regs_mut().rax = CURRENT_THREAD_PSEUDO_HANDLE; } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread_id.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread_id.rs index b4e15797..d323bc6b 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread_id.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_current_thread_id.rs @@ -1,10 +1,9 @@ - use crate::emu; pub fn GetCurrentThreadId(emu: &mut emu::Emu) { let thread_id = emu.current_thread().id; - + log_red!(emu, "kernel32!GetCurrentThreadId = 0x{:x}", thread_id); - + emu.regs_mut().rax = thread_id; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_strings_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_strings_w.rs index fc52a456..12ca440b 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_strings_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_strings_w.rs @@ -1,13 +1,10 @@ - use crate::emu; +use crate::maps::mem64::Permission; pub fn GetEnvironmentStringsW(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetEnvironmentStringsW" - ); - let addr = emu.alloc("environment", 1024); + log_red!(emu, "kernel32!GetEnvironmentStringsW"); + let addr = emu.alloc("environment", 1024, Permission::READ_WRITE); emu.maps .write_wide_string(addr, "PATH=c:\\Windows\\System32"); emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_variable_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_variable_w.rs index 61f981f0..d842fe39 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_variable_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_environment_variable_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetEnvironmentVariableW(emu: &mut emu::Emu) { @@ -6,7 +5,15 @@ pub fn GetEnvironmentVariableW(emu: &mut emu::Emu) { let lp_buffer = emu.regs().rdx as usize; let n_size = emu.regs().r8 as usize; let name = emu.maps.read_wide_string(lp_name as u64); - log_red!(emu, "** {} kernel32!GetEnvironmentVariableW {:x} {:x} {:x} name: {}", emu.pos, lp_name, lp_buffer, n_size, name); + log_red!( + emu, + "** {} kernel32!GetEnvironmentVariableW {:x} {:x} {:x} name: {}", + emu.pos, + lp_name, + lp_buffer, + n_size, + name + ); // TODO: implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_a.rs index 2da85af7..3c7d0da6 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_a.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn GetFileAttributesA(emu: &mut emu::Emu) { let filename_ptr = emu.regs().rcx; let filename = emu.maps.read_string(filename_ptr); - log_red!( - emu, - "kernel32!GetFileAttributesA file: {}", - filename - ); + log_red!(emu, "kernel32!GetFileAttributesA file: {}", filename); emu.regs_mut().rax = 0x123; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_w.rs index 84db45b3..0e4b51cc 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_attributes_w.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn GetFileAttributesW(emu: &mut emu::Emu) { let filename_ptr = emu.regs().rcx; let filename = emu.maps.read_wide_string(filename_ptr); - log_red!( - emu, - "kernel32!GetFileAttributesW file: {}", - filename - ); + log_red!(emu, "kernel32!GetFileAttributesW file: {}", filename); emu.regs_mut().rax = 0x123; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_size.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_size.rs index d2a03cb9..b0ee1e1d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_size.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_file_size.rs @@ -1,19 +1,32 @@ - use crate::emu; use crate::winapi::helper; pub fn GetFileSize(emu: &mut emu::Emu) { let h_file = emu.regs().rcx; let lp_file_size_high = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!GetFileSize {:x} {:x}", emu.pos, h_file, lp_file_size_high); + log_red!( + emu, + "** {} kernel32!GetFileSize {:x} {:x}", + emu.pos, + h_file, + lp_file_size_high + ); // TODO: Implement this let name = helper::handler_get_uri(h_file); if name == "HaspEmul.dll" { - let size = std::fs::metadata("/Users/jesus/Downloads/enigma/surprise.dll").unwrap().len(); - log::info!("** {} kernel32!GetFileSize {:x} {:x} size: {}", emu.pos, h_file, lp_file_size_high, size); + let size = std::fs::metadata("/Users/jesus/Downloads/enigma/surprise.dll") + .unwrap() + .len(); + log::info!( + "** {} kernel32!GetFileSize {:x} {:x} size: {}", + emu.pos, + h_file, + lp_file_size_high, + size + ); emu.regs_mut().rax = size as u64; } else { panic!("unknown file"); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_a.rs index 5bf0372a..fc0ea1d5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetFullPathNameA(emu: &mut emu::Emu) { @@ -8,12 +7,8 @@ pub fn GetFullPathNameA(emu: &mut emu::Emu) { let path = emu.regs().r9; let filename = emu.maps.read_string(file_ptr); - log_red!( - emu, - "kernel32!GetFullPathNameA file: {}", - filename - ); + log_red!(emu, "kernel32!GetFullPathNameA file: {}", filename); // TODO: save the path to buff. //emu.regs_mut().rax = 10; panic!("TODO"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_w.rs index e5706e69..ed7cd654 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_full_path_name_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetFullPathNameW(emu: &mut emu::Emu) { @@ -8,12 +7,8 @@ pub fn GetFullPathNameW(emu: &mut emu::Emu) { let path = emu.regs().r9; let filename = emu.maps.read_wide_string(file_ptr); - log_red!( - emu, - "kernel32!GetFullPathNameW file: {}", - filename - ); + log_red!(emu, "kernel32!GetFullPathNameW file: {}", filename); // TODO: save the path to buff. //emu.regs_mut().rax = 10; panic!("TODO"); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_last_error.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_last_error.rs index 9aa38354..85a86fb1 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_last_error.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_last_error.rs @@ -1,13 +1,8 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::LAST_ERROR; pub fn GetLastError(emu: &mut emu::Emu) { let err = LAST_ERROR.lock().unwrap(); emu.regs_mut().rax = *err; - log_red!( - emu, - "kernel32!GetLastError ={}", - emu.regs().rax - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetLastError ={}", emu.regs().rax); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_local_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_local_time.rs index 2b653d77..28cc3c92 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_local_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_local_time.rs @@ -22,8 +22,5 @@ pub fn GetLocalTime(emu: &mut emu::Emu) { emu.maps.write_bytes(ptr, buffer.to_vec()); - log_red!( - emu, - "kernel32!GetLocalTime" - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetLocalTime"); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_a.rs index 5a439d86..1457f4ba 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_a.rs @@ -1,6 +1,5 @@ - -use crate::{constants, emu}; use crate::winapi::winapi64::kernel32::{clear_last_error, LAST_ERROR}; +use crate::{constants, emu}; pub fn GetLocaleInfoA(emu: &mut emu::Emu) { let locale = emu.regs().rcx as usize; @@ -20,7 +19,12 @@ pub fn GetLocaleInfoA(emu: &mut emu::Emu) { // Check if buffer is too small if cch_data < required_size { - log::warn!("{} buffer too small for result cch_data: {} required_size: {}", emu.pos, cch_data, required_size); + log::warn!( + "{} buffer too small for result cch_data: {} required_size: {}", + emu.pos, + cch_data, + required_size + ); let mut err = LAST_ERROR.lock().unwrap(); *err = constants::ERROR_INSUFFICIENT_BUFFER; emu.regs_mut().rax = 0; @@ -31,4 +35,4 @@ pub fn GetLocaleInfoA(emu: &mut emu::Emu) { emu.maps.write_string(lp_lc_data as u64, &result); emu.regs_mut().rax = result.len() as u64; // Return length without null terminator clear_last_error(emu); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_w.rs index 26ce1b78..784cbd34 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_locale_info_w.rs @@ -1,5 +1,5 @@ -use crate::{constants, emu}; use crate::winapi::winapi64::kernel32::{clear_last_error, LAST_ERROR}; +use crate::{constants, emu}; // FROM THE ASSEMBLY FILE - THESE ARE THE CORRECT VALUES: const LOCALE_ILANGUAGE: u64 = 0x1; @@ -43,46 +43,46 @@ const LOCALE_IDAYLZERO: u64 = 0x26; const LOCALE_IMONLZERO: u64 = 0x27; const LOCALE_S1159: u64 = 0x28; const LOCALE_S2359: u64 = 0x29; -const LOCALE_SDAYNAME1: u64 = 0x2A; // Monday -const LOCALE_SDAYNAME2: u64 = 0x2B; // Tuesday -const LOCALE_SDAYNAME3: u64 = 0x2C; // Wednesday -const LOCALE_SDAYNAME4: u64 = 0x2D; // Thursday -const LOCALE_SDAYNAME5: u64 = 0x2E; // Friday -const LOCALE_SDAYNAME6: u64 = 0x2F; // Saturday -const LOCALE_SDAYNAME7: u64 = 0x30; // Sunday -const LOCALE_SABBREVDAYNAME1: u64 = 0x31; // Monday abbreviated -const LOCALE_SABBREVDAYNAME2: u64 = 0x32; // Tuesday abbreviated -const LOCALE_SABBREVDAYNAME3: u64 = 0x33; // Wednesday abbreviated -const LOCALE_SABBREVDAYNAME4: u64 = 0x34; // Thursday abbreviated -const LOCALE_SABBREVDAYNAME5: u64 = 0x35; // Friday abbreviated -const LOCALE_SABBREVDAYNAME6: u64 = 0x36; // Saturday abbreviated -const LOCALE_SABBREVDAYNAME7: u64 = 0x37; // Sunday abbreviated -const LOCALE_SMONTHNAME1: u64 = 0x38; // January -const LOCALE_SMONTHNAME2: u64 = 0x39; // February -const LOCALE_SMONTHNAME3: u64 = 0x3A; // March -const LOCALE_SMONTHNAME4: u64 = 0x3B; // April -const LOCALE_SMONTHNAME5: u64 = 0x3C; // May -const LOCALE_SMONTHNAME6: u64 = 0x3D; // June -const LOCALE_SMONTHNAME7: u64 = 0x3E; // July -const LOCALE_SMONTHNAME8: u64 = 0x3F; // August -const LOCALE_SMONTHNAME9: u64 = 0x40; // September -const LOCALE_SMONTHNAME10: u64 = 0x41; // October -const LOCALE_SMONTHNAME11: u64 = 0x42; // November -const LOCALE_SMONTHNAME12: u64 = 0x43; // December -const LOCALE_SABBREVMONTHNAME1: u64 = 0x44; // January abbreviated -const LOCALE_SABBREVMONTHNAME2: u64 = 0x45; // February abbreviated -const LOCALE_SABBREVMONTHNAME3: u64 = 0x46; // March abbreviated -const LOCALE_SABBREVMONTHNAME4: u64 = 0x47; // April abbreviated -const LOCALE_SABBREVMONTHNAME5: u64 = 0x48; // May abbreviated -const LOCALE_SABBREVMONTHNAME6: u64 = 0x49; // June abbreviated -const LOCALE_SABBREVMONTHNAME7: u64 = 0x4A; // July abbreviated -const LOCALE_SABBREVMONTHNAME8: u64 = 0x4B; // August abbreviated -const LOCALE_SABBREVMONTHNAME9: u64 = 0x4C; // September abbreviated +const LOCALE_SDAYNAME1: u64 = 0x2A; // Monday +const LOCALE_SDAYNAME2: u64 = 0x2B; // Tuesday +const LOCALE_SDAYNAME3: u64 = 0x2C; // Wednesday +const LOCALE_SDAYNAME4: u64 = 0x2D; // Thursday +const LOCALE_SDAYNAME5: u64 = 0x2E; // Friday +const LOCALE_SDAYNAME6: u64 = 0x2F; // Saturday +const LOCALE_SDAYNAME7: u64 = 0x30; // Sunday +const LOCALE_SABBREVDAYNAME1: u64 = 0x31; // Monday abbreviated +const LOCALE_SABBREVDAYNAME2: u64 = 0x32; // Tuesday abbreviated +const LOCALE_SABBREVDAYNAME3: u64 = 0x33; // Wednesday abbreviated +const LOCALE_SABBREVDAYNAME4: u64 = 0x34; // Thursday abbreviated +const LOCALE_SABBREVDAYNAME5: u64 = 0x35; // Friday abbreviated +const LOCALE_SABBREVDAYNAME6: u64 = 0x36; // Saturday abbreviated +const LOCALE_SABBREVDAYNAME7: u64 = 0x37; // Sunday abbreviated +const LOCALE_SMONTHNAME1: u64 = 0x38; // January +const LOCALE_SMONTHNAME2: u64 = 0x39; // February +const LOCALE_SMONTHNAME3: u64 = 0x3A; // March +const LOCALE_SMONTHNAME4: u64 = 0x3B; // April +const LOCALE_SMONTHNAME5: u64 = 0x3C; // May +const LOCALE_SMONTHNAME6: u64 = 0x3D; // June +const LOCALE_SMONTHNAME7: u64 = 0x3E; // July +const LOCALE_SMONTHNAME8: u64 = 0x3F; // August +const LOCALE_SMONTHNAME9: u64 = 0x40; // September +const LOCALE_SMONTHNAME10: u64 = 0x41; // October +const LOCALE_SMONTHNAME11: u64 = 0x42; // November +const LOCALE_SMONTHNAME12: u64 = 0x43; // December +const LOCALE_SABBREVMONTHNAME1: u64 = 0x44; // January abbreviated +const LOCALE_SABBREVMONTHNAME2: u64 = 0x45; // February abbreviated +const LOCALE_SABBREVMONTHNAME3: u64 = 0x46; // March abbreviated +const LOCALE_SABBREVMONTHNAME4: u64 = 0x47; // April abbreviated +const LOCALE_SABBREVMONTHNAME5: u64 = 0x48; // May abbreviated +const LOCALE_SABBREVMONTHNAME6: u64 = 0x49; // June abbreviated +const LOCALE_SABBREVMONTHNAME7: u64 = 0x4A; // July abbreviated +const LOCALE_SABBREVMONTHNAME8: u64 = 0x4B; // August abbreviated +const LOCALE_SABBREVMONTHNAME9: u64 = 0x4C; // September abbreviated const LOCALE_SABBREVMONTHNAME10: u64 = 0x4D; // October abbreviated const LOCALE_SABBREVMONTHNAME11: u64 = 0x4E; // November abbreviated const LOCALE_SABBREVMONTHNAME12: u64 = 0x4F; // December abbreviated -const LOCALE_SPOSITIVESIGN: u64 = 0x50; // Positive sign -const LOCALE_SNEGATIVESIGN: u64 = 0x51; // Negative sign +const LOCALE_SPOSITIVESIGN: u64 = 0x50; // Positive sign +const LOCALE_SNEGATIVESIGN: u64 = 0x51; // Negative sign // Additional constants: const LOCALE_STIMEFORMAT: u64 = 0x1003; @@ -96,10 +96,10 @@ const LOCALE_SSORTNAME: u64 = 0x1013; const LOCALE_IDIGITSUBSTITUTION: u64 = 0x1014; // These don't have conflicts anymore, but removing duplicates: -const LOCALE_ICALENDARTYPE: u64 = 0x100A; // Calendar type (1=Gregorian) - MADE UP VALUE -const LOCALE_IOPTIONALCALENDAR: u64 = 0x100B; // Optional calendar type - MADE UP VALUE -const LOCALE_IFIRSTDAYOFWEEK: u64 = 0x100C; // First day of week (0=Monday, 6=Sunday) - MADE UP VALUE -const LOCALE_IFIRSTWEEKOFYEAR: u64 = 0x100D; // First week of year - MADE UP VALUE +const LOCALE_ICALENDARTYPE: u64 = 0x100A; // Calendar type (1=Gregorian) - MADE UP VALUE +const LOCALE_IOPTIONALCALENDAR: u64 = 0x100B; // Optional calendar type - MADE UP VALUE +const LOCALE_IFIRSTDAYOFWEEK: u64 = 0x100C; // First day of week (0=Monday, 6=Sunday) - MADE UP VALUE +const LOCALE_IFIRSTWEEKOFYEAR: u64 = 0x100D; // First week of year - MADE UP VALUE const LOCALE_RETURN_NUMBER: u64 = 0x20000000; pub fn GetLocaleInfoW(emu: &mut emu::Emu) { @@ -183,7 +183,7 @@ pub fn GetLocaleInfoW(emu: &mut emu::Emu) { LOCALE_SABBREVDAYNAME5 => "Fri", LOCALE_SABBREVDAYNAME6 => "Sat", LOCALE_SABBREVDAYNAME7 => "Sun", - + // Additional commonly used constants: LOCALE_ILANGUAGE => "0409", LOCALE_IDEFAULTLANGUAGE => "0409", @@ -208,9 +208,13 @@ pub fn GetLocaleInfoW(emu: &mut emu::Emu) { LOCALE_IDEFAULTMACCODEPAGE => "10000", LOCALE_SSORTNAME => "Default", LOCALE_IDIGITSUBSTITUTION => "1", - + _ => { - log::warn!("{} GetLocaleInfoW unhandled lctype: 0x{:x}", emu.pos, lctype); + log::warn!( + "{} GetLocaleInfoW unhandled lctype: 0x{:x}", + emu.pos, + lctype + ); "." // Default fallback } }; @@ -235,7 +239,12 @@ pub fn GetLocaleInfoW(emu: &mut emu::Emu) { // Check if buffer is too small if cch_data < required_size { - log::warn!("{} buffer too small for result cch_data: {} required_size: {}", emu.pos, cch_data, required_size); + log::warn!( + "{} buffer too small for result cch_data: {} required_size: {}", + emu.pos, + cch_data, + required_size + ); let mut err = LAST_ERROR.lock().unwrap(); *err = constants::ERROR_INSUFFICIENT_BUFFER; emu.regs_mut().rax = 0; diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_logical_drives.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_logical_drives.rs index e3fa8e34..62425c19 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_logical_drives.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_logical_drives.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn GetLogicalDrives(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetLogicalDrives" - ); + log_red!(emu, "kernel32!GetLogicalDrives"); emu.regs_mut().rax = 0xc; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_a.rs index 2cb36431..92e43232 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_a.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn GetModuleFileNameA(emu: &mut emu::Emu) { @@ -13,9 +12,5 @@ pub fn GetModuleFileNameA(emu: &mut emu::Emu) { emu.regs_mut().rax = 0; } - log_red!( - emu, - "kernel32!GetModuleFileNameA hndl:{:x}", - hndl - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetModuleFileNameA hndl:{:x}", hndl); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_w.rs index 1731d250..fa891e8a 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_file_name_w.rs @@ -4,7 +4,7 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { let module_handle = emu.regs().rcx; let lp_filename = emu.regs().rdx; let n_size = emu.regs().r8 as u32; - + log_red!( emu, "kernel32!GetModuleFileNameW hModule: 0x{:x} lpFilename: 0x{:x} nSize: {}", @@ -15,20 +15,14 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { // Handle zero size buffer if n_size == 0 { - log_red!( - emu, - "GetModuleFileNameW: Zero size buffer" - ); + log_red!(emu, "GetModuleFileNameW: Zero size buffer"); emu.regs_mut().rax = 0; return; } // Validate buffer pointer if lp_filename == 0 || !emu.maps.is_mapped(lp_filename) { - log_red!( - emu, - "GetModuleFileNameW: Invalid buffer pointer" - ); + log_red!(emu, "GetModuleFileNameW: Invalid buffer pointer"); emu.regs_mut().rax = 0; return; } @@ -36,7 +30,7 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { // Determine which module name to use based on handle let module_name = if module_handle == 0 { // NULL handle means current process executable - constants::MODULE_NAME // or constants::EXE_NAME if you have it + constants::MODULE_NAME // or constants::EXE_NAME if you have it } else { // TODO: Look up actual module by handle // For now, just use the default module name @@ -50,29 +44,29 @@ pub fn GetModuleFileNameW(emu: &mut emu::Emu) { // Buffer too small - truncate to fit let max_chars = (n_size as usize) - 1; // Reserve space for null terminator let truncated: String = module_name.chars().take(max_chars).collect(); - + emu.maps.write_wide_string(lp_filename, &truncated); - + log_red!( - emu, - "GetModuleFileNameW: Buffer too small, truncated to '{}'", - truncated - ); - + emu, + "GetModuleFileNameW: Buffer too small, truncated to '{}'", + truncated + ); + // Set last error for Windows XP+ behavior set_last_error(constants::ERROR_INSUFFICIENT_BUFFER); emu.regs_mut().rax = n_size as u64; // Return buffer size when truncated } else { // Buffer is large enough emu.maps.write_wide_string(lp_filename, module_name); - + log_red!( - emu, - "GetModuleFileNameW: Returning '{}' (length: {})", - module_name, - name_chars - ); - + emu, + "GetModuleFileNameW: Returning '{}' (length: {})", + module_name, + name_chars + ); + emu.regs_mut().rax = name_chars as u64; // Return actual length (without null terminator) } } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_a.rs index 6262c383..929a41b3 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_a.rs @@ -1,7 +1,6 @@ - +use crate::constants; use crate::emu; use crate::peb; -use crate::constants; use crate::winapi::helper; pub fn GetModuleHandleA(emu: &mut emu::Emu) { @@ -10,17 +9,18 @@ pub fn GetModuleHandleA(emu: &mut emu::Emu) { let base; if module_name_ptr == 0 { - module_name = constants::EXE_NAME.to_string(); base = match peb::peb64::get_module_base(&module_name, emu) { Some(b) => b, None => helper::handler_create(&module_name), }; - } else { module_name = emu.maps.read_string(module_name_ptr); - let mod_mem = match emu.maps.get_mem2(&module_name.to_lowercase().replace(".dll",".pe")) { + let mod_mem = match emu + .maps + .get_mem2(&module_name.to_lowercase().replace(".dll", ".pe")) + { Some(m) => m, None => { emu.regs_mut().rax = 0; @@ -28,7 +28,6 @@ pub fn GetModuleHandleA(emu: &mut emu::Emu) { } }; base = mod_mem.get_base(); - } log_red!( @@ -37,6 +36,6 @@ pub fn GetModuleHandleA(emu: &mut emu::Emu) { module_name, base ); - + emu.regs_mut().rax = base; } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_w.rs index 5369108a..67d299e4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_module_handle_w.rs @@ -1,7 +1,6 @@ - +use crate::constants; use crate::emu; use crate::peb; -use crate::constants; use crate::winapi::helper; pub fn GetModuleHandleW(emu: &mut emu::Emu) { @@ -10,16 +9,17 @@ pub fn GetModuleHandleW(emu: &mut emu::Emu) { let base; if module_name_ptr == 0 { - module_name = constants::EXE_NAME.to_string(); base = match peb::peb64::get_module_base(&module_name, emu) { Some(b) => b, None => helper::handler_create(&module_name), }; - } else { module_name = emu.maps.read_wide_string(module_name_ptr).to_lowercase(); - let mod_mem = match emu.maps.get_mem2(&module_name.to_lowercase().replace(".dll",".pe")) { + let mod_mem = match emu + .maps + .get_mem2(&module_name.to_lowercase().replace(".dll", ".pe")) + { Some(m) => m, None => { emu.regs_mut().rax = 0; diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_native_system_info.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_native_system_info.rs index 1f2e2ca3..2e22849e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_native_system_info.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_native_system_info.rs @@ -1,4 +1,3 @@ - use crate::{emu, structures}; pub fn GetNativeSystemInfo(emu: &mut emu::Emu) { @@ -7,15 +6,7 @@ pub fn GetNativeSystemInfo(emu: &mut emu::Emu) { let mut sysinfo = structures::SystemInfo64::new(); sysinfo.save(ptr_sysinfo, &mut emu.maps); - log_red!( - emu, - "kernel32!GetNativeSysteminfo {:?}", - sysinfo - ); + log_red!(emu, "kernel32!GetNativeSysteminfo {:?}", sysinfo); - log_red!( - emu, - "kernel32!GetNativeSysteminfo 0x{:x}", - ptr_sysinfo - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetNativeSysteminfo 0x{:x}", ptr_sysinfo); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_proc_address.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_proc_address.rs index 3b358a24..5d08a194 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_proc_address.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_proc_address.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::peb::peb64; @@ -10,12 +9,12 @@ pub fn GetProcAddress(emu: &mut emu::Emu) { if func == "zwcopyfilechunk" { emu.regs_mut().rax = 0x7ff7e0001337; log_red!( - emu, - "kernel32!GetProcAddress `{}!{}` =0x{:x}", - "kernel32", - "zwcopyfilechunk", - emu.regs().rax - ); + emu, + "kernel32!GetProcAddress `{}!{}` =0x{:x}", + "kernel32", + "zwcopyfilechunk", + emu.regs().rax + ); return; } @@ -36,12 +35,12 @@ pub fn GetProcAddress(emu: &mut emu::Emu) { if ordinal.func_name.to_lowercase() == func { emu.regs_mut().rax = ordinal.func_va; log_red!( - emu, - "kernel32!GetProcAddress `{}!{}` =0x{:x}", - flink.mod_name, - ordinal.func_name, - emu.regs().rax - ); + emu, + "kernel32!GetProcAddress `{}!{}` =0x{:x}", + flink.mod_name, + ordinal.func_name, + emu.regs().rax + ); return; } } @@ -54,4 +53,4 @@ pub fn GetProcAddress(emu: &mut emu::Emu) { } emu.regs_mut().rax = 0; log::warn!("kernel32!GetProcAddress error searching {}", func); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_affinity_mask.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_affinity_mask.rs index 7cd1d249..1a5573a9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_affinity_mask.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_affinity_mask.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetProcessAffinityMask(emu: &mut emu::Emu) { @@ -9,10 +8,7 @@ pub fn GetProcessAffinityMask(emu: &mut emu::Emu) { emu.maps.write_dword(proc_affinity_mask_ptr, 0x1337); emu.maps.write_dword(sys_affinity_mask_ptr, 0x1337); - log_red!( - emu, - "kernel32!GetProcessAffinityMask" - ); + log_red!(emu, "kernel32!GetProcessAffinityMask"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_heap.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_heap.rs index adc96f9c..f6d2d9be 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_heap.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_process_heap.rs @@ -1,13 +1,8 @@ - use crate::emu; use crate::winapi::helper; pub fn GetProcessHeap(emu: &mut emu::Emu) { emu.regs_mut().rax = helper::handler_create("heap"); - log_red!( - emu, - "kernel32!GetProcessHeap ={}", - emu.regs().rax - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetProcessHeap ={}", emu.regs().rax); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_a.rs index 6a770ffc..bef852a8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_a.rs @@ -1,15 +1,11 @@ - use crate::{emu, structures}; pub fn GetStartupInfoA(emu: &mut emu::Emu) { let startup_info_ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetStartupInfoA" - ); + log_red!(emu, "kernel32!GetStartupInfoA"); if startup_info_ptr > 0 { let startupinfo = structures::StartupInfo64::new(); startupinfo.save(startup_info_ptr, &mut emu.maps); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_w.rs index e7639d4d..9e7b8489 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_startup_info_w.rs @@ -1,15 +1,11 @@ - use crate::{emu, structures}; pub fn GetStartupInfoW(emu: &mut emu::Emu) { let startup_info_ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetStartupInfoW" - ); + log_red!(emu, "kernel32!GetStartupInfoW"); if startup_info_ptr > 0 { let startupinfo = structures::StartupInfo64::new(); startupinfo.save(startup_info_ptr, &mut emu.maps); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_std_handle.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_std_handle.rs index 4940338d..d196e3f2 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_std_handle.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_std_handle.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn GetStdHandle(emu: &mut emu::Emu) { - let nstd = emu.regs().rcx as usize; // Parameter passed in RCX in x64 - log_red!(emu, "** {} kernel32!GetStdHandle nstd: {}", - emu.pos, - nstd - ); + let nstd = emu.regs().rcx as usize; // Parameter passed in RCX in x64 + log_red!(emu, "** {} kernel32!GetStdHandle nstd: {}", emu.pos, nstd); emu.regs_mut().rax = nstd as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_a.rs index 32873752..fcbc21b8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_a.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn GetSystemDirectoryA(emu: &mut emu::Emu) { @@ -8,10 +7,7 @@ pub fn GetSystemDirectoryA(emu: &mut emu::Emu) { let output = constants::SYSTEM_DIRECTORY; emu.maps.write_string(out_buff_ptr, &output); - log_red!( - emu, - "kernel32!GetSystemDirectoryA" - ); + log_red!(emu, "kernel32!GetSystemDirectoryA"); emu.regs_mut().rax = output.len() as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_w.rs index 9a7bb62c..9d8984e3 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_directory_w.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn GetSystemDirectoryW(emu: &mut emu::Emu) { @@ -23,7 +22,10 @@ pub fn GetSystemDirectoryW(emu: &mut emu::Emu) { // Check if buffer is mapped if !emu.maps.is_mapped(out_buff_ptr) { - log::error!("GetSystemDirectoryW: lpBuffer 0x{:x} is not mapped", out_buff_ptr); + log::error!( + "GetSystemDirectoryW: lpBuffer 0x{:x} is not mapped", + out_buff_ptr + ); emu.regs_mut().rax = 0; // Failure return; } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_firmware_table.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_firmware_table.rs index bc137902..b1032f5d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_firmware_table.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_firmware_table.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetSystemFirmwareTable(emu: &mut emu::Emu) { @@ -40,4 +39,4 @@ pub fn GetSystemFirmwareTable(emu: &mut emu::Emu) { } else { emu.regs_mut().rax = 0; // Return 0 (error) for now } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_info.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_info.rs index fa6fb5a8..3d38feb0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_info.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_info.rs @@ -1,15 +1,10 @@ - use crate::{emu, structures}; pub fn GetSystemInfo(emu: &mut emu::Emu) { let out_sysinfo = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetSystemInfo sysinfo: 0x{:x}", - out_sysinfo - ); + log_red!(emu, "kernel32!GetSystemInfo sysinfo: 0x{:x}", out_sysinfo); let mut sysinfo = structures::SystemInfo64::new(); sysinfo.save(out_sysinfo, &mut emu.maps); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time.rs index 2eb9e862..55c41d5c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time.rs @@ -1,15 +1,10 @@ - use crate::{emu, structures}; pub fn GetSystemTime(emu: &mut emu::Emu) { let out_time = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetSystemTime ptr: 0x{:x}'", - out_time - ); + log_red!(emu, "kernel32!GetSystemTime ptr: 0x{:x}'", out_time); let systime = structures::SystemTime::now(); systime.save(out_time, &mut emu.maps); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time_as_file_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time_as_file_time.rs index 47b6f845..d853b948 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time_as_file_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_system_time_as_file_time.rs @@ -1,15 +1,11 @@ - use crate::emu; pub fn GetSystemTimeAsFileTime(emu: &mut emu::Emu) { let sys_time_ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetSystemTimeAsFileTime" - ); + log_red!(emu, "kernel32!GetSystemTimeAsFileTime"); // TODO: implement emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_temp_path_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_temp_path_w.rs index a1798e66..abf29341 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_temp_path_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_temp_path_w.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn GetTempPathW(emu: &mut emu::Emu) { @@ -39,4 +38,4 @@ pub fn GetTempPathW(emu: &mut emu::Emu) { // Return the number of characters copied (excluding null terminator) emu.regs_mut().rax = (required_length - 1) as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_context.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_context.rs index b4a6d426..ccfefea5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_context.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_context.rs @@ -1,4 +1,3 @@ - use crate::context::context64; use crate::emu; @@ -9,10 +8,7 @@ pub fn GetThreadContext(emu: &mut emu::Emu) { let ctx = context64::Context64::new(&emu.regs()); ctx.save(ctx_ptr, &mut emu.maps); - log_red!( - emu, - "kernel32!GetThreadContext" - ); + log_red!(emu, "kernel32!GetThreadContext"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_locale.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_locale.rs index 5688d82f..b71636d0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_locale.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_thread_locale.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn GetThreadLocale(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetThreadLocale" - ); + log_red!(emu, "kernel32!GetThreadLocale"); //emu.regs_mut().rax = constants::LOCALE_USER_DEFAULT; // TODO: 0x400 LOCALE_USER_DEFAULT or 0x409? emu.regs_mut().rax = 0x409; // English (United States) -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_tick_count.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_tick_count.rs index f36633b6..06c80df4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_tick_count.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_tick_count.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn GetTickCount(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetTickCount" - ); + log_red!(emu, "kernel32!GetTickCount"); // TODO: increment the tick? emu.regs_mut().rax = emu.tick as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lang_id.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lang_id.rs index 660ecacc..70f9da45 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lang_id.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lang_id.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn GetUserDefaultLangId(emu: &mut emu::Emu) { @@ -8,4 +7,4 @@ pub fn GetUserDefaultLangId(emu: &mut emu::Emu) { "kernel32!GetUserDefaultLangID =0x{:x}", emu.regs().rax as u16 ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lcid.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lcid.rs index 1a1d0982..25c33826 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lcid.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_user_default_lcid.rs @@ -1,10 +1,6 @@ - use crate::{constants, emu}; pub fn GetUserDefaultLCID(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!GetUserDefaultLCID" - ); + log_red!(emu, "kernel32!GetUserDefaultLCID"); emu.regs_mut().rax = constants::LOCALE_USER_DEFAULT; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version.rs index 64885917..d2abcb55 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version.rs @@ -1,11 +1,6 @@ - use crate::{constants, emu}; pub fn GetVersion(emu: &mut emu::Emu) { emu.regs_mut().rax = constants::VERSION; - log_red!( - emu, - "kernel32!GetVersion =0x{:x}", - emu.regs().rax - ); -} \ No newline at end of file + log_red!(emu, "kernel32!GetVersion =0x{:x}", emu.regs().rax); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_a.rs index ae3b3351..ad47ce22 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_a.rs @@ -3,58 +3,44 @@ use crate::{emu, structures}; pub fn GetVersionExA(emu: &mut emu::Emu) { let version_info_ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetVersionExA 0x{:x}", - version_info_ptr - ); + log_red!(emu, "kernel32!GetVersionExA 0x{:x}", version_info_ptr); // Check if pointer is valid if version_info_ptr == 0 || !emu.maps.is_mapped(version_info_ptr) { - log_red!( - emu, - "GetVersionExA: Invalid pointer" - ); + log_red!(emu, "GetVersionExA: Invalid pointer"); emu.regs_mut().rax = 0; return; } // Read the dwOSVersionInfoSize field (first 4 bytes) to determine structure type - let struct_size = emu.maps.read_dword(version_info_ptr).expect("Cannot read struct size"); - - log_red!( - emu, - "GetVersionExA: Structure size: {}", - struct_size - ); + let struct_size = emu + .maps + .read_dword(version_info_ptr) + .expect("Cannot read struct size"); + + log_red!(emu, "GetVersionExA: Structure size: {}", struct_size); // Determine which structure type based on size - const OSVERSIONINFOA_SIZE: u32 = 148; // Basic structure - const OSVERSIONINFOEXA_SIZE: u32 = 284; // Extended structure + const OSVERSIONINFOA_SIZE: u32 = 148; // Basic structure + const OSVERSIONINFOEXA_SIZE: u32 = 284; // Extended structure let use_extended = match struct_size { OSVERSIONINFOA_SIZE => { - log_red!( - emu, - "Using OSVERSIONINFOA (basic)" - ); + log_red!(emu, "Using OSVERSIONINFOA (basic)"); false - }, + } OSVERSIONINFOEXA_SIZE => { - log_red!( - emu, - "Using OSVERSIONINFOEXA (extended)" - ); + log_red!(emu, "Using OSVERSIONINFOEXA (extended)"); true - }, + } _ => { log_red!( - emu, - "GetVersionExA: Invalid struct size: {} (expected {} or {})", - struct_size, - OSVERSIONINFOA_SIZE, - OSVERSIONINFOEXA_SIZE - ); + emu, + "GetVersionExA: Invalid struct size: {} (expected {} or {})", + struct_size, + OSVERSIONINFOA_SIZE, + OSVERSIONINFOEXA_SIZE + ); emu.regs_mut().rax = 0; return; } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_w.rs index 3213686e..e39a01f7 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_version_ex_w.rs @@ -1,17 +1,12 @@ - use crate::{emu, structures}; pub fn GetVersionExW(emu: &mut emu::Emu) { let version_info_ptr = emu.regs().rcx; - log_red!( - emu, - "kernel32!GetVersionExW 0x{:x}", - version_info_ptr - ); + log_red!(emu, "kernel32!GetVersionExW 0x{:x}", version_info_ptr); let os_version_info = structures::OsVersionInfoExW::new(); os_version_info.save(version_info_ptr, &mut emu.maps); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_a.rs index 0255b7c5..6db2c3e4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_a.rs @@ -1,10 +1,11 @@ - use crate::{constants, emu}; pub fn GetWindowsDirectoryA(emu: &mut emu::Emu) { let lp_buffer = emu.regs().rcx as usize; let u_size = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!GetWindowsDirectoryA lp_buffer: 0x{:x} u_size: {}", + log_red!( + emu, + "** {} kernel32!GetWindowsDirectoryA lp_buffer: 0x{:x} u_size: {}", emu.pos, lp_buffer, u_size @@ -12,4 +13,4 @@ pub fn GetWindowsDirectoryA(emu: &mut emu::Emu) { let output = constants::WINDOWS_DIRECTORY; emu.maps.write_string(lp_buffer as u64, output); emu.regs_mut().rax = output.len() as u64; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_w.rs index a4938b98..fbc6ffc5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/get_windows_directory_w.rs @@ -1,19 +1,20 @@ - use crate::{constants, emu}; pub fn GetWindowsDirectoryW(emu: &mut emu::Emu) { let lp_buffer = emu.regs().rcx; let u_size = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!GetWindowsDirectoryW lp_buffer: 0x{:x} u_size: {}", + log_red!( + emu, + "** {} kernel32!GetWindowsDirectoryW lp_buffer: 0x{:x} u_size: {}", emu.pos, lp_buffer, u_size ); let output = constants::WINDOWS_DIRECTORY; - if emu.maps.is_mapped(lp_buffer) && u_size > output.len()*2+2 { + if emu.maps.is_mapped(lp_buffer) && u_size > output.len() * 2 + 2 { emu.maps.write_wide_string(lp_buffer, output); emu.regs_mut().rax = output.len() as u64 * 2; } else { emu.regs_mut().rax = 0; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/global_add_atom_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/global_add_atom_a.rs index c19cac6f..128f5ce9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/global_add_atom_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/global_add_atom_a.rs @@ -1,12 +1,13 @@ - use crate::emu; pub fn GlobalAddAtomA(emu: &mut emu::Emu) { let lp_string = emu.regs().rcx as usize; - log_red!(emu, "** {} kernel32!GlobalAddAtomA lp_string: 0x{:x}", + log_red!( + emu, + "** {} kernel32!GlobalAddAtomA lp_string: 0x{:x}", emu.pos, lp_string ); // TODO: not sure what to do emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_alloc.rs index 3d9ddab5..ee446621 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_alloc.rs @@ -1,5 +1,5 @@ - use crate::emu; +use crate::maps::mem64::Permission; pub fn HeapAlloc(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; @@ -13,6 +13,7 @@ pub fn HeapAlloc(emu: &mut emu::Emu) { format!("alloc_{:x}", emu.regs().rax).as_str(), emu.regs().rax, size, + Permission::READ_WRITE, ) .expect("kernel32!HeapAlloc out of memory"); @@ -24,4 +25,4 @@ pub fn HeapAlloc(emu: &mut emu::Emu) { size, emu.regs().rax ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_create.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_create.rs index 3aa10e3c..4b84bf46 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_create.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_create.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -7,12 +6,8 @@ pub fn HeapCreate(emu: &mut emu::Emu) { let initSZ = emu.regs().rdx; let maxSZ = emu.regs().r8; - log_red!( - emu, - "kernel32!HeapCreate maxSZ:{}", - maxSZ - ); + log_red!(emu, "kernel32!HeapCreate maxSZ:{}", maxSZ); let uri = format!("HeapCreate://{}", maxSZ); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_free.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_free.rs index ce8cff43..957e136e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_free.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_free.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn HeapFree(emu: &mut emu::Emu) { @@ -6,11 +5,7 @@ pub fn HeapFree(emu: &mut emu::Emu) { let flags = emu.regs().rdx; let mem = emu.regs().r8; - log_red!( - emu, - "kernel32!HeapFree mem: 0x{:x}", - mem - ); + log_red!(emu, "kernel32!HeapFree mem: 0x{:x}", mem); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_re_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_re_alloc.rs index d7c65bb6..18ee747f 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/heap_re_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/heap_re_alloc.rs @@ -1,4 +1,4 @@ - +use crate::maps::mem64::Permission; use crate::{constants, emu}; pub fn HeapReAlloc(emu: &mut emu::Emu) { @@ -30,6 +30,7 @@ pub fn HeapReAlloc(emu: &mut emu::Emu) { format!("alloc_{:x}", new_addr).as_str(), new_addr, new_size, + Permission::READ_WRITE, ) { emu.regs_mut().rax = 0; return; @@ -38,8 +39,7 @@ pub fn HeapReAlloc(emu: &mut emu::Emu) { // Copy old content to new location if HEAP_REALLOC_IN_PLACE_ONLY is not set if (flags & constants::HEAP_REALLOC_IN_PLACE_ONLY) == 0 { // Get the size of the old allocation to know how much to copy - let old_size = emu.maps.get_mem_size(old_mem) - .unwrap_or(new_size as usize); + let old_size = emu.maps.get_mem_size(old_mem).unwrap_or(new_size as usize); let copy_size = std::cmp::min(old_size, new_size as usize); // Copy the data @@ -66,4 +66,4 @@ pub fn HeapReAlloc(emu: &mut emu::Emu) { emu.regs_mut().rax = 0; } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/init_once_begin_initialize.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/init_once_begin_initialize.rs index 9a9a421f..b3f9dcbc 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/init_once_begin_initialize.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/init_once_begin_initialize.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn InitOnceBeginInitialize(emu: &mut emu::Emu) { @@ -6,7 +5,15 @@ pub fn InitOnceBeginInitialize(emu: &mut emu::Emu) { let dw_flags = emu.regs().rdx as usize; let f_pending = emu.regs().r8 as usize; let lp_context = emu.regs().r9 as usize; - log_red!(emu, "** {} kernel32!InitOnceBeginInitialize {:x} {:x} {:x} {:x}", emu.pos, lp_init_once, dw_flags, f_pending, lp_context); + log_red!( + emu, + "** {} kernel32!InitOnceBeginInitialize {:x} {:x} {:x} {:x}", + emu.pos, + lp_init_once, + dw_flags, + f_pending, + lp_context + ); // TODO: implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section.rs index 44ef9030..cb70bc25 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn InitializeCriticalSection(emu: &mut emu::Emu) { @@ -11,4 +10,4 @@ pub fn InitializeCriticalSection(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_and_spin_count.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_and_spin_count.rs index 262e880d..bd33fd0d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_and_spin_count.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_and_spin_count.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn InitializeCriticalSectionAndSpinCount(emu: &mut emu::Emu) { @@ -13,4 +12,4 @@ pub fn InitializeCriticalSectionAndSpinCount(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_ex.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_ex.rs index 614fe87e..8f273f1c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_ex.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/initialize_critical_section_ex.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn InitializeCriticalSectionEx(emu: &mut emu::Emu) { @@ -13,4 +12,4 @@ pub fn InitializeCriticalSectionEx(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/is_bad_read_ptr.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/is_bad_read_ptr.rs index 3af5af4b..13fd2dc0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/is_bad_read_ptr.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/is_bad_read_ptr.rs @@ -1,10 +1,15 @@ - use crate::emu; pub fn IsBadReadPtr(emu: &mut emu::Emu) { let lp = emu.regs().rcx as usize; let ucb = emu.regs().rdx as usize; - log_red!(emu, "** {} kernel32!IsBadReadPtr {:x} {:x}", emu.pos, lp, ucb); + log_red!( + emu, + "** {} kernel32!IsBadReadPtr {:x} {:x}", + emu.pos, + lp, + ucb + ); // TODO: implement this emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/is_debugger_present.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/is_debugger_present.rs index 19dfd8bd..2bb5cf11 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/is_debugger_present.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/is_debugger_present.rs @@ -1,10 +1,6 @@ - use crate::emu; pub fn IsDebuggerPresent(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!IsDebuggerPresent" - ); + log_red!(emu, "kernel32!IsDebuggerPresent"); emu.regs_mut().rax = 0; // of course :p -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/is_processor_feature_present.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/is_processor_feature_present.rs index b5599fb1..6dbc8fd9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/is_processor_feature_present.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/is_processor_feature_present.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn IsProcessorFeaturePresent(emu: &mut emu::Emu) { @@ -55,4 +54,4 @@ pub fn IsProcessorFeaturePresent(emu: &mut emu::Emu) { msg ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/leave_critical_section.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/leave_critical_section.rs index bd5f6d9a..9cc50322 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/leave_critical_section.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/leave_critical_section.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -28,4 +27,4 @@ pub fn LeaveCriticalSection(emu: &mut emu::Emu) { // Small delay to simulate atomic operation overhead helper::advance_tick(emu, 1); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_a.rs index c8ce1656..209a8955 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_a.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::load_library; @@ -8,5 +7,12 @@ pub fn LoadLibraryA(emu: &mut emu::Emu) { emu.regs_mut().rax = load_library(emu, &dll); - log_red!(emu, "** {} kernel32!LoadLibraryA '{}' =0x{:x} rip: 0x{:x}", emu.pos, &dll, emu.regs().get_eax() as u32, emu.regs().rip); -} \ No newline at end of file + log_red!( + emu, + "** {} kernel32!LoadLibraryA '{}' =0x{:x} rip: 0x{:x}", + emu.pos, + &dll, + emu.regs().get_eax() as u32, + emu.regs().rip + ); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_a.rs index fe154cac..642ebf0e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_a.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::load_library; @@ -14,4 +13,4 @@ pub fn LoadLibraryExA(emu: &mut emu::Emu) { dll, emu.regs().rax ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_w.rs index 8957ed04..bfc3eb2d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_ex_w.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::load_library; @@ -14,4 +13,4 @@ pub fn LoadLibraryExW(emu: &mut emu::Emu) { dll, emu.regs().rax ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_w.rs index 8f9d0130..a36edd7f 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/load_library_w.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::load_library; @@ -8,5 +7,12 @@ pub fn LoadLibraryW(emu: &mut emu::Emu) { emu.regs_mut().rax = load_library(emu, &dll); - log_red!(emu, "** {} kernel32!LoadLibraryW '{}' =0x{:x} rip: 0x{:x}", emu.pos, &dll, emu.regs().get_eax() as u32, emu.regs().rip); -} \ No newline at end of file + log_red!( + emu, + "** {} kernel32!LoadLibraryW '{}' =0x{:x} rip: 0x{:x}", + emu.pos, + &dll, + emu.regs().get_eax() as u32, + emu.regs().rip + ); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/load_resource.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/load_resource.rs index daa9daa6..61b4f970 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/load_resource.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/load_resource.rs @@ -1,11 +1,16 @@ - use crate::emu; pub fn LoadResource(emu: &mut emu::Emu) { let hModule = emu.regs().rcx; let hResInfo = emu.regs().rdx as u64; - log_red!(emu, "** {} kernel32!LoadResource {:x} {:x}", emu.pos, hModule, hResInfo); + log_red!( + emu, + "** {} kernel32!LoadResource {:x} {:x}", + emu.pos, + hModule, + hResInfo + ); emu.regs_mut().rax = hResInfo; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/local_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/local_alloc.rs index 0fe4a5ed..9c262f64 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/local_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/local_alloc.rs @@ -1,24 +1,24 @@ - use crate::emu; +use crate::maps::mem64::Permission; pub fn LocalAlloc(emu: &mut emu::Emu) { let flags = emu.regs().rcx; let bytes = emu.regs().rdx; - log_red!( - emu, - "kernel32!LocalAlloc flags: {:x} sz: {}", - flags, - bytes - ); + log_red!(emu, "kernel32!LocalAlloc flags: {:x} sz: {}", flags, bytes); let base = emu .maps .alloc(bytes) .expect("kernel32!LocalAlloc out of memory"); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, bytes) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + bytes, + Permission::READ_WRITE, + ) .expect("kernel32!LocalAlloc out of memory"); emu.regs_mut().rax = base; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lock_resource.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lock_resource.rs index 4dbfdde2..930bb738 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lock_resource.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lock_resource.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -9,12 +8,23 @@ pub fn LockResource(emu: &mut emu::Emu) { let uri = helper::handler_get_uri(hResData); let ptr = uri.split("_").next().unwrap().parse::().unwrap() + emu.base as u64; - log_red!(emu, "** {} kernel32!LockResource {:x} {:x}", emu.pos, hResData, ptr); + log_red!( + emu, + "** {} kernel32!LockResource {:x} {:x}", + emu.pos, + hResData, + ptr + ); emu.regs_mut().rax = ptr; return; } - log_red!(emu, "** {} kernel32!LockResource {:x} not found", emu.pos, hResData); + log_red!( + emu, + "** {} kernel32!LockResource {:x} not found", + emu.pos, + hResData + ); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_a.rs index 7b00f26e..1522c3b1 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrcatA(emu: &mut emu::Emu) { @@ -8,15 +7,10 @@ pub fn lstrcatA(emu: &mut emu::Emu) { let mut str1 = emu.maps.read_string(str1_ptr); let str2 = emu.maps.read_string(str2_ptr); - log_red!( - emu, - "kernel32!lstrcatA '{}'+'{}'", - str1, - str2 - ); + log_red!(emu, "kernel32!lstrcatA '{}'+'{}'", str1, str2); str1.push_str(&str2); emu.maps.write_string(str1_ptr, &str1); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_w.rs index c58839b0..660e8b3d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcat_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrcatW(emu: &mut emu::Emu) { @@ -8,15 +7,10 @@ pub fn lstrcatW(emu: &mut emu::Emu) { let mut str1 = emu.maps.read_wide_string(str1_ptr); let str2 = emu.maps.read_wide_string(str2_ptr); - log_red!( - emu, - "kernel32!lstrcatW '{}'+'{}'", - str1, - str2 - ); + log_red!(emu, "kernel32!lstrcatW '{}'+'{}'", str1, str2); str1.push_str(&str2); emu.maps.write_wide_string(str1_ptr, &str1); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi.rs index 76585261..3e0b9249 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn LStrCmpI(emu: &mut emu::Emu) { @@ -10,36 +9,21 @@ pub fn LStrCmpI(emu: &mut emu::Emu) { let s1_lower = s1.to_lowercase(); let s2_lower = s2.to_lowercase(); - + let result = match s1_lower.cmp(&s2_lower) { std::cmp::Ordering::Less => { - log_red!( - emu, - "kernel32!lstrcmpi `{}` < `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpi `{}` < `{}`", s1, s2); -1i64 as u64 } std::cmp::Ordering::Equal => { - log_red!( - emu, - "kernel32!lstrcmpi `{}` == `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpi `{}` == `{}`", s1, s2); 0 } std::cmp::Ordering::Greater => { - log_red!( - emu, - "kernel32!lstrcmpi `{}` > `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpi `{}` > `{}`", s1, s2); 1 } }; - + emu.regs_mut().rax = result; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi_w.rs index 441c5171..c3c6ee69 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcmpi_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn LStrCmpIW(emu: &mut emu::Emu) { @@ -10,36 +9,21 @@ pub fn LStrCmpIW(emu: &mut emu::Emu) { let s1_lower = s1.to_lowercase(); let s2_lower = s2.to_lowercase(); - + let result = match s1_lower.cmp(&s2_lower) { std::cmp::Ordering::Less => { - log_red!( - emu, - "kernel32!lstrcmpiW `{}` < `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpiW `{}` < `{}`", s1, s2); -1i64 as u64 } std::cmp::Ordering::Equal => { - log_red!( - emu, - "kernel32!lstrcmpiW `{}` == `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpiW `{}` == `{}`", s1, s2); 0 } std::cmp::Ordering::Greater => { - log_red!( - emu, - "kernel32!lstrcmpiW `{}` > `{}`", - s1, - s2 - ); + log_red!(emu, "kernel32!lstrcmpiW `{}` > `{}`", s1, s2); 1 } }; - + emu.regs_mut().rax = result; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy.rs index caea58bb..326f2b7c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrcpy(emu: &mut emu::Emu) { @@ -9,17 +8,11 @@ pub fn lstrcpy(emu: &mut emu::Emu) { emu.maps.write_string(dst, &s); emu.maps.write_byte(dst + (s.len() as u64), 0); - log_red!( - emu, - "kernel32!lstrcpy 0x{:x} 0x{:x} {}", - dst, - src, - &s - ); + log_red!(emu, "kernel32!lstrcpy 0x{:x} 0x{:x} {}", dst, src, &s); if s.is_empty() { emu.regs_mut().rax = 0; } else { emu.regs_mut().rax = dst; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy_w.rs index c801ad0d..7be777cf 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpy_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrcpyW(emu: &mut emu::Emu) { @@ -9,17 +8,11 @@ pub fn lstrcpyW(emu: &mut emu::Emu) { emu.maps.write_wide_string(dst, &s); emu.maps.write_byte(dst + (s.len() as u64 * 2), 0); - log_red!( - emu, - "kernel32!lstrcpyW 0x{:x} 0x{:x} {}", - dst, - src, - &s - ); + log_red!(emu, "kernel32!lstrcpyW 0x{:x} 0x{:x} {}", dst, src, &s); if s.is_empty() { emu.regs_mut().rax = 0; } else { emu.regs_mut().rax = dst; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpyn.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpyn.rs index 414f6418..33199796 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpyn.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrcpyn.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrcpyn(emu: &mut emu::Emu) { @@ -13,11 +12,7 @@ pub fn lstrcpyn(emu: &mut emu::Emu) { emu.maps.memset(out_str1, 0, len); emu.maps.write_string(out_str1, &s); - log_red!( - emu, - "kernel32!lstrcpyn {}", - s - ); + log_red!(emu, "kernel32!lstrcpyn {}", s); emu.regs_mut().rax = out_str1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_a.rs index dbf8d67a..ad690a73 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrlenA(emu: &mut emu::Emu) { @@ -7,12 +6,7 @@ pub fn lstrlenA(emu: &mut emu::Emu) { let s = emu.maps.read_string(s_ptr); let len = s.len() as u64; - log_red!( - emu, - "kernel32!lstrlen '{}' ={}", - s, - len - ); + log_red!(emu, "kernel32!lstrlen '{}' ={}", s, len); emu.regs_mut().rax = len; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_w.rs index 88747414..d261f6e6 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/lstrlen_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn lstrlenW(emu: &mut emu::Emu) { @@ -7,12 +6,7 @@ pub fn lstrlenW(emu: &mut emu::Emu) { let s = emu.maps.read_wide_string(s_ptr); let len = s.len() as u64; - log_red!( - emu, - "kernel32!lstrlen '{}' ={}", - s, - len - ); + log_red!(emu, "kernel32!lstrlen '{}' ={}", s, len); emu.regs_mut().rax = len * 2; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/map_view_of_file.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/map_view_of_file.rs index aa5fc91f..83dc6536 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/map_view_of_file.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/map_view_of_file.rs @@ -1,5 +1,5 @@ - use crate::emu; +use crate::maps::mem64::Permission; pub fn MapViewOfFile(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; @@ -23,7 +23,7 @@ pub fn MapViewOfFile(emu: &mut emu::Emu) { .expect("kernel32!MapViewOfFile cannot allocate"); let mem = emu .maps - .create_map("file_map", addr, size) + .create_map("file_map", addr, size, Permission::READ_WRITE) .expect("kernel32!MapViewOfFile cannot create map"); let loaded = mem.load_chunk(&emu.filename, off, size as usize); @@ -41,4 +41,4 @@ pub fn MapViewOfFile(emu: &mut emu::Emu) { } emu.regs_mut().rax = addr; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/mod.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/mod.rs index 24e0c408..dbfe0219 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/mod.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/mod.rs @@ -1,5 +1,5 @@ -use std::sync::Mutex; use lazy_static::lazy_static; +use std::sync::Mutex; use crate::constants; use crate::emu; @@ -37,6 +37,7 @@ pub mod exit_process; pub mod expand_environment_strings_a; pub mod expand_environment_strings_w; pub mod file_time_to_system_time; +pub mod find_act_ctx_section_string_w; pub mod find_close; pub mod find_first_file_a; pub mod find_first_file_ex_w; @@ -45,13 +46,11 @@ pub mod find_next_file_a; pub mod find_next_file_w; pub mod find_resource_a; pub mod find_resource_w; -pub mod find_act_ctx_section_string_w; pub mod fls_alloc; pub mod fls_get_value; pub mod fls_set_value; pub mod free_resource; pub mod get_acp; -pub mod get_cp_info; pub mod get_command_line_a; pub mod get_command_line_w; pub mod get_computer_name_a; @@ -59,12 +58,13 @@ pub mod get_computer_name_w; pub mod get_console_cp; pub mod get_console_mode; pub mod get_console_output_cp; +pub mod get_cp_info; pub mod get_current_directory_a; pub mod get_current_directory_w; -pub mod get_current_process_id; pub mod get_current_process; -pub mod get_current_thread_id; +pub mod get_current_process_id; pub mod get_current_thread; +pub mod get_current_thread_id; pub mod get_environment_strings_w; pub mod get_environment_variable_w; pub mod get_file_attributes_a; @@ -92,17 +92,17 @@ pub mod get_system_directory_a; pub mod get_system_directory_w; pub mod get_system_firmware_table; pub mod get_system_info; -pub mod get_system_time_as_file_time; pub mod get_system_time; +pub mod get_system_time_as_file_time; pub mod get_temp_path_w; pub mod get_thread_context; pub mod get_thread_locale; pub mod get_tick_count; -pub mod get_user_default_lcid; pub mod get_user_default_lang_id; +pub mod get_user_default_lcid; +pub mod get_version; pub mod get_version_ex_a; pub mod get_version_ex_w; -pub mod get_version; pub mod get_windows_directory_a; pub mod get_windows_directory_w; pub mod global_add_atom_a; @@ -111,14 +111,12 @@ pub mod heap_create; pub mod heap_free; pub mod heap_re_alloc; pub mod init_once_begin_initialize; +pub mod initialize_critical_section; pub mod initialize_critical_section_and_spin_count; pub mod initialize_critical_section_ex; -pub mod initialize_critical_section; pub mod is_bad_read_ptr; pub mod is_debugger_present; pub mod is_processor_feature_present; -pub mod lstrcmpi_w; -pub mod lstrcmpi; pub mod leave_critical_section; pub mod load_library_a; pub mod load_library_ex_a; @@ -129,8 +127,10 @@ pub mod local_alloc; pub mod lock_resource; pub mod lstrcat_a; pub mod lstrcat_w; -pub mod lstrcpy_w; +pub mod lstrcmpi; +pub mod lstrcmpi_w; pub mod lstrcpy; +pub mod lstrcpy_w; pub mod lstrcpyn; pub mod lstrlen_a; pub mod lstrlen_w; @@ -165,13 +165,13 @@ pub mod tls_free; pub mod tls_get_value; pub mod tls_set_value; pub mod unhandled_exception_filter; -pub mod virtual_alloc_ex_numa; -pub mod virtual_alloc_ex; pub mod virtual_alloc; +pub mod virtual_alloc_ex; +pub mod virtual_alloc_ex_numa; pub mod virtual_free; pub mod virtual_lock; -pub mod virtual_protect_ex; pub mod virtual_protect; +pub mod virtual_protect_ex; pub mod wait_for_single_object; pub mod wide_char_to_multi_byte; pub mod win_exec; @@ -211,6 +211,7 @@ pub use exit_process::ExitProcess; pub use expand_environment_strings_a::ExpandEnvironmentStringsA; pub use expand_environment_strings_w::ExpandEnvironmentStringsW; pub use file_time_to_system_time::FileTimeToSystemTime; +pub use find_act_ctx_section_string_w::FindActCtxSectionStringW; pub use find_close::FindClose; pub use find_first_file_a::FindFirstFileA; pub use find_first_file_ex_w::FindFirstFileExW; @@ -219,13 +220,11 @@ pub use find_next_file_a::FindNextFileA; pub use find_next_file_w::FindNextFileW; pub use find_resource_a::FindResourceA; pub use find_resource_w::FindResourceW; -pub use find_act_ctx_section_string_w::FindActCtxSectionStringW; pub use fls_alloc::FlsAlloc; pub use fls_get_value::FlsGetValue; pub use fls_set_value::FlsSetValue; pub use free_resource::FreeResource; pub use get_acp::GetACP; -pub use get_cp_info::GetCPInfo; pub use get_command_line_a::GetCommandLineA; pub use get_command_line_w::GetCommandLineW; pub use get_computer_name_a::GetComputerNameA; @@ -233,12 +232,13 @@ pub use get_computer_name_w::GetComputerNameW; pub use get_console_cp::GetConsoleCP; pub use get_console_mode::GetConsoleMode; pub use get_console_output_cp::GetConsoleOutputCP; +pub use get_cp_info::GetCPInfo; pub use get_current_directory_a::GetCurrentDirectoryA; pub use get_current_directory_w::GetCurrentDirectoryW; -pub use get_current_process_id::GetCurrentProcessId; pub use get_current_process::GetCurrentProcess; -pub use get_current_thread_id::GetCurrentThreadId; +pub use get_current_process_id::GetCurrentProcessId; pub use get_current_thread::GetCurrentThread; +pub use get_current_thread_id::GetCurrentThreadId; pub use get_environment_strings_w::GetEnvironmentStringsW; pub use get_environment_variable_w::GetEnvironmentVariableW; pub use get_file_attributes_a::GetFileAttributesA; @@ -266,17 +266,17 @@ pub use get_system_directory_a::GetSystemDirectoryA; pub use get_system_directory_w::GetSystemDirectoryW; pub use get_system_firmware_table::GetSystemFirmwareTable; pub use get_system_info::GetSystemInfo; -pub use get_system_time_as_file_time::GetSystemTimeAsFileTime; pub use get_system_time::GetSystemTime; +pub use get_system_time_as_file_time::GetSystemTimeAsFileTime; pub use get_temp_path_w::GetTempPathW; pub use get_thread_context::GetThreadContext; pub use get_thread_locale::GetThreadLocale; pub use get_tick_count::GetTickCount; -pub use get_user_default_lcid::GetUserDefaultLCID; pub use get_user_default_lang_id::GetUserDefaultLangId; +pub use get_user_default_lcid::GetUserDefaultLCID; +pub use get_version::GetVersion; pub use get_version_ex_a::GetVersionExA; pub use get_version_ex_w::GetVersionExW; -pub use get_version::GetVersion; pub use get_windows_directory_a::GetWindowsDirectoryA; pub use get_windows_directory_w::GetWindowsDirectoryW; pub use global_add_atom_a::GlobalAddAtomA; @@ -285,14 +285,12 @@ pub use heap_create::HeapCreate; pub use heap_free::HeapFree; pub use heap_re_alloc::HeapReAlloc; pub use init_once_begin_initialize::InitOnceBeginInitialize; +pub use initialize_critical_section::InitializeCriticalSection; pub use initialize_critical_section_and_spin_count::InitializeCriticalSectionAndSpinCount; pub use initialize_critical_section_ex::InitializeCriticalSectionEx; -pub use initialize_critical_section::InitializeCriticalSection; pub use is_bad_read_ptr::IsBadReadPtr; pub use is_debugger_present::IsDebuggerPresent; pub use is_processor_feature_present::IsProcessorFeaturePresent; -pub use lstrcmpi_w::LStrCmpIW; -pub use lstrcmpi::LStrCmpI; pub use leave_critical_section::LeaveCriticalSection; pub use load_library_a::LoadLibraryA; pub use load_library_ex_a::LoadLibraryExA; @@ -303,8 +301,10 @@ pub use local_alloc::LocalAlloc; pub use lock_resource::LockResource; pub use lstrcat_a::lstrcatA; pub use lstrcat_w::lstrcatW; -pub use lstrcpy_w::lstrcpyW; +pub use lstrcmpi::LStrCmpI; +pub use lstrcmpi_w::LStrCmpIW; pub use lstrcpy::lstrcpy; +pub use lstrcpy_w::lstrcpyW; pub use lstrcpyn::lstrcpyn; pub use lstrlen_a::lstrlenA; pub use lstrlen_w::lstrlenW; @@ -339,13 +339,13 @@ pub use tls_free::TlsFree; pub use tls_get_value::TlsGetValue; pub use tls_set_value::TlsSetValue; pub use unhandled_exception_filter::UnhandledExceptionFilter; -pub use virtual_alloc_ex_numa::VirtualAllocExNuma; -pub use virtual_alloc_ex::VirtualAllocEx; pub use virtual_alloc::VirtualAlloc; +pub use virtual_alloc_ex::VirtualAllocEx; +pub use virtual_alloc_ex_numa::VirtualAllocExNuma; pub use virtual_free::VirtualFree; pub use virtual_lock::VirtualLock; -pub use virtual_protect_ex::VirtualProtectEx; pub use virtual_protect::VirtualProtect; +pub use virtual_protect_ex::VirtualProtectEx; pub use wait_for_single_object::WaitForSingleObject; pub use wide_char_to_multi_byte::WideCharToMultiByte; pub use win_exec::WinExec; @@ -539,12 +539,20 @@ pub fn gateway(addr: u64, emu: &mut emu::Emu) -> String { _ => { if emu.cfg.skip_unimplemented == false { if emu.cfg.dump_on_exit && emu.cfg.dump_filename.is_some() { - serialization::Serialization::dump_to_file(&emu, emu.cfg.dump_filename.as_ref().unwrap()); + serialization::Serialization::dump_to_file( + &emu, + emu.cfg.dump_filename.as_ref().unwrap(), + ); } unimplemented!("atemmpt to call unimplemented API 0x{:x} {}", addr, api); } - log::warn!("calling unimplemented API 0x{:x} {} at 0x{:x}", addr, api, emu.regs().rip); + log::warn!( + "calling unimplemented API 0x{:x} {} at 0x{:x}", + addr, + api, + emu.regs().rip + ); return api; } } diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_a.rs index f2f98814..a504cb12 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_a.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn MoveFileA(emu: &mut emu::Emu) { @@ -8,11 +7,6 @@ pub fn MoveFileA(emu: &mut emu::Emu) { let src = emu.maps.read_string(src_ptr); let dst = emu.maps.read_string(dst_ptr); - log_red!( - emu, - "kernel32!MoveFileA `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!MoveFileA `{}` to `{}`", src, dst); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_w.rs index a0349ffc..5f2d5ebb 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/move_file_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn MoveFileW(emu: &mut emu::Emu) { @@ -8,11 +7,6 @@ pub fn MoveFileW(emu: &mut emu::Emu) { let src = emu.maps.read_wide_string(src_ptr); let dst = emu.maps.read_wide_string(dst_ptr); - log_red!( - emu, - "kernel32!MoveFileW `{}` to `{}`", - src, - dst - ); + log_red!(emu, "kernel32!MoveFileW `{}` to `{}`", src, dst); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/multi_byte_to_wide_char.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/multi_byte_to_wide_char.rs index 863e2d84..bb9e472c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/multi_byte_to_wide_char.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/multi_byte_to_wide_char.rs @@ -1,4 +1,3 @@ - use crate::winapi::winapi64::kernel32::LAST_ERROR; use crate::{constants, emu}; @@ -11,10 +10,10 @@ pub fn MultiByteToWideChar(emu: &mut emu::Emu) { .maps .read_qword(emu.regs().rsp + 0x20) .expect("kernel32!MultiByteToWideChar cannot read wide_ptr"); - let cch_wide_char = emu - .maps - .read_dword(emu.regs().rsp + 0x28) // yes, read only half of the stack item - .expect("kernel32!MultiByteToWideChar cannot read cchWideChar") as i32; + let cch_wide_char = + emu.maps + .read_dword(emu.regs().rsp + 0x28) // yes, read only half of the stack item + .expect("kernel32!MultiByteToWideChar cannot read cchWideChar") as i32; let mut utf8: String = String::new(); @@ -28,9 +27,7 @@ pub fn MultiByteToWideChar(emu: &mut emu::Emu) { // validation 2: output NO NULL but cch == 0 if wide_ptr != 0 && cch_wide_char == 0 { - log::warn!( - "[ALERT] MultiByteToWideChar: output buffer is non-NULL but cch_wide_char = 0" - ); + log::warn!("[ALERT] MultiByteToWideChar: output buffer is non-NULL but cch_wide_char = 0"); } // validation 3: size too big @@ -70,12 +67,12 @@ pub fn MultiByteToWideChar(emu: &mut emu::Emu) { // LOG THE INPUT STRING if utf8_ptr > 0 && !utf8.is_empty() { log_red!( - emu, - "Input UTF-8 string: \"{}\" (length: {} bytes)", - utf8.escape_debug(), - // This will show escape sequences for non-printable chars + emu, + "Input UTF-8 string: \"{}\" (length: {} bytes)", + utf8.escape_debug(), + // This will show escape sequences for non-printable chars cb_multi_byte - ); + ); } // Convert to UTF-16 (without null terminator since cb_multi_byte is explicit) @@ -101,4 +98,4 @@ pub fn MultiByteToWideChar(emu: &mut emu::Emu) { *err = constants::ERROR_INVALID_PARAMETER; emu.regs_mut().rax = 0; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/open_process.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/open_process.rs index 54ad6d66..9a86b9c8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/open_process.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/open_process.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -7,12 +6,8 @@ pub fn OpenProcess(emu: &mut emu::Emu) { let inherit = emu.regs().rdx; let pid = emu.regs().r8; - log_red!( - emu, - "kernel32!OpenProcess pid: {}", - pid - ); + log_red!(emu, "kernel32!OpenProcess pid: {}", pid); let uri = format!("pid://{}", pid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/open_thread.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/open_thread.rs index d009b329..aae95c01 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/open_thread.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/open_thread.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -7,12 +6,8 @@ pub fn OpenThread(emu: &mut emu::Emu) { let inherit = emu.regs().rdx; let tid = emu.regs().r8; - log_red!( - emu, - "kernel32!OpenThread tid: {}", - tid - ); + log_red!(emu, "kernel32!OpenThread tid: {}", tid); let uri = format!("tid://{}", tid); emu.regs_mut().rax = helper::handler_create(&uri); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/process32_first.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/process32_first.rs index 09d64c68..30bd40b4 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/process32_first.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/process32_first.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -37,4 +36,4 @@ pub fn Process32First(emu: &mut emu::Emu) { */ emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/process32_next.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/process32_next.rs index e81b3074..2d8ba947 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/process32_next.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/process32_next.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -21,4 +20,4 @@ pub fn Process32Next(emu: &mut emu::Emu) { } emu.regs_mut().rax = 0; // trigger exit loop -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/query_performance_counter.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/query_performance_counter.rs index 815aa21f..b58c20ec 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/query_performance_counter.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/query_performance_counter.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn QueryPerformanceCounter(emu: &mut emu::Emu) { @@ -6,7 +5,7 @@ pub fn QueryPerformanceCounter(emu: &mut emu::Emu) { // Use emu.tick directly, maybe scaled up to simulate higher frequency let counter_value = (emu.tick as u64) * 1000; // Scale to simulate ~1MHz frequency - + emu.maps.write_qword(counter_ptr, counter_value); log_red!( @@ -16,4 +15,4 @@ pub fn QueryPerformanceCounter(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; // Return TRUE -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/read_file.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/read_file.rs index 6624a0c1..737bda14 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/read_file.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/read_file.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -27,7 +26,12 @@ pub fn ReadFile(emu: &mut emu::Emu) { } let name = helper::handler_get_uri(file_hndl); - log_red!(emu, "** {} kernel32!ReadFile name = {name} {}", emu.pos, emu.colors.nc); + log_red!( + emu, + "** {} kernel32!ReadFile name = {name} {}", + emu.pos, + emu.colors.nc + ); if name == "HaspEmul.dll" { let bytes = std::fs::read("/Users/jesus/Downloads/enigma/surprise.dll").unwrap(); @@ -42,4 +46,4 @@ pub fn ReadFile(emu: &mut emu::Emu) { } else { panic!("unknown file"); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/read_process_memory.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/read_process_memory.rs index abd08ef9..fe4604af 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/read_process_memory.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/read_process_memory.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn ReadProcessMemory(emu: &mut emu::Emu) { @@ -24,4 +23,4 @@ pub fn ReadProcessMemory(emu: &mut emu::Emu) { emu.maps.memset(buff, 0x90, size as usize); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/reset_event.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/reset_event.rs index 062721ef..dbf7bdc0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/reset_event.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/reset_event.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn ResetEvent(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!ResetEvent" - ); + log_red!(emu, "kernel32!ResetEvent"); // TODO: do something emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/resume_thread.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/resume_thread.rs index 3d58683b..81847351 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/resume_thread.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/resume_thread.rs @@ -1,15 +1,10 @@ - use crate::emu; use crate::winapi::helper; pub fn ResumeThread(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; - log_red!( - emu, - "kernel32!ResumeThread hndl: 0x{:x}", - hndl - ); + log_red!(emu, "kernel32!ResumeThread hndl: 0x{:x}", hndl); // Get the URI from the handle to extract thread ID let uri = helper::handler_get_uri(hndl); @@ -36,14 +31,14 @@ pub fn ResumeThread(emu: &mut emu::Emu) { // Find the thread in the threads vector let mut previous_suspend_count = 0; let mut thread_found = false; - + for thread in &mut emu.threads { if thread.id == thread_id { thread_found = true; // Track previous suspend count (Windows tracks multiple suspends) // For now we use a simple boolean, so count is either 0 or 1 previous_suspend_count = if thread.suspended { 1 } else { 0 }; - + // Resume the thread if thread.suspended { thread.suspended = false; @@ -63,5 +58,8 @@ pub fn ResumeThread(emu: &mut emu::Emu) { // Return the previous suspend count emu.regs_mut().rax = previous_suspend_count; - log::info!("ResumeThread returning previous suspend count: {}", previous_suspend_count); -} \ No newline at end of file + log::info!( + "ResumeThread returning previous suspend count: {}", + previous_suspend_count + ); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_current_directory_a.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_current_directory_a.rs index b14e0d3d..90d793e6 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_current_directory_a.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_current_directory_a.rs @@ -1,9 +1,13 @@ - use crate::emu; pub fn SetCurrentDirectoryA(emu: &mut emu::Emu) { let lp_path_name = emu.regs().rcx as usize; - log_red!(emu, "** {} kernel32!SetCurrentDirectoryA lp_path_name: 0x{:x}", emu.pos, lp_path_name); + log_red!( + emu, + "** {} kernel32!SetCurrentDirectoryA lp_path_name: 0x{:x}", + emu.pos, + lp_path_name + ); // TODO: Implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_error_mode.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_error_mode.rs index 71481692..e60df76d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_error_mode.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_error_mode.rs @@ -1,14 +1,9 @@ - use crate::emu; pub fn SetErrorMode(emu: &mut emu::Emu) { let mode = emu.regs().rcx; - log_red!( - emu, - "kernel32!SetErrorMode 0x{:x}", - mode - ); + log_red!(emu, "kernel32!SetErrorMode 0x{:x}", mode); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_last_error.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_last_error.rs index 0e78cbd1..e97109d1 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_last_error.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_last_error.rs @@ -1,14 +1,9 @@ - use crate::emu; use crate::winapi::winapi64::kernel32::set_last_error; pub fn SetLastError(emu: &mut emu::Emu) { let err_code = emu.regs().rcx; - log_red!( - emu, - "kernel32!SetLastError err: {}", - err_code - ); + log_red!(emu, "kernel32!SetLastError err: {}", err_code); set_last_error(err_code); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_locale.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_locale.rs index 86bd0ad9..cb3fc5d0 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_locale.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_locale.rs @@ -1,11 +1,7 @@ - use crate::emu; pub fn SetThreadLocale(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!SetThreadLocale" - ); + log_red!(emu, "kernel32!SetThreadLocale"); // TODO: do something emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_stack_guarantee.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_stack_guarantee.rs index 6116b111..f483260e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_stack_guarantee.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_thread_stack_guarantee.rs @@ -1,9 +1,13 @@ - use crate::emu; pub fn SetThreadStackGuarantee(emu: &mut emu::Emu) { let stack_size_in_bytes = emu.regs().rcx as usize; - log_red!(emu, "** {} kernel32!SetThreadStackGuarantee {:x}", emu.pos, stack_size_in_bytes); + log_red!( + emu, + "** {} kernel32!SetThreadStackGuarantee {:x}", + emu.pos, + stack_size_in_bytes + ); // TODO: implement this emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/set_unhandled_exception_filter.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/set_unhandled_exception_filter.rs index 44090a84..8bbd6c80 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/set_unhandled_exception_filter.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/set_unhandled_exception_filter.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn SetUnhandledExceptionFilter(emu: &mut emu::Emu) { @@ -12,4 +11,4 @@ pub fn SetUnhandledExceptionFilter(emu: &mut emu::Emu) { emu.regs_mut().rax = emu.seh(); emu.set_seh(callback); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/sizeof_resource.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/sizeof_resource.rs index 4b8cb833..033ae8f5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/sizeof_resource.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/sizeof_resource.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; @@ -9,12 +8,24 @@ pub fn SizeofResource(emu: &mut emu::Emu) { if helper::handler_exist(hResInfo) { let uri = helper::handler_get_uri(hResInfo); let size = uri.split("_").last().unwrap().parse::().unwrap(); - log::info!("** {} kernel32!SizeofResource {:x} {:x} size: {}", emu.pos, hModule, hResInfo, size); + log::info!( + "** {} kernel32!SizeofResource {:x} {:x} size: {}", + emu.pos, + hModule, + hResInfo, + size + ); emu.regs_mut().rax = size as u64; return; } - log_red!(emu, "** {} kernel32!SizeofResource {:x} {:x} not found", emu.pos, hModule, hResInfo); + log_red!( + emu, + "** {} kernel32!SizeofResource {:x} {:x} not found", + emu.pos, + hModule, + hResInfo + ); emu.regs_mut().rax = 0; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/sleep.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/sleep.rs index 083bb085..8e92837a 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/sleep.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/sleep.rs @@ -1,23 +1,22 @@ - use crate::emu; use crate::winapi::helper; pub fn Sleep(emu: &mut emu::Emu) { let millis = emu.regs().rcx; - + if millis > 0 { // Set wake tick for this thread let thread_idx = emu.current_thread_id; emu.threads[thread_idx].wake_tick = emu.tick + millis as usize; } - + // Advance global tick helper::advance_tick(emu, millis); - + log_red!( emu, "kernel32!Sleep thread: 0x{:x} millis: {}", emu.current_thread().id, millis ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_file_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_file_time.rs index 45e8f702..f08f38a9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_file_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_file_time.rs @@ -1,4 +1,3 @@ - use crate::{emu, structures}; pub fn SystemTimeToFileTime(emu: &mut emu::Emu) { @@ -8,8 +7,5 @@ pub fn SystemTimeToFileTime(emu: &mut emu::Emu) { let now = structures::SystemTime::now(); now.save(out_ptr, &mut emu.maps); - log_red!( - emu, - "kernel32!SystemTimeToFileTime" - ); -} \ No newline at end of file + log_red!(emu, "kernel32!SystemTimeToFileTime"); +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_tz_specific_local_time.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_tz_specific_local_time.rs index 6273f950..d0dedaa5 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_tz_specific_local_time.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/system_time_to_tz_specific_local_time.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn SystemTimeToTzSpecificLocalTime(emu: &mut emu::Emu) { @@ -6,10 +5,7 @@ pub fn SystemTimeToTzSpecificLocalTime(emu: &mut emu::Emu) { let ut_ptr = emu.regs().rcx; let lt_ptr = emu.regs().r8; - log_red!( - emu, - "kernel32!SystemTimeToTzSpecificLocalTime" - ); + log_red!(emu, "kernel32!SystemTimeToTzSpecificLocalTime"); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/terminate_process.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/terminate_process.rs index 9f6f2b07..b5093c12 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/terminate_process.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/terminate_process.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn TerminateProcess(emu: &mut emu::Emu) { @@ -12,4 +11,4 @@ pub fn TerminateProcess(emu: &mut emu::Emu) { code ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_first.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_first.rs index f97fa27a..cf6c7637 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_first.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_first.rs @@ -1,15 +1,11 @@ - use crate::emu; pub fn Thread32First(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; let entry = emu.regs().rdx; - log_red!( - emu, - "kernel32!Thread32First" - ); + log_red!(emu, "kernel32!Thread32First"); emu.regs_mut().rax = 1; //emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_next.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_next.rs index 4e7af5fe..b4a5c30c 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_next.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/thread32_next.rs @@ -1,14 +1,10 @@ - use crate::{constants, emu}; pub fn Thread32Next(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; let entry = emu.regs().rdx; - log_red!( - emu, - "kernel32!Thread32Next" - ); + log_red!(emu, "kernel32!Thread32Next"); emu.regs_mut().rax = constants::ERROR_NO_MORE_FILES; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_alloc.rs index 6d283de8..ddbe2f73 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_alloc.rs @@ -1,12 +1,8 @@ - use crate::emu; pub fn TlsAlloc(emu: &mut emu::Emu) { - log_red!( - emu, - "kernel32!TlsAlloc" - ); + log_red!(emu, "kernel32!TlsAlloc"); emu.tls64_mut().push(0); - emu.regs_mut().rax = (emu.tls64().len() - 1) as u64; // Return index of newly allocated slot -} \ No newline at end of file + emu.regs_mut().rax = (emu.tls64().len() - 1) as u64; // Return index of newly allocated slot +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_free.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_free.rs index b9adfe51..4926d794 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_free.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_free.rs @@ -1,19 +1,14 @@ - use crate::emu; pub fn TlsFree(emu: &mut emu::Emu) { - let idx = emu.regs().rcx as usize; // First parameter passed in RCX in x64 + let idx = emu.regs().rcx as usize; // First parameter passed in RCX in x64 - log_red!( - emu, - "kernel32!TlsFree idx: {}", - idx - ); + log_red!(emu, "kernel32!TlsFree idx: {}", idx); if idx < emu.tls64().len() { - emu.tls64_mut()[idx] = 0; // Clear the slot - emu.regs_mut().rax = 1; // Return TRUE + emu.tls64_mut()[idx] = 0; // Clear the slot + emu.regs_mut().rax = 1; // Return TRUE } else { - emu.regs_mut().rax = 0; // Return FALSE if invalid index + emu.regs_mut().rax = 0; // Return FALSE if invalid index } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_get_value.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_get_value.rs index 946bb1cb..de5cb701 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_get_value.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_get_value.rs @@ -1,9 +1,8 @@ - -use crate::{constants, emu}; use crate::winapi::winapi64::kernel32::LAST_ERROR; +use crate::{constants, emu}; pub fn TlsGetValue(emu: &mut emu::Emu) { - let idx = emu.regs().rcx as usize; // Parameter passed in RCX in x64 + let idx = emu.regs().rcx as usize; // Parameter passed in RCX in x64 let val = if idx < emu.tls64().len() { // Set last error to SUCCESS when the function succeeds @@ -19,9 +18,11 @@ pub fn TlsGetValue(emu: &mut emu::Emu) { emu.regs_mut().rax = val; - log_red!(emu, "** {} kernel32!TlsGetValue idx: {} =0x{:x}", + log_red!( + emu, + "** {} kernel32!TlsGetValue idx: {} =0x{:x}", emu.pos, idx, val ); -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_set_value.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_set_value.rs index f0d02dc5..3a902407 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/tls_set_value.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/tls_set_value.rs @@ -1,16 +1,10 @@ - use crate::emu; pub fn TlsSetValue(emu: &mut emu::Emu) { - let idx = emu.regs().rcx as usize; // First parameter in RCX - let val = emu.regs().rdx; // Second parameter in RDX + let idx = emu.regs().rcx as usize; // First parameter in RCX + let val = emu.regs().rdx; // Second parameter in RDX - log_red!( - emu, - "kernel32!TlsSetValue idx: {} val: 0x{:x}", - idx, - val - ); + log_red!(emu, "kernel32!TlsSetValue idx: {} val: 0x{:x}", idx, val); if idx < emu.tls64().len() { emu.tls64_mut()[idx] = val; @@ -22,5 +16,5 @@ pub fn TlsSetValue(emu: &mut emu::Emu) { emu.tls64_mut()[idx] = val; } - emu.regs_mut().rax = 1; // Return TRUE -} \ No newline at end of file + emu.regs_mut().rax = 1; // Return TRUE +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/unhandled_exception_filter.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/unhandled_exception_filter.rs index f25da231..faa1eb7b 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/unhandled_exception_filter.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/unhandled_exception_filter.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn UnhandledExceptionFilter(emu: &mut emu::Emu) { @@ -12,4 +11,4 @@ pub fn UnhandledExceptionFilter(emu: &mut emu::Emu) { emu.regs_mut().rax = constants::EXCEPTION_EXECUTE_HANDLER as u64; // a debugger would had answered EXCEPTION_CONTINUE_SEARCH -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc.rs index 98cd5e8a..784a31dc 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc.rs @@ -1,5 +1,17 @@ +use crate::maps::mem64::Permission; use crate::{constants, emu}; +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; + pub fn VirtualAlloc(emu: &mut emu::Emu) { let addr = emu.regs().rcx; let size = emu.regs().rdx; @@ -7,26 +19,40 @@ pub fn VirtualAlloc(emu: &mut emu::Emu) { let prot = emu.regs().r9 as u32; let mem_reserve = (typ & constants::MEM_RESERVE) != 0; let mem_commit = (typ & constants::MEM_COMMIT) != 0; - let mut base:u64 = 0; + let mut base: u64 = 0; + let can_read = (prot + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (prot + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (prot + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; if size == 0 { log_red!( - emu, - "kernel32!VirtualAlloc addr: 0x{:x} sz: {} = 0 flags: {}", - addr, - size, - typ - ); + emu, + "kernel32!VirtualAlloc addr: 0x{:x} sz: {} = 0 flags: {}", + addr, + size, + typ + ); emu.regs_mut().rax = 0 } else { - let is_allocated = emu.maps.is_allocated(addr); let status_already_allocated = mem_commit && addr > 0 && is_allocated; let status_error = !status_already_allocated && mem_commit && addr > 0 && !is_allocated; let status_need_allocate = mem_reserve || (mem_commit && addr == 0); let status_other = !status_already_allocated && !status_error && !status_need_allocate; - if status_need_allocate { if addr == 0 { base = emu @@ -38,9 +64,13 @@ pub fn VirtualAlloc(emu: &mut emu::Emu) { } emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAlloc out of memory"); - } else if status_already_allocated { base = addr; } else if status_error { @@ -51,14 +81,14 @@ pub fn VirtualAlloc(emu: &mut emu::Emu) { } log_red!( - emu, - "kernel32!VirtualAlloc addr: 0x{:x} sz: {} flags: {} =0x{:x}", - addr, - size, - typ, - base - ); + emu, + "kernel32!VirtualAlloc addr: 0x{:x} sz: {} flags: {} =0x{:x}", + addr, + size, + typ, + base + ); emu.regs_mut().rax = base; } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex.rs index 559af1c0..2f2ea6eb 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex.rs @@ -1,5 +1,16 @@ - use crate::emu; +use crate::maps::mem64::Permission; + +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; pub fn VirtualAllocEx(emu: &mut emu::Emu) { let proc_hndl = emu.regs().rcx; @@ -8,8 +19,25 @@ pub fn VirtualAllocEx(emu: &mut emu::Emu) { let alloc_type = emu.regs().r9; let protect = emu .maps - .read_qword(emu.regs().rsp + 0x20) - .expect("kernel32!VirtualAllocEx cannot read_qword protect"); + .read_dword(emu.regs().rsp + 0x20) + .expect("kernel32!VirtualAllocEx cannot read_dword protect"); + + let can_read = (protect + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; let base = emu .maps @@ -26,8 +54,13 @@ pub fn VirtualAllocEx(emu: &mut emu::Emu) { ); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAllocEx out of memory"); emu.regs_mut().rax = base; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex_numa.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex_numa.rs index f91dbc99..27c5d857 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex_numa.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_alloc_ex_numa.rs @@ -1,5 +1,16 @@ - use crate::emu; +use crate::maps::mem64::Permission; + +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { let proc_hndl = emu.regs().rcx; @@ -8,13 +19,30 @@ pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { let alloc_type = emu.regs().r9; let protect = emu .maps - .read_qword(emu.regs().rsp + 0x20) + .read_dword(emu.regs().rsp + 0x20) .expect("kernel32!VirtualAllocExNuma cannot read the protect"); let nnd = emu .maps .read_qword(emu.regs().rsp + 0x28) .expect("kernel32!VirtualAllocExNuma cannot read the nndPreferred"); + let can_read = (protect + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + log_red!( emu, "kernel32!VirtualAllocExNuma hproc: 0x{:x} addr: 0x{:x}", @@ -27,8 +55,13 @@ pub fn VirtualAllocExNuma(emu: &mut emu::Emu) { .alloc(size) .expect("kernel32!VirtualAllocExNuma out of memory"); emu.maps - .create_map(format!("alloc_{:x}", base).as_str(), base, size) + .create_map( + format!("alloc_{:x}", base).as_str(), + base, + size, + Permission::from_flags(can_read, can_write, can_execute), + ) .expect("kernel32!VirtualAllocExNuma cannot create map"); emu.regs_mut().rax = base; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_free.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_free.rs index 0102f297..20d45166 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_free.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_free.rs @@ -1,22 +1,16 @@ - use crate::emu; pub fn VirtualFree(emu: &mut emu::Emu) { let addr = emu.regs().rcx; let sz = emu.regs().rdx; - log_red!( - emu, - "kernel32!VirtualFree {} bytes at 0x{:x}", - sz, - addr - ); + log_red!(emu, "kernel32!VirtualFree {} bytes at 0x{:x}", sz, addr); // zero out the memory? for i in 0..sz { emu.maps.write_byte(addr + i, 0); } - + // TODO: do something (dump+free or not free) emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_lock.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_lock.rs index 08607468..135b0070 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_lock.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_lock.rs @@ -1,20 +1,19 @@ - use crate::emu; pub fn VirtualLock(emu: &mut emu::Emu) { - let lp_address = emu.regs().rcx; - let dw_size = emu.regs().rdx; + let lp_address = emu.regs().rcx; + let dw_size = emu.regs().rdx; - log_red!( + log_red!( emu, "kernel32!VirtualLock addr: 0x{:x} size: 0x{:x}", lp_address, dw_size ); - // TODO: Implement actual memory locking functionality - // VirtualLock locks pages in physical memory to prevent paging to disk - // For emulation purposes, this is typically not critical + // TODO: Implement actual memory locking functionality + // VirtualLock locks pages in physical memory to prevent paging to disk + // For emulation purposes, this is typically not critical - emu.regs_mut().rax = 1; // Return TRUE (non-zero) -} \ No newline at end of file + emu.regs_mut().rax = 1; // Return TRUE (non-zero) +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect.rs index bced328a..26bebed8 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn VirtualProtect(emu: &mut emu::Emu) { @@ -18,4 +17,4 @@ pub fn VirtualProtect(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect_ex.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect_ex.rs index ed588fe2..ef7feac9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect_ex.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/virtual_protect_ex.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn VirtualProtectEx(emu: &mut emu::Emu) { @@ -21,4 +20,4 @@ pub fn VirtualProtectEx(emu: &mut emu::Emu) { ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/wait_for_single_object.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/wait_for_single_object.rs index f2fc48d6..4e3a7a4d 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/wait_for_single_object.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/wait_for_single_object.rs @@ -1,4 +1,3 @@ - use crate::{constants, emu}; pub fn WaitForSingleObject(emu: &mut emu::Emu) { @@ -13,4 +12,4 @@ pub fn WaitForSingleObject(emu: &mut emu::Emu) { ); emu.regs_mut().rax = constants::WAIT_TIMEOUT; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/wide_char_to_multi_byte.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/wide_char_to_multi_byte.rs index 2a522c77..379d4ea9 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/wide_char_to_multi_byte.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/wide_char_to_multi_byte.rs @@ -1,6 +1,5 @@ - -use crate::{constants, emu}; use crate::winapi::winapi64::kernel32::{clear_last_error, LAST_ERROR}; +use crate::{constants, emu}; pub fn WideCharToMultiByte(emu: &mut emu::Emu) { let code_page = emu.regs().rcx as u64; @@ -76,7 +75,12 @@ pub fn WideCharToMultiByte(emu: &mut emu::Emu) { // 5. Check output buffer size if cb_multi_byte < input_len as u64 { // Set last error to ERROR_INSUFFICIENT_BUFFER - log::warn!("{} buffer too small for result cb_multi_byte: {} input_len: {}", emu.pos, cb_multi_byte, input_len); + log::warn!( + "{} buffer too small for result cb_multi_byte: {} input_len: {}", + emu.pos, + cb_multi_byte, + input_len + ); let mut err = LAST_ERROR.lock().unwrap(); *err = constants::ERROR_INSUFFICIENT_BUFFER; emu.regs_mut().rax = 0; @@ -85,7 +89,9 @@ pub fn WideCharToMultiByte(emu: &mut emu::Emu) { // 6. Perform the actual conversion if lp_multi_byte_str > 0 && !s.is_empty() { - if lp_multi_byte_str < emu.cfg.stack_addr || lp_multi_byte_str > emu.cfg.stack_addr + 0x030000 { + if lp_multi_byte_str < emu.cfg.stack_addr + || lp_multi_byte_str > emu.cfg.stack_addr + 0x030000 + { emu.maps.write_string(lp_multi_byte_str, &s); } @@ -107,11 +113,11 @@ pub fn WideCharToMultiByte(emu: &mut emu::Emu) { // LOG THE INPUT WIDE STRING if lp_wide_char_str > 0 && !s.is_empty() { log_red!( - emu, - "Input wide string: \"{}\" (length: {} characters)", - s.escape_debug(), - // This will show escape sequences for non-printable chars + emu, + "Input wide string: \"{}\" (length: {} characters)", + s.escape_debug(), + // This will show escape sequences for non-printable chars input_len - ); + ); } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/win_exec.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/win_exec.rs index 2f465e5b..ff29ab94 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/win_exec.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/win_exec.rs @@ -1,15 +1,10 @@ - use crate::emu; pub fn WinExec(emu: &mut emu::Emu) { let cmdline_ptr = emu.regs().rcx; let cmdline = emu.maps.read_string(cmdline_ptr); - log_red!( - emu, - "kernel32!WinExec '{}'", - cmdline - ); + log_red!(emu, "kernel32!WinExec '{}'", cmdline); emu.regs_mut().rax = 32; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/write_console_w.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/write_console_w.rs index fe8c255a..933ce06e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/write_console_w.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/write_console_w.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn WriteConsoleW(emu: &mut emu::Emu) { @@ -14,7 +13,10 @@ pub fn WriteConsoleW(emu: &mut emu::Emu) { // Read the UTF-16 buffer let mut wide_chars = Vec::new(); for i in 0..n_number_of_chars_to_write { - let wchar = emu.maps.read_word(lp_buffer as u64 + (i * 2) as u64).unwrap(); + let wchar = emu + .maps + .read_word(lp_buffer as u64 + (i * 2) as u64) + .unwrap(); wide_chars.push(wchar); } @@ -26,6 +28,9 @@ pub fn WriteConsoleW(emu: &mut emu::Emu) { lp_number_of_chars_written, lp_reserved, s1); // Write back the number of characters written - emu.maps.write_dword(lp_number_of_chars_written as u64, n_number_of_chars_to_write); + emu.maps.write_dword( + lp_number_of_chars_written as u64, + n_number_of_chars_to_write, + ); emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/write_file.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/write_file.rs index 911eaa15..09767008 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/write_file.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/write_file.rs @@ -1,4 +1,3 @@ - use crate::emu; use crate::winapi::helper; use crate::winapi::winapi64::kernel32::COUNT_WRITE; @@ -31,4 +30,4 @@ pub fn WriteFile(emu: &mut emu::Emu) { } emu.regs_mut().rax = 1; -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernel32/write_process_memory.rs b/crates/libmwemu/src/winapi/winapi64/kernel32/write_process_memory.rs index 55f1b114..cbd44835 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernel32/write_process_memory.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernel32/write_process_memory.rs @@ -1,4 +1,3 @@ - use crate::emu; pub fn WriteProcessMemory(emu: &mut emu::Emu) { @@ -41,4 +40,4 @@ pub fn WriteProcessMemory(emu: &mut emu::Emu) { log::info!("kernel32!WriteProcessMemory cannot write on written_ptr"); } } -} \ No newline at end of file +} diff --git a/crates/libmwemu/src/winapi/winapi64/kernelbase.rs b/crates/libmwemu/src/winapi/winapi64/kernelbase.rs index fb50583b..d2a0f41e 100644 --- a/crates/libmwemu/src/winapi/winapi64/kernelbase.rs +++ b/crates/libmwemu/src/winapi/winapi64/kernelbase.rs @@ -108,11 +108,7 @@ pub fn PathCombineW(emu: &mut emu::Emu) { pub fn IsCharAlphaNumericA(emu: &mut emu::Emu) { let c = emu.regs().rcx as u8 as char; - log_red!( - emu, - "kernelbase!IsCharAlphaNumericA char: {}", - c - ); + log_red!(emu, "kernelbase!IsCharAlphaNumericA char: {}", c); emu.regs_mut().rax = if c.is_ascii_alphanumeric() { 1 } else { 0 }; } @@ -142,13 +138,13 @@ DWORD GetFileVersionInfoSizeA( fn GetFileVersionInfoSizeA(emu: &mut emu::Emu) { let lptstr_filename = emu.regs().rcx; let lpdw_handle = emu.regs().rdx as usize; - + let filename = if lptstr_filename > 0 { emu.maps.read_string(lptstr_filename) } else { "unknown".to_string() }; - + log_red!( emu, "** {} kernelbase!GetFileVersionInfoSizeA filename: {} lpdw_handle: 0x{:x}", @@ -180,13 +176,13 @@ fn GetFileVersionInfoA(emu: &mut emu::Emu) { let dw_handle = emu.regs().rdx as usize; let dw_len = emu.regs().r8 as usize; let lp_data = emu.regs().r9 as usize; - + let filename = if lptstr_filename > 0 { emu.maps.read_string(lptstr_filename) } else { "unknown".to_string() }; - + log_red!(emu, "** {} kernelbase!GetFileVersionInfoA filename: {} dw_handle: 0x{:x} dw_len: 0x{:x} lp_data: 0x{:x}", emu.pos, filename, @@ -194,31 +190,31 @@ fn GetFileVersionInfoA(emu: &mut emu::Emu) { dw_len, lp_data ); - + if filename == "comctl32.dll" { - use crate::structures::{VS_VERSIONINFO, VS_FIXEDFILEINFO}; - + use crate::structures::{VS_FIXEDFILEINFO, VS_VERSIONINFO}; + let mut version_info = VS_VERSIONINFO::new(); - + // Set comctl32.dll specific values based on the actual file version_info.value = VS_FIXEDFILEINFO { dw_signature: 0xFEEF04BD, dw_struc_version: 0x00010000, - dw_file_version_ms: 0x0006000A, // 6.10 - dw_file_version_ls: 0x585D11BD, // 22621.4541 - dw_product_version_ms: 0x000A0000, // 10.0 - dw_product_version_ls: 0x585D11BD, // 22621.4541 + dw_file_version_ms: 0x0006000A, // 6.10 + dw_file_version_ls: 0x585D11BD, // 22621.4541 + dw_product_version_ms: 0x000A0000, // 10.0 + dw_product_version_ls: 0x585D11BD, // 22621.4541 dw_file_flags_mask: 0x0000003F, dw_file_flags: 0x00000000, - dw_file_os: 0x00040004, // VOS_NT_WINDOWS32 - dw_file_type: 0x00000002, // VFT_DLL + dw_file_os: 0x00040004, // VOS_NT_WINDOWS32 + dw_file_type: 0x00000002, // VFT_DLL dw_file_subtype: 0x00000000, dw_file_date_ms: 0x00000000, dw_file_date_ls: 0x00000000, }; - + version_info.write(emu, lp_data as u64); - + emu.regs_mut().rax = 1; // Success } else { panic!("TODO: {}", filename); @@ -238,13 +234,13 @@ fn VerQueryValueA(emu: &mut emu::Emu) { let lp_sub_block = emu.regs().rdx; let lplp_buffer = emu.regs().r8 as usize; let pu_len = emu.regs().r9 as usize; - + let sub_block = if lp_sub_block > 0 { emu.maps.read_string(lp_sub_block) } else { "\\".to_string() }; - + log_red!(emu, "** {} kernelbase!VerQueryValueA p_block: 0x{:x} lp_sub_block: {} lplp_buffer: 0x{:x} pu_len: 0x{:x}", emu.pos, p_block, @@ -252,7 +248,7 @@ fn VerQueryValueA(emu: &mut emu::Emu) { lplp_buffer, pu_len ); - + if sub_block == "\\" { // Root query returns pointer to VS_FIXEDFILEINFO // The VS_FIXEDFILEINFO starts at offset 0x28 in the version block @@ -267,17 +263,23 @@ fn VerQueryValueA(emu: &mut emu::Emu) { "\\StringFileInfo\\040904B0\\FileDescription" => "User Experience Controls Library\0", "\\StringFileInfo\\040904B0\\FileVersion" => "6.10 (WinBuild.160101.0800)\0", "\\StringFileInfo\\040904B0\\InternalName" => "comctl32\0", - "\\StringFileInfo\\040904B0\\LegalCopyright" => "© Microsoft Corporation. All rights reserved.\0", + "\\StringFileInfo\\040904B0\\LegalCopyright" => { + "© Microsoft Corporation. All rights reserved.\0" + } "\\StringFileInfo\\040904B0\\OriginalFilename" => "comctl32.DLL\0", "\\StringFileInfo\\040904B0\\ProductName" => "Microsoft® Windows® Operating System\0", "\\StringFileInfo\\040904B0\\ProductVersion" => "10.0.22621.4541\0", _ => "\0", }; - - let string_addr = emu.maps.alloc(string_data.len() as u64).expect("out of memory"); + + let string_addr = emu + .maps + .alloc(string_data.len() as u64) + .expect("out of memory"); emu.maps.write_string(string_addr, string_data); emu.maps.write_qword(lplp_buffer as u64, string_addr); - emu.maps.write_dword(pu_len as u64, string_data.len() as u32); + emu.maps + .write_dword(pu_len as u64, string_data.len() as u32); emu.regs_mut().rax = 1; } else if sub_block == "\\VarFileInfo\\Translation" { // Translation array @@ -293,44 +295,28 @@ fn VerQueryValueA(emu: &mut emu::Emu) { } fn _initterm_e(emu: &mut emu::Emu) { - log_red!( - emu, - "kernelbase!_initterm_e" - ); + log_red!(emu, "kernelbase!_initterm_e"); emu.regs_mut().rax = 0; } fn _initterm(emu: &mut emu::Emu) { - log_red!( - emu, - "kernelbase!_initterm" - ); + log_red!(emu, "kernelbase!_initterm"); emu.regs_mut().rax = 0; } fn exit(emu: &mut emu::Emu) { - log_red!( - emu, - "kernelbase!exit" - ); + log_red!(emu, "kernelbase!exit"); panic!("exit called"); } fn _exit(emu: &mut emu::Emu) { - log_red!( - emu, - "kernelbase!_exit" - ); + log_red!(emu, "kernelbase!_exit"); panic!("_exit called"); } fn atexit(emu: &mut emu::Emu) { let fptr = emu.regs().rcx; - log_red!( - emu, - "kernelbase!atexit fptr: 0x{:x}", - fptr - ); + log_red!(emu, "kernelbase!atexit fptr: 0x{:x}", fptr); emu.regs_mut().rax = 0; } @@ -341,8 +327,8 @@ DWORD CharLowerBuffW( ); */ pub fn CharLowerBuffW(emu: &mut emu::Emu) { - let lpsz = emu.regs().rcx; // Buffer pointer (LPWSTR) - let cch_length = emu.regs().rdx; // Length in characters (DWORD) + let lpsz = emu.regs().rcx; // Buffer pointer (LPWSTR) + let cch_length = emu.regs().rdx; // Length in characters (DWORD) log_red!( emu, @@ -361,21 +347,21 @@ pub fn CharLowerBuffW(emu: &mut emu::Emu) { // Process each character in the buffer for i in 0..cch_length { let char_addr = lpsz + (i * 2); // Each wide character is 2 bytes - + if let Some(wide_char) = emu.maps.read_word(char_addr) { // Convert UTF-16 code unit to char for processing if let Some(unicode_char) = char::from_u32(wide_char as u32) { // Convert to lowercase let lowercase_char = unicode_char.to_lowercase().next().unwrap_or(unicode_char); - + // Convert back to UTF-16 code unit let mut utf16_buf = [0u16; 2]; let utf16_encoded = lowercase_char.encode_utf16(&mut utf16_buf); - + // Write the lowercase character back (take first code unit for BMP characters) let lowercase_code_unit = utf16_encoded[0]; emu.maps.write_word(char_addr, lowercase_code_unit); - + processed_count += 1; } else { // Invalid Unicode, but still count as processed diff --git a/crates/libmwemu/src/winapi/winapi64/msvcrt.rs b/crates/libmwemu/src/winapi/winapi64/msvcrt.rs index 2bfb1169..bf6059bc 100644 --- a/crates/libmwemu/src/winapi/winapi64/msvcrt.rs +++ b/crates/libmwemu/src/winapi/winapi64/msvcrt.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::winapi::winapi64::kernel32; @@ -54,15 +55,15 @@ fn malloc(emu: &mut emu::Emu) { let base = emu.maps.alloc(size).expect("msvcrt!malloc out of memory"); emu.maps - .create_map(&format!("alloc_{:x}", base), base, size) + .create_map( + &format!("alloc_{:x}", base), + base, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!malloc cannot create map"); - log_red!( - emu, - "msvcrt!malloc sz: {} addr: 0x{:x}", - size, - base - ); + log_red!(emu, "msvcrt!malloc sz: {} addr: 0x{:x}", size, base); emu.regs_mut().rax = base; } else { diff --git a/crates/libmwemu/src/winapi/winapi64/ntdll.rs b/crates/libmwemu/src/winapi/winapi64/ntdll.rs index 8f83301d..39c8dd97 100644 --- a/crates/libmwemu/src/winapi/winapi64/ntdll.rs +++ b/crates/libmwemu/src/winapi/winapi64/ntdll.rs @@ -7,11 +7,23 @@ use crate::console::Console; use crate::constants; use crate::context::context64::Context64; use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::structures; use crate::winapi::helper; use crate::winapi::winapi64::kernel32; +const PAGE_NOACCESS: u32 = 0x01; +const PAGE_READONLY: u32 = 0x02; +const PAGE_READWRITE: u32 = 0x04; +const PAGE_WRITECOPY: u32 = 0x08; +const PAGE_EXECUTE: u32 = 0x10; +const PAGE_EXECUTE_READ: u32 = 0x20; +const PAGE_EXECUTE_READWRITE: u32 = 0x40; +const PAGE_EXECUTE_WRITECOPY: u32 = 0x80; +const PAGE_GUARD: u32 = 0x100; +const PAGE_NOCACHE: u32 = 0x200; + pub fn gateway(addr: u64, emu: &mut emu::Emu) -> String { let api = kernel32::guess_api_name(emu, addr); match api.as_str() { @@ -93,6 +105,34 @@ fn NtAllocateVirtualMemory(emu: &mut emu::Emu) { let addr_ptr = emu.regs().rcx; let size_ptr = emu.regs().rdx; + let protection_offset = 0x30; + let protection_addr = emu.regs().rsp + protection_offset; + let protect_value = emu + .maps + .read_dword(protection_addr) + .expect("Failed to read Protection argument at NtAllocateVirtualMemory"); + + let can_read = (protect_value + & (PAGE_READONLY + | PAGE_READWRITE + | PAGE_WRITECOPY + | PAGE_EXECUTE_READ + | PAGE_EXECUTE_READWRITE + | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_write = (protect_value + & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + let can_execute = (protect_value + & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY)) + != 0; + + // Special cases + let no_access = (protect_value & PAGE_NOACCESS) != 0; + let guard_page = (protect_value & PAGE_GUARD) != 0; + let no_cache = (protect_value & PAGE_NOCACHE) != 0; let addr = emu .maps @@ -135,6 +175,7 @@ fn NtAllocateVirtualMemory(emu: &mut emu::Emu) { format!("valloc_{:x}", alloc_addr).as_str(), alloc_addr, size, + Permission::from_flags(can_read, can_write, can_execute), ) .expect("ntdll!NtAllocateVirtualMemory cannot create map"); @@ -151,12 +192,7 @@ fn stricmp(emu: &mut emu::Emu) { let str1 = emu.maps.read_string(str1ptr); let str2 = emu.maps.read_string(str2ptr); - log_red!( - emu, - "ntdll!stricmp '{}'=='{}'?", - str1, - str2 - ); + log_red!(emu, "ntdll!stricmp '{}'=='{}'?", str1, str2); if str1 == str2 { emu.regs_mut().rax = 0; @@ -169,11 +205,7 @@ fn NtQueryVirtualMemory(emu: &mut emu::Emu) { let handle = emu.regs().rcx; let addr = emu.regs().rdx; - log_red!( - emu, - "ntdll!NtQueryVirtualMemory addr: 0x{:x}", - addr - ); + log_red!(emu, "ntdll!NtQueryVirtualMemory addr: 0x{:x}", addr); if handle != 0xffffffff { log::info!("\tusing handle of remote process {:x}", handle); @@ -219,21 +251,22 @@ fn LdrLoadDll(emu: &mut emu::Emu) { let libaddr_ptr = emu.regs().r9; let libname = emu.maps.read_wide_string(libname_ptr); - log_red!( - emu, - "ntdll!LdrLoadDll lib: {}", - libname - ); + log_red!(emu, "ntdll!LdrLoadDll lib: {}", libname); if libname == "user32.dll" { let user32 = emu .maps - .create_map("user32", 0x773b0000, 0x1000) + .create_map("user32", 0x773b0000, 0x1000, Permission::READ_WRITE) .expect("ntdll!LdrLoadDll_gul cannot create map"); user32.load("maps32/user32.bin"); let user32_text = emu .maps - .create_map("user32_text", 0x773b1000, 0x1000) + .create_map( + "user32_text", + 0x773b1000, + 0x1000, + Permission::READ_WRITE_EXECUTE, + ) .expect("ntdll!LdrLoadDll_gul cannot create map"); user32_text.load("maps32/user32_text.bin"); @@ -283,10 +316,7 @@ fn NtGetContextThread(emu: &mut emu::Emu) { .read_qword(ctx_ptr) .expect("ntdll_NtGetContextThread: error reading context ptr"); - log_red!( - emu, - "ntdll_NtGetContextThread ctx:" - ); + log_red!(emu, "ntdll_NtGetContextThread ctx:"); let ctx = Context64::new(&emu.regs()); ctx.save(ctx_ptr2, &mut emu.maps); @@ -295,10 +325,7 @@ fn NtGetContextThread(emu: &mut emu::Emu) { } fn RtlExitUserThread(emu: &mut emu::Emu) { - log_red!( - emu, - "ntdll!RtlExitUserThread" - ); + log_red!(emu, "ntdll!RtlExitUserThread"); Console::spawn_console(emu); std::process::exit(1); } @@ -349,9 +376,11 @@ fn RtlAllocateHeap(emu: &mut emu::Emu) { Some(a) => a, None => panic!("/!\\ out of memory cannot allocate ntdll!RtlAllocateHeap"), }; + + // TODO: fix this from READ_WRITE_EXECUTE to maybe READ_WRITE let map_name = format!("valloc_{:x}", alloc_addr); emu.maps - .create_map(&map_name, alloc_addr, size) + .create_map(&map_name, alloc_addr, size, Permission::READ_WRITE) .expect("ntdll!RtlAllocateHeap cannot create map"); //} @@ -410,12 +439,7 @@ fn sscanf(emu: &mut emu::Emu) { let buffer = emu.maps.read_string(buffer_ptr); let fmt = emu.maps.read_string(fmt_ptr); - log_red!( - emu, - "ntdll!sscanf out_buff: `{}` fmt: `{}`", - buffer, - fmt - ); + log_red!(emu, "ntdll!sscanf out_buff: `{}` fmt: `{}`", buffer, fmt); let rust_fmt = fmt .replace("%x", "{x}") @@ -431,10 +455,7 @@ fn sscanf(emu: &mut emu::Emu) { } fn NtGetTickCount(emu: &mut emu::Emu) { - log_red!( - emu, - "ntdll!NtGetTickCount" - ); + log_red!(emu, "ntdll!NtGetTickCount"); emu.regs_mut().rax = emu.tick as u64; } @@ -442,10 +463,7 @@ fn NtQueryPerformanceCounter(emu: &mut emu::Emu) { let perf_counter_ptr = emu.regs().rcx; let perf_freq_ptr = emu.regs().rdx; - log_red!( - emu, - "ntdll!NtQueryPerformanceCounter" - ); + log_red!(emu, "ntdll!NtQueryPerformanceCounter"); emu.maps.write_dword(perf_counter_ptr, 0); emu.regs_mut().rax = constants::STATUS_SUCCESS; @@ -481,7 +499,7 @@ RtlDosPathNameToNtPathName_U(IN PCWSTR DosName, fn RtlDosPathNameToNtPathName_U(emu: &mut emu::Emu) { let dos_path_name_ptr = emu.regs().rcx; - let nt_path_name_ptr = emu.regs().rdx; // This should point to a UNICODE_STRING structure + let nt_path_name_ptr = emu.regs().rdx; // This should point to a UNICODE_STRING structure let nt_file_name_part_ptr = emu.regs().r8; let curdir_ptr = emu.regs().r9; @@ -505,50 +523,76 @@ fn RtlDosPathNameToNtPathName_U(emu: &mut emu::Emu) { format!("\\??\\{}", dos_path_name) }; - log_red!(emu, "Converted DOS path '{}' to NT path '{}'", dos_path_name, nt_path); + log_red!( + emu, + "Converted DOS path '{}' to NT path '{}'", + dos_path_name, + nt_path + ); if nt_path_name_ptr > 0 { // nt_path_name_ptr points to a UNICODE_STRING structure that we need to populate - + // Calculate string length in bytes (UTF-16, so chars * 2) let string_length_bytes = nt_path.encode_utf16().count() * 2; - + // Allocate buffer for the NT path string - match emu.maps.alloc((string_length_bytes + 2) as u64) { // +2 for null terminator + match emu.maps.alloc((string_length_bytes + 2) as u64) { + // +2 for null terminator Some(string_buffer_addr) => { // TODO: only create if it does not already exist // Create the string buffer map - emu.maps.create_map(&format!("nt_path_string_{:x}", string_buffer_addr), string_buffer_addr, (string_length_bytes + 2) as u64) + emu.maps + .create_map( + &format!("nt_path_string_{:x}", string_buffer_addr), + string_buffer_addr, + (string_length_bytes + 2) as u64, + Permission::READ_WRITE, + ) .expect("Failed to create nt_path_string map"); - + // Write the NT path string to the allocated buffer emu.maps.write_wide_string(string_buffer_addr, &nt_path); - + // Now populate the UNICODE_STRING structure at nt_path_name_ptr // typedef struct _UNICODE_STRING { // USHORT Length; // +0x00 - // USHORT MaximumLength; // +0x02 + // USHORT MaximumLength; // +0x02 // PWSTR Buffer; // +0x08 // } UNICODE_STRING; - - emu.maps.write_word(nt_path_name_ptr, string_length_bytes as u16); // Length - emu.maps.write_word(nt_path_name_ptr + 2, (string_length_bytes + 2) as u16); // MaximumLength - emu.maps.write_qword(nt_path_name_ptr + 8, string_buffer_addr); // Buffer - - log_red!(emu, "Created UNICODE_STRING: Length={}, MaxLength={}, Buffer=0x{:x}", - string_length_bytes, string_length_bytes + 2, string_buffer_addr); - + + emu.maps + .write_word(nt_path_name_ptr, string_length_bytes as u16); // Length + emu.maps + .write_word(nt_path_name_ptr + 2, (string_length_bytes + 2) as u16); // MaximumLength + emu.maps + .write_qword(nt_path_name_ptr + 8, string_buffer_addr); // Buffer + + log_red!( + emu, + "Created UNICODE_STRING: Length={}, MaxLength={}, Buffer=0x{:x}", + string_length_bytes, + string_length_bytes + 2, + string_buffer_addr + ); + // Set nt_file_name_part_ptr if requested if nt_file_name_part_ptr > 0 { // Find the last backslash to get filename part if let Some(last_backslash_pos) = nt_path.rfind('\\') { let filename_offset = (last_backslash_pos + 1) * 2; // Convert to byte offset let filename_part_addr = string_buffer_addr + filename_offset as u64; - emu.maps.write_qword(nt_file_name_part_ptr, filename_part_addr); - log_red!(emu, "Set filename part pointer to 0x{:x}", filename_part_addr); + emu.maps + .write_qword(nt_file_name_part_ptr, filename_part_addr); + log_red!( + emu, + "Set filename part pointer to 0x{:x}", + filename_part_addr + ); } else { // No backslash found, filename part is the whole string - emu.maps.write_qword(nt_file_name_part_ptr, string_buffer_addr); + emu.maps + .write_qword(nt_file_name_part_ptr, string_buffer_addr); } } } @@ -589,13 +633,34 @@ fn NtCreateFile(emu: &mut emu::Emu) { let access_mask = emu.regs().rdx; let oattrib = emu.regs().r8; let iostat = emu.regs().r9; - let alloc_sz = emu.maps.read_qword(emu.regs().rsp + 0x20).expect("ntdll!NtCreateFile error reading alloc_sz param"); - let fattrib = emu.maps.read_dword(emu.regs().rsp + 0x28).expect("ntdll!NtCreateFile error reading fattrib param"); - let share_access = emu.maps.read_dword(emu.regs().rsp + 0x30).expect("ntdll!NtCreateFile error reading share_access param"); - let create_disp = emu.maps.read_dword(emu.regs().rsp + 0x38).expect("ntdll!NtCreateFile error reading create_disp param"); - let create_opt = emu.maps.read_dword(emu.regs().rsp + 0x40).expect("ntdll!NtCreateFile error reading create_opt param"); - let ea_buff = emu.maps.read_qword(emu.regs().rsp + 0x48).expect("ntdll!NtCreateFile error reading ea_buff param"); - let ea_len = emu.maps.read_dword(emu.regs().rsp + 0x50).expect("ntdll!NtCreateFile error reading ea_len param"); + let alloc_sz = emu + .maps + .read_qword(emu.regs().rsp + 0x20) + .expect("ntdll!NtCreateFile error reading alloc_sz param"); + let fattrib = emu + .maps + .read_dword(emu.regs().rsp + 0x28) + .expect("ntdll!NtCreateFile error reading fattrib param"); + let share_access = emu + .maps + .read_dword(emu.regs().rsp + 0x30) + .expect("ntdll!NtCreateFile error reading share_access param"); + let create_disp = emu + .maps + .read_dword(emu.regs().rsp + 0x38) + .expect("ntdll!NtCreateFile error reading create_disp param"); + let create_opt = emu + .maps + .read_dword(emu.regs().rsp + 0x40) + .expect("ntdll!NtCreateFile error reading create_opt param"); + let ea_buff = emu + .maps + .read_qword(emu.regs().rsp + 0x48) + .expect("ntdll!NtCreateFile error reading ea_buff param"); + let ea_len = emu + .maps + .read_dword(emu.regs().rsp + 0x50) + .expect("ntdll!NtCreateFile error reading ea_len param"); log_red!(emu, "** {} ntdll!NtCreateFile | Handle=0x{:x} Access=0x{:x} ObjAttr=0x{:x} IoStat=0x{:x} AllocSz=0x{:x} FileAttr=0x{:x} ShareAccess=0x{:x} CreateDisp=0x{:x} CreateOpt=0x{:x} EaBuff=0x{:x} EaLen=0x{:x}", emu.pos, @@ -623,8 +688,13 @@ fn NtCreateFile(emu: &mut emu::Emu) { } OBJECT_ATTRIBUTES; */ let filename = if oattrib != 0 { - log_red!(emu, "** {} Reading OBJECT_ATTRIBUTES at 0x{:x}", emu.pos, oattrib); - + log_red!( + emu, + "** {} Reading OBJECT_ATTRIBUTES at 0x{:x}", + emu.pos, + oattrib + ); + // Dump the OBJECT_ATTRIBUTES structure first log_red!(emu, "** {} OBJECT_ATTRIBUTES structure dump:", emu.pos); for i in (0..0x30).step_by(8) { @@ -632,19 +702,28 @@ fn NtCreateFile(emu: &mut emu::Emu) { log_red!(emu, "** {} +0x{:02x}: 0x{:016x}", emu.pos, i, qword_val); } } - + // Read RootDirectory and ObjectName fields let root_directory = emu.maps.read_qword(oattrib + 0x08).unwrap_or(0); let obj_name_ptr = emu.maps.read_qword(oattrib + 0x10).unwrap_or(0); - - log_red!(emu, "** {} RootDirectory: 0x{:x}, ObjectName pointer: 0x{:x}", - emu.pos, root_directory, obj_name_ptr); - + + log_red!( + emu, + "** {} RootDirectory: 0x{:x}, ObjectName pointer: 0x{:x}", + emu.pos, + root_directory, + obj_name_ptr + ); + // Handle different scenarios if obj_name_ptr == 0 { // Case 1: ObjectName is NULL - unnamed object - log_red!(emu, "** {} ObjectName is NULL - creating unnamed object", emu.pos); - + log_red!( + emu, + "** {} ObjectName is NULL - creating unnamed object", + emu.pos + ); + if root_directory != 0 { // Creating unnamed object relative to root directory String::from("") @@ -654,30 +733,52 @@ fn NtCreateFile(emu: &mut emu::Emu) { } } else if !emu.maps.is_mapped(obj_name_ptr) { // Case 2: ObjectName pointer is invalid - log_red!(emu, "** {} ObjectName pointer 0x{:x} is not mapped", emu.pos, obj_name_ptr); + log_red!( + emu, + "** {} ObjectName pointer 0x{:x} is not mapped", + emu.pos, + obj_name_ptr + ); String::from("") } else { // Case 3: ObjectName pointer is valid - read UNICODE_STRING - log_red!(emu, "** {} Reading UNICODE_STRING at 0x{:x}", emu.pos, obj_name_ptr); - + log_red!( + emu, + "** {} Reading UNICODE_STRING at 0x{:x}", + emu.pos, + obj_name_ptr + ); + // Debug: dump UNICODE_STRING structure for i in (0..16).step_by(8) { if let Some(qword_val) = emu.maps.read_qword(obj_name_ptr + i) { - log_red!(emu, "** {} UNICODE_STRING +0x{:02x}: 0x{:016x}", emu.pos, i, qword_val); + log_red!( + emu, + "** {} UNICODE_STRING +0x{:02x}: 0x{:016x}", + emu.pos, + i, + qword_val + ); } } - + let length = emu.maps.read_word(obj_name_ptr).unwrap_or(0); let max_length = emu.maps.read_word(obj_name_ptr + 2).unwrap_or(0); let buffer_ptr = emu.maps.read_qword(obj_name_ptr + 8).unwrap_or(0); - - log_red!(emu, "** {} UNICODE_STRING: Length={} MaxLength={} Buffer=0x{:x}", - emu.pos, length, max_length, buffer_ptr); - + + log_red!( + emu, + "** {} UNICODE_STRING: Length={} MaxLength={} Buffer=0x{:x}", + emu.pos, + length, + max_length, + buffer_ptr + ); + if buffer_ptr == 0 { // Case 4: UNICODE_STRING.Buffer is NULL log_red!(emu, "** {} UNICODE_STRING Buffer is NULL", emu.pos); - + if root_directory != 0 { String::from("") } else { @@ -685,8 +786,12 @@ fn NtCreateFile(emu: &mut emu::Emu) { } } else if length == 0 { // Case 5: UNICODE_STRING.Length is 0 (empty string) - log_red!(emu, "** {} UNICODE_STRING Length is 0 (empty string)", emu.pos); - + log_red!( + emu, + "** {} UNICODE_STRING Length is 0 (empty string)", + emu.pos + ); + if root_directory != 0 { String::from("") } else { @@ -694,15 +799,20 @@ fn NtCreateFile(emu: &mut emu::Emu) { } } else if !emu.maps.is_mapped(buffer_ptr) { // Case 6: UNICODE_STRING.Buffer pointer is invalid - log_red!(emu, "** {} UNICODE_STRING Buffer 0x{:x} is not mapped", emu.pos, buffer_ptr); + log_red!( + emu, + "** {} UNICODE_STRING Buffer 0x{:x} is not mapped", + emu.pos, + buffer_ptr + ); String::from("") } else { // Case 7: Valid UNICODE_STRING with valid buffer - read the string let char_count = (length / 2) as usize; let filename_str = emu.maps.read_wide_string_n(buffer_ptr, char_count); - + log_red!(emu, "** {} Filename: '{}'", emu.pos, filename_str); - + if root_directory != 0 { // Relative path to root directory format!("\\{}", root_directory, filename_str) @@ -717,7 +827,12 @@ fn NtCreateFile(emu: &mut emu::Emu) { String::from("") }; - log_red!(emu, "** {} ntdll!NtCreateFile resolved filename: '{}'", emu.pos, filename); + log_red!( + emu, + "** {} ntdll!NtCreateFile resolved filename: '{}'", + emu.pos, + filename + ); if out_hndl_ptr > 0 { emu.maps @@ -732,18 +847,10 @@ fn RtlFreeHeap(emu: &mut emu::Emu) { let flags = emu.regs().rdx; let base_addr = emu.regs().r8; - log_red!( - emu, - "ntdll!RtlFreeHeap 0x{}", - base_addr - ); + log_red!(emu, "ntdll!RtlFreeHeap 0x{}", base_addr); helper::handler_close(hndl); - let name = emu - .maps - .get_addr_name(base_addr) - .unwrap_or("") - .to_string(); + let name = emu.maps.get_addr_name(base_addr).unwrap_or("").to_string(); if name.is_empty() { if emu.cfg.verbose >= 1 { log::info!("map not allocated, so cannot free it."); @@ -766,11 +873,7 @@ fn RtlFreeHeap(emu: &mut emu::Emu) { fn RtlFreeAnsiString(emu: &mut emu::Emu) { let ptr = emu.regs().rcx; - log_red!( - emu, - "ntdll!RtlFreeAnsiString 0x{}", - ptr - ); + log_red!(emu, "ntdll!RtlFreeAnsiString 0x{}", ptr); // TODO: no-op? } @@ -785,10 +888,7 @@ fn NtQueryInformationFile(emu: &mut emu::Emu) { .read_qword(emu.regs().rsp + 0x20) .expect("ntdll!NtQueryInformationFile cannot read fileinfoctls param"); - log_red!( - emu, - "ntdll!NtQueryInformationFile" - ); + log_red!(emu, "ntdll!NtQueryInformationFile"); emu.regs_mut().rax = constants::STATUS_SUCCESS; } @@ -874,7 +974,15 @@ fn NtReadFile(emu: &mut emu::Emu) { // filename from handle let filename = helper::handler_get_uri(file_hndl); - log_red!(emu, "ntdll!NtReadFile {} hndl: 0x{:x} buff: 0x{:x} sz: {} off_var: 0x{:x}", filename, file_hndl, buff, len, off); + log_red!( + emu, + "ntdll!NtReadFile {} hndl: 0x{:x} buff: 0x{:x} sz: {} off_var: 0x{:x}", + filename, + file_hndl, + buff, + len, + off + ); emu.maps.memset(buff, 0x90, len); @@ -904,7 +1012,7 @@ fn NtReadFile(emu: &mut emu::Emu) { } else { panic!("TODO: read {}", filename); } - + emu.regs_mut().rax = constants::STATUS_SUCCESS; } @@ -913,12 +1021,7 @@ fn NtClose(emu: &mut emu::Emu) { let uri = helper::handler_get_uri(hndl); - log_red!( - emu, - "ntdll!NtClose hndl: 0x{:x} uri: {}", - hndl, - uri - ); + log_red!(emu, "ntdll!NtClose hndl: 0x{:x} uri: {}", hndl, uri); if uri.is_empty() { emu.regs_mut().rax = constants::STATUS_INVALID_HANDLE; @@ -931,10 +1034,7 @@ fn RtlInitializeCriticalSectionAndSpinCount(emu: &mut emu::Emu) { let crit_sect = emu.regs().rcx; let spin_count = emu.regs().rdx; - log_red!( - emu, - "ntdll!RtlInitializeCriticalSectionAndSpinCount" - ); + log_red!(emu, "ntdll!RtlInitializeCriticalSectionAndSpinCount"); emu.regs_mut().rax = 1; } @@ -949,12 +1049,7 @@ fn NtProtectVirtualMemory(emu: &mut emu::Emu) { .read_qword(emu.regs().rsp + 0x20) .expect("ntdll!NtProtectVirtualMemory error reading old prot param"); - log_red!( - emu, - "ntdll!NtProtectVirtualMemory sz: {} {}", - sz, - prot - ); + log_red!(emu, "ntdll!NtProtectVirtualMemory sz: {} {}", sz, prot); emu.regs_mut().rax = constants::STATUS_SUCCESS } @@ -962,10 +1057,7 @@ fn NtProtectVirtualMemory(emu: &mut emu::Emu) { fn RtlEnterCriticalSection(emu: &mut emu::Emu) { let hndl = emu.regs().rcx; - log_red!( - emu, - "ntdll!RtlEnterCriticalSection" - ); + log_red!(emu, "ntdll!RtlEnterCriticalSection"); emu.regs_mut().rax = 1; } @@ -973,10 +1065,7 @@ fn RtlEnterCriticalSection(emu: &mut emu::Emu) { fn RtlGetVersion(emu: &mut emu::Emu) { let versioninfo_ptr = emu.regs().rcx; - log_red!( - emu, - "ntdll!RtlGetVersion" - ); + log_red!(emu, "ntdll!RtlGetVersion"); let versioninfo = structures::OsVersionInfoExA::new(); // TODO: should this be Ex? versioninfo.save(versioninfo_ptr, &mut emu.maps); @@ -989,10 +1078,7 @@ fn RtlInitializeCriticalSectionEx(emu: &mut emu::Emu) { let spin_count = emu.regs().rdx; let flags = emu.regs().r8; - log_red!( - emu, - "ntdll!RtlInitializeCriticalSectionEx" - ); + log_red!(emu, "ntdll!RtlInitializeCriticalSectionEx"); emu.regs_mut().rax = 1; } @@ -1067,12 +1153,7 @@ fn RtlReAllocateHeap(emu: &mut emu::Emu) { None => 0, }; - log_red!( - emu, - "ntdll!RtlReAllocateHeap hndl: {:x} sz: {}", - hndl, - sz - ); + log_red!(emu, "ntdll!RtlReAllocateHeap hndl: {:x} sz: {}", hndl, sz); } fn NtFlushInstructionCache(emu: &mut emu::Emu) { @@ -1104,11 +1185,7 @@ fn LdrGetDllHandleEx(emu: &mut emu::Emu) { let dll_name = emu.maps.read_wide_string(dll_name_ptr); - log_red!( - emu, - "ntdll!LdrGetDllHandleEx {}", - dll_name - ); + log_red!(emu, "ntdll!LdrGetDllHandleEx {}", dll_name); let result = emu.maps.memcpy(path_ptr, dll_name_ptr, dll_name.len()); if result == false { @@ -1125,12 +1202,7 @@ fn NtTerminateThread(emu: &mut emu::Emu) { let handle = emu.regs().rcx; let exit_status = emu.regs().rdx; - log_red!( - emu, - "ntdll!NtTerminateThread {:x} {}", - handle, - exit_status - ); + log_red!(emu, "ntdll!NtTerminateThread {:x} {}", handle, exit_status); emu.regs_mut().rax = 0; } @@ -1147,10 +1219,7 @@ fn RtlAddFunctionTable(emu: &mut emu::Emu) { let entry_count = emu.regs().rdx; let base_address = emu.regs().r8; - log_red!( - emu, - "ntdll!RtlAddFunctionTable" - ); + log_red!(emu, "ntdll!RtlAddFunctionTable"); // TODO: do something with it @@ -1208,38 +1277,33 @@ fn strlen(emu: &mut emu::Emu) { let s = emu.maps.read_string(s_ptr as u64); let l = s.len(); - log_red!( - emu, - "ntdll!strlen: `{}` {}", - s, - l - ); + log_red!(emu, "ntdll!strlen: `{}` {}", s, l); emu.regs_mut().rax = l as u32 as u64; } fn NtSetInformationThread(emu: &mut emu::Emu) { - let thread_handle = emu.regs().rcx; - let thread_info_class = emu.regs().rdx; - let thread_info_ptr = emu.regs().r8; - let thread_info_length = emu.regs().r9; - - // TODO: Parse ThreadInformationClass values: - // - ThreadHideFromDebugger = 17 (common anti-debug technique) - // - ThreadBreakOnTermination = 18 - // - ThreadPriority = 0 - // - ThreadBasePriority = 3 - // - ThreadAffinityMask = 4 - // - ThreadImpersonationToken = 5 - // - ThreadQuerySetWin32StartAddress = 9 - // - ThreadZeroTlsCell = 16 - - // TODO: Read ThreadInformation data based on class and length - // TODO: Handle ThreadHideFromDebugger (sets thread to not be debugged) - // TODO: Handle other thread information classes as needed - // TODO: Validate thread_handle (GetCurrentThread() = -2, real handles > 0) - - log_red!( + let thread_handle = emu.regs().rcx; + let thread_info_class = emu.regs().rdx; + let thread_info_ptr = emu.regs().r8; + let thread_info_length = emu.regs().r9; + + // TODO: Parse ThreadInformationClass values: + // - ThreadHideFromDebugger = 17 (common anti-debug technique) + // - ThreadBreakOnTermination = 18 + // - ThreadPriority = 0 + // - ThreadBasePriority = 3 + // - ThreadAffinityMask = 4 + // - ThreadImpersonationToken = 5 + // - ThreadQuerySetWin32StartAddress = 9 + // - ThreadZeroTlsCell = 16 + + // TODO: Read ThreadInformation data based on class and length + // TODO: Handle ThreadHideFromDebugger (sets thread to not be debugged) + // TODO: Handle other thread information classes as needed + // TODO: Validate thread_handle (GetCurrentThread() = -2, real handles > 0) + + log_red!( emu, "ntdll!NtSetInformationThread handle: 0x{:x} class: {} info_ptr: 0x{:x} length: {}", thread_handle, @@ -1248,10 +1312,10 @@ fn NtSetInformationThread(emu: &mut emu::Emu) { thread_info_length ); - // TODO: Return appropriate NTSTATUS: - // - STATUS_SUCCESS = 0x00000000 - // - STATUS_INVALID_HANDLE = 0xC0000008 - // - STATUS_INVALID_PARAMETER = 0xC000000D - // - STATUS_INFO_LENGTH_MISMATCH = 0xC0000004 - emu.regs_mut().rax = 0x00000000; // STATUS_SUCCESS for now + // TODO: Return appropriate NTSTATUS: + // - STATUS_SUCCESS = 0x00000000 + // - STATUS_INVALID_HANDLE = 0xC0000008 + // - STATUS_INVALID_PARAMETER = 0xC000000D + // - STATUS_INFO_LENGTH_MISMATCH = 0xC0000004 + emu.regs_mut().rax = 0x00000000; // STATUS_SUCCESS for now } diff --git a/crates/libmwemu/src/winapi/winapi64/ole32.rs b/crates/libmwemu/src/winapi/winapi64/ole32.rs index a1b86682..596db0a2 100644 --- a/crates/libmwemu/src/winapi/winapi64/ole32.rs +++ b/crates/libmwemu/src/winapi/winapi64/ole32.rs @@ -37,10 +37,7 @@ HRESULT OleInitialize( ); */ fn OleInitialize(emu: &mut emu::Emu) { - log_red!( - emu, - "ole32!OleInitialize" - ); + log_red!(emu, "ole32!OleInitialize"); // TODO: do something emu.regs_mut().rax = 0; // S_OK } diff --git a/crates/libmwemu/src/winapi/winapi64/oleaut32.rs b/crates/libmwemu/src/winapi/winapi64/oleaut32.rs index bd27edd0..6e256a60 100644 --- a/crates/libmwemu/src/winapi/winapi64/oleaut32.rs +++ b/crates/libmwemu/src/winapi/winapi64/oleaut32.rs @@ -1,5 +1,6 @@ -use crate::emu; use crate::constants; +use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::winapi::winapi64::kernel32; //use crate::winapi::helper; @@ -47,24 +48,27 @@ fn SysAllocStringLen(emu: &mut emu::Emu) { str_ptr, char_count ); - + // Calculate exact sizes like the real API - let string_bytes = char_count * 2; // Requested characters in bytes + let string_bytes = char_count * 2; // Requested characters in bytes let total_alloc_size = 4 + string_bytes + 2 + 16; // Length prefix + string + null terminator // the extra 16 byes are not allocated on the // real winapi, but it's needed to allo some // optimizations - + // Allocate memory (no extra padding needed) - let bstr = emu.maps.alloc(total_alloc_size) + let bstr = emu + .maps + .alloc(total_alloc_size) .expect("oleaut32!SysAllocStringLen out of memory"); let name = format!("bstr_alloc_{:x}", bstr); - emu.maps.create_map(&name, bstr, total_alloc_size); - + emu.maps + .create_map(&name, bstr, total_alloc_size, Permission::READ_WRITE); + // Write length prefix (byte count of string data, excluding null terminator) emu.maps.write_dword(bstr, string_bytes as u32); - + if str_ptr == 0 { // Handle null input - zero out the string area for i in 0..char_count { @@ -78,12 +82,12 @@ fn SysAllocStringLen(emu: &mut emu::Emu) { emu.maps.write_word(bstr + 4 + (i * 2), wide_char); } } - + // Always write null terminator after the copied characters emu.maps.write_word(bstr + 4 + (char_count * 2), 0); - - let return_ptr = bstr + 4; // Return pointer to string data (after length prefix) - + + let return_ptr = bstr + 4; // Return pointer to string data (after length prefix) + log_red!( emu, "SysAllocStringLen returning: 0x{:x} (base: 0x{:x}, length_prefix: {})", @@ -91,18 +95,14 @@ fn SysAllocStringLen(emu: &mut emu::Emu) { bstr, string_bytes ); - + emu.regs_mut().rax = return_ptr; } fn SysFreeString(emu: &mut emu::Emu) { let str_ptr = emu.regs().rcx; - log_red!( - emu, - "oleaut32!SysFreeString 0x{:x}", - str_ptr - ); + log_red!(emu, "oleaut32!SysFreeString 0x{:x}", str_ptr); if str_ptr == 0 { // NULL pointer - nothing to free (this is valid behavior) @@ -111,12 +111,12 @@ fn SysFreeString(emu: &mut emu::Emu) { // BSTR pointer points to string data, but allocation starts 4 bytes earlier (length prefix) let alloc_base = str_ptr - 4; - + // Read the length from the prefix to know how much to zero out if let Some(length_bytes) = emu.maps.read_dword(alloc_base) { let total_size = 4 + length_bytes as u64 + 2; // prefix + string + null terminator let string_length = length_bytes / 2; // Convert bytes to characters - + log_red!( emu, "SysFreeString zeroing {} bytes starting at 0x{:x} (string data was {} bytes, {} chars)", @@ -128,7 +128,7 @@ fn SysFreeString(emu: &mut emu::Emu) { // String data in bytes string_length ); - + // Zero out the entire BSTR allocation for i in 0..total_size { emu.maps.write_byte(alloc_base + i, 0); @@ -136,8 +136,7 @@ fn SysFreeString(emu: &mut emu::Emu) { } else { panic!( "** {} SysFreeString: Could not read length prefix at 0x{:x}", - emu.pos, - alloc_base, + emu.pos, alloc_base, ); } @@ -155,9 +154,9 @@ INT SysReAllocStringLen( ); */ fn SysReAllocStringLen(emu: &mut emu::Emu) { - let pbstr_ptr = emu.regs().rcx; // Pointer to BSTR* - let psz = emu.regs().rdx; // Source string (can be NULL) - let len = emu.regs().r8; // Length in characters + let pbstr_ptr = emu.regs().rcx; // Pointer to BSTR* + let psz = emu.regs().rdx; // Source string (can be NULL) + let len = emu.regs().r8; // Length in characters log_red!( emu, @@ -175,20 +174,22 @@ fn SysReAllocStringLen(emu: &mut emu::Emu) { // Read the current BSTR pointer (might be NULL for first allocation) let old_bstr = emu.maps.read_qword(pbstr_ptr).unwrap_or(0); - + // Log old content if it exists if old_bstr != 0 { let old_alloc_base = old_bstr - 4; let old_len_bytes = emu.maps.read_dword(old_alloc_base).unwrap_or(0); let old_len_chars = old_len_bytes / 2; if old_len_chars > 0 { - let old_string = emu.maps.read_wide_string_n(old_bstr, old_len_chars as usize); + let old_string = emu + .maps + .read_wide_string_n(old_bstr, old_len_chars as usize); log_red!( - emu, - "Old BSTR content: \"{}\" (length: {} chars)", - old_string, - old_len_chars - ); + emu, + "Old BSTR content: \"{}\" (length: {} chars)", + old_string, + old_len_chars + ); } } @@ -196,27 +197,34 @@ fn SysReAllocStringLen(emu: &mut emu::Emu) { if psz != 0 && len > 0 { let new_string = emu.maps.read_wide_string_n(psz, len as usize); log_red!( - emu, - "New source string: \"{}\" (length: {} chars)", - new_string, - len - ); + emu, + "New source string: \"{}\" (length: {} chars)", + new_string, + len + ); } // Calculate allocation size - let byte_len = len * 2; // Length in bytes (UTF-16) - let total_alloc_size = 4 + byte_len + 2; // 4-byte prefix + string + null terminator - + let byte_len = len * 2; // Length in bytes (UTF-16) + let total_alloc_size = 4 + byte_len + 2; // 4-byte prefix + string + null terminator + // Always allocate new memory (simpler than trying to realloc) - let new_base = emu.maps.alloc(total_alloc_size + 100) + let new_base = emu + .maps + .alloc(total_alloc_size + 100) .expect("oleaut32!SysReAllocStringLen out of memory"); - + let name = format!("bstr_{:x}", new_base); - emu.maps.create_map(&name, new_base, total_alloc_size + 100); - + emu.maps.create_map( + &name, + new_base, + total_alloc_size + 100, + Permission::READ_WRITE, + ); + // Write length prefix (in bytes, not including null terminator) emu.maps.write_dword(new_base, byte_len as u32); - + // Copy data from source if provided if psz != 0 && len > 0 { emu.maps.memcpy(new_base + 4, psz, len as usize * 2); @@ -226,11 +234,12 @@ fn SysReAllocStringLen(emu: &mut emu::Emu) { let old_len_bytes = emu.maps.read_dword(old_alloc_base).unwrap_or(0); let old_len_chars = old_len_bytes / 2; let copy_len = std::cmp::min(len, old_len_chars as u64); - + if copy_len > 0 { - emu.maps.memcpy(new_base + 4, old_bstr, copy_len as usize * 2); + emu.maps + .memcpy(new_base + 4, old_bstr, copy_len as usize * 2); } - + // Zero out any remaining space if new length is longer than old length for i in copy_len..len { emu.maps.write_word(new_base + 4 + (i * 2), 0); @@ -241,30 +250,27 @@ fn SysReAllocStringLen(emu: &mut emu::Emu) { emu.maps.write_word(new_base + 4 + (i * 2), 0); } } - + // Write null terminator emu.maps.write_word(new_base + 4 + byte_len, 0); - + // Update the BSTR pointer to point to the string data (skip the 4-byte length prefix) let new_bstr = new_base + 4; emu.maps.write_qword(pbstr_ptr, new_bstr); - + // Log the final result if len > 0 { let final_string = emu.maps.read_wide_string_n(new_bstr, len as usize); log_red!( - emu, - "Final BSTR content: \"{}\" (length: {} chars)", - final_string, - len - ); + emu, + "Final BSTR content: \"{}\" (length: {} chars)", + final_string, + len + ); } else { - log_red!( - emu, - "Created empty BSTR" - ); + log_red!(emu, "Created empty BSTR"); } - + log_red!( emu, "oleaut32!SysReAllocStringLen allocated new string at 0x{:x} size: {} (base: 0x{:x})", @@ -275,7 +281,7 @@ fn SysReAllocStringLen(emu: &mut emu::Emu) { // Note: In a real implementation, you'd free the old BSTR here // but in an emulator, we might want to keep it for debugging - + emu.regs_mut().rax = constants::TRUE; } @@ -287,18 +293,11 @@ HRESULT VariantClear( fn VariantClear(emu: &mut emu::Emu) { let pvarg = emu.regs().rcx; - log_red!( - emu, - "oleaut32!VariantClear pvarg: 0x{:x}", - pvarg - ); + log_red!(emu, "oleaut32!VariantClear pvarg: 0x{:x}", pvarg); // Basic validation if pvarg == 0 || !emu.maps.is_mapped(pvarg) { - log_red!( - emu, - "VariantClear: Invalid pvarg pointer" - ); + log_red!(emu, "VariantClear: Invalid pvarg pointer"); emu.regs_mut().rax = 0x80070057; // E_INVALIDARG return; } @@ -307,10 +306,7 @@ fn VariantClear(emu: &mut emu::Emu) { // The vt field is typically at offset 0 in the VARIANT structure emu.maps.write_word(pvarg, 0); // VT_EMPTY = 0 - log_red!( - emu, - "VariantClear: Cleared variant (set vt to VT_EMPTY)" - ); + log_red!(emu, "VariantClear: Cleared variant (set vt to VT_EMPTY)"); emu.regs_mut().rax = 0; // S_OK } diff --git a/crates/libmwemu/src/winapi/winapi64/shell32.rs b/crates/libmwemu/src/winapi/winapi64/shell32.rs index 9cd0fe67..d5b44998 100644 --- a/crates/libmwemu/src/winapi/winapi64/shell32.rs +++ b/crates/libmwemu/src/winapi/winapi64/shell32.rs @@ -47,12 +47,7 @@ fn RealShellExecuteA(emu: &mut emu::Emu) { let file = emu.maps.read_string(file_ptr); let params = emu.maps.read_string(params_ptr); - log_red!( - emu, - "shell32!RealShellExecuteA {} {}", - file, - params - ); + log_red!(emu, "shell32!RealShellExecuteA {} {}", file, params); emu.regs_mut().rax = 34; } diff --git a/crates/libmwemu/src/winapi/winapi64/user32.rs b/crates/libmwemu/src/winapi/winapi64/user32.rs index 03efdb58..17d425df 100644 --- a/crates/libmwemu/src/winapi/winapi64/user32.rs +++ b/crates/libmwemu/src/winapi/winapi64/user32.rs @@ -44,21 +44,13 @@ fn MessageBoxA(emu: &mut emu::Emu) { let msg = emu.maps.read_string(msgptr); let title = emu.maps.read_string(titleptr); - log_red!( - emu, - "user32!MessageBoxA {} {}", - title, - msg - ); + log_red!(emu, "user32!MessageBoxA {} {}", title, msg); emu.regs_mut().rax = 0; } fn GetDesktopWindow(emu: &mut emu::Emu) { - log_red!( - emu, - "user32!GetDesktopWindow" - ); + log_red!(emu, "user32!GetDesktopWindow"); //emu.regs_mut().rax = 0x11223344; // current window handle emu.regs_mut().rax = 0; // no windows handler is more stealthy } @@ -70,11 +62,7 @@ int GetSystemMetrics( */ fn GetSystemMetrics(emu: &mut emu::Emu) { let nindex = emu.regs().rcx as usize; - log_red!( - emu, - "user32!GetSystemMetrics nindex: {}", - nindex - ); + log_red!(emu, "user32!GetSystemMetrics nindex: {}", nindex); // TODO: do something emu.regs_mut().rax = 0; } diff --git a/crates/libmwemu/src/winapi/winapi64/wincrt.rs b/crates/libmwemu/src/winapi/winapi64/wincrt.rs index 655558f0..6655887f 100644 --- a/crates/libmwemu/src/winapi/winapi64/wincrt.rs +++ b/crates/libmwemu/src/winapi/winapi64/wincrt.rs @@ -1,4 +1,5 @@ use crate::emu; +use crate::maps::mem64::Permission; use crate::serialization; use crate::winapi::winapi64; @@ -54,10 +55,7 @@ fn _initialize_onexit_table(emu: &mut emu::Emu) { 139 */ - log_red!( - emu, - "wincrt!_initialize_onexit_table" - ); + log_red!(emu, "wincrt!_initialize_onexit_table"); emu.regs_mut().rax = 0; } @@ -107,10 +105,7 @@ fn _get_initial_narrow_environment(emu: &mut emu::Emu) { // char*** CDECL __p___argv(void) { return &MSVCRT___argv; } fn __p___argv(emu: &mut emu::Emu) { - log_red!( - emu, - "wincrt!__p___argv" - ); + log_red!(emu, "wincrt!__p___argv"); // First, allocate space for argv array (pointer array) // We'll allocate space for 2 pointers - one for program name and null terminator @@ -118,8 +113,12 @@ fn __p___argv(emu: &mut emu::Emu) { .maps .alloc(16) // 2 * sizeof(pointer) on x64 .expect("wincrt!__p___argv cannot allocate argv array"); - emu.maps - .create_map(&format!("alloc_{:x}", argv_array_addr), argv_array_addr, 16); + emu.maps.create_map( + &format!("alloc_{:x}", argv_array_addr), + argv_array_addr, + 16, + Permission::READ_WRITE, + ); // Allocate space for program name string (using a dummy name) let prog_name = "program.exe\0"; @@ -127,8 +126,12 @@ fn __p___argv(emu: &mut emu::Emu) { .maps .alloc(prog_name.len() as u64) .expect("wincrt!__p___argv cannot allocate program name"); - emu.maps - .create_map(&format!("alloc_{:x}", prog_name_addr), prog_name_addr, 16); + emu.maps.create_map( + &format!("alloc_{:x}", prog_name_addr), + prog_name_addr, + 16, + Permission::READ_WRITE, + ); // Write program name string emu.maps.write_string(prog_name_addr, prog_name); @@ -144,8 +147,12 @@ fn __p___argv(emu: &mut emu::Emu) { .maps .alloc(8) // sizeof(pointer) on x64 .expect("wincrt!__p___argv cannot allocate p_argv"); - emu.maps - .create_map(&format!("alloc_{:x}", p_argv_addr), p_argv_addr, 8); + emu.maps.create_map( + &format!("alloc_{:x}", p_argv_addr), + p_argv_addr, + 8, + Permission::READ_WRITE, + ); // Write pointer to argv array emu.maps.write_qword(p_argv_addr, argv_array_addr); @@ -158,18 +165,18 @@ fn __p___argv(emu: &mut emu::Emu) { fn __p___argc(emu: &mut emu::Emu) { let argc = emu.regs().rcx; - log_red!( - emu, - "wincrt!__p___argc argc: 0x{:x}", - argc - ); + log_red!(emu, "wincrt!__p___argc argc: 0x{:x}", argc); let argc_addr = emu .maps .alloc(4) .expect("wincrt!__p___argc cannot allocate"); - emu.maps - .create_map(&format!("alloc_{:x}", argc_addr), argc_addr, 4); + emu.maps.create_map( + &format!("alloc_{:x}", argc_addr), + argc_addr, + 4, + Permission::READ_WRITE, + ); emu.maps.write_dword(argc_addr, 1); emu.regs_mut().rax = argc_addr; } @@ -184,11 +191,7 @@ FILE * CDECL __acrt_iob_func(int index) fn __acrt_iob_func(emu: &mut emu::Emu) { let index = emu.regs().rcx; - log_red!( - emu, - "wincrt!__acrt_iob_func index: 0x{:x}", - index - ); + log_red!(emu, "wincrt!__acrt_iob_func index: 0x{:x}", index); // TODO: Implement this emu.regs_mut().rax = 0; @@ -284,22 +287,23 @@ fn realloc(emu: &mut emu::Emu) { if addr == 0 { if size == 0 { + emu.maps.dealloc(addr); emu.regs_mut().rax = 0; return; } else { let base = emu.maps.alloc(size).expect("msvcrt!malloc out of memory"); + // normally malloc region is permission read write emu.maps - .create_map(&format!("alloc_{:x}", base), base, size) + .create_map( + &format!("alloc_{:x}", base), + base, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!malloc cannot create map"); - log_red!( - emu, - "msvcrt!realloc 0x{:x} {} =0x{:x}", - addr, - size, - base - ); + log_red!(emu, "msvcrt!realloc 0x{:x} {} =0x{:x}", addr, size, base); emu.regs_mut().rax = base; return; @@ -307,27 +311,27 @@ fn realloc(emu: &mut emu::Emu) { } if size == 0 { - log_red!( - emu, - "msvcrt!realloc 0x{:x} {} =0x1337", - addr, - size - ); + log_red!(emu, "msvcrt!realloc 0x{:x} {} =0x1337", addr, size); emu.regs_mut().rax = 0x1337; // weird msvcrt has to return a random unallocated pointer, and the program has to do free() on it return; } + let new_addr = emu.maps.alloc(size).expect("msvcrt!realloc out of memory"); let mem = emu .maps .get_mem_by_addr_mut(addr) .expect("msvcrt!realloc error getting mem"); + let old_permission = mem.permission(); let prev_size = mem.size(); - let new_addr = emu.maps.alloc(size).expect("msvcrt!realloc out of memory"); - emu.maps - .create_map(&format!("alloc_{:x}", new_addr), new_addr, size) + .create_map( + &format!("alloc_{:x}", new_addr), + new_addr, + size, + old_permission, + ) .expect("msvcrt!realloc cannot create map"); emu.maps.memcpy(new_addr, addr, prev_size); @@ -345,10 +349,7 @@ fn realloc(emu: &mut emu::Emu) { } fn set_invalid_parameter_handler(emu: &mut emu::Emu) { - log_red!( - emu, - "wincrt!_set_invalid_parameter_handler" - ); + log_red!(emu, "wincrt!_set_invalid_parameter_handler"); emu.regs_mut().rax = 0; } @@ -363,15 +364,15 @@ fn malloc(emu: &mut emu::Emu) { let base = emu.maps.alloc(size).expect("msvcrt!malloc out of memory"); emu.maps - .create_map(&format!("alloc_{:x}", base), base, size) + .create_map( + &format!("alloc_{:x}", base), + base, + size, + Permission::READ_WRITE, + ) .expect("msvcrt!malloc cannot create map"); - log_red!( - emu, - "msvcrt!malloc {} =0x{:x}", - size, - base - ); + log_red!(emu, "msvcrt!malloc {} =0x{:x}", size, base); emu.regs_mut().rax = base; } @@ -384,11 +385,7 @@ int _crt_atexit( fn _crt_atexit(emu: &mut emu::Emu) { let function = emu.regs().rcx; - log_red!( - emu, - "wincrt!_crt_atexit function: 0x{:x}", - function - ); + log_red!(emu, "wincrt!_crt_atexit function: 0x{:x}", function); // TODO: Implement this emu.regs_mut().rax = 0; } diff --git a/crates/libmwemu/src/winapi/winapi64/wininet.rs b/crates/libmwemu/src/winapi/winapi64/wininet.rs index abb3f4fb..3e3692ba 100644 --- a/crates/libmwemu/src/winapi/winapi64/wininet.rs +++ b/crates/libmwemu/src/winapi/winapi64/wininet.rs @@ -486,12 +486,7 @@ fn HttpSendRequestA(emu: &mut emu::Emu) { let hdrs = emu.maps.read_string(hdrs_ptr); let opt = emu.maps.read_string(opt_ptr); - log_red!( - emu, - "wininet!HttpSendRequestA hdrs: {} opt: {}", - hdrs, - opt - ); + log_red!(emu, "wininet!HttpSendRequestA hdrs: {} opt: {}", hdrs, opt); if !helper::handler_exist(req_hndl) { log::info!("\tinvalid handle."); @@ -519,12 +514,7 @@ fn HttpSendRequestW(emu: &mut emu::Emu) { let hdrs = emu.maps.read_wide_string(hdrs_ptr); let opt = emu.maps.read_wide_string(opt_ptr); - log_red!( - emu, - "wininet!HttpSendRequestW hdrs: {} opt: {}", - hdrs, - opt - ); + log_red!(emu, "wininet!HttpSendRequestW hdrs: {} opt: {}", hdrs, opt); if !helper::handler_exist(req_hndl) { log::info!("\tinvalid handle."); @@ -542,11 +532,7 @@ fn HttpSendRequestW(emu: &mut emu::Emu) { fn InternetErrorDlg(emu: &mut emu::Emu) { let err = emu.regs().rcx; - log_red!( - emu, - "wininet!InternetErrorDlg err: {}", - err - ); + log_red!(emu, "wininet!InternetErrorDlg err: {}", err); emu.regs_mut().rax = 0; } @@ -595,11 +581,7 @@ fn InternetReadFileExA(emu: &mut emu::Emu) { let flags = emu.regs().r8; let ctx = emu.regs().r9; - log_red!( - emu, - "wininet!InternetReadFileExA buff: 0x{:x}", - buff_ptr - ); + log_red!(emu, "wininet!InternetReadFileExA buff: 0x{:x}", buff_ptr); if !helper::handler_exist(file_hndl) { log::info!("\tinvalid handle."); @@ -614,11 +596,7 @@ fn InternetReadFileExW(emu: &mut emu::Emu) { let flags = emu.regs().r8; let ctx = emu.regs().r9; - log_red!( - emu, - "wininet!InternetReadFileExW buff: 0x{:x}", - buff_ptr - ); + log_red!(emu, "wininet!InternetReadFileExW buff: 0x{:x}", buff_ptr); if !helper::handler_exist(file_hndl) { log::info!("\tinvalid handle."); diff --git a/crates/libmwemu/src/winapi/winapi64/ws2_32.rs b/crates/libmwemu/src/winapi/winapi64/ws2_32.rs index 37bda042..ea426004 100644 --- a/crates/libmwemu/src/winapi/winapi64/ws2_32.rs +++ b/crates/libmwemu/src/winapi/winapi64/ws2_32.rs @@ -5,6 +5,7 @@ use crate::structures::*; use crate::winapi::helper; use crate::winapi::winapi64; +use crate::maps::mem64::Permission; use lazy_static::lazy_static; use std::sync::Mutex; @@ -66,28 +67,19 @@ lazy_static! { } fn WsaStartup(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!WsaStartup" - ); + log_red!(emu, "ws2_32!WsaStartup"); emu.regs_mut().rax = 0; } fn WsaSocketA(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!WsaSocketA" - ); + log_red!(emu, "ws2_32!WsaSocketA"); emu.regs_mut().rax = helper::socket_create(); } fn socket(emu: &mut emu::Emu) { - log_red!( - emu, - "ws2_32!socket" - ); + log_red!(emu, "ws2_32!socket"); emu.regs_mut().rax = helper::socket_create(); } @@ -96,11 +88,7 @@ fn WsaHtons(emu: &mut emu::Emu) { let host_port = emu.regs().rdx; let out_port = emu.regs().r8; - log_red!( - emu, - "ws2_32!WsaHtons {}", - host_port - ); + log_red!(emu, "ws2_32!WsaHtons {}", host_port); //TODO: implement this emu.regs_mut().rax = 0; @@ -109,11 +97,7 @@ fn WsaHtons(emu: &mut emu::Emu) { fn htons(emu: &mut emu::Emu) { let port: u16 = emu.regs().rcx as u16; - log_red!( - emu, - "ws2_32!htons port: {}", - port - ); + log_red!(emu, "ws2_32!htons port: {}", port); emu.regs_mut().rax = port.to_be() as u64; } @@ -123,10 +107,7 @@ fn inet_addr(emu: &mut emu::Emu) { //TODO: derreferece addr - log_red!( - emu, - "ws2_32!inet_addr" - ); + log_red!(emu, "ws2_32!inet_addr"); emu.regs_mut().rax = 0; } @@ -156,13 +137,7 @@ fn connect(emu: &mut emu::Emu) { (ip & 0xff0000) >> 16, (ip & 0xff000000) >> 24 ); - log_red!( - emu, - "ws2_32!connect family: {} {}:{}", - family, - sip, - port - ); + log_red!(emu, "ws2_32!connect family: {} {}:{}", family, sip, port); if emu.cfg.endpoint { /* @@ -190,12 +165,7 @@ fn recv(emu: &mut emu::Emu) { let mut len = emu.regs().r8; let flags = emu.regs().r9; - log_red!( - emu, - "ws2_32!recv buff: 0x{:x} sz: {}", - buff, - len - ); + log_red!(emu, "ws2_32!recv buff: 0x{:x} sz: {}", buff, len); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -227,7 +197,9 @@ fn recv(emu: &mut emu::Emu) { } else { if emu.maps.overflow_predicted(buff, len) { if emu.cfg.verbose > 0 { - log::info!("/!\\ on this asm, the recv overflows the buffer, canceled the write!"); + log::info!( + "/!\\ on this asm, the recv overflows the buffer, canceled the write!" + ); } } else { emu.maps.memset(buff, 0x90, len as usize); @@ -247,11 +219,7 @@ fn send(emu: &mut emu::Emu) { let bytes = emu.maps.read_string_of_bytes(buff, len as usize); - log_red!( - emu, - "ws2_32!send {{{}}}", - bytes - ); + log_red!(emu, "ws2_32!send {{{}}}", bytes); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -323,11 +291,7 @@ fn listen(emu: &mut emu::Emu) { let sock = emu.regs().rcx; let connections = emu.regs().rdx; - log_red!( - emu, - "ws2_32!listen connections: {}", - connections - ); + log_red!(emu, "ws2_32!listen connections: {}", connections); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -345,11 +309,7 @@ fn accept(emu: &mut emu::Emu) { let bytes = emu.maps.read_string_of_bytes(saddr, len as usize); - log_red!( - emu, - "ws2_32!accept connections: {}", - bytes - ); + log_red!(emu, "ws2_32!accept connections: {}", bytes); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -362,10 +322,7 @@ fn accept(emu: &mut emu::Emu) { fn closesocket(emu: &mut emu::Emu) { let sock = emu.regs().rcx; - log_red!( - emu, - "ws2_32!closesocket" - ); + log_red!(emu, "ws2_32!closesocket"); helper::socket_close(sock); @@ -417,12 +374,7 @@ fn getsockopt(emu: &mut emu::Emu) { emu.maps.write_dword(optval, 1); - log_red!( - emu, - "ws2_32!getsockopt lvl: {} opt: {}", - level, - optname - ); + log_red!(emu, "ws2_32!getsockopt lvl: {} opt: {}", level, optname); if !helper::socket_exist(sock) { log::info!("\tinvalid socket."); @@ -467,11 +419,7 @@ fn GetSockName(emu: &mut emu::Emu) { emu.maps.write_dword(sockaddr_ptr, 0); emu.maps.write_dword(namelen_ptr, 4); - log_red!( - emu, - "ws2_32!GetSockName sock: {}", - sock - ); + log_red!(emu, "ws2_32!GetSockName sock: {}", sock); emu.regs_mut().rax = 0; } @@ -480,17 +428,13 @@ fn gethostbyname(emu: &mut emu::Emu) { let domain_name_ptr = emu.regs().rcx; let domain_name = emu.maps.read_string(domain_name_ptr); - log_red!( - emu, - "ws2_32!gethostbyname `{}`", - domain_name - ); + log_red!(emu, "ws2_32!gethostbyname `{}`", domain_name); let addr = emu.maps.alloc(1024).expect("low memory"); let str_addr = addr + 1024 - 100; let mem = emu .maps - .create_map("hostent", addr, 1024) + .create_map("hostent", addr, 1024, Permission::READ_WRITE) .expect("cannot create hostent map"); mem.write_dword(addr, 0x04030201); mem.write_qword(addr + 8, addr); diff --git a/crates/mwemu/src/main.rs b/crates/mwemu/src/main.rs index b4d8b2fd..0fce70c7 100644 --- a/crates/mwemu/src/main.rs +++ b/crates/mwemu/src/main.rs @@ -2,14 +2,14 @@ extern crate clap; -use std::{panic, process}; use clap::{App, Arg}; use libmwemu::emu32; use libmwemu::emu64; use libmwemu::serialization; +use std::{panic, process}; //use libmwemu::definitions; -use fast_log::{Config}; use fast_log::appender::{Command, FastLogRecord, RecordFormat}; +use fast_log::Config; macro_rules! match_register_arg { ($matches:expr, $emu:expr, $reg:expr) => { @@ -76,7 +76,6 @@ impl CustomLogFormat { pub fn new() -> CustomLogFormat { Self {} } - } fn main() { @@ -196,7 +195,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); } if matches.is_present("trace_filename") { let trace_filename = matches @@ -214,16 +213,18 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); } // verbose_at if matches.is_present("verbose_at") { - emu.cfg.verbose_at = Some(matches - .value_of("verbose_at") - .expect("select the number of moment to enable verbose") - .parse::() - .expect("select a valid number where to enable verbosity")); + emu.cfg.verbose_at = Some( + matches + .value_of("verbose_at") + .expect("select the number of moment to enable verbose") + .parse::() + .expect("select a valid number where to enable verbosity"), + ); } // console @@ -279,7 +280,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); if !matches.is_present("entry_point") { log::error!("if the code base is selected, you have to select the entry point ie -b 0x600000 -a 0x600000"); std::process::exit(1); @@ -295,7 +296,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); } // register values @@ -324,7 +325,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); emu.flags_mut().load(value as u32); } if matches.is_present("mxcsr") { @@ -335,7 +336,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); emu.fpu_mut().mxcsr = value as u32; } @@ -356,7 +357,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); emu.spawn_console_at_addr(emu.cfg.console_addr); } @@ -369,7 +370,7 @@ fn main() { .trim_start_matches("0x"), 16, ) - .expect("invalid address"); + .expect("invalid address"); } // exit position @@ -380,14 +381,12 @@ fn main() { emu.cfg.exit_position = if exit_pos_str.starts_with("0x") { // Handle hexadecimal format - u64::from_str_radix( - exit_pos_str.trim_start_matches("0x"), - 16 - ) + u64::from_str_radix(exit_pos_str.trim_start_matches("0x"), 16) } else { // Handle decimal format exit_pos_str.parse::() - }.expect("invalid position"); + } + .expect("invalid position"); } // stack trace @@ -412,29 +411,48 @@ fn main() { // cmd if matches.is_present("cmd") { - emu.cfg.command = Some(matches.value_of("cmd").expect("specify the console command").to_string()); + emu.cfg.command = Some( + matches + .value_of("cmd") + .expect("specify the console command") + .to_string(), + ); } // args if matches.is_present("args") { - log::info!("espeicificando argumentos: {}", matches.value_of("args").expect("specify the argument string").to_string()); - emu.cfg.arguments = matches.value_of("args").expect("specify the argument string").to_string(); + log::info!( + "espeicificando argumentos: {}", + matches + .value_of("args") + .expect("specify the argument string") + .to_string() + ); + emu.cfg.arguments = matches + .value_of("args") + .expect("specify the argument string") + .to_string(); } // log to file if matches.is_present("log") { let filename = matches.value_of("log").expect("log filename is missing"); emu.colors.disable(); - fast_log::init(Config::new() - .format(CustomLogFormat::new()) - .file(filename) - .chan_len(Some(100000))).unwrap(); - + fast_log::init( + Config::new() + .format(CustomLogFormat::new()) + .file(filename) + .chan_len(Some(100000)), + ) + .unwrap(); } else { - fast_log::init(Config::new() - .format(CustomLogFormat::new()) - .console() - .chan_len(Some(100000))).unwrap(); + fast_log::init( + Config::new() + .format(CustomLogFormat::new()) + .console() + .chan_len(Some(100000)), + ) + .unwrap(); } // definitions @@ -456,7 +474,7 @@ fn main() { ); } }); - + // flush all the log log::logger().flush(); // invoke the default handler and exit the process @@ -480,7 +498,7 @@ fn main() { emu.maps.set_banzai(emu.cfg.skip_unimplemented); } - // script + // script if matches.is_present("script") { emu.disable_ctrlc(); let mut script = libmwemu::script::Script::new(); @@ -489,23 +507,23 @@ fn main() { .value_of("script") .expect("select a script filename"), ); - + // Run script script.run(&mut emu); - + // Clear the current emu libmwemu::emu_context::clear_current_emu(); } else { if matches.is_present("handle") { - emu.cfg.console_enabled = true; + emu.cfg.console_enabled = true; emu.enable_ctrlc(); } - + let result = emu.run(None); - + // Clear the current emu libmwemu::emu_context::clear_current_emu(); - + log::logger().flush(); result.unwrap(); } diff --git a/crates/pymwemu/src/lib.rs b/crates/pymwemu/src/lib.rs index bddfb406..54279cba 100644 --- a/crates/pymwemu/src/lib.rs +++ b/crates/pymwemu/src/lib.rs @@ -1,5 +1,5 @@ -use iced_x86::{Formatter}; use env_logger::Env; +use iced_x86::Formatter; use std::io::Write as _; use pyo3::exceptions::PyValueError; @@ -8,6 +8,7 @@ use pyo3::prelude::*; use libmwemu::console::Console; use libmwemu::emu32; use libmwemu::emu64; +use libmwemu::maps::mem64::Permission; #[pyclass(unsendable)] pub struct Emu { @@ -25,7 +26,9 @@ impl Emu { /// get last emulated mnemonic with name and parameters. fn get_prev_mnemonic(&mut self) -> PyResult { let mut output = String::new(); - self.emu.formatter.format(&self.emu.instruction.unwrap(), &mut output); + self.emu + .formatter + .format(&self.emu.instruction.unwrap(), &mut output); Ok(output.clone()) } @@ -284,14 +287,14 @@ impl Emu { /// allocate a buffer on the emulated process address space. fn alloc(&mut self, name: &str, size: u64) -> PyResult { - Ok(self.emu.alloc(name, size)) + Ok(self.emu.alloc(name, size, Permission::READ_WRITE_EXECUTE)) } /// allocate at specific address fn alloc_at(&mut self, name: &str, addr: u64, size: u64) { self.emu .maps - .create_map(name, addr, size) + .create_map(name, addr, size, Permission::READ_WRITE_EXECUTE) .expect("pymwemu alloc_at out of memory"); } @@ -300,7 +303,7 @@ impl Emu { let map = self .emu .maps - .create_map(name, base_addr, 1) + .create_map(name, base_addr, 1, Permission::READ_WRITE_EXECUTE) .expect("pymwemu load_map out of memory"); map.load(filename); } @@ -870,4 +873,3 @@ fn pymwemu(_py: Python, m: &PyModule) -> PyResult<()> { m.add_function(wrap_pyfunction!(init64, m)?)?; Ok(()) } - diff --git a/maps/maps64/oleaut32.dll.i64 b/maps/maps64/oleaut32.dll.i64 new file mode 100644 index 00000000..9e367761 Binary files /dev/null and b/maps/maps64/oleaut32.dll.i64 differ