💏 👰🏽 🌱 लिनक्स के लिए CreateRemoteThread 🥇 👚 🧖🏽

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

सामान्य तौर पर, इस फ़ंक्शन में संदिग्ध एप्लिकेशन उपयोगिता होती है, इसलिए यह आश्चर्यजनक नहीं है कि लिनक्स में CreateRemoteThread का तैयार एनालॉग नहीं है। हालांकि, मैं सोच रहा था कि इसे कैसे लागू किया जा सकता है। विषय का अध्ययन करना एक अच्छे साहसिक कार्य में बदल गया।

मैं विस्तार से बात करूँगा कि कैसे, ELF विनिर्देशन की मदद से, x86_64 आर्किटेक्चर और लिनक्स सिस्टम कॉल के कुछ ज्ञान, डिबगर के अपने छोटे टुकड़े को लिखें जो पहले से चल रहे और काम करने की प्रक्रिया में मनमाने कोड को लोड और निष्पादित कर सकते हैं।

पाठ को समझना लिनक्स के लिए सिस्टम प्रोग्रामिंग के बुनियादी ज्ञान की आवश्यकता होगी: सी भाषा, उस पर प्रोग्राम और डिबगिंग प्रोग्राम, कंप्यूटर में मशीन कोड और मेमोरी की भूमिका की समझ, सिस्टम कॉल की अवधारणा, मुख्य पुस्तकालयों के साथ परिचित, और प्रलेखन पढ़ने की क्षमता।

परिणामस्वरूप, मैं Gnome Control Center में पासवर्ड पूर्वावलोकन करने की क्षमता "जोड़ने" में सक्षम था:

गनोम कंट्रोल सेंटर में इंजेक्शन प्रदर्शन

मुख्य विचार

यदि पहले से चल रही प्रक्रिया में कोड लोड करने के बारे में आवश्यकताओं में कोई खंड नहीं था, तो समाधान बेहद सरल होगा: LD_PRELADAD। यह पर्यावरण चर एप्लिकेशन के साथ एक मनमाना पुस्तकालय लोड करने की अनुमति देता है। साझा पुस्तकालयों में, आप निर्माण कार्यों को परिभाषित कर सकते हैं जो लाइब्रेरी लोड होने पर निष्पादित होते हैं।

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

दुर्भाग्य से, LD_PRELOAD केवल तभी काम करता है जब प्रक्रिया शुरू होती है। इसका उपयोग लाइब्रेरी को पहले से चल रही प्रक्रिया में लोड करने के लिए नहीं किया जा सकता है। प्रक्रिया चल रही है, जबकि पुस्तकालयों को लोड करने के लिए एक dlopen () फ़ंक्शन है, लेकिन, जाहिर है, प्रक्रिया को प्लगइन्स को लोड करने के लिए इसे कॉल करना होगा।

स्थिर निष्पादन के बारे में

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

सांख्यिकीय रूप से इकट्ठे कार्यक्रमों में, आप रन टाइम पर कोड एम्बेड कर सकते हैं, लेकिन यह थोड़ा अलग तरीके से किया जाना चाहिए। और यह पूरी तरह से सुरक्षित नहीं है, क्योंकि कार्यक्रम इस तरह के मोड़ के लिए तैयार नहीं हो सकता है।

सामान्य तौर पर, कोई भी तैयार सुविधाजनक समाधान नहीं है, आपको अपनी बाइक लिखनी होगी। अन्यथा, आप इस पाठ को नहीं पढ़ेंगे :)

किसी अन्य प्रकार की कोड को निष्पादित करने के लिए किसी और की प्रक्रिया को बाध्य करने के लिए, आपको निम्नलिखित क्रियाएं करने की आवश्यकता है:

लक्ष्य प्रक्रिया में नियंत्रण प्राप्त करें।
लक्ष्य प्रक्रिया की मेमोरी में कोड लोड करें।
लक्ष्य प्रक्रिया में निष्पादन के लिए डाउनलोड किया गया कोड तैयार करें।
लक्षित प्रक्रिया द्वारा डाउनलोड किए गए कोड के निष्पादन को व्यवस्थित करें।

आइए जाने ...

प्रक्रिया में नियंत्रण प्राप्त करना

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

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

हम नियंत्रण हासिल करने के लिए एक और, ईमानदार तरीके का उपयोग करेंगे: डिबगिंग सिस्टम कॉल । इंटरएक्टिव डिबगर्स तीसरे पक्ष की प्रक्रियाओं को पूरी तरह से रोक सकते हैं, अभिव्यक्ति का मूल्यांकन कर सकते हैं, और कई अन्य चीजें। वे कर सकते हैं - हम कर सकते हैं।

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

कोड को प्रोसेस मेमोरी में लोड करना

बफर ओवरफ्लो के मामले में, पेलोड ( शेल कोड ) आमतौर पर उन सामग्री में शामिल होता है जो उसी बफर को ओवरफ्लो करते हैं। डिबगर का उपयोग करते समय, आवश्यक कोड को सीधे प्रक्रिया मेमोरी में लिखा जा सकता है। WinAPI में इसके लिए एक विशेष फ़ंक्शन WriteProcessMemory है। इस प्रयोजन के लिए लिनक्स UNIX तरीके से अनुपालन करता है: सिस्टम में प्रत्येक प्रक्रिया के लिए एक फ़ाइल / प्रोक / $ pid / मेम है , जो इस प्रक्रिया की मेमोरी प्रदर्शित करता है। सामान्य इनपुट-आउटपुट का उपयोग करके प्रक्रिया मेमोरी में कुछ लिखना संभव है।

निष्पादन के लिए कोड तैयार करना

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

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

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

जब प्रक्रिया सामान्य रूप से शुरू होती है, तो लोडर जो लोड करता है वह पुस्तकालयों के सटीक पतों को निर्धारित करने के लिए जिम्मेदार होता है। हालाँकि, वह शुरू में केवल एक बार पूरा करता है। यदि प्रक्रिया पुस्तकालयों के गतिशील लोडिंग की अनुमति देती है, तो इसमें एक गतिशील लोडर है जो प्रक्रिया चलने के दौरान भी ऐसा कर सकता है। हालाँकि, डायनेमिक लोडर का पता भी निश्चित नहीं है।

सामान्य तौर पर, पुस्तकालयों के साथ, चार विकल्प होते हैं:

