सामग्री

• SilentMoonWalk
  • विवरण
  • श्रेय
  • उपयोग
    • call_function!() मैक्रो
    • indirect_syscall!() मैक्रो
    • पैरामीटर पास करना
  • उदाहरण
    • kernel32.dll!Sleep() को कॉल करना
    • kernel32.dll!OpenProcess() को कॉल करना
    • NtDelayExecution() को अप्रत्यक्ष syscall के रूप में कॉल करना
    • मैक्रो कॉल्स को जोड़ना
  • विचारणीय बातें
    • प्रारंभिक फ्रेम
    • PoC
• स्टैक प्रतिस्थापन
  • विवरण
  • उपयोग
  • व्यावहारिक उदाहरण
  • टिप्पणियाँ

SilentMoonWalk

विवरण

Unwinder, SilentMoonWalk तकनीक का पूर्ण शस्त्रीकरण प्रदान करता है, जो Rust में पूर्ण और स्थिर कॉल स्टैक स्पूफिंग प्राप्त करने की अनुमति देता है।

इस तकनीक में निम्नलिखित विशेषताएँ हैं:

• किसी भी मनमाने फ़ंक्शन को अधिकतम 11 पैरामीटर के साथ चलाने का समर्थन।
• अप्रत्यक्ष syscalls (बिना अतिरिक्त heap आवंटन के) को अधिकतम 11 पैरामीटर के साथ चलाने का समर्थन।
• यह क्रेट इसके माध्यम से बुलाए गए फ़ंक्शनों द्वारा लौटाए गए मान को प्राप्त करने की अनुमति देता है।
• स्पूफिंग प्रक्रिया को कॉल स्टैक आकार बढ़ाए बिना कितनी भी बार जोड़ा जा सकता है।
• स्पूफिंग प्रक्रिया के दौरान दक्षता बढ़ाने के लिए TLS का उपयोग किया जाता है।
• क्रेट के लिए आवश्यक किसी भी Windows API कॉल को करने के लिए dinvoke_rs का उपयोग किया जाता है।

श्रेय

SilentMoonWalk तकनीक के निर्माताओं को धन्यवाद:

• KlezVirus
• Waldo-IRC
• Trickster0

और निश्चित रूप से namazso को उस Twitter थ्रेड के लिए एक बड़ा धन्यवाद, जिसने इस पूरे प्रोजेक्ट को प्रेरित किया।

उपयोग

इस क्रेट को अपने प्रोजेक्ट में आयात करने के लिए अपने cargo.toml में निम्नलिखित पंक्ति जोड़ें और release मोड पर कंपाइल करें:

[dependencies]
unwinder = "=0.1.4"

इस क्रेट की मुख्य कार्यक्षमता को दो मैक्रोज़ में लपेटा गया है:

• call_function!() मैक्रो एक साफ कॉल स्टैक के साथ किसी भी मनमाने फ़ंक्शन को चलाने की अनुमति देता है।
• indirect_syscall!() मैक्रो एक साफ कॉल स्टैक के साथ निर्दिष्ट (अप्रत्यक्ष) syscall निष्पादित करता है।

इनमें से किसी भी मैक्रो का उपयोग करने के लिए std::ffi::c_void डेटा प्रकार को आयात करना आवश्यक है।

दोनों मैक्रोज़ एक *mut c_void लौटाते हैं जिसका उपयोग निष्पादित फ़ंक्शन द्वारा लौटाए गए मान को प्राप्त करने के लिए किया जा सकता है। अधिक विस्तृत जानकारी उदाहरण अनुभाग में दी गई है।

call_function मैक्रो

इस मैक्रो का उपयोग एक साफ कॉल स्टैक के साथ किसी भी वांछित फ़ंक्शन को कॉल करने के लिए किया जाता है। मैक्रो निम्नलिखित पैरामीटर की अपेक्षा करता है:

• पहला पैरामीटर कॉल स्टैक स्पूफ करने के बाद कॉल करने के लिए मेमोरी एड्रेस है। यह पैरामीटर usize, isize या पॉइंटर के रूप में पास किया जाना चाहिए।
• दूसरा पैरामीटर एक bool है जो दर्शाता है कि स्टार्ट फ़ंक्शन फ्रेम को रखना है या नहीं। यदि आप इसके बारे में निश्चित नहीं हैं, तो इसे false पर सेट करें, जो हमेशा एक अच्छे कॉल स्टैक की गारंटी देता है।
• अगले पैरामीटर वे तर्क हैं जो कॉल स्टैक स्पूफ हो जाने के बाद फ़ंक्शन को भेजने हैं।

indirect_syscall मैक्रो

इस मैक्रो का उपयोग एक साफ कॉल स्टैक के साथ किसी भी वांछित अप्रत्यक्ष syscall को करने के लिए किया जाता है। मैक्रो निम्नलिखित पैरामीटर की अपेक्षा करता है:

