Volatility: Guía Completa de Análisis Forense de Memoria RAM

Por qué la memoria volátil es la evidencia más valiosa

Cuando un atacante compromete un sistema, deja rastros. Pero muchos de esos rastros están en la memoria RAM, no en el disco. El malware fileless, los rootkits y las inyecciones de código viven exclusivamente en memoria volátil. Si apagas la máquina, esa evidencia desaparece para siempre.

En un escenario de respuesta a incidentes, cada segundo cuenta. Los equipos de IR se enfrentan a una decisión crítica: ¿apagar el equipo para contener la amenaza o mantenerlo encendido para preservar la evidencia volátil? La memoria RAM contiene artefactos que no existen en ningún otro lugar: conexiones de red activas, contraseñas en texto plano, procesos inyectados, claves de cifrado en tránsito y la cadena de comandos completa que ejecutó el atacante. Según estudios recientes, más del 70% de las amenazas modernas utilizan técnicas fileless o living-off-the-land, lo que significa que no dejan artefactos en disco y solo pueden detectarse mediante análisis de memoria.

Volatility es el framework de código abierto más utilizado por investigadores forenses, equipos de respuesta a incidentes (IR) y analistas de SOC para extraer esa evidencia antes de que se pierda. Su capacidad para analizar capturas de memoria sin necesidad de ejecutar software en la máquina comprometida lo convierte en una herramienta indispensable en cualquier laboratorio forense.

Qué puedes encontrar en la memoria

Instalación rápida

# Volatility 3 (Python 3, última versión estable)
git clone https://github.com/volatilityfoundation/volatility3.git
cd volatility3
pip install -r requirements.txt

# Verificar
python vol.py --help

Adquisición de memoria: herramientas y técnicas

Antes de analizar, necesitas una captura de memoria. Este paso es crítico y debe realizarse con cuidado para no alterar la evidencia.

Herramientas de adquisición recomendadas

Buenas prácticas en la adquisición

1. Usar un dispositivo USB booteable con herramientas de adquisición para evitar escribir en el disco de la víctima.
2. Capturar la memoria completa, no parcial. Una imagen truncada puede perder evidencia crítica.
3. Verificar el hash (SHA-256) inmediatamente después de la captura.
4. Registrar la cadena de custodia: quién realizó la captura, cuándo, en qué condiciones y con qué herramienta.
5. No ejecutar software en la máquina comprometida más de lo estrictamente necesario, ya que el acto de ejecutar herramientas modifica la memoria.
6. Capturar volcados de pagefile y hibernación complementarios, ya que pueden contener datos que se expulsaron de RAM.

# Ejemplo con WinPmem desde USB booteable
winpmem_mini_x64.exe memory.raw

# Verificar integridad
sha256sum memory.raw > memory.hash.txt

Flujo de análisis forense

1. Identificar el sistema operativo

python vol.py -f imagen.raw windows.info

Esto determina la versión exacta de Windows y los offsets de memoria necesarios para todos los análisis posteriores.

2. Listado de procesos

# Procesos normales (desde EPROCESS)
python vol.py -f imagen.raw windows.pslist

# Procesos ocultos (búsqueda en memoria cruda)
python vol.py -f imagen.raw windows.psscan

# Diferencias = posibles rootkits
diff pslist.txt psscan.txt

Señales de alerta:

• Proceso que aparece en psscan pero no en pslist (oculto)
• Proceso sin nombre o con nombre genérico inusual
• Proceso padre inesperado (e.g., word.exe ejecuta cmd.exe)

3. Conexiones de red

# Conexiones activas
python vol.py -f imagen.raw windows.netscan

# Filtrar conexiones sospechosas
python vol.py -f imagen.raw windows.netscan | grep "ESTABLISHED" | grep -v "127.0.0.1"

Qué buscar en netscan:

• Conexiones ESTABLISHED hacia IPs externas no conocidas o rangos de IP inusuales.
• Procesos del sistema (como svchost.exe, lsass.exe) con conexiones TCP salientes inesperadas.
• Escucha activa en puertos no estándar (fuera de 80, 443, 53).
• Conexiones a puertos altos (>49152) que podrían indicar túneles C2.
• Patrones de comunicación periódica (beaconing) que sugieren un C2 callback.

# Exportar para análisis en Wireshark
python vol.py -f imagen.raw windows.netscan > netscan_full.txt
# Filtrar solo conexiones salientes a internet
grep "ESTABLISHED" netscan_full.txt | grep -v -E "127\.0\.0\.1|0\.0\.0\.0|::"

4. Detección de malware con malfind

# Buscar código inyectado en procesos
python vol.py -f imagen.raw windows.malfind

# Extraer memoria del proceso sospechoso
python vol.py -f imagen.raw windows.memmap --pid 1234 --dump-dir ./evidence/

