SindriKit

आक्रामक विकास बेहतर आर्किटेक्चर का हकदार है।
आक्रामक क्षमताओं के निर्माण के लिए एक C लाइब्रेरी।

मूल अवधारणा

अधिकांश आक्रामक उपयोगिताएँ अपने निष्पादन तंत्र को तकनीक के तर्क के भीतर हार्डकोड कर देती हैं। एक रिफ्लेक्टिव लोडर केवल एक इमेज को मैप नहीं करता; यह इसे VirtualAlloc या नेटिव NTAPI कॉल्स की एक विशिष्ट, हार्डकोडेड श्रृंखला का उपयोग करके मैप करता है। जब कोई EDR उस विशिष्ट श्रृंखला की निगरानी शुरू करता है, तो आपको पूरे टूल को फिर से लिखने के लिए मजबूर होना पड़ता है।

SindriKit इंटरफ़ेस एब्स्ट्रैक्शन टेबल्स के माध्यम से कंसर्न्स के पृथक्करण को लागू करके इसे हल करता है:

तकनीक तर्क: (जैसे, लोडर, इंजेक्शन, पैचर) स्टेट ट्रैकिंग और डेटा ऑर्केस्ट्रेशन से संबंधित है। इसे इस बात का कोई ज्ञान नहीं है कि मेमोरी कैसे आवंटित की जाती है या थ्रेड कैसे बनाए जाते हैं।
निष्पादन तंत्र: (जैसे, Win32 API, Native NTAPI, Direct Syscalls) स्वतंत्र API टेबल्स के भीतर होते हैं और रनटाइम पर तकनीक में इंजेक्ट किए जाते हैं।

निष्पादन तंत्र को रनटाइम फ़ंक्शन पॉइंटर्स में स्थानांतरित करके, आप अपने पेलोड निष्पादन तर्क को बदले बिना कोड की एक पंक्ति से अपनी पूरी रणनीति को Win32 कॉल्स से रॉ डायरेक्ट सिसकॉल्स में बदल सकते हैं।

डिज़ाइन आर्किटेक्चर

डिकपल्ड एक्ज़ीक्यूशन प्रोफाइल्स: कॉलिंग तकनीक को तोड़े बिना फ़ंक्शन पॉइंटर टेबल्स के माध्यम से अंतर्निहित मेमोरी, मॉड्यूल, और थ्रेड मैनिपुलेशन व्यवहार को स्वैप करें।
कैस्केडिंग सिसकॉल फ़ॉलबैक्स: प्लग करने योग्य SSN रिज़ॉल्वर (snd_syscall_resolve_ssn_scan, snd_syscall_resolve_ssn_sort) एक प्राथमिकता श्रृंखला के साथ — डोमेन कोड को छुए बिना रणनीतियों को स्वैप या विस्तारित करें।
कंपाइल-टाइम ऑबफस्केशन: स्ट्रिंग और API हैशिंग एल्गोरिदम (DJB2, FNV1A) को CMake के माध्यम से विश्व स्तर पर स्वैप किया जा सकता है। कंपाइल करना स्वचालित रूप से ग्लोबल सीड को रैंडमाइज़ करता है ताकि स्टैटिक सिग्नेचर बदल जाएँ।
म्यूटेशन इंजन: SND_MORPH के माध्यम से गहरी पॉलीमॉर्फिज़्म को सक्षम करता है। C कोड में वोलेटाइल ओपेक प्रेडिकेट्स, Assembly स्टब्स में कार्यात्मक रूप से समकक्ष मैथ/NOPs, और कोर स्ट्रक्चर्स के मेमोरी लेआउट को स्क्रैम्बल करके प्रत्येक बिल्ड पर अद्वितीय बाइनरी सिग्नेचर उत्पन्न करता है।
रिलीज़ बिल्ड्स: एक साइलेंट टियर अंतिम बाइनरी से सभी डायग्नोस्टिक स्ट्रिंग्स, फ़ाइल डिस्क्रिप्टर्स, और ट्रैकिंग फ़्रेम्स को हटा देता है, जिससे आपका स्टैटिक फुटप्रिंट बेयर प्रिमिटिव्स तक कम हो जाता है।

