análise-de-comportamento-de-malware-com-cuckoo-sandbox

Analisando o Comportamento de Malware com Cuckoo Sandbox

Quando Usar

• Uma amostra suspeita passou pela triagem de análise estática e requer observação comportamental em um ambiente controlado
• Você precisa capturar tráfego de rede, arquivos criados, modificações no registro e chamadas de API da execução do malware
• Determinar a cadeia completa de infecção, incluindo downloads de payloads de segundo estágio e mecanismos de persistência
• Gerar assinaturas comportamentais e regras YARA com base na atividade de tempo de execução observada
• Análise automatizada de amostras de malware em massa que requerem relatórios consistentes

Não use quando a amostra for uma variante de ransomware conhecida que pode se espalhar por compartilhamentos de rede em um sandbox mal configurado; verifique o isolamento de rede primeiro.

Pré-requisitos

• Cuckoo Sandbox 3.x instalado em um servidor de análise dedicado (Ubuntu 22.04 recomendado)
• VMs convidadas configuradas com snapshots do Windows 10/11 (agente Cuckoo instalado, snapshots tirados em estado limpo)
• VirtualBox, KVM ou VMware configurado como backend de virtualização do Cuckoo
• Rede isolada com InetSim ou FakeNet-NG para simular serviços de internet
• Suricata ou Snort integrados para correspondência de assinaturas em nível de rede durante a análise
• Espaço em disco suficiente para capturas PCAP e despejos de memória (mínimo de 500 GB recomendado)

Fluxo de Trabalho

Passo 1: Enviar Amostra para o Cuckoo

Envie a amostra de malware para análise automatizada:

# Envio via linha de comando
cuckoo submit /caminho/para/suspeito.exe

# Envio com tempo limite específico de análise (300 segundos)
cuckoo submit --timeout 300 /caminho/para/suspeito.exe

# Envio com VM específica e pacote de análise
cuckoo submit --machine win10_x64 --package exe --timeout 300 /caminho/para/suspeito.exe

# Envio via API REST
curl -F "[email protected]" -F "timeout=300" -F "machine=win10_x64" \
  http://localhost:8090/tasks/create/file

# Envio de URL para análise
curl -F "url=http://site-malicioso.com/payload" -F "timeout=300" \
  http://localhost:8090/tasks/create/url

# Verificar status da tarefa
curl http://localhost:8090/tasks/view/1 | jq '.task.status'

Passo 2: Monitorar a Execução em Tempo Real

Acompanhe o progresso da análise e observe o comportamento ao vivo:

# Assistir ao log de análise do Cuckoo
tail -f /opt/cuckoo/log/cuckoo.log

# Monitorar status da tarefa de análise
cuckoo status

# Acessar a interface web do Cuckoo para capturas de tela ao vivo e árvore de processos
# Navegue para http://localhost:8080/analysis/<task_id>/

Eventos comportamentais chave para observar durante a execução:

• Cadeia de criação de processos (relações pai-filho)
• Tentativas de conexão de rede para IPs externos
• Arquivos criados em diretórios temporários ou de sistema
• Modificações no registro em chaves Run ou entradas de serviço
• Chamadas de API relacionadas a criptografia (CryptEncrypt), injeção (WriteProcessMemory) ou evasão

Passo 3: Analisar a Atividade de Processos

Revise a árvore de processos e o rastro de chamadas de API do relatório Cuckoo:

# Analisar o relatório JSON do Cuckoo programaticamente
import json

with open("/opt/cuckoo/storage/analyses/1/reports/report.json") as f:
    report = json.load(f)

# Análise da árvore de processos
for process in report["behavior"]["processes"]:
    pid = process["pid"]
    ppid = process["ppid"]
    name = process["process_name"]
    print(f"PID: {pid} PPID: {ppid} Nome: {name}")

    # Extrair chamadas de API suspeitas
    for call in process["calls"]:
        api = call["api"]
        if api in ["CreateRemoteThread", "VirtualAllocEx", "WriteProcessMemory",
                    "NtCreateThreadEx", "RegSetValueExA", "URLDownloadToFileA"]:
            args = {arg["name"]: arg["value"] for arg in call["arguments"]}
            print(f"  [!] {api}({args})")

Passo 4: Revisar a Atividade de Rede

