SysWhispers3

SysWhispers ajuda com evasão gerando arquivos de cabeçalho/ASM que implantes podem usar para fazer chamadas diretas ao sistema.

Canal Oficial do Discord

Venha conversar no Discord!

Por que diabos não criei um PR para o SysWhispers2?

As razões para o SysWhispers3 ser uma versão independente são muitas, mas as mais importantes são:

• SysWhispers3 é o "fork" de facto usado pelo [Inceptor][1] e implementa algumas classes utilitárias que não são relevantes para a versão original da ferramenta.
• SysWhispers2 está caminhando para suportar compilação NASM (para gcc/mingw), enquanto esta versão é especificamente projetada e testada para suportar MSVC (porque o [Inceptor][1] permanecerá uma estrutura apenas para Windows num futuro próximo).
• SysWhispers3 contém funcionalidades parcialmente implementadas (como egg-hunting) que não faria sentido incluir na versão original da ferramenta.

Diferenças em relação ao SysWhispers2

O uso é bastante semelhante ao SysWhispers2, com as seguintes exceções:

• Também suporta x86/WoW64
• Suporta substituição de instruções syscall por um EGG (a ser substituído dinamicamente)
• Suporta saltos diretos para syscalls no modo x86/x64 (no WOW64 é quase padrão)
• Suporta saltos diretos para syscalls aleatórias (emprestando a ideia de @ElephantSeal)

Uma explicação melhor dessas funcionalidades está melhor descrita no post do blog [SysWhispers está morto, vida longa ao SysWhispers!][2]

Introdução

Produtos de segurança, como AVs e EDRs, geralmente colocam hooks em funções da API em modo de usuário para analisar o fluxo de execução de um programa, a fim de detectar atividades potencialmente maliciosas.

SysWhispers2 é uma ferramenta projetada para gerar pares de cabeçalho/ASM para qualquer chamada de sistema na imagem do kernel principal (ntoskrnl.exe), que podem então ser integrados e chamados diretamente de código C/C++, evadindo hooks no espaço do usuário.

A ferramenta, no entanto, gera alguns padrões que podem ser incluídos em assinaturas, ou comportamentos que podem ser detectados em tempo de execução.

SysWhispers3 é construído sobre o SysWhispers2 e integra alguns recursos úteis para contornar essas formas de detecção.

Instalação

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

Uso e Exemplos

A ajuda mostra todos os comandos e funcionalidades disponíveis da ferramenta:

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)

Linhas de Comando

SysWhispers padrão, chamadas de sistema embutidas (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

Amostras exclusivas do 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

Saída do 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...

Importando para o Visual Studio

1. Copie os arquivos H/C/ASM gerados para a pasta do projeto.
2. No Visual Studio, vá em Projeto → Personalizações de Compilação... e habilite MASM.
3. No Gerenciador de Soluções, adicione os arquivos .h e .c/.asm ao projeto como arquivos de cabeçalho e fonte, respectivamente.
4. Vá para as propriedades do arquivo ASM e defina o Tipo de Item como Microsoft Macro Assembler.

Compilando fora do Visual Studio

Windows

Makefile para 64 bits:

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 para 32 bits:

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

Compile com nmake:

nmake -f Makefile.msvc

Linux

Makefile para 64 e 32 bits:

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)

Compile com make:

make -f Makefile.mingw

Advertências e Limitações