👕 🔓 🚏 आईडीए मुफ़्त और अन्य मुफ्त टूल का उपयोग करके शोषण और उलट करने का परिचय। अध्याय 2 ☹️ 💗 🖖🏾

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

अभ्यास शुरू करने से पहले आइए कुछ अवधारणाओं को देखें।

BAG क्या है?

BAG कंप्यूटर प्रोग्राम (सॉफ़्टवेयर) या कंप्यूटर बनाने की प्रक्रिया में विफलता या कमी का परिणाम है। निर्दिष्ट विफलता सॉफ़्टवेयर जीवन चक्र के किसी भी चरण में हो सकती है, हालांकि विकास और प्रोग्रामिंग चरण में सबसे स्पष्ट विफलता होती है।

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

प्रश्न BAG और VULNERABILITY के बीच अंतर जानने के लिए है, तो आइए देखें कि VULNERABILITY क्या है।

VULNERABILITY क्या है?

VULNERABILITY एक प्रोग्राम में एक निश्चित प्रकार का बग है जो इसे कंप्यूटर सिस्टम की सुरक्षा का उल्लंघन करने के लिए उपयोग करने की अनुमति देता है।

इस प्रकार, कमजोरियां आपको उन कार्यों को करने की अनुमति देती हैं जिनके लिए कार्यक्रम का इरादा नहीं था, और उनका दुरुपयोग करें।

दूसरे शब्दों में, भेद्यता एक निश्चित प्रकार की बग है, उनके बीच एक उपसमुच्चय।

बेशक, कई प्रकार की कमजोरियां हैं। हम विन्डोज़ में कमजोरियों के अध्ययन और शोषण पर ध्यान केंद्रित करने जा रहे हैं।

EXPLOIT क्या है?

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

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

पहले प्रकार की कमजोरियों की हम जांच करेंगे कि बफर ओवरफ्लो होगा। हम सबसे सरल उदाहरणों से शुरू करेंगे, और फिर हम धीरे-धीरे जटिलता बढ़ाएंगे।

सबसे पहले, सिस्टम की सुरक्षा सुविधाएँ सक्रिय नहीं होंगी, लेकिन धीरे-धीरे हम यह पता लगाने के लिए उन्हें सक्रिय करेंगे कि हम उनसे कैसे और किन स्थितियों में निपट सकते हैं।

एक खरीदार क्या है?

BUFFER डेटा भंडारण और प्रबंधन के लिए आरक्षित एक निश्चित आकार की मेमोरी स्पेस है।

एक मूल उदाहरण 20 लीटर जार है, जो मेरे पास सामग्री रखने के लिए है। यह 20 लीटर से कम या बराबर हो सकता है, जो कि अधिकतम आकार है। यदि आप एक टैंक में अधिक स्टोर करना चाहते हैं, तो आपको बफर के आकार को बढ़ाने का एक तरीका खोजना होगा, अन्यथा जब आप बचाने की कोशिश करते हैं, उदाहरण के लिए, 20-लीटर कैन में 40 लीटर, यह ओवरफ्लो हो जाएगा।

एक खरीदार क्या है?

BUFFER OVERFLOW तब होता है जब कंप्यूटर प्रोग्राम किसी सन्निहित मेमोरी ब्लॉक में डेटा लिखकर उसके लिए आरक्षित मेमोरी की मात्रा से अधिक हो जाता है।

https://www.welivesecurity.com/la-es/tag/buffer-overflow-la-es

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

बफर ओवरफ्लो के सबसे सामान्य प्रकार स्टैक बफर ओवरफ्लो और हीप बफर ओवरफ्लो हैं।

यहां हम बफर ओवरफ्लो की परिभाषा देखते हैं, और हमारे पिछले उदाहरण में, अगर मैं 20 लीटर टैंक में 40 लीटर डालने की कोशिश करता हूं, तो यह ओवरफ्लो हो जाएगा, जैसा कि हम इसे समझते हैं। यह एक अतिप्रवाह है जो एक बफर अतिप्रवाह का कारण बनता है, अर्थात। जब मेरी अधिकतम क्षमता पार हो जाती है तो मेरे टैंक का ओवरफ्लो।

अब स्टैक और ढेर के बीच का अंतर स्पष्ट करें।

STACK क्या है?

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

बहुत कुछ क्या है?

हीप का उपयोग गतिशील मेमोरी को आरक्षित करने के लिए किया जाता है, जिसका उपयोगी जीवन पहले से ज्ञात नहीं है, लेकिन उम्मीद है कि यह कुछ समय तक चलेगा। यदि हम इसके आकार को नहीं जानते हैं या इसे रनटाइम पर निर्धारित किया जाता है, तो आकार की गणना और ढेर पर आरक्षित होनी चाहिए।