SindriKit को इंटीग्रेट करना

cmake_minimum_required(VERSION 3.16)
project(MyTool C ASM_MASM)

set(SND_BUILD_PAYLOADS  OFF    CACHE BOOL   "")
set(SND_ENABLE_DEBUG    OFF    CACHE BOOL   "")
set(SND_HASH_ALGO      "DJB2"  CACHE STRING "")
set(SND_RANDOMIZE_SEED  ON     CACHE BOOL   "")
set(SND_MORPH           ON     CACHE BOOL   "")

add_subdirectory(libs/SindriKit)

add_executable(my_tool src/main.c)
target_link_libraries(my_tool PRIVATE sindri::engine)

cmake -B build && cmake --build build --config Release

आपके टूल को SindriKit की सभी क्षमताओं को विरासत में पाने के लिए बस दो पंक्तियाँ: PE पार्सिंग, सिसकॉल रिज़ॉल्यूशन, रिफ्लेक्टिव लोडिंग...

इंजन

API एब्स्ट्रैक्शन लेयर

        ┌────────────────────────────────────────────────────────────────────────────┐
        │                          ANY OFFENSIVE INTENT                              │
        │    Loader · Injector · Spoofer · Patcher · Bypasser · Harvester · ...      │
        ├────────────────────────────────────────────────────────────────────────────┤
        │                     SINDRIKIT API ABSTRACTION LAYER                        │
        │      snd_memory_api_t  ->  alloc · free · protect                          │
        │      snd_module_api_t  ->  load_library · get_proc_address · ...           │
        │      snd_process_api_t ->  open · alloc_remote · write · protect · thread  │
        │      [ future tables ] ->  thread · object · ...                           │
        ├──────────────────┬──────────────────────┬──────────────────────────────────┤
        │   Win32 Profile  │    Native Profile    │    Bring Your Own Mechanic       │
        │  VirtualAlloc    │  NtAllocateVirtual   │  Driver · ROP · Exotic           │
        │  LoadLibraryA    │  PEB Walk + EAT      │  Operator-defined functions      │
        └──────────────────┴──────────────────────┴──────────────────────────────────┘

व्यवहार में, इसका मतलब है कि प्रत्येक डोमेन एक ही अनुबंध का पालन करता है:

// Reflective loader
snd_ldr_pe_ctx_t ctx = {0};
ctx.raw_source = &payload;
ctx.mem_api    = &snd_mem_win;   // or snd_mem_nt / snd_mem_sys
ctx.mod_api    = &snd_mod_win;   // or snd_mod_nt
snd_ldr_pe_prepare_image(&ctx);
snd_ldr_pe_execute_image(&ctx);

// Classic injection
snd_inj_ctx_t inj = {0};
inj.target_pid = 1337;
inj.payload    = &shellcode;
inj.proc_api   = &snd_proc_sys;  // or snd_proc_win / snd_proc_nt
snd_inj_classic_shell(&inj);
snd_inj_cleanup(&inj);

कैस्केडिंग सिसकॉल पाइपलाइन

SindriKit सिसकॉल रिज़ॉल्यूशन को एक इंजेक्टेबल मैकेनिक के रूप में मानता है, जो रणनीतियों को प्राथमिकता क्रम में स्टैक करता है। इंजन तब तक फ़ॉल-थ्रू करता है जब तक कोई एक सफल न हो जाए:

snd_ntdll_set_clean(clean_ntdll);
snd_syscall_set_resolver(snd_syscall_resolve_ssn_scan);
snd_syscall_add_resolver(snd_syscall_resolve_ssn_sort);
snd_syscall_set_invoker(snd_syscall_direct_invoke_asm);
// or for indirect syscalls:
// snd_syscall_set_invoker(snd_syscall_indirect_invoke_asm);
// snd_syscall_set_gadget_finder(snd_syscall_find_gadget_scan);

