ग्रे हैट पायथन - इम्यूनिटी डिबगर

पहचान

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

5.1 इम्युनिटी डिबगर को स्थापित करना

इम्यूनिटी डिबगर मुफ्त में वितरित और समर्थित है [1] , इसे डाउनलोड करने के लिए लिंक यहां है: debugger.microsoftity.com

बस इंस्टॉलर को डाउनलोड करें और चलाएं। यदि आपने Python 2.5 (लगभग। प्रति के रूप में आपको सलाह दी गई थी) स्थापित नहीं किया है, तो यह एक बड़ी समस्या नहीं है, क्योंकि Immunity Debugger को Python 2.5 इंस्टॉलर (लगभग Per) के साथ बंडल किया गया है। .1) यदि जरूरत पड़ी तो आपके लिए व्यापारी द्वारा स्थापित किया जाएगा। इम्युनिटी डिबगर को स्थापित करने और चलाने के तुरंत बाद, यह उपयोग करने के लिए तैयार होगा।

5.2 इम्यूनिटी डिबगर 101

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


अंजीर। 5-1 : प्रतिरक्षा डिबगर मुख्य इंटरफ़ेस

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

5.2.1 PyCommands

इम्यूनिटी डिबगर में पायथन स्क्रिप्ट को निष्पादित करने का मुख्य तरीका PyCommands [2] का उपयोग करना है। PyCommands Python स्क्रिप्ट्स हैं जिन्हें Immunity Debugger के अंदर विभिन्न कार्यों को करने के लिए लिखा जाता है, उदाहरण के लिए, स्क्रिप्ट जो प्रदर्शन करती हैं: विभिन्न हुक, स्थिर विश्लेषण या कोई अन्य डीबगिंग कार्यक्षमता। प्रत्येक PyCommand में इसके उचित निष्पादन के लिए एक विशिष्ट संरचना होनी चाहिए। निम्न कोड स्निपेट मुख्य PyCommand संरचना को दर्शाता है, जिसे आप अपने PyCommands बनाने के लिए टेम्पलेट के रूप में उपयोग कर सकते हैं।

from immlib import * def main(args): # Instantiate a immlib.Debugger instance imm = Debugger() return "[*] PyCommand Executed!" 

प्रत्येक PyCommand के दो मुख्य घटक होते हैं। पहला घटक, आपको मुख्य () फ़ंक्शन को परिभाषित करना चाहिए था, जिसे एक पैरामीटर लेना चाहिए, जो कि पाइयोमैंड के लिए पारित तर्कों की एक सूची है। दूसरा घटक यह है कि मुख्य () को एक "स्ट्रिंग" वापस करना चाहिए जब वह अपना निष्पादन समाप्त कर लेता है। यह लाइन "डीबगर स्थिति पट्टी" (लगभग प्रति पंक्ति कमांड लाइन के नीचे स्थित) को अपडेट करेगी, जब स्क्रिप्ट निष्पादन समाप्त हो जाती है।

जब आप PyCommand को चलाना चाहते हैं, तो आपको यह सुनिश्चित करना चाहिए कि आपकी स्क्रिप्ट PyCommands निर्देशिका में सहेजी गई है, जो Immunity Debugger की मुख्य स्थापना निर्देशिका में स्थित है। सहेजी गई स्क्रिप्ट को निष्पादित करने के लिए, केवल डिबगर कमांड लाइन में स्क्रिप्ट नाम के बाद विस्मयादिबोधक चिह्न दर्ज करें, जैसे:

 !scriptname 

जैसे ही आप एंटर दबाएंगे, आपकी स्क्रिप्ट चलने लगेगी।

5.2.2 पाइकहुक

प्रतिरक्षा डिबगर 13 अलग-अलग प्रकार के इंटरसेप्ट्स के साथ आता है, जिनमें से प्रत्येक को आप एक अलग स्क्रिप्ट के रूप में या आंतरिक PyCommand स्क्रिप्ट के रूप में लागू कर सकते हैं। निम्नलिखित प्रकार के इंटरसेप्ट्स का उपयोग किया जा सकता है:

Bphook / logbphook
जब ब्रेकपॉइंट होता है, तो इस प्रकार के इंटरसेप्ट काम करते हैं। दोनों हुक एक ही व्यवहार करते हैं, सिवाय इसके कि जब BpHook का सामना होता है, तो यह वास्तव में डिबगर को रोकता है, जबकि LogBpHook इसके निष्पादन को बाधित नहीं करता है।

