SindriKit

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/735/ac7a3259ddf602d9e7d0c2f683f22497afec347da32bb930d5369acf66ae34f5.png" width="100%">
</p>

<h1 align="center">SindriKit</h1>

<p align="center">
  <strong>आक्रामक विकास बेहतर आर्किटेक्चर का हकदार है।</strong><br>
  <em>आक्रामक क्षमताओं के निर्माण के लिए एक C लाइब्रेरी।</em>
</p>

---

## मूल अवधारणा

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

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

1. **तकनीक तर्क:** (जैसे, लोडर, इंजेक्शन, पैचर) स्टेट ट्रैकिंग और डेटा ऑर्केस्ट्रेशन से निपटता है। इसे इस बात की कोई जानकारी नहीं होती कि मेमोरी कैसे आवंटित की जाती है या थ्रेड्स कैसे बनाए जाते हैं।
2. **निष्पादन तंत्र:** (जैसे, 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 प्रदान करती है जो प्रत्येक प्रोफाइल का प्रयोग करती है:

```sh
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](https://github.com/youssefnoob003/sindrikit/blob/main/docs/examples/README.md) और [शुरुआत करना](https://github.com/youssefnoob003/sindrikit/blob/main/docs/getting_started/README.md)।

---

## SindriKit को एकीकृत करना

```cmake
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)
```

```sh
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      │
        └──────────────────┴──────────────────────┴──────────────────────────────────┘
```

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

```c
// 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 सिसकॉल रिज़ॉल्यूशन को एक इंजेक्टेबल तंत्र के रूप में मानता है, जो रणनीतियों को प्राथमिकता क्रम में स्टैक करता है। इंजन तब तक फॉल-थ्रू करता है जब तक कोई एक सफल न हो जाए:

```c
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 वेरिएबल के माध्यम से अंतिम बाइनरी से हटा दिया जाता है:

```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% सैंपल्स में क्रैश किए बिना साफ़ तौर पर अस्वीकार करता है।

### COFF / BOF लोडर

एक दूसरी लोडर तकनीक अनलिंक्ड COFF ऑब्जेक्ट फ़ाइलों (Beacon Object Files) को संभालती है: हेडर्स, सेक्शन्स, सिंबल्स, और रीलोकेशन्स की बाउंडेड पार्सिंग; इंजेक्ट किए गए `mod_api` के माध्यम से `MODULE$Function` एक्सटर्नल सिंबल रिज़ॉल्यूशन; आउट-ऑफ़-रेंज कॉल्स के लिए x64 `JMP [RIP+0]` ट्रैम्पोलिन्स; और एक नामित एंट्री पॉइंट (डिफ़ॉल्ट `go`) का निष्पादन — स्थानीय रूप से या किसी रिमोट प्रोसेस में मार्शल किया गया।

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

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

---

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

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

```c
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);
// 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" के अंदर एक वास्तविक कॉलर रिटर्न एड्रेस लगाता है, ताकि कॉल-स्टैक अनवाइंड्स सुसंगत रहें।

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

```c
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` दो इंटीजर्स में सिमट जाता है। और कुछ नहीं। एक `SND_CRTLESS=ON` बिल्ड `/NODEFAULTLIB`, कोई Windows SDK हेडर नहीं, एक PEB कमांड-लाइन फ्रंटएंड, और केवल नेटिव बैकएंड्स पर परत चढ़ाता है।

```cmake
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/`](https://github.com/youssefnoob003/sindrikit/blob/main/docs/README.md) के अंतर्गत पूर्ण संदर्भ:

- **[API संदर्भ](https://github.com/youssefnoob003/sindrikit/blob/main/docs/api_reference.md)** — पूर्ण सार्वजनिक C API (फ़ंक्शन्स, टाइप्स, DI टेबल्स, स्टेटस कोड्स)
- **[शुरुआत करना](https://github.com/youssefnoob003/sindrikit/blob/main/docs/getting_started/README.md)** — बिल्ड टियर्स, CMake एकीकरण, सिसकॉल बूटस्ट्रैप, पहला लोडर/इंजेक्शन वर्कफ़्लो
- **[आर्किटेक्चर](https://github.com/youssefnoob003/sindrikit/blob/main/docs/architecture/README.md)** — डिपेंडेंसी इंजेक्शन, स्टेट मशीन्स, फैसिलिटी-एनकोडेड स्टेटस सिस्टम
- **[प्रिमिटिव्स](https://github.com/youssefnoob003/sindrikit/blob/main/docs/primitives/README.md)** — मेमोरी, मॉड्यूल्स, प्रोसेस, मैपिंग, फ़ाइल्स, थ्रेड, सिसकॉल्स, एक्ज़ीक्यूशन (FFI, Heaven's Gate)
- **[लोडर्स](https://github.com/youssefnoob003/sindrikit/blob/main/docs/loaders/README.md)** — रिफ्लेक्टिव PE और COFF/BOF लोडिंग
- **[इंजेक्शन](https://github.com/youssefnoob003/sindrikit/blob/main/docs/injection/README.md)** — क्लासिक, अर्ली-बर्ड APC, और थ्रेड-हाईजैक इंजेक्शन (शेलकोड, PE, COFF)
- **[पार्सर्स](https://github.com/youssefnoob003/sindrikit/blob/main/docs/parsers/README.md)** — PE, COFF, और env (PEB/NTDLL) पार्सिंग
- **[कॉमन](https://github.com/youssefnoob003/sindrikit/blob/main/docs/common/README.md)** — CRT-मुक्त हेल्पर्स, बफ़र्स, हैशिंग, स्टेटस
- **[उदाहरण और PoCs](https://github.com/youssefnoob003/sindrikit/blob/main/docs/examples/README.md)** — `unified` CLI (`load pe|coff`, `inject classic|apc|hijack`, `hg`)
- **[टेस्ट्स](https://github.com/youssefnoob003/sindrikit/blob/main/docs/tests/README.md)** — इंटीग्रेशन रनर्स और PE म्यूटेटर

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

---

## अस्वीकरण

**SindriKit केवल शैक्षिक, अनुसंधान, और अधिकृत Red Teaming उद्देश्यों के लिए बनाया गया है।** पूर्ण कानूनी अस्वीकरण और OpSec विचारों के संबंध में जानकारी के लिए, [सुरक्षा नीति](https://github.com/youssefnoob003/sindrikit/blob/main/SECURITY.md) देखें।

---

## लाइसेंस

[MIT](https://github.com/youssefnoob003/sindrikit/blob/main/LICENSE)

---

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/735/c6b18a5428e9f22275a36c38df781706c1ddd2639451b49276a6cc0634dcb175.png" width="100%">
</p>