ढेर का उपयोग उन वस्तुओं के लिए भी किया जाता है जो आकार में भिन्न होते हैं क्योंकि हम संकलन समय पर नहीं जानते हैं कि उनका उपयोग कब तक किया जाएगा।

मैं शोषण के लेखक के रूप में 13 वर्षों से अधिक समय से हमारी कंपनी में काम कर रहा हूं, और पहली बात यह है कि हम सभी किराए के लोगों के साथ भी करते हैं, जब मैंने ज्वाइन किया था, तो प्रसिद्ध गेरार्ड रिचर्ट के ढेर और ढेर को हटाने की कोशिश की थी। वह CORE SECURITY के संस्थापक और एक शोषण विश्लेषण गुरु हैं।

हम सबसे सरल स्टैक के साथ धीरे-धीरे शुरू करेंगे। बेशक, जैसा कि मैंने कहा, वे इस समय न्यूनतम संरक्षण के साथ संकलित हैं और ऑपरेशन की सुविधा के लिए 32-बिट हैं।

STACK1 कार्य के लिए स्रोत कोड देखें।

https://drive.google.com/open?id=16btJAetpa1V5yHDZE2bnnFWTQNpsUR4H

हम अभ्यास के साथ एक फ़ोल्डर देखते हैं, और अंदर स्रोत कोड STACK1 है जिसे STACK1 -VS_2017.CPP कहा जाता है।

#define _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_DEPRECATE

#include <stdlib.h>
#include  <stdio.h> 
#include "Windows.h"


int main(int argc, char **argv) 
{


	MessageBoxA((HWND)-0, (LPCSTR) "Imprimir You win..\n", (LPCSTR)"Vamosss", (UINT)0);

	int cookie;
	char buf[80];

	printf("buf: %08x cookie: %08x\n", &buf, &cookie);
	gets(buf);

	if (cookie == 0x41424344) printf("you win!\n");

}

हम इस कोड को समझने की कोशिश करेंगे और देखेंगे कि बफर ओवरफ्लो कहां हो सकता है, और क्या यह स्टैक पर या ढेर पर एक बफर ओवरफ्लो होगा।

MessageBoxA फ़ंक्शन कॉल STACK1 स्रोत कोड में जोड़ा गया था ताकि हमें एक छोटा संदेश दिखाया जा सके जो हमें इसे हल करने के लिए प्रेरित कर रहा था। यह सिर्फ एक जोड़ है जो कुछ भी प्रभावित नहीं करता है। यह निर्दिष्ट विंड फ़ंक्शन के लिए एक मानक कॉल है, जिसका हम यहां विश्लेषण नहीं करेंगे।

इस फ़ंक्शन की जानकारी किसे चाहिए, आप इसे यहां प्राप्त कर सकते हैं।

हम जानते हैं कि फ़ंक्शन के अंदर, यदि स्थानीय चर हैं, तो आपको उनके लिए एक स्थान आरक्षित करना होगा।

इसलिए हम GERARDO RICHART द्वारा बनाए गए इस स्रोत कोड के साथ बचे हैं।

int main(int argc, char **argv) 
{

	int cookie;
	char buf[80];

	printf("buf: %08x cookie: %08x\n", &buf, &cookie);
	gets(buf);

	if (cookie == 0x41424344) printf("you win!\n");

}

हम कार्यक्रम के पहले भाग को लाल रंग में देखते हैं, जहां स्थानीय चर के लिए आरक्षित स्थान है। इस मामले में, दो स्थानीय चर, कूकी और बीयूएफ हैं।

आप तालिका में डेटा प्रकार देख सकते हैं । अन्य प्रकार के चर भी वहां स्थित हैं।

कोड को 32 बिट्स में संकलित किया जाएगा।

हम देखते हैं कि COOKIE वैरिएबल INT का होगा, इसलिए मेमोरी के 4 बाइट्स इस वैरिएबल के लिए आरक्षित होंगे।

बीयूएफ चर के मामले में, हम देखते हैं कि यह एक सरणी या वर्णों का एक स्ट्रिंग है (वर्ण आकार = 1 बाइट)।

उन। यह 80 वर्णों की एक सरणी होगी, अर्थात इसकी लंबाई 80x1 = 80 बाइट होगी।

जो कोई यह नहीं जानता है कि एक सरणी इसके बारे में क्या पढ़ सकती है:

https://www.programiz.com/c-programming/c-arrays

इस प्रकार, एक सरणी एक ही डेटा प्रकार के कई मानों को संग्रहीत कर सकती है। आपको बस उसे बताना होगा कि किस प्रकार का डेटा होगा और कितना होगा।

