Análisis de malware estático: strings, PE/ELF, YARA, sandbox

El análisis de malware es una de las especializaciones centrales de la seguridad defensiva. Cuando un equipo SOC detecta un artefacto sospechoso en un endpoint, cuando un bug hunter encuentra un backdoor en una app, cuando un analista forense investiga un incidente: el primer paso siempre es analizar el binario para entender qué hace, de qué familia es, qué IOCs genera y cómo detectarlo a escala. El análisis se divide en dos fases: estático (sin ejecutar: metadatos, strings, disassembly, YARA) y dinámico (ejecutar en sandbox controlado, observar). Esta lección cubre el análisis estático básico que todo analista entry-level debería dominar; es la puerta de entrada a reverse engineering.

En 2026 el ecosistema malware se dividen entre commodity (banking trojans, infostealers como RedLine, LummaC2) con cientos de variantes al día, y targeted/APT (ransomware operadores, state-sponsored) con muestras novel. El análisis estático permite triar en minutos: distingir rápidamente familias conocidas (clasificación por YARA) de muestras realmente nuevas que merecen análisis profundo.

Es la primera lección del bloque blue team / defensa avanzada de la Tanda 5, continuación natural de las lecciones de forense (Volatility, timeline Windows) de la Tanda 4.

Trabaja solo con samples obtenidas legalmente: honeypots propios, MalwareBazaar, bug bounty, equipos autorizados. Ejecutar malware fuera de sandbox aislado es peligroso.

Precauciones antes de empezar#

• Nunca abrir malware en tu máquina principal. Lab aislado: VM dedicada sin red, o REMnux / FLARE VM.
• Shared folders apagados durante análisis.
• Snapshots antes de cada análisis dinámico para restaurar fácilmente.
• Nombre del archivo con extensión cambiada mientras inicia analisis: malware.exe.danger para evitar doble-click accidental.
• Hashes y rename: nombrar samples por SHA256_8chars.bin para consistencia.

Primer vistazo: metadatos#

Comandos iniciales (Linux):

# Hashes
md5sum sample.bin
sha1sum sample.bin
sha256sum sample.bin

# Tipo de archivo
file sample.bin
# PE32+ executable (console) x86-64, for MS Windows
# Magic bytes: MZ = Windows PE, 7F ELF = Linux ELF, CA FE BA BE = Mach-O universal

# Tamaño
ls -la sample.bin

Los hashes son críticos: permite buscar en VirusTotal, MalwareBazaar, Hybrid-Analysis, ANY.RUN si la muestra ya se conoce.

VirusTotal y servicios públicos#

# Via CLI (vt-cli)
vt file sha256:ABCDEF... --summary

# O web: virustotal.com

Qué buscar en la respuesta:

• First seen: fecha del primer upload. Muy reciente = posiblemente nuevo.
• Detection ratio: X/Y antivirus lo detectan.
• Behavior tags: si se ejecutó en sandbox.
• Yara rules: cuáles matcharon.
• Relations: dominios, IPs, archivos relacionados.

Otros servicios:

• MalwareBazaar (abuse.ch): samples descargables para research.
• ANY.RUN: sandbox interactivo online.
• Hybrid-Analysis: sandbox + análisis estático.
• Triage (Hatching): sandbox comercial.

Importante operacional: subir sample a VirusTotal/ANY.RUN lo hace público. Si es IR real, usar sandbox privado para no filtrar presencia.

Strings#

Sacar strings legibles del binario:

# ASCII strings mínimo 6 chars
strings -n 6 sample.bin

# Unicode strings
strings -e l sample.bin

# Combinado
strings -a -n 6 sample.bin | less

Qué buscar:

• URLs/dominios: C2 potenciales.
• IPs: hardcoded C2.
• Rutas de archivo: paths de persistencia, loot.
• Comandos cmd/PS: ejecución de sistema.
• Mutex names: característica de familia.
• PDB paths: dejados por desarrolladores (C:\Users\attacker\dev\malware.pdb).
• Nombres de funciones/APIs: si no está obfuscado.
• Base64 / hex blobs: payloads embebidos.

Malware moderno ofusca strings: aparecen pocos o ninguno legibles. Eso ya es información: binario con solo strings de API imports y nada más es sospechoso.

PE headers (Windows)#

# pefile (Python)
pip install pefile
python3 -c "import pefile; pe=pefile.PE('sample.bin'); print(pe.dump_info())"

# CFF Explorer (Windows GUI).
# PE-bear (Windows GUI).

Qué revelar:

• Compilation timestamp: cuándo se compiló. Timestamps falsificables pero útiles.
• Sections: .text, .data, .rdata, .rsrc. Sección .text con entropy > 7.0 = probablemente packed.
• Imports (IAT): qué APIs usa el binario. Pocas imports = packer.
• Exports: si es DLL.
• Resources: binaries embebidos, iconos, strings, manifests.
• Digital signature: firmas válidas vs inválidas vs ausentes.
• Rich Header: huella del compilador Microsoft, útil para clasificación.

