BOF_RunPE

BOF RunPE es un archivo de objeto Beacon (BOF) para Cobalt Strike que ejecuta archivos PE completamente en memoria dentro del proceso del beacon. A diferencia del tradicional fork&run, no se crea ningún proceso hijo, no se crea ninguna consola y no se utiliza ninguna tubería (pipe); toda la salida se captura mediante el hooking de la IAT y se redirige a la consola del beacon.

Arquitectura: solo x64

Descripción general

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

Características principales

• Sin creación de procesos: el PE se ejecuta dentro del proceso del beacon
• Sin consola/tubería: salida capturada mediante hooks de printf/WriteConsole
• Múltiples métodos de asignación: Heap, VirtualAlloc, Module Stomping
• Carga mediante proxy: Timer Queue, RegisterWait o llamadas directas
• Ntdll Unhooking: copia nueva opcional desde el disco
• RWX : opcional asignar memoria en RWX
• Thread Start Spoofing: dirección de inicio legítima con secuestro de RIP (RIP hijacking)

Opciones de configuración

El comportamiento del BOF se puede editar en Additionals postex -> RunPe Config

Métodos de proxy

Método	Descripción
None	Llamadas directas a la API
Draugr	Llamadas a la API con la pila falsificada (stack spoofing)
Regwait	Devolución de llamada (callback) de RegisterWaitForSingleObject
Timer	Devolución de llamada de Timer Queue

Métodos de asignación

Método	Descripción
Heap	Heap privado mediante RtlCreateHeap con Draugr
VirtualAlloc	NtAllocateVirtualMemory con Draugr
Module stomping	Sobrescribe la sección .text de una DLL legítima

Opciones generales

Opción	Descripción
AllocRWX	Asignar como RWX (frente a la transición RW→RX)
UnhookNtdll	Reemplazar la sección .text de ntdll.dll con una copia nueva del disco
Timeout	Tiempo de espera de ejecución en milisegundos (0 = infinito)
StompModule	Ruta de la DLL para module stomping (p. ej., chakra.dll)

Spoofing de hilos

Opción	Descripción
ModuleName	Módulo legítimo para la dirección de inicio (p. ej., Kernel32.dll)
ProcedureName	Nombre de la función dentro del módulo (p. ej., BaseThreadInitThunk)
Offset	Desplazamiento desde el inicio de la función

Captura de salida

Toda la salida del PE se redirige a la consola del beacon mediante hooks de la IAT. No se crea ninguna ventana de consola ni tubería con nombre (named pipe).

Función enganchada	Destino
GetCommandLineA/W	Devuelve argumentos falsificados
__getmainargs / __wgetmainargs	Inicialización de argumentos CRT
printf / wprintf	Redirección a BeaconPrintf
WriteConsoleA/W	Redirección a BeaconPrintf
__stdio_common_vfprintf	Funciones de impresión UCRT
ExitProcess / exit	Convertido en ExitThread

Técnicas de evasión

Técnica	Bypass
Syscalls indirectos	Hooks de API en modo usuario (EDR/AV)
Draugr Stack Spoofing	Inspección de la pila de llamadas
Thread Start Spoofing	Análisis de la dirección de inicio del hilo
Module Stomping	Detección de memoria sin respaldo (unbacked)
Private Heap Allocation	Monitorización de VirtualAlloc
Ntdll Unhooking	Sobrescribir la ntdll en memoria con la ntdll del disco
IAT Hooking (sin tuberías)	Monitorización de tuberías con nombre (named pipes)

Vectores de detección

Telemetría del kernel (ETW-TI)

NtGetContextThread / NtSetContextThread:

• Manipulación del contexto de hilos suspendidos y posterior reanudación

Operaciones de memoria:

• Asignación de NtAllocateMemory, puede ser en RWX (depende de la configuración)
• Transiciones de NtProtectVirtualMemory (RW → RX)
• La memoria ejecutable en regiones del heap es sospechosa (depende de la configuración)
• Module stomping detectable mediante discrepancia de hash de sección (depende de la configuración)

Indicadores de comportamiento

• Hilo suspendido creado, se toma el contexto y luego se cambia el valor de RIP
• Memoria del heap marcada como ejecutable (si el asignador de memoria es heap)
• DLL cargada con DONT_RESOLVE_DLL_REFERENCES (si el asignador de memoria es module stomping)
• Sección .text de ntdll modificada (si el unhooking está habilitado)

Uso

Carga del script

Cobalt Strike → Script Manager → Load → BOF_RunPe.cna

Comandos de Aggressor

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

beacon> help runpe

Compilación

Requiere GCC 13 (mingw-w64). Utilice el Dockerfile proporcionado:

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

Salida: Bin/runpe.o

Limitaciones

Limitación	Descripción
CET	La tecnología Control-flow Enforcement Technology puede bloquear los marcos de pila sintéticos
Solo x64	Sin soporte para x86/WoW64
Visibilidad del kernel	La creación de hilos es visible para las devoluciones de llamada del kernel
.NET	No se admiten ejecutables administrados

Créditos / Recursos utilizados para el desarrollo

Repos / entradas 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/