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

Métodos de Alocação

Opções Gerais

Spoofing de Thread

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.

Técnicas de Evasão

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

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