malfind busca regiones de memoria con permisos de ejecución que contienen código sospechoso. Es el plugin más importante para detectar amenazas fileless.

Cómo funciona malfind:

• Escanea las regiones de memoria virtual de cada proceso buscando páginas con permisos PAGE_EXECUTE_READWRITE (RWX).
• Cuando encuentra una región ejecutable que no está mapeada a un archivo en disco, la marca como sospechosa.
• Extrae los primeros bytes de cada región y busca patrones conocidos de shellcode, cabeceras PE y firmas de frameworks de explotación como Metasploit.

Ejemplo práctico de análisis:

# Buscar inyecciones y volcar las sospechosas
python vol.py -f imagen.raw windows.malfind --dump-dir ./malfind_evidence/

# Verificar los volúmenes extraídos con YARA
yara -r rules/malware.yar ./malfind_evidence/

# Identificar qué proceso contiene la inyección
python vol.py -f imagen.raw windows.malfind | grep -i "Pid"

Señales de alerta en malfind:

• Regiones con PAGE_EXECUTE_READWRITE en procesos de usuario normales (Word, Excel, Chrome).
• Cabeceras MZ (PE) en memoria no mapeada a un archivo.
• Código que contiene llamadas a VirtualAlloc, WriteProcessMemory, CreateRemoteThread (técnicas clásicas de inyección).
• Entropía alta en las primeras decenas de bytes (indicativo de shellcode cifrado o empaquetado).

5. Recuperación de credenciales

# Hashes de contraseñas
python vol.py -f imagen.raw windows.hashdump

# LSA secrets
python vol.py -f imagen.raw windows.lsadump

Qué revelan estas herramientas:

• hashdump extrae los hashes NTLM de todas las cuentas del sistema, incluyendo la cuenta de administrador local. Si el atacante logró dump these hashes (mediante mimikatz o similar), puede usarlos para movimiento lateral con la técnica Pass-the-Hash sin conocer la contraseña original.
• lsadump extrae los LSA secrets, que contienen contraseñas de cuentas de servicio, credenciales guardadas y claves de cifrado del sistema.

# Buscar credenciales en memoria de procesos de autenticación
python vol.py -f imagen.raw windows.hashdump

# Comparar con hashes conocidos (hashcat)
hashcat -m 1000 hash_dump.txt wordlist.txt

Indicadores de compromiso en credenciales:

• Hashes de cuentas que normalmente no inician sesión interactivamente.
• LSA secrets que contienen contraseñas de cuentas de servicio de dominio.
• Procesos de autenticación (lsass.exe) con memoria modificada o inyecciones sospechosas.

6. Comandos ejecutados

python vol.py -f imagen.raw windows.cmdline

Busca comandos con certutil, bitsadmin, powershell o cmd que indiquen descargas de malware o ejecución remota.

Detectando rootkits

La comparación entre pslist y psscan es la técnica más efectiva:

# Listado normal
python vol.py -f imagen.raw windows.pslist > pslist.txt

# Búsqueda profunda en memoria
python vol.py -f imagen.raw windows.psscan > psscan.txt

# Procesos ocultos
comm -23 <(sort pslist.txt) <(sort psscan.txt)

Los rootkits eliminan sus procesos del listado normal pero no pueden borrar las entradas de la memoria física que psscan analiza.

Script de automatización

#!/bin/bash
# Script de análisis forense automatizado
IMAGE="$1"
OUTPUT_DIR="./forensic_report_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$OUTPUT_DIR"

# Hash de integridad
sha256sum "$IMAGE" > "$OUTPUT_DIR/hash_original.txt"

# Análisis completo
python vol.py -f "$IMAGE" windows.info > "$OUTPUT_DIR/system_info.txt"
python vol.py -f "$IMAGE" windows.pslist > "$OUTPUT_DIR/processes.txt"
python vol.py -f "$IMAGE" windows.netscan > "$OUTPUT_DIR/network.txt"
python vol.py -f "$IMAGE" windows.cmdline > "$OUTPUT_DIR/commands.txt"
python vol.py -f "$IMAGE" windows.malfind > "$OUTPUT_DIR/malware.txt"
python vol.py -f "$IMAGE" windows.hashdump > "$OUTPUT_DIR/credentials.txt"

echo "Análisis completado: $OUTPUT_DIR/"

Cadena de custodia

En investigación forense, la integridad de la evidencia es sagrada:

1. Documentar quién, cuándo y cómo se adquirió la imagen
2. Calcular hash (MD5/SHA256) de la imagen original
3. Analizar con herramientas validadas
4. Documentar cada paso y hallazgo
5. Almacenar evidencia de forma segura

Nunca trabajes sobre la imagen original. Siempre usa copias.

Volatility vs otras herramientas

Volatility 3 vs Volatility 2

Si vienes de Volatility 2, la transición a Volatility 3 puede ser confusa. Aquí las diferencias clave:

Cambios importantes en Volatility 3

