| \ / / | | | _ __ | || _ \ ___ _ __ _ | | | | \ / | | | | | | ' | | | | |/ _ | ' | | | | | | | / \ || || |__| | | | || || | () | | | | || | | |_____//__|||| ||_|____/ _/|| ||_,|__| por @JoeLeonJr (@FortyNorthSec)

EXCELntDonut é um gerador de macros XLM (Excel 4.0). Comece com código-fonte C# (EXE) e termine com uma macro XLM (Excel 4.0) que executará seu código na memória. Macros XLM (Excel 4.0) podem ser salvas em arquivos .XLS.

Instalação

chmod +x install.sh
./install.sh

O que é instalado?

pip3
mono-complete (tanto mcs quanto todas as bibliotecas possíveis que você referenciaria em seus arquivos fonte)
EXCELntDonut como uma CLI

Se você quiser executar o EXCELntDonut apenas como um script Python, precisará configurar um ambiente virtual com os dois pacotes "pandas" e "donut-shellcode". Além disso, você precisará instalar o mono-complete via apt-get e chamar o script drive.py usando python3. Recomendamos apenas usar o script bash ./install.sh, mas fica a seu critério.

Uso

Uso:
	$ EXCELntDonut -f exe_source.cs -r System.Windows.Forms.dll --sandbox --obfuscate

Flags:
	(obrigatório)
	-f caminho para o arquivo contendo seu código-fonte C# (apenas exe)

	-r Referências necessárias para compilar seu código C# (as mesmas usadas ao compilar com mcs no Linux)
	(ex: -r 'System.Management')

	(opcional)
	-o nome do arquivo de saída
	--sandbox 
		Realiza verificações básicas de sandbox. Isso será atualizado conforme novas abordagens forem descobertas.
	--obfuscate 
		Realiza ofuscação básica da macro.

Como funciona

Você fornece um arquivo C# contendo seu payload (como um EXE com um método main que executa um payload de beacon Cobalt Strike). Esse arquivo C# é compilado usando MCS em dois assemblies .NET: x86 e x64. Após a compilação, as ferramentas incríveis Donut (para x86) e CLRvoyance (para x64) convertem cada assembly em shellcode independente de posição. Em seguida, todos os nullbytes são removidos, já que macros XLM (Excel 4.0) não lidam bem com nullbytes, e o payload é dividido em linhas com no máximo 255 caracteres (para x86) ou 10 caracteres (para x64).

Assim que o shellcode é preparado, ele é combinado com funções básicas de injeção de processo (VirtualAlloc, WriteProcessMemory e CreateThread), bem como uma função de verificação de arquitetura para determinar qual payload (x86 ou x64) executar no sistema alvo. Se você optar por executar verificações de sandbox ou ofuscação básica, essas funções atualizarão sua macro. Finalmente, a saída é colocada em um arquivo CSV (salvo como .txt).

Como criar uma macro XLM (Excel 4.0)

Depois de obter o arquivo de saída do EXCELntDonut, abra o arquivo de saída em um editor de texto e copie todo o conteúdo (Ctrl-A, Ctrl-C). Abra o Excel em uma VM Windows, clique com o botão direito em "Planilha1" e selecione "Inserir". Escolha "Macro MS Excel 4.0". Vá para a célula A1 e cole a saída do EXCELntDonut. Provavelmente todos os dados serão colados em uma coluna. Os dados são separados por ponto e vírgula ";". Vá para a guia "Dados" e clique em "Texto para colunas". Selecione "Delimitado" e na próxima tela selecione "Ponto e vírgula" e clique em "Concluir". A macro se espalhará pelas colunas e linhas apropriadas.

(Nota - se você selecionou a flag "--obfuscate", precisará rolar horizontalmente um pouco para encontrar seu código real, pois parte da lógica de ofuscação move a macro para uma seção aleatória da planilha).

Recomendamos duas coisas neste ponto:

