Análisis Estático de Malware: Herramientas y Técnicas Esenciales

Qué es el análisis estático y por qué es tu primera línea de defensa

El análisis estático consiste en examinar un archivo sospechoso sin ejecutarlo. Se estudian sus propiedades intrínsecas: hashes, cabeceras, strings embebidos, funciones importadas, recursos y estructura interna. Todo sin que el binario toque un solo ciclo de CPU como proceso activo.

Es la primera fase de cualquier triaje por tres razones: seguridad (sin riesgo de infección), velocidad (clasificas muestras en minutos) y cobertura (funciona incluso cuando el malware detecta sandboxes y no ejecuta su payload).

Este artículo cubre las siete categorías esenciales de herramientas, con ejemplos prácticos y un workflow completo para analizar un PE sospechoso.

---

1. Inspección de archivos PE

El formato Portable Executable (PE) es el contenedor de ejecutables en Windows (.exe, .dll, .sys). Su cabecera contiene metadatos que revelan mucho sobre la muestra antes de mirar una sola instrucción de código.

PEStudio (gratuito)

La herramienta de referencia para triaje rápido de PEs. Abre el archivo sin ejecutarlo y presenta un resumen visual de indicadores sospechosos.

Qué buscar en PEStudio:

• Indicadores rojos: imports sospechosas (VirtualAlloc, CreateRemoteThread, WriteProcessMemory), entropy alta en secciones (posible packing), timestamps incoherentes.
• Strings: PEStudio clasifica automáticamente las cadenas como URLs, rutas de archivo, claves de registro o direcciones IP.
• Imports: funciones del API de Windows agrupadas por categoría (inyección de procesos, manipulación de archivos, red, registro, criptografía).
• Secciones: nombres, tamaños, entropía. Una sección .text con entropía superior a 7.0 sugiere cifrado o packing.
• Recursos: iconos, manifiestos, datos embebidos. Malware frecuentemente esconde payloads en la sección de recursos.

CFF Explorer

Editor de cabeceras PE con vista hexadecimal sincronizada con la estructura parseada. Permite inspeccionar cada campo del PE header (DOS Header, NT Headers, Section Headers, Import/Export Directory, Resource Directory). Su punto fuerte: seleccionas un campo en el árbol y se resalta el offset exacto en el hex dump.

PE-bear

Alternativa visual moderna. Ofrece comparación side-by-side de secciones, análisis de overlay y detección de anomalías en la cabecera PE.

---

2. Desensambladores y descompiladores

Cuando la inspección de cabeceras no es suficiente, necesitas ver las instrucciones reales del binario. Los desensambladores convierten código máquina en ensamblador legible. Los descompiladores van un paso más allá y generan pseudocódigo en C o similar.

IDA Pro / IDA Free

IDA es el estándar de la industria desde hace dos décadas. IDA Free soporta x86/x64 con descompilador cloud limitado. IDA Pro (desde 1.879 USD) añade ARM, MIPS, PPC y el descompilador Hex-Rays integrado.

Flujo típico: cargar el binario, ir al entry point, renombrar funciones según su propósito, usar cross-references (Xrefs) para rastrear strings y funciones sospechosas, y anotar cada bloque con comentarios.

Ghidra (NSA, gratuito y open source)

Ghidra cambió el panorama del reversing al ofrecer un descompilador de calidad profesional completamente gratuito. Soporta más de 20 arquitecturas de procesador.

Ventajas clave para análisis de malware:

• Descompilador integrado: genera pseudocódigo C navegable, sincronizado con la vista de ensamblador.
• Scripting en Java/Python: automatiza tareas repetitivas (renombrar funciones, extraer IOCs, deofuscar strings).
• Collaborative reversing: permite que varios analistas trabajen en el mismo proyecto simultáneamente.
• Version tracking: compara versiones de un mismo malware para identificar cambios entre variantes.
• Plugin ecosystem: Ghidra Bridge, YARA integration, Lighthouse (code coverage).

Binary Ninja

Alternativa comercial (desde 299 USD) con una representación intermedia (BNIL) que facilita scripts de análisis automatizado. Se posiciona entre IDA Pro y Ghidra en funcionalidad y coste.

---

3. Análisis de strings

Las cadenas de texto embebidas en un binario son una mina de información: URLs de C2, rutas de archivos que manipula, mensajes de error, claves de registro, nombres de mutex y comandos de shell.

FLOSS (FireEye Labs Obfuscated String Solver)

FLOSS es la evolución del clásico strings. No solo extrae cadenas en texto plano, sino que aplica técnicas de deobfuscación automática:

