basic of dll

Author: Whitecat18

dll_injection/callfunc_dll.rs

@@ -0,0 +1,55 @@
+use std::ffi::CString;
+use winapi::um::libloaderapi::{FreeLibrary, GetProcAddress, LoadLibraryA};
+
+const PLU: &str = "[+]";
+
+// Some shit i tried . dont laugh at me @_@
+// fn calling(handle:*mut HINSTANCE__ ,name: &str) -> *mut __some_function{
+//     let name_cstr = Cstring::new(name).unwrap();
+//     let name_cstr_ptr = unsafe {
+//         GetProcAddress(handle, name_cstr.as_ptr());   
+//     };
+//     return name_cstr_ptr
+// }
+
+fn main(){
+    let dll_path = "hook.dll";
+    unsafe{
+        let dll_path_cstr = CString::new(dll_path).expect("Failed CString");
+        let dll_path_ptr = dll_path_cstr.as_ptr();
+        let handle = LoadLibraryA(dll_path_ptr);
+        if handle.is_null(){
+            println!("Failed to load DLL");
+            return;
+        }
+
+        let name = CString::new("msg_frm_vx").unwrap();
+        let name_ptr = GetProcAddress(handle, name.as_ptr());
+
+        let name1 = CString::new("msg_frm_smukx").unwrap();
+        let name_ptr1 = GetProcAddress(handle, name1.as_ptr());
+
+
+        if name_ptr.is_null(){
+            println!("{} Failed to get function Address for vx",PLU);
+            FreeLibrary(handle);
+            return;
+        }
+
+        if name_ptr1.is_null(){
+            println!("{} Failed to get function Address for smukx",PLU);
+            FreeLibrary(handle);
+            return;
+        }
+                        //unsafe
+        type MyFunction = extern "stdcall" fn();
+
+        let my_func: MyFunction = std::mem::transmute(name_ptr);
+        let my_func1: MyFunction = std::mem::transmute(name_ptr1);
+        //exec the func
+        my_func();
+        my_func1();
+
+        FreeLibrary(handle); 
+    }
+}

dll_injection/hook.dll.rs

@@ -0,0 +1,27 @@
+use std::{ffi::CString, ptr::null_mut};
+use winapi::um::winuser::{MessageBoxA, MB_OK};
+
+/*
+    #[no_mangle] Short Explain
+    - no_mangle is used to interoperate with C code meaning we can call 
+        these functions directly from C without any naming conflicts.
+    - It can also used to keep its original name during the compile time.
+*/
+#[no_mangle]
+pub extern "stdcall" fn msg_frm_vx(){
+    let msg = CString::new("DLL's are awesome ! Especially Exec in Rust").expect("Failed");
+    let cap = CString::new("Message From Vx-Underground").expect("Error cap");
+    unsafe{
+        MessageBoxA(null_mut(), msg.as_ptr(), cap.as_ptr(), MB_OK);
+    }
+}
+
+// stdcall in C
+#[no_mangle]
+pub extern "system" fn msg_frm_smukx(){
+    let msg = CString::new("Custom DLL's are always Cool. Bye").expect("Failed");
+    let cap = CString::new("Message From SMukx").expect("Error cap");
+    unsafe{
+        MessageBoxA(null_mut(), msg.as_ptr(), cap.as_ptr(), MB_OK);
+    }
+}