पहले उदाहरण में, यह पूर्णांक का एक सरणी है, अर्थात। यह 100 बाइट्स होगा, और चूंकि प्रत्येक पूर्णांक 4 बाइट्स लेता है, सरणी की लंबाई 100 x 4 = 400 बाइट्स होगी।

दूसरे उदाहरण में, FLOAT में 4 बाइट्स लगते हैं, इसलिए यह 5 FLOAT की एक सरणी होगी, इसलिए इसकी लंबाई 5 x 4 = 20 बाइट्स होगी।

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

हमारे व्यायाम पर लौटना:

char buf[80];

यह वर्णों की एक सरणी है 80 x 1 = 80 बाइट्स लंबा, अर्थात्। यह हमारे 20 लीटर जार जैसा दिखता है। अगर हम 80 से ज्यादा बाइट्स स्टोर करने की कोशिश करते हैं, तो बैंक ओवरफ्लो हो जाएगा।

अब देखते हैं कि BUF बफर का उपयोग कहां किया जाता है।

हम देखते हैं कि लाल तीरों से चिह्नित दो स्थानों पर बफर का उपयोग किया जाता है।

पहले निर्देश में एक PRINTF फ़ंक्शन है, जिसका उपयोग कंसोल में एक संदेश प्रदर्शित करने के लिए किया जाता है, जो एक उद्धृत स्ट्रिंग होगा।

"buf: %08x cookie: %08x\n"

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

इस मामले में, हमारे पास दो% एक्स प्रारूप हैं, इसलिए, अगर मैं PRINTF प्रारूप तालिका का संदर्भ देता हूं:

हम देखते हैं कि फ़ंक्शन इन पूर्णांकों (INT) को ले जाएगा और उन्हें संख्या प्रणाली 16 के आधार के साथ आउटपुट लाइन में सम्मिलित करेगा, अर्थात। हेक्साडेसिमल प्रारूप में। 08 इंगित करता है कि यदि संख्या में 8 अंक से कम है, तो फ़ंक्शन इसे रिक्त स्थान के साथ भर देगा।

"Buf:% 31x" के लिए आउटपुट, और buf इस तरह होगा

buf:             19FED4

हम देखते हैं कि इस उदाहरण में संख्या से पहले रिक्त स्थान भरे हुए हैं। आउटपुट को दिखाने के लिए कई संशोधक हैं।

सभी संभावित मामलों को यहां सूचीबद्ध किया गया है:

http://www.cplusplus.com/reference/cstdio/printf/

हमारा मामला यह है:

हम देखते हैं कि परिणाम छोटा नहीं है, यह केवल रिक्त स्थान से भरा हुआ है यदि सम्मिलित करने के लिए तर्क की लंबाई मान से कम है एक्स से पहले।

इसलिए, हम जानते हैं कि फ़ंक्शन दो हेक्साडेसिमल संख्याओं को प्रिंट करता है, जो दो तर्कों से प्राप्त होते हैं।

printf("buf: %08x cookie: %08x\n", &buf, &cookie);

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

यह प्रतीक दर्शाता है। यह जार का पता या स्थान लौटाता है, न कि इसकी सामग्री या मूल्य।

AMPERSAND की परिभाषा

AMPERSAND का उपयोग चर के मेमोरी पते को इंगित करने के लिए किया जाता है जिसमें डेटा संग्रहीत किया जाएगा।

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

पते आपके पीसी पर बदल सकते हैं, लेकिन चूंकि दोनों पते के निचले पते BUF पते से मेल खाते हैं, इसलिए हम देखते हैं कि वे इस तरह से स्थित हैं:

BUF पता COOKIE पते से कम है, इसलिए यह बढ़ेगा।

और ये चर पते हमें क्या बताते हैं? (मेरे मामले में, और BUF = 0x19FED4 और COOKIE = 0x19FF24)

दोनों हेक्साडेसिमल प्रारूप में हैं। याद रखें कि यह% X प्रारूप था? इसलिए मैंने दशमलव संख्या को अलग करने के लिए 0x आगे रखा कि हम बिना किसी जोड़ के प्रतिनिधित्व करेंगे।

अगर मैं PYTHON कंसोल या PYCHARM में एक घटाव करता हूं:

हमें 80 बाइट्स का परिणाम मिलता है, क्योंकि COOKIE वैरिएबल माना जाता है कि जहां BUF बफर समाप्त होता है, ठीक उसी समय शुरू होता है, इसलिए अंतर हमें बफर का आकार देता है।

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

तथ्य यह है कि हम पहले से ही कोड, चर के आकार और उनके स्थान के बारे में कुछ इस तथ्य के कारण जानते हैं कि इसमें PRFF फ़ंक्शन है।