इनवोकर SSN रिज़ॉल्यूशन से डिकपल्ड है — डोमेन कोड को संशोधित किए बिना डायरेक्ट और इनडायरेक्ट सिसकॉल्स के बीच स्विच करें। इनडायरेक्ट इनवोकेशन एक वैध NTDLL गैजेट पर जंप करता है, जिससे सिसकॉल रिटर्न एड्रेस ntdll.dll के भीतर रहता है।

कंपाइल-टाइम एल्गोरिदम एजिलिटी

प्रत्येक API नाम और मॉड्यूल स्ट्रिंग को एकल CMake वेरिएबल के माध्यम से कंपाइल टाइम पर अंतिम बाइनरी से हटा दिया जाता है:

set(SND_HASH_ALGO "FNV1A")  # or DJB2 recomputes everything automatically
set(SND_RANDOMIZE_SEED ON)  # generates a fresh 32-bit seed on next configure

प्रत्येक हैश की गणना एक रैंडमली जनरेट किए गए सीड के साथ की जाती है (यदि SND_RANDOMIZE_SEED=ON)। C की एक पंक्ति को छुए बिना कंपाइलेशन के बीच स्टैटिक फुटप्रिंट पूरी तरह से बदल जाता है।

आर्किटेक्चर-अवेयर डायनामिक FFI

मनमाने रनटाइम फ़ंक्शन इनवोकेशन के लिए एक कस्टम MASM असेंबली ब्रिज। x64 बिल्ड्स Microsoft x64 कॉलिंग कन्वेंशन का सटीक पालन करते हैं (शैडो स्पेस, रजिस्टर आर्गुमेंट प्लेसमेंट, स्टैक अलाइनमेंट)। x86 बिल्ड्स cdecl और stdcall दोनों टारगेट्स के समर्थन के साथ आर्गुमेंट्स को उल्टे क्रम में पुश करते हैं।

बाउंड्स-चेक्ड PE पार्सर

एक एकीकृत PE32/PE32+ पार्सर जिसमें एक is_mapped फ़्लैग है जो रॉ ऑन-डिस्क इमेज और मेमोरी-मैप्ड व्यू दोनों को सही ढंग से संभालता है। प्रत्येक डेटा डायरेक्टरी एक्सेस को डीरेफ़रेंस करने से पहले ट्रैक किए गए बफ़र बाउंड्स के विरुद्ध मान्य किया जाता है। एक्सपोर्ट रिज़ॉल्यूशन हैश-आधारित लुकअप के साथ गहराई 4 तक फ़ॉरवर्डर चेन का समर्थन करता है।

इसके विरुद्ध परीक्षण किया गया:

x86 और x64 में एज-केस EXEs, DLLs, बैड आर्गुमेंट्स, मिसिंग एक्सपोर्ट्स, और TLS कॉलबैक्स को लक्षित करने वाले 40+ कोर टेस्ट संयोजन।
pe_mutator मॉड्यूल द्वारा उत्पन्न 100+ डायनामिक PE म्यूटेशन: ज़ीरोड सेक्शन नाम, इंटीजर ओवरफ़्लो, अमान्य e_lfanew बाउंड्स, मैंगल्ड इम्पोर्ट्स।
पूर्ण Corkami कॉर्पस: वैध सैंपल्स को साफ़ तौर पर लोड करता है, 99% सैंपल्स में क्रैश किए बिना मैलफ़ॉर्म्ड को साफ़ तौर पर अस्वीकार करता है।

स्टेट-ट्रैक्ड डोमेन कॉन्टेक्स्ट्स

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

API डिज़ाइन दर्शन

सिसकॉल पाइपलाइन को एक बार बूटस्ट्रैप करें (विशिष्ट पैटर्न):

PVOID clean_ntdll = NULL;
snd_om_knowndll_map(&snd_map_nt, L"ntdll.dll", &clean_ntdll);
snd_ntdll_set_clean(clean_ntdll);
snd_syscall_set_resolver(snd_syscall_resolve_ssn_scan);
snd_syscall_add_resolver(snd_syscall_resolve_ssn_sort);
snd_syscall_set_invoker(snd_syscall_direct_invoke_asm);
// or for indirect syscalls:
// snd_syscall_set_invoker(snd_syscall_indirect_invoke_asm);
// snd_syscall_set_gadget_finder(snd_syscall_find_gadget_scan);

