BOF_RunPE

BOF RunPE é um Beacon Object File para o Cobalt Strike que executa arquivos PE inteiramente em memória dentro do processo do beacon. Diferentemente do tradicional fork&run, nenhum processo filho é criado, nenhum console é criado e nenhum pipe é usado - toda a saída é capturada via hooking de IAT e redirecionada para o console do beacon.

Arquitetura: apenas x64

Visão Geral

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

Recursos Principais

• Sem Criação de Processo: O PE executa dentro do processo do beacon
• Sem Console/Pipe: Saída capturada via hooks de printf/WriteConsole
• Múltiplos Métodos de Alocação: Heap, VirtualAlloc, Module Stomping
• Carregamento por Proxy: Timer Queue, RegisterWait ou chamadas diretas
• Unhooking do Ntdll: Cópia nova opcional do disco
• RWX : Opcionalmente alocar memória em RWX
• Spoofing de Início de Thread: Endereço inicial legítimo com sequestro de RIP

Opções de Configuração

O comportamento do BOF pode ser editado em Additionals postex -> RunPe Config

Métodos de Proxy

Method	Description
None	Chamadas diretas de API
Draugr	Chamadas de API com stack spoofing
Regwait	Callback de RegisterWaitForSingleObject
Timer	Callback de Timer Queue

Métodos de Alocação

Method	Description
Heap	Heap privado via RtlCreateHeap com Draugr
VirtualAlloc	NtAllocateVirtualMemory com Draugr
Module stomping	Sobrescreve a seção .text de uma DLL legítima

Opções Gerais

Option	Description
AllocRWX	Alocar como RWX (vs transição RW→RX)
UnhookNtdll	Substituir a seção .text da ntdll.dll por uma cópia nova do disco
Timeout	Tempo limite de execução em milissegundos (0 = infinito)
StompModule	Caminho da DLL para module stomping (ex.: chakra.dll)

Spoofing de Thread

Option	Description
ModuleName	Módulo legítimo para o endereço inicial (ex.: Kernel32.dll)
ProcedureName	Nome da função dentro do módulo (ex.: BaseThreadInitThunk)
Offset	Offset a partir do início da função

Captura de Saída

Toda a saída do PE é redirecionada para o console do beacon via hooks de IAT. Nenhuma janela de console ou pipe nomeado é criada.

Hooked Function	Target
GetCommandLineA/W	Retorna argumentos falsificados
__getmainargs / __wgetmainargs	Inicialização de argumentos do CRT
printf / wprintf	Redirecionamento para BeaconPrintf
WriteConsoleA/W	Redirecionamento para BeaconPrintf
__stdio_common_vfprintf	Funções de impressão da UCRT
ExitProcess / exit	Convertido em ExitThread

Técnicas de Evasão

Technique	Bypasses
Syscalls Indiretos	Hooks de API em userland (EDR/AV)
Stack Spoofing do Draugr	Inspeção da pilha de chamadas (call stack)
Spoofing de Início de Thread	Análise do endereço inicial da thread
Module Stomping	Detecção de memória não mapeada (unbacked)
Alocação de Heap Privado	Monitoramento de VirtualAlloc
Unhooking do Ntdll	Substitui a ntdll em memória pela ntdll do disco
Hook de IAT (sem pipes)	Monitoramento de pipes nomeados

Vetores de Detecção

Telemetria do Kernel (ETW-TI)

NtGetContextThread / NtSetContextThread:

• Manipulação do contexto da thread em threads suspensas e, em seguida, retomada

Operações de Memória:

• Alocação de NtAllocateMemory, pode ser em RWX (depende da configuração)
• Transições de NtProtectVirtualMemory (RW → RX)
• Memória executável em regiões de heap é suspeita (depende da configuração)
• Module stomping detectável via incompatibilidade de hash da seção (depende da configuração)

Indicadores Comportamentais

• Thread suspensa criada, obter o contexto e alterar o valor do RIP
• Memória do heap marcada como executável (se o alocador de memória for heap)
• DLL carregada com DONT_RESOLVE_DLL_REFERENCES (se o alocador de memória for module stomping)
• Seção .text da Ntdll modificada (se o unhooking estiver habilitado)

Uso

Carregando o Script

Cobalt Strike → Script Manager → Load → BOF_RunPe.cna

Comandos do Aggressor

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

beacon> help runpe

Compilação

Requer GCC 13 (mingw-w64). Use o Dockerfile fornecido:

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

Saída: Bin/runpe.o

Limitações

Limitation	Description
CET	A Control-flow Enforcement Technology pode bloquear stack frames sintéticos
Apenas x64	Sem suporte a x86/WoW64
Visibilidade do Kernel	Criação de threads visível para callbacks do kernel
.NET	Executáveis gerenciados não suportados

Créditos / Recursos usados no desenvolvimento

Repositórios/blogposts

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

Livros

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