अब एक अन्य स्थान पर देखें जहां BUF बफर का उपयोग किया जाता है, क्योंकि अब यह प्रोग्राम केवल अपने पते को प्रिंट करता है, लेकिन इसका उपयोग इसमें डेटा संग्रहीत करने के लिए नहीं करता है।

int main(int argc, char **argv) 
{

	int cookie;
	char buf[80];

	printf("buf: %08x cookie: %08x\n", &buf, &cookie);
	gets(buf);

	if (cookie == 0x41424344) printf("you win!\n");

}

यहां, लाल रेखा पर, GET कीबोर्ड से डेटा दर्ज करने के लिए एक फ़ंक्शन है। जब तक मैं Enter दबाता हूं तब तक डेटा दर्ज किया जाएगा।

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

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

तथ्य यह है कि बीयूएफ के तहत कूकी चर है, इसलिए अतिप्रवाह ओवरराइट कर देगा और इसे एक मूल्य के साथ भर देगा जिसे आप नियंत्रित कर सकते हैं।

उदाहरण के लिए, यदि कोई व्यक्ति प्रिंट करता है जो 80 * ए और 4 * बी लिखता है, तो 80 * ए बीयूएफ में भर जाएगा, और 4 * बी कूकी में भर जाएगा, और जैसा कि हम जानते हैं, जब कोई कंसोल में एक चरित्र प्रिंट करता है, तो मूल्य कम रहेगा। ASCII।

चूंकि कुकी चार अक्षरों बी से भरी जाएगी, जो 0x42 के मान के बराबर हैं, हम गारंटी दे सकते हैं कि कुकी का मूल्य 0x42424242 होगा, अर्थात। मेरे कंप्यूटर पर, कुकी पते 0x19FF24 में सामग्री के रूप में 0x42424242 होगा।

0x19FF24 => 42424242

तथ्य यह है कि हमने पहले ही देखा है कि COOKIE मान को कैसे ओवरफ्लो और नियंत्रित किया जाए।

int main(int argc, char **argv) 
{

	int cookie;
	char buf[80];

	printf("buf: %08x cookie: %08x\n", &buf, &cookie);
	gets(buf);

	if (cookie == 0x41424344) printf("you win!\n");

}

अभ्यास पूरा करने के लिए आपको "आप जीत" प्रिंट करना होगा। इसके लिए, COOKIE का मान 0x41424344 के बराबर होना चाहिए, और यदि कोई अतिप्रवाह नहीं था, तो यह असंभव होगा, क्योंकि COOKIE मान कार्यक्रम की शुरुआत से कभी नहीं बदला है। हम "आप जीत" को प्रिंट नहीं कर पाए, और इसके लिए हम एक बफर अतिप्रवाह का उपयोग करते हैं, जो कहता है कि यह प्रोग्राम को प्रोग्राम किए गए के अलावा कुछ कार्रवाई करने का कारण बन सकता है।

इस मामले में, आप कभी भी "आप जीत" टाइप नहीं कर सकते हैं, केवल अतिप्रवाह आपको ऐसा करने की अनुमति देगा।

AAAAAAAA

दूसरे शब्दों में, उदाहरण के लिए, पास करने के बजाय, 80 * A और 4 * B, "आप जीतें" को प्रिंट करने के लिए, आपको 80 * A और उसके बाद DCBA को पास करना होगा, क्योंकि इससे COOKIE में संचित होने वाले मान उत्पन्न होंगे। ASCII।

44434241

https://www.arumeinformatica.es/blog/los-formatos-big-endian-y-little-endian/

जिसमें डेटा संग्रहीत किया जाता है वह प्रारूप LITTLE ENDIAN है। दूसरे शब्दों में, मेमोरी में डेटा को रिवर्स ऑर्डर में संग्रहित किया जाता है, बस इसे डालने के लिए।

और यदि अनुक्रम 0x41424344 सहेजा गया है, तो सिस्टम इसे मेमोरी में सेव करेगा:

44 43 42 41

इस कारण से, मेमोरी में कॉपी करते समय, कॉपी करते समय हम टाइप करेंगे, इसलिए हमें रिवर्स ऑर्डर में वैल्यू लिखना चाहिए ताकि मेमोरी से इसे पढ़ सकें। सही आकार में था।

हम निष्पादन योग्य को कंसोल में चला सकते हैं।

और कर्सर फ्लैश करेगा, क्योंकि जीईटी फ़ंक्शन मुझे इनपुट दर्ज करने के लिए कहता है। ध्यान से 80 अक्षर A और फिर DCBA टाइप करें।

