GhostAcademy logo GhostAcademy
ANÁLISIS ACTIVO · MALWARE FORENSE

Análisis Forense
CRIDEX

// cridex.vmem · Windows XP · Volatility · Ejercicio guiado

Fichero cridex.vmem
Sistema WinXP SP3 x86
Herramienta Volatility 2 / 3
Tipo Troyano bancario
Pasos 8 etapas
▼ COMENZAR ANÁLISIS
MÓDULOS:
01
02
03
04
05
06
07
08

cridex.vmem es uno de los casos de estudio más famosos del análisis forense de memoria. Se trata de un volcado de RAM de un sistema Windows XP infectado con el malware Cridex: un troyano bancario, antecesor del conocido Dridex, que se inyecta en procesos legítimos para robar credenciales bancarias y comunicarse con servidores C2.

A lo largo de este ejercicio usarás Volatility (v2 para el análisis principal y v3 como alternativa), bulk_extractor, Wireshark y VirusTotal para reconstruir toda la cadena de infección desde la RAM.

⬇ Fichero de práctica

Descarga el volcado de memoria para seguir este ejercicio. El ZIP contiene cridex.vmem listo para usar con Volatility.

📦 cridexmemdump.zip 🔗 SourceForge ⚠️ Usar en VM aislada
DESCARGAR cridex.vmem
⚠️Aviso de seguridad

Este fichero contiene un volcado de RAM con malware real. Trabaja siempre dentro de una máquina virtual aislada sin acceso a red o con red restringida. No ejecutes los binarios extraídos fuera de un entorno controlado.

01

Identificación del Sistema

🎯 Objetivo Confirmar el perfil del sistema operativo del volcado. En Volatility 2 es necesario especificar el profile; en la versión 3 la herramienta lo detecta automáticamente.

Empezamos siempre identificando el sistema operativo y su arquitectura. En Volatility 2 (que es el que produce la mayoría de capturas de este ejercicio) usamos imageinfo:

PowerShell / Terminal — Volatility 2
$ vol.py -f cridex.vmem imageinfo

En Volatility 3 (instalación Windows con vol.exe) no necesitas especificar el profile:

PowerShell — Volatility 3
PS> vol.exe -f cridex.vmem windows.info
Captura 01 — imageinfo output
Imageinfo output
🔍Hallazgo
  • El Suggested Profile indica WinXPSP3x86 — Windows XP Service Pack 3, 32 bits.
  • El huso horario es UTC-0400. Deberás tenerlo en cuenta al analizar marcas temporales.
  • Anota el profile exacto; lo necesitarás en todos los comandos de Volatility 2: --profile=WinXPSP3x86
📝Tarea del alumno
  1. Ejecuta el comando y localiza el campo Suggested Profile(s).
  2. ¿Cuántos profiles sugiere Volatility? ¿Qué implica que haya más de uno?
  3. Apunta el huso horario del sistema. ¿Cuántas horas de diferencia hay con UTC?
02

Análisis de Procesos — El «Árbol Genealógico»

🎯 Objetivo Identificar procesos activos en el momento del volcado y detectar relaciones padre-hijo anómalas que delaten la presencia del malware.

El primer paso forense siempre es ver qué se estaba ejecutando. pslist muestra los procesos en formato tabla ordenados por PID; pstree muestra la jerarquía de procesos, lo que es crítico para detectar anomalías.

Volatility 2
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 pslist
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 pstree
Volatility 3
PS> vol.exe -f cridex.vmem windows.pstree
Captura 02 — pslist: procesos ordenados por fecha de inicio
pslist output
🚨Anomalía detectada
  • reader_sl.exe (PID 1640) aparece como proceso hijo de explorer.exe (PID 1484).
  • reader_sl.exe es el proceso del Adobe Acrobat Speed Launcher. Aunque es legítimo, nunca debería ser hijo de explorer.exe de forma persistente y sin interacción del usuario.
  • El momento de inicio de los dos procesos es sospechosamente similar, lo que sugiere que uno lanzó al otro.
📝Tarea del alumno
  1. ¿Qué PID tiene explorer.exe? ¿Y reader_sl.exe?
  2. Busca en la salida de pstree la relación padre-hijo entre ambos procesos y descríbela.
  3. ¿Qué otros procesos te parecen inusuales? Justifica tu respuesta.
03

Análisis de Conexiones de Red

🎯 Objetivo Cridex es un troyano que necesita comunicarse con su servidor de Comando y Control (C2). Vamos a identificar conexiones activas y los procesos que las generan.