Encontre a célula inicial (será a célula superior esquerda do código da macro, provavelmente A1). Clique com o botão direito e selecione "Executar". Teste sua macro para garantir que funcione.
Depois de verificar que a macro funciona, selecione novamente a mesma célula superior esquerda. No lado esquerdo da tela, deve haver um menu suspenso que mostra a célula em que você está (provavelmente "A1"). Clique no menu suspenso e altere o valor do texto para "Auto_open". Isso produzirá a mesma funcionalidade de execução automática que você está acostumado em macros VBA.

Salve o arquivo (.xls) e tente abri-lo. Ele deve executar automaticamente seu payload.

Verificações de Sandbox

Essas verificações são baseadas no que agentes de ameaças reais estão usando em seus malwares.

Há um mouse ativo?
O tamanho da tela é maior que 770 de largura e 381 de altura?
O host pode reproduzir sons?
Isso é uma máquina Windows?

Ofuscação

Para as instruções de injeção de processo (VirtualAlloc, WriteProcessMemory, CreateThread) e verificações de sandbox, todas as funções da macro se transformarão na seguinte estrutura:

=FORMULA(D3&D23&D54&D23&D44,E45)

A função FORMULA nos permite colocar uma fórmula, que pode ser executada posteriormente, em outra célula. Então, neste caso, colocamos as instruções de injeção de processo e depois usamos a função FORMULA para colocar a função real em outra célula para ser executada. Isso evita que defensores que realizam análise estática vejam coisas como "VirtualAlloc".

A macro inteira deslocará algum valor para a direita, de modo que, ao abrir inicialmente a planilha com as macros, ela pareça em branco.

Coisas para saber

Payloads menos sofisticados usam apenas o comando =EXEC() para executar comandos. Alguns também usam URLMON para baixar arquivos. Outros arquivos incluem até a palavra "SHELL". Tudo isso pareceu uma má ideia para nós. Esta ferramenta não inclui nada disso. Em vez disso, ela injeta seu código-fonte C# no processo do Excel (seja 32 bits ou 64 bits) e depois executa. A partir daí, cabe ao seu payload decidir o que fazer em seguida.

Dicas

Seu código-fonte C# pode fazer o que você quiser. Recomendamos que seu código-fonte quebre a relação Pai > Filho entre o Excel e o que você gerar.
Existem muitos posts bons de blog sobre planilhas "Muito ocultas" do Excel. Considere usar isso.
Não se esqueça de fazer seu arquivo Excel parecer real.

Solução de Problemas

"O tipo ou namespace ... não existe ... "

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    por @JoeLeonJr (@FortyNorthSec)                
[i] Gerando seu assembly .NET x86.
warning CS8001: O caminho do SDK não pôde ser resolvido
test.cs(2,14): error CS0234: O tipo ou namespace `Management' não existe no namespace `System'. Você está faltando uma referência de assembly?

Esse erro provavelmente significa que você está faltando uma referência de assembly durante a compilação usando mono. Para corrigir, basta passar o namespace mencionado na flag -r. Neste caso, adicionaríamos -r 'System.Management' à linha de comando. O novo comando seria:

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs -r 'System.Management'

"Arquivo de metadados ... não pôde ser encontrado"

root@excelntdonut-test:/opt# EXCELntDonut -f test.cs -r System.Management
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    por @JoeLeonJr (@FortyNorthSec)                
[i] Gerando seu assembly .NET x86.
warning CS8001: O caminho do SDK não pôde ser resolvido
error CS0006: O arquivo de metadados `System.Management' não pôde ser encontrado

[x] Erro ao gerar o assembly .NET x86 usando MCS. Veja a mensagem de erro acima.

Esse erro não deve aparecer a menos que você execute o EXCELntDonut sem usar o script bash install.sh. Nesse caso, você precisará instalar manualmente o mono-complete. Isso baixará as dependências relevantes. Você pode instalá-lo usando apt assim:

apt-get install mono-complete

"Programa ... não contém um método 'Main' estático ..."

root@kali:~/Desktop# EXCELntDonut -f test.cs
 _______  ______ _____ _           _   ____                    _   
| ____\ \/ / ___| ____| |    _ __ | |_|  _ \  ___  _ __  _   _| |_ 
|  _|  \  / |   |  _| | |   | '_ \| __| | | |/ _ \| '_ \| | | | __|
| |___ /  \ |___| |___| |___| | | | |_| |_| | (_) | | | | |_| | |_ 
|_____/_/\_\____|_____|_____|_| |_|\__|____/ \___/|_| |_|\__,_|\__|
                    por @JoeLeonJr (@FortyNorthSec)                
[i] Gerando seu assembly .NET x86.
error CS5001: O programa `_excelntdonut_GJAoNuVPMcX.exe' não contém um método `Main' estático adequado para um ponto de entrada