PYTHON या PYCHARM कंसोल में, मैं लाइन को प्रिंट कर सकता हूं, इसे उद्धरण के बिना कॉपी कर सकता हूं और कंसोल में पेस्ट कर सकता हूं ताकि इसे पागलों की तरह न प्रिंट करें, और फिर इसे दर्ज करने के लिए ENTER कुंजी दबाएं।

हम देखते हैं कि हमें "आप जीत गए"।

हम डिबगर में इसे देख सकते हैं। इसके लिए हम X64DBG का उपयोग करेंगे।

मैं 32 बिट संस्करण का चयन करता हूं।

यदि हम NTDLL.DLL लाइब्रेरी में रुकते हैं, तो हम F9 के साथ फिर से RUN दबाते हैं।

हम देखते हैं कि डीबगर STACK1 मॉड्यूल के पहले निर्देश पर रुकता है, जिसे ENTRY POINT कहा जाता है या मॉड्यूल द्वारा निष्पादित पहला निर्देश है।

जाहिर है कि यह हमारे सोर्स कोड जैसा नहीं है। आपको यह समझना चाहिए कि संकलक निष्पादन योग्य कार्य करने और सही ढंग से चलाने के लिए बहुत सारे कोड जोड़ता है। हम अपने मुख्य कार्य को खोजने की कोशिश करेंगे। हम कार्यक्रम की तर्ज पर देखकर खुद को उन्मुख कर सकते हैं।

हमने वर्तमान क्षेत्र में केवल खोज का चयन किया। हम जानते हैं कि लाइनें एक ही खंड में होंगी।

यहाँ हम देखते हैं कि प्रोग्राम लाइन और अन्य हैं जो कंपाइलर ने जोड़े हैं। हम अपनी एक लाइन पर डबल क्लिक करते हैं।

अब आप और भी बहुत कुछ देख सकते हैं। हम MessageBoxA, PRINTF, GETS फ़ंक्शन और मान 0x41424344 के साथ एक कॉल देखते हैं।

इसके अलावा, हम SNOWMAN को हटाने के लिए एक प्लगइन जोड़ रहे हैं। हम यह देखने की कोशिश कर सकते हैं कि यह कोड को कैसे हटाता है, अर्थात। कैसे वह संकलित फ़ाइल से स्रोत कोड या कुछ इसी तरह प्राप्त करने की कोशिश कर रहा है।

हम देखते हैं कि यह सही नहीं है, लेकिन यह जो था उससे बेहतर है।

मैं फ़ंक्शन की शुरुआत में बीपी लगाने जा रहा हूं और जब तक डिबगर बंद नहीं हो जाता है तब तक F9 दबाएं।

उन लोगों के लिए जो एक फ़ंक्शन तर्क नहीं जानते हैं।

हमारे मामले में, मुख्य फ़ंक्शन में तर्क हैं, लेकिन वे फ़ंक्शन के अंदर उपयोग नहीं किए जाते हैं।

int main(int argc, char **argv) 
{

	int cookie;
	char buf[80];

	printf("buf: %08x cookie: %08x\n", &buf, &cookie);
	gets(buf);

	if (cookie == 0x41424344) printf("you win!\n");

}

यहां हम देखते हैं कि दो तर्क हैं, और उन्हें स्टैक से गुजारा जाता है जब निष्पादन योग्य को 32 बिट्स में संकलित किया जाता है।

फ़ंक्शन कॉल से ठीक पहले, स्टैक पर तर्क संग्रहीत किए जाएंगे।

जब हम फ़ंक्शन की शुरुआत में रुकते हैं, तो स्टैक पर पहला मान RETURN ADDRESS होगा, यानी जहां फ़ंक्शन पूरा होने के बाद फ़ंक्शन वापस आएगा, और इस मान के नीचे इस फ़ंक्शन के तर्क होंगे।

यदि मैं RETURN ADDRESS पर राइट-क्लिक करता हूं और FASSLOW DWORD IN DISASSEMBLER का चयन करता हूं, तो मैं देखूंगा कि फंक्शन पूरा होने के बाद डीबगर को कहां लौटना चाहिए।

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

मैं बीपी को थोड़ा पहले रखूंगा और कार्यक्रम को रिबूट करूंगा।

डिबगर यहां बंद हो जाएगा।

यह इन PUSH निर्देशों का उपयोग करके मुख्य फ़ंक्शन के तर्कों को सहेजने जा रहा है।

नीचे उन लोगों के लिए एक लिंक है जो फ़ंक्शन के तर्कों के बारे में अधिक जानना चाहते हैं:

https://publications.gbdirect.co.uk/c_book/chapter10/arguments_to_main.html

