stealth_call

O que é isso?

Biblioteca apenas de cabeçalho para Windows x64 que permite invocar qualquer chamada de sistema NT sem tocar em importações ntdll, sem deixar strings no seu binário e sem as bandeiras vermelhas habituais que fazem os EDRs perderem a cabeça.

Sem CRT. Sem STL. Sem IAT. A coisa toda compila para ~19KB com literalmente zero dependências de DLL.

Construída para evitar as armadilhas comuns das bibliotecas de syscall existentes — strings em texto simples, constantes de hash conhecidas, chamada direta de syscall de memória não-ntdll, importações IAT que gritam "estou fazendo algo estranho", IOC SEC_NO_CHANGE, inchaço CRT. Nada disso aqui.

Funcionalidades

Syscall Engine

• Syscalls indiretos — stubs saltam para o gadget syscall; ret do próprio ntdll, então RIP está sempre dentro de ntdll quando a instrução de syscall é disparada
• Geração de stub por chamada — cada invocação constrói um stub novo com lixo aleatório, layout aleatório, número de syscall XORado. Nada é reutilizado
• Imposição W^X — páginas temporárias vão RW → RX → RW. RWX nunca é alocado, ponto.
• Stubs apagados imediatamente após cada chamada
• Syscalls extraídos do mapeamento de seção \KnownDlls\ntdll.dll (sem acesso ao sistema de arquivos, invisível para ProcMon)
• 977 syscalls resolvidos em um sistema Win11 típico

Anti-Breakpoint

• Abordagem baseada em VEH — se um depurador colocar um 0xCC em sua função alvo, o manipulador de exceção silenciosamente restaura o byte original, executa a instrução sob passo único, então coloca o breakpoint de volta. O depurador nunca sabe que foi ignorado. Janela de tempo zero.
• Funciona em qualquer função em qualquer DLL, não apenas ntdll

Evasion

• Bypass AMSI — patcheia AmsiScanBuffer para retornar S_OK
• Bypass ETW — patcheia EtwEventWrite para retornar SUCCESS
• Todo patching feito através de syscalls diretos, não VirtualProtect
• Strings criptografadas com XOR em toda parte — nomes de DLL, caminhos, tudo. Descriptografado na pilha, apagado após o uso
• Algoritmo de hash personalizado (não FNV-1a, não CRC32 — sem assinaturas YARA conhecidas)
• Caminhada PEB para toda resolução de módulo/função — sem GetModuleHandle, sem GetProcAddress

Code Quality

• Apenas cabeçalho, solte a pasta stealth/ no seu projeto e pronto
• Thread-safe via páginas temporárias por thread + spinlocks
• Limpeza completa ao desligar — páginas temporárias liberadas, mapas zerados, VEH removido
• Detecção de hooks para trampolins comuns de EDR (jmp rel32, jmp [rip], mov rax + jmp rax)

Como Funciona

Caminho da Syscall

1. initialize() abre ntdll através da seção \KnownDlls, analisa exportações PE, captura cada número de syscall
2. Escaneia .text do ntdll por um gadget syscall; ret — é daqui que a instrução de syscall real executará
3. Quando você chama sc::invoke():
   • Procura a entrada de syscall por hash
   • Pega a página temporária da thread chamadora (ou aloca uma, apenas RW)
   • emit_stub() constrói um stub polimórfico único — instruções de lixo aleatórias antes/depois, número de syscall ofuscado com XOR com uma chave por chamada, jmp indireto para o gadget ntdll
   • Inverte a página RW → RX
   • Chama através do stub
   • Inverte de volta RX → RW
   • Zera os bytes do stub

Em nenhum momento existe memória RWX. Em nenhum momento uma instrução syscall executa fora de ntdll. Em nenhum momento números de syscall são armazenados em texto simples.

Trampolim VEH

Você chama tramp::invoke() com a função alvo. Se não houver breakpoint — a função simplesmente executa normalmente com zero overhead. Se um depurador colocou 0xCC:

1. Exceção INT3 dispara
2. Nosso manipulador VEH verifica se o endereço está em nossa tabela (busca hash, não varredura linear)
3. Restaura o byte original de uma cópia limpa lida do disco
4. Define a Trap Flag
5. Continua a execução — a instrução real é executada
6. Exceção de passo único dispara
7. Manipulador coloca 0xCC de volta

A lista de breakpoints do depurador ainda mostra como ativo. O breakpoint simplesmente nunca dispara em nossas chamadas.

Compilação

cmake -B build -A x64
cmake --build build --config Release

Requer MSVC (VS 2019+) e CMake 3.15+. A saída é ~19KB com zero importações.

Uso

Syscalls

#include "stealth/syscall.hpp"

stealth::sc::initialize();

PVOID base = nullptr;
SIZE_T size = 0x1000;
NTSTATUS status = stealth::sc::invoke<NTSTATUS>(
    HASH("NtAllocateVirtualMemory"),
    NtCurrentProcess(), &base, (ULONG_PTR)0, &size,
    (ULONG)(MEM_COMMIT | MEM_RESERVE), (ULONG)PAGE_READWRITE
);

Anti-Breakpoint

#include "stealth/trampoline.hpp"

// works even if x64dbg has a BP on MessageBoxA
int ret = stealth::tramp::invoke<int>(
    HASH_CI("user32.dll"), HASH("MessageBoxA"),
    (HWND)nullptr, (LPCSTR)"hello", (LPCSTR)"title", (UINT)MB_OK
);

AMSI / ETW

#include "stealth/bypass.hpp"

stealth::bypass::patch_etw();
stealth::bypass::patch_amsi();

Limpeza

stealth::tramp::shutdown();
stealth::sc::shutdown();

Estrutura do Projeto

stealth/
  common.hpp      — memory ops, spinlock, static_map, PRNG, debug output
  hash.hpp        — compile-time custom hash
  xorstr.hpp      — compile-time XOR string encryption
  peb.hpp         — PEB walk, PE export parser, hook detection
  syscall.hpp     — indirect syscall engine, stub generator, W^X, anti-dump
  trampoline.hpp  — VEH-based anti-breakpoint
  bypass.hpp      — AMSI + ETW patching

Licença

MIT — faça o que quiser com isso.