APIs que gritan malware:

• VirtualAlloc + WriteProcessMemory + CreateRemoteThread = injection.
• InternetOpen / WinHttp* = network.
• CryptEncrypt + large file access = ransomware.
• EnumProcesses / OpenProcess = reconnaissance.

ELF headers (Linux)#

readelf -a sample.bin
# O
objdump -x sample.bin

Sección .note.ABI-tag, dynamic libraries, sections sospechosas (p. ej. .hidden).

Entropy#

Secciones con alta entropía (>7.0) indican compression o encryption. Packers (UPX, Themida) resultan en binarios con secciones de alta entropía. binwalk -E sample.bin grafica la entropía por offset.

# Detectar packer común (UPX)
upx -t sample.bin
# If "upx: sample.bin: OK" → es UPX
upx -d sample.bin -o unpacked.bin

Otros packers requieren unpacking manual o scripts especializados.

YARA: la navaja suiza#

YARA es el framework estándar para escribir reglas que identifican malware. Sintaxis simple:

rule RedLine_Stealer_Strings {
    meta:
        description = "Detecta strings tipicas RedLine"
        author = "analyst"
        date = "2026-11-06"
    strings:
        $s1 = "SELECT * FROM logins" ascii
        $s2 = "Chromium" ascii
        $s3 = { 48 8B 05 ?? ?? ?? ?? 48 85 C0 } // hex pattern
    condition:
        2 of them
}

Usage:

yara rules.yar samples/
yara -r rules.yar /mnt/evidence/

Grandes repositorios públicos:

• YARA-Rules (community).
• Florian Roth / Neo23x0 rules.
• Elastic security-rules.
• The DFIR Report.

En SOCs, YARA se corre sobre email attachments, drops recientes del sistema, memoria vía Volatility. Clasificación rápida de miles de muestras.

Diferentes tipos de malware#

Reconocer el tipo acelera análisis:

• Trojan dropper: pequeño, descarga second-stage.
• Infostealer: busca credentials, cookies, wallets. Strings SELECT FROM logins, paths de browsers.
• Banker trojan: inyección en navegador, hooks on banking URLs.
• Ransomware: CryptEncrypt + enumeración de archivos + mensaje de rescate.
• RAT (Remote Access Trojan): C2 persistente, comandos remotos.
• Cryptominer: CPU intensive, strings tipo stratum+tcp://.
• Rootkit: oculta procesos/archivos, LKM / driver nivel.
• Wiper: borra datos irrecuperablemente (NotPetya, HermeticWiper).

Cada uno tiene patterns distintos; YARA lo refleja.

IOCs: lo que se publica al final#

Tras análisis, se extraen IOCs (Indicators of Compromise) para compartir:

• Hashes (MD5, SHA1, SHA256).
• Dominios C2.
• IPs.
• Mutex names.
• Registry keys (Windows).
• Rutas de archivo típicas.
• YARA rules.

Se comparten vía:

• MISP: platform de sharing.
• OTX (AlienVault): open threat exchange.
• STIX/TAXII: estándares estructurados.
• Twitter/Mastodon: la community informal pero activa.

Siguiente paso: dinámico#

Lección no cubierta aquí pero mencionada: análisis dinámico. Ejecutar sample en sandbox aislado observando:

• Procesos creados.
• Conexiones de red.
• Archivos tocados.
• Registry modifications.
• API calls.

Herramientas: Cuckoo Sandbox, CAPE Sandbox, ANY.RUN, Procmon, Wireshark, RegShot.

Walkthrough: trojan commodity#

Para fijar el patrón, un flujo con sample de infostealer.

Paso 1 — hash y VT:

sha256sum sample.bin
# a1b2c3d4...
vt file sha256:a1b2c3d4...
# Detection: 42/68 AV engines, RedLine Stealer

Ya conocido. Si fuera 0/68 sería novel → análisis profundo.

Paso 2 — strings:

strings -n 6 sample.bin | grep -iE "http|login|wallet"
# http://45.95.147.x/api/upload
# SELECT origin_url, username_value, password_value FROM logins
# wallet.dat
# Local State  (Chrome encrypted key path)

Confirma infostealer. C2 identificado.

Paso 3 — PE headers:

python3 -c "import pefile; pe=pefile.PE('sample.bin'); \
  print([(e.dll, [i.name for i in e.imports]) for e in pe.DIRECTORY_ENTRY_IMPORT])"

Imports: WinInet (network), Crypt32 (decrypt Chrome keys), shlwapi (file manipulation). Patrón clásico stealer.

Paso 4 — YARA matches:

yara -r rules/redline.yar sample.bin
# redline_stealer_v2 : sample.bin

Paso 5 — IOCs:

• Hash: a1b2c3d4...
• C2: 45.95.147.x
• Target apps: Chrome, Firefox, Opera, wallets crypto
• Mutex: detectado en dynamic subsequent