यह बहुत मुश्किल नहीं है। ARGC के लिए पहला तर्क INT है, जो प्रोग्राम को निष्पादित करने के लिए उपयोग किए जाने वाले कंसोल मापदंडों की संख्या को इंगित करता है, जिसमें निष्पादन योग्य मार्ग भी शामिल है, और ARGV स्ट्रिंग्स के लिए पॉइंटर्स का एक सरणी है।

हम देखते हैं कि यदि मैं कमांड लाइन को बदलता हूं, तो मैं अधिक तर्क पारित करूंगा और पुनः लोड करूंगा।

यहां डिबगर तब रुक जाता है जब यह PUSH निर्देश का उपयोग करके तर्कों को सहेजने वाला होता है। पहला तर्क जो संग्रहीत है वह सबसे दूर है, और अंतिम जिसे आप सहेजते हैं वह फ़ंक्शन का पहला तर्क होगा।

मैं ट्रेस करता हूं और प्रत्येक PUSH निर्देश तर्कों को बचाता है।

यहां मैं फ़ंक्शन के तर्कों को देख सकता हूं। ऊपर ARGC का पहला तर्क है। यह 3 है, क्योंकि यह कंसोल को पास किए गए तर्कों की संख्या को चिह्नित करता है।

यहाँ 3 तर्क दिए गए हैं।

अब हम FEP दबाकर STEP INTO करते हैं और फंक्शन में प्रवेश करते हैं।

यहाँ हम देखते हैं कि CALL दर्ज करते समय, डिबगर RETURN ADDRESS को स्टैक में सहेजता है।

इसलिए, जैसा कि हमने फ़ंक्शन में प्रवेश करते समय पहले ही कहा था, स्टैक पर सहेजी जाने वाली पहली चीज़ RETURN ADDRESS (32-बिट संकलन में) है, और नीचे फ़ंक्शन के तर्क हैं, पहला तर्क, और फिर क्रमिक रूप से शेष।

दूसरा तर्क, जैसा कि हमने देखा, व्यूअर का एक सरणी है। यहां हम स्मृति में देखते हैं कि तीन बिंदुओं के तीन बिंदु हैं जो तर्कों के रूप में पारित किए जाते हैं।

यहाँ हम फंक्शन की शुरुआत में रुक गए, हमारे पास RETURN ADDRESSES और ARGUMENTS हैं।

हम स्पष्ट करते हैं कि फ़ाइल को 32-बिट में संकलित किया गया है, क्योंकि 64-बिट संस्करण में, तर्कों को एक अलग तरीके से पारित किया जाता है। हम इसे बाद में देखेंगे।

फिर फ़ंक्शन निष्पादित करना शुरू कर देता है। पहली बात तथाकथित PROLOGUE है, जो हमारे कहे जाने वाले फ़ंक्शन का EBP मान संग्रहीत करता है।

यह EBP मान को रिटर्न एड्रेस के ठीक ऊपर रखेगा।

अगर मैं F7 का उपयोग करके निर्देशों का पालन करता हूं।

मैं देख रहा हूँ कि EBP GUARDADO मान रिटर्न एड्रेस के ऊपर स्टैक पर है।

PROLOGUE में निम्नलिखित निर्देश:

MOV EBP, ESP

यह वर्तमान फ़ंक्शन के लिए EBP मान सेट करता है जो सहेजा गया था और वह पेरेंट फ़ंक्शन था जो हमारा कहता है (इस मामले में, मेरा मुख्य कार्य EBP- आधारित फ़ंक्शन है, अन्य मामलों में यह अलग हो सकता है, और हम उन्हें बाद में देखें)

ईबीपी में वर्तमान ईएसपी मूल्य रखकर, हम यह सुनिश्चित करते हैं कि हम अपने वर्तमान फ़ंक्शन के लिए एक फ्रेम बनाते हैं।

अब, चूंकि यह फ़ंक्शन EBP या EBP आधार पर आधारित है, EBP मान को फ़ंक्शन के अंदर संग्रहीत किया जाएगा और इसे संदर्भ के रूप में स्वीकार किया जाएगा, और ESP बदल जाएगा।

इस EBP मान को आधार के रूप में लिया जाता है।

ईबीपी-आधारित कार्यों में, चर और तर्कों को इस पते से उनकी दूरी के आधार पर नामित किया जा सकता है, जिसे ईबीपी मूल्य में इसके उपसंहार तक संग्रहीत किया जाएगा।

हम सूची में कई चर देख सकते हैं जिन्हें EBP-4 या EBP-54 के रूप में संदर्भित किया जाता है, यह EBP मान का उल्लेख करता है कि यह वर्तमान में स्वीकार कर रहा है।

