This Repository is a collection of different ethical hacking tools and malware's for penetration testing and research purpose written in python, ruby, rust, c++, go and c.
JavaScript algorithmsartificial-intelligencebugbountycryptographycyber-threat-intelligencecybersecurity-projectsethical-hackinghacking-toolsmalwarenessusnetwork-monitoringnetwork-securitynmapportscannerpythonpythonprojectsthreat-intelligencevirus-scanning
Create main.rs
Abdul Wahab Junaid5b572e90197a
diff --git a/Rust for Hacking/obfuscation/src/main.rs b/Rust for Hacking/obfuscation/src/main.rsnew file mode 100644index 0000000..cb50e91--- /dev/null+++ b/Rust for Hacking/obfuscation/src/main.rs@@ -0,0 +1,230 @@+/*+ Shellcode Obfuscation and Deobfuscation Technique+ Wonderful Resource By Maldev Academy+ @5mukx+*/++use std::fs::File;+use std::io::{Read, Write, BufReader, BufRead};+use std::net::{Ipv4Addr, Ipv6Addr};+use uuid::Uuid;+use clap::{Parser, ValueEnum};++#[derive(Parser)]+#[clap(about = "Shellcode Obfuscation and Deobfuscation Technique")]+pub struct Args {+ #[clap(short, long, required = true, help = "Enter shellcode file")]+ pub file: String,++ #[clap(short, long, required = true, help = "Enter obfuscation type")]+ pub technique: Obfuscation,++ #[clap(short, long, required = true, help = "Specify whether to obfuscate or deobfuscate")]+ pub operation: Operation,+}++#[derive(ValueEnum, Clone, Debug)]+pub enum Obfuscation {+ IPV4,+ IPV6,+ MAC,+ UUID,+}++#[derive(ValueEnum, Clone, Debug)]+pub enum Operation {+ Obfuscate,+ Deobfuscate,+}++// IPv4 Obfuscation+fn obfuscate_ipv4(shellcode: &mut Vec<u8>, output_file: &str) {+ if shellcode.len() % 4 != 0 {+ while shellcode.len() % 4 != 0 {+ shellcode.push(0);+ }+ }+ let mut file = File::create(output_file).expect("Could not create output file");+ for ip_addr in shellcode.chunks(4) {+ let ip = format!("{}.{}.{}.{}", ip_addr[0], ip_addr[1], ip_addr[2], ip_addr[3]);+ writeln!(file, "{}", ip).expect("Could not write to output file");+ }+}++fn deobfuscate_ipv4(file: &str) -> Result<Vec<u8>, ()> {+ let file = File::open(file).map_err(|_| ())?;+ let reader = BufReader::new(file);+ let mut debug: Vec<u8> = Vec::new();++ for line in reader.lines() {+ let ip = line.unwrap().trim().to_string();+ match ip.parse::<Ipv4Addr>() {+ Ok(ip_addr) => debug.extend_from_slice(&ip_addr.octets()),+ Err(_) => return Err(()),+ }+ }+ Ok(debug)+}++// IPv6 Obfuscation+fn obfuscate_ipv6(shellcode: &mut Vec<u8>, output_file: &str) {+ if shellcode.len() % 16 != 0 {+ while shellcode.len() % 16 != 0 {+ shellcode.push(0);+ }+ }+ let mut file = File::create(output_file).expect("Could not create output file");+ for chunk in shellcode.chunks(16) {+ let ip = format!(+ "{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}:{:02x}{:02x}",+ chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7],+ chunk[8], chunk[9], chunk[10], chunk[11], chunk[12], chunk[13], chunk[14], chunk[15]+ );+ writeln!(file, "{}", ip).expect("Could not write to output file");+ }+}++fn deobfuscate_ipv6(file: &str) -> Result<Vec<u8>, ()> {+ let file = File::open(file).map_err(|_| ())?;+ let reader = BufReader::new(file);+ let mut deobfuscated_ips: Vec<u8> = Vec::new();++ for line in reader.lines() {+ let ip = line.unwrap().trim().to_string();+ match ip.parse::<Ipv6Addr>() {+ Ok(ip_addr) => {+ for segment in ip_addr.segments() {+ deobfuscated_ips.extend_from_slice(&segment.to_be_bytes());+ }+ }+ Err(_) => return Err(()),+ }+ }++ Ok(deobfuscated_ips)+}++// MAC Obfuscation+fn obfuscate_mac(shellcode: &mut Vec<u8>, output_file: &str) {+ let mut file = File::create(output_file).expect("Could not create output file");++ let mac_addresses: Vec<String> = shellcode+ .chunks(6)+ .map(|chunk| {+ chunk+ .iter()+ .map(|byte| format!("{:02X}", byte))+ .collect::<Vec<String>>()+ .join(":")+ })+ .collect();++ for mac in &mac_addresses {+ writeln!(file, "{}", mac).expect("Could not write to output file");+ }+}++fn deobfuscate_mac(file: &str) -> Result<Vec<u8>, ()> {+ let file = File::open(file).map_err(|_| ())?;+ let reader = BufReader::new(file);+ let mut original_ints: Vec<u8> = Vec::new();++ for line in reader.lines() {+ let mac = line.unwrap().trim().to_string();+ let bytes: Vec<u8> = mac+ .split(':')+ .map(|byte_str| u8::from_str_radix(byte_str, 16).unwrap())+ .collect();+ original_ints.extend_from_slice(&bytes);+ }++ Ok(original_ints)+}++// UUID Obfuscation+fn obfuscate_uuid(shellcode: &mut Vec<u8>, output_file: &str) {+ let mut file = File::create(output_file).expect("Could not create output file");+ let uuids: Vec<Uuid> = shellcode+ .chunks(16)+ .map(|chunk| {+ let mut array = [0; 16];+ for (i, &byte) in chunk.iter().enumerate() {+ array[i] = byte;+ }+ Uuid::from_bytes(array)+ })+ .collect();++ for uuid in &uuids {+ writeln!(file, "{}", uuid).expect("Could not write to output file");+ }+}++fn deobfuscate_uuid(file: &str) -> Result<Vec<u8>, ()> {+ let file = File::open(file).map_err(|_| ())?;+ let reader = BufReader::new(file);+ let mut desofuscated_bytes = Vec::new();++ for line in reader.lines() {+ let uuid_str = line.unwrap().trim().to_string();+ match Uuid::parse_str(&uuid_str) {+ Ok(uuid) => {+ desofuscated_bytes.extend_from_slice(uuid.as_bytes());+ }+ Err(_) => return Err(()),+ }+ }++ Ok(desofuscated_bytes)+}++fn main() -> std::io::Result<()> {+ let argument = Args::parse();+ let file = argument.file;+ let technique = argument.technique;+ let operation = argument.operation;+ let mut shellcode = File::open(&file)?;+ let mut buffer: Vec<u8> = Vec::new();+ shellcode.read_to_end(&mut buffer)?;++ match operation {+ Operation::Obfuscate => {+ match technique {+ Obfuscation::IPV4 => {+ obfuscate_ipv4(&mut buffer, "obfuscated_ipv4.txt");+ }+ Obfuscation::IPV6 => {+ obfuscate_ipv6(&mut buffer, "obfuscated_ipv6.txt");+ },+ Obfuscation::MAC => {+ obfuscate_mac(&mut buffer, "obfuscated_mac.txt");+ }+ Obfuscation::UUID => {+ obfuscate_uuid(&mut buffer, "obfuscated_uuid.txt");+ }+ }+ println!("Obfuscation successful, output written to file.");+ }+ Operation::Deobfuscate => {+ let result = match technique {+ Obfuscation::IPV4 => deobfuscate_ipv4(&file),+ Obfuscation::IPV6 => deobfuscate_ipv6(&file),+ Obfuscation::MAC => deobfuscate_mac(&file),+ Obfuscation::UUID => deobfuscate_uuid(&file),+ };++ match result {+ Ok(deobfuscated) => {+ let mut output_file = File::create("deobfuscated_output.bin")?;+ output_file.write_all(&deobfuscated)?;+ println!("Deobfuscation successful, output written to deobfuscated_output.bin");+ }+ Err(_) => {+ eprintln!("Deobfuscation failed");+ }+ }+ }+ };++ Ok(())+}