En sistemas Windows XP, Volatility ofrece dos plugins de red: connections muestra conexiones TCP activas en el momento del volcado; connscan hace un escaneo más profundo del pool de memoria para recuperar también conexiones ya cerradas.

Volatility 2 — Conexiones activas y terminadas
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 connections
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 connscan
Volatility 3 (usar netstat o netscan)
PS> vol.exe -f cridex.vmem windows.netstat
Captura 03 — connscan: IPs remotas asociadas a explorer.exe
connscan output
🔍IPs C2 identificadas
  • Se descubren dos IPs asociadas al proceso explorer.exe (PID 1484):
  • 41.168.5.140 — comunicación activa por puerto 8080 (típico de botnets)
  • 125.19.103.198 — segunda IP de C2

Un proceso de sistema como explorer.exe estableciendo conexiones salientes hacia IPs externas por el puerto 8080 es una alerta roja inmediata.

Para saber si estas IPs tienen reputación maliciosa, las verificamos en servicios de inteligencia de amenazas como IPVoid o AbuseIPDB:

Captura 04 — Reputación 41.168.5.140
IPVoid 41.168.5.140
Captura 05 — Reputación 125.19.103.198
IPVoid 125.19.103.198
🔍Resultado reputación
  • La IP 125.19.103.198 aparece en al menos una lista negra de amenazas.
  • La presencia en listas negras confirma que estas IPs son servidores C2 conocidos.

Volviendo a Volatility, también podemos examinar los sockets a la escucha del sistema:

Volatility 2 — Sockets
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 sockets
Captura 11_2 — Sockets: PID 1484 escuchando en puerto 1038
Sockets output
📝Tarea del alumno
  1. ¿A qué puertos remotos se conecta explorer.exe? ¿Son puertos inusuales para este proceso?
  2. Busca las IPs encontradas en IPVoid o AbuseIPDB. ¿En cuántas listas negras aparecen?
  3. ¿Qué puerto usa explorer.exe como socket a la escucha? ¿Para qué podría servir?
04

Extracción de Tráfico de Red con bulk_extractor

🎯 Objetivo Extraer el tráfico de red embebido en el volcado de memoria y analizarlo con Wireshark para identificar comunicaciones HTTP, IPs adicionales y rutas de C2.

bulk_extractor es una herramienta que escanea un fichero binario (incluyendo volcados de memoria) buscando artefactos como paquetes de red, emails, URLs, números de tarjeta, etc. Puede reconstruir un PCAP a partir de la RAM:

bulk_extractor — Extracción de PCAP
$ bulk_extractor -o output_dir cridex.vmem
# El PCAP se genera en output_dir/packets.pcap
Captura 06 — bulk_extractor en ejecución
bulk_extractor

Una vez generado el PCAP, lo abrimos en Wireshark para analizarlo visualmente:

Captura 07 — Wireshark: protocolos identificados en el tráfico
Wireshark protocoles
Captura 08 — Wireshark: IPs activas en la captura
Wireshark IPs
🔍Nuevas IPs descubiertas
  • El tráfico capturado revela IPs adicionales no visibles desde Volatility directamente.
  • 211.44.250.173 — nueva IP sospechosa
  • 190.81.107.70 — segunda IP adicional
Captura 09 — Reputación 211.44.250.173
IPVoid 211.44.250.173
Captura 10 — Reputación 190.81.107.70
IPVoid 190.81.107.70
🔍Resultado reputación IPs adicionales
  • Ambas IPs aparecen en listas negras. La 211.44.250.173 aparece en tres listas negras.

Filtrando el tráfico de Wireshark por la IP más relevante, descubrimos actividad HTTP específica:

Captura 11 — HTTP POST hacia la ruta de C2
Wireshark POST request
🚨Ruta de C2 identificada
  • Se detecta un HTTP POST hacia la IP 41.168.5.140.
  • La ruta del POST es: /zb/v_01_a/in/ — ruta característica del malware Cridex.
  • Las conexiones se realizan al puerto 1038.
📝Tarea del alumno
  1. Abre el PCAP en Wireshark y usa el filtro http.request.method == "POST". ¿Qué encuentras?
  2. ¿Qué protocolo predomina en el tráfico? ¿Tiene sentido para un troyano bancario?
  3. Verifica las cuatro IPs encontradas en IPVoid. ¿Cuál tiene peor reputación?
  4. ¿Qué información podría estar enviando el malware en el POST a /zb/v_01_a/in/?
05

Detección de Código Inyectado — malfind

🎯 Objetivo Cridex utiliza Code Injection para ocultarse dentro de procesos legítimos. El plugin malfind detecta regiones de memoria con permisos RWX (lectura, escritura, ejecución) que suelen indicar código inyectado.

La técnica de inyección de código consiste en escribir código malicioso en el espacio de memoria de un proceso legítimo (como explorer.exe) para que se ejecute bajo su identidad y evite detección. La señal de alarma es encontrar páginas de memoria con permisos PAGE_EXECUTE_READWRITE — algo anormal en condiciones normales.

Volatility 2
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 malfind
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 malfind -D dump/
# -D dump/ extrae las regiones sospechosas a disco
Volatility 3
PS> vol.exe -f cridex.vmem windows.malfind
Captura 12 — malfind: procesos afectados
malfind list
Captura 13 — malfind: hex dump con cabecera MZ
malfind hex dump
🚨Procesos con código inyectado
  • csrss.exe — proceso del subsistema de cliente/servidor de Windows
  • winlogon.exe — proceso de inicio de sesión de Windows
  • explorer.exe (PID 1484) — el escritorio de Windows
  • reader_sl.exe (PID 1640) — el proceso sospechoso que ya conocemos

En el hex dump, fíjate en los primeros bytes: 4D 5A (caracteres MZ) es la firma de un ejecutable PE (Portable Executable). Haber encontrado un ejecutable completo oculto dentro de la memoria de otro proceso confirma la inyección.

Ahora extraemos los volcados de malfind a disco y los analizamos con file para identificar cuáles son ejecutables:

Captura 14 — Comando file sobre los volcados
file command output
Captura 15 — MD5 de los ejecutables extraídos
MD5 hashes

Subimos los hashes MD5 a VirusTotal para confirmar su naturaleza maliciosa:

Captura 16 — VirusTotal: volcado de explorer.exe
VirusTotal explorer
Captura 17 — VirusTotal: volcado de reader_sl.exe
VirusTotal reader_sl
🔍Confirmación — Malware identificado
  • La inmensa mayoría de motores antivirus de VirusTotal identifican ambos ejecutables como malware.
  • Varios motores los etiquetan específicamente como Cridex.
  • Procesos infectados confirmados: explorer.exe (PID 1484) y reader_sl.exe (PID 1640).
📝Tarea del alumno
  1. ¿Qué significa que una región de memoria tenga permisos PAGE_EXECUTE_READWRITE? ¿Por qué es sospechoso?
  2. ¿Qué es la firma MZ (4D 5A)? ¿Qué implica encontrarla al principio de una región inyectada?
  3. Calcula el MD5 de los ficheros extraídos con md5sum y busca los hashes en VirusTotal.
  4. ¿Cuántos motores detectan cada fichero? ¿Qué familia de malware identifican?
06

Análisis de Handles, Mutants y Persistencia

🎯 Objetivo Los mutexes (objetos de exclusión mutua) son «marcas» que el malware crea para evitar ejecutarse dos veces. Identificar estos mutants nos da indicadores únicos del malware (IOCs). También analizamos cómo se asegura la persistencia.

Empezamos examinando los handles del proceso sospechoso reader_sl.exe:

Volatility 2 — Handles de reader_sl.exe (PID 1640)
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 handles -p 1640 -t Mutant,Event
Captura 19 — Handles de reader_sl.exe: Mutants y Events
Handles reader_sl
🔍Mutants sospechosos en reader_sl.exe
  • Se observan objetos Event y Mutant que comienzan por el prefijo XM
  • Específicamente: XM00000668 y XMR8149A9A8
  • Estos nombres con prefijo XM son IOCs (Indicadores de Compromiso) asociados a Cridex.

Ahora analizamos explorer.exe buscando las mismas estructuras:

Volatility 2 — Handles de explorer.exe (PID 1484)
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 handles -p 1484 -t Mutant
Captura 20 — Mutants en explorer.exe
Explorer handles Mutant
Captura 21 — Mutant _SHuassist.mtx
SHuassist mutant
Captura 22 — Más Mutants XM en explorer.exe
More mutants
🔍IOCs adicionales en explorer.exe
  • Se identifica el Mutant _SHuassist.mtx — otro IOC conocido de Cridex.
  • Múltiples Mutants con prefijo XM confirman la presencia del mismo malware.
Captura 23 — Eventos relacionados con los Mutants
Events related to mutants

Persistencia — Mecanismo de arranque

Para asegurar que el malware sobreviva a un reinicio, Cridex utiliza el ejecutable reader_sl.exe como mecanismo de persistencia (probablemente via clave de registro Run):

Captura 24 — Identificación del mecanismo de persistencia
Persistence mechanism

Localizamos el fichero en el sistema de ficheros del volcado con filescan y lo extraemos:

Volatility 2 — Localizar y extraer reader_sl.exe
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 filescan | grep -i reader_sl
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 dumpfiles -Q [OFFSET] -D dump/
Captura 25 — filescan: localización de reader_sl.exe en memoria
filescan reader_sl
Captura 26 — VirusTotal sobre reader_sl.exe extraído (detectado como Artemis)
VirusTotal reader_sl file
🔍reader_sl.exe — Falso Adobe Reader Speed Launcher
  • El fichero extraído es reconocido por varios motores como Artemis: un browser hijacker / adware que redirige a páginas maliciosas y descarga componentes adicionales.
  • Esto encaja con el comportamiento de Cridex: instala un componente secundario como persistencia disfrazado de software legítimo.
📝Tarea del alumno
  1. ¿Para qué sirve un mutex en programación? ¿Por qué los usa el malware?
  2. Anota todos los nombres de Mutant encontrados — son IOCs que podrías buscar en otras máquinas comprometidas.
  3. Busca en el registro HKCU\Software\Microsoft\Windows\CurrentVersion\Run (mediante el plugin printkey) si reader_sl.exe está listado.
  4. ¿Cuál es la diferencia entre los plugins filescan y dumpfiles? ¿Cuándo usarías cada uno?
07

Volcado de Memoria y Análisis de Strings

🎯 Objetivo Extraer el espacio de memoria completo de los procesos infectados y buscar cadenas de texto que revelen URLs, IPs, rutas y configuración del malware.

Con memdump extraemos toda la memoria del proceso a un fichero binario. Luego usamos strings para extraer cadenas de texto legibles, y grep para filtrar las más relevantes:

Volatility 2 — Volcado completo de ambos procesos
$ mkdir -p memdumps
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 memdump -p 1484 -D memdumps/
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 memdump -p 1640 -D memdumps/
Captura 27 — memdump de los procesos infectados
memdump

Análisis con strings sobre el volcado de explorer.exe:

Strings sobre explorer.exe (PID 1484)
$ strings memdumps/1484.dmp | more
$ strings memdumps/1484.dmp | grep -i "/zb/"
$ strings memdumps/1484.dmp | grep -i "41.168"
Captura 28 — Strings: primeros resultados de explorer.exe
strings explorer first
Captura 29 — Strings: URLs y emails en explorer.exe
strings explorer URLs
🔍Hallazgos en strings de explorer.exe
  • Se confirma la ruta POST /zb/v_01_a/in/ que vimos en Wireshark.
  • Se encuentran URLs, direcciones de correo y otras cadenas de interés.
  • Aparecen rutas locales sospechosas y la IP C2 ya conocida.
Captura 30 — Rutas locales sospechosas
Local paths
Captura 31 — IP C2 en strings
C2 IP in strings

Usando grep con la carpeta sospechosa encontrada, obtenemos más artefactos:

Captura 32 — grep sobre carpeta sospechosa: nueva IP y cp.php
grep suspicious folder
Captura 33 — grep sobre todas las IPs conocidas
grep all IPs
💡 Nota interesante

Si subimos el volcado completo del proceso a VirusTotal, lo detectará como limpio. Esto es porque los volcados memdump incluyen la memoria legítima del proceso mezclada con el código inyectado, diluyendo las firmas. Los fragmentos específicos extraídos por malfind son más concentrados y por eso se detectan.

Captura 34 — Volcado explorer.exe: limpio en VirusTotal
VT clean explorer dump
Captura 35 — Volcado reader_sl.exe: limpio en VirusTotal
VT clean reader_sl dump

Sin embargo, el análisis de strings sobre el proceso reader_sl.exe (PID 1640) revela masivamente su naturaleza de adware:

