Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

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

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
windows-x86-shellcode-poc — Windows x86 PoC: पुराने 32-बिट विंडोज पर कस्टम शेलकोड के साथ स्टैक-आधारित बफर ओवरफ्लो | Kitploit
उपकरण/GitHubGitHub/nataliadiak/windows-x86-shellcode-poc
भेद्यता विश्लेषणरिवर्स इंजीनियरिंगशेलकोडलर्निंग और शिक्षापेलोड डेवलपमेंटबाइनरी शोषण
GitHubnataliadiak/windows-x86-shellcode-poc

windows-x86-shellcode-poc

Windows x86 PoC: पुराने 32-बिट विंडोज पर कस्टम शेलकोड के साथ स्टैक-आधारित बफर ओवरफ्लो

रिपॉजिटरी देखें
8223 महीने पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

विंडोज x86 बफर ओवरफ्लो PoC शुरुआती के लिए

यह 32-बिट विंडोज के लिए स्टैक-आधारित बफर ओवरफ्लो एक्सप्लॉइट्स पर एक सरल, स्व-निहित ट्यूटोरियल है। किसी बाहरी गाइड की आवश्यकता नहीं है—आपको जो कुछ भी चाहिए वह यहाँ है।

यह रिपॉजिटरी क्या है?

  • vulnerable.c: एक सरल प्रोग्राम जिसमें असुरक्षित gets() फंक्शन है।
  • messageBox.asm: एक छोटा असेंबली पेलोड जो ओवरफ्लो के बाद निष्पादित होगा।
  • exploit.c: एक उदाहरण कि ओवरफ्लो कैसे ट्रिगर किया जा सकता है।

यह प्रोजेक्ट एक मुख्य विचार सिखाता है: असुरक्षित इनपुट पढ़ना एक हमलावर को रिटर्न एड्रेस को ओवरराइट करने और निष्पादन को पुनर्निर्देशित करने की अनुमति दे सकता है।

भेद्यता: gets() का कोई आकार सीमा नहीं है

vulnerable.c में, प्रोग्राम ऐसा करता है:

root@kitploit:~
char buffer[32];
gets(buffer);

प्रोग्राम buffer के लिए 32 बाइट्स आरक्षित करता है, फिर इनपुट पढ़ने के लिए gets() को कॉल करता है। समस्या: gets() बफर आकार की जाँच नहीं करता है। यह तब तक कैरेक्टर पढ़ता रहता है जब तक कि उसे न्यूलाइन न मिल जाए। यदि उपयोगकर्ता 40 या 50 कैरेक्टर टाइप करता है, तो अतिरिक्त कैरेक्टर 32-बाइट बफर से आगे बह जाते हैं।

स्टैक पर मेमोरी कैसे व्यवस्थित होती है

जब कोई C फंक्शन चलता है, तो स्टैक (मेमोरी का एक क्षेत्र) संग्रहीत करता है:

  1. लोकल वेरिएबल्स (जैसे buffer)
  2. सहेजा गया EBP (कॉलिंग फंक्शन का बेस पॉइंटर)
  3. सहेजा गया रिटर्न एड्रेस (जहां CPU को फंक्शन लौटने पर कूदना चाहिए)

इसे इस तरह चित्रित करें:

root@kitploit:~
Lower addresses (top of stack as drawn)
[  buffer (32 bytes)  ]
[    saved EBP (4 bytes)     ]
[  return address (4 bytes)  ]
Higher addresses (bottom)

जब gets() buffer को बहुत अधिक इनपुट से ओवरफ्लो करता है, तो अतिरिक्त बाइट्स सहेजे गए EBP और फिर रिटर्न एड्रेस को ओवरराइट कर देते हैं।

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

एक्सप्लॉइट कैसे काम करता है: चरण दर चरण

  1. प्रोग्राम शुरू होता है और स्टैक पर buffer[32] आवंटित करता है।
  2. यह उपयोगकर्ता इनपुट की एक पंक्ति पढ़ने के लिए gets(buffer) को कॉल करता है।
  3. हम एक स्ट्रिंग भेजते हैं जो 32 बाइट्स से लंबी है (मान लीजिए, 50 बाइट्स)।
  4. gets() में आकार की जाँच नहीं है, इसलिए यह सभी 50 बाइट्स को बफर में लिखता है।
  5. अतिरिक्त 18 बाइट्स buffer से आगे बह जाते हैं और सहेजे गए EBP और रिटर्न एड्रेस को ओवरराइट कर देते हैं।
  6. हम ध्यानपूर्वक ओवरफ्लो का निर्माण करते हैं ताकि रिटर्न एड्रेस स्टैक पर शेलकोड की ओर इशारा करे।
  7. जब फंक्शन लौटता है, तो CPU ओवरराइट किए गए रिटर्न एड्रेस को पढ़ता है।
  8. CPU शेलकोड पर कूद जाता है।
  9. शेलकोड प्रोग्राम की अनुमतियों के तहत चलता है।

यह बफर ओवरफ्लो के माध्यम से कोड निष्पादन का सबसे सरल रूप है।

शेलकोड में क्या होता है: पेलोड

messageBox.asm एक छोटा कोड टुकड़ा है जो ओवरफ्लो के बाद चलने के लिए डिज़ाइन किया गया है।

यह निम्नलिखित करता है:

  1. USER32.DLL लोड करें: लाइब्रेरी को मेमोरी में सुनिश्चित करने के लिए LoadLibraryA को स्ट्रिंग "USER32.DLL" के साथ कॉल करता है।
  2. MessageBoxA के लिए आर्गुमेंट तैयार करें: स्टैक पर चार आर्गुमेंट पुश करता है (विंडो हैंडल, मैसेज टेक्स्ट, कैप्शन, बटन प्रकार)।
  3. MessageBoxA को कॉल करें: टेक्स्ट "CAN I HACK THE PC?" के साथ एक मैसेज बॉक्स प्रदर्शित करने के लिए Windows API फंक्शन को कॉल करता है।
  4. साफ-साफ बाहर निकलें: प्रोग्राम को सुरक्षित रूप से समाप्त करने के लिए ExitProcess को कॉल करता है।

मुख्य बिंदु: यह निष्पादन योग्य कोड है जो ओवरफ्लो द्वारा निष्पादन को पुनर्निर्देशित करने के बाद चलता है। जब मैसेज बॉक्स स्क्रीन पर दिखाई देता है, तो यह तीन बातें साबित करता है:

  1. बफर ओवरफ्लो काम किया और रिटर्न एड्रेस को फिर से लिख दिया।
  2. निष्पादन स्टैक पर शेलकोड पर कूद गया।
  3. शेलकोड सफलतापूर्वक चला और Windows API कॉल किए।

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

यह विशिष्ट पेलोड MessageBoxA (0x751D8830) और ExitProcess (0x7437ADB0) के लिए हार्डकोडेड मेमोरी पतों का उपयोग करता है। ये पते एक सिस्टम के लिए विशिष्ट हैं। पेलोड को किसी भिन्न विंडोज संस्करण या सिस्टम के लिए समायोजित करने की आवश्यकता होगी।

MessageBoxA

डेमो को कैसे बनाएं और चलाएं

चरण 1: सुरक्षा अक्षम करें

आधुनिक विंडोज में कई सुरक्षा विशेषताएं हैं जो इस एक्सप्लॉइट को रोकती हैं:

  • स्टैक कैनरी (GS फ्लैग): स्टैक ओवरराइट का पता लगाता है।
  • ASLR (DYNAMICBASE): मेमोरी पतों को यादृच्छिक करता है ताकि हार्डकोडेड पते काम न करें।
  • DEP/NX (NXCOMPAT): स्टैक को निष्पादन योग्य नहीं के रूप में चिह्नित करता है ताकि वहां कोड निष्पादन को रोका जा सके।

इस शिक्षण अभ्यास के लिए, हम उन सभी को अक्षम करते हैं।

चरण 2: विंडोज पर कंपाइल करें

विशिष्ट फ्लैग के साथ MSVC (Microsoft Visual C++) का उपयोग करें:

root@kitploit:~
cl /c /GS- /W3 /Zl vulnerable.c
link /SUBSYSTEM:CONSOLE /DYNAMICBASE:NO /NXCOMPAT:NO vulnerable.obj /OUT:vulnerable.exe

फ्लैग के अर्थ:

  • /GS- स्टैक बफर ओवररन सुरक्षा को अक्षम करता है।
  • /DYNAMICBASE:NO एड्रेस स्पेस लेआउट रैंडमाइजेशन (ASLR) को अक्षम करता है।
  • /NXCOMPAT:NO DEP को अक्षम करता है, स्टैक पर कोड को निष्पादित करने की अनुमति देता है।

यदि आपके पास पहले से ही एक्जीक्यूटेबल है, तो आप editbin के साथ सुरक्षा अक्षम कर सकते हैं:

root@kitploit:~
editbin /NXCOMPAT:NO /DYNAMICBASE:NO vulnerable.exe

चरण 3: इसे चलाएं

  1. vulnerable.exe शुरू करें।
  2. जब संकेत दिया जाए, तो एक लंबी स्ट्रिंग दर्ज करें (32 कैरेक्टर से अधिक)।
  3. यदि ओवरफ्लो काम करता है, तो सहेजा गया रिटर्न एड्रेस ओवरराइट हो जाता है।
  4. प्रोग्राम क्रैश हो सकता है, यादृच्छिक मेमोरी पर कूद सकता है, या (सही शेलकोड के साथ एक वास्तविक एक्सप्लॉइट में) पेलोड को निष्पादित कर सकता है।

README पूर्ण क्यों है

यह README बताता है:

  1. gets() क्या है और यह असुरक्षित क्यों है (कोई आकार सीमा नहीं)।
  2. स्टैक लोकल वेरिएबल्स, सहेजे गए रजिस्टर और रिटर्न एड्रेस कैसे संग्रहीत करता है।
  3. कैसे एक ओवरफ्लो रिटर्न एड्रेस को ओवरराइट कर सकता है।
  4. जब कोई फंक्शन लौटता है तो CPU रिटर्न एड्रेस का उपयोग कैसे करता है।
  5. जब रिटर्न एड्रेस शेलकोड की ओर इशारा करता है तो शेलकोड कैसे निष्पादित हो सकता है।
  6. कौन सी सुरक्षा मौजूद हैं और हम उन्हें क्यों अक्षम करते हैं।
  7. उदाहरण को कैसे बनाएं और चलाएं।

अब आप संपूर्ण बफर ओवरफ्लो एक्सप्लॉइट प्रवाह को समझ गए हैं। अपनी समझ को मजबूत करने के लिए कोड फ़ाइलों को पढ़ें और इस स्पष्टीकरण से तुलना करें।

महत्वपूर्ण सुरक्षा सूचना

यह उदाहरण केवल सीखने के लिए है। इस तकनीक का उपयोग उन सिस्टमों के खिलाफ न करें जिनके आप मालिक नहीं हैं या जिनके परीक्षण के लिए आपके पास स्पष्ट अनुमति नहीं है। कंप्यूटर सिस्टम तक अनधिकृत पहुंच अवैध है।

टूल डाउनलोड करें