एक असाइनमेंट के साथ एक्ज़ीक्यूशन प्रोफाइल स्वैप करें:

ctx.mem_api = &snd_mem_win;   // diagnostic
ctx.mem_api = &snd_mem_nt;    // NT stubs via PEB + EAT
ctx.mem_api = &snd_mem_sys;   // direct syscalls (pipeline required)

मॉड्यूल रिज़ॉल्यूशन उसी पैटर्न का पालन करता है (snd_mod_win बनाम snd_mod_nt)। कोई सिसकॉल-बैक्ड मॉड्यूल बैकएंड नहीं है — इम्पोर्ट्स पूर्ण _sys प्रोफाइल्स में भी PEB वॉक + EAT का उपयोग करते हैं।

बिल्ड टियर्स

डीबग टियर — `SND_ENABLE_DEBUG=ON`

स्थानीय विकास के लिए। snd_status_t file, line, और एक 128-बाइट context स्ट्रिंग बफ़र को शामिल करने के लिए विस्तारित होता है। SND_ERR_CTX और SND_DEBUG_PRINT स्टेट मशीन ट्रांज़िशन, पार्स किए गए PE फ़ील्ड मान, और सिसकॉल रिज़ॉल्यूशन परिणाम उत्सर्जित करते हैं। डीबग कंसोल के बजाय stdout पर आउटपुट रूट करने के लिए SND_USE_PRINTF=ON का उपयोग करें।

साइलेंट टियर — `SND_ENABLE_DEBUG=OFF`

ऑपरेशनल बाइनरीज़ के लिए मानक डिप्लॉयमेंट कॉन्फ़िगरेशन। प्रत्येक डायग्नोस्टिक स्ट्रिंग, फ़ाइल संदर्भ, और लाइन नंबर पूरी तरह से कंपाइल हो जाता है। snd_status_t दो इंटीजर्स में सिमट जाता है। और कुछ नहीं।

set(SND_ENABLE_DEBUG   OFF   CACHE BOOL   "")
set(SND_BUILD_PAYLOADS OFF   CACHE BOOL   "")
set(SND_RANDOMIZE_SEED ON    CACHE BOOL   "")
set(SND_USE_DEFAULTS   ON    CACHE BOOL   "")
set(SND_HASH_ALGO    "DJB2"  CACHE STRING "")
add_subdirectory(vendor/SindriKit)
target_link_libraries(my_tool PRIVATE sindri::engine)

दस्तावेज़ीकरण

docs/ के अंतर्गत पूर्ण संदर्भ:

शुरुआत करना — CMake, बिल्ड टियर्स, DI बूटस्ट्रैप, पहला लोडर/इंजेक्शन वर्कफ़्लो
आर्किटेक्चर — डिपेंडेंसी इंजेक्शन, स्टेट मशीन्स, स्टेटस सिस्टम
प्रिमिटिव्स — मेमोरी, मॉड्यूल्स, प्रोसेस, मैपिंग, सिसकॉल्स, एक्ज़ीक्यूशन (FFI)
लोडर्स — रिफ्लेक्टिव PE पाइपलाइन
इंजेक्शन — क्लासिक शेलकोड और PE इंजेक्शन
पार्सर्स — PE और env (PEB) सबडोमेन्स
कॉमन — CRT-फ़्री हेल्पर्स, बफ़र्स, हैशिंग, स्टेटस
उदाहरण और PoCs — unified एक्ज़ीक्यूटेबल प्रोफाइल्स (load, inject, hg)
टेस्ट्स — इंटीग्रेशन रनर, PE म्यूटेटर

नियोजित: इवेज़न डोमेन।

अस्वीकरण

SindriKit केवल शैक्षिक, शोध, और अधिकृत Red Teaming उद्देश्यों के लिए बनाया गया है। पूर्ण कानूनी अस्वीकरण और OpSec विचारों के संबंध में जानकारी के लिए, सुरक्षा नीति देखें।

लाइसेंस

MIT

SindriKit v2.0.0

श्रेणियाँ