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étodos de asignación

Opciones generales

Spoofing de hilos

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).

Técnicas de evasión

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

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/

Libros

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