पुस्तकालयों का उपयोग बिल्कुल न करें, स्वच्छ सिस्टम कॉल पर सब कुछ करें
शेल कोड में सभी आवश्यक पुस्तकालयों की प्रतियां डालें
गतिशील लोडर का काम खुद करें
एक गतिशील बूटलोडर ढूंढें और इसे हमारे पुस्तकालयों को लोड करें

हम बाद का चयन करेंगे, क्योंकि हम पुस्तकालय चाहते हैं, और हमारे पूर्ण बूटलोडर को लंबे समय तक लिखना चाहते हैं। यह सबसे गुप्त विधि नहीं है, और सबसे दिलचस्प नहीं है, लेकिन सबसे सरल, शक्तिशाली और विश्वसनीय है।

कोड पर नियंत्रण का स्थानांतरण

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

समाधान स्केच

कुल मिलाकर, हम अपने प्रवाह को तीसरे पक्ष की प्रक्रिया में निम्नानुसार कार्यान्वित करेंगे:

हम डिबगिंग के लिए लक्ष्य प्रक्रिया से जुड़े हैं।
हम स्मृति में आवश्यक पुस्तकालय पाते हैं:
- libdl - एक नया पुस्तकालय लोड करने के लिए
- libpthread - एक नया सूत्र शुरू करने के लिए
हम पुस्तकालयों में आवश्यक कार्य पाते हैं:
- libdl: dlopen (), dlsym ()
- libpthread: pthread_create (), pthread_detach ()

हम लक्ष्य प्रक्रिया की स्मृति में शेल कोड का परिचय देते हैं:

 void shellcode(void) { void *payload = dlopen("/path/to/payload.so", RTLD_LAZY); void *entry = dlsym(payload, "entry_point"); pthread_t thread; pthread_create(&thread, NULL, entry, NULL); pthread_detach(thread); }

हम पूरा होने के लिए शेल कोड देते हैं।

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

प्रतिबंध

ऊपर वर्णित दृष्टिकोण कुछ सीमाएं लगाता है:

बूटलोडर में लक्ष्य प्रक्रिया को डिबग करने के लिए पर्याप्त विशेषाधिकार होने चाहिए।
प्रक्रिया का उपयोग करना चाहिए libdl (मॉड्यूल के गतिशील लोडिंग के लिए तैयार)।
प्रक्रिया को लेबरप्र्रेड (मल्टीथ्रेडिंग के लिए तैयार) का उपयोग करना चाहिए।
स्थैतिक अनुप्रयोगों का समर्थन नहीं कर रहे हैं।

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

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

पाचन: libdl और libpthread का उपयोग करने के बारे में

एक अनुभवी पेशेवर पाठक आश्चर्यचकित हो सकता है: अगर __libc_dlopen_mode () और __libc_dlsym () आंतरिक फ़ंक्शन पहले से ही glibc में निर्मित हैं, तो libdl की आवश्यकता क्यों है, और libdl उनके ऊपर सिर्फ एक आवरण है? इसी प्रकार, क्लोन () सिस्टम कॉल का उपयोग करके एक नया धागा आसानी से बनाया जा सकता है, तो लेबरपैथ की आवश्यकता क्यों है?

वास्तव में, इंटरनेट पर उनके उपयोग के एक उदाहरण से बहुत दूर है:

वे लोकप्रिय हैकर साहित्य में भी उल्लिखित हैं:

लिनक्स बाइनरी विश्लेषण सीखना
स्मृति फोरेंसिक की कला

तो क्यों नहीं? खैर, कम से कम क्योंकि हम दुर्भावनापूर्ण कोड नहीं लिख रहे हैं जहां एक समाधान उपयुक्त है जो 90% चेक को छोड़ देता है, 20 गुना कम जगह लेता है, लेकिन 80% मामलों में भी काम करता है। इसके अलावा, मैं अपने हाथों से सब कुछ आजमाना चाहता था।

दरअसल, glibc के मामले में पुस्तकालय को लोड करने के लिए libdl आवश्यक नहीं है । प्रक्रिया द्वारा इसका उपयोग इंगित करता है कि यह गतिशील कोड लोडिंग के लिए स्पष्ट रूप से तैयार है। इसके बावजूद, सिद्धांत रूप में, आप लिब्डल का उपयोग करने से इनकार कर सकते हैं (यह देखते हुए कि हमें अभी भी बाद में ग्लिबेक की तलाश करनी होगी)।

क्यों dlopen () सब पर glibc के अंदर?

यह अपने तरीके से एक दिलचस्प सवाल है। संक्षिप्त उत्तर: कार्यान्वयन विवरण।

बिंदु नाम सेवा स्विच (NSS) है - glibc के कुछ हिस्सों में से एक जो विभिन्न नामों का अनुवाद प्रदान करता है: मशीनों, प्रोटोकॉल, उपयोगकर्ताओं, मेल सर्वरों आदि के नाम। यह वह है जो getaddrinfo () जैसे कार्यों के लिए IP पते प्राप्त करने के लिए ज़िम्मेदार है। डोमेन नाम और getpwuid () अपने संख्यात्मक पहचानकर्ता द्वारा उपयोगकर्ता के बारे में जानकारी प्राप्त करने के लिए।

एनएसएस में एक मॉड्यूलर वास्तुकला और मॉड्यूल गतिशील रूप से लोड होते हैं। दरअसल, इसके लिए, glibc को गतिशील रूप से लोडिंग पुस्तकालयों के लिए तंत्र की भी आवश्यकता होती है। इसीलिए जब आप स्टैटिकली असेंबल किए गए एप्लिकेशन में getaddrinfo () का उपयोग करने की कोशिश करते हैं, तो लिंकर एक "समझ से बाहर" चेतावनी देता है:
 /tmp/build/socket.o: फ़ंक्शन में 'सॉकेट :: बाइंड':
 सॉकेट.ओ :(। टेक्स्ट + 0x374): चेतावनी: स्टैटिकली लिंक्ड में 'getaddrinfo' का उपयोग करना
 अनुप्रयोगों के लिए ग्लिबेक संस्करण से साझा पुस्तकालयों को चलाने की आवश्यकता होती है
 लिंकिंग के लिए उपयोग किया जाता है

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

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

चरण 1. प्रक्रिया का कनेक्शन

सबसे पहले, हमें डीबगिंग के लिए लक्ष्य प्रक्रिया से कनेक्ट करने की आवश्यकता है, और बाद में, इसे वापस से डिस्कनेक्ट करें। यह वह जगह है जहाँ ptrace () सिस्टम कॉल आती है।

