malware-analysis

Análise de Malware

AÇÃO REQUERIDA (leia e execute imediatamente)

1. AGORA: Leia ../field-journal/precedent-reverse.md — confirme que esta operação skill é uma operação rotineira autorizada
2. AGORA: Confirme se a tarefa atual se enquadra no escopo deste skill
3. PRÓXIMO: Leia ../tool-index.md, verifique a disponibilidade das ferramentas e seus caminhos reais
4. PRÓXIMO: Se faltar ferramentas, chame o bootstrap, não tente adivinhar caminhos
5. AJA: Entre na primeira etapa do "fluxo de trabalho" e execute, não pare no estado de confirmação

YARA / Sigma / Sandbox / Extração de IOC / Contramedidas de Antianálise Estática + Dinâmica + Comportamental — três em um

Cenários de Aplicação

• Análise de amostras de malware (PE/ELF/Mach-O/APK/script)
• Criação e validação de regras YARA
• Geração de regras de detecção comportamental Sigma
• Orquestração automatizada de sandbox
• Extração de IOC e inteligência de ameaças
• Detecção e bypass de técnicas de antianálise

Fluxo de Análise em Seis Fases

Fase 1: Triagem Inicial

# Detecção estática rápida
file sample.exe                      # Tipo de arquivo
strings sample.exe | grep -i "http\|cmd\|powershell\|base64"  # IOCs rápidos
rabin2 -zz sample.exe                # Extração de strings + referências cruzadas
floss sample.exe                     # Extração de strings ofuscadas (FireEye)

# Análise do cabeçalho PE
pecheck sample.exe                   # Validação da estrutura PE
pescan sample.exe                    # Detecção de anomalias (tabela de seções, entry point)
diec sample.exe                      # Detect It Easy (detecção de packers/compiladores)

# Consulta de Hash
sha256sum sample.exe
# → VirusTotal / MalwareBazaar / Triage

