youssefnoob003/sindrikitUma biblioteca C fundamental para construir capacidades ofensivas operacionalmente críveis.
<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>O Desenvolvimento Ofensivo Merece uma Arquitetura Melhor.</strong><br>
<em>Uma biblioteca C para construir capacidades ofensivas.</em>
</p>
---
## Conceito Central
A maioria dos utilitários ofensivos codifica rigidamente seus mecanismos de execução dentro da lógica da técnica. Um loader reflexivo não apenas mapeia uma imagem; ele a mapeia usando uma cadeia específica e codificada de chamadas `VirtualAlloc` ou NTAPI nativas. Quando um EDR começa a monitorar essa cadeia específica, você é forçado a reescrever a ferramenta inteira.
O SindriKit resolve isso impondo uma separação de responsabilidades por meio de tabelas de abstração de interface:
1. **A Lógica da Técnica:** (ex.: loaders, injeções, patchers) lida com rastreamento de estado e orquestração de dados. Ela não tem conhecimento de como a memória é alocada ou como as threads são criadas.
2. **Os Mecanismos de Execução:** (ex.: Win32 API, NTAPI Nativa, Syscalls Diretas) ficam dentro de tabelas de API independentes e são injetados na técnica em tempo de execução.
Ao deslocar os mecanismos de execução para ponteiros de função em tempo de execução, você pode trocar toda a sua estratégia de chamadas Win32 para syscalls diretas brutas com uma única linha de código — sem alterar a lógica de execução do seu payload.
---
## Arquitetura de Design
* **Perfis de Execução Desacoplados:** Troque mecânicas de memória, módulo, mapeamento, processo, thread e arquivo por meio de tabelas independentes de ponteiros de função (`snd_memory_api_t`, `snd_module_api_t`, `snd_process_api_t`, `snd_thread_api_t`, `snd_mapping_api_t`, `snd_file_api_t`) sem tocar na lógica da técnica.
* **Cobertura de Técnicas:** Carregamento reflexivo de **PE** (EXE/DLL) e **COFF/BOF**, injeção **clássica** e **early-bird APC** sobre shellcode/PE/COFF, além de FFI ciente de arquitetura e Heaven's Gate — tudo sobre os mesmos perfis componíveis.
* **Pipeline de Syscalls em Cascata:** Resolvedores de SSN plugáveis (`snd_syscall_resolve_ssn_scan`, `snd_syscall_resolve_ssn_sort`) com uma cadeia de prioridade, desacoplados dos invocadores: **direto**, **indireto** (gadget NTDLL) ou **spoofed** (spoofing dinâmico de call-stack Fat-Frame).
* **Status Codificado por Facility:** Toda chamada sujeita a falha retorna `snd_status_t` — um código de facility/local empacotado mais o erro do SO capturado, com strings de contexto que são removidas na compilação no tier silencioso.
* **Ofuscação em Tempo de Compilação:** Algoritmos de hash de strings e APIs (DJB2, FNV1A) podem ser trocados globalmente via CMake. A compilação randomiza automaticamente a seed global para alterar assinaturas estáticas.
* **Motor de Mutação:** Habilita polimorfismo profundo via `SND_MORPH`. Gera assinaturas binárias únicas a cada build ao injetar predicados opacos voláteis no código C, matemática/NOPs funcionalmente equivalentes em stubs Assembly, e embaralhar o layout de memória de structs centrais.
* **Builds de Release:** Um tier silencioso remove todas as strings de diagnóstico, descritores de arquivo e frames de rastreamento; builds `SND_CRTLESS` vão além com `/NODEFAULTLIB`, sem header do SDK, um frontend PEB e apenas backends nativos.
---
## Início Rápido
O repositório inclui uma única CLI `unified` que exercita todos os perfis:
```sh
build.bat pocs
build64\pocs\Release\unified.exe load pe -f payload.dll -e Run --sys
```
`unified` suporta `load pe|coff`, `inject classic|apc|hijack` (shell, PE, COFF) e `hg`, cada um sobre `--win`/`--nt`/`--sys`. Veja [Exemplos & PoCs](https://github.com/youssefnoob003/sindrikit/blob/main/docs/examples/README.md) e [Primeiros Passos](https://github.com/youssefnoob003/sindrikit/blob/main/docs/getting_started/README.md).
---
## Integrando o 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
```
Apenas duas linhas para que sua ferramenta herde todas as capacidades do SindriKit: parsing de PE e COFF, carregamento reflexivo, syscalls em cascata e perfis de injeção.
---
## O Motor
### Camada de Abstração de API
```
┌────────────────────────────────────────────────────────────────────────────┐
│ QUALQUER INTENÇÃO OFENSIVA │
│ Loader · Injector · Spoofer · Patcher · Bypasser · Harvester · ... │
├────────────────────────────────────────────────────────────────────────────┤
│ CAMADA DE ABSTRAÇÃO DE API DO SINDRIKIT │
│ 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 │
├──────────────────┬──────────────────────┬──────────────────────────────────┤
│ Perfil Win32 │ Perfil Nativo │ Traga Seu Próprio Mecanismo │
│ VirtualAlloc │ NtAllocateVirtual │ Driver · ROP · Exótico │
│ LoadLibraryA │ PEB Walk + EAT │ Funções definidas pelo operador │
└──────────────────┴──────────────────────┴──────────────────────────────────┘
```
Na prática, isso significa que todo domínio segue o mesmo contrato:
```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);
```
### Pipeline de Syscalls em Cascata
O SindriKit trata a resolução de syscalls como um mecanismo injetável, empilhando estratégias em ordem de prioridade. O motor percorre até que uma tenha sucesso:
```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);
```
O invocador é desacoplado da resolução de SSN — alterne entre syscalls diretas, indiretas e spoofed sem modificar o código do domínio. A invocação indireta salta para um gadget legítimo da NTDLL para que o endereço de retorno permaneça dentro de `ntdll.dll`; a invocação spoofed adicionalmente planta um endereço de retorno genuíno do chamador dentro de um "Fat Frame" descoberto dinamicamente, para que os unwinds da call-stack permaneçam coerentes.
### Agilidade de Algoritmos em Tempo de Compilação
Todo nome de API e string de módulo é removido do binário final em tempo de compilação por meio de uma única variável 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
```
Cada hash é calculado com uma seed gerada aleatoriamente (se `SND_RANDOMIZE_SEED=ON`). A pegada estática muda completamente entre compilações sem tocar em uma linha de C.
### FFI Dinâmica Ciente de Arquitetura
Uma ponte assembly MASM personalizada para invocação arbitrária de funções em tempo de execução. Builds x64 seguem precisamente a convenção de chamada Microsoft x64 (shadow space, posicionamento de argumentos em registradores, alinhamento de pilha). Builds x86 empilham argumentos em ordem reversa com suporte para alvos `cdecl` e `stdcall`.
### Parser PE com Verificação de Limites
Um parser unificado PE32/PE32+ com uma flag `is_mapped` que lida corretamente tanto com imagens brutas em disco quanto com views mapeadas em memória. Todo acesso a data directory é validado contra limites de buffer rastreados antes da desreferência. A resolução de exportações suporta cadeias de forwarders até profundidade 4 com busca baseada em hash.
Testado contra:
- Mais de 40 combinações de testes centrais visando EXEs de casos extremos, DLLs, argumentos inválidos, exportações ausentes e callbacks TLS em x86 e x64.
- Mais de 100 mutações dinâmicas de PE geradas pelo módulo `pe_mutator`: nomes de seção zerados, overflows de inteiros, limites inválidos de `e_lfanew`, imports corrompidos.
- Corpus completo do Corkami: carrega amostras válidas de forma limpa, rejeita amostras malformadas de forma limpa sem travar em 99% das amostras.
### Loader COFF / BOF
Uma segunda técnica de loader lida com arquivos objeto COFF não linkados (Beacon Object Files): parsing limitado de headers, seções, símbolos e relocações; resolução de símbolos externos `MODULE$Function` através do `mod_api` injetado; trampolins x64 `JMP [RIP+0]` para chamadas fora de alcance; e execução de um ponto de entrada nomeado (padrão `go`) — localmente ou marshaled para um processo remoto.
### Contextos de Domínio com Rastreamento de Estado
Toda operação ofensiva é gerenciada através de uma estrutura de contexto discreta com enumeração de estágios. As operações podem ser pausadas entre estágios para ofuscação de sleep ou implantação em estágios, retomadas de forma limpa e inspecionadas quanto ao ponto exato de falha, até o subsistema e o motivo.
---
## A Filosofia de Design da API
Inicialize o pipeline de syscalls uma vez (padrão típico):
```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);
```
O invocador é desacoplado da resolução de SSN — alterne entre syscalls diretas, indiretas e spoofed sem modificar o código do domínio. A invocação indireta salta para um gadget legítimo da NTDLL para que o endereço de retorno permaneça dentro de `ntdll.dll`; a invocação spoofed adicionalmente planta um endereço de retorno genuíno do chamador dentro de um "Fat Frame" descoberto dinamicamente, para que os unwinds da call-stack permaneçam coerentes.
Troque o perfil de execução com uma atribuição:
```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)
```
A resolução de módulos segue o mesmo padrão (`snd_mod_win` vs `snd_mod_nt`). Não há backend de módulo baseado em syscalls — imports usam PEB walk + EAT mesmo em perfis `_sys` completos.
---
## Tiers de Build
### Tier de Debug — `SND_ENABLE_DEBUG=ON`
Para desenvolvimento local. `snd_status_t` expande para incluir `file`, `line` e um buffer de string `context` de 128 bytes. `SND_ERR_CTX` e `SND_DEBUG_PRINT` emitem transições de máquina de estado, valores de campos PE parseados e resultados de resolução de syscalls. Use `SND_USE_PRINTF=ON` para direcionar a saída para `stdout` em vez do console de debug.
### Tier Silencioso — `SND_ENABLE_DEBUG=OFF`
A configuração padrão de implantação para binários operacionais. Toda string de diagnóstico, referência de arquivo e número de linha é removida completamente na compilação. `snd_status_t` colapsa para dois inteiros. Nada mais. Um build `SND_CRTLESS=ON` adiciona `/NODEFAULTLIB`, sem header do Windows SDK, um frontend de linha de comando PEB e apenas backends nativos.
```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)
```
---
## Documentação
Referência completa em [`docs/`](https://github.com/youssefnoob003/sindrikit/blob/main/docs/README.md):
- **[Referência da API](https://github.com/youssefnoob003/sindrikit/blob/main/docs/api_reference.md)** — a API C pública completa (funções, tipos, tabelas DI, códigos de status)
- **[Primeiros Passos](https://github.com/youssefnoob003/sindrikit/blob/main/docs/getting_started/README.md)** — tiers de build, integração CMake, bootstrap de syscalls, primeiro fluxo de loader/injeção
- **[Arquitetura](https://github.com/youssefnoob003/sindrikit/blob/main/docs/architecture/README.md)** — injeção de dependência, máquinas de estado, sistema de status codificado por facility
- **[Primitivas](https://github.com/youssefnoob003/sindrikit/blob/main/docs/primitives/README.md)** — memória, módulos, processo, mapeamento, arquivos, thread, syscalls, execução (FFI, Heaven's Gate)
- **[Loaders](https://github.com/youssefnoob003/sindrikit/blob/main/docs/loaders/README.md)** — carregamento reflexivo de PE e COFF/BOF
- **[Injeção](https://github.com/youssefnoob003/sindrikit/blob/main/docs/injection/README.md)** — injeção clássica, early-bird APC e thread-hijack (shellcode, PE, COFF)
- **[Parsers](https://github.com/youssefnoob003/sindrikit/blob/main/docs/parsers/README.md)** — parsing de PE, COFF e env (PEB/NTDLL)
- **[Common](https://github.com/youssefnoob003/sindrikit/blob/main/docs/common/README.md)** — helpers sem CRT, buffers, hashing, status
- **[Exemplos & PoCs](https://github.com/youssefnoob003/sindrikit/blob/main/docs/examples/README.md)** — a CLI `unified` (`load pe|coff`, `inject classic|apc|hijack`, `hg`)
- **[Testes](https://github.com/youssefnoob003/sindrikit/blob/main/docs/tests/README.md)** — runners de integração e o mutador de PE
*Planejado: um domínio de **Evasão**.*
---
## Aviso Legal
**O SindriKit é construído apenas para fins educacionais, de pesquisa e Red Teaming autorizado.** Para o aviso legal completo e informações sobre considerações de OpSec, veja a [Política de Segurança](https://github.com/youssefnoob003/sindrikit/blob/main/SECURITY.md).
---
## Licença
[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>