Captura 36 — Strings reader_sl.exe: multitud de URLs
strings reader_sl URLs
Captura 37 — Más URLs de adware en reader_sl.exe
strings reader_sl more URLs
Captura 38 — IP y ruta C2 confirmadas en reader_sl.exe
C2 path in reader_sl
Captura 39 — Más referencias a C2 en reader_sl.exe
More C2 in reader_sl
🔍Hallazgos en strings de reader_sl.exe
  • Centenares de URLs de dominio diverso confirman el componente adware (Artemis).
  • La IP 41.168.5.140 y la ruta /zb/v_01_a/in/ aparecen también aquí.
  • El proceso reader_sl.exe actúa tanto como dropper/backdoor (componente Cridex) como adware (redireccionador de navegador).
📝Tarea del alumno
  1. Usa strings memdumps/1484.dmp | grep -i "http". ¿Cuántas URLs encuentras? ¿Hay algún patrón?
  2. Busca con grep referencias a archivos .php. ¿Encuentras cp.php u otros? ¿Para qué podría usarse?
  3. ¿Por qué un volcado memdump de un proceso infectado puede ser detectado como «limpio» por VirusTotal mientras que los fragmentos extraídos por malfind sí se detectan?
  4. ¿Qué diferencia conceptual hay entre el comportamiento de explorer.exe (Cridex bancario) y reader_sl.exe (Artemis adware)?
08

Generación de la Línea Temporal

🎯 Objetivo Reconstruir la secuencia de eventos de la infección ordenados cronológicamente para entender cuándo y en qué orden ocurrió todo.

El plugin timeliner recopila todas las marcas temporales del volcado (procesos, ficheros, entradas de registro, conexiones...) y las agrega en un único fichero cronológico. El formato de salida es compatible con mactime de The Sleuth Kit:

Volatility 2 — Generación de línea temporal
$ vol.py -f cridex.vmem --profile=WinXPSP3x86 timeliner --output=body --output-file=largetimeliner.txt
$ mactime -b largetimeliner.txt -d -z UTC-0400 | grep reader_sl
Captura 40 — timeliner: generación del fichero de línea temporal
timeliner output
Captura 41 — mactime: eventos de reader_sl.exe filtrados
mactime reader_sl
🔍Línea temporal de la infección
  • mactime permite filtrar por proceso, fichero o extensión para aislar eventos específicos.
  • Puedes ver exactamente cuándo se creó reader_sl.exe, cuándo fue accedido y cuándo se ejecutó.
  • Combina esta información con los timestamps de los procesos de pslist para reconstruir el orden de infección.
📝Tarea del alumno
  1. Ejecuta timeliner y busca el evento de creación de reader_sl.exe. ¿Cuándo se creó?
  2. Filtra también por explorer.exe y compara los timestamps. ¿Qué proceso fue primero?
  3. ¿Hay algún evento de modificación del registro cerca del momento de infección? Usa grep -i "\\Run\\"
  4. Construye una línea temporal narrativa de la infección con al menos 5 eventos ordenados cronológicamente.

🏁 Resumen del Análisis — Conclusiones

Tras completar los 8 pasos, hemos reconstruido la cadena de infección completa del volcado cridex.vmem:

Fase Técnica Herramienta Hallazgo
Infección Code Injection malfind MZ header en explorer.exe PID 1484
Persistencia Proceso hijo falso pstree / filescan reader_sl.exe PID 1640 hijo de explorer
C2 activo HTTP POST puerto 8080 connscan + Wireshark 41.168.5.140 → /zb/v_01_a/in/
C2 adicional Múltiples IPs bulk_extractor + IPVoid 125.19.103.198 / 211.44.250.173
IOCs Mutex Anti-doble ejecución handles XM00000668 / _SHuassist.mtx
Identificación Hash + VirusTotal md5sum + VT Familia: Cridex / Artemis

Técnica usada por Cridex: El malware se inyectó en el proceso legítimo explorer.exe usando secciones de memoria con permisos RWX. Desde allí creó un proceso hijo falso (reader_sl.exe) para asegurar la persistencia, y mantuvo conexiones HTTP activas con servidores C2 para recibir órdenes y exfiltrar datos bancarios robados.


📌 IOCs — Indicadores de Compromiso

IP C2 Principal
41.168.5.140:8080
IP C2 Secundaria
125.19.103.198
IP Adicional #1
211.44.250.173
IP Adicional #2
190.81.107.70
Ruta HTTP POST
/zb/v_01_a/in/
Mutex #1
XM00000668
Mutex #2
XMR8149A9A8
Mutex #3
_SHuassist.mtx
Proceso malicioso
reader_sl.exe (PID 1640)
Proceso inyectado
explorer.exe (PID 1484)
Puerto C2
1038 / 8080
Fichero PHP C2
cp.php