packer-tutorial

विषय-सूची

1. पैकर क्या है?: पैकर के उद्देश्य का परिचय और पैकर के विकास के लिए आवश्यक चीज़ों के बारे में एक मार्गदर्शिका।
2. आवश्यक शर्तें: इस ट्यूटोरियल के साथ काम करने के लिए आवश्यक उपकरण।
3. एक झलक: इस ट्यूटोरियल के साथ आप क्या बनाएँगे, इसका एक प्रदर्शन।
4. हमारे CMake प्रोजेक्ट की रूपरेखा: पैकर की कुछ जटिल आवश्यकताओं के लिए बिल्ड सिस्टम बनाने पर एक लघु CMake ट्यूटोरियल।
5. अपने स्टब में बाइनरीज़ पैक करना: पैकर/स्टब संयोजन का पैकर भाग कैसे लिखें, इस पर एक ट्यूटोरियल, और साथ ही विंडोज़ निष्पादन योग्य फ़ाइल प्रारूप का परिचय।
   1. संसाधनों का प्रबंधन
   2. PE फ़ाइल को पार्स करना
   3. PE फ़ाइल में हेरफेर करना
6. लोडर का अनुकरण: लक्ष्य निष्पादन योग्य को अनपैक करने और लोड करने के लिए एक न्यूनतम स्टब निष्पादन योग्य कैसे बनाएं, इस पर एक ट्यूटोरियल, और साथ ही अधिक उन्नत विंडोज़ निष्पादन योग्य हेरफेर का परिचय।
   1. हमारे PE को मेमोरी से पढ़ना
   2. निष्पादन के लिए हमारे PE को लोड करना
   3. API इम्पोर्ट को हल करना
   4. पतों को हल करना
   5. निष्पादन स्थानांतरित करना
7. आगे के अभ्यास: आपके पैकर विकास ज्ञान को और विस्तृत करने के लिए कुछ अभ्यास।

क्या यह एक कठिन पठन लगता है? प्रस्तुति संस्करण आज़माएँ, जो इस readme का सारांश देता है। YouTube वीडियो जल्द आ रहा है!

पैकर क्या है?

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

• संपीड़न: पैकर सामान्यतः किसी दिए गए बाइनरी के कोड को संपीड़ित करने के लिए उपयोग किए जाते हैं। यह इसके कुछ वैध उपयोगों में से एक है। एक संपीड़ित पैकर के उदाहरण के लिए UPX देखें।
• अस्पष्टीकरण: पैकर का उपयोग तब भी किया जाता है जब किसी प्रोग्राम को अस्पष्ट करने या रिवर्स इंजीनियरिंग से बचाने का प्रयास किया जाता है। एक एंटी-रिवर्सिंग पैकर के उदाहरण के लिए Riot Games का packman पैकर देखें।
• बचाव: मैलवेयर अक्सर एंटीवायरस और यहां तक कि EDR से बचने के लिए विभिन्न प्रकार के पैकर का उपयोग करता है। एक बचाव-उन्मुख पैकर के उदाहरण के लिए SmokeLoader पैकर का यह विश्लेषण देखें।

मूल रूप से, एक पैकर के कुछ ही बुनियादी चरण होते हैं:

1. संपीड़न चरण: यह वह जगह है जहाँ मूल निष्पादन योग्य को एक नई बाइनरी में संपीड़ित, अस्पष्ट, या दोनों किया जाता है।
2. डीकंप्रेसन चरण: यह वह जगह है जहाँ पैक किया गया निष्पादन योग्य लोडिंग के लिए अपने मूल निष्पादन योग्य को डीकंप्रेस या डी-अस्पष्ट करता है।
3. लोडिंग चरण: यह वह जगह है जहाँ पैकर होस्ट प्लेटफ़ॉर्म के निष्पादन योग्य लोडर के समान विभिन्न चरणों की नकल करता है। निष्पादन योग्य बाइनरी की जटिलता के कारण, यह सबसे जटिल चरण है, यह इस बात पर निर्भर करता है कि आप कितनी गहराई का अनुकरण करना चाहते हैं।
4. निष्पादन चरण: यह वह जगह है जहाँ कोड होस्ट स्टब निष्पादन योग्य से नए लोड किए गए (यानी, अनपैक किए गए) कोड में स्थानांतरित होता है।

उतना ही सरल, एक पैकर केवल कुछ हिस्सों से मिलकर बनता है:

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

पैकर बनाना मुश्किल हो सकता है, क्योंकि स्टब को बनाने और किसी भी तरह पैकर निष्पादन योग्य में आयात करने की आवश्यकता होती है। विंडोज़ के लिए, साधारण संकलन से परे Visual Studio के लिए बिल्ड सिस्टम सीखना एक कठिन काम हो सकता है। सौभाग्य से, CMake एक सरल, क्रॉस-प्लेटफ़ॉर्म बिल्ड सिस्टम प्रदान करता है जो Visual Studio का समर्थन करता है, और अत्यधिक अनुकूलन योग्य है!