AllExceptHook
प्रोसेसर में होने वाला कोई भी अपवाद इस प्रकार के अवरोधन को निष्पादित करने का कारण होगा।

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

AccessViolationHook
जब भी कोई पहुंच उल्लंघन होता है तो यह अवरोधन चालू हो जाता है; यह फ़ज़िंग के दौरान सूचना अवरोधन के लिए सबसे उपयोगी है।

LoadDLLHook / UnloadDLLHook
जब भी DLL लोड / अनलोड होता है तो यह अवरोधन चालू हो जाता है।

CreateThreadHook / ExitThreadHook
जब भी कोई धागा बनाया / नष्ट किया जाता है तो यह अवरोधन शुरू हो जाता है।

CreateProcessHook / ExitProcessHook
इस प्रकार का अवरोधन तब शुरू होता है जब लक्ष्य प्रक्रिया शुरू होती है या बाहर निकल जाती है।

FastLogHook / STDCALLFastLogHook
ये दोनों अंतर्संबंध छोटे शरीर को इंटरसेप्टर के कोड को भेजने के लिए एक स्टब का उपयोग करते हैं, जो इंटरसेप्शन के दौरान रजिस्टर या मेमोरी के एक विशिष्ट मूल्य को लॉग कर सकता है। ये इंटरसेप्ट्स अक्सर फंक्शन्स को इंटरसेप्ट करने के लिए उपयोगी होते हैं; हम अध्याय 6 में उनके उपयोग की जाँच करेंगे।

PyHook को सेट करने के लिए, आप निम्न टेम्पलेट का उपयोग कर सकते हैं, जो एक उदाहरण के रूप में LogBpHook का उपयोग करता है:

 from immlib import * class MyHook( LogBpHook ): def __init__( self ): LogBpHook.__init__( self ) def run( regs ): # Executed when hook gets triggered 

हम LogBpHook वर्ग को अधिभारित करते हैं और सुनिश्चित करते हैं कि रन () फ़ंक्शन परिभाषित है। जब अवरोधन काम करता है, तो रन () फ़ंक्शन एक ही तर्क के रूप में लेता है, सभी प्रोसेसर रजिस्टरों की एक सूची जो हुक शुरू होने के समय निर्धारित की गई थी, जो हमें वर्तमान मूल्यों को देखने या बदलने की अनुमति देती है जैसा कि हम फिट देखते हैं। रेज वेरिएबल एक डिक्शनरी है जिसका उपयोग हम रजिस्टरों को नाम से एक्सेस करने के लिए कर सकते हैं, जैसे:

 regs["ESP"] 

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

५.३ शोषण विकास

एक सॉफ्टवेयर भेद्यता का पता लगाना एक विश्वसनीय कामकाजी कारनामे प्राप्त करने के लिए आपके आगे लंबी और कठिन यात्रा की शुरुआत है। इम्यूनिटी डिबगर में कई डिज़ाइन विशेषताएं हैं जो इसके विकास पथ के माध्यम से जाना थोड़ा आसान बनाती हैं। हम कुछ PyCommands विकसित करेंगे जो शोषण विकास प्रक्रिया को गति प्रदान करते हैं, जिसमें EIP प्राप्त करने के लिए निर्देश खोजने का एक तरीका है, साथ ही बाइट्स को फ़िल्टर करना जो शेल कोड में उपयोग के लिए उपयुक्त नहीं हैं। हम PyCommand! Findatidep का भी उपयोग करेंगे, जिसे Immunity Debugger के साथ बंडल किया गया है, जो DEP (डेटा निष्पादन रोकथाम) [3] को बायपास करने में मदद करता है। चलो शुरू हो जाओ!

5.3.1 शोषण के अनुकूल निर्देशों की खोज करें

ईआईपी पर नियंत्रण प्राप्त करने के बाद, आपको निष्पादन को शेल कोड में स्थानांतरित करना होगा। एक नियम के रूप में, आपके पास एक रजिस्टर या केस ऑफ़सेट होगा जो शेल कोड को इंगित करेगा। आपका कार्य निष्पादन योग्य फ़ाइल में या उसके किसी लोड किए गए मॉड्यूल में कहीं निर्देश खोजना है, जो नियंत्रण को वांछित पते पर स्थानांतरित करेगा। इम्यूनिटी डीबगर पायथन पुस्तकालय एक खोज इंटरफ़ेस प्रदान करके इसे आसान बनाता है जो आपको पूरे डाउनलोड किए गए बाइनरी में ब्याज के निर्देशों की खोज करने की अनुमति देता है। आइए हमारे घुटने पर एक स्क्रिप्ट डालें जो निर्देश प्राप्त करेगा और उन सभी पतों को लौटा देगा जहां यह निर्देश होता है। एक नई findinstruction.py फ़ाइल बनाएँ और निम्नलिखित कोड दर्ज करें।

findinstruction.py:

 from immlib import * def main(args): imm = Debugger() search_code = " ".join(args) (#1): search_bytes = imm.Assemble( search_code ) (#2): search_results = imm.Search( search_bytes ) for hit in search_results: # Retrieve the memory page where this hit exists # and make sure it's executable (#3): code_page = imm.getMemoryPagebyAddress( hit ) (#4): access = code_page.getAccess( human = True ) if "execute" in access.lower(): imm.log( "[*] Found: %s (0x%08x)" % ( search_code, hit ), address = hit ) return "[*] Finished searching for instructions, check the Log window." 

शुरुआत में, हम प्राप्त निर्देशों को उनके बाइनरी समतुल्य (# 1) में अनुवाद करते हैं, और फिर डाउनलोड बाइनरी फ़ाइल (# 2) की स्मृति में सभी निर्देशों की खोज करने के लिए खोज () फ़ंक्शन का उपयोग करते हैं। अगली, लौटी हुई सूची में, हम सभी ज्ञात पतों के माध्यम से मेमोरी पेज प्राप्त करने के लिए सॉर्ट करते हैं जहां निर्देश स्थित है (# 3) , जिसके बाद हम यह सुनिश्चित करते हैं कि मेमोरी निष्पादन योग्य (# 4) के रूप में चिह्नित है। फिर, प्रत्येक निर्देश के लिए, स्मृति निष्पादन योग्य पृष्ठ में, हम इसका पता ढूंढते हैं और इसे "लॉग" विंडो में प्रदर्शित करते हैं। स्क्रिप्ट का उपयोग करने के लिए, आप जिस निर्देश को तर्क के रूप में देख रहे हैं, उसे इस तरह पास करें:

 !findinstruction "instruction to search for" 

स्क्रिप्ट को निष्पादित करने के बाद, निम्नलिखित मापदंडों के साथ:

 !findinstruction jmp esp 

आपको अंजीर के समान परिणाम दिखाई देगा। 5-2।


अंजीर। 5-2 : PyCommand! खोज उत्पादन

अब हमारे पास पतों की एक सूची है जिसे हम अपने शेलकोड को निष्पादित करने के लिए उपयोग कर सकते हैं, यह मानते हुए कि इसे ईएसपी रजिस्टर के माध्यम से लॉन्च किया जा सकता है। पतों की सूची के अलावा, अब हमारे पास उन निर्देशों का पता लगाने के लिए एक अच्छा उपकरण है जिन्हें हम रुचि रखते हैं।

5.3.2 खराब वर्णों को छानना

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

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


अंजीर। 5-3 : अतिप्रवाह के बाद प्रतिरक्षा डिबगर विंडो स्टैक

हम देखते हैं कि ईआईपी रजिस्टर वर्तमान में ईएसपी रजिस्टर की ओर इशारा करता है। 0xCC के चार बाइट बस डिबगर को रोक देंगे, जैसे कि एक ब्रेकपॉइंट वहां स्थापित किया गया था (याद रखें? 0xCC एक INT3 निर्देश है)। ऑफसेट ईएसपी + 0x4 पर चार INT3 निर्देशों के तुरंत बाद, शेल कोड स्थित है। यह वहाँ है कि आपको मेमोरी का अध्ययन शुरू करने की आवश्यकता है, यह सुनिश्चित करने के लिए कि हमारा शेल कोड बिल्कुल वैसा ही है जैसा हमने लक्ष्य प्रणाली पर हमारे हमले के दौरान भेजा था। मेमोरी में शेलकोड का अध्ययन करने के लिए, हम बस एक ASCII स्ट्रिंग के रूप में मूल लेते हैं और इसकी तुलना (बाइट-बाय-बिट) मेमोरी में स्थित शेलकोड के साथ करते हैं ताकि यह सुनिश्चित हो सके कि शेलकोड सही तरीके से लोड किया गया था। यदि हमें कोई अंतर दिखाई देता है, तो हम एक खराब बाइट का उत्पादन करते हैं जो लॉग में सॉफ़्टवेयर फ़िल्टर से नहीं गुज़रा। उसके बाद, हम इस तरह के चरित्र के प्रसंस्करण को शेलकोड एनकोडर में जोड़ सकते हैं, एक दूसरे हमले को शुरू करने से पहले! इस उपकरण की कार्यक्षमता का परीक्षण करने के लिए, आप Metasploit, या अपने स्वयं के होमवर्क से शेलकोड ले सकते हैं। एक नई badchar.py फ़ाइल बनाएँ और निम्नलिखित कोड डालें।

badchar.py:

 from immlib import * def main(args): imm = Debugger() bad_char_found = False # First argument is the address to begin our search address = int(args[0],16) # Shellcode to verify shellcode = ">>COPY AND PASTE YOUR SHELLCODE HERE<<" shellcode_length = len(shellcode) debug_shellcode = imm.readMemory( address, shellcode_length ) debug_shellcode = debug_shellcode.encode("HEX") imm.log("Address: 0x%08x" % address) imm.log("Shellcode Length : %d" % length) imm.log("Attack Shellcode: %s" % canvas_shellcode[:512]) imm.log("In Memory Shellcode: %s" % id_shellcode[:512]) # Begin a byte-by-byte comparison of the two shellcode buffers count = 0 while count <= shellcode_length: if debug_shellcode[count] != shellcode[count]: imm.log("Bad Char Detected at offset %d" % count) bad_char_found = True break count += 1 if bad_char_found: imm.log("[*****] ") imm.log("Bad character found: %s" % debug_shellcode[count]) imm.log("Bad character original: %s" % shellcode[count]) imm.log("[*****] ") return "[*] !badchar finished, check Log window." 

इस स्क्रिप्ट में, हम वास्तव में केवल इम्यूनिटी डीबगर लाइब्रेरी से रीडमेरी () कॉल का उपयोग करते हैं, और बाकी स्क्रिप्ट सरल स्ट्रिंग तुलना करती है। अब आपको बस अपना शेलकोड ASCII स्ट्रिंग के रूप में लेना है (उदाहरण के लिए, यदि आपके पास बाइट्स 0xEB 0x09 है, तो आपका स्ट्रिंग EB09 की तरह दिखेगा), इसे स्क्रिप्ट में डालें और स्क्रिप्ट निम्नानुसार चलाएं।

 !badchar "Address to Begin Search" 

हमारे पिछले उदाहरण में, हम ESP + 0x4 के साथ खोज शुरू करेंगे, जिसका पूर्ण पता 0x00AEFD4C है, इसलिए हम PyCommand को निम्नानुसार चलाते हैं:

 !badchar 0x00AEFD4c 

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

5.3.3 डीईपी बाईपास

डीईपी माइक्रोसॉफ्ट विंडोज (एक्सपी SP2, 2003 और विस्टा) में लागू सुरक्षा उपाय है जो कोड को मेमोरी क्षेत्रों जैसे कि ढेर और स्टैक में निष्पादित करने से रोकता है। यह अधिकांश कारनामों पर शेल कोड निष्पादन में हस्तक्षेप कर सकता है, क्योंकि अधिकांश शोषण अपने शेल कोड को ढेर या स्टैक पर संग्रहीत करते हैं। हालांकि, एक अच्छी तरह से ज्ञात तकनीक है [4] जिसके माध्यम से हम मूल विंडोज एपीआई कॉल का उपयोग डीईपी को निष्क्रिय करने के लिए कर सकते हैं, वर्तमान प्रक्रिया के लिए जिसमें हम चल रहे हैं और इसमें हमारे शेल कोड पर नियंत्रण सुरक्षित रूप से स्थानांतरित करने की अनुमति है, चाहे वह स्टैक पर संग्रहीत हो। या एक ढेर में। इम्युनिटी डिबगर PyCommand के साथ आता है जिसे findantidep.py कहा जाता है। जो डीईपी को निष्क्रिय करने और शेलकोड को निष्पादित करने के लिए इस तरह से अपने कारनामे को स्थापित करने के लिए उपयुक्त पते निर्धारित करता है। डीईपी को अक्षम करने के लिए एक छोटे से सिद्धांत पर विचार करें। फिर हम PyCommand स्क्रिप्ट का उपयोग करने के लिए आगे बढ़ते हैं, जो हमें हमारे लिए रुचि के पते खोजने की अनुमति देता है।

वर्तमान प्रक्रिया के लिए डीईपी को निष्क्रिय करने के लिए इस्तेमाल किया जा सकता है कि एक विंडोज एपीआई कॉल एक undocumented फ़ंक्शन NtSetInformationProcess () [5] है , जिसमें निम्न प्रोटोटाइप है:

 NTSTATUS NtSetInformationProcess( IN HANDLE hProcessHandle, IN PROCESS_INFORMATION_CLASS ProcessInformationClass, IN PVOID ProcessInformation, IN ULONG ProcessInformationLength ); 

DEP को अक्षम करने के लिए, आपको पैरामीटर सेट के साथ NtSetInformationProcess () फ़ंक्शन को कॉल करने की आवश्यकता है: ProcessInformationClass to ProcessExecuteFlags (0x22) और ProcessInformation MEM_EXECUTE_OPENION_ENABLE (0x2) पर कॉल करें। एक साधारण शेलकोड सेटअप के साथ समस्या यह है कि इस फ़ंक्शन को कॉल करने में कई NULL पैरामीटर होते हैं, जो अधिकांश शेलकोड के लिए समस्याग्रस्त होते हैं। एक तकनीक जो आपको इस सीमा को दरकिनार करने की अनुमति देती है, वह फ़ंक्शन के बीच में शेल कोड को रखना है, जो पहले से ही स्टैक पर आवश्यक मापदंडों के साथ NtSetInformationProcess () कॉल करेगा। Ntdll.dll में एक ज्ञात स्थान है जो हमारे लिए ऐसा करता है। Immunity डीबगर का उपयोग करके प्राप्त Windows XP SP2 के लिए ntdll.dll disassembler आउटपुट को देखें।

 7C91D3F8 . 3C 01 CMP AL,1 7C91D3FA . 6A 02 PUSH 2 7C91D3FC . 5E POP ESI 7C91D3FD . 0F84 B72A0200 JE ntdll.7C93FEBA ... 7C93FEBA > 8975 FC MOV DWORD PTR SS:[EBP-4],ESI 7C93FEBD .^E9 41D5FDFF JMP ntdll.7C91D403 ... 7C91D403 > 837D FC 00 CMP DWORD PTR SS:[EBP-4],0 7C91D407 . 0F85 60890100 JNZ ntdll.7C935D6D ... 7C935D6D > 6A 04 PUSH 4 7C935D6F . 8D45 FC LEA EAX,DWORD PTR SS:[EBP-4] 7C935D72 . 50 PUSH EAX 7C935D73 . 6A 22 PUSH 22 7C935D75 . 6A FF PUSH -1 7C935D77 . E8 B188FDFF CALL ntdll.ZwSetInformationProcess 

इस कोड के बाद, हम 1 की वैल्यू के साथ AL की तुलना देखते हैं, फिर मान 2 को ESI में रखा जाता है। यदि AL 1 है, तो 0x7C93FEBA में एक सशर्त संक्रमण शुरू हो जाता है। वहां, ESI से मान EBP-4 स्टैक चर में स्थानांतरित किया जाता है (याद रखें कि ESI अभी भी 2 से 2 पर सेट है)। फिर, 0x7C91D403 पर स्थिति की जांच की जाती है, जो स्टैक पर हमारे वेरिएबल की जांच करता है (यह अभी भी 2 है) यह सुनिश्चित करने के लिए कि यह शून्य नहीं है, जिसके बाद 0x7C935D6D पर सशर्त संक्रमण शुरू हो जाता है। यहीं से शुरू होती है मस्ती; यह देखा जा सकता है कि मान 4 को स्टैक पर धकेल दिया गया है, EBP-4 वैरिएबल (अभी भी 2 के बराबर!) को EAX रजिस्टर में लोड किया जाता है, फिर इस मान को स्टैक पर धकेला जाता है, फिर मान 0x22 और मान -1 (-1, प्रोसेस हैंडल जो फ़ंक्शन कॉल बताता है, धकेल दिया जाता है) यह वर्तमान प्रक्रिया है जिसमें आप DEP को अक्षम करना चाहते हैं), इसके बाद ZwSetInformationProcess (अन्य नाम NtSetInformationProcess) पर कॉल करें। तो, वास्तव में, निम्नलिखित मापदंडों के साथ NtSetInformationProcess () फ़ंक्शन नामक कोड के इस टुकड़े में क्या हुआ:

 NtSetInformationProcess( -1, 0x22, 0x2, 0x4 ) 

बिल्कुल सही! यह वर्तमान प्रक्रिया के लिए DEP को अक्षम कर देगा, लेकिन इसके लिए हमें 0x7C91D3F8 को संबोधित करने के लिए नियंत्रण स्थानांतरित करना होगा। इससे पहले कि हम कोड के इस टुकड़े पर नियंत्रण स्थानांतरित करें, हमें यह सुनिश्चित करने की आवश्यकता है कि AL (EAX का कम बाइट) 1 पर सेट है। इन शर्तों के पूरा होने के बाद, हम शेल कोड पर नियंत्रण स्थानांतरित कर सकते हैं, जैसा कि किसी भी अन्य अतिप्रवाह में, उदाहरण के लिए, का उपयोग करके JMP ईएसपी निर्देश। इस प्रकार, आपको तीन पते चाहिए:

• एक पता जो AL को 1 पर सेट करता है और फिर लौटता है;
• पता जहां कोड का टुकड़ा डीईपी को निष्क्रिय करने के लिए स्थित है;
• हमारे शेल कोड की शुरुआत में नियंत्रण स्थानांतरित करने के लिए पता।

आमतौर पर आपको इन पतों को मैन्युअल रूप से खोजना होगा, लेकिन इम्युनिटी में होने वाले कारनामों के डेवलपर्स ने एक विज़ार्ड के रूप में बनाई गई एक छोटी पायथन लिपि findantidep.py बनाई, जो आपको इन पतों को खोजने की प्रक्रिया से मार्गदर्शन करेगी। यह एक शोषण स्ट्रिंग भी बनाता है जिसे आप अपने शोषण में कॉपी और पेस्ट कर सकते हैं। यह आपको किसी भी प्रयास के बिना पाए गए पते का उपयोग करने की अनुमति देता है। आइए findantidep.py स्क्रिप्ट को देखें और फिर इसे आज़माएँ।

findantidep.py:

 import immlib import immutils def tAddr(addr): buf = immutils.int2str32_swapped(addr) return "\\x%02x\\x%02x\\x%02x\\x%02x" % ( ord(buf[0]) , ord(buf[1]), ord(buf[2]), ord(buf[3]) ) DESC="""Find address to bypass software DEP""" def main(args): imm=immlib.Debugger() addylist = [] mod = imm.getModule("ntdll.dll") if not mod: return "Error: Ntdll.dll not found!" # Finding the First ADDRESS (#1): ret = imm.searchCommands("MOV AL,1\nRET") if not ret: return "Error: Sorry, the first addy cannot be found" for a in ret: addylist.append( "0x%08x: %s" % (a[0], a[2]) ) ret = imm.comboBox("Please, choose the First Address [sets AL to 1]", addylist) firstaddy = int(ret[0:10], 16) imm.Log("First Address: 0x%08x" % firstaddy, address = firstaddy) # Finding the Second ADDRESS (#2): ret = imm.searchCommandsOnModule( mod.getBase(), "CMP AL,0x1\n PUSH 0x2\n POP ESI\n" ) if not ret: return "Error: Sorry, the second addy cannot be found" secondaddy = ret[0][0] imm.Log( "Second Address %x" % secondaddy , address= secondaddy ) # Finding the Third ADDRESS (#3): ret = imm.inputBox("Insert the Asm code to search for") ret = imm.searchCommands(ret) if not ret: return "Error: Sorry, the third address cannot be found" addylist = [] for a in ret: addylist.append( "0x%08x: %s" % (a[0], a[2]) ) ret = imm.comboBox("Please, choose the Third return Address [jumps to shellcode]", addylist) thirdaddy = int(ret[0:10], 16) imm.Log( "Third Address: 0x%08x" % thirdaddy, thirdaddy ) (#4): imm.Log( 'stack = "%s\\xff\\xff\\xff\\xff%s\\xff\\xff\\xff\\xff" + "A" * 0x54 + "%s" + shellcode ' % ( tAddr(firstaddy), tAddr(secondaddy), tAddr(thirdaddy) ) ) 

इसलिए, पहले हम उन कमांड्स को खोजते हैं जो AL से 1 (# 1) सेट करेंगे, फिर उपयोगकर्ता से उचित पते का चयन करने के लिए कहेंगे। उसके बाद, हम ntdll.dll में निर्देशों के एक सेट की खोज करेंगे, जिसमें DEP अक्षम कोड (# 2) है। तीसरे चरण में, हम उपयोगकर्ता को निर्देश या निर्देश दर्ज करने के लिए कहते हैं जिन्हें शेल कोड (# 3) पर नियंत्रण स्थानांतरित करना होगा, और उपयोगकर्ता को उन पतों की एक सूची प्रदान करें जहां ये निर्देश मिल सकते हैं। स्क्रिप्ट लॉग विंडो (# 4) के परिणामों को आउटपुट करने के साथ समाप्त होती है। 5-4 - 5-6 के आंकड़ों को देखें कि यह प्रक्रिया कैसे होती है।


अंजीर। 5-4: सबसे पहले, उस पते को चुनें जो AL से 1 सेट करता है


अंजीर। 5-5: फिर हम निर्देशों का एक सेट पेश करते हैं जो शेल कोड पर नियंत्रण स्थानांतरित करेगा


अंजीर। 5-6: अब उस पते का चयन करें जो चरण (# 2) से वापस आएगा [/ CENTER]

और अंत में, आपको लॉग विंडो में आउटपुट दिखाई देगा, जैसा कि यहां दिखाया गया है:

 stack = "\x75\x24\x01\x01\xff\xff\xff\xff\x56\x31\x91\x7c\xff\xff\xff\xff" + "A" * 0x54 + "\x75\x24\x01\x01" + shellcode 

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

5.4 एंटी-डिबगिंग विधियों को दरकिनार करना

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

५.४.१ इडेबुगरपर्सेंट

- IsDebuggerPresent() kernel32.dll. 1 0 . , :

 7C813093 >/$ 64:A1 18000000 MOV EAX,DWORD PTR FS:[18] 7C813099 |. 8B40 30 MOV EAX,DWORD PTR DS:[EAX+30] 7C81309C |. 0FB640 02 MOVZX EAX,BYTE PTR DS:[EAX+2] 7C8130A0 \. C3 RETN 

TIB (Thread Information Block), 0x18 FS. PEB (Process Environment Block), 0x30 TIB. EAX BeingDebugged, 0x2 PEB. – 0x1. (Damian Gomez) [6] Immunity, Python-, PyCommand Python- Immunity Debugger:

 imm.writeMemory( imm.getPEBaddress() + 0x2, "\x00" ) 

BeingDebugged PEB, , , , , .

5.4.2

, . , Immunity Debugger , ImmunityDebugger.exe . Process32First() , Process32Next() . , , , EAX , . Immunity Debugger . :

 (#1): process32first = imm.getAddress("kernel32.Process32FirstW") process32next = imm.getAddress("kernel32.Process32NextW") function_list = [ process32first, process32next ] (#2): patch_bytes = imm.Assemble( "SUB EAX, EAX\nRET" ) for address in function_list: (#3): opcode = imm.disasmForward( address, nlines = 10 ) (#4): imm.writeMemory( opcode.address, patch_bytes ) 

(#1) . , EAX 0 ; (#2) , 10 (#3) , Process32First Process32Next. , , , . , 10- ; , , . (#4) , , .

, Python Immunity Debugger , . - , , Python-, ! , .

, .

संदर्भ

[1] For debugger support and general discussions visit http://forum.immunityinc.com .

[2] For a full set of documentation on the Immunity Debugger Python library, refer to http://debugger.immunityinc.com/update/Documentation/ref/ .

[3] An in-depth explanation of DEP can be found at http://support.microsoft.com/kb/875352/EN-US/ .

[4] See Skape and Skywing's paper at http://www.uninformed.org/?v=2&a=4&t=txt .

[5] The NtSetInformationProcess() function definition can be found at http://undocumented.ntinternals.net/UserMode/Undocumented%20Functions/NT%20Objects/Process/NtSetInformationProcess.html .

[6] The original forum post is located at http://forum.immunityinc.com/index.php?topic=71.0 .