Ptrace () के साथ पहला संपर्क

Ptrace () के लिए प्रलेखन में आप लगभग सभी आवश्यक जानकारी पा सकते हैं:

   संलग्न और कोचिंग
        कॉल का उपयोग करके ट्रेसर से एक धागा जोड़ा जा सकता है

            ptrace (PTRACE_ATTACH, pid, 0, 0);

        या

            ptrace (PTRACE_SEIZE, pid, 0, PTRACE_O_flags);

        PTRACE_ATTACH इस धागे को SIGSTOP भेजता है।  अगर ट्रैसर ऐसा चाहता है
        SIGSTOP का कोई प्रभाव नहीं है, इसे दबाने की जरूरत है।  ध्यान दें कि यदि
        अन्य संकेत समवर्ती रूप से इस धागे को संलग्न करने के दौरान भेजे जाते हैं
        अनुरेखक अन्य सिग के साथ ट्रेस सिग्नल-डिलीवरी-स्टॉप दर्ज कर सकता है
        nal (s) पहले!  सामान्य संकेतों को तब तक इन संकेतों को मजबूत करना है
        SIGSTOP देखा जाता है, फिर SIGSTOP इंजेक्शन दबाएं।  डिजाइन बग
        यहाँ है कि एक ptrace संलग्न है और एक समवर्ती वितरित SIGSTOP हो सकता है
        दौड़ और समवर्ती SIGSTOP खो सकता है।

तो पहला कदम PTRACE_ATTACH का उपयोग करना है:

 int ptrace_attach(pid_t pid) { /*     */ if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) return -1; /*    */ if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; return 0; }

Ptrace () के बाद, लक्ष्य प्रक्रिया डिबगिंग के लिए बिल्कुल तैयार नहीं है। हम इससे जुड़े, लेकिन प्रक्रिया की स्थिति के एक इंटरैक्टिव अध्ययन के लिए, इसे रोकना होगा। ptrace () प्रक्रिया के लिए एक SIGSTOP सिग्नल भेजता है, लेकिन हमें तब तक इंतजार करना होगा जब तक प्रक्रिया वास्तव में बंद न हो जाए।

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

 static int wait_for_process_stop(pid_t pid, int expected_signal) { for (;;) { int status = 0; /* ,    -  */ if (waitpid(pid, &status, 0) < 0) return -1; /*      —   */ if (WIFSIGNALED(status) || WIFEXITED(status)) return -1; /*   ,     */ if (WIFSTOPPED(status)) { /* *  WSTOPSIG()   , *   ptrace()   *     . */ int stop_signal = status >> 8; /*    ,    */ if (stop_signal == expected_signal) break; /*        */ if (ptrace(PTRACE_CONT, pid, 0, stop_signal) < 0) return -1; continue; } /*   —   */ return -1; } return 0; }

प्रक्रिया वियोग

डिबगिंग प्रक्रिया को रोकना बहुत सरल है: बस PTRACE_DETACH का उपयोग करें:

 int ptrace_detach(pid_t pid) { if (ptrace(PTRACE_DETACH, pid, 0, 0) < 0) return -1; return 0; }

स्पष्ट रूप से, डिबगर को स्पष्ट रूप से अक्षम करना हमेशा आवश्यक नहीं होता है। जब डिबगर प्रक्रिया समाप्त हो जाती है, तो यह स्वचालित रूप से सभी डीबग की गई प्रक्रियाओं से डिस्कनेक्ट हो जाता है, और यदि वे ptrace () द्वारा रोक दिए गए थे, तो प्रक्रिया फिर से शुरू हो जाती है। हालाँकि, यदि डीबग करने की प्रक्रिया को स्पष्ट रूप से डिबगर्स द्वारा SIGSTOP सिग्नल का उपयोग किए बिना ptrace () का उपयोग किए बिना किया जाता है, तो यह संबंधित SIGCONT या PTRACE_DETACH सिग्नल के बिना नहीं जागेगा। इसलिए, सांस्कृतिक रूप से प्रक्रियाओं से डिस्कनेक्ट करना बेहतर है।

Ptrace_scope सेटिंग

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

इन कारणों से, सुरक्षा कारणों से, सिस्टम आमतौर पर डिफ़ॉल्ट रूप से जो भी प्रक्रियाएं डिबग करने की क्षमता को अक्षम करता है। इसके लिए यम सुरक्षा मॉड्यूल ज़िम्मेदार है, जिसे फ़ाइल / proc / sys / कर्नेल / yama / ptrace_scope द्वारा प्रबंधित किया गया है। यह चार व्यवहार प्रदान करता है:

0 - उपयोगकर्ता किसी भी प्रक्रिया को डीबग कर सकता है जो उसने शुरू की थी
1 - डिफ़ॉल्ट मोड, केवल डिबगर द्वारा शुरू की गई प्रक्रियाओं को डीबग किया जा सकता है
2 - केवल एक रूट सिस्टम व्यवस्थापक प्रक्रियाओं को डीबग कर सकता है
3 - डिबगिंग हर किसी के लिए निषिद्ध है, मोड तब तक बंद नहीं होता है जब तक सिस्टम रिबूट नहीं करता है

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

 $ sudo sh -c 'echo 0 > /proc/sys/kernel/yama/ptrace_scope'

या डिबगर को व्यवस्थापक के रूप में चलाएं:

 $ sudo ./inject-thread ...

पहले चरण के परिणाम

नतीजतन, पहले चरण में, हम एक डिबगर के रूप में लक्ष्य प्रक्रिया से जुड़ने में सक्षम हैं और बाद में इससे डिस्कनेक्ट हो जाते हैं।

लक्ष्य प्रक्रिया को रोक दिया जाएगा और हम यह सुनिश्चित कर सकते हैं कि ऑपरेटिंग सिस्टम वास्तव में हमें डिबगर के रूप में देखता है:

 $ sudo ./inject-thread --target $(pgrep docker) $ cat /proc/$(pgrep docker)/status | head Name: docker State: t (tracing stop) <---    Tgid: 31330 Ngid: 0 Pid: 31330 PPid: 1 TracerPid: 2789 <--- PID   Uid: 0 0 0 0 Gid: 0 0 0 0 FDSize: 64 $ ps a | grep [2]789 2789 pts/5 S+ 0:00 ./inject-thread --target 31330

चरण 2. मेमोरी में लाइब्रेरी खोजें