हम कह सकते हैं कि जैसे ही EBP PROLOGUE के बाद अपने मूल्य को ले लेता है, यह एक नाली की तरह दिखाई देगा, इसलिए तर्क हमेशा उस दिशा में जाएंगे, इसलिए EBP + XXX तर्क को संदर्भित करता है (संग्रहीत EBP और RETURN ADDRESS भी कम हैं, लेकिन लिंक नहीं होंगे कोड में), जबकि चर, जैसा कि हम देखेंगे, इस पते के ऊपर होगा, इसलिए EBP-XXX का लिंक कुछ स्थानीय चर को संदर्भित करता है।

इस प्रकार, EBP- आधारित फ़ंक्शन में:

EBP + XXXX = फ़ंक्शन के लिए पारित तर्क
EBP - XXXX = स्थानीय फ़ंक्शन चर

PROLOGUE के बाद चर के लिए स्थान आरक्षित करने का कोई रास्ता होगा। हमारे मामले में, यह ईएसपी को ऊपर ले जाकर किया जाता है ताकि नीचे की शेष जगह सभी चर लंबाई के योग के लिए आरक्षित हो और, कभी-कभी, बस मामले में थोड़ा अधिक, जो कंपाइलर पर निर्भर करता है।

00401043 | 83EC 54 | SUB ESP, 54

हम देखते हैं कि ESP EBP के ऊपर स्थित है, जो लिंक रहेगा, और यह कि 0x54 को दशमलव में परिवर्तित किया गया 84 है, जो BUF और COOKIE लंबाई का योग है। याद रखें कि वे क्रमशः 80 और 4 थे।

निष्पादन पर, आकार में 84 बाइट्स के BUF और COOKIE चर के लिए एक स्थान बनाया गया है। आप पहले कॉलम को क्षैतिज दिशा में क्लिक कर सकते हैं और EBP मान को देख सकते हैं और स्टैक पर उस मान को पा सकते हैं। जाहिर है, अब यह कम होगा।

मैं यहां डबल क्लिक करता हूं।

इस प्रकार, हमारे पास ईबीपी के बारे में भी स्टैक पर मूल्य होंगे।

उदाहरण के लिए, EBP-4 लिस्टिंग से मेल खाता है, -4 स्टैक के पहले कॉलम में प्रदर्शित होता है, और स्पष्टीकरण में, EBP-4 के रूप में भी प्रदर्शित किया जाता है।

यदि मैं ट्रेस करता हूं, तो हम देखते हैं कि उस जगह से जहां ईएसपी चर को आरक्षित करने के लिए स्थित था, यह हमेशा ऊपर जाएगा, क्योंकि इसे चर के लिए आवंटित स्थान को ध्यान में रखना चाहिए। MessageBoxA के लिए 4 PUSH प्रदर्शन करते समय, डिबगर आरक्षित स्थान के ऊपर चर रखता है और ESP को बढ़ाता है।

यदि मैं स्टैक को देखता हूं, तो मुझे 4 हरे तर्क दिखाई देते हैं जो मैं लाल रंग में चिह्नित आरक्षित स्थान पर जोड़ता हूं।

जब आप MessageBoxA फ़ंक्शन दर्ज करते हैं, तो इस फ़ंक्शन का RETURN ADDRESS स्टैक पर संग्रहीत होता है।

यहाँ MessageBoxA की वापसी पता है। जब मैं F8 के साथ ट्रेस करके इस फ़ंक्शन के RET में जाता हूं, और मैं MessageBoxA निष्पादित करता हूं।

हम देखते हैं कि डिबगर मैसेजबॉक्सए कॉल के ठीक नीचे जाएगा।

और PUSH मान जो आपने MessageBoxA फ़ंक्शन के लिए पास किया और इस फ़ंक्शन के लिए RETURN ADDRESS पहले से ही उपयोग किया गया है, और ESP आरक्षित क्षेत्र के ठीक ऊपर है, जैसा कि किसी फ़ंक्शन को कॉल करने से पहले था। PRINTF फ़ंक्शन को कॉल करने के साथ भी यही होगा।

PRINTF फ़ंक्शन को पास करने के बाद, BUF और COOKIE पते प्रिंट किए जाएंगे।

मेरी मशीन पर BUF का पता 0x19FED4 होगा, और COOKIE का पता 0x19FF24 होगा।

यहां, कार्यक्रम GETS फ़ंक्शन को पास करने और BUF को पॉप्युलेट करने के लिए BUF पते को पढ़ता है। हम जाँच सकते हैं कि पता 0x19FED4 कंसोल से पता चलता है कि क्या मेल खाता है।