• Stack strings: cadenas construidas caracter a caracter en la pila.
• Tight loops: bucles XOR o ADD que decodifican strings en runtime.
• Decoded strings: ejecuta funciones de decodificación de forma emulada para extraer las cadenas resultantes.

Ejemplo de uso:

# Extracción básica con deofuscación
floss malware_sample.exe

# Solo strings ofuscadas (stack + decoded)
floss --only stack,decoded malware_sample.exe

# Formato JSON para procesamiento automatizado
floss -j malware_sample.exe > strings_report.json

Salida típica de FLOSS en una muestra de infostealer:

FLOSS decoded strings (via emulation):
  http://185.215.113[.]43/gate.php
  Software\Microsoft\Windows\CurrentVersion\Run
  %APPDATA%\svchost.exe
  Mozilla/5.0 (Windows NT 10.0; Win64; x64)
  cmd.exe /c ping 127.0.0.1 -n 3 & del "%~f0"

Cada cadena es un IOC o indicador de comportamiento: la URL revela el C2, la clave de registro indica persistencia, la ruta en APPDATA es el destino del dropper y el comando final es la rutina de auto-borrado.

Strings (Sysinternals / GNU) y BinText

Strings es la herramienta clásica: busca secuencias ASCII y Unicode de longitud mínima configurable. Instantánea pero sin deofuscación. BinText añade una GUI con offset de archivo y memoria, útil para reportes.

---

4. Análisis de malware .NET

