असुरक्षा शोषण करण्याचा एक नजर

मी या विषयावर चर्चा सुरू ठेवण्याची अपेक्षा करीत असता, मी आपणास थोडा इतिहास, सिद्धांत आणि असुरक्षिततेवर सराव करू देतो. आम्ही सर्व आतापर्यंत ऐकले आहे की सुरक्षिततेच्या त्रुटींमध्ये खूप किंमत असू शकते, आम्हाला माहित आहे की आम्हाला आपले सॉफ्टवेअर अद्ययावत ठेवणे आवश्यक आहे, आपल्या सर्वांना माहित आहे की बरीच अद्यतने सुरक्षा बगमुळे उद्भवली आहेत. परंतु आज मी या त्रुटी कशा सापडतात आणि त्यांचे शोषण कसे केले याबद्दल थोडेसे सांगेन 🙂 परंतु यापूर्वी आम्ही अधिक विहंगावलोकन करण्यासाठी आम्ही काही तपशील स्पष्ट करणार आहोत.

आपण प्रारंभ करण्यापूर्वी

प्रथम मी तुम्हाला सांगू इच्छितो की आम्ही ज्या प्रथम असुरक्षिततेचा फायदा घेऊ शकतो त्याबद्दल आम्ही लक्ष केंद्रित करणार आहोत बफर ओव्हरफ्लो, या असुरक्षिततेमध्ये आम्ही मजेदार गोष्टी करण्यासाठी मेमरी पडताळणीच्या अभावाचा फायदा घेतो 🙂 परंतु त्याबद्दल थोडे अधिक स्पष्टीकरण देऊया.

हे वास्तविक जगातील परिस्थिती होणार नाही

त्यांना दिसणारा कोणताही कार्यक्रम खंडित करण्यास मी त्यांना परवडत नाही - प्रथम कारण ते त्यांच्या संगणकांसाठी धोकादायक आहे, दुसरे कारण ते माझ्या नेहमीच्या शब्दांच्या कोट्यापेक्षा जास्त घेतील.

आम्ही 80 च्या प्रवासाला निघालो

मी आपल्या लॅपटॉपवर काय करू शकतो हे मी तुम्हाला दाखवणार आहे, परंतु याचा अर्थ असा नाही की आज ते एका सोप्या मार्गाने केले जाऊ शकते these यापैकी अनेक संकल्पना यापूर्वीच बर्‍याच वेळा शोषल्या गेल्या आहेत की नवीन संरक्षण पद्धती आणि नवीन पद्धती टाळण्यासाठी आहेत ते उदयास आले आहेत - परंतु ते आम्हाला त्याच ठिकाणी परत करते, हे सर्व सांगण्यात सक्षम होण्यासाठी जागा नाही is

हे कदाचित आपल्या प्रोसेसरवर कार्य करणार नाही

जरी मी एक अगदी साधे उदाहरण वापरणार आहे, परंतु मला हे सुरुवातीपासूनच अगदी स्पष्टपणे सांगावेसे वाटले आहे की या गोष्टीचे तपशील बरेच आणि इतके वैविध्यपूर्ण आहेत की जसे आपण प्रयत्न करू इच्छित असाल तर ते माझ्यासारखेच बाहेर येऊ शकेल. , इच्छित प्रभाव देखील साध्य होणार नाही 🙂 परंतु आपण कल्पना करू शकता की मी या जागेवर हे स्पष्ट करू शकत नाही, विशेषत: कारण या परिचयात मी आधीच 300 हून अधिक शब्द घेतले आहेत, म्हणून आपण थेट आपल्या मुद्द्यावर पोहोचू.

काय आहे ए बफर ओव्हरफ्लो

याचे उत्तर देण्यासाठी आम्हाला प्रथम या संयोजनाचा पूर्वार्ध समजला पाहिजे.

बफर्स

प्रत्येक गोष्ट संगणकात मेमरीबद्दल असल्यामुळे, त्यामध्ये काही प्रकारचे माहिती कंटेनर असणे आवश्यक आहे हे तर्कसंगत आहे. जेव्हा आपण याबद्दल बोलतो इनपुट o आउटपुट, आम्ही थेट संकल्पनेत येऊ बफर. ते लहान ठेवण्यासाठी, ए बफर हे परिभाषित आकाराचे एक मेमरी स्पेस आहे ज्यामध्ये आम्ही माहितीची साधी साठवण करणार आहोत

नावाप्रमाणेच ओव्हरफ्लोज उद्भवतात, जेव्हा एखादा बफर त्याच्याकडे ठेवण्यापेक्षा अधिक माहिती भरतो. पण हे महत्वाचे का आहे?

स्टॅक