यहाँ हम देखते हैं कि यह EBP-54 है। यदि मैं उस स्टैक पर डबल-क्लिक करता हूं, जहां यह -54 दिखाता है, तो यह दिखाएगा कि मेरी मशीन पर पता BUF = 0x19FED4 है।

अब, जब मैं इस पते पर दर्ज किए गए डेटा को बचाऊंगा, तो मैं उन्हें एक डंप में यह देखने के लिए डाल सकता हूं कि वहां बाइट्स कैसे संग्रहीत किए जाते हैं।

वे यहाँ हैं। इसके अलावा, नीचे कुछ भी प्रदर्शित नहीं है, क्योंकि कोई डेटा नहीं है।

जब मैं F8 का उपयोग करके GETS फ़ंक्शन को कॉल करता हूं, तो मुझे BUF बफर को भरने के लिए कंसोल पर टाइप करना होगा और ENTER दबाएँ, और COOKIE को फिर से लिखना होगा।

हम देखते हैं कि मेरी मशीन पर COOKIE चर 19FF24 में था।

यहाँ, कार्यक्रम 0x41424344 के साथ कुकी की तुलना करता है।

हम देखते हैं कि EBP-4 कहता है कि यह पते के अलावा एक COOKIE है, अगर हम पहले की तरह EBP मूल्य में HORIZON सेट करते हैं।

मैं यहां डबल क्लिक करता हूं।

हम देखते हैं कि EBP-4 एक COOKIE है, क्योंकि चर -4 स्टैक स्तर पर है, HORIZON को शून्य करता है।

हम देखते हैं कि कार्यक्रम कूद नहीं जाएगा और हमें आपको दिखाएगा!

तो हम मैन्युअल रूप से उस लक्ष्य को प्राप्त करते हैं जो आप जीतते हैं।

हम गतिशील रूप से X64DBG का उपयोग करके STACK1 का विश्लेषण करते हैं, जो एक डिबगर है और हमें इसे शुरू किए बिना प्रोग्राम का विश्लेषण करने की अनुमति नहीं देता है। ऐसा करने के लिए, हमें अन्य उपकरणों का उपयोग करना चाहिए, जैसे कि आईडीए प्रो, जीएचआईआईडीआरए या राडारे।

मैं PYTHON से अभ्यास के संचालन के लिए एक स्क्रिप्ट मॉडल बना सकता हूं।

import sys
from subprocess import Popen, PIPE

payload = b"A" * 80 + b"\x44\x43\x42\x41"

p1 = Popen(r"C:\Users\ricardo\Desktop\abos y stack nuevos\STACK1_VS_2017.exe", stdin=PIPE)
print ("PID: %s" % hex(p1.pid))
print ("Enter para continuar")
p1.communicate(payload)
p1.wait()
input()

PYTHON 3 के मामले में, मुझे PRINT फ़ंक्शन में कोष्ठक लगाने होंगे और उन पंक्तियों को जोड़ते समय सावधान रहना चाहिए जो बाइट्स होनी चाहिए (PYTHON 2 में लाइनों के सामने b)।

मैं जाँचता हूँ कि पथ सही है और जब मैं फ़ाइल चलाता हूँ।

अच्छा। हमारे पास पहले से ही STACK1 के संचालन के लिए PYTHON 3 का एक स्क्रिप्ट मॉडल है। अगले भाग में, हम IDA, RADARE और GHIDRA में स्थैतिक विश्लेषण जारी रखेंगे।

कृपया ध्यान दें कि STACK1 कार्य के अलावा, संस्करण 2, 3 और 4 भी हैं। आप उन्हें हल करने का प्रयास कर सकते हैं। वे बहुत ही सरल और STACK1 के समान हैं, इसलिए ऊब नहीं है।

अगले भाग में हम IDA FREE, RADARE और GHIDRA देखेंगे।

अगले भाग 3 में मिलते हैं।

रिकार्डो नरवाहा
25/10/2019

PS # 1
मेरे होम पेज पर एक सुंदर पीडीएफ डाउनलोड किया जा सकता है - yasha.su

PS # 2
जल्द ही मैं लेख की एक निरंतरता लिखूंगा https://habr.com/en/post/464117/ के बारे में कि कैसे मैंने पिता क्रिस कास्परस्की के लिए मदद एकत्र की और इस बारे में क्या हो गई।

बोर मत होइए।

आईडीए मुफ़्त और अन्य मुफ्त टूल का उपयोग करके शोषण और उलट करने का परिचय। अध्याय 2

EXPLOIT क्या है?

एक खरीदार क्या है?

एक खरीदार क्या है?

STACK क्या है?

बहुत कुछ क्या है?

AMPERSAND की परिभाषा

More articles: