SysWhispers3

SysWhispers aiuta nell'evasione generando file header/ASM che gli implant possono utilizzare per effettuare chiamate di sistema dirette.

Canale Discord Ufficiale

Venite a trovarci su Discord!

Perché diavolo non ho creato una PR per SysWhispers2?

Le ragioni per cui SysWhispers3 è una versione autonoma sono molte, ma le più importanti sono:

• SysWhispers3 è il "fork" de facto utilizzato da [Inceptor][1], e implementa alcune classi di utilità che non sono rilevanti per la versione originale dello strumento.
• SysWhispers2 si sta muovendo verso il supporto della compilazione NASM (per gcc/mingw), mentre questa versione è specificamente progettata e testata per supportare MSVC (perché [Inceptor][1] rimarrà un framework solo Windows per il prossimo futuro).
• SysWhispers3 contiene funzionalità parzialmente implementate (come l'egg-hunting) che non sarebbe sensato includere nella versione originale dello strumento.

Differenze rispetto a SysWhispers2

L'uso è abbastanza simile a SysWhispers2, con le seguenti eccezioni:

• Supporta anche x86/WoW64
• Supporta la sostituzione delle istruzioni syscall con un EGG (da sostituire dinamicamente)
• Supporta salti diretti alle syscall in modalità x86/x64 (in WOW64 è quasi standard)
• Supporta salti diretti a syscall casuali (prendendo in prestito l'idea di @ElephantSeal)

Una spiegazione migliore di queste funzionalità è descritta nel post del blog [SysWhispers is dead, long live SysWhispers!][2]

Introduzione

I prodotti di sicurezza, come AV e EDR, solitamente inseriscono hook nelle funzioni API in modalità utente per analizzare il flusso di esecuzione di un programma, al fine di rilevare attività potenzialmente dannose.

SysWhispers2 è uno strumento progettato per generare coppie header/ASM per qualsiasi chiamata di sistema nell'immagine del kernel principale (ntoskrnl.exe), che possono poi essere integrate e chiamate direttamente da codice C/C++, eludendo gli hook in modalità utente.

Lo strumento, tuttavia, genera alcuni pattern che possono essere inclusi nelle firme, o comportamenti che possono essere rilevati a runtime.

SysWhispers3 è costruito sopra SysWhispers2 e integra alcune funzionalità utili per bypassare queste forme di rilevamento.

Installazione

C:\> git clone https://github.com/klezVirus/SysWhispers3.git
C:\> cd SysWhispers3
C:\> python .\syswhispers.py --help

Utilizzo ed Esempi

L'help mostra tutti i comandi e le funzionalità disponibili dello strumento:

C:\>python syswhispers.py -h

usage: syswhispers.py [-h] [-p PRESET] [-a {x86,x64}] [-m {embedded,egg_hunter,jumper,jumper_randomized}] [-f FUNCTIONS] -o OUT_FILE [--int2eh] [--wow64] [-v] [-d]

SysWhispers3 - SysWhispers on steroids

optional arguments:
  -h, --help            show this help message and exit
  -p PRESET, --preset PRESET
                        Preset ("all", "common")
  -a {x86,x64}, --arch {x86,x64}
                        Architecture
  -c {msvc,mingw,all}, --compiler {msvc,mingw,all}
                        Compiler
  -m {embedded,egg_hunter,jumper,jumper_randomized}, --method {embedded,egg_hunter,jumper,jumper_randomized}
                        Syscall recovery method
  -f FUNCTIONS, --functions FUNCTIONS
                        Comma-separated functions
  -o OUT_FILE, --out-file OUT_FILE
                        Output basename (w/o extension)
  --int2eh              Use the old `int 2eh` instruction in place of `syscall`
  --wow64               Use Wow64 to run x86 on x64 (only usable with x86 architecture)
  -v, --verbose         Enable debug output
  -d, --debug           Enable syscall debug (insert software breakpoint)

Righe di Comando

SysWhispers standard, chiamate di sistema incorporate (x64)

# Export all functions with compatibility for all supported Windows versions (see example-output/).
py .\syswhispers.py --preset all -o syscalls_all

# Export just the common functions (see below for list).
py .\syswhispers.py --preset common -o syscalls_common

# Export NtProtectVirtualMemory and NtWriteVirtualMemory with compatibility for all versions.
py .\syswhispers.py --functions NtProtectVirtualMemory,NtWriteVirtualMemory -o syscalls_mem

Esempi solo SysWhispers3

# Normal SysWhispers, 32-bits mode
py .\syswhispers.py --preset all -o syscalls_all -m jumper --arch x86

# Normal SysWhispers, using WOW64 in 32-bits mode (only specific functions)
py .\syswhispers.py --functions NtProtectVirtualMemory,NtWriteVirtualMemory -o syscalls_mem --arch x86 --wow64

# Egg-Hunting SysWhispers, to bypass the "mark of the sycall" (common function)
py .\syswhispers.py --preset common -o syscalls_common -m egg_hunter

# Jumping/Jumping Randomized SysWhispers, to bypass dynamic RIP validation (all functions) using MinGW as the compiler
py .\syswhispers.py --preset all -o syscalls_all -m jumper -c mingw

Output dello Script

PS C:\Projects\SysWhispers2> py .\syswhispers.py --preset common --out-file temp\syscalls_common -v 
                                                       
                  .                         ,--.
,-. . . ,-. . , , |-. o ,-. ,-. ,-. ,-. ,-.  __/
`-. | | `-. |/|/  | | | `-. | | |-' |   `-. .  \
`-' `-| `-' ' '   ' ' ' `-' |-' `-' '   `-'  '''
     /|                     |  @Jackson_T
    `-'                     '  @modexpblog, 2021

                      Edits by @klezVirus,  2022
SysWhispers3: Why call the kernel when you can whisper?


Common functions selected.

Complete! Files written to:
        temp\syscalls_common.h
        temp\syscalls_common.c
        temp\syscalls_common_.asm
Press a key to continue...

Importazione in Visual Studio

1. Copiare i file H/C/ASM generati nella cartella del progetto.
2. In Visual Studio, andare su Progetto → Build Customizations... e abilitare MASM.
3. In Esplora soluzioni, aggiungere i file .h e .c/.asm al progetto rispettivamente come file di header e sorgente.
4. Andare alle proprietà del file ASM e impostare Tipo elemento su Microsoft Macro Assembler.

Compilazione al di fuori di Visual Studio

Windows

Makefile per 64 bit:

Makefile.msvc

OPTIONS = -Zp8 -c -nologo -Gy -Os -O1 -GR- -EHa -Oi -GS-
LIBS = libvcruntime.lib libcmt.lib ucrt.lib kernel32.lib

program:
  ML64 /c syscalls-asm.x64.asm /link /NODEFAULTLIB /RELEASE /MACHINE:X64
  cl.exe $(OPTIONS) syscalls.c  program.c
  link.exe /OUT:program.x64.exe -nologo $(LIBS) /MACHINE:X64 -subsystem:console -nodefaultlib syscalls-asm.x64.obj syscalls.obj program.obj

Makefile per 32 bit:

Makefile.msvc

OPTIONS = -Zp8 -c -nologo -Gy -Os -O1 -GR- -EHa -Oi -GS-
LIBS = libvcruntime.lib libcmt.lib ucrt.lib kernel32.lib

program:
  ML /c syscalls-asm.x86.asm /link /NODEFAULTLIB /RELEASE /MACHINE:X86
  cl.exe $(OPTIONS) syscalls.c  program.c
  link.exe /OUT:program.x86.exe -nologo $(LIBS) /MACHINE:X86 -subsystem:console -nodefaultlib syscalls-asm.x86.obj syscalls.obj program.obj

Compilare con nmake:

nmake -f Makefile.msvc

Linux

Makefile sia per 64 che per 32 bit:

Makefile.mingw

CC_x64 := x86_64-w64-mingw32-gcc
CC_x86 := i686-w64-mingw32-gcc
OPTIONS := -masm=intel -Wall

program:
  $(CC_x64) syscalls.c program.c -o program.x64.exe $(OPTIONS)
  $(CC_x86) syscalls.c program.c -o program.x86.exe $(OPTIONS)

Compilare con make:

make -f Makefile.mingw

Avvertenze e Limitazioni