अगला चरण सरल है: आपको आवश्यक कार्यों के साथ लाइब्रेरी को लक्ष्य प्रक्रिया की स्मृति में खोजने की आवश्यकता है। लेकिन स्मृति बहुत है, जहां तलाश शुरू करना है और वास्तव में क्या है?

फ़ाइल / खरीद / $ पीआईडी / नक्शे

एक विशेष फ़ाइल हमें इसमें मदद करेगी, जिसके माध्यम से कर्नेल इस बारे में बताता है कि स्मृति में क्या और कहाँ प्रक्रिया स्थित है। जैसा कि आप जानते हैं , प्रत्येक प्रक्रिया के लिए / proc निर्देशिका में एक उपनिर्देशिका होती है। और इसमें एक फ़ाइल है जो प्रक्रिया मेमोरी कार्ड का वर्णन करती है:

 $ बिल्ली / खरीद / स्व / नक्शे
 00400000-0040c000 r-xp 00000000 fe: 01 1044592 / बिन / बिल्ली
 0060b000-0060c000 r - p 0000b000 fe: 01 1044592 / बिन / बिल्ली
 0060c000-0060d000 rw-p 0000c000 fe: 01 1044592 / बिन / बिल्ली
 013d5000-013f6000 rw-p 00000000 00:00 0 [ढेर]
 7f9920bd1000-7f9920d72000 r-xp 00000000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920d72000-7f9920f72000 --- p 001a1000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920f72000-7f9920f76000 r - p 001a1000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7f9920f76000-7f9920f78000 rw-p 001a5000 fe: 01 920019 /lib/x86_64-linux-gnu/libc-2.19.so
 7fc3f8381000-7fc3f8385000 rw-p 00000000 00:00 0
 7fc3f8385000-7fc3f83a6000 r-xp 00000000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f83ec000-7fc3f840e000 rw-p 00000000 00:00 0
 7fc3f840e000-7fc3f8597000 r - p 00000000 fe: 01 657286 / usr / lib / स्थानीय / स्थानीय-संग्रह
 7fc3f8597000-7fc3f859a000 rw-p 00000000 00:00 0
 7fc3f85a3000-7fc3f85a5000 rw-p 00000000 00:00 0
 7fc3f85a5000-7fc3f85a6000 r - p 00020000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f85a6000-7fc3f85a7000 rw-p 00021000 fe: 01 920012 /lib/x86_64-linux-gnu/ld-2.19.so
 7fc3f85a7000-7fc3f85a8000 rw-p 00000000 00:00 0
 7ffdb6f0e000-7ffdb6f2f000 rw-p 00000000 00:00 0 [स्टैक]
 7ffdb6f7f000-7ffdb6f81000 r-xp 00000000 00:00 0 [vdso]
 7ffdb6f81000-7ffdb6f83000 r - p 00000000 00:00 0 [vvar]
 ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [विस्कॉन्सिन]

इस फाइल की सामग्री आंतरिक संरचनाओं से ऑपरेटिंग सिस्टम कर्नेल द्वारा मक्खी पर उत्पन्न होती है जो हमारे लिए ब्याज की प्रक्रिया के मेमोरी क्षेत्रों का वर्णन करती है, और इसमें निम्न जानकारी शामिल है:

क्षेत्र के लिए आवंटित पता सीमा
इस क्षेत्र पर अधिकार
- r/- : पढ़ा
- w/- : लिखें
- x/- : निष्पादन
- p/s : अन्य प्रक्रियाओं के साथ स्मृति साझा करना
फ़ाइल ऑफसेट (यदि कोई हो)
डिवाइस का कोड जहां प्रदर्शित फ़ाइल स्थित है
फ़ाइल इनकोड संख्या (यदि कोई हो)
प्रदर्शित फ़ाइल का पथ (यदि कोई हो)

मेमोरी के कुछ क्षेत्रों को फ़ाइलों पर मैप किया जाता है: जब कोई प्रक्रिया ऐसी मेमोरी पढ़ती है, तो यह वास्तव में एक विशिष्ट ऑफसेट पर संबंधित फाइलों से डेटा पढ़ता है। यदि आप किसी क्षेत्र को लिख सकते हैं, तो मेमोरी में परिवर्तन या तो केवल प्रक्रिया के लिए ही दिखाई दे सकता है ( कॉपी-ऑन-राइट मैकेनिज्म, p मोड प्राइवेट है), या डिस्क के साथ सिंक्रनाइज़ ( s मोड साझा किया गया है)।

अन्य क्षेत्र अनाम हैं - यह मेमोरी किसी भी फ़ाइल के अनुरूप नहीं है। ऑपरेटिंग सिस्टम बस प्रक्रिया को भौतिक मेमोरी का एक टुकड़ा देता है जो इसका उपयोग करता है। ऐसे क्षेत्रों का उपयोग किया जाता है, उदाहरण के लिए, "सामान्य" प्रक्रिया मेमोरी के लिए: स्टैक और ढेर। अनाम क्षेत्र या तो किसी प्रक्रिया के लिए व्यक्तिगत हो सकते हैं या कई प्रक्रियाओं ( साझा मेमोरी तंत्र) के बीच साझा किए जा सकते हैं।

इसके अलावा, छद्म नामों [vdso] और [vsyscall] के साथ चिह्नित मेमोरी में कई विशेष क्षेत्र हैं। उनका उपयोग कुछ सिस्टम कॉल को अनुकूलित करने के लिए किया जाता है।

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

 static bool read_proc_line(const char *line, const char *library, struct memory_region *region) { unsigned long vaddr_low = 0; unsigned long vaddr_high = 0; char read = 0; char write = 0; char execute = 0; int path_offset = 0; /*    /proc/$pid/maps */ sscanf(line, "%lx-%lx %c%c%c%*c %*lx %*x:%*x %*d %n", &vaddr_low, &vaddr_high, &read, &write, &execute, &path_offset); /* ,       */ if (!strstr(line + path_offset, library)) return false; /*           */ if (region) { region->vaddr_low = vaddr_low; region->vaddr_high = vaddr_high; region->readable = (read == 'r'); region->writeable = (write == 'w'); region->executable = (execute == 'x'); region->content = NULL; } return true; }

, libc-2.19.so, :

libc-2.19.so में छेद

2 - ? 51? ? ?

, , .

, , . , , , (, , ).

, ( 4 ). , .

, . — — . 2 — , ( x86_64 4 , 2 , 1 ). .

, :

libdl: dlopen() dlsym()
libpthread: pthread_create() pthread_detach()