Examine conexões de rede, consultas DNS e requisições HTTP:

# Análise de rede a partir do relatório Cuckoo
network = report["network"]

# Resoluções DNS
print("Consultas DNS:")
for dns in network.get("dns", []):
    print(f"  {dns['request']} -> {dns.get('answers', [])}")

# Requisições HTTP
print("\nRequisições HTTP:")
for http in network.get("http", []):
    print(f"  {http['method']} {http['uri']} (Host: {http['host']})")
    if http.get("body"):
        print(f"    Corpo: {http['body'][:200]}")

# Conexões TCP
print("\nConexões TCP:")
for tcp in network.get("tcp", []):
    print(f"  {tcp['src']}:{tcp['sport']} -> {tcp['dst']}:{tcp['dport']}")

# Extrair PCAP para análise mais aprofundada com Wireshark
# Localização do PCAP: /opt/cuckoo/storage/analyses/1/dump.pcap

Passo 5: Examinar Alterações no Sistema de Arquivos e Registro

Documente mecanismos de persistência e arquivos criados:

# Operações de arquivo
print("Arquivos Criados/Modificados:")
for f in report["behavior"].get("summary", {}).get("files", []):
    print(f"  {f}")

# Arquivos criados com hashes
print("\nArquivos Criados:")
for dropped in report.get("dropped", []):
    print(f"  Caminho: {dropped['filepath']}")
    print(f"  SHA-256: {dropped['sha256']}")
    print(f"  Tamanho: {dropped['size']} bytes")
    print(f"  Tipo: {dropped['type']}")

# Modificações no registro
print("\nChaves de Registro Modificadas:")
for key in report["behavior"].get("summary", {}).get("keys", []):
    print(f"  {key}")

Passo 6: Revisar Assinaturas e Pontuação

Verifique as assinaturas comportamentais e a pontuação de ameaça do Cuckoo:

# Assinaturas comportamentais acionadas
print("Assinaturas Acionadas:")
for sig in report.get("signatures", []):
    severity = sig["severity"]
    name = sig["name"]
    description = sig["description"]
    marker = "[!]" if severity >= 3 else "[*]"
    print(f"  {marker} [{severity}/5] {name}: {description}")
    for mark in sig.get("marks", []):
        if mark.get("call"):
            print(f"      API: {mark['call']['api']}")
        if mark.get("ioc"):
            print(f"      IOC: {mark['ioc']}")

# Pontuação geral
score = report.get("info", {}).get("score", 0)
print(f"\nPontuação Geral de Ameaça: {score}/10")

Passo 7: Extrair Artefatos do Despejo de Memória

Analise o despejo de memória completo capturado durante a execução:

# O despejo de memória é salvo em:
# /opt/cuckoo/storage/analyses/1/memory.dmp

# Use o Volatility para analisar o despejo de memória
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.pslist
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.malfind
vol3 -f /opt/cuckoo/storage/analyses/1/memory.dmp windows.netscan

Conceitos Chave

Termo	Definição
Análise Dinâmica	Executar malware em um ambiente controlado para observar o comportamento em tempo de execução, incluindo chamadas de sistema, atividade de rede e operações de arquivo
Evasão de Sandbox	Técnicas que o malware usa para detectar ambientes virtuais/sandbox e alterar o comportamento para evitar análise (temporizadores de espera, verificações de VM, verificações de interação do usuário)
API Hooking	Método do Cuckoo de interceptar chamadas de API do Windows feitas pelo malware para registrar nomes de funções, parâmetros e valores de retorno
InetSim	Ferramenta de simulação de serviços de internet que responde a requisições de rede do malware (HTTP, DNS, SMTP) dentro da rede de análise isolada
Injeção de Processo	Técnica de malware de injetar código em processos legítimos; detectada monitorando sequências de API VirtualAllocEx e WriteProcessMemory
Assinatura Comportamental	Detecção baseada em regras que corresponde a sequências específicas de chamadas de API, operações de arquivo ou atividade de rede a comportamentos conhecidos de malware
Pacote de Análise	Módulo do Cuckoo que define como executar um tipo de arquivo específico (exe, dll, pdf, doc) dentro da VM convidada para captura comportamental adequada

Ferramentas e Sistemas