इस ट्यूटोरियल का उद्देश्य निम्नलिखित सिखाना है:

• पैकर के दो मुख्य हिस्सों को एक सुसंगत, परीक्षण योग्य बिल्ड वातावरण में कैसे विभाजित और एकीकृत करें।
• अतिरिक्त, लोड करने योग्य डेटा जोड़ने के लिए विंडोज़ निष्पादन योग्य में हेरफेर कैसे करें।
• मनमाना डेटा प्राप्त करने और लोड करने के लिए विंडोज़ निष्पादन योग्य को कैसे नेविगेट करें।
• विंडोज़ लोडर के हिस्सों का अनुकरण करके विंडोज़ निष्पादन योग्य को लोड और निष्पादित करने के लिए।

यदि आप पहले से ही C++ और CMake से परिचित हैं, तो बेझिझक सीधे पैकिंग अनुभाग पर जाएँ। अन्यथा, पढ़ते रहें!

आवश्यक शर्तें

• C++ का ज्ञान: यदि आप C++ नहीं जानते हैं तो यह ट्यूटोरियल बेकार है, क्योंकि हम बहुत सारा पॉइंटर अंकगणित करने जा रहे हैं।
• Visual Studio: Visual Studio में एक पूर्ण-विशेषताओं वाला Windows C++ कंपाइलर शामिल है। यह प्रोजेक्ट Visual Studio 2019 के साथ परीक्षण किया गया है, लेकिन नए संस्करण भी ठीक होने चाहिए।
• CMake: CMake वह बिल्ड सिस्टम है जिसका उपयोग हम Visual Studio कंपाइलर के लिए अपने बिल्ड को तैयार करने में सहायता करने के लिए करते हैं।

एक झलक

पहले, किसी तरह साबित करते हैं कि यह बिल्ड सिस्टम काम करता है और एक उचित रूप से पैक किया गया निष्पादन योग्य बनाता है। एक बार जब आपके पास CMake और Visual Studio स्थापित हो जाएं, तो अपनी पसंद के टर्मिनल के साथ इस रिपॉजिटरी की रूट निर्देशिका पर जाएं और निम्नलिखित निष्पादित करें:``` $ mkdir build $ cd build $ cmake ../

यह पैकर ट्यूटोरियल कोड बनाने के लिए आवश्यक प्रोजेक्ट फ़ाइलें बनाएगा। फिर चलाएँ:```
$ cmake --build ./ --config Release

यह पैकर प्रोजेक्ट को Release मोड में बनाएगा। फिर, आप निम्नलिखित परीक्षण चला सकते हैं:``` $ ctest -C Release ./

यदि सब कुछ ठीक रहा, तो test\_pack और test_unpack सफल होने चाहिए। यदि आप पैकिंग के परिणाम स्वयं देखना चाहते हैं, तो आपको यह देखना चाहिए:```
$ ./packed.exe
I'm just a little guy!

आइए उन सभी गतिशील भागों के बारे में बात करें जिन्होंने इसे संभव बनाया।

अपनी CMake परियोजना का खाका तैयार करना

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

• पैकर
• स्टब
• पैक करने के लिए डमी निष्पादन योग्य

हमें एक संपीड़न लाइब्रेरी की भी आवश्यकता है ताकि यह सुनिश्चित हो सके कि बाइनरी स्टब निष्पादन योग्य में संपीड़ित हो जाए। zlib इसके लिए अच्छा काम करेगा।

हमारी परियोजना संरचना, शुरुआत के लिए, इस तरह दिखनी चाहिए:``` packer/ +---+ CMakeLists.txt + dummy/ | | | +---+ CMakeLists.txt | + src/ | | | +---+ main.cpp | + stub/ | | | +---+ CMakeLists.txt | + src/ | | | +---+ main.cpp | + src/ | | | +---+ main.cpp | + zlib-1.2.13/ | +---+ CMakeLists.txt + ...

हमारा main.cpp प्रत्येक फ़ोल्डर में अभी के लिए बस इस तरह दिख सकता है:```cpp
#include <iostream>

int main(int argc, char *argv[]) {
    std::cout << "I'm just a little guy!" << std::endl;
    
    return 0;
}

शुरुआत में ही, हमें यह स्थापित कर लेना चाहिए कि हमारे पास एक सरल निर्भरता श्रृंखला है, जिसे CMake कुछ इंस्ट्रुमेंटेशन के साथ अच्छी तरह से हल कर देगा: