x86byte/obfusk8Obfusk8: हल्का Obfuscation लाइब्रेरी, C++17 पर आधारित / Header Only, Windows बाइनरी के लिए
Obfusk8 एक हल्की, हेडर-ओनली C++17 लाइब्रेरी है जिसे आपके अनुप्रयोगों के ऑब्फस्केशन को महत्वपूर्ण रूप से बढ़ाने के लिए डिज़ाइन किया गया है, जो रिवर्स इंजीनियरिंग को काफी अधिक चुनौतीपूर्ण प्रयास बनाता है। यह विभिन्न प्रकार की कंपाइल-टाइम और रनटाइम तकनीकों के माध्यम से ऐसा करता है जिनका उद्देश्य आपके कोड के तर्क और डेटा की रक्षा करना है।
main_mainआपके अनुप्रयोग के प्रवेश बिंदु (main) को एक जटिल, बहु-स्तरीय ऑब्फस्केशन इंजन में रूपांतरित किया जाता है:
main_body कोड के निष्पादित होने से पहले, एक मिनी-VM (सिम्युलेटेड CPU) "एन्क्रिप्टेड" निर्देशों का एक क्रम चलाता है। यह वास्तविक प्रवेश बिंदु और प्रारंभिक संचालन को छुपाता है। VM की स्थिति (रजिस्टर, प्रोग्राम काउंटर, डिस्पैच कुंजी) रनटाइम-यादृच्छिक मानों से आरंभ की जाती है।_main मैक्रो (प्रोलॉग और एपिलॉग दोनों में) के भीतर महत्वपूर्ण लूप जटिल स्थिति मशीनों में रूपांतरित हो जाते हैं। नियंत्रण प्रवाह सीधा नहीं है बल्कि भारी "एन्क्रिप्टेड" स्थिति चर द्वारा निर्धारित होता है। इन स्थिति चरों के लिए एन्कोडिंग/डिकोडिंग कुंजियाँ गतिशील होती हैं, जो VM स्थिति, लूप काउंटर, कंपाइल-टाइम यादृच्छिकता (जैसे __COUNTER__, __LINE__, __TIME__), और एक वैश्विक अपारदर्शी बीज से प्राप्त होती हैं। यह नियंत्रण प्रवाह के स्थैतिक विश्लेषण को अत्यधिक कठिन बनाता है।
obf_icff_ns_dcff और obf_icff_ns_epd) विभिन्न स्थिति संक्रमण तर्क और कुंजी निर्माण के साथ उपयोग किए जाते हैं, जो विश्लेषण को और जटिल बनाते हैं।OBF_BOGUS_FLOW_* मैक्रोज़): _main में कई भ्रामक जंप पैटर्न और जटिल सशर्त संरचनाएँ इंजेक्ट की जाती हैं। ये अपारदर्शी विधेय (ऐसी शर्तें जो हमेशा सत्य या असत्य होती हैं लेकिन गणनात्मक रूप से महंगी या स्थैतिक रूप से निर्धारित करना कठिन होता हैं) के साथ संयुक्त goto स्टेटमेंट का उपयोग करते हैं। यह डिस्सेम्बलर और डीकंपाइलर के लिए झूठे पथों की एक भूलभुलैया बनाता है।
OBF_BOGUS_FLOW_LABYRINTH, OBF_BOGUS_FLOW_GRID, OBF_BOGUS_FLOW_SCRAMBLE, OBF_BOGUS_FLOW_WEAVER, OBF_BOGUS_FLOW_CASCADE, और OBF_BOGUS_FLOW_CYCLONE शामिल हैं।Runtime मैक्रो, SEH):
__except ब्लॉक प्रोग्राम की स्थिति को बदल सकते हैं, जिससे यदि डीबगर अपवादों को छोड़ देता है तो ट्रैक करना कठिन हो जाता है।Runtime मैक्रो में ऐसी शर्तें होती हैं जो, यदि पूरी होती हैं (विशिष्ट VM अवस्थाओं या समय-निर्धारण के कारण), __debugbreak() को ट्रिगर कर सकती हैं या अपवाद फेंक सकती हैं, जो डीबगिंग सत्रों को बाधित करने के लिए डिज़ाइन की गई हैं।obf_vm_engine)_main मैक्रो के ऑब्फस्केशन का एक मुख्य घटक:
r0, r1, r2), एक प्रोग्राम काउंटर (pc), और एक dispatch_key होता है। यह कस्टम "निर्देश" (हैंडलर) निष्पादित करता है।reg_dispatch_idx)।get_mem_dispatch_table)।mixed_dispatch_idx)।
dispatch_key लगातार परिवर्तित होता रहता है, जिससे निष्पादित हैंडलर का क्रम अत्यधिक अप्रत्याशित हो जाता है।vm_handler_table) की तालिका _main प्रोलॉग और एपिलॉग के भीतर रनटाइम पर स्वयं परिवर्तित होती है, जो VM के व्यवहार को और अस्पष्ट करती है।OBFUSCATE_STRING AES8.hpp से)__FILE__, __LINE__), और बिल्ड समय (__DATE__, __TIME__) से प्राप्त होती हैं।AES8.hpp से MSVC-विशिष्ट सुविधा)।STEALTH_API_OBFSTR / STEALTH_API_OBF Resolve8.hpp से)GetModuleHandle और GetProcAddress को दरकिनार करता है।CT_HASH) का उपयोग करता है। यह इन मैक्रोज़ का उपयोग करते समय बाइनरी के आयात-संबंधित डेटा या स्ट्रिंग तालिकाओं में सादा पाठ DLL और API नामों को दिखने से रोकता है।K8_SYSCALL)Obfusk8 अब यूज़र-मोड हुक (EDRs/AVs) और स्थैतिक विश्लेषण जाँचों को बायपास करने के लिए एक अत्याधुनिक अप्रत्यक्ष सिस्कॉल तंत्र को एकीकृत करता है।
NtOpenProcess के बजाय K8_SYSCALL("ZwOpenProcess", ...) का उपयोग करें।OBF_METHOD) के साथObfusk8 अब विधि-आधारित ऑब्फस्केशन के माध्यम से आपके बाइनरी की सुरक्षा पर दानेदार नियंत्रण प्रदान करता है। अपने पूरे प्रोजेक्ट को ऑब्फस्केट करने के बजाय (जो प्रदर्शन को प्रभावित कर सकता है), अब आप चुनिंदा रूप से विशिष्ट, उच्च-मूल्य वाले फ़ंक्शन या क्लास विधियों की रक्षा कर सकते हैं।
OBF_METHOD मैक्रो का उपयोग करके परिभाषित करें: ```cpp
OBF_METHOD(ret_type, func_name, params, method_body)
ret_type: आपके फ़ंक्शन का रिटर्न प्रकार (उदा., bool, int, void*)।func_name: विधि का नाम।params: फ़ंक्शन पैरामीटर (कोष्ठक में संलग्न होना चाहिए)।method_body: आपके फ़ंक्शन का वास्तविक तर्क { } में संलग्न।इस उदाहरण में, PrintStatus एक सामान्य, पठनीय फ़ंक्शन है। Obfusk8_PrintStatus Obfusk8 द्वारा संरक्षित है।```cpp
#include "../Instrumentation/materialization/state/Obfusk8Core.hpp"
#include "../Instrumentation/materialization/transform/K8_UTILS/k8_utils.hpp" // for the printf_, u can change the printf_ with anything else...
class Obfusk8_C { public: // standard method which is visible to reverse engineers void PrintStatus(void) { printf_("method\n"); }
// Obfuscated method protected by Obfusk8
OBF_METHOD_(void, Obfusk8_PrintStatus, (void),
{
printf_("same method but Obfuscated\n");
})
};
_main({ Obfusk8_C *pp = new Obfusk8_C; pp->PrintStatus(); pp->Obfusk8_PrintStatus(); delete pp; })
*You can view the full example here: [obfusk8_methods.cpp](https://github.com/x86byte/Obfusk8/blob/main/Obfusk8/EXAMPLES/obfusk8_methods.cpp)*
---
### 6. अंतर्निहित स्टील्थ के साथ API एब्सट्रैक्शन क्लासेस
Obfusk8 हेल्पर क्लासेस प्रदान करता है जो Windows API के सामान्य सेटों को एन्कैप्सुलेट करते हैं। ये क्लासेस अपने निर्माण के दौरान स्वचालित रूप से स्टील्थी API रिज़ॉल्यूशन मैकेनिज़्म (`STEALTH_API_OBFSTR`) का उपयोग करते हैं, जिससे यह सुनिश्चित होता है कि अंतर्निहित Windows फ़ंक्शन बिना स्पष्ट स्टैटिक इम्पोर्ट ट्रेस छोड़े रिज़ॉल्व हो जाएं।
- **`K8_ProcessManipulationAPIs::ProcessAPI` (`k8_ProcessManipulationAPIs.hpp`)**:
* प्रक्रिया हेरफेर के लिए Windows API तक सुविधाजनक पहुँच प्रदान करता है, जैसे कि `OpenProcess`, `TerminateProcess`, `CreateRemoteThread`, `VirtualAllocEx`, `WriteProcessMemory`, `ReadProcessMemory`, `GetProcAddress`, `GetModuleHandleA`, `NtQueryInformationProcess`, `SuspendThread`, और `GetCurrentProcessId`।
* **स्वचालित स्टील्थ रिज़ॉल्यूशन**: `kernel32.dll` और `ntdll.dll` से आवश्यक फ़ंक्शन्स को स्टील्थली रिज़ॉल्व करता है।
* कम स्टैटिक विश्लेषण फुटप्रिंट के साथ प्रक्रिया-संबंधित संचालन करने को सरल बनाता है। इसमें `NtQueryInformationProcess` के उपयोग के लिए `PROCESSINFOCLASS` एनम शामिल है।
- **`k8_CryptographyAPIs::CryptographyAPI` (`k8_CryptographyAPIs.hpp`)**:
* सामान्य Windows क्रिप्टोग्राफ़ी API (CAPI/CNG) फ़ंक्शन्स के लिए रैपर प्रदान करता है। (कार्यक्षमता इस फ़ाइल के वास्तविक कार्यान्वयन पर निर्भर करती है - प्रदान किया गया स्निपेट डुप्लिकेट था। सामान्य CAPI फ़ंक्शन्स जैसे `CryptAcquireContextA`, `CryptCreateHash`, आदि मानते हुए।)
* **स्वचालित स्टील्थ रिज़ॉल्यूशन**: आवश्यक फ़ंक्शन्स को मुख्य रूप से `advapi32.dll` (और मुख्य फ़ंक्शन्स के लिए `kernel32.dll`) से स्टील्थली रिज़ॉल्व करता है।
* क्रिप्टो API उपयोग के एक्सपोज़र को कम करते हुए क्रिप्टोग्राफ़िक संचालन को सुविधाजनक बनाता है।
- **`k8_NetworkingAPIs::NetworkingAPI` (`k8_NetworkingAPIs.hpp`)**:
* `wininet.dll` (जैसे, `InternetOpenA`, `HttpOpenRequestA`, `FtpPutFileA`), `urlmon.dll` (जैसे, `URLDownloadToFileA`), `ws2_32.dll` (जैसे, `socket`, `connect`, `WSAStartup`), `shell32.dll` (जैसे, `ShellExecuteA`), `dnsapi.dll` (जैसे, `DnsQuery_A`), और `mpr.dll` (जैसे, `WNetOpenEnumA`) से नेटवर्किंग फ़ंक्शन्स की एक विस्तृत श्रृंखला तक आसान पहुँच प्रदान करता है।
* **स्वचालित स्टील्थ रिज़ॉल्यूशन**: अपने कंस्ट्रक्टर में, यह सभी आवश्यक फ़ंक्शन्स को उनके संबंधित DLLs (और `LoadLibraryA`/`GetLastError` के लिए `kernel32.dll`) से बिना स्पष्ट इम्पोर्ट ट्रेस छोड़े रिज़ॉल्व करने के लिए `STEALTH_API_OBFSTR` और `OBFUSCATE_STRING` का उपयोग करता है।
* ओबफस्केटेड नेटवर्क अनुरोध करने और अन्य नेटवर्क-संबंधित कार्य करने को सरल बनाता है।
- **`RegistryAPIs::RegistryAPI` (`k8_RegistryAPIs.hpp`)**:
* सामान्यतः उपयोग किए जाने वाले Windows रजिस्ट्री फ़ंक्शन्स जैसे `RegSetValueExA`, `RegCreateKeyExA`, `RegOpenKeyExA`, `RegQueryValueExA`, `RegCloseKey`, आदि को रैप करता है।
* **स्वचालित स्टील्थ रिज़ॉल्यूशन**: कंस्ट्रक्शन के दौरान `advapi32.dll` (और `kernel32.dll`) से फ़ंक्शन्स को स्टील्थली रिज़ॉल्व करता है।
* कम ट्रेसेबल API कॉल के साथ रजिस्ट्री संचालन करने में सहायता करता है।
### 7. कोर ओबफस्केशन प्रिमिटिव्स (`Obfusk8Core.hpp` में मैक्रोज़)
ये वे बिल्डिंग ब्लॉक्स हैं जिनका पूरे लाइब्रेरी में बड़े पैमाने पर उपयोग किया जाता है, विशेष रूप से `_main` मैक्रो और VM इंजन में:
* **मिक्स्ड बूलियन-अरिथमेटिक (MBA)**: सरल गणितीय और तार्किक संक्रियाओं (ADD, SUB, XOR, NOT, MUL) को जटिल, लेकिन समतुल्य, बिटवाइज़ और अरिथमेटिक सूत्रों के अनुक्रमों में रूपांतरित करता है (जैसे, `OBF_MBA_ADD`, `OBF_MBA_XOR`)। ये डीकंपाइलर्स के लिए अपने मूल रूपों में वापस सरलीकरण करना बहुत कठिन बनाने के लिए डिज़ाइन किए गए हैं।
* **अपारदर्शी प्रेडिकेट्स**: सशर्त शाखाएँ सम्मिलित करता है जहाँ स्थिति हमेशा सत्य (जैसे, `OBF_OPAQUE_PREDICATE_TRUE_1`) या हमेशा असत्य (जैसे, `OBF_OPAQUE_PREDICATE_FALSE_1`) का मूल्यांकन करती है। ये स्थितियाँ `__COUNTER__`, `__LINE__`, `__TIME__`, और `_obf_global_opaque_seed` से जुड़े जटिल, स्थिर रूप से मूल्यांकन करने में कठिन अभिव्यक्तियों से निर्मित होती हैं। ये भ्रामक कोड पथ बनाती हैं और डेड कोड की रक्षा करने या विशिष्ट निष्पादन प्रवाह को बाध्य करने के लिए उपयोग की जा सकती हैं।
* **जंक कोड इंजेक्शन**:
* `OBF_CALL_ANY_LOCAL_JUNK`: `obf_junk_ns` में परिभाषित कई छोटे, यादृच्छिक जंक फ़ंक्शनों में से एक को कॉल करता है। ये फ़ंक्शन तुच्छ, अस्थिर संचालन करते हैं और संकलन समय पर यादृच्छिक रूप से चुने जाते हैं। इनका उद्देश्य कोड एन्ट्रॉपी बढ़ाना, सरल कोड पैटर्न को तोड़ना, और संभावित रूप से हस्ताक्षर-आधारित पहचान या विश्लेषण उपकरणों को गुमराह करना है।
* `NOP()`: एक मैक्रो जो अस्थिर संचालन सम्मिलित करता है जो ऑप्टिमाइज़र्स द्वारा आसान हटाने को रोकने और एक वैश्विक सीड को सूक्ष्म रूप से संशोधित करने के लिए डिज़ाइन किया गया है।
* **एंटी-डिसअसेंबली और एंटी-विश्लेषण चालें**:
* **ओबफस्केटेड जंप (`OBF_JUMP_*` मैक्रोज़)**: `goto` स्टेटमेंट बनाता है जिनकी स्थितियाँ या लक्ष्य ओबफस्केटेड होते हैं, जो अक्सर अपारदर्शी प्रेडिकेट्स या MBA पर निर्भर होते हैं।
* **ओबफस्केटेड स्टेट ट्रांज़िशन (`OBF_SET_NEXT_STATE_*` मैक्रोज़)**: ICFF में उपयोग किए जाते हैं, ये मैक्रोज़ फ्लैटन कंट्रोल फ्लो डिस्पैचर के लिए अगले स्टेट वेरिएबल को ओबफस्केटेड जंप के समान ओबफस्केशन तकनीकों का उपयोग करके सेट करते हैं।
* **स्टैक मैनिपुलेशन (`OBF_STACK_ALLOC_MANIP`, `OBF_FAKE_PROLOGUE_MANIP`)**: स्टैक पर परिवर्तनीय आकार के चंक आवंटित करता है और उन पर नकली हेरफेर करता है। नकली प्रोलॉग स्टैक विश्लेषण को भ्रमित करने का प्रयास करते हैं।
* **ओबफस्केटेड फ़ंक्शन कॉल (`OBF_CALL_VIA_OBF_PTR`)**: फ़ंक्शन पॉइंटर्स को उपयोग से पहले और बाद में एक गतिशील कुंजी के साथ XOR किया जाता है, जिससे वास्तविक कॉल लक्ष्य अस्पष्ट हो जाता है।
* `K8_ASSUME(0)`: डेड कोड पथों में MSVC कंपाइलर को संकेत देने के लिए उपयोग किया जाता है कि ये पथ अप्राप्य हैं, जो संभावित रूप से विभिन्न ऑप्टिमाइज़ेशन या कोड जनरेशन की अनुमति देता है जो यदि किसी पैच द्वारा धारणा का उल्लंघन किया जाता है तो विश्लेषण को और भ्रमित कर सकता है।
### निर्भरताएँ
Obfusk8 लाइब्रेरी मॉड्यूलर है। मुख्य कार्यक्षमता इस पर निर्भर करती है:
- `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp`: (यह फ़ाइल) केंद्रीय हेडर जो मुख्य ओबफस्केशन मैक्रोज़ और प्रिमिटिव्स को ऑर्केस्ट्रेट और प्रदान करता है।
- `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`: AES-आधारित कंपाइल-टाइम स्ट्रिंग एन्क्रिप्शन और वैकल्पिक PE सेक्शन मैनिपुलेशन सुविधाएँ प्रदान करता है।
- `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp`: PEB-आधारित स्टील्थी Windows API रिज़ॉल्यूशन लागू करता है।
* `Obfusk8/Instrumentation/materialization/transform/k8_indsys.hpp`: **इनडायरेक्ट सिस्कॉल इंजन** को ऑर्केस्ट्रेट करता है। यह ट्रांज़िशन स्टब्स के जीवनचक्र का प्रबंधन करता है और लेटरल मेमोरी गैजेट्स के माध्यम से सिस्टम कॉल निष्पादित करने के लिए इंटरफ़ेस प्रदान करता है।
* `Obfusk8/Instrumentation/materialization/transform/getpeb8.hpp`: प्रारंभिक बूटस्ट्रैप और **PEB डिस्कवरी** की सुविधा प्रदान करता है। इसमें कस्टम हैशिंग लॉजिक, मूल संरचना परिभाषाएँ, और SSN कटौती के लिए "सॉर्टिंग हैट" एल्गोरिथ्म शामिल है। यह सभी मॉड्यूल एन्यूमरेशन कार्यों के लिए निम्न-स्तरीय आधार के रूप में कार्य करता है।
वैकल्पिक हेल्पर API क्लासेस अलग-अलग हेडर्स में प्रदान की जाती हैं, जो आमतौर पर उपनिर्देशिकाओं में स्थित होती हैं:
- `k8_ProcessManipulationAPIs/k8_ProcessManipulationAPIs.hpp`: स्टील्थी प्रक्रिया हेरफेर API के लिए।
- `k8_CryptographyAPIs/k8_CryptographyAPIs.hpp`: स्टील्थी क्रिप्टोग्राफ़ी API के लिए।
- `k8_NetworkingAPIs/k8_NetworkingAPIs.hpp`: स्टील्थी नेटवर्किंग API के लिए।
- `k8_RegistryAPIs/k8_RegistryAPIs.hpp`: स्टील्थी रजिस्ट्री API के लिए।
### विज़ुअलाइज़ेशन
* **आईडीए ग्राफ**:
* **आईडीए प्रो से कुछ चंक्स**:
* **डिटेक्ट इट ईज़ी सिग्नेचर परिणाम**:
* **वायरसटोटल से क्राउडसोर्स्ड YARA नियम**:
* **मेमोरी मैप (die से)**:
* **सेक्शन्स**:
* **बाउंडेड फ़ाइलें**:
### इंजन विश्लेषण और पहचान प्रोफ़ाइल
Obfusk8 को स्टैटिक सिग्नेचर-आधारित पहचान इंजनों को बायपास करने को प्राथमिकता देने के लिए डिज़ाइन किया गया है। उद्योग-मानक विक्रेताओं के विरुद्ध परीक्षण से पता चलता है कि मुख्य ओबफस्केशन लॉजिक प्रमुख सुरक्षा उत्पादों द्वारा अज्ञात रहता है, जिनमें शामिल हैं:
* **Microsoft Defender**: अज्ञात
* **Kaspersky**: अज्ञात
* **ESET-NOD32**: अज्ञात
* **BitDefender**: अज्ञात
जबकि स्टैटिक सिग्नेचर बायपास हो जाते हैं, कुछ नेक्स्ट-जनरेशन AV और EDR (जैसे CrowdStrike या Symantec) "संदिग्ध" या "उच्च विश्वास के साथ दुर्भावनापूर्ण" लेबल वाले ह्यूरिस्टिक फ्लैग उत्पन्न कर सकते हैं। ये डिटेक्शन आमतौर पर पहचाने जाने योग्य दुर्भावनापूर्ण कोड के बजाय उच्च आर्किटेक्चरल जटिलता और कस्टम PE सेक्शन की उपस्थिति से शुरू होते हैं।
### संरचनात्मक और फोरेंसिक विशेषताएँ
* **एन्ट्रॉपी प्रबंधन**: वर्तमान कार्यान्वयन लगभग 6.2 की वैश्विक एन्ट्रॉपी उत्पन्न करता है। यह जानबूझकर संतुलित किया गया है ताकि लॉजिक को अस्पष्ट करने के लिए पर्याप्त उच्च हो लेकिन 7.0 से ऊपर एन्ट्रॉपी स्तरों द्वारा ट्रिगर किए जाने वाले सामान्य "पैक्ड फ़ाइल" अलर्ट से बचने के लिए पर्याप्त कम हो।
* **सेक्शन कस्टमाइज़ेशन**: डिफ़ॉल्ट कॉन्फ़िगरेशन में 23 PE सेक्शन शामिल हैं, जिनमें से कुछ ज्ञात व्यावसायिक प्रोटेक्टर्स की नकल करने के लिए डिकॉय नामों (जैसे, `.themida`, `.vmp0`, `.enigma2`) का उपयोग करते हैं।
* **ह्यूरिस्टिक ऑप्टिमाइज़ेशन**: संदेह स्कोर को और कम करने के लिए, उपयोगकर्ता इन सेक्शनों को सामान्य स्ट्रिंग्स (जैसे, `.data_01`, `.rdata_aux`) में पुनः नाम दे सकते हैं। सेक्शन नामों को मानकीकृत करने से अक्सर ह्यूरिस्टिक "विशिष्टता" स्कोर कम हो जाता है, जिससे बाइनरी एक पारंपरिक संकलित एप्लिकेशन की तरह दिखाई देती है।
* **इम्पोर्ट ओबफस्केशन**: लाइब्रेरी महत्वपूर्ण Windows API के लिए Import Address Table (IAT) फुटप्रिंट को सफलतापूर्वक समाप्त करती है। रिज़ॉल्यूशन के लिए Process Environment Block (PEB) और इनडायरेक्ट सिस्कॉल इंजन का उपयोग करके, बाइनरी एक स्वच्छ कॉल स्टैक बनाए रखती है, जो व्यवहारिक मॉनिटरों को संरक्षित कोड क्षेत्रों में वापस सिस्टम कॉल को ट्रेस करने से रोकती है।
- **त्वरित स्पष्टीकरण**:
* **SSN कटौती**: ntdll.dll के इंस्ट्रक्शन स्ट्रीम पर अक्सर रखे जाने वाले यूज़र-मोड हुक को बायपास करने के लिए, इंजन एक सापेक्ष सॉर्टिंग एल्गोरिथ्म का उपयोग करता है। एक्सपोर्ट डायरेक्ट्री को पार्स करके और सभी Zw-उपसर्ग फ़ंक्शन्स को उनके मेमोरी पतों के अनुसार सॉर्ट करके, इंजन उनकी सापेक्ष अनुक्रमणिका के आधार पर सिस्टम सर्विस नंबर (SSN) का अनुमान लगाता है। यह फ्रेमवर्क को फ़ंक्शन प्रोलॉग के हुक किए गए बाइट्स को कभी पढ़े बिना सही syscall इंडेक्स की पहचान करने की अनुमति देता है।
* **डायनामिक सिस्कॉल स्टब्स**: उपयोगकर्ता-लैंड बाइनरी के भीतर स्थिर syscall निर्देशों का उपयोग करने के बजाय, लाइब्रेरी गतिशील रूप से क्षणिक ट्रांज़िशन स्टब्स को होस्ट करने के लिए निष्पादन योग्य मेमोरी आवंटित करती है। इंजन इन स्टब्स को syscalls को अप्रत्यक्ष रूप से निष्पादित करने के लिए एक कस्टम शेलकोड अनुक्रम (`mov r10, rcx; mov eax, ssnnumber; syscall; ret`) से आबाद करता है।
* **चेन बूटस्ट्रैपिंग**: रिज़ॉल्यूशन प्रक्रिया स्व-बूटस्ट्रैप्ड है; इंजन बाद के अप्रत्यक्ष syscalls के लिए वातावरण स्थापित करने के लिए एक प्रारंभिक रिज़ॉल्व्ड कॉल का उपयोग करता है। यह सुनिश्चित करता है कि प्रक्रिया का पूरा जीवनचक्र—मॉड्यूल एन्यूमरेशन से लेकर फ़ंक्शन निष्पादन तक—व्यवहारिक मॉनिटरों के लिए अपारदर्शी रहे और एक स्वच्छ कॉल स्टैक बनाए रखे।
* **एंटी-फोरेंसिक्स**: मिक्स्ड बूलियन-अरिथमेटिक (MBA) और बहु-स्तरीय वर्चुअल इंस्ट्रक्शन सेट आर्किटेक्चर (V-ISA) का उपयोग यह सुनिश्चित करता है कि भले ही मेमोरी डंप प्राप्त हो, अंतर्निहित लॉजिक स्वचालित डीओबफस्केशन टूल के माध्यम से पुनर्निर्माण करना गैर-तुच्छ है।
### उपयोग
1. अपने मुख्य प्रोजेक्ट फ़ाइल (जैसे, `main.cpp`) में `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` शामिल करें।
```cpp
#include "Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp" // आवश्यकतानुसार पथ समायोजित करें
```
2. अपने `main` फ़ंक्शन के बॉडी को `_main` से रैप करें:
```cpp
_main({
// आपका एप्लिकेशन का मूल main कोड यहाँ
// उदाहरण:
// OBFUSCATE_STRING("Hello, Obfuscated World!").c_str();
// API रैपर क्लास का उपयोग करना
k8_NetworkingAPIs::NetworkingAPI* netAPI = new k8_NetworkingAPIs::NetworkingAPI;
if (netAPI->IsInitialized() && netAPI->pInternetOpenA) {
HINTERNET hInternet = netAPI->pInternetOpenA(OBFUSCATE_STRING("MyAgent").c_str(), INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
if (hInternet) {
// ... hInternet का उपयोग करें ...
netAPI->pInternetCloseHandle(hInternet);
}
}
delete netAPI;
})
```
3. सभी महत्वपूर्ण स्ट्रिंग लिटरल के लिए `OBFUSCATE_STRING("your string")` का उपयोग करें। API कॉल के लिए आवश्यक होने पर डिक्रिप्टेड स्ट्रिंग को इसके `.c_str()` मेथड के माध्यम से एक्सेस करें, या यदि `Obfusk8/Instrumentation/materialization/transform/AES8.hpp` द्वारा प्रदान किया गया हो तो इसके अन्य मेथड जैसे `.print_to_console()` का उपयोग करें।
4. प्रत्यक्ष स्टील्थी API कॉल के लिए `STEALTH_API_OBFSTR("dll_name.dll", "FunctionNameA")` का उपयोग करें, या अधिमानतः सुविधा और अंतर्निहित स्टील्थ के लिए API रैपर क्लासेस (जैसे, `K8_ProcessManipulationAPIs::ProcessAPI`, `k8_NetworkingAPIs::NetworkingAPI`) का उपयोग करें।
5. अपने कोड के प्रदर्शन-असंवेदनशील महत्वपूर्ण अनुभागों में ओबफस्केशन की अतिरिक्त परतों के लिए `OBF_BOGUS_FLOW_*`, `OBF_CALL_ANY_LOCAL_JUNK`, `NOP()` और अन्य प्रिमिटिव्स छिड़कें।
* main.cpp फ़ाइल देखें।
### निर्माण
* **कंपाइलर आवश्यकता**: यह लाइब्रेरी C++17 के लिए डिज़ाइन की गई है। Microsoft C++ कंपाइलर (`cl.exe`) मुख्य रूप से लक्षित है, विशेष रूप से PE सेक्शन सुविधाओं और SEH उपयोग के लिए।
* **Windows पर `cl.exe` (MSVC कंपाइलर) प्राप्त करना**:
1. **Visual Studio इंस्टॉल करें**: `cl.exe` प्राप्त करने का सबसे आसान तरीका Visual Studio इंस्टॉल करना है। आप [Visual Studio वेबसाइट](https://visualstudio.microsoft.com/downloads/) से Visual Studio Community संस्करण मुफ्त में डाउनलोड कर सकते हैं।
2. **वर्कलोड चुनें**: इंस्टॉलेशन के दौरान, सुनिश्चित करें कि आप "Desktop development with C++" वर्कलोड चुनें। यह C++ कंपाइलर, Windows SDK और अन्य आवश्यक उपकरण स्थापित करेगा।
3. **डेवलपर कमांड प्रॉम्प्ट का उपयोग करें**: इंस्टॉलेशन के बाद, अपने स्टार्ट मेनू में "Developer Command Prompt for VS" (जैसे, "x64 Native Tools Command Prompt for VS 2022") खोजें और इसे चलाएँ। यह कमांड प्रॉम्प्ट स्वचालित रूप से `cl.exe` का उपयोग करने के लिए आवश्यक पर्यावरण चर (PATH, INCLUDE, LIB) सेट करता है।
* **शामिल पथ**:
* सुनिश्चित करें कि `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` वाली निर्देशिका आपके कंपाइलर के इन्क्लूड पथ में है।
* यदि `Obfusk8/Instrumentation/materialization/transform/AES8.hpp`, `Obfusk8/Instrumentation/materialization/transform/Resolve8.hpp`, और API रैपर निर्देशिकाएँ (जैसे, `k8_NetworkingAPIs/`) `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` के समान निर्देशिका में नहीं हैं, तो सुनिश्चित करें कि उनके पथ भी सही ढंग से कॉन्फ़िगर किए गए हैं। `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` अपने कुछ आंतरिक शामिल API रैपरों के लिए `../Obfusk8Core.hpp` जैसे सापेक्ष पथों का उपयोग करता है, इसलिए निर्देशिका संरचना मायने रखती है। यदि `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` इस लाइब्रेरी के लिए आपकी इन्क्लूड निर्देशिका के मूल में है, तो API रैपर उपनिर्देशिकाओं में होने चाहिए जैसे `k8_NetworkingAPIs/` उस स्थान के सापेक्ष जहाँ `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` उन्हें अपेक्षा करता है या `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` के भीतर इन्क्लूड पथों को समायोजित करें।
* **संकलन उदाहरण (डेवलपर कमांड प्रॉम्प्ट का उपयोग करके)**:
यह मानते हुए कि आपका `main.cpp` और Obfusk8 हेडर्स सही ढंग से संरचित हैं, आप निम्न कमांड के समान कमांड का उपयोग करके संकलित कर सकते हैं:
```bash
cl /std:c++17 /EHsc main.cpp
```
* `x64 Native Tools Command Prompt for VS 2022` खोलने के बाद:
* `/std:c++17`: C++17 मानक निर्दिष्ट करता है।
* `/EHsc`: C++ अपवाद हैंडलिंग मॉडल निर्दिष्ट करता है।
* `main.cpp`: आपकी मुख्य स्रोत फ़ाइल।
* `/I"path/to/your/obfusk8_includes"`: (वैकल्पिक, यदि हेडर्स डिफ़ॉल्ट पथों में नहीं हैं) वह निर्देशिका जोड़ें जहाँ `Obfusk8/Instrumentation/materialization/state/Obfusk8Core.hpp` और इसकी निर्भरताएँ स्थित हैं। यदि वे उपनिर्देशिकाओं में हैं, तो सुनिश्चित करें कि `Obfusk8Core.hpp` के भीतर सापेक्ष पथ आपके लेआउट से मेल खाते हैं।
* **लाइब्रेरी पर ध्यान दें**: जबकि स्टील्थ API रिज़ॉल्यूशन का उद्देश्य ओबफस्केटेड फ़ंक्शन के लिए स्टैटिक लिंकिंग से बचना है, Windows SDK हेडर्स को लिंकर को कुछ `.lib` फ़ाइलों की उपलब्धता की आवश्यकता हो सकती है ताकि किसी भी गैर-ओबफस्केटेड SDK उपयोग या आंतरिक प्रकारों (जैसे, `Ws2_32.lib`, `Wininet.lib`, `Advapi32.lib`, आदि) को हल किया जा सके। एक साधारण प्रोजेक्ट जैसे `cl /std:c++17 /EHsc main.cpp` के लिए, लिंकर अक्सर इन्हें स्वचालित रूप से हल करता है यदि वे मानक Windows लाइब्रेरी हैं।
* **CMAKE**: आप cmake का उपयोग करके भी Obfusk8 बना सकते हैं।
1. रेपो को क्लोन करें और उसमें शामिल हों: `git clone https://github.com/x86byte/Obfusk8.git` और निर्देशिका में जाएँ `cd Obfusk8`
2. फ़ाइलों को कॉन्फ़िगर और जनरेट करें: `cmake CMakeLists.txt`
3. बिल्ड टूल्स का स्वचालित चयन और संकलन: `cmake --build .`
* `x64 Native Tools Command Prompt for VS 2022` खोलने के बाद:
* **CMAKE और Microsoft Visual Studio**:
* `microsoft visual studio` खोलने के बाद, प्रोजेक्ट को संकलित करने के लिए `Ctrl + B` पर क्लिक करें:
* **बाइनरी आकार और भविष्य संवर्द्धन पर विचार**:
* **आकार प्रभाव**: ध्यान रखें कि हेडर-ओनली ओबफस्केशन का व्यापक उपयोग, विशेष रूप से जंक कोड इनलाइनिंग, MBA एक्सपैंशन और फ्लैटन कंट्रोल फ्लो जैसी तकनीकों के साथ, अंतिम बाइनरी आकार में महत्वपूर्ण वृद्धि कर सकता है। एक छोटा प्रोग्राम किलोबाइट्स से बढ़कर 2MB या उससे अधिक हो सकता है, जो लागू ओबफस्केशन की तीव्रता पर निर्भर करता है।
* **कस्टमाइज़ेशन और पैकिंग (भविष्य की दिशा)**:
* वर्तमान में, Obfusk8 इन-कोड ओबफस्केशन पर केंद्रित है। यदि बाइनरी आकार एक महत्वपूर्ण बाधा है, तो उपयोगकर्ताओं को विभिन्न मैक्रोज़ के उपयोग को ठीक-ठीक समायोजित करने की आवश्यकता हो सकती है (जैसे, `OBF_CALL_ANY_LOCAL_JUNK` के घनत्व को कम करना या `_main` के लूप की जटिलता को कम करना)।
* ओबफस्केशन के बाद पर्याप्त आकार कमी के लिए, बाहरी PE पैकर (जैसे UPX, MPRESS, या कस्टम समाधान) को एकीकृत या उपयोग करना एक अलग कदम होगा।
* Obfusk8 के भविष्य के विकास में ओबफस्केशन तीव्रता पर अधिक सूक्ष्म नियंत्रण के विकल्प या यहां तक कि लाइब्रेरी के भीतर सीधे हल्के पैकिंग/कम्प्रेशन स्टब्स को एकीकृत करने के विकल्पों का पता लगाया जा सकता है, हालांकि इससे इसकी जटिलता में काफी वृद्धि होगी।
### पोस्ट-बिल्ड PE ओबफस्केशन
Obfusk8 में संकलित बाइनरी को फोरेंसिक आर्टिफैक्ट्स को हटाकर और अधिक कठोर बनाने के लिए एक पोस्ट-बिल्ड स्क्रिप्ट शामिल है।
* **स्क्रिप्ट स्थान**: `Obfusk8/SCRIPTS/obfuscate_pe.ps1`
* **यह क्या करता है**:
1. **रिच हेडर हटाता है** — MSVC बिल्ड-एनवायरनमेंट फिंगरप्रिंट को हटाता है जो कंपाइलर संस्करण और टूलचेन विवरण प्रकट करता है।
2. **TimeDateStamp स्पूफ करता है** — PE हेडर टाइमस्टैम्प को बिल्ड समय को अस्पष्ट करने के लिए एक निश्चित मान से बदल देता है।
3. **डीबग निर्देशिका साफ़ करता है** — डीबग निर्देशिका प्रविष्टियों को मिटा देता है जो PDB पथ या बिल्ड मेटाडेटा लीक कर सकती हैं।
* **उपयोग**:
संकलन के बाद पोस्ट-बिल्ड चरण के रूप में चलाएँ:
```powershell
PowerShell -NoProfile -ExecutionPolicy Bypass -File Obfusk8/SCRIPTS/obfuscate_pe.ps1 -Path "path\to\Obfusk8.exe"
```
स्क्रिप्ट बाइनरी को इन-प्लेस संशोधित करती है। कोई बैकअप नहीं बनाया जाता है।
### डेमो
[[Obfusk8: C++17-आधारित ओबफस्केशन लाइब्रेरी - IDA प्रो ग्राफ़ व्यू] ~वीडियो डेमो](https://youtu.be/B9g4KSg3tHQ)
### योगदान और प्रतिक्रियायह प्रोजेक्ट, Obfusk8, उन्नत C++ अस्पष्टीकरण तकनीकों की एक सतत खोज है। वर्तमान संस्करण कई आपस में जुड़ी रणनीतियों के साथ एक मजबूत नींव रखता है।
* **आपकी प्रतिक्रिया अमूल्य है**: Obfusk8 के डेवलपर के रूप में, मुझे आपके दृष्टिकोण, अंतर्दृष्टि और आपके किसी भी फीडबैक में गहरी दिलचस्पी है। चाहे वह नई सुविधाओं के सुझाव हों, मौजूदा तकनीकों में सुधार, Obfusk8 द्वारा संरक्षित कोड के खिलाफ सफल (या असफल) रिवर्स इंजीनियरिंग प्रयासों की रिपोर्ट, या लाइब्रेरी की उपयोगिता और प्रभावशीलता पर सामान्य विचार हों।
* **योगदान**: सभी योगदानों का स्वागत है और उनकी बहुत सराहना की जाती है। यह प्रोजेक्ट समुदाय के इनपुट और वास्तविक दुनिया के परीक्षण पर पनपता है ताकि इसकी सीमाओं को आगे बढ़ाया जा सके और कोड सुरक्षा के लिए और भी अधिक दुर्जेय उपकरण बन सके। कृपया अपने विचार साझा करने, मुद्दे उठाने, या इसके विकास में योगदान देने में संकोच न करें!।
* **[Obfusk8 में कैसे योगदान करें?](https://opensource.guide/how-to-contribute/)**
### विशेष धन्यवाद
* [sadMosquito](https://github.com/sadMosquito) — मुद्दों की रिपोर्ट करने और प्रोजेक्ट का परीक्षण करने के लिए
**अस्वीकरण**
अस्पष्टीकरण बचाव की एक परत है, कोई अचूक समाधान नहीं। पर्याप्त कौशल और समय वाले दृढ़ हमलावर अक्सर अस्पष्ट कोड को रिवर्स इंजीनियर कर सकते हैं। Obfusk8 का उद्देश्य ऐसे प्रयासों के लिए बार को काफी ऊपर उठाना है। अन्य सुरक्षा उपायों के साथ प्रयोग करें।
**संपर्क करें**
यदि आप प्रतिक्रिया साझा करना चाहते हैं, अस्पष्टीकरण तकनीकों पर चर्चा करना चाहते हैं, रिवर्स इंजीनियरिंग प्रयासों की रिपोर्ट करना चाहते हैं, या बस एक तकनीकी चर्चा करना चाहते हैं, तो बेझिझक सीधे संपर्क करें। मैं हमेशा रचनात्मक बातचीत और सहयोग के लिए खुला हूँ (मुझे अस्पष्टीकरण से संबंधित प्रोजेक्ट्स या किसी और चीज में सहयोग करने में खुशी होगी)।
- x : https://x.com/x86byte
- telegram: https://t.me/x86byte
- discord: @x86byte