Paso 6 — compartir via MISP / OTX con los IOCs.

Total time para triar: ~15 minutos.

Herramientas top 2026#

• CAPEv2: sandbox opensource moderno, mejor que Cuckoo clásico.
• IDA Pro / Ghidra / Binary Ninja: disassemblers.
• x64dbg: debugger Windows user-mode gratuito.
• PE-sieve (Hasherezade): detecta implants en memoria.
• DIE (Detect It Easy): fingerprinting rápido de PE.
• Scylla: dumping/rebuilding de PEs unpacked.
• ApateDNS, FakeNet-NG: sinkholing de C2 en sandbox.

Errores comunes#

• Analizar en host sin aislar.
• No hashear antes de analizar (perder tracking).
• No buscar en VirusTotal primero (reinventar la rueda).
• Copiar reglas YARA community sin adaptar a entorno.
• Ignorar entropy / packing (análisis directo sobre binario packed es inútil).

Preguntas frecuentes#

¿Necesito disassembly skills para empezar?#

No para análisis estático básico. Reading disassembly (IDA, Ghidra) es siguiente nivel; con strings + imports + YARA + VirusTotal cubres el 80% de triaje.

¿Cuál es el camino carrier?#

Analyst SOC L1 → L2 → Threat Hunter → Malware Analyst → Reverse Engineer → RE senior en vendor security o think tank. Salarios: 40k (L1) a 150k+ (senior RE) según región.

¿Linux malware analysis difiere mucho?#

Menos tooling GUI (más CLI), menos variedad de familias (menos commodity, más botnets IoT), misma metodología. ELF en vez de PE pero el pensamiento es idéntico.

¿YARA puede falsificar firmas?#

No, YARA detecta patrones. Para firmar código habría otras mecanismos. YARA se puede bypassear con obfuscation; packers rompen la mayoría de reglas estáticas.

¿Dónde practico?#

El laboratorio snort de whoami-labs incluye samples neutros (no live malware) pero representativos: un binario packed, uno con infostealer strings típicas, uno con C2 hardcoded. Practicas el flujo completo: hashes, strings, pefile, YARA, IOCs.

¿Qué pasa con malware .NET y PowerShell?#

.NET: dnSpy, dotPeek permiten decompile directo a C# legible. Muy didáctico para empezar reverse. PowerShell: muchos payloads vienen en PS1/PS2 ofuscado base64. Decodificar y desofuscar con PSDecode, revoke-obfuscation, análisis manual.

¿Rust y Go cambian el análisis?#

Go: binarios grandes (stripped runtime), strings abundantes pero scattered. Herramientas: GoReSym, golang-info. Rust: binarios pequeños pero sin runtime obvio. Ambos tienen tendencia creciente en malware moderno (ransomware BlackCat/ALPHV en Rust, varios loaders Go). Mismo pensamiento pero toolchain específica.

¿Hay futuro para analistas si la IA genera malware?#

La IA ayuda a ambos lados: atacantes generan variantes más rápido, pero también defensores automatizan clasificación. El rol del analyst evoluciona de triage manual a supervisor de pipelines automatizados + análisis profundo de casos novel. La demanda sigue creciendo.

¿Cuántos samples por día ve un analista SOC típico?#

L1 triaje: cientos. L2 análisis: decenas. Senior reverse engineer: 1-5 a profundidad. El pipeline filtra: automation + YARA cubren el 90-95%, el humano se enfoca en el resto.

Resumen#

• Análisis estático = sin ejecutar. Metadatos, strings, headers, YARA.
• Precauciones: lab aislado, snapshots, naming conventions.
• VirusTotal + MalwareBazaar primeros antes de análisis profundo (sample puede ser conocida).
• Strings: URLs, IPs, PDB paths, mutex names, APIs.
• PE/ELF headers: imports revelan capacidades.
• Entropy > 7.0 = probablemente packed.
• YARA = clasificación a escala.
• Siguiente paso: dinámico (Cuckoo, CAPE, ANY.RUN).

El análisis de malware es una disciplina técnica que premia la práctica constante y la paciencia. Cada familia de malware tiene características; con el tiempo el analyst reconoce signatures visuales en segundos de leer strings o imports. Es trabajo de equipo: los hallazgos de un analyst se comparten como YARA rules y threat intel para toda la industria, y las muestras públicas en MalwareBazaar son el gym abierto donde cualquiera puede practicar sin coste y sin riesgo de incident propio.

Las próximas lecciones cubren threat hunting (búsqueda proactiva de amenazas), zero trust (modelo defensivo sistemático) y ransomware anatomía, cerrando el bloque defensa avanzada de esta tanda con los temas más demandados por equipos SOC maduros.

Fuentes y lecturas recomendadas#

• MalwareBazaar
• YARA documentation
• Practical Malware Analysis (book)
• REMnux Linux distro