[x] Erro ao gerar o assembly .NET x86 usando MCS. Veja a mensagem de erro acima.

No momento, o EXCELntDonut permite apenas arquivos C# com payloads na função Main.

Conselhos Gerais de Solução de Problemas

Primeiro, compile seu código-fonte C# usando csc no Windows e execute para verificar se o payload funciona. Teste compilando para payloads x86 e x64, já que é provável que você não saiba se o ambiente alvo opera Excel 32 bits ou 64 bits.
Você deve ser capaz de executar seu payload várias vezes no mesmo processo, mas se estiver obtendo erros estranhos, feche o Excel, reabra e tente novamente.
Na dúvida, feche o Excel e crie um novo arquivo para testar.

Detecção

Aqui estão algumas regras Yara para começar, por @InQuest:

Procure por uma planilha muito oculta

https://github.com/InQuest/yara-rules/blob/master/Excel_Hidden_Macro_Sheet.rule

Procure pela string Auto_Open

https://github.com/Neo23x0/signature-base/blob/master/yara/general_officemacros.yar

Há muitos posts sobre o uso de OLEDUMP.py para revisar arquivos XLM. Considere este:

https://clickallthethings.wordpress.com/2020/04/06/covid-19-excel-4-0-macros-and-sandbox-detection/

Defesa

Habilite o bloqueio de GPO para execução de macros em arquivos baixados da internet. Veja - https://www.microsoft.com/security/blog/2016/03/22/new-feature-in-office-2016-can-block-macros-and-help-prevent-infection/
Infelizmente, o AMSI não ajuda aqui.
Regras ASR... não temos certeza.
A maioria dos usuários envia arquivos .xlsx atualmente. Talvez bloqueie arquivos .xls de serem enviados para as caixas de entrada dos seus funcionários. Não seria absurdo pedir que alguém reenvie um arquivo salvo como .xlsx.
A versão mais recente do Defender ATP detectou a versão não ofuscada deste arquivo quando foi gravada em disco.

Agradecimentos

Isso nem estaria em nosso radar sem o fantástico trabalho feito pela equipe da Outflank (@outflanknl). Agradecimentos especiais a @StanHacked por sua visão durante este projeto. Além disso, igualmente, este projeto não seria possível sem o Donut (por @TheWover e @odzhan) e a biblioteca python relacionada (por @byt3bl33d3r). Relacionado, a equipe da Accenture criou o CLRvoyance, que resolveu alguns problemas x64 que não conseguíamos resolver com Donut + macros XLM 4.0. Finalmente, agradecimentos a Philip Tsukerman, da Cybereason, pela pesquisa incrível sobre como tornar macros XLM compatíveis com versões de 64 bits do Excel.

Aviso Legal

Não somos responsáveis pelo uso indevido desta ferramenta. Esta ferramenta foi criada para fins educacionais e de teste autorizado, para demonstrar como o código-fonte C# pode ser injetado na memória usando uma macro XLM (Excel 4.0). O objetivo final deste projeto é (1) fornecer aos red teamers mais uma opção de payload de phishing para emular o que os adversários reais estão usando atualmente, e (2) fornecer aos defensores um ponto de referência para construir análises e mitigações. Sem uma ferramenta para gerar rapidamente esse tipo de payload, acreditamos que os defensores não estarão adequadamente preparados para o que realmente está por vir. Por favor, aja com responsabilidade.

Licença

Consulte o arquivo de licença nesta pasta. Observe que esta ferramenta incorpora duas outras ferramentas de código aberto, incluindo Donut e CLRvoyance.

EXCELntDonut

Mais Populares