Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग · पाठ

रिवर्स इंजीनियरिंग की मूल तकनीकें

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

पाठ 3, कुल 4 में से11 चरण

रिवर्स इंजीनियरिंग की मूल तकनीकें, CoddyKit पर Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

रिवर्स इंजीनियरिंग क्या है

रिवर्स इंजीनियरिंग (RE) सॉफ़्टवेयर के मूल स्रोत कोड तक पहुँच के बिना उसकी आंतरिक कार्यप्रणाली समझने के लिए उसका विश्लेषण करने की प्रक्रिया है। इसे प्रोग्रामों के जासूस बनने जैसा समझिए!

इसमें एक संकलित प्रोग्राम (बाइनरी) लेकर पीछे की ओर काम करते हुए यह पता लगाया जाता है कि वह क्या करता है, कैसे करता है और कभी-कभी क्यों करता है।

आपका RE टूलकिट

रिवर्स इंजीनियरिंग के लिए आप मुख्य रूप से दो प्रकार के उपकरणों का उपयोग करेंगे:

डिसअसेंबलर: ये उपकरण मशीन कोड (प्रोग्राम के कच्चे बाइट) को वापस मनुष्यों द्वारा पढ़ी जा सकने वाली असेंबली भाषा में बदलते हैं। लोकप्रिय उदाहरणों में objdump, IDA Pro और Ghidra शामिल हैं। ये प्रोग्राम के निर्देशों को देखने के लिए आपकी 'आँखें' हैं।
डिबगर: GDB (GNU Debugger) जैसे उपकरण आपको प्रोग्राम को चरण-दर-चरण चलाने, उसका निष्पादन रोकने और किसी भी समय रजिस्टरों तथा मेमोरी की सामग्री का निरीक्षण करने देते हैं। ये सक्रिय प्रोग्राम के साथ काम करने के लिए आपके 'हाथ' हैं।

लक्ष्य प्रोग्राम से परिचय

इस पाठ में हम एक सरल x86 असेंबली प्रोग्राम का विश्लेषण करेंगे। कल्पना कीजिए कि आपके पास केवल उसका संकलित संस्करण है और आपको उसका तर्क समझना है!

यह प्रोग्राम दो पहले से निर्धारित मानों की तुलना करके और परिणाम के आधार पर एक संदेश दिखाकर साधारण 'पासवर्ड जाँच' का अनुकरण करता है।

section .data
    msg_access db "Access granted!", 0xA
    len_access equ $ - msg_access
    msg_denied db "Access denied.", 0xA
    len_denied equ $ - msg_denied

section .text
    global _start

_start:
    ; Simulate checking a "password" value
    mov eax, 1234       ; Our "secret" password value
    mov ebx, 5678       ; A "user-provided" value

    cmp eax, ebx        ; Compare secret with user input
    je .access_granted  ; If equal, jump to access granted

.access_denied:
    mov eax, 4          ; sys_write
    mov ebx, 1          ; stdout
    mov ecx, msg_denied
    mov edx, len_denied
    int 0x80
    jmp .exit

.access_granted:
    mov eax, 4          ; sys_write
    mov ebx, 1          ; stdout
    mov ecx, msg_access
    mov edx, len_access
    int 0x80

.exit:
    mov eax, 1          ; sys_exit
    mov ebx, 0          ; Exit code 0
    int 0x80

संकलित करना और डिसअसेंबल करना

सबसे पहले, हम अपने असेंबली प्रोग्राम को एक निष्पादन योग्य फ़ाइल में संकलित करेंगे। Linux पर इसमें आमतौर पर एक असेंबलर (जैसे NASM) और एक लिंकर (जैसे LD) का उपयोग होता है।

nasm -f elf32 program.asm -o program.o
ld -m elf_i386 program.o -o program

फिर, मशीन कोड को वापस असेंबली में बदला हुआ देखने के लिए हम objdump जैसे डिसअसेंबलर का उपयोग करते हैं:

objdump -d program

आपको कुछ ऐसा दिखाई दे सकता है:

08048060 <_start>: 8048060: b8 d2 04 00 00 mov $0x4d2,%eax 8048065: bb 36 16 00 00 mov $0x1636,%ebx 804806a: 39 d8 cmp %ebx,%eax 804806c: 74 1c je 804808a <.access_granted>

प्रवेश बिंदुओं की पहचान

रिवर्स इंजीनियरिंग करते समय सबसे पहले जिन चीज़ों को आप खोजते हैं, उनमें से एक प्रोग्राम का प्रवेश बिंदु है। यहीं से निष्पादन शुरू होता है।

असेंबली से संकलित Linux निष्पादन योग्य फ़ाइलों में प्रवेश बिंदु को अक्सर _start लेबल किया जाता है। हमारे डिसअसेंबली आउटपुट में आप पते 08048060 पर <_start> लेबल देख सकते हैं।

इससे आपको ठीक-ठीक पता चलता है कि प्रोग्राम लोड होने पर CPU निर्देशों का निष्पादन कहाँ से शुरू करता है।

प्रोग्राम के प्रवाह और जम्प का पता लगाना

किसी प्रोग्राम के तर्क को समझने के लिए आपको उसके निष्पादन-प्रवाह का पता लगाना होगा। निर्णय लेने की प्रक्रिया (जैसे if/else कथन) समझने के लिए सशर्त जम्प निर्देश महत्वपूर्ण होते हैं।