, , . Linux ( address space layout randomization , ASLR). (- , ), — - .

, , , /proc/$pid/maps. , .

3. ELF-

, , , .

 $ nm -D /lib/x86_64-linux-gnu/libdl-2.19.so | grep dlopen 0000000000001090 T dlopen

nm . .

- , nm , . , dlsym().

— ELF-, . procfs. UNIX way, /proc/$pid/mem , — ( /proc/$pid/maps).

Linux mmap(), ( , ). :

 static int map_region(pid_t pid, struct memory_region *region) { size_t length = region->vaddr_high - region->vaddr_low; off_t offset = region->vaddr_low; char path[32] = {0}; snprintf(path, sizeof(path), "/proc/%d/mem", pid); /*     */ int fd = open(path, O_RDONLY); if (fd < 0) goto error; /*      */ void *buffer = malloc(length); if (!buffer) goto error_close_file; /*   */ if (read_region(fd, offset, buffer, length) < 0) goto error_free_buffer; region->content = buffer; close(fd); return 0; error_free_buffer: free(buffer); error_close_file: close(fd); error: return -1; } static int read_region(int fd, off_t offset, void *buffer, size_t length) { /*      */ if (lseek(fd, offset, SEEK_SET) < 0) return -1; size_t remaining = length; char *ptr = buffer; /* *     .   , *      ,  . */ while (remaining > 0) { ssize_t count = read(fd, ptr, remaining); if (count < 0) return -1; remaining -= count; ptr += count; } return 0; }

ELF- . , -, , -, .

ELF

ELF — Linux. , , .

ELF . ELF . — , . , — . ELF-.

, libdl-2.19.so :

सेक्शन और सेगमेंट libdl-2.19.so

( readelf --headers .)

, , (29 9). — , , . ELF — , . Linux, , LOAD, ( ).

ELF- , . , .

, . «» . .bss, , ( ).

, ELF — , . ...

?

() . , dlsym(), . - .

ELF (. 2-10). , .dynamic , DYNAMIC . .dynamic , :

.dynsym — ;
.dynstr — ;
.hash — -, .

, , ELF:

डायनामिक खंड खोज

ELF, (1), (2), (3), (4) , ।

ELF →

() ELF <elf.h>, , , . , ELF — . 32- 64- , , , . x86_64, ELF .

ELF- ( Elf64_Ehdr ). ( program headers ), e_phoff e_phnum :

ईएलएफ हेडर

— , , ELF- — , , , , .

e_phoff, , . e_phnum e_phentsize .

( ), ELF — 64 .

→ DYNAMIC

. — Elf64_Phdr ( 64- ELF-), . PT_DYNAMIC p_type :

ELF खंड तालिका

p_vaddr — , ;
p_memsz — .

.dynamic 0x2D88 ( ). DYNAMIC — 0x202D88. 0x210 (8448) . .

DYNAMIC → .dynsym, .dynstr, .hash

.dynamic, DYNAMIC, . Elf64_Dyn , :

डायनामिक अनुभाग टैग

8 d_val d_ptr , 8- d_tag , , . :

DT_HASH (4) — .hash ( d_ptr)
DT_STRTAB (5) — .dynstr ( d_ptr)
DT_SYMTAB (6) — .dynsym ( d_ptr)
DT_STRSZ (10) — .dynstr ( d_val)
DT_NULL (0) —

. .dynamic : , , , .

, DYNAMIC , . , , - , .

.dynamic , . -, .dynstr , ? .

. , .dynsym , . ( «» .symtab, , , . .)

Elf64_Sym , ELF — , , , . dlopen :

ईएलएफ वर्ण तालिका

st_name — ,
st_info — ( )
st_value —

( , nm , dlopen() .text, 0x1090 .)

, .

— - , . ( ). .dynstr , libdl-2.19.so :

ईएलएफ पंक्ति तालिका

, ( «dlopen», 0xA5) , . .

-

.hash - , . - — — ELF-, . , .dynsym, , . ( ) - .

- <elf.h>, (. 2-19). - , :

हैश टेबल ईएलएफ

जहाँ

nbuckets — buckets
nchains — chains ( )
buckets —
chains —

- :

h .
i buckets[h % nbuckets] , .
( ) , .
— chains[i % nchains] .
3—4 , .

-, ELF:

 static uint32_t elf_hash(const char *name) { uint32_t h = 0; uint32_t g; while (*name) { h = (h << 4) + *name++; g = h & 0xF0000000; if (g) h ^= g >> 24; h &= ~g; } return h; }

, "dlopen" - 112420542 :

एक पुस्तकालय में एक चरित्र के लिए खोज

libdl — , 39 , . - .

, :

dlopen() dlsym() libdl
pthread_create() pthread_detach() libpthread

, .

. . , .

ELF- . , ( ). , . , , . .

4. -

, , - , : , . - .

-

, -:

 void shellcode(void) { void *payload = dlopen("/path/to/payload.so", RTLD_LAZY); void (*entry)(void) = dlsym(payload, "entry_point"); pthread_t thread; pthread_create(&thread, NULL, entry, NULL); pthread_detach(thread); }

, — . , , , - — - ! .

— - . , , : .

 /* *      .rodata:   * .         , *        . */ .section .rodata /* *   .       . *      -:    ,  *  ,       . */ .global shellcode_start .global shellcode_address_dlopen .global shellcode_address_dlsym .global shellcode_address_pthread_create .global shellcode_address_pthread_detach .global shellcode_address_payload .global shellcode_address_entry .global shellcode_end /* *   dlopen().     #include <dlfcn.h>, *       . */ .set RTLD_LAZY, 1 .align 8 shellcode_start: /* * void *payload = dlopen(shellcode_address_payload, RTLD_LAZY); * *        x86_64: * * -     %rdi, %rsi, %rdx, %rcx * -     %rax * -      * *         . * *       %rax,    *     . */ lea shellcode_address_payload(%rip),%rdi mov $RTLD_LAZY,%rsi mov shellcode_address_dlopen(%rip),%rax callq *%rax /* * void (*entry)(void) = dlsym(payload, shellcode_address_entry); */ mov %rax,%rdi lea shellcode_address_entry(%rip),%rsi mov shellcode_address_dlsym(%rip),%rax callq *%rax /* * pthread_t thread; * pthread_create(&thread, NULL, entry, NULL); * *            * ,     pthread_create(). */ sub $8,%rsp mov %rsp,%rdi xor %rsi,%rsi mov %rax,%rdx xor %rcx,%rcx mov shellcode_address_pthread_create(%rip),%rax callq *%rax /* * pthread_detach(thread); * *    ,   ,  *     . */ mov (%rsp),%rdi add $8,%rsp mov shellcode_address_pthread_detach(%rip),%rax callq *%rax /* *   - —    ,     *      ret.    *     ,  *      . */ int $3 /* *       ,   *   ,    - *     .   “  *  ” (global offset table, GOT),   *           . */ .align 8 shellcode_address_dlopen: .space 8 shellcode_address_dlsym: .space 8 shellcode_address_pthread_create: .space 8 shellcode_address_pthread_detach: .space 8 shellcode_address_payload: .space 256 shellcode_address_entry: .space 256 /* *  - . */ shellcode_end: .end

