michaelweber/macromeLeitor/Gravador de Documentos de Macro do Excel para Red Teamers e Analistas
Um Leitor/Escritor de Documentos de Macro do Excel para Red Teamers e Analistas. Postagens de blog que descrevem o que esta ferramenta realmente faz podem ser encontradas aqui e aqui.
Clone ou baixe este repositório; a ferramenta pode ser executada usando dotnet - por exemplo:
dotnet run -- build --decoy-document Docs\decoy_document.xls --payload Docs\popcalc.bin
ou
dotnet build
cd bin/Debug/netcoreapp2.0
dotnet Macrome.dll deobfuscate --path obfuscated_document.xls
Observe que é necessária uma compilação 5.0+ do dotnet para que isso funcione conforme configurado - pode ser obtida em https://dotnet.microsoft.com/download/dotnet/5.0.
Versões binárias da ferramenta que não requerem dotnet e contêm um binário executável podem ser encontradas na seção de Releases para Windows, OSX e Linux.
Execute o Macrome usando dotnet run a partir do diretório da solução, ou dotnet contra o binário Macrome compilado. Existem três modos de operação para o Macrome - modo Build, modo Dump e modo Deobfuscação.
Execute o Macrome com o comando build para gerar um documento Excel contendo uma planilha de macro ofuscada usando um documento isca e payload de macro fornecidos. dotnet Macrome.dll build -h exibirá instruções completas de uso.
Por exemplo, para construir um documento usando o documento isca caminho/para/decoy_document.xls e shellcode x86 binário armazenado em caminho/para/shellcode.bin, execute dotnet Macrome.dll build --decoy-document caminho/para/decoy_document.xls --payload /caminho/para/shellcode.bin. Isso gerará um documento XLS 2003 que, após ser aberto e ter o botão "Habilitar Conteúdo" pressionado, executará o shellcode de shellcode.bin.
O restante da documentação explicará cada flag/função em detalhes, mas agora o "mais recente e melhor" que o Macrome tem a oferecer pode ser obtido executando:
Macrome build --decoy-document decoy_document.xls --payload beacon.bin --payload64-bit beacon64.bin --payload-method Base64 --method ArgumentSubroutines --password VelvetSweatshop --preamble preamble.txt --output-file-name ReadyToPhish.xls
Primeiro, gere um documento Excel "isca" base que conterá o conteúdo que os usuários devem ver. Isso deve ser algum tipo de chamariz que convença os usuários a clicar no botão "Habilitar Macros" exibido no Excel. Existem alguns exemplos de criação de chamariz do "mais recente e melhor" em https://inquest.net/blog/2020/05/06/ZLoader-4.0-Macrosheets-. Uma vez criada esta planilha, salve o documento como tipo Excel 97-2003 Workbook (*.xls) em vez do formato mais recente Excel Workbook (*.xlsx). Um exemplo de documento isca está incluído em /Docs/decoy_document.xls. Observe que se você estiver usando ofuscação XOR para proteger seu documento, atualmente NÃO é possível adicionar uma imagem ao seu documento isca.
Em seguida, gere um payload de shellcode para fornecer à ferramenta. O payload binário de exemplo (que abre a calculadora) foi gerado usando msfvenom com os seguintes parâmetros:
msfvenom -a x86 -b '\x00' --platform windows -p windows/exec cmd=calc.exe -e x86/alpha_mixed -f raw EXITFUNC=thread > popcalc.bin
Payloads de 64 bits também são suportados. O payload de 64 bits de exemplo, popcalc64.bin, foi gerado usando o comando:
msfvenom -a x64 -b '\x00' --platform windows -p windows/x64/exec cmd=calc.exe -e x64/xor -f raw EXITFUNC=thread > popcalc64.bin
Este payload pode então ser embutido executando o comando:
dotnet Macrome.dll build --decoy-document decoy_document.xls --payload popcalc.bin --payload64-bit popcalc64.bin
Atualmente, payloads de 64 bits exigirão que um payload x86 também seja fornecido. Se isso não for um problema, você pode especificar qualquer lixo para a flag de payload x86.
Há suporte eventual para embutir assemblies .NET diretamente no documento, mas se você quiser fazer isso agora, sugiro usar EXCELntDonut.
A partir do Macrome 0.5.0 e superior, todos os payloads serão codificados com base64, então seu payload poderá conter qualquer sequência de bytes (incluindo bytes nulos).
Se você quiser embutir um executável .NET usando Macrome, sugiro usar Donut com o comando donut.exe -a 3 -b 1 -z 1 executableToEmbed.exe, e então embutir o payload resultante como seus payloads de 32 e 64 bits.
Outra alternativa sólida é o Amber, que funcionou muito bem para embutir binários Go bastante grandes.
Se por algum motivo você quiser usar o modo de codificação de payload legado do pré-Macrome 0.5.0, use a flag --payload-method com SheetPackingMethod. Observe que no modo legado, usar um payload majoritariamente alfanumérico reduzirá o tamanho do arquivo de macro gerado, pois é mais fácil expressar letras e números na forma de macro do que anexar invocações repetidas da função CHAR como =CHAR(123)&CHAR(124)&CHAR(125)... etc. Mas a ferramenta deve ser capaz de lidar também com um payload binário completamente não imprimível.
Semelhante ao uso de payload binário, um documento isca deve ser gerado primeiro. Em seguida, deve ser criado um arquivo de texto contendo as macros a serem executadas. As macros devem ter colunas separadas por caracteres ; e linhas separadas por quebras de linha. Atualmente, o conteúdo das macros especificadas será escrito e executado a partir de A1 - embora suporte futuro seja adicionado para permitir especificar a localização inicial. Exemplos de macros podem ser encontrados em /Docs/macro_example.txt e /Docs/multi_column_macro_example.txt.
Finalmente, execute o comando:
dotnet Macrome.dll build --decoy-document decoy_document.xls --payload macro-example.txt --payload-type Macro
Observe o uso da flag payload-type definida como Macro.
Você pode gerar uma macro você mesmo, ou usar a maravilhosa ferramenta EXCELntDonut para criar uma macro para você.
Isso será detalhado em uma próxima postagem de blog, mas o Macrome agora pode codificar payloads de macro de três maneiras diferentes. A maioria delas ainda não é detectada por nenhum AV - mas experimente com seus payloads para ver o que funciona melhor.
IF e SET.NAME. Isso é algo que ainda não foi abusado por autores proeminentes de maldocs, então é improvável que dispare no AV por enquanto.ROUND.Especifique uma codificação usando a flag method ao construir - por exemplo, para usar o codificador CharSubroutine:
dotnet Macrome.dll b --decoy-document decoy_document.xls --method CharSubroutine --payload popcalc.bin --output-file-name CharSubroutine-Macro.xls
Às vezes, você pode querer que certas macros sejam executadas ANTES do código do payload. Isso é útil quando você está adicionando macros para evasão de sandbox e/ou verificando se seu payload está sendo executado no host correto.
O formato para arquivos de preâmbulo é exatamente o mesmo que ao usar payload-type Macro, mas suporta apenas uma única coluna. Por exemplo, você poderia ter um preâmbulo como:
=IF(GET.WORKSPACE(13)<770, CLOSE(FALSE),)
=IF(GET.WORKSPACE(14)<390, CLOSE(FALSE),)
=IF(GET.WORKSPACE(19),,CLOSE(FALSE))
=IF(GET.WORKSPACE(42),,CLOSE(FALSE))
Isso verificaria valores de resolução de tela, a presença de um mouse e a capacidade de reproduzir som. Se algum desses falhasse, o aplicativo fecharia antes de executar o conteúdo principal do payload.
Além disso, se você quiser que uma macro de preâmbulo seja avaliada IMEDIATAMENTE, em vez de após desempacotar o restante das macros, você pode prefixar um comando com %%%%%. Por exemplo:
%%%%%=IF(GET.WORKSPACE(13)<770, HALT(),)
%%%%%=IF(GET.WORKSPACE(14)<390, HALT(),)
%%%%%=IF(GET.WORKSPACE(19),,HALT())
%%%%%=IF(GET.WORKSPACE(42),,HALT())
Isso é útil para minimizar o número de comandos XLM executados antes de eliminar o documento e pode ser útil para reações mais imediatas à presença de indicadores de sandbox.
Macrome 0.3.0+ suporta proteção por senha de documentos usando ofuscação XOR, um modo de criptografia legado de versões MUITO mais antigas do Office. Esse modo de criptografia geralmente não é suportado por ferramentas de IR e pode ajudar a proteger o conteúdo do documento contra inspeção.
O Excel tem uma senha 'padrão' de VelvetSweatshop, que permitirá criptografar o conteúdo do documento enquanto ainda faz com que o documento seja descriptografado automaticamente ao ser aberto. Essa é a maneira 'ideal' de usar ofuscação XOR em um contexto ofensivo. O Macrome tentará automaticamente usar esta senha ao desofuscar ou despejar um documento.
Para usar esta funcionalidade, basta adicionar --password <senhaParaCriptografar> ao seu comando de construção.
Execute o Macrome com o comando dump para exibir os registros BIFF8 mais relevantes de documentos arbitrários. Essa funcionalidade é semelhante à funcionalidade de despejo de macro do olevba, mas possui um processamento mais completo de entradas Ptg de casos extremos para ajudar a garantir que o formato seja o mais próximo possível das entradas reais de FORMULA do Excel. É isso que venho usando para depurar alguns documentos estranhos de casos extremos que gerei enquanto criava esta ferramenta, por isso é comparativamente robusto. Tenho certeza de que existem muitos casos extremos que ainda não são suportados, portanto, se você encontrar um documento cujo conteúdo não seja despejado corretamente, abra uma issue e compartilhe o documento como um arquivo zip.
O comando dump requer apenas um argumento path apontando para o arquivo alvo. Um exemplo de invocação é:
dotnet Macrome.dll dump --path docToDump.xls
A maioria das flags do comando dump são para depuração, mas a flag dump-hex-bytes pode ser útil para usuários que desejam ver os payloads de bytes individuais de registros relevantes. Isso é semelhante à funcionalidade do BiffView, embora apenas entradas específicas de maldocs sejam exibidas por padrão.
Execute o Macrome com o comando deobfuscate para receber um documento binário XLS ofuscado e tentar reverter vários comportamentos anti-análise. dotnet Macrome.dll deobfuscate -h exibirá instruções completas de uso. Atualmente, por padrão, este modo irá:
Lbl que o Excel interpretará como entradas Auto_Open, apesar de seus nomes não corresponderem a essa string.Por exemplo, para desofuscar um arquivo de macro XLS 2003 malicioso em caminho/para/obfuscated_file.xls, execute dotnet Macrome.dll deobfuscate --path caminho/para/obfuscated_file.xls. Isso gerará uma cópia do arquivo ofuscado que será mais fácil de analisar manualmente ou com ferramentas.
NOTA: Isso ainda não faz muito, serve principalmente para demonstrar como o uso da biblioteca b2xtranslator modificada pode ajudar a automatizar a desofuscação. Mais recursos úteis estão por vir.
Muitos agradecimentos a todos os ombros sobre os quais pude me apoiar para escrever isso.
b2xtranslator, bem como o pessoal da EvolutionJobs que a atualizou e portou para dotnet. O código usado aqui foi inicialmente obtido de https://github.com/EvolutionJobs/b2xtranslator.