हमारे उदाहरण में, cmp %ebx,%eax से eax और ebx की तुलना करने के बाद हमें je 804808a <.access_granted> दिखाई देता है।

cmp: दो मानों की तुलना करता है और CPU फ़्लैग सेट करता है।
je (समान होने पर जम्प): यदि तुलना का परिणाम समान था, तो निष्पादन पते 0804808a (हमारे .access_granted खंड) पर चला जाता है।
यदि मान समान नहीं हैं, तो निष्पादन क्रम में अगले निर्देश (.access_denied खंड) पर जारी रहता है।

सिस्टम कॉल को समझना

प्रोग्राम सिस्टम कॉल के माध्यम से ऑपरेटिंग सिस्टम के साथ काम करते हैं। Linux x86 (32-बिट) पर इन्हें आमतौर पर int 0x80 निर्देश से लागू किया जाता है।

int 0x80 से पहले, विशिष्ट रजिस्टरों में मान लोड किए जाते हैं:

eax: इसमें सिस्टम कॉल संख्या होती है (जैसे sys_write के लिए 4 और sys_exit के लिए 1)।
ebx, ecx, edx: इनमें सिस्टम कॉल के तर्क रखे जाते हैं (जैसे sys_write के लिए फ़ाइल डिस्क्रिप्टर, बफ़र का पता और लंबाई)।

इन पैटर्न को देखकर आप कंसोल पर लिखने या प्रोग्राम से बाहर निकलने जैसी क्रियाओं की पहचान कर सकते हैं।

स्ट्रिंग और डेटा निकालना

संदेश और अन्य स्थिर डेटा बाइनरी के डेटा अनुभागों में संग्रहीत होते हैं। आप अक्सर इन्हें objdump -s -j .data program या objdump -s -j .rodata program का उपयोग करके देख सकते हैं।

असेंबली में आपको ऐसे निर्देश दिखाई देंगे जो इन स्ट्रिंग के पते को किसी रजिस्टर में लोड करते हैं (जैसे mov ecx, 0x8049080, जहाँ 0x8049080 किसी स्ट्रिंग की ओर संकेत करता है)।

हमारे उदाहरण में, संदेश "Access granted!" और "Access denied." .data अनुभाग में मिलेंगे और उनके पते sys_write को दिए जाएँगे।

मूल तर्क का पुनर्निर्माण

इन सभी निरीक्षणों को मिलाकर हम प्रोग्राम के मूल तर्क का पुनर्निर्माण कर सकते हैं:

यह _start से शुरू होता है।
यह दो विशिष्ट पूर्णांक मानों को eax और ebx में लोड करता है।
यह इन दोनों मानों की तुलना करता है।
यदि वे समान हैं, तो यह उस खंड पर जम्प करता है जो कंसोल पर "Access granted!" दिखाता है।
यदि वे समान नहीं हैं, तो यह उस खंड में चला जाता है जो कंसोल पर "Access denied." दिखाता है।
दिखाने के बाद प्रोग्राम सही ढंग से समाप्त हो जाता है।

यही रिवर्स इंजीनियरिंग का सार है: प्रोग्राम के संकलित रूप से उसके उद्देश्य और व्यवहार को समझना।

त्वरित जाँच

निम्नलिखित असेंबल किए गए x86 अंश पर विचार कीजिए। मान लीजिए कि 0x402000 में स्ट्रिंग "Yes\n" और 0x402008 में "No\n" मौजूद है।

0x401000: mov eax, 0x5 0x401005: mov ebx, 0x5 0x40100a: cmp eax, ebx 0x40100c: jne 0x401018 0x40100e: mov edi, 0x402000 ; "Yes\n" 0x401013: call 0x401040 <puts@plt> 0x401018: mov edi, 0x402008 ; "No\n" 0x40101d: call 0x401040 <puts@plt>

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

इस पाठ में आपने मूलभूत रिवर्स इंजीनियरिंग की आवश्यक तकनीकें सीखी हैं:

यह समझना कि RE क्या है और इसका महत्व क्या है।
डिसअसेंबलर (objdump) और डीबगर (GDB) जैसे प्रमुख उपकरणों की पहचान करना।
प्रोग्राम के प्रवेश बिंदु (_start) का पता लगाना।
सशर्त जंप (cmp, je) का उपयोग करके प्रोग्राम के प्रवाह का पता लगाना।
सिस्टम कॉल (int 0x80) और उनके पैरामीटर पहचानना।
बाइनरी से अर्थपूर्ण स्ट्रिंग और डेटा निकालना।

इन तकनीकों को लागू करके आप प्रोग्राम के मूल स्रोत कोड के बिना भी उसकी कार्यप्रणाली और व्यवहार को पुनर्निर्मित करना शुरू कर सकते हैं!

शुरुआत निःशुल्क

एआई शिक्षक के साथ Assembly सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “रिवर्स इंजीनियरिंग की मूल तकनीकें” पाठ निःशुल्क है?

हाँ—“रिवर्स इंजीनियरिंग की मूल तकनीकें” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“रिवर्स इंजीनियरिंग की मूल तकनीकें” में मैं क्या सीखूँगा?

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

क्या Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“रिवर्स इंजीनियरिंग की मूल तकनीकें” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

← Assembly भाषा और x86 निम्न-स्तरीय सिस्टम प्रोग्रामिंग पर वापस जाएँ