, . :

 $ as -o shellcode.o shellcode.S

, , , . : (procedure linkage table, PLT), .

- , (, ) . - .

-

- . , , , . ?

-

, . , . , . , .

(- ), : , , . , , JIT- , . ?

, . -, - , . -, . -, , - -, .

, . . x86_64 int $3 — 0xCC — . ptrace() PTRACE_POKETEXT — , 8 , . , , .

, , , : . - , .

?

, ! malloc()!

. , -, . . , mmap():

 void inject_shellcode(const void *shellcode_src, size_t shellcode_size) { void *shellcode_dst = mmap(NULL, shellcode_size, PROT_READ | PROT_WRITE | PROT_EXEC, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0); copy_shellcode(shellcode_dst, shellcode_src, shellcode_size); }

, ptrace() , .

, ? , . Linux x86_64 :

%rax
— — %rsi, %rdi, %rdx, %r10, %r8, %r9
SYSCALL,
%rax

ptrace() PTRACE_GETREGS PTRACE_SETREGS. , . - SYSCALL.

: , %rip. , , SYSCALL.

SYSCALL

SYSCALL? , . - , - . — libc. , , , :

 unsigned long find_syscall_instruction(struct library *library) { for (size_t i = 0; i < library->region_count; i++) { struct memory_region *region = &library->regions[i]; if (!(region->readable && region->executable)) continue; const uint8_t *region_data = region->content; size_t region_size = region->vaddr_high - region->vaddr_low; if (region_size < 2) continue; /* * 0F 05 syscall */ for (size_t offset = 0; offset < region_size - 1; offset++) { if (region_data[offset + 0] == 0x0F && region_data[offset + 1] == 0x05) { return region->vaddr_low + offset; } } } return 0; }

, /proc/$pid/maps . x86_64 , - . , 0x0F 0x05. , , ARM, 0xDF 0x00 ( SVC #0), .

PTRACE_{GET,SET}REGS

 int get_registers(pid_t pid, struct user_regs_struct *registers) { int err = 0; if (ptrace(PTRACE_GETREGS, pid, registers, registers) < 0) err = -errno; return err; }

struct user_regs_struct , <sys/user.h>. . . , varargs :

 static int set_regs_for_syscall(struct user_regs_struct *registers, unsigned long syscall_insn_vaddr, long syscall_number, int args_count, va_list args) { registers->rip = syscall_insn_vaddr; registers->rax = syscall_number; for (int i = 0; i < args_count; i++) { switch (i) { case 0: registers->rdi = va_arg(args, long); break; case 1: registers->rsi = va_arg(args, long); break; case 2: registers->rdx = va_arg(args, long); break; case 3: registers->r10 = va_arg(args, long); break; case 4: registers->r8 = va_arg(args, long); break; case 5: registers->r9 = va_arg(args, long); break; default: return -E2BIG; } } return 0; } static long perform_syscall(pid_t pid, unsigned long syscall_insn_vaddr, long syscall_number, int args_count, ...) { struct user_regs_struct old_registers; struct user_regs_struct new_registers; /* *    ,   *      . */ get_registers(pid, &old_registers); /* *      ,   * ,     . */ new_registers = old_registers; va_list args; va_start(args, args_count); set_regs_for_syscall(&new_registers, syscall_insn_vaddr, syscall_number, args_count, args); va_end(args); set_registers(pid, &new_registers); /* *    ,    *   ,    * (  ),    . *     . */ wait_for_syscall_completion(pid); /* *       *    . *        . */ get_registers(pid, &new_registers); long result = new_registers.rax; set_registers(pid, &old_registers); return result; }

PTRACE_SYSCALL

: , ?

PTRACE_SYSCALL. PTRACE_CONT, . , - : , .

PTRACE_SYSCALL SIGTRAP : ( ) ( ). , ptrace() , , .

, SIGTRAP:

 static int wait_for_syscall_enter_exit_stop(pid_t pid) { if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) return -1; if (wait_for_process_stop(pid, SIGTRAP) < 0) return -1; return 0; } void wait_for_syscall_completion(pid_t pid) { wait_for_syscall_enter_exit_stop(pid); wait_for_syscall_enter_exit_stop(pid); }

— , — (wait_for_process_stop() ). . , .

PTRACE_O_TRACESYSGOOD

, PTRACE_SYSCALL : , , - . , SIGTRAP ( ).

SIGTRAP . PTRACE_O_TRACESYSGOOD, :

SIGTRAP — -
SIGTRAP | 0x80 —

  int ptrace_attach(pid_t pid) { if (ptrace(PTRACE_ATTACH, pid, 0, 0) < 0) return -1; if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; + /*     */ + unsigned long options = PTRACE_O_TRACESYSGOOD; + if (ptrace(PTRACE_SETOPTIONS, pid, 0, options) < 0) + return -1; return 0; } static int wait_for_syscall_enter_exit_stop(pid_t pid) { if (ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0) return -1; - if (wait_for_process_stop(pid, SIGTRAP) < 0) + if (wait_for_process_stop(pid, SIGTRAP | 0x80) < 0) return -1; return 0; }

-

- :

 void write_shellcode(void) { char shellcode_text[SHELLCODE_TEXT_SIZE]; size_t shellcode_size = shellcode_end - shellcode_start; /*   ,  ,  . . */ prepare_shellcode(shellcode_text, shellcode_size); /*   -   */ write_remote_memory(target, shellcode_text_vaddr, shellcode_text, shellcode_size); }

- : dlopen(), .

 static inline void copy_shellcode(char *shellcode_text, const char *shellcode_addr, const void *data, size_t length) { ptrdiff_t offset = shellcode_addr - shellcode_start; memcpy(shellcode_text + offset, data, length); } static void prepare_shellcode(char *shellcode_text, size_t shellcode_size) { copy_shellcode(shellcode_text, shellcode_start, shellcode_start, shellcode_size); copy_shellcode(shellcode_text, shellcode_address_dlopen, &dlopen_vaddr, sizeof(dlopen_vaddr)); copy_shellcode(shellcode_text, shellcode_address_dlsym, &dlsym_vaddr, sizeof(dlsym_vaddr)); copy_shellcode(shellcode_text, shellcode_address_pthread_create, &pthread_create_vaddr, sizeof(pthread_create_vaddr)); copy_shellcode(shellcode_text, shellcode_address_pthread_detach, &pthread_detach_vaddr, sizeof(pthread_detach_vaddr)); copy_shellcode(shellcode_text, shellcode_address_payload, payload, sizeof(payload)); copy_shellcode(shellcode_text, shellcode_address_entry, entry, sizeof(entry)); }

, , -:

 extern const char shellcode_start[]; extern const char shellcode_address_dlopen[]; extern const char shellcode_address_dlsym[]; extern const char shellcode_address_pthread_create[]; extern const char shellcode_address_pthread_detach[]; extern const char shellcode_address_payload[]; extern const char shellcode_address_entry[]; extern const char shellcode_end[];

, .

- . /proc/$pid/mem, :

 int write_remote_memory(pid_t pid, unsigned long vaddr, const void *data, size_t size) { char path[32] = {0}; snprintf(path, sizeof(path), "/proc/%d/mem", pid); /*       */ int fd = open(path, O_WRONLY); if (fd < 0) return -1; /*     */ if (lseek(fd, vaddr, SEEK_SET) < 0) { close(fd); return -1; } /*    */ int err = do_write_remote_memory(fd, data, size); close(fd); return err; } static int do_write_remote_memory(int fd, const void *data, size_t size) { size_t left = size; /* *    ,  ,     *   ,       *      . */ while (left > 0) { ssize_t wrote = write(fd, data, left); if (wrote < 0) return -1; data += wrote; left -= wrote; } return 0; }

, - — « » . . - , .

5.

- . , : %rip -, PTRACE_SETREGS, PTRACE_CONT . .

, , . -? ?

, . , « » . , . :

(async-signal-safe)

— . dlopen() pthread_create() . - dlopen(), dlopen() ?

-, , , . , pthread_create() . , ( ). clone().

pthread_create()?

, - , ?

: clone().

, (libc) (pthread). clone() (thread control block, TCB) (thread-local storage, TLS), , . . pthread_create() , .

«», clone() libc pthread. , .

clone() :

: -?

, - : , , , .

. , , . कैसे? : exit(). , .

. exit() -:

 +.set __NR_exit, 60 .set RTLD_LAZY, 1 @@ - /* - *  . - */ - int $3 + /* + * exit(0); + */ + xor %rdi,%rdi + mov $__NR_exit,%rax + syscall

: exit() — exit() . exit() , exit() — . Linux exit_group().

. . , , PROT_EXEC:

 shellcode_stack_vaddr = remote_mmap(target, syscall_vaddr, 0, SHELLCODE_STACK_SIZE, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE | MAP_STACK | MAP_GROWSDOWN, -1, 0);

, Linux x86_64 — «» , . mmap() , clone() . , mmap() MAP_GROWSDOWN, , .

PTRACE_O_TRACECLONE

. , - . waitpid(), : , .

— PTRACE_O_TRACECLONE. . , . , , , . , PTRACE_ATTACH , .

-, :

 - unsigned long options = PTRACE_O_TRACESYSGOOD; + unsigned long options = PTRACE_O_TRACESYSGOOD | PTRACE_O_TRACECLONE; if (ptrace(PTRACE_SETOPTIONS, pid, 0, options) < 0) return -1;

-, clone(), PTRACE_EVENT_CLONE, , PTRACE_SYSCALL. :

 -void wait_for_syscall_completion(pid_t pid) +void wait_for_syscall_completion(pid_t pid, long syscall) { wait_for_syscall_enter_exit_stop(pid); + + /*  clone()   PTRACE_EVENT_CLONE */ + if (syscall == __NR_clone) + wait_for_clone_event(pid); wait_for_syscall_enter_exit_stop(pid); }

 static int wait_for_clone_event(pid_t pid) { if (ptrace(PTRACE_CONT, pid, 0, 0) < 0) return -1; int event = SIGTRAP | (PTRACE_EVENT_CLONE << 8); if (wait_for_process_stop(pid, event) < 0) return -1; return 0; }

clone() PID , . :

 void clear_ptrace_options(pid_t pid) { ptrace(PTRACE_SETOPTIONS, pid, 0, 0); }

, clone() ptrace(), PTRACE_O_TRACECLONE. , , - .

, - . clone() :

 static int spawn_shell_thread() { shell_tid = remote_clone(target, syscall_ret_vaddr, CLONE_FILES | CLONE_FS | CLONE_IO | CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_THREAD | CLONE_VM, /*   **  */ shellcode_stack_vaddr + SHELLCODE_STACK_SIZE); if (!shell_tid) return -1; return 0; }

clone() : , , , . , .

CLONE_FILES, CLONE_FS, CLONE_IO, CLONE_SIGHAND, CLONE_SYSVSEM, CLONE_VM — . , CLONE_FILES , ( fork()). — — , . . , CLONE_VM , , .

CLONE_THREAD : Linux — « », . , , getpid() , kill() — - , execve() — , .

, clone() fork(): , . clone() : , — . . ( , , .)

, pthread_create() , , . ?

fork() :

 pid_t child = fork(); if (child < 0) { /* fork() ,    */ } if (child == 0) { /*     execve() */ } /*     */

, . clone() . .

. , clone() , . syscall ret, , . .

SYSCALL + RET

, . , syscall ret:

 -if (region_size < 2) +if (region_size < 3) continue; /* * 0F 05 syscall + * C3 retq */ -for (size_t offset = 0; offset < region_size - 1; offset++) { +for (size_t offset = 0; offset < region_size - 2; offset++) { if (region_data[offset + 0] == 0x0F && - region_data[offset + 1] == 0x05) + region_data[offset + 1] == 0x05 && + region_data[offset + 2] == 0xC3) { return region->vaddr_low + offset; } }

, .

