SindriKit

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

मुख्य अवधारणा

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

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

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

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

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

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

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_syscall_set_ntdll(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 पार्सर

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

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

40+ कोर टेस्ट कॉम्बिनेशन, जो x86 और x64 में एज-केस EXE, DLL, गलत आर्गुमेंट, लापता एक्सपोर्ट्स और TLS कॉलबैक्स को लक्षित करते हैं।
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_syscall_set_ntdll(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 — loader_winapi, loader_nowinapi, inject_pe, inject_shell, heavens_gate
टेस्ट — इंटीग्रेशन रनर, PE म्यूटेटर

नियोजित: Evasion डोमेन।

अस्वीकरण

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

लाइसेंस

MIT

SindriKit v1.5.0

श्रेणियाँ