Análisis estático de malware

El análisis estático examina una muestra de malware sin ejecutarla, lo que lo hace la primera parada segura del análisis: inspeccionas el fichero, sus cadenas, sus imports, su estructura y su código para deducir qué hace. Es seguro (no corres código peligroso) y aporta una visión completa, aunque el malware ofuscado o empacado (ver Ofuscación y packing) limita lo que se ve sin ejecutar. Es reversing (ver Análisis estático) aplicado a muestras maliciosas.

Triaje inicial (sin abrir el código)

# identidad de la muestra
sha256sum muestra ; md5sum muestra        # hash -> buscar en VirusTotal/MalwareBazaar
file muestra                               # tipo (PE/ELF/script/documento con macro)
# reputación (sin subir si es sensible -> buscar solo el hash)
VirusTotal, MalwareBazaar, Hybrid Analysis  (buscar por hash primero)
# entropía (alta = probablemente empacado/cifrado)
# cadenas legibles
strings -a muestra ; strings -e l muestra   # ASCII y unicode
floss muestra                               # FLARE: extrae strings OFUSCADAS/apiladas

FLOSS (de Mandiant) es clave: muchos malwares construyen sus strings en runtime para evitar que strings las revele; FLOSS las extrae estáticamente.

Analizar un PE (Windows, lo más común)

# cabeceras, secciones, imports/exports
pefile (Python) / PE-bear / CFF Explorer / PEstudio
# qué buscar:
- imports (IAT): APIs que usa -> comportamiento
    VirtualAlloc/WriteProcessMemory/CreateRemoteThread -> inyección de código
    InternetOpen/WinHttp/socket -> red (C2)
    CryptEncrypt/CryptAcquireContext -> cifrado (¿ransomware?)
    RegSetValue/CreateService/schtasks -> persistencia
- secciones anómalas (entropía alta, nombres raros, RWX) -> packing
- timestamp de compilación, firma digital (¿válida? ¿robada?)
- recursos embebidos (otro PE dentro -> dropper)

Los imports cuentan la historia: una muestra que importa VirtualAllocEx + WriteProcessMemory + CreateRemoteThread casi seguro inyecta código en otro proceso.

Decompilar y leer la lógica

Ghidra / IDA           desensamblar + pseudo-C (ver rev-static)
# localizar: la rutina de descifrado de strings/config, la lógica de C2,
#   el algoritmo de cifrado (ransomware), la persistencia
# capa.dev (Mandiant): identifica CAPACIDADES del binario automáticamente
capa muestra           # -> "encrypts data", "communicates over HTTP", "injects code"...

capa es muy útil: mapea automáticamente las capacidades del binario a MITRE ATT&CK leyendo su código, dándote un resumen de qué hace sin leer todo el desensamblado.

Documentos y scripts maliciosos

# Office con macros (VBA)
oletools: olevba muestra.doc          # extraer y desofuscar macros VBA
# PDF
pdfid / pdf-parser                     # JavaScript embebido, acciones automáticas
# scripts
PowerShell/JS/HTA ofuscados -> desofuscar (base64, concatenación, ver mal-obfus)

Extraer IOCs (estático)

# del binario/strings/config descifrada:
dominios/IPs/URLs de C2, user-agents, mutexes, rutas, claves de registro,
nombres de ficheros, claves de cifrado, versiones/campañas

Para la defensa

El análisis estático alimenta la detección: de aquí salen las reglas YARA (Reglas YARA) e IOCs para el SIEM/EDR.
Capacidades (capa) + imports permiten clasificar rápido una muestra y priorizar la respuesta.
Compartir IOCs/firmas con la comunidad (threat intel) acelera la detección global.

Checklist de prueba

Triaje: hash, file, VirusTotal/MalwareBazaar, entropía
Strings (strings + FLOSS para las ofuscadas)
PE: imports/IAT, secciones, recursos (PEstudio/pefile)
Deducir comportamiento por imports (inyección/red/cripto/persistencia)
capa.dev para capacidades → MITRE ATT&CK
Decompilar la lógica clave (Ghidra)
Documentos/scripts: olevba/pdf-parser/desofuscar
Extraer IOCs → reglas YARA (Reglas YARA)