• Prefijo de namespace obligatorio: Todos los plugins ahora requieren el prefijo del OS. pslist se convierte en windows.pslist.
• Nuevo sistema de archivos: Volatility 3 usa un sistema de archivos virtual para acceder a la memoria, lo que permite análisis más granular.
• Plugin windows.filescan mejorado: Puede encontrar archivos eliminados que aún residen en memoria con mayor precisión.
• Nuevos plugins: windows.driverscan, windows.handles, windows.registry.hivelist entre otros.
• Mejor soporte para imágenes de máquinas virtuales: VM snapshots, VMware, VirtualBox, Hyper-V.

# En Volatility 2
python volatility pslist -f imagen.raw

# En Volatility 3
python vol.py -f imagen.raw windows.pslist

Recomendación: Si estás empezando, usa directamente Volatility 3. Solo usa Volatility 2 si necesitas plugins específicos que aún no han sido portados.

Cuándo usar Volatility vs otras herramientas

Volatility no es la única opción para análisis forense de memoria. Aquí cuándo usar cada herramienta:

Cuándo NO usar Volatility:

• Cuando solo necesitas adquisición de memoria (usa WinPmem o LiME).
• Cuando el análisis es de disco duro completo (usa Autopsy o FTK).
• Cuando necesitas análisis en tiempo real de procesos ejecutándose (usa Process Hacker o Sysmon).
• Cuando trabajas con contenedores Docker/Kubernetes (herramientas específicas como docker-forensics son más adecuadas).

Caso práctico: Análisis completo de un incidente

Vamos a recorrer un escenario real de análisis forense de memoria paso a paso.

Escenario

Una empresa reporta que un empleado de contabilidad hizo clic en un enlace sospechoso en un correo electrónico. El equipo de SOC detectó tráfico inusual hacia una IP externa. Se tomó una captura de memoria del equipo comprometido.

Paso 1: Identificar el sistema

python vol.py -f empresa_laptop.raw windows.info

Resultado: Windows 10 Pro 21H2, construido 19044. Identificamos la versión del kernel para calibrar los offsets.

Paso 2: Análisis de procesos

python vol.py -f empresa_laptop.raw windows.pslist
python vol.py -f empresa_laptop.raw windows.psscan

Hallazgo: Un proceso svchost.exe con PID 4892 que aparece en psscan pero tiene un padre inusual (explorer.exe en lugar de services.exe).

Paso 3: Conexiones de red del proceso sospechoso

python vol.py -f empresa_laptop.raw windows.netscan | grep "4892"

Hallazgo: El proceso se conecta periódicamente cada 30 segundos a 185.xx.xx.xx:443 — un patrón típico de beaconing C2.

Paso 4: Detectar inyecciones de código

python vol.py -f empresa_laptop.raw windows.malfind --pid 4892

Hallazgo: Tres regiones RWX con cabeceras MZ en memoria, no mapeadas a disco. Shellcode de Metasploit confirmado por análisis con YARA.

Paso 5: Extraer evidencia

python vol.py -f empresa_laptop.raw windows.memmap --pid 4892 --dump-dir ./evidence/
python vol.py -f empresa_laptop.raw windows.hashdump

Resultado: El malware había intentado dump las credenciales NTLM pero fue detectado antes de completar el movimiento lateral.

Paso 6: Cadenas de comandos

python vol.py -f empresa_laptop.raw windows.cmdline

Hallazgo: powershell.exe -enc <base64> ejecutado por el malware, seguido de una descarga con certutil -urlcache -split -f.

Conclusión del caso

El ataque fue un phishing con payload de Metasploit que logró ejecución remota de código, inyección en un proceso legítimo y establecimiento de un canal C2. Gracias al análisis de memoria, se identificó la IP del atacante, la técnica de persistencia y el alcance real del compromiso antes de que se propagara a otros equipos.

Certificaciones que evalúan Volatility

• GCFE (GIAC Certified Forensics Examiner): Análisis forense de Windows, incluyendo memoria volátil
• GCIH (GIAC Certified Incident Handler): Respuesta a incidentes con análisis de memoria
• GCFA (GIAC Certified Forensic Analyst): Análisis forense avanzado
• CHFI (Computer Hacking Forensic Investigator): Investigación forense de hacking

Conclusión

El análisis forense de memoria es una de las habilidades más demandadas en ciberseguridad. Volatility es la herramienta que necesitas dominar para detectar amenazas que evaden todos los controles tradicionales.

La clave: captura la memoria ANTES de apagar la máquina. Una vez apagada, esa evidencia se pierde para siempre.

---

Herramientas relacionadas: Nmap (reconocimiento), Wireshark (análisis de red), TCPDump (captura de tráfico)

Artículos relacionados:

• Respuesta a incidentes: desde la detección hasta la recuperación
• SOC corporativo: cómo defender una empresa en tiempo real