• पहला पैरामीटर एक स्ट्रिंग है जिसमें NT फ़ंक्शन का नाम होता है जिसका syscall आप निष्पादित करना चाहते हैं।
• दूसरा पैरामीटर एक bool है जो दर्शाता है कि स्टार्ट फ़ंक्शन फ्रेम को रखना है या नहीं। यदि आप इसके बारे में निश्चित नहीं हैं, तो इसे false पर सेट करें, जो हमेशा एक अच्छे कॉल स्टैक की गारंटी देता है।
• अगले पैरामीटर वे तर्क हैं जो NT फ़ंक्शन को भेजने हैं।

पैरामीटर पास करना

इन दोनों मैक्रोज़ में विभिन्न प्रकार के तर्क पास करने के लिए, निम्नलिखित बातों को ध्यान में रखा जाना चाहिए:

• कोई भी मूल डेटा प्रकार जिसे usize (u8-u64, i8-i64, bool, आदि) में परिवर्तित किया जा सकता है, सीधे मैक्रोज़ में पास किया जा सकता है।
• 8, 16, 32 या 64 बिट आकार की संरचनाएँ और यूनियनें ऐसे पास की जाती हैं जैसे कि वे समान आकार के पूर्णांक हों।
• 64 बिट से बड़े आकार की संरचनाएँ और यूनियनें पॉइंटर के रूप में पास की जानी चाहिए।
• स्ट्रिंग्स (&str और String) को पॉइंटर के रूप में पास किया जाना चाहिए।
• नल पॉइंटर्स (ptr::null(), ptr::null_mut(), आदि) को 0 के रूप में पास किया जाता है (चाहे वह u8, u16, i32 या कोई अन्य हो)।
• फ्लोटिंग-पॉइंट और डबल-प्रिसिजन पैरामीटर वर्तमान में समर्थित नहीं हैं।
• किसी भी अन्य डेटा प्रकार को पॉइंटर के रूप में पास किया जाना चाहिए।

उदाहरण

Sleep को कॉल करना

let k32 = dinvoke_rs::dinvoke::get_module_base_address("kernel32.dll");
let sleep = dinvoke_rs::dinvoke::get_function_address(k32, "Sleep"); // Memory address of kernel32.dll!Sleep() 
let miliseconds = 1000i32;
unwinder::call_function!(sleep, false, miliseconds);

OpenProcess को कॉल करना

let k32 = dinvoke_rs::dinvoke::get_module_base_address("kernel32.dll"); 
let open_process: isize = dinvoke_rs::dinvoke::get_function_address(k32, "Openprocess");
let desired_access: u32 = 0x1000;
let inherit = 0i32;
let pid = 20628i32;
let handle = unwinder::call_function!(open_process, false, desired_access, inherit, pid); // returns *mut c_void
let handle: HANDLE = std::mem::transmute(handle);
println!("Handle id: {:x}", handle.0);

ध्यान दें कि मैक्रो एक *mut c_void लौटाता है जिसे सीधे HANDLE में परिवर्तित किया जा सकता है, क्योंकि दोनों डेटा प्रकारों का आकार समान है। यह OpenProcess द्वारा लौटाए गए मान तक पहुँचने की अनुमति देता है, जो टारगेट प्रोसेस के लिए नया हैंडल है।

NtDelayExecution को अप्रत्यक्ष syscall के रूप में कॉल करना

let large = 0x8000000000000000 as u64; // Sleep indefinitely
let large: *mut i64 = std::mem::transmute(&large);
let alertable = false;
let ntstatus = unwinder::indirect_syscall!("NtDelayExecution", false, alertable, large); // returns *mut c_void
println!("ntstatus: {:x}", ntstatus as i32);

ध्यान दें कि मैक्रो एक *mut c_void लौटाता है जिसका उपयोग NtDelayExecution द्वारा लौटाए गए NTSTATUS को प्राप्त करने के लिए किया जा सकता है।

मैक्रो कॉल्स को जोड़ना

स्पूफिंग प्रक्रिया को कॉल स्टैक आकार में असामान्य वृद्धि के बिना कितनी भी बार जोड़ा जा सकता है। निष्पादन प्रवाह भी संरक्षित रहेगा। निम्नलिखित कोड इसका एक उदाहरण है:

fn main()
{
	function_a();
}

fn function_a()
{
	unsafe
	{
		let func_b = function_b as usize;
		call_function!(func_b, false);
		println!("function_a done.");
	}
}

fn function_b()
{
	unsafe
	{
		let func_c = function_c as usize;
		call_function!(func_c, false);
		println!("function_b done.")
	}
}

fn function_c()
{
	unsafe
	{
		let large = 0x0000000000000000 as u64; // Don't sleep so we return to function_b, allowing to check the execution flow preservation.
		let large: *mut i64 = std::mem::transmute(&large);
		let alertable = false;
		let ntstatus = unwinder::indirect_syscall!("NtDelayExecution", false, alertable, large);
		println!("ntstatus: {:x}", (ntstatus as usize) as i32); //NTSTATUS is a i32, although that second casting is not really required in this case.
	}
}

विचारणीय बातें

प्रारंभिक फ्रेम

यदि आप दूसरे पैरामीटर को true पर सेट करते हैं (दोनों मैक्रोज़ में), तो स्पूफिंग प्रक्रिया वैधता बढ़ाने के लिए कॉल स्टैक में थ्रेड स्टार्ट एड्रेस के फ्रेम को रखने का प्रयास करेगी।