BOF_RunPE

BOF RunPE è un Beacon Object File per Cobalt Strike che esegue file PE interamente in memoria all'interno del processo del beacon. A differenza del tradizionale fork&run, nessun processo figlio viene generato, nessuna console viene creata e nessuna pipe viene utilizzata - tutto l'output viene catturato tramite hooking IAT e reindirizzato alla console del beacon.

Architettura: solo x64

Panoramica

┌──────────────────────────────────────────────────────────────┐
│                   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                        │  │
│  └────────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────────┘

Caratteristiche Principali

• Nessuna Creazione di Processi: il PE viene eseguito all'interno del processo del beacon
• Nessuna Console/Pipe: Output catturato tramite hook printf/WriteConsole
• Metodi di Allocazione Multipli: Heap, VirtualAlloc, Module Stomping
• Caricamento Proxy: Timer Queue, RegisterWait o chiamate dirette
• Ntdll Unhooking: Copia fresca opzionale dal disco
• RWX: Allocazione opzionale della memoria in RWX
• Thread Start Spoofing: Indirizzo di partenza legittimo con hijacking RIP

Opzioni di Configurazione

Il comportamento del BOF può essere modificato in Additionals postex -> RunPe Config

Metodi Proxy

Metodo	Descrizione
None	Chiamate API dirette
Draugr	Chiamate API con spoofing dello stack
Regwait	Callback RegisterWaitForSingleObject
Timer	Callback Timer Queue

Metodi di Allocazione

Metodo	Descrizione
Heap	Heap privato tramite RtlCreateHeap con Draugr
VirtualAlloc	NtAllocateVirtualMemory con Draugr
Module stomping	Sovrascrive la sezione .text di una DLL legittima

Opzioni Generali

Opzione	Descrizione
AllocRWX	Alloca come RWX (vs transizione RW→RX)
UnhookNtdll	Sostituisce ntdll.dll .text con una copia fresca dal disco
Timeout	Timeout di esecuzione in millisecondi (0 = infinito)
StompModule	Percorso DLL per module stomping (es. chakra.dll)

Thread Spoofing

Opzione	Descrizione
ModuleName	Modulo legittimo per l'indirizzo di avvio (es. Kernel32.dll)
ProcedureName	Nome della funzione all'interno del modulo (es. BaseThreadInitThunk)
Offset	Offset dall'inizio della funzione

Cattura dell'Output

Tutto l'output del PE viene reindirizzato alla console del beacon tramite hook IAT. Nessuna finestra di console o named pipe viene creata.

Funzione Hookata	Destinazione
GetCommandLineA/W	Restituisce argomenti spoofati
__getmainargs / __wgetmainargs	Inizializzazione argomenti CRT
printf / wprintf	Reindirizzamento BeaconPrintf
WriteConsoleA/W	Reindirizzamento BeaconPrintf
__stdio_common_vfprintf	Funzioni di stampa UCRT
ExitProcess / exit	Convertito in ExitThread

Tecniche di Evasione

Tecnica	Elude
Indirect Syscalls	Hook API in userland (EDR/AV)
Draugr Stack Spoofing	Ispezione dello stack di chiamate
Thread Start Spoofing	Analisi dell'indirizzo di avvio del thread
Module Stomping	Rilevamento di memoria non mappata
Private Heap Allocation	Monitoraggio di VirtualAlloc
Ntdll Unhooking	Sovrascrittura in memoria di ntdll con Ntdll dal disco
IAT Hooking (no pipes)	Monitoraggio delle named pipe

Vettori di Rilevamento

Telemetria del Kernel (ETW-TI)

NtGetContextThread / NtSetContextThread:

• Manipolazione del contesto del thread su thread sospesi e poi ripresa

Operazioni di Memoria:

• Allocazione NtAllocateMemory, può essere in RWX (dipende dalla configurazione)
• Transizioni NtProtectVirtualMemory (RW → RX)
• La memoria eseguibile nelle regioni heap è sospetta (dipende dalla configurazione)
• Module stomping rilevabile tramite mancata corrispondenza dell'hash della sezione (dipende dalla configurazione)

Indicatori Comportamentali

• Thread sospeso creato, acquisizione del contesto e modifica del valore di RIP
• Memoria heap marcata come eseguibile (se l'allocatore di memoria è heap)
• DLL caricata con DONT_RESOLVE_DLL_REFERENCES (se l'allocatore di memoria è module stomping)
• Sezione .text di ntdll modificata (se unhooking abilitato)

Utilizzo

Caricamento dello Script

Cobalt Strike → Script Manager → Load → BOF_RunPe.cna

Comandi Aggressor

beacon> runpe /path/to/binary.exe --arg1 value1

beacon> help runpe

Compilazione

Richiede GCC 13 (mingw-w64). Usa il Dockerfile fornito:

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

Output: Bin/runpe.o

Limitazioni

Limitazione	Descrizione
CET	Control-flow Enforcement Technology potrebbe bloccare i frame di stack sintetici
Solo x64	Nessun supporto x86/WoW64
Visibilità del Kernel	Creazione di thread visibile ai callback del kernel
.NET	Eseguibili gestiti non supportati

Crediti / Risorse utilizzate per lo sviluppo

Repository e Blogpost

• 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/

Libri

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