Inline-Execute-PE

AVISO:

Este projeto é complexo e a falha em compreender como funciona e testá-lo adequadamente pode resultar em Beacons quebrados e perda de acesso!

Recomendo fortemente que leia toda a documentação até a secção "Considerações de Design e Comentários"!

Introdução

Inline-Execute-PE é um conjunto de Beacon Object Files (BOFs) e um script Aggressor para CobaltStrike que permite aos Operadores carregar executáveis Windows não gerenciados na memória do Beacon e executá-los, recuperando a saída e exibindo-a no console do Beacon.

Isso permite que os Operadores utilizem muitas ferramentas de terceiros (Mimikatz, Dsquery, ferramentas Sysinternals, etc.) sem precisar gravá-las em disco, reformatá-las para código independente de posição usando uma ferramenta como Donut, ou criar um novo processo para executá-las.

Esses executáveis são mapeados na memória do Beacon para que possam ser executados repetidamente sem precisar enviá-los pela rede, alocar nova memória e criar um novo processo conhost.exe a cada vez.

Os executáveis carregados nos Beacons são acessíveis e podem ser executados por todos os Clientes CobaltStrike conectados ao Servidor de Equipe CobaltStrike.

O Inline-Execute-PE foi projetado para Beacons x64 e executáveis Windows x64 em C ou C++ compilados com Mingw ou Visual Studio. Este projeto não suporta executáveis x86 ou executáveis x64 escritos em outra linguagem ou compilados com outro compilador.

Configuração

Clone o repositório e opcionalmente execute make para recompilar os BOFs.

Carregue o Inline-Execute-PE.cna no cliente CobaltStrike. Certifique-se de que o diretório de onde o CobaltStrike está sendo executado seja gravável pelo seu utilizador; o Inline-Execute-PE cria um ficheiro de texto lá (petable.txt) para garantir a disponibilidade dos dados necessários para o funcionamento do Inline-Execute-PE.

Comandos

O Inline-Execute-PE compreende 3 comandos voltados para o alvo que executam BOFs e 3 comandos internos que manipulam a estrutura de dados do projeto:

Voltados para o alvo:

1. peload
2. perun
3. peunload

Estrutura de dados interna:

1. petable
2. peconfig
3. pebroadcast

peload

peload é o início do Inline-Execute-PE. Este comando é utilizado para carregar um PE na memória do Beacon. Ele realiza as seguintes ações principais:

1. Envia o PE especificado pela rede para o Beacon OU envia o nome do PE a ser lido do disco na máquina alvo
2. Cria uma estrutura na memória do Beacon para armazenar vários ponteiros e handles necessários ao Inline-Execute-PE ao longo do seu ciclo de vida
3. Aloca memória no Beacon e escreve o PE nela com proteção RW
4. Criptografa XOR o PE na memória usando uma chave especificada pelo utilizador
5. Aloca outro bloco de memória e copia o PE criptografado XOR para ele. Isso é necessário para poder "reverter" o PE para execuções subsequentes
6. Gera um processo filho conhost.exe sob o Beacon para inicializar stdin/stdout/stderr
7. Redireciona stdout e stderr para um pipe anónimo para que a saída do PE possa ser capturada

perun

perun é o segundo passo no Inline-Execute-PE. Ele realiza as seguintes ações principais:

1. Envia argumentos de linha de comando pela rede para o Beacon
2. Descriptografa XOR o PE na memória
3. Corrige a Tabela de Endereços de Importação do PE, fazendo hook em certas APIs relacionadas a argumentos de linha de comando e saída de processos
4. Altera a proteção de memória do PE para RWX
5. Executa o PE em sua própria thread
6. Captura a saída do PE e a retorna para o CobaltStrike
7. Reverte a proteção de memória do PE para RW
8. Sobrescreve o PE na memória com a cópia criptografada XOR feita durante o peload

peunload

peunload é chamado para remover o PE da memória do Beacon quando um Operador terminar com ele ou desejar carregar um PE diferente. Ele realiza as seguintes ações principais:

1. Fecha handles e ponteiros de ficheiro criados durante o peload
2. Termina o processo conhost.exe criado durante o peload
3. Zera e depois libera ambas as cópias do PE na memória
4. Tenta descarregar quaisquer DLLs carregadas pelo PE no processo Beacon (opcional)

petable

petable é usado para exibir informações sobre todos os PEs atualmente carregados nos Beacons.

Cada Cliente CobaltStrike tem seu próprio petable; o Inline-Execute-PE se esforça ao máximo para garantir a sincronicidade dos seus dados entre todos os Clientes CobaltStrike conectados, para que os PEs possam ser usados por todos os Operadores. Para mais informações, veja "Considerações de Design e Comentários".

peconfig

peconfig é usado para configurar opções relacionadas ao funcionamento do Inline-Execute-PE. As duas opções atuais que podem ser alteradas são:

1. Timeout. Isto determina quanto tempo o perun aguardará pela conclusão da execução do PE antes de terminá-lo. Existe como uma salvaguarda no caso de argumentos incorretos serem fornecidos a um PE que façam com que ele nunca retorne/termine a execução. Esta configuração é de 60 segundos por padrão, mas pode ser modificada para acomodar PEs de execução mais longa.
2. UnloadLibraries. Esta opção controla se o peunload tentará libertar DLLs do processo Beacon que foram carregadas pelo PE. Por padrão, está definido como TRUE. Alguns PEs causam problemas quando as DLLs são descarregadas do processo Beacon e podem fazer com que o Beacon falhe; nesse caso, é melhor deixar todas as DLLs carregadas pelo PE no processo Beacon. Isso foi observado ao usar powershell.exe (talvez por carregar o CLR .NET no processo Beacon).

pebroadcast

pebroadcast pode ser usado para transmitir manualmente o conteúdo do petable de um Cliente para todos os outros Clientes CobaltStrike conectados.

Cada outro Cliente CobaltStrike atualizará seu petable com os dados transmitidos. Isso nunca deve ser realmente necessário, mas a funcionalidade existe apenas por precaução.

Utilização

Use peload para carregar um PE na memória do Beacon

Alternativamente, se houver um PE na máquina alvo que deseje usar sem criar um novo processo, forneça o caminho e a opção --local

Chame perun, passando quaisquer argumentos para o PE carregado

Aspas duplas em argumentos devem ser escapadas com barras invertidas

Se identificou que um PE causa problemas ao tentar libertar DLLs durante o descarregamento, use peconfig para definir unloadlibraries como falso

Depois de terminar de usar um PE, chame peunload para limpá-lo do Beacon

Agora, um PE diferente pode ser carregado no Beacon