MSRKit

एक टूल जो कर्नेल फ़ंक्शंस को कॉल करने और ड्राइवर्स को मैप करने के लिए एक ROP चेन के माध्यम से एक कमजोर ड्राइवर (AmdTools64.sys) में wrmsr प्रिमिटिव का उपयोग करता है।

यह कैसे काम करता है

1. NtLoadDriver के माध्यम से AmdTools64.sys लोड करता है (यदि सिमलिंक उपलब्ध नहीं है तो PnP devnode + GUID-आधारित डिवाइस इंटरफ़ेस पर फ़ॉलबैक करता है)
2. ड्राइवर के MSR read IOCTL (0xFFF02804) के माध्यम से IA32_LSTAR पढ़ता है
3. ROP गैजेट्स (pop rcx; ret, mov cr4, rcx; ret, wbinvd; ret, आदि) के लिए ntoskrnl.exe को स्कैन करता है
4. एंट्री गैजेट के साथ IA32_LSTAR को ओवरराइट करता है, FMASK में AC को क्लियर करता है, और syscall जारी करता है
5. ROP चेन CR4 में SMEP/SMAP बिट्स को क्लियर करती है, कर्नेल स्टैक पर टारगेट फ़ंक्शन को डिस्पैच करती है, CR4 और LSTAR को रीस्टोर करती है, और sysretq के माध्यम से यूज़र मोड में लौटती है

ड्राइवर मैपिंग भी इसी पथ का अनुसरण करती है: ExAllocatePoolWithTag के माध्यम से कर्नेल पूल आवंटित करता है, तैयार PE इमेज को कॉपी करता है (रिलोकेशन्स लागू, इम्पोर्ट्स रिज़ॉल्व्ड, सिक्योरिटी कुकी पैच्ड), और मैप्ड एंट्री पॉइंट को कॉल करता है।

उपयोग

CLI

msrkit <driver.sys> call    <ExportName> [args...]
msrkit <driver.sys> call_at <address>    [args...]
msrkit <driver.sys> map     <unsigned.sys> [entry args...]
msrkit <driver.sys> unmap   <address>

• call -- एक नामित ntoskrnl एक्सपोर्ट को रिज़ॉल्व और कॉल करता है। आर्ग्युमेंट्स को इंटीजर के रूप में पार्स किया जाता है (0x प्रीफ़िक्स के साथ हेक्स)। रिटर्न वैल्यू प्रिंट करता है।
• call_at -- एक मनमाना कर्नेल वर्चुअल एड्रेस कॉल करता है।
• map -- एक अहस्ताक्षरित ड्राइवर को नॉनपेज्ड पूल में मैप करता है और उसके एंट्री पॉइंट (ExAllocatePoolWithTag) को कॉल करता है। मैप्ड बेस एड्रेस प्रिंट करता है।
• unmap -- दिए गए बेस एड्रेस पर पहले से मैप किए गए ड्राइवर को फ़्री करता है।

लाइब्रेरी

#include "msrkit.h"

#pragma comment(lib, "msrkit.lib")

int main()
{
	MSRK::INIT(L"AmdTools64.sys");

	void* mptr = MSRK::CALL("ExAllocatePool2", 0x40ULL, 0x1000, 'Ruri');
	std::cout << "Memory allocate: " << mptr << std::endl;

	auto mptr23 = MSRK::MAP("driver.sys", 123, 456);
	std::cout << "Driver mapped: " << std::hex << (uintptr_t)mptr23 << "\n";

	// raw call
	std::vector<uint64_t>args = { 0x40ULL, 1024, 'Tagz' };
	void* mptr24 = MSRK::M_FUNCTION::CALL("ExAllocatePool2", args.data(), args.size());
	std::cout << "raw memory alloc : " << mptr24 << std::endl;

	std::vector<uint64_t>args2 = { 123, 456 };
	auto mptr25 = MSRK::M_DRIVERMAP::MAP( "driver.sys", args2.data(), args2.size() );

	MSRK::UNMAP(mptr23);	
	MSRK::CLEANUP();
}

वैकल्पिक रूप से लोडिंग छोड़ने के लिए एक मौजूदा ड्राइवर हैंडल पास करें:

MSRK::INIT("AmdTools64.sys", existing_handle);

बिल्ड

Visual Studio के साथ MSVC (v143+) और MASM (ml64.exe) की आवश्यकता है।

cmake -B build -G "Visual Studio 17 2022" -A x64
cmake --build build --config Release

आउटपुट: build/Release/msrkit.exe (CLI) और msrkit.lib (स्टैटिक लाइब्रेरी)।

CFG अक्षम है (/guard:cf-)। स्टैक कुकीज़ (/GS) सक्षम हैं।

विशेषताएँ

• सभी Windows 10 और 11 बिल्ड्स के लिए पूर्ण समर्थन
• KPTI के साथ संगत
• HVCI समर्थन नहीं (HVCI अक्षम होना चाहिए)
• PnP / Non PnP ड्राइवर्स का समर्थन

सीमाएँ

• केवल सिंगल-कोर निष्पादन -- कर्नेल कॉल्स के दौरान थ्रेड CPU 0 पर पिन किया जाता है
• अलग-अलग प्रोसेस से समवर्ती LSTAR हाइजैक्स BSOD का कारण बनेंगे (एक समय में एक कॉलर)
• Zw/Nt syscall स्टब्स को LSTAR कॉन्टेक्स्ट से कॉल नहीं किया जा सकता (KiSystemService में पुनः प्रवेश करता है)