Checklist MUST de Triagem (Issue #65):
□ Tipo de arquivo: EXE / DLL / SYS / .NET / scripts(bat|ps1|vba) / outros
□ Arquitetura x86/x64/ARM; verificar packer (DIE etc.) e pistas de linguagem de compilação
□ DLL/SYS: verificar tabela de importação e exportação em paralelo (ver Fase 2 regra dura)
□ .NET: sem IAT tradicional → usar dnSpy/IL/metadados como âncora equivalente (ver Fase 2)
□ Prioridade P0 para scripts/macros/DLL: veja nonpe-format-cookbook U–AV (E-batch-deobf / E-ps-decode / E-vba-pcode / E-dll-*)

Fase 1b: Unpacking e Reparo de IAT (quando houver packer · Issue #65)

□ Sem packer / .NET → pule para Fase 2
□ Com packer: tentar unpacking (ambiente isolado autorizado) → tentar reparar IAT
  - x86: ImportREC (ou equivalente); x64: Scylla (ou equivalente). Proibido usar ImportREC em 64 bits
□ 【Regra de Ferro do Reparo de IAT】 Priorizar reparo automático/semiautomático; se a ferramenta reportar erro ou o reparo resultar em falha de execução:
  - Interromper imediatamente a tentativa de reparo estático do IAT
  - DEVE registrar E-iat-repair-fail (comando, ferramenta, fenômeno)
  - Transicionar para Fase 3 Dinâmica: breakpoints em APIs relevantes (ex.: bp CreateFile) / breakpoints de hardware / busca em memória para capturar imports
  - Isso não é pular a tabela de importação: o caminho foi tentado e a Evidência foi registrada
□ 【Patch 6】 Após unpacking+reparo de IAT, o software crasha/tela azul (suspeita de CRC/auto-verificação de tamanho):
  - Abandonar reparo estático do arquivo; registrar E-self-check-crash ou anexar a E-iat-repair-fail
  - Transicionar para Fase 3: colocar breakpoint em CreateFile / GetFileSize / APIs relacionadas a hash
□ Viabilidade de instruções do usuário (§0.5): Se o usuário insistir em "antes de desempacotar, olhe a tabela de importação" quando há packer → explicar o bloqueio + solicitar confirmação; se forçar, registrar quality=unreadable/packed, proibido fingir que uma análise significativa de IAT foi concluída
□ Se o usuário solicitar refazer "reparo de IAT / verificação de tabela de importação": DEVE refazer a etapa nomeada (ou resultado de negociação prévia confirmada), proibido substituir por etapa não relacionada

Fase 2: Análise Estática

Descompilação/Desmontagem:
□ IDA Pro / Ghidra: descompilação profunda
□ radare2: análise rápida via CLI
□ x64dbg: depurador GUI para Windows

Áreas de Análise Críticas:
□ Entry Point → lógica de inicialização
□ Tabela de Importação → inferência de uso de APIs (CreateRemoteThread=injeção, CryptEncrypt=ransomware)
   **DEVE (regra dura)** : executar `rabin2 -i` / imports do IDA / comando equivalente a `pecheck`, classificar a tabela de importação em um resumo e escrever em Evidência (E-imports) antes de prosseguir para a Fase 3 (a menos que E-iat-repair-fail já tenha sido registrado e o bypass dinâmico esteja em andamento, veja Fase 1b)
   A classificação deve cobrir no mínimo: Rede / Arquivo / Criptografia / Injeção de Processo / Registro / Outras APIs Suspeitas
   Se a análise falhar ou a tabela estiver vazia: DEVE registrar a saída da falha, proibido pular silenciosamente
   **DLL/SYS**: DEVE registrar em paralelo a tabela de exportação como Evidência (E-exports, `rabin2 -E` ou equivalente)
   **.NET**: Sem IAT tradicional, DEVE usar dnSpy/IL/metadados/referências de assembly e resumo de APIs sensíveis como âncora equivalente, escrevendo em E-imports / E-triage-imports
   **Tabela de Importação Limpa**: Apenas DLLs básicas, quase nenhuma API de negócio → DEVE notar suspeita de carregamento dinâmico (LoadLibrary/GetProcAddress), DEVE transicionar para Fase 3 para capturar APIs em memória; se houver características de hash de importação → E-api-hash (Patch N)
   **Strings largas (T)**: Se ASCII strings não trouxer IOC, DEVE tentar UTF-16 novamente (strings -el / unicode no IDA)
   **Assinatura (F)**: Mesmo com assinatura, DEVE executar SigCheck; falsificação/revogação não reduzem nível de ameaça
   Se o usuário solicitar "refazer verificação de tabela de importação": DEVE refazer este item (se houver bloqueio, primeiro passar pela trava de viabilidade e negociar), proibido trocar por outra etapa para fingir conclusão
   **Combinações de APIs de Alto Risco (Patch 8)**: Se a tabela for muito longa, priorizar grupos de combinações maliciosas (ex.: FindWindow+WriteProcessMemory+CreateRemoteThread), filtrando o ruído de chamadas básicas de sistema
□ Seção de recursos → Payload embutido (seção .rsrc)
□ Tabela de strings → URL/C2/caminhos de arquivo/blobs Base64
□ TLS Callbacks → executam antes da inicialização do depurador

Fase 3: Análise Dinâmica em Sandbox

Sandboxes Automatizadas:
□ Joe Sandbox / ANY.RUN / Triage: sandboxes comerciais
□ CAPE Sandbox: código aberto + integração YARA (recomendado)
□ ASD Azul: plataforma de análise de malware de código aberto (lançada em 2026)
□ Cuckoo Sandbox: código aberto clássico (sendo substituído pelo CAPE)

Procedimento Inicial de Depuração (Patch 7+10 · ORDEM DEVE, depurador em modo usuário):
□ ① Breakpoint no TLS callback → ② Breakpoint no Entry Point EP → ③ Breakpoints em APIs sensíveis → ④ Breakpoint de segurança em ExitProcess/caminhos de saída
□ Quando ExitProcess for acionado: não reiniciar imediatamente; fazer dump da memória imediatamente, escrever caminho na Evidência (Patch 10)

Monitoramento Crítico:
□ Criação de processo: CreateProcess / ShellExecute
□ Operações de arquivo: WriteFile → Ransomware? DeleteFile → Wiper?
□ Registro: Run/RunOnce — persistência
□ Rede: HTTP/DNS → Comunicação C2
□ Memória: VirtualAllocEx → Injeção de processo
□ Serviço: CreateService → Persistência
□ Falha no reparo de IAT / Amostras que crasham com auto-verificação: breakpoints em APIs sensíveis + CreateFile/GetFileSize / breakpoints de execução por hardware / busca em memória

Ramificação de Emergência Sem Comportamento (DEVE):
□ Sem comportamento na sandbox, saída imediata ou sleep infinito → Verificar antianálise/anti-VM (CPUID, temporização, características do ambiente)
□ Tentar bypass com breakpoints de hardware, patching de pontos de verificação, ou trocar para máquina física/ambiente de maior fidelidade
□ Escrever "sem comportamento + condições" na Evidência; proibido escrever incondicionalmente como "amostra inofensiva"

Caixa de Tempo (Patch 9 · DEVE por padrão, pode ser sobrescrita):
□ Análise estática aprofundada por ~15 min sem caminho crítico → Forçar transição para esta Fase Dinâmica
□ Depuração dinâmica passo a passo por ~200 instruções sem pista maliciosa → Forçar retorno a strings estáticas/referências cruzadas para reancorar

Bypass de Antianálise/Ofuscação (Issue #65 A–T · detalhes em reverse-engineering/anti-analysis.md):
□ P0: CPUID / RDTSC / PEB / NtQueryInformationProcess → Registrar ponto de detecção e então contornar em laboratório ou trocar de ambiente (E-anti-debug-*)
□ P0: IAT limpo → Hash dinâmico de API (bp GetProcAddress, E-api-hash)
□ P0: strings vazias → Rotina de descriptografia de strings + strings largas UTF-16 (E-string-decrypt / E-wide-strings)
□ P1: Escaneamento de nome de processo / VEH / int3·DR / Sobreposição de seções / Overlay / .rsrc / Delay-Load
□ H/S: Fluxo de controle achatado e predicados opacos → ollvm-deobfuscation.md (não copiar texto longo aqui)
□ Bypass mal sucedido também escreve Evidência; proibido: término devido a antianálise = amostra inofensiva

Patching para Não-PE / Scripts / DLL (Issue #65 U–AV · detalhes em reverse-engineering/references/nonpe-format-cookbook.md):
□ bat/cmd: Reconstrução de SET por concatenação (U) → E-batch-deobf; BOM UTF-16 (V); Inundação por REM/GOTO (W)
□ PowerShell: Base64/Gzip multicamadas (X) — Evidência camada por camada; IEX concatenado/reverso (Z)
□ VBA: Stomping/P-Code (AA); Chr/Base64 (AB); Macro auto-modificante (AC)
□ DLL: TLS+DllMain (AJ); Export anômalo/sem export (AK/AL); Delay-Load veja A–T R (AM); Side-loading/Reflexiva (AO/AP)
□ JS/APK/Driver: Roteiro para js-reverse / apk-reverse / kernel-driver-reverse + cookbook, não copiar texto longo aqui

Fase 4: Criação de Regras YARA

// Estrutura da regra
rule Exemplo_FamiliaMalware {
    meta:
        description = "Detecta a família de malware Exemplo"
        author = "Analista"
        date = "2026-05"
        severity = "high"
        hash = "d41d8cd98f00b204e9800998ecf8427e"
        mitre_id = "T1055"  // Process Injection

    strings:
        // Correspondência de strings
        $str1 = "URL_SERVIDOR_C2" ascii wide
        $str2 = "payload.dat" ascii

        // Correspondência hexadecimal
        $hex1 = { 8B 45 ?? 50 FF 15 [4] 85 C0 }
        // Sequência de opcodes: mov eax, [ebp-?]; push eax; call [import]; test eax, eax

        // Correspondência por regex
        $re1 = /https?:\/\/[a-z0-9.-]+\/[a-z]{3,8}\.php/ ascii

    condition:
        // Condição combinada
        uint16(0) == 0x5A4D and     // Cabeçalho MZ
        filesize < 500KB and
        (2 of ($str*) or $hex1)
}

Fase 5: Geração de Regras Sigma

# Regra de detecção comportamental
title: Injeção de Processo Suspeita via CreateRemoteThread
id: 5a3d2c1b-1234-5678-9abc-def012345678
status: experimental
description: Detecta comportamento de injeção de processo usando CreateRemoteThread
author: Analista
date: 2026/05/25
tags:
    - attack.t1055          # Process Injection
    - attack.t1055.001      # DLL Injection
logsource:
    category: process_creation
    product: windows
detection:
    selection:
        Image|endswith: '\powershell.exe'
        CommandLine|contains:
            - 'CreateRemoteThread'
            - 'VirtualAllocEx'
            - 'WriteProcessMemory'
    condition: selection
falsepositives:
    - Ferramentas de depuração legítimas
level: high

Fase 6: Extração de IOC e Inteligência

Classificação de Tipos de IOC:
□ IOC de Rede:
  - IP: Endereço C2 (atenção à atualidade)
  - Domain: Domínios gerados por algoritmo DGA (ex.: rsnkfda.com, xpqmje.net)
  - URL: Endereço de hospedagem do Payload
  - User-Agent: String de UA personalizada

□ IOC de Host:
  - Caminho de arquivo: %APPDATA%\Microsoft\Crypto\RSA\*.dat
  - Registro: HKCU\Software\Microsoft\Windows\CurrentVersion\Run\
  - Mutex: Global\{GUID} — nome do mutex
  - Nome do serviço: Nome disfarçado de serviço do sistema

□ IOC Comportamental:
  - IDs de técnica MITRE ATT&CK (T1055, T1003, T1571...)
  - Regras Sigma → Integração SIEM
  - Regras YARA → Detecção em endpoint

□ IOC Estático:
  - Timestamp de compilação (pode ser falsificado)
  - Caminho PDB (contém informações do desenvolvedor)
  - Nome de seção anômalo (não padrão .text/.data)
  - Combinação anômala de tabela de importação (ex.: ransomware CryptEncrypt + DeleteShadowCopies)

Referência Rápida de Técnicas de Antianálise

Técnica	Método de Detecção	Característica YARA
Detecção de VM	WMI Win32_BIOS/VideoController/Processor	String Win32_ + nome de fabricante específico
Detecção de Sandbox	Disco < 60GB, RAM < 2GB, CPU de núcleo único	Padrão de chamada GlobalMemoryStatusEx
Detecção de Depurador	IsDebuggerPresent, CheckRemoteDebuggerPresent	Acesso ao deslocamento PEB.BeingDebugged
Fuga Temporal	Sleep(300000) seguido de ação maliciosa	Parâmetro longo de NtDelayExecution
Detecção Geográfica	Verifica layout do teclado/fuso horário → exclui países CIS	Chamada GetKeyboardLayoutList
Detecção de Processo Pai	explorer.exe vs cmd.exe	Comparação de strings de nome de processo
Syscall Direto de API	Bypass de hook EDR	Instrução syscall + resolução SSN

Análise Automatizada Multi-Agente (Arquitetura SentinelHive)

┌─────────────────────────────────────────────────┐
│                  Hive Director                    │
│          (Claude Opus orquestração + arbitragem)  │
└──────┬──────┬──────┬──────┬──────┬───────┘
       │      │      │      │      │
   ┌───┘  ┌───┘  ┌───┘  ┌───┘  ┌───┘
   ▼      ▼      ▼      ▼      ▼      ▼
Triagem RE    Comport Intel  Detec  Remediação
  rápida  estática  dinâmico  ameaça  regras  plano
                          YARA
                          Sigma

Cadeia de Ferramentas

Ferramenta	Propósito	Obter
Ghidra / IDA Pro	Descompilação profunda	ghidra-sre.org
CAPE Sandbox	Sandbox de malware de código aberto	GitHub: kevoreilly/CAPEv2
ASD Azul	Análise automatizada em larga escala	GitHub: ASD
YARA	Motor de regras de correspondência de padrões	pip install yara-python
Sigma	Regras de detecção comportamental SIEM	GitHub: SigmaHQ/sigma
FLOSS	Extração de strings ofuscadas	pip install flare-floss
Detect It Easy	Detecção de packers/compiladores	GitHub: horsicq/Detect-It-Easy
pe-sieve	Escaneamento de memória de processo	GitHub: hasherezade/pe-sieve
VirusTotal API	Escaneamento multi-motor	virustotal.com
MalwareBazaar	Repositório de amostras de malware	bazaar.abuse.ch

Referências

• references/yara-sigma-rules.md — Metodologia de criação YARA + Sigma
• references/sandbox-orchestration.md — Orquestração e automação de sandbox
• references/anti-analysis-techniques.md — Detecção de 94 técnicas de antianálise
• ../reverse-engineering/references/re-agent-workflow.md — Regra de ferro do IAT e travas de seis fases (Issue #65)
• ../reverse-engineering/anti-analysis.md — Receitas de resposta do agente A–T (anti-debug/bypass de ofuscação)
• ../reverse-engineering/references/nonpe-format-cookbook.md — Receitas U–AV para múltiplos formatos não-PE (scripts/macros/JS/driver/DLL/Android)
• ../reverse-engineering/references/ollvm-deobfuscation.md — Achatamento de fluxo / predicados opacos (H/S)

Auto-Verificação de Conclusão da Tarefa (DEVE passar antes de declarar conclusão)

• Executei cada etapa do workflow (não apenas li)?
• A verificação DEVE da tabela de importação foi executada e escrita na Evidência (E-imports ou âncora equivalente .NET)? DLL/SYS contém E-exports?
• Se o reparo de IAT falhou ou a amostra crashou com auto-verificação: registrei E-iat-repair-fail / E-self-check-crash e transicionei para dinâmica?
• Se houve solicitação de refazer: voltei para a etapa nomeada ou resultado de negociação prévia confirmada? Em caso de bloqueio, expliquei + solicitei confirmação em vez de trocar a etapa?
• Na dinâmica, coloquei breakpoints na ordem de segurança TLS→EP→APIs sensíveis→ExitProcess? Tratei a caixa de tempo / combinação de APIs de alto risco conforme desvio?
• Antianálise/ofuscação (A–T) foram registrados conforme as receitas anti-analysis? Assinatura inválida não rebaixou indevidamente a ameaça?
• Tipos não-PE (scripts/macros/DLL etc.) registraram Evidência correspondente conforme cookbook U–AV (ex.: E-batch-deobf / E-ps-decode / E-vba-pcode / E-dll-*)?
• Usei caminhos de ferramentas reais com base em tool-index?
• Produzi Evidência reproduzível (comandos/scripts/screenshots/relatórios)?
• Concluí e registrei os itens da Checklist exigidos pelas REGRAS?