El malware escrito en .NET (C#, VB.NET) es cada vez más frecuente. Familias como Agent Tesla, AsyncRAT, QuasarRAT, RedLine Stealer y Snake Keylogger usan .NET como plataforma. La ventaja para el analista: .NET compila a bytecode IL (Intermediate Language), no a código nativo, y se puede descompilar a código fuente casi idéntico al original.

dnSpy (descompilador interactivo)

La herramienta estrella para malware .NET. Permite:

• Descompilar assemblies a C# o VB.NET con precisión casi perfecta.
• Depurar el assembly directamente, poniendo breakpoints y evaluando variables.
• Editar el código IL y recompilar (útil para parchear checks anti-análisis).
• Buscar strings, métodos, tipos y referencias cruzadas en todo el assembly.

Flujo de análisis .NET con dnSpy:

1. Abrir el .exe o .dll en dnSpy.
2. Navegar al entry point (normalmente Program.Main()).
3. Buscar strings sospechosas: URLs, direcciones de email, claves de cifrado.
4. Identificar funciones de comunicación (HttpClient, WebRequest, Socket).
5. Rastrear el flujo de datos desde la captura de credenciales hasta la exfiltración.

dotPeek e ILSpy

dotPeek (JetBrains, gratuito) ofrece un excelente motor de descompilación sin debugger integrado. ILSpy (open source) es más ligero y soporta versiones recientes de .NET (6, 7, 8). Ambos son útiles como segundo descompilador cuando dnSpy produce código confuso.

de4dot (deobfuscador .NET)

Muchas muestras .NET vienen ofuscadas con herramientas como ConfuserEx, SmartAssembly, Eazfuscator o .NET Reactor. de4dot revierte automáticamente muchas de estas protecciones:

• Renombra clases, métodos y variables a nombres legibles.
• Descifra strings ofuscadas.
• Elimina proxy calls y control flow obfuscation.
• Restaura metadata removida.

# Deobfuscar una muestra protegida con ConfuserEx
de4dot malware_obfuscated.exe -o malware_clean.exe

Después de pasar la muestra por de4dot, el código en dnSpy pasa de ser ilegible a navegable. Es un paso casi obligatorio cuando la muestra está ofuscada.

---

5. Análisis de archivos y recursos

Antes de abrir un binario en un desensamblador, conviene inspeccionar su estructura como archivo.

• 7-Zip: abre formatos PE, MSI, ISO, CAB como archivos comprimidos. Permite extraer recursos embebidos e identificar payloads dentro de droppers sin ejecutar nada.
• CFF Explorer: además de editor PE, explora la sección de recursos (iconos, manifiestos XML, datos binarios). Los droppers almacenan payloads cifrados aquí frecuentemente.
• Resource Hacker: especializada en extraer y examinar recursos. Útil para encontrar payloads en RT_RCDATA, identificar iconos suplantados (PDF falso) y examinar manifiestos que solicitan elevación de privilegios (requireAdministrator).

---

6. Reglas YARA

YARA es el lenguaje estándar para describir patrones de malware. Una regla YARA combina strings (texto o bytes), condiciones lógicas y metadatos para identificar y clasificar muestras.

Anatomía de una regla YARA

rule Emotet_Loader_2024 {
    meta:
        author      = "MalwareIntel Research"
        description = "Detects Emotet loader variants (2024 campaigns)"
        date        = "2024-03-15"
        reference   = "https://malpedia.caad.fkie.fraunhofer.de/details/win.emotet"
        tlp         = "WHITE"
        severity    = "high"

    strings:
        // C2 communication pattern
        $http_post = "POST" ascii
        $content_type = "Content-Type: multipart/form-data" ascii

        // Registry persistence
        $reg_run = "Software\\Microsoft\\Windows\\CurrentVersion\\Run" ascii

        // Characteristic byte sequences (XOR-encoded config)
        $xor_loop = { 8B 45 ?? 0F B6 00 33 45 ?? 88 01 }

        // Anti-analysis checks
        $api_1 = "IsDebuggerPresent" ascii
        $api_2 = "GetTickCount" ascii
        $api_3 = "NtQueryInformationProcess" ascii

    condition:
        uint16(0) == 0x5A4D and          // MZ header (es un PE)
        filesize < 500KB and              // tamaño típico del loader
        ($http_post and $content_type) and
        $reg_run and
        $xor_loop and
        1 of ($api_*)
}

Cada parte cumple una función:

• meta: documenta la regla (autor, fecha, referencia, TLP). No afecta la detección.
• strings: define patrones a buscar. Pueden ser texto ASCII/Unicode, expresiones regulares o secuencias hexadecimales con wildcards (??).
• condition: lógica booleana que combina los strings con condiciones sobre el archivo (tamaño, magic bytes, offset).

Aplicando reglas YARA

# Escanear un archivo con un conjunto de reglas
yara -s rules/emotet.yar suspicious_sample.exe

# Escanear un directorio completo
yara -r rules/ /path/to/samples/

# Usar reglas de repositorios públicos
git clone https://github.com/Yara-Rules/rules.git
yara -r rules/malware/ sample.exe

Repositorios de reglas YARA públicos

• Yara-Rules/rules (GitHub): colección comunitaria organizada por categoría.
• InQuest/awesome-yara: índice de recursos YARA.
• Florian Roth (Neo23x0): reglas de alta calidad para amenazas actuales (THOR, signature-base).
• Malpedia: incluye reglas YARA vinculadas a cada familia de malware documentada.

Buenas prácticas al escribir reglas

1. Especificidad: combinar múltiples strings reduce falsos positivos. Una sola cadena genérica produce demasiados hits.
2. Performance: evitar expresiones regulares complejas en reglas que se ejecutan contra miles de archivos. Las secuencias hex son más rápidas.
3. Versionado: documentar la fecha y la referencia de cada regla. Las variantes de malware evolucionan y las reglas necesitan actualizarse.
4. Testing: probar contra un corpus de muestras benignas antes de desplegar en producción para medir la tasa de falsos positivos.

---

7. Herramientas de hashing y firmas

Los hashes son la forma más directa de identificar una muestra conocida. Un cambio de un solo byte produce un hash completamente diferente (en hashes criptográficos), pero las herramientas de fuzzy hashing resuelven parcialmente ese problema.

Hashes criptográficos (MD5, SHA-1, SHA-256)

Cada muestra tiene un hash único que permite buscarla en VirusTotal/MalwareBazaar, verificar si ya fue analizada y compartir IOCs sin distribuir el binario.

# Linux/macOS
sha256sum sample.exe

# PowerShell
Get-FileHash -Algorithm SHA256 sample.exe

ssdeep (fuzzy hashing)

A diferencia de SHA-256, ssdeep genera hashes que permiten medir similitud entre archivos. Dos variantes del mismo malware (con pequeñas modificaciones) producirán hashes ssdeep con un porcentaje de coincidencia alto.

# Generar hash ssdeep
ssdeep sample_v1.exe
# 3072:Hk8gN3DqmANbJj2BjYQk5W3VZ:HkxN3hJj2B0k5WFZ

# Comparar dos muestras
ssdeep -d sample_v1.exe sample_v2.exe
# sample_v1.exe matches sample_v2.exe (87)

# Comparar contra una base de datos de hashes
ssdeep -m known_malware_hashes.txt new_sample.exe

Un score de 87 indica alta similitud, útil para agrupar variantes de la misma familia cuando los atacantes recompilan con cambios menores.

HashCalc / HashMyFiles y VirusTotal

HashCalc y HashMyFiles (NirSoft) son GUIs que calculan múltiples hashes simultáneamente. VirusTotal es el punto de referencia cloud para verificar hashes conocidos. Precaución: al subir un archivo, queda disponible para suscriptores premium. Busca siempre primero por hash antes de subir el archivo completo.

---

Workflow práctico: análisis estático de un PE sospechoso

Este es el flujo que sigue un analista experimentado. Cada paso tiene criterios de decisión para continuar o detenerse.

Paso 1: Hashing e identificación (2 min). Calcular SHA-256 y ssdeep. Buscar en VirusTotal y MalwareBazaar. Si aparece con detecciones conocidas, documentar y cerrar triaje. Si no, continuar.

Paso 2: Inspección PE con PEStudio (5 min). Revisar indicadores rojos: timestamp incoherente, secciones con nombres sospechosos (UPX0, .enigma), entropía mayor a 7.0, imports de inyección de procesos, overlay.

Paso 3: Strings con FLOSS (3 min). Clasificar hallazgos: URLs/IPs (C2), rutas de archivo (persistencia), claves de registro (Run, Services), nombres de mutex, comandos shell.

Paso 4: Reglas YARA (2 min). Escanear con reglas públicas. Match positivo indica familia catalogada. Sin match, la muestra puede ser nueva.

Paso 5: Recursos embebidos (3 min). Inspeccionar con Resource Hacker y 7-Zip. Si hay datos sospechosos en RT_RCDATA, extraer y repetir pasos 1-4.

Paso 6: Desensamblado (15-60+ min). Si lo anterior no fue concluyente, abrir en Ghidra o IDA. Localizar entry point, buscar funciones de red, identificar rutinas de cifrado. Para .NET: de4dot primero, luego dnSpy.

Paso 7: Documentación. Informe con SHA-256, familia identificada, IOCs extraídos, técnicas MITRE ATT&CK, nivel de confianza y recomendación sobre necesidad de análisis dinámico.

---

Cuándo el análisis estático es suficiente (y cuándo no)

El estático basta cuando:

• La muestra matchea una regla YARA conocida con alta confianza.
• Los strings revelan el C2, la familia y el mecanismo de persistencia.
• El código desensamblado muestra un flujo de ejecución claro y documentable.
• La muestra no tiene ofuscación pesada ni packing multicapa.

Necesitas análisis dinámico cuando:

• La muestra está empacada con un packer desconocido o multicapa.
• Los strings están completamente cifrados y FLOSS no logra resolver.
• El malware usa carga dinámica de funciones (GetProcAddress con strings ofuscadas) y no puedes determinar qué APIs usa realmente.
• Necesitas confirmar el comportamiento exacto: a qué C2 se conecta, qué datos exfiltra, qué archivos modifica.
• La muestra contiene técnicas de evasión que solo se revelan en ejecución (environment checks, sleep timers, geofencing).

La combinación de ambos enfoques es lo que produce un análisis completo. El estático te da el mapa; el dinámico te confirma el territorio.

---

Resumen: las 7 categorías del análisis estático

La infografía que acompaña este artículo resume visualmente estas categorías. La tabla siguiente sirve como referencia rápida.

Categoría	Herramientas principales	Indicadores clave
Inspección PE	PEStudio, CFF Explorer, PE-bear	Entropía, imports, secciones, timestamp
Desensamblado	IDA Pro, Ghidra, Binary Ninja	Flujo de ejecución, funciones, xrefs
Strings	FLOSS, Strings, BinText	URLs, IPs, rutas, mutex, comandos
.NET analysis	dnSpy, dotPeek, ILSpy, de4dot	Código fuente, configs, C2 hardcoded
Archivos/Recursos	7-Zip, CFF Explorer, Resource Hacker	Payloads embebidos, iconos, manifiestos
YARA	yara, repositorios públicos	Matches por familia, packer, TTP
Hashing/Firmas	ssdeep, SHA-256, VirusTotal	Identificación, similitud, detecciones

La mayoría de herramientas son gratuitas. Un analista puede montar un laboratorio completo con coste cero usando Ghidra, PEStudio, FLOSS, dnSpy, YARA y ssdeep.

---

Referencias y recursos

• MITRE ATT&CK: Techniques para mapear las técnicas observadas.
• Malpedia para referencias cruzadas de familias y reglas YARA.
• MalwareBazaar para buscar muestras por hash.
• Yara-Rules/rules repositorio de reglas YARA comunitarias.
• Ghidra para descarga e instalación.
• FLOSS herramienta de extracción de strings de Mandiant.
• Practical Malware Analysis (Sikorski & Honig): el libro de referencia para análisis estático y dinámico de malware.