BOF_RunPE

BOF RunPE est un fichier Beacon Object pour Cobalt Strike qui exécute des fichiers PE entièrement en mémoire dans le processus du beacon. Contrairement au fork&run traditionnel, aucun processus enfant n'est créé, aucune console n'est ouverte et aucun tube n'est utilisé – toute la sortie est capturée via un hooking IAT et redirigée vers la console du beacon.

Architecture : x64 uniquement

Aperçu

┌──────────────────────────────────────────────────────────────┐
│                   Cobalt Strike Beacon                       │
│                    (Current Process)                         │
└────────────────────────┬─────────────────────────────────────┘
                         │
                         │  beacon_inline_execute()
                         │
                         ▼
┌──────────────────────────────────────────────────────────────┐
│                    BOF RunPE                                 │
│  ┌────────────────────────────────────────────────────────┐  │
│  │  VxTable + Draugr Initialization                       │  │
│  │  (Syscall Resolution + Stack Spoofing)                 │  │
│  └──────────────────────┬─────────────────────────────────┘  │
│                         │                                    │
│  ┌──────────────────────▼─────────────────────────────────┐  │
│  │  PE Mapping                                            │  │
│  │  - Section Copy    - IAT Patching (with hooks)         │  │
│  │  - Relocations     - Memory Protection                 │  │
│  └──────────────────────┬─────────────────────────────────┘  │
│                         │                                    │
│  ┌──────────────────────▼─────────────────────────────────┐  │
│  │  Thread Execution                                      │  │
│  │  - Spoofed Start Address                               │  │
│  │  - RIP Hijacking to Entry Point                        │  │
│  │  - Output Redirection via Hooks                        │  │
│  └────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────┘

Principales fonctionnalités

• Aucune création de processus : le PE s'exécute dans le processus du beacon
• Aucune console/tube : la sortie est capturée via des hooks printf/WriteConsole
• Plusieurs méthodes d'allocation : Heap, VirtualAlloc, Module Stomping
• Chargement par proxy : Timer Queue, RegisterWait, ou appels directs
• Déhooking de Ntdll : copie fraîche facultative depuis le disque
• RWX : allocation mémoire facultative en RWX
• Usurpation du démarrage de thread : adresse de départ légitime avec détournement de RIP

Options de configuration

Le comportement du BOF peut être modifié dans Additionals postex -> RunPe Config

Méthodes de proxy

Méthode	Description
None	Appels API directs
Draugr	Appels API avec spoofing de pile
Regwait	Callback RegisterWaitForSingleObject
Timer	Callback Timer Queue

Méthodes d'allocation

Méthode	Description
Heap	Tas privé via RtlCreateHeap avec Draugr
VirtualAlloc	NtAllocateVirtualMemory avec Draugr
Module stomping	Écrase la section .text d'une DLL légitime

Options générales

Option	Description
AllocRWX	Allouer en RWX (vs transition RW→RX)
UnhookNtdll	Remplacer la section .text de ntdll.dll par une copie fraîche du disque
Timeout	Délai d'exécution en millisecondes (0 = infini)
StompModule	Chemin de la DLL pour le module stomping (ex. chakra.dll)

Usurpation de thread

Option	Description
ModuleName	Module légitime pour l'adresse de départ (ex. Kernel32.dll)
ProcedureName	Nom de la fonction dans le module (ex. BaseThreadInitThunk)
Offset	Décalage depuis le début de la fonction

Capture de sortie

Toute la sortie du PE est redirigée vers la console du beacon via des hooks IAT. Aucune fenêtre de console ni tube nommé n'est créé.

Fonction hookée	Cible
GetCommandLineA/W	Retourne des arguments usurpés
__getmainargs / __wgetmainargs	Initialisation des arguments CRT
printf / wprintf	Redirection vers BeaconPrintf
WriteConsoleA/W	Redirection vers BeaconPrintf
__stdio_common_vfprintf	Fonctions d'impression UCRT
ExitProcess / exit	Converti en ExitThread

Techniques d'évasion

Technique	Contourne
Syscalls indirects	Hooks API en espace utilisateur (EDR/AV)
Draugr Stack Spoofing	Inspection de la pile d'appels
Usurpation du démarrage de thread	Analyse de l'adresse de début de thread
Module Stomping	Détection de mémoire sans sauvegarde
Allocation en tas privé	Surveillance de VirtualAlloc
Déhooking de Ntdll	Écriture de ntdll du disque sur celui en mémoire
Hooking IAT (sans tubes)	Surveillance des tubes nommés

Vecteurs de détection

Télémétrie du noyau (ETW-TI)

NtGetContextThread / NtSetContextThread :

• Manipulation du contexte d'un thread suspendu puis reprise

Opérations mémoire :

• Allocation NtAllocateMemory, possible en RWX (selon configuration)
• Transitions NtProtectVirtualMemory (RW → RX)
• Mémoire exécutable dans des régions de tas est suspecte (selon configuration)
• Module stomping détectable par désaccord de hachage de section (selon configuration)

Indicateurs comportementaux

• Création d'un thread suspendu, récupération du contexte puis modification de la valeur de RIP
• Mémoire du tas marquée comme exécutable (si l'allocateur est le tas)
• DLL chargée avec DONT_RESOLVE_DLL_REFERENCES (si l'allocateur est le module stomping)
• Section .text de Ntdll modifiée (si le déhooking est activé)

Utilisation

Chargement du script

Cobalt Strike → Script Manager → Load → BOF_RunPe.cna

Commandes Aggressor

beacon> runpe /chemin/vers/binaire.exe --arg1 valeur1

beacon> help runpe

Compilation

Nécessite GCC 13 (mingw-w64). Utiliser le Dockerfile fourni :

sudo docker build -t ubuntu-gcc-13 .
sudo docker run --rm -it -v "$PWD":/work -w /work ubuntu-gcc-13:latest make

Sortie : Bin/runpe.o

Limitations

Limitation	Description
CET	La technologie Control-flow Enforcement peut bloquer les trames de pile synthétiques
x64 Only	Pas de support x86/WoW64
Kernel Visibility	La création de threads est visible par les callbacks du noyau
.NET	Les exécutables managés ne sont pas supportés

Crédits / Ressources utilisées pour le développement

Dépôts/articles de blog

• https://github.com/susMdT/LoudSunRun
• https://github.com/Octoberfest7/Inline-Execute-PE
• https://www.coresecurity.com/core-labs/articles/running-pes-inline-without-console
• https://0xdarkvortex.dev/proxying-dll-loads-for-hiding-etwti-stack-tracing/

Livres

• Windows Native API Programming par Pavel Yosifovich
• Windows Internals, Part 1 par Pavel Yosifovich
• Windows Internals, Part 2 par Andrea Allievi