स्टॅक म्हणून देखील ओळखले जाते, हा एक अमूर्त डेटा प्रकार आहे ज्यामध्ये आपण करू शकतो स्टॅक माहिती, त्यांचे मुख्य वैशिष्ट्य आहे की त्यांच्याकडे ऑर्डर आहे LIFO (शेवटच्या शेवटी प्रथम). प्लेट्सच्या स्टॅकबद्दल सेकंदाचा विचार करूया, आम्ही त्यांना एकामागून एक वर ठेवले, आणि मग वरून आम्ही त्यांना एक एक काढतो, यामुळे आम्ही ठेवलेली शेवटची प्लेट बनते (शीर्षस्थानी असलेली एक) ) आम्ही काढत असलेली पहिली प्लेट आहे, अर्थात आम्ही एकाच वेळी फक्त एक प्लेट बाहेर काढू शकलो आणि त्या त्या क्रमाने करण्याचा निर्णय घेतला तरः पी.

आता आपल्याला या दोन संकल्पना माहित आहेत तेव्हा आम्हाला त्या व्यवस्थित लावाव्या लागतील. स्टॅक महत्वाचे आहेत कारण आपण चालवित असलेल्या प्रत्येक प्रोग्रामचे स्वतःचे असते एक्झिक्यूशन स्टॅक. पण या स्टॅकला ए विशिष्ट वैशिष्ट्यपूर्ण, खाली वाढते. आपल्याला या बद्दल फक्त एक गोष्ट माहित असणे आवश्यक आहे ती अशी की एखादा प्रोग्राम चालू असताना, जेव्हा एखादा फंक्शन कॉल केला जातो तेव्हा स्टॅक मेमरी X मधील एका क्रमांकावरून (एक्सएन) वर जातो. परंतु सुरू ठेवण्यासाठी आम्हाला आणखी एक संकल्पना समजली पाहिजे.

पॉईंटर्स

ही एक संकल्पना आहे जी बर्‍याच प्रोग्रामरना वेगाने वळवते जेव्हा ते सीच्या जगात प्रारंभ करतात, खरं तर सी प्रोग्रामिंगची महान शक्ती पॉईंटर्सच्या वापरामुळे भाग आहे. हे सोपे ठेवण्यासाठी, एक पॉईंटर मेमरी पत्त्याकडे निर्देश करतो. हे गुंतागुंतीचे वाटते, परंतु हे गुंतागुंतीचे नाही, आपल्या सर्वांमध्ये आमच्या मशीनमध्ये रॅम आहे, बरोबर? पण, हे ए म्हणून परिभाषित केले जाऊ शकते अवरोधांची सलग व्यवस्था, ही स्थाने सामान्यत: हेक्झाडेसिमल संख्यांमधून (0 ते 9 पर्यंत आणि नंतर ए ते फॅ पर्यंत, 0x0, 0x1, 0x6, 0xA, 0xF, 0x10) व्यक्त केली जातात. येथे एक जिज्ञासू नोट, 0x10 नाही 10 equal च्या बरोबरीने आपण हे दशांश क्रमानुसार रुपांतरित केले तर ते 15 म्हणण्यासारखेच असेल. ही अशी गोष्ट आहे जी पहिल्यांदा एकापेक्षा जास्त लोकांना गोंधळात टाकते, परंतु आपण त्याकडे जाऊ.

नोंदी

प्रोसेसर असंख्य काम करतात रेकॉर्ड, जे प्रोसेसरकडे भौतिक मेमरीपासून स्थान हस्तांतरित करण्याचे काम करतात, आर्किटेक्चर जे 64 XNUMX-बिट वापरतात, त्या रजिस्टरची संख्या येथे वर्णन करणे खूप मोठे आणि अवघड आहे, परंतु कल्पना जाणून घेण्यासाठी, रजिस्टर पॉईंटर्ससारखे असतात, ते इतर गोष्टींमध्ये देखील सूचित करतात. , एक मेमरी स्पेस (स्थान).

आता सराव

मला माहित आहे की आतापर्यंत प्रक्रिया करण्यासाठी बर्‍याच माहिती आहे, परंतु प्रत्यक्षात ते काही जटिल समस्या आहेत ज्या मी मी अगदी सोप्या पद्धतीने स्पष्ट करण्याचा प्रयत्न केला आहे, आम्ही एक छोटासा कार्यक्रम पाहणार आहोत ज्यामध्ये बफर वापरतात आणि आम्ही जात आहोत ओव्हरफ्लोजबद्दल हे समजून घेण्यासाठी तो मोडा, अर्थात हे वास्तव नाही, हा एक वास्तविक कार्यक्रम आहे आणि आज वापरल्या जाणा many्या बर्‍याच प्रतिवादांना आपण "टाळायला" जात आहोत, फक्त त्या आधी गोष्टी कशा घडल्या हे दाखवण्यासाठी आणि त्यातील काही अधिक जटिल गोष्टी शिकण्यास तत्त्वे आवश्यक आहेत 😉

जीडीबी

एक उत्कृष्ट प्रोग्राम जो निःसंशयपणे सी प्रोग्रामरद्वारे वापरला जाणारा सर्वात एक आहे.त्याच्या पुष्कळ सद्गुणांपैकी आम्हाला हे सत्य आहे की आपण आतापर्यंत ज्या सर्व गोष्टींबद्दल बोलत आहोत त्या सर्व आपल्याला पाहण्याची परवानगी देते, नोंदी, स्टॅक, बफर इ. 🙂 आपण आपल्या प्रोग्रामसाठी वापरणार असलेला प्रोग्राम पाहू.

retinput.c

हा बर्‍यापैकी सोपा प्रोग्राम आहे, आम्ही ग्रंथालय वापरणार आहोत stdio.h टर्मिनलवर माहिती मिळवून ते प्रदर्शित करण्यात सक्षम होण्यासाठी. आपल्याला म्हणतात फंक्शन दिसेल return_input जे निर्माण करते बफर म्हणतात अॅरे, ज्याची लांबी 30 आहे बाइट (चार्ट डेटा प्रकार 1 बाइट लांब आहे).

कार्य gets(array); कन्सोल आणि कार्य द्वारे माहिती विनंती printf() अ‍ॅरेची सामग्री परत करते आणि ती स्क्रीनवर प्रदर्शित करते.

सी मध्ये लिहिलेला प्रत्येक प्रोग्राम फंक्शनने सुरू होतो main(), हे फक्त रिटर्न_इंटपुट कॉल करण्यासाठी असेल, आता आपण प्रोग्राम संकलित करणार आहोत.

आता मी काय केले ते थोडे घेऊया. पर्याय -ggdb जीसीबी ला प्रोग्राम योग्य प्रकारे डीबग करण्यास सक्षम होण्यासाठी माहिती संकलित करण्यास सांगते. -fno-stack-protector हा एक पर्याय आहे जे स्पष्टपणे आम्ही वापरत नसावेत, परंतु आम्ही ते वापरत आहोत कारण अन्यथा स्टॅकमध्ये बफर ओव्हरफ्लो तयार करणे शक्य होईल. शेवटी मी परीक्षेची चाचणी घेतली. ./a.out मी नुकतेच संकलित केलेले ते चालवते, ती माहिती विचारते आणि परत करते. धावणे 🙂

चेतावणी

येथे आणखी एक टीप. आपण चेतावणी पाहू शकता? स्पष्टपणे जेव्हा आपण कोडसह काम करतो तेव्हा कंपाईल करतो तेव्हा हे लक्षात घेण्यासारखे काहीतरी आहे, हे थोडी स्पष्ट आहे आणि आज असे काही प्रोग्राम आहेत जे कार्य करीत आहेत. gets() कोडमध्ये जेंटूचा एक फायदा असा आहे की प्रत्येक प्रोग्रामचे संकलन करून, मी काय चुकीचे असू शकते ते पाहू शकतो, "आदर्श" प्रोग्राममध्ये तो असू नये, परंतु आपल्याला किती आश्चर्य वाटेल की किती मोठ्या प्रोग्राममध्ये हे इशारे आहेत कारण ते फक्त बरेच मोठे आहेत आणि ते आहे एकाच वेळी बर्‍याच चेतावणी असताना धोकादायक कार्ये. जर आपण पुढे चालू ठेवले तर

प्रोग्राम डीबग करत आहे

आता हा भाग जरा गोंधळात टाकू शकतो, परंतु मी आधीच पुरेसे लिहिले आहे म्हणून सर्वकाही समजावून सांगणे मला परवडत नाही, म्हणून जर मी पाहिले की मी खूप वेगवान आहे if

कोड निराकरण करत आहे

आमच्या कंपाईल मशीन भाषेचा कार्यक्रम पाहून प्रारंभ करूया.

ही आमच्या मुख्य फंक्शनची कोड आहे विधानसभा, हा आपला प्रोसेसर समजतो, डावीकडील ओळ स्मृतीमधील भौतिक पत्ता आहे <+ एन> म्हणून ओळखले जाते ऑफसेटमूलत: फंक्शनच्या सुरूवातीपासून (मुख्य) त्या विधानाचे अंतर (म्हणून ओळखले जाते) ऑपकोड). मग आम्ही निर्देशांचा प्रकार (पुश / मूव्ह / कॉलक…) आणि एक किंवा अधिक नोंदणी पहा. सारांश आम्ही असे म्हणू शकतो की ते स्त्रोत / मूळ आणि गंतव्यस्थान त्यानंतरचे संकेत आहे. <return_input> आमच्या दुस function्या फंक्शनचा संदर्भ देतो, चला आता जरा पाहू.

रिटर्न_इनपुट

हे जरा जास्त गुंतागुंतीचे आहे, परंतु मी तुम्हाला फक्त दोन गोष्टी तपासून पाहू इच्छितो, एक टॅग आहे <gets@plt> आणि एक शेवटचा ऑपकोड म्हणतात retq फंक्शनचा शेवट दर्शविणारा. फंक्शनमधे आम्ही काही ब्रेकपॉइंट्स ठेवणार आहोत gets आणि दुसरा मध्ये retq.

चालवा

आता कृती कशी सुरू होते हे पाहण्यासाठी आपण प्रोग्राम चालवणार आहोत.

आपण पाहू शकतो की एक छोटा बाण आपण जेथे आहोत तेथील ओपकोड दर्शवितो, मी त्यांना दिशेने विचारात घेऊ इच्छितो 0x000055555555469b, कॉल केल्यावर हा पत्ता आहे return_input कार्य मध्ये main , हे महत्त्वाचे आहे कारण आपण जेव्हा हे प्राप्त करणे समाप्त केले तेव्हा प्रोग्राम परत आला पाहिजे इनपुटचला फंक्शन मध्ये जाऊ. फंक्शनमध्ये प्रवेश करण्यापूर्वी आपण मेमरी तपासणार आहोत gets.

मी तुमच्यासाठी मुख्य कार्य पुन्हा ठेवले आहे आणि मी ज्या कोडचा संदर्भ देत होता त्याचा कोड हायलाइट केला आहे, जसे की तुम्ही पाहू शकता शेवट दोन विभागांमध्ये विभक्त केले गेले आहे, आपण दिशा विचारात घ्यावी अशी माझी इच्छा आहे 0x7fffffffdbf0 (कमांडो नंतर डावीकडून पहिला x/20x $rsp) हे निकाल आम्हाला तपासण्यासाठी वापरायचे हे स्थान असल्याने, सुरू ठेवा:

कार्यक्रम ब्रेकिंग

मी त्यांना ठळक केले आहे 0x44444444कारण ते आमच्या डी चे प्रतिनिधीत्व आहेत 🙂 आता आम्ही जोडण्यास सुरवात केली आहे इनपुट प्रोग्रामला आणि जसे आपण पाहू शकता की आम्ही आमच्या इच्छित पत्त्यापासून फक्त दोन ओळी आहोत, आम्ही मागील चरणात ठळक केलेल्या पत्त्यांपर्यत आम्ही तो भरणार आहोत.

परतीचा मार्ग बदलत आहे

आता आम्ही कोडचा हा विभाग प्रविष्ट करण्यास व्यवस्थापित केला आहे जेथे तो फंक्शनचा परतीचा संकेत देतो, आपण पत्ता बदलल्यास काय होते ते पाहूया - त्या क्षणी आपल्या आधीच्या ओपनकोडच्या जागी ओपनकोडच्या ठिकाणी जाण्याऐवजी, आम्ही परत गेलो तर आपल्याला काय वाटते? return_input? परंतु यासाठी, आम्हाला बायनरीमध्ये हवा असलेला पत्ता लिहिणे आवश्यक आहे, आम्ही हे फंक्शनद्वारे करणार आहोत printf बॅश पासून from

आता आम्हाला दोनदा माहिती प्राप्त झाली आहे - निश्चितच प्रोग्राम त्या साठी बनलेला नव्हता, परंतु आम्ही कोड तोडून व्यवस्थापित केले आहे आणि असे करू नये अशी काहीतरी पुनरावृत्ती केली आहे.

परावर्तन

हा साधा बदल मानला जाऊ शकतो a शोषण करणे खूप मूलभूत - तो कार्यक्रम तोडण्यात यशस्वी झाला आहे आणि आम्ही त्याला करू इच्छित असे काहीतरी केले आहे.

पाहण्याच्या आणि जोडण्याच्या जवळजवळ असीम यादीतील ही फक्त पहिली पायरी आहे, फक्त ऑर्डरची पुनरावृत्ती करण्यापेक्षा आणखी काही गोष्टी समाविष्ट करण्याचे मार्ग आहेत, परंतु यावेळी मी बरेच काही लिहिले आहे आणि संबंधित सर्वकाही शेलकोडिंग मी म्हणेन, लेखांपेक्षा लेख आणि पूर्ण पुस्तके यापेक्षा अधिक लिहिणे हा विषय आहे. क्षमस्व मला आवडलेल्या विषयांवर मी आणखी काही शोधू शकलो नसतो, परंतु नक्कीच तेथे संधी मिळेल - ग्रीटिंग्ज आणि येथे आल्याबद्दल धन्यवाद.