. prepare_shellcode() , , :

  void write_shellcode(void) { char shellcode_text[SHELLCODE_TEXT_SIZE]; size_t shellcode_size = shellcode_end - shellcode_start; /*   ,  ,  . . */ prepare_shellcode(shellcode_text, shellcode_size); /*   -   */ write_remote_memory(target, shellcode_text_vaddr, shellcode_text, shellcode_size); + /*    «»   */ + unsigned long retaddr_vaddr = + shellcode_stack_vaddr + SHELLCODE_STACK_SIZE - 8; + write_remote_memory(target, retaddr_vaddr, + &shellcode_text_vaddr, sizeof(shellcode_text_vaddr)); }

, , .

, , . System V ABI , ( %rsp) 16 . shellcode_stack_vaddr + SHELLCODE_STACK_SIZE : ( 4096 ), 1 . 8 , , retq, - . - :

 - sub $8,%rsp + sub $16,%rsp /*   */ mov %rsp,%rdi xor %rsi,%rsi mov %rax,%rdx xor %rcx,%rcx mov shellcode_address_pthread_create(%rip),%rax callq *%rax

, %rsp 16 pthread_create(). SIGSEGV, — pthread_create() , .

, - , clone():

  static int spawn_shell_thread() { shell_tid = remote_clone(target, syscall_ret_vaddr, CLONE_FILES | CLONE_FS | CLONE_IO | CLONE_SIGHAND | CLONE_SYSVSEM | CLONE_THREAD | CLONE_VM, /*   **  */ - shellcode_stack_vaddr + SHELLCODE_STACK_SIZE); + shellcode_stack_vaddr + SHELLCODE_STACK_SIZE - 8); if (!shell_tid) return -1; return 0; }

ptrace() SIGSTOP, :

 int ignore_thread_stop(pid_t pid) { return wait_for_process_stop(pid, SIGSTOP); }

. ptrace():

 void resume_thread(pid_t pid) { ptrace(PTRACE_CONT, pid, 0, 0); }

, , , exit(). waitpid(). — CLONE_THREAD wait() ,— PTRACE_O_TRACECLONE, :

 int wait_for_process_exit(pid_t pid) { int status = 0; if (waitpid(pid, &status, 0) < 0) return -1; if (!WIFEXITED(status)) return -1; return WEXITSTATUS(status); }

pthread , , pthread_join() pthread , . , — . , , .

मुक्त स्मृति

, - . , - , munmap():

 void remote_munmap(pid_t pid, unsigned long syscall_insn_vaddr, unsigned long addr, size_t len) { perform_syscall(pid, syscall_insn_vaddr, __NR_munmap, 2, (long) addr, (long) len); } static void unmap_shellcode() { remote_munmap(target, syscall_ret_vaddr, shellcode_text_vaddr, SHELLCODE_TEXT_SIZE); remote_munmap(target, syscall_ret_vaddr, shellcode_stack_vaddr, SHELLCODE_STACK_SIZE); }

, , , — ptrace() . (, SIGSTOP), , ( ):

 int stop_thread(pid_t pid) { if (kill(pid, SIGSTOP) < 0) return -1; if (wait_for_process_stop(pid, SIGSTOP) < 0) return -1; return 0; }

, , . PTRACE_DETACH:

 int ptrace_detach(pid_t pid) { if (ptrace(PTRACE_DETACH, pid, 0, 0) < 0) return -1; return 0; }

, . , . , .

निष्कर्ष

? . , , .

गनोम कंट्रोल सेंटर में इंजेक्शन प्रदर्शन

Linux . GTK+ . , make:

 libpayload.so: payload.c $(CC) $(CFLAGS) $(shell pkg-config --cflags --libs gtk+-3.0) -shared -o $@ $<

entry() GTK- — GTK UI , :

 #include <glib.h> #include <gtk/gtk.h> static gboolean actual_entry(gpointer _arg) { /*       : */ hook_gtk_entry_constructor(); /*   FALSE,       */ return FALSE; } void entry(void) { /*    -,   */ g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, actual_entry, NULL, NULL); }

, GTK , GtkEntry . "input-purpose" . «», , .

GTK glib — — GtkEntry . constructed(), . :

 static void (*old_gtk_entry_constructed)(GObject *object); static void new_gtk_entry_constructed(GObject *object) { GtkEntry *entry = GTK_ENTRY(object); /*    */ old_gtk_entry_constructed(object); /*    ,  ,   entry */ } static void hook_gtk_entry_constructor(void) { /*     GtkEntry */ GTypeClass *entry_type_class = g_type_class_peek(GTK_TYPE_ENTRY); GObjectClass *entry_object_class = G_OBJECT_CLASS(entry_type_class); /* *     "constructed"     . */ old_gtk_entry_constructed = entry_object_class->constructed; entry_object_class->constructed = new_gtk_entry_constructed; }

GtkEntry :

, GtkEntry , , . , :

 static void new_gtk_entry_constructed(GObject *object) { GtkEntry *entry = GTK_ENTRY(object); old_gtk_entry_constructed(object); /*       */ g_signal_connect(entry, "notify::input-purpose", G_CALLBACK(input_purpose_changed), NULL); /*      */ g_signal_connect(entry, "icon-press", G_CALLBACK(icon_pressed), NULL); /*      */ g_signal_connect(entry, "icon-release", G_CALLBACK(icon_released), NULL); }

. , . .

 static void input_purpose_changed(GtkEntry *entry) { GtkInputPurpose purpose = gtk_entry_get_input_purpose(entry); if (purpose == GTK_INPUT_PURPOSE_PASSWORD) { gtk_entry_set_icon_activatable(entry, GTK_ENTRY_ICON_PRIMARY, TRUE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-remove"); } else { gtk_entry_set_icon_activatable(entry, GTK_ENTRY_ICON_PRIMARY, FALSE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, NULL); } }

: , , , - , :

 static void icon_pressed(GtkEntry *entry, GtkEntryIconPosition position) { if (position != GTK_ENTRY_ICON_PRIMARY) return; gtk_entry_set_visibility(entry, TRUE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-add"); } static void icon_released(GtkEntry *entry, GtkEntryIconPosition position) { if (position != GTK_ENTRY_ICON_PRIMARY) return; gtk_entry_set_visibility(entry, FALSE); gtk_entry_set_icon_from_icon_name(entry, GTK_ENTRY_ICON_PRIMARY, "list-remove"); }

वह सब है।

GitHub (GPLv2).

, . gdb :

 $ gdb --pid $(pgrep target) \ --batch \ -ex 'compile file -raw shell-code.c'

लिनक्स के लिए CreateRemoteThread