• Cuckoo Sandbox: Sistema automatizado de análise de malware de código aberto que fornece relatórios comportamentais, capturas de rede e despejos de memória
• InetSim: Suíte de simulação de serviços de internet que fornece serviços falsos de HTTP, DNS, SMTP e outros para redes de análise de malware isoladas
• FakeNet-NG: Ferramenta de simulação de rede da equipe FLARE que intercepta e redireciona todo o tráfego de rede para análise
• Suricata: IDS/IPS de rede integrado ao Cuckoo para detecção em tempo real baseada em assinaturas de tráfego de rede malicioso
• Volatility: Framework de análise forense de memória usado para analisar despejos de memória capturados durante a análise do Cuckoo

Cenários Comuns

Cenário: Analisando um Dropper Multi-Estágio

Contexto: A análise estática revela um executável empacotado com poucas importações e alta entropia. A amostra precisa de execução em sandbox para observar o desempacotamento, entrega de payload e estabelecimento de C2.

Abordagem:

1. Enviar amostra para o Cuckoo com tempo limite estendido (600 segundos) para capturar comportamento lento
2. Revisar a árvore de processos para criação de processos filhos (dropper gerando processos de payload)
3. Identificar arquivos criados em %TEMP%, %APPDATA% ou diretórios do sistema
4. Extrair os arquivos criados e calcular hashes para análise separada
5. Mapear conexões de rede para identificar a infraestrutura C2 contatada após a execução inicial
6. Verificar mecanismos de persistência (chaves Run, tarefas agendadas, serviços) nas modificações do registro
7. Comparar assinaturas comportamentais com famílias de malware conhecidas

Armadilhas:

• Usar tempo limite de análise insuficiente, fazendo com que o sandbox termine antes da execução do payload de segundo estágio
• Não configurar o InetSim para responder a requisições DNS e HTTP, impedindo que o malware progrida após o check-in com o C2
• Ignorar detecções de evasão de sandbox; se a amostra sair imediatamente, pode estar detectando o ambiente virtual
• Não analisar os arquivos criados separadamente; o dropper inicial pode ser menos interessante que o payload final

Formato de Saída

RELATÓRIO DE ANÁLISE DINÂMICA - CUCKOO SANDBOX
==========================================
ID da Tarefa:      1547
Amostra:           suspeito.exe (SHA-256: e3b0c44298fc1c149afbf4c8996fb924...)
Tempo de Análise:  300 segundos
VM:                win10_x64 (Windows 10 21H2)
Pontuação:         8.5/10

ÁRVORE DE PROCESSOS
suspeito.exe (PID: 2184)
  └── cmd.exe (PID: 3456)
      └── powershell.exe (PID: 4012)
          └── svchost_fake.exe (PID: 4568)

ATIVIDADE DO SISTEMA DE ARQUIVOS
[CRIADO]  C:\Users\Admin\AppData\Local\Temp\payload.dll
[CRIADO]  C:\Windows\System32\svchost_fake.exe
[MODIFICADO] C:\Windows\System32\drivers\etc\hosts

MODIFICAÇÕES NO REGISTRO
[DEFINIDO] HKCU\Software\Microsoft\Windows\CurrentVersion\Run\WindowsUpdate = "C:\Windows\System32\svchost_fake.exe"
[DEFINIDO] HKLM\SYSTEM\CurrentControlSet\Services\FakeService\ImagePath = "C:\Windows\System32\svchost_fake.exe"

ATIVIDADE DE REDE
DNS:    update.malicious[.]com -> 185.220.101.42
HTTP:   POST hxxps://185.220.101[.]42/gate.php (beacon)
TCP:    10.0.2.15:49152 -> 185.220.101.42:443 (237 conexões)

ASSINATURAS COMPORTAMENTAIS
[!] [4/5] injection_createremotethread: Injeta código em processo remoto
[!] [4/5] persistence_autorun: Modifica chave de registro Run para persistência
[!] [3/5] network_cnc_http: Realiza comunicação HTTP com C2
[*] [2/5] antiav_detectfile: Verifica a presença de arquivos de produtos antivírus

ARQUIVOS CRIADOS
payload.dll    SHA-256: abc123... Tamanho: 98304  Tipo: PE32 DLL
svchost_fake.exe SHA-256: def456... Tamanho: 184320 Tipo: PE32 EXE