Volcado de Memoria RAM en Kali Linux

https://www.onlinetis.com/es/

Volcado de Memoria RAM en Kali Linux

Capturar la memoria volátil (RAM) en Kali Linux es un paso crítico en la informática forense. Esto permite recuperar contraseñas, claves de cifrado y procesos que desaparecen al apagar el equipo.

Aquí tienes una guía rápida sobre las herramientas más efectivas y cómo usarlas:

1. AVML (Acquisition Tool for Linux)

Desarrollada por Microsoft, es actualmente una de las opciones más sencillas y fiables porque es un archivo binario estático que no requiere instalación de dependencias en el sistema objetivo (lo cual evita contaminar la evidencia).

Pasos para usar AVML:

Descarga el binario desde el repositorio oficial de GitHub.
Dale permisos de ejecución: chmod +x avml.
Ejecuta la captura:
Bash
```
sudo ./avml imagen_memoria.raw
```

2. LiME (Linux Memory Extractor)

Es un clásico. Se utiliza como un módulo del kernel (LKM), lo que le permite tener un impacto mínimo en el sistema.

Cómo usar LiME:

Instalación: sudo apt install lime-forensics-dkms

Carga del módulo: Al cargar el módulo, se especifica la ruta de salida y el formato.

Bash

sudo insmod /lib/modules/$(uname -r)/updates/dkms/lime.ko "path=./memoria.lime format=raw"

Verificación: Una vez terminado, descarga el módulo: sudo rmmod lime.

3. LinPMem

Es parte del proyecto Rekall. Es muy potente y permite volcar la memoria en diferentes formatos.

Comando básico:

Bash

sudo ./linpmem-2.1.post4 -o memoria_dump.aff4

¿Qué hacer después del volcado? (Análisis)

Una vez que tienes el archivo (ej. memoria.raw), el estándar de oro para analizarlo es Volatility 3.

Ejemplo de análisis con Volatility:

Para listar los procesos que estaban abiertos en el momento del volcado:

Bash

python3 vol.py -f imagen_memoria.raw linux.pslist

Notas de seguridad y buenas prácticas

Uso de dispositivos externos: Siempre guarda el volcado en un disco duro externo o una unidad USB, nunca en el mismo disco duro del sistema que estás investigando.
Hash de integridad: Inmediatamente después de crear el volcado, genera un hash para asegurar que la evidencia no sea alterada:
sha256sum imagen_memoria.raw > hash.txt

Instalar Volatility 3 en Kali Linux es un poco diferente a la versión antigua (v2.7), ya que ahora corre nativamente en Python 3 y es mucho más modular.

Sigue estos pasos para dejarlo listo:

1. Clonar el repositorio y dependencias

Primero, necesitamos el código fuente y las librerías de Python necesarias para que Volatility pueda interpretar los diferentes sistemas de archivos y capas de memoria.

Bash
# Clonar el repositorio oficial
git clone https://github.com/volatilityfoundation/volatility3.git
cd volatility3

# Instalar dependencias necesarias
pip3 install -r requirements.txt

Dependencias recomendadas:

Para un análisis completo, asegúrate de tener instaladas estas librerías adicionales que ayudan con la compresión y el escaneo de firmas:

pefile: Para analizar archivos ejecutables de Windows.
yara-python: Para escaneo de malware mediante reglas YARA.
capstone: Para desensamblado de código.

2. El problema de los "Symbol Tables" (Símbolos)

A diferencia de Windows, donde Volatility puede descargar los símbolos automáticamente, en Linux necesitas un archivo de símbolos que coincida exactamente con el kernel de la muestra de memoria que capturaste.

Si analizas una máquina Windows: Volatility 3 descargará los perfiles sobre la marcha (si tienes internet).
Si analizas una máquina Linux: Deberás generar un ISF (Intermediate Symbol File) usando la herramienta dwarf2json.

3. Comandos básicos de análisis

Una vez dentro de la carpeta de volatility3, puedes empezar a interrogar tu archivo .raw o .img.

Identificar información del sistema

Este es siempre el primer paso para confirmar que el volcado es legible:

Bash

python3 vol.py -f /ruta/a/tu/memoria.raw banner.Banner

Listar procesos (PsList)

Muestra los procesos que estaban activos, su PID (ID de proceso) y el proceso padre:

Bash

python3 vol.py -f /ruta/a/tu/memoria.raw linux.pslist

Ver conexiones de red

Muy útil para detectar troyanos o exfiltración de datos:

Bash

python3 vol.py -f /ruta/a/tu/memoria.raw linux.netstat

4. Un truco de "pro" en Kali

Si no quieres estar entrando siempre a la carpeta del git, puedes crear un alias en tu archivo .bashrc o .zshrc:

Abre el archivo: nano ~/.zshrc
Añade al final: alias vol3='python3 /ruta/completa/a/volatility3/vol.py'
Guarda y reinicia la terminal: source ~/.zshrc

Ahora podrás usar simplemente el comando vol3 desde cualquier carpeta.

Para interpretar los resultados de Volatility 3, lo más importante es saber qué columnas buscar y qué valores "gritan" que algo anda mal.

Cuando ejecutas un comando como linux.pslist o linux.psscan, te encontrarás con una tabla. Aquí te explico cómo leerla como un experto en forense:

1. El Análisis de Procesos (`pslist`)

Busca anomalías en estas columnas:

Columna	Qué buscar (Red Flags)
PID / PPID	Un proceso con un Parent PID que no tiene sentido (ej. un navegador cuyo padre es un proceso del sistema crítico).
Name	Procesos con nombres ligeramente mal escritos (ej. `sshd` escrito como `shhd`) o procesos legítimos corriendo desde rutas temporales como `/tmp`.
Threads	Un número inusualmente alto de hilos en un proceso pequeño puede indicar inyección de código.

Tip Pro: Si un proceso aparece en psscan pero no en pslist, es una señal técnica de que el proceso intentó ocultarse manipulando las listas del kernel (un síntoma clásico de un Rootkit).

2. Conexiones de Red (`netstat`)

Aquí es donde atrapas al atacante "hablando por teléfono".

Foreign Address: Busca IPs que no pertenezcan a tu red local o servicios conocidos.
State: ESTABLISHED: Si ves una conexión establecida en un puerto extraño (ej. 4444, 5555 o puertos altos aleatorios) asociada a un proceso como bash o python, probablemente tienes una Reverse Shell.
Listening Ports: Busca puertos abiertos que no deberían estar ahí en un servidor estándar.

3. Extracción de archivos sospechosos

Si encuentras un proceso que te da mala espina (digamos que su PID es 1234), puedes "sacarlo" de la memoria al disco para analizarlo con un antivirus o en VirusTotal:

Bash

python3 vol.py -f memoria.raw -o ./salida linux.elffp.ElfFP --pid 1234

Esto creará un archivo ejecutable basado en lo que había en la RAM.

4. Búsqueda de Inyecciones de Código (`malfind`)

Este es el comando "mágico" para encontrar malware persistente:

Bash

python3 vol.py -f memoria.raw linux.malfind

¿Qué buscar aquí?

Si el resultado muestra secciones de memoria con permisos Read/Write/Execute (RWX), es casi seguro que hay código inyectado. El malware necesita esos permisos para ejecutarse y modificarse a sí mismo en tiempo real.

¿Cómo proceder ahora?

Para darte una ayuda más precisa, ¿tienes algún resultado de un comando que te parezca extraño? Puedes copiar y pegar aquí una línea del pslist o netstat (borrando IPs privadas si prefieres) y la analizamos juntos.

Vamos a crear un Script de Triage Rápido. La idea es que, en lugar de escribir cada comando de Volatility uno por uno, el script ejecute los análisis más importantes automáticamente y guarde todo en una carpeta organizada.

Copia este código en un archivo llamado analisis_forense.sh en tu Kali Linux:

Bash
#!/bin/bash

# Configuración básica
MEM_IMAGE=$1
OUTPUT_DIR="analisis_$(date +%Y%m%d_%H%M%S)"

if [ -z "$1" ]; then
    echo "Uso: ./analisis_forense.sh <ruta_de_la_memoria.raw>"
    exit 1
fi

mkdir -p $OUTPUT_DIR
echo "[+] Iniciando análisis forense en: $OUTPUT_DIR"

# 1. Información del sistema
echo "[*] Extrayendo información del banner..."
python3 vol.py -f $MEM_IMAGE banner.Banner > $OUTPUT_DIR/01_banner.txt

# 2. Listado de procesos
echo "[*] Listando procesos (pslist)..."
python3 vol.py -f $MEM_IMAGE linux.pslist > $OUTPUT_DIR/02_procesos.txt

# 3. Conexiones de red
echo "[*] Revisando conexiones de red..."
python3 vol.py -f $MEM_IMAGE linux.netstat > $OUTPUT_DIR/03_red.txt

# 4. Módulos del kernel (Busca Rootkits)
echo "[*] Listando módulos del kernel (lsmod)..."
python3 vol.py -f $MEM_IMAGE linux.lsmod > $OUTPUT_DIR/04_modulos.txt

# 5. Escaneo de Malware (Malfind)
echo "[*] Buscando inyecciones de código sospechosas..."
python3 vol.py -f $MEM_IMAGE linux.malfind > $OUTPUT_DIR/05_malware.txt

echo "[+] ¡Análisis completado! Revisa la carpeta $OUTPUT_DIR"

Cómo usar tu nuevo script:

Dale permisos de ejecución:
chmod +x analisis_forense.sh
Ejecútalo pasando tu imagen de memoria:
./analisis_forense.sh mi_volcado.raw

¿En qué fijarte primero al leer los resultados?

Una vez que el script termine, abre el archivo 03_red.txt. Si ves una dirección IP externa conectada a un proceso como /usr/bin/python3 o /bin/bash, es la "pistola humeante" (smoking gun). El atacante está dentro en ese preciso momento.

Un detalle técnico importante:

Para que los comandos de Linux funcionen en Volatility 3, necesitas tener el archivo de símbolos (Symbol Table) adecuado para el kernel de la máquina capturada. Si el script te da errores de "Symbol table not found", es porque necesitamos construir el perfil de esa versión específica de Linux.

Este es el paso donde la mayoría de la gente se detiene porque puede ser un poco técnico, pero es lo que separa a un principiante de un profesional de la informática forense.

Volatility 3 necesita saber la "forma" del kernel de Linux que estás analizando (estructuras de datos, variables, etc.). Para ello, usa archivos ISF (Intermediate Symbol File) en formato JSON.

Paso 1: Instalar dwarf2json

Esta es la herramienta oficial de Volatility para convertir símbolos de depuración en el formato que el programa entiende.

Instala Go (lenguaje necesario para compilarlo):
sudo apt install golang-go

Descarga y compila dwarf2json:

Bash

git clone https://github.com/volatilityfoundation/dwarf2json.git
cd dwarf2json
go build

Paso 2: Obtener los símbolos del sistema objetivo

Aquí hay dos escenarios:

Escenario A: Tienes acceso a la máquina viva (o una idéntica):
Debes buscar el archivo de símbolos (vmlinux) y la información de tipos (System.map). Normalmente están en /boot/.
Escenario B: Solo tienes el volcado:
Tendrás que descargar el paquete de símbolos (dbgsym) que coincida exactamente con la versión del kernel del volcado.

Paso 3: Generar el archivo JSON

Una vez que tienes el archivo vmlinux (que contiene los datos DWARF), ejecutas:

Bash

./dwarf2json linux --elf /ruta/a/vmlinux > mi_perfil_linux.json

Paso 4: Ubicar el archivo en Volatility

Para que Volatility 3 lo reconozca automáticamente:

Copia el archivo .json generado a la carpeta:
volatility3/volatility3/framework/symbols/linux/
¡Listo! La próxima vez que ejecutes tu script de triage, Volatility encontrará el perfil y podrá "leer" la memoria sin errores.

Resumen de flujo de trabajo

Captura con AVML o LiME.
Genera el JSON con dwarf2json (si no lo tienes ya).
Analiza con tu script de triage.

Para identificar la versión del kernel sin tener los símbolos todavía, usaremos la técnica de "fuerza bruta" con el comando strings. Esto es como buscar una aguja en un pajar, pero con los filtros adecuados es muy efectivo.

1. Encontrar la versión del Kernel

Ejecuta este comando sobre tu archivo de volcado (por ejemplo, memoria.raw):

Bash

strings memoria.raw | grep "Linux version" | head -n 1

Lo que verás será algo como esto:

Linux version 6.1.0-kali7-amd64 (devel@kali.org) (gcc (Debian 12.2.0-14) 12.2.0) #1 SMP PREEMPT_DYNAMIC...

2. Descargar los símbolos (Debian/Kali)

Si tu volcado es de una máquina Kali o Debian, no necesitas compilar nada manualmente la mayoría de las veces. Puedes buscar el paquete de símbolos oficial:

Busca el paquete exacto:
sudo apt update && apt-search linux-image-$(uname -r)-dbg
(Nota: Cambia $(uname -r) por la versión que encontraste en el paso anterior si estás en una máquina distinta).
Instálalo:
sudo apt install linux-image-6.1.0-kali7-amd64-dbg (ejemplo).

Los archivos de símbolos aparecerán en /usr/lib/debug/boot/vmlinux-6.1.0-kali7-amd64. Ese es el archivo que debes pasarle a dwarf2json como vimos antes.

3. ¿Y si es un Kernel personalizado?

Si el comando strings no te da una respuesta clara, puedes intentar buscar el "Banner" con Volatility, aunque a veces falla si no tiene el perfil:

Bash

python3 vol.py -f memoria.raw banner.Banner

Resumen de la "Hoja de Ruta" Forense:

Paso	Herramienta	Resultado
Identificar	`strings` / `grep`	Versión exacta del Kernel.
Obtener	`apt install ...-dbg`	Archivo `vmlinux` con símbolos.
Convertir	`dwarf2json`	Archivo `.json` para Volatility.
Analizar	`vol.py`	Procesos, Red, Malware.

Siguiente paso sugerido:

Una vez que tengas el archivo .json en la carpeta de símbolos de Volatility, el análisis será fluido.

Al analizar la salida de linux.netstat en Volatility, no solo buscamos conexiones, sino comportamientos anómalos. Aquí tienes una lista de "Red Flags" (banderas rojas) que deberían hacerte saltar las alarmas:

1. Conexiones Inversas (Reverse Shells)

El atacante suele forzar a la máquina víctima a conectarse hacia su servidor.

Proceso Sospechoso: Si ves /bin/bash, /bin/sh, python o perl con una conexión de red activa en estado ESTABLISHED.
Dirección Remota: Una IP externa (Foreign Address) conectada a un puerto local que normalmente solo inicia conexiones (como el puerto de un intérprete de comandos).

2. Puertos de "Puerta Trasera" (Backdoors)

Existen puertos que son clásicos en el mundo del hacking. Si los ves en estado LISTEN o ESTABLISHED, investiga de inmediato:

Puerto 4444: El puerto por defecto de Metasploit.
Puertos 31337: Históricamente usado por troyanos (Back Orifice).
Puertos 666x: A veces asociados a canales de IRC utilizados para redes de Botnets (C2).
Puertos aleatorios altos (ej. 53421): Los atacantes suelen usar puertos por encima del 1024 para evitar necesitar privilegios de root al abrir el socket.

3. Beaconing (Señalización)

Si tuvieras varias capturas de memoria o registros de red, buscarías el "Beaconing".

Qué es: El malware "llama a casa" cada cierto tiempo (ej. cada 30 segundos) para recibir órdenes.
En Volatility: Fíjate si hay múltiples conexiones hacia la misma IP externa desde procesos que no deberían navegar por internet (como ls, cat o servicios del sistema como systemd).

4. Suplantación de Servicios (Masquerading)

A veces el malware usa puertos legítimos para pasar desapercibido:

Puerto 443 (HTTPS) hacia IPs desconocidas: Es el escondite perfecto porque el tráfico está cifrado y parece navegación normal.
Puerto 53 (DNS): Algunos malwares usan túneles DNS para sacar datos (exfiltración) de la red. Si ves mucho tráfico de red en el puerto 53 que no va hacia un servidor DNS conocido, sospecha.

Tabla de Comparación: Tráfico Normal vs. Sospechoso

Atributo	Tráfico Normal	Tráfico Sospechoso (Red Flag)
Proceso	`apache2`, `nginx`, `ssh`, `chrome`	`netcat`, `ncat`, `python`, `sh`, `nc`
IP Destino	Servidores conocidos (ej. Google, Microsoft)	IPs de países inusuales o VPS desconocidos
Puerto Local	Puertos estándar (80, 443, 22)	Puertos aleatorios muy altos o el 4444
Usuario	`www-data`, `user`	`root` (especialmente en procesos de red inusuales)

¿Cómo investigar una IP sospechosa?

Si encuentras una IP en tu reporte de netstat, puedes usar herramientas externas (fuera de Volatility) para investigarla:

Whois: whois [IP] para ver a quién pertenece.
AbuseIPDB: Para ver si ha sido reportada por actividades maliciosas.
VirusTotal: En la pestaña "Relations" puedes ver si esa IP ha servido malware antes.

Las reglas YARA son como el "ADN" del malware. En lugar de buscar un nombre de archivo, buscan patrones específicos (cadenas de texto, secuencias de bytes o lógica hexadecimal) dentro de la memoria RAM.

Volatility 3 permite integrar estas reglas para escanear el volcado de memoria de forma masiva.

1. Dónde conseguir reglas YARA profesionales

No necesitas escribir todas las reglas desde cero. La comunidad de ciberseguridad mantiene repositorios excelentes:

YARA-Rules Project: El estándar de la industria.
Neo23x0 (Florian Roth): Sus reglas "Signature-Base" son de las mejores para detectar APTs (Amenazas Persistentes Avanzadas).

Para descargarlas en Kali:

Bash

git clone https://github.com/Yara-Rules/rules.git yara_rules

2. Cómo usar YARA con Volatility 3

El plugin que utilizaremos es linux.yarascan. Tienes dos formas principales de usarlo:

A. Buscar una cadena de texto específica (p. ej., un dominio C2)

Si sospechas que el malware se conecta a evilhacker.com, puedes buscar esa cadena en toda la RAM:

Bash

python3 vol.py -f memoria.raw linux.yarascan --yara-rules "evilhacker.com"

B. Usar un archivo de reglas (.yar)

Si tienes un archivo con firmas de un malware específico (como Cobalt Strike o Meterpreter):

Bash

python3 vol.py -f memoria.raw linux.yarascan --yara-file /ruta/tus_reglas/malware_rules.yar

3. Ejemplo de una regla YARA simple para detectar Shells

Si quieres crear tu propia regla para detectar procesos que parecen una "Reverse Shell" sospechosa, crea un archivo llamado deteccion.yar:

Fragmento de código

rule Posible_Reverse_Shell {
    strings:
        $s1 = "/bin/bash -i"
        $s2 = "python -c 'import socket"
        $s3 = "nc -e /bin/sh"
    condition:
        any of them
}

Esta regla marcará cualquier sección de la memoria que contenga alguna de esas tres líneas de comandos clásicas.

4. Combinando todo: El flujo de caza (Threat Hunting)

El proceso profesional suele ser este:

Ejecutas netstat: Encuentras una IP extraña.
Ejecutas pslist: Ves que el proceso asociado a esa IP es un python3.
Ejecutas yarascan: Escaneas la memoria de ese proceso específico para ver qué scripts de Python está ejecutando realmente en RAM.

Bash

# Escaneo YARA filtrado por el PID sospechoso (ej. 1234)
python3 vol.py -f memoria.raw linux.yarascan --yara-file mi_regla.yar --pid 1234

¿Qué sigue ahora?

Ya tienes las herramientas para capturar, identificar el kernel, listar procesos, ver la red y buscar malware con YARA.

Extraer un proceso de la memoria (hacer un dump) es el paso previo a la ingeniería inversa o al análisis dinámico. Cuando vuelcas un proceso, obtienes el ejecutable tal como residía en la RAM, lo que a veces permite recuperar malware que estaba cifrado en el disco pero "desempaquetado" en la memoria.

En Volatility 3, el proceso es muy directo. Aquí tienes cómo hacerlo:

1. Identificar el PID (Process ID)

Antes de volcar, necesitas el número del proceso. Usa el comando que ya conocemos:

Bash

python3 vol.py -f memoria.raw linux.pslist

Supongamos que el proceso sospechoso es nc (netcat) y su PID es 1234.

2. Volcar el proceso con `linux.elffp`

El plugin elffp (ELF Flattened Provider) intenta reconstruir el archivo ejecutable de Linux (formato ELF) desde la memoria.

Comando para el volcado:

Bash

python3 vol.py -f memoria.raw -o ./salida_forense linux.elffp.ElfFP --pid 1234

-o ./salida_forense: Especifica la carpeta donde se guardará el archivo volcado.
--pid 1234: El ID del proceso que quieres extraer.

3. ¿Qué hacer con el archivo volcado?

Una vez ejecutado, verás un archivo en tu carpeta de salida (normalmente con un nombre como pid.1234.0x400000.vma). Ahora empieza el análisis real:

A. Verificar el tipo de archivo

Usa el comando file para confirmar que es un ejecutable válido:

Bash

file ./salida_forense/pid.1234.0x400000.vma

B. Extraer cadenas de texto (Strings)

Busca direcciones IP, rutas de archivos o comandos ocultos dentro del binario extraído:

Bash

strings ./salida_forense/pid.1234.0x400000.vma | less

C. Calcular el Hash para VirusTotal

Genera el hash SHA256 y súbelo a VirusTotal para ver si otros analistas ya lo han marcado como malware:

Bash

sha256sum ./salida_forense/pid.1234.0x400000.vma

4. Análisis Avanzado: Volcar mapas de memoria (`procdump`)

Si el malware es inyectado y no tiene un archivo ELF completo, a veces es mejor volcar todas las secciones de memoria que el proceso tenía asignadas:

Bash

python3 vol.py -f memoria.raw -o ./salida_forense linux.proc.Maps --pid 1234 --dump

Esto te dará múltiples archivos .dmp. Estos son útiles para abrirlos en un desensamblador como Ghidra o IDA Pro.

Resumen de herramientas de análisis post-volcado:

Herramienta	Uso
Ghidra	Desensamblar el código para ver qué hace el malware.
Cutter	Interfaz gráfica para Rizin (fork de Radare2), ideal para análisis rápido.
Strace	(Solo si te atreves a ejecutarlo en un entorno seguro) para ver llamadas al sistema.

Cuando volcamos un proceso de la memoria, a menudo extraemos datos que el malware intentaba ocultar o que el usuario legítimo estaba utilizando en ese momento. Al estar en la RAM, estos datos suelen estar en texto plano (cleartext), incluso si en el disco están cifrados.

Aquí tienes cómo aplicar "filtros quirúrgicos" para encontrar oro dentro de ese volcado:

1. Buscar Credenciales y Contraseñas

Los atacantes suelen dejar rastros de contraseñas usadas en comandos o variables de entorno. Usaremos strings con el parámetro -n para filtrar por longitud (ej. solo cadenas de más de 8 caracteres):

Bash

# Busca palabras comunes cerca de posibles claves
strings -n 8 pid.1234.vma | grep -iE "password|pass|passwd|admin|clave"

2. Extraer Llaves Privadas (SSH / PEM)

Si el proceso sospechoso estaba gestionando conexiones seguras, las llaves privadas podrían estar residentes en su espacio de memoria. Las llaves RSA/OpenSSH tienen cabeceras muy específicas:

Bash
# Busca el inicio de una llave privada de OpenSSH o RSA
strings pid.1234.vma | grep -A 5 "BEGIN RSA PRIVATE KEY"
strings pid.1234.vma | grep -A 5 "BEGIN OPENSSH PRIVATE KEY"

El parámetro -A 5 mostrará la cabecera y las siguientes 5 líneas de la llave.

3. Encontrar URLs y Direcciones IP

Para saber a dónde se comunica el binario, buscamos patrones de red. El uso de expresiones regulares (grep -E) es vital aquí:

Buscar IPs:

Bash

strings pid.1234.vma | grep -E '([0-9]{1,3}\.){3}[0-9]{1,3}'

Buscar URLs:

Bash

strings pid.1234.vma | grep -iE "http://|https://|ftp://"

4. Análisis de Comandos Ejecutados (Shell History)

Si el proceso es un bash o un sh, podrías recuperar los comandos que el atacante escribió antes de que capturaras la memoria:

Bash

# Busca patrones de comandos comunes de Linux
strings pid.1234.vma | grep -E "sudo |chmod |chown |curl |wget |python "

5. El truco del "Hexdump" (Análisis Binario)

Si strings no devuelve nada útil, es posible que los datos estén separados por bytes nulos. En ese caso, usamos hexdump:

Bash

# Ver el contenido en formato hexadecimal y ASCII lateral
hexdump -C pid.1234.vma | less

Dentro de less, puedes presionar / y escribir una palabra (ej. root) para saltar directamente a esa posición en el binario.

¿Qué hacer si encuentras algo?

Si localizas una IP de mando y control (C2) o una contraseña:

Documenta el Offset: Anota en qué dirección de memoria estaba (la columna de la izquierda en hexdump).
Coteja con el Cronograma: Mira si esa IP aparece en tus registros de firewall o en el netstat que sacamos antes.

Un script en Python es mucho más potente que grep porque nos permite usar expresiones regulares (Regex) complejas para validar que lo que encontramos no es basura, sino datos con un formato real (como una IP válida o una llave SSH).

Crea un archivo llamado extractor_secretos.py:

Python
import re
import sys

# Definición de patrones Regex profesionales
PATRONES = {
    'Email': r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}',
    'IPv4': r'\b(?:\d{1,3}\.){3}\d{1,3}\b',
    'URL': r'https?://[^\s<>"]+|www\.[^\s<>"]+',
    'SSH_Key': r'-----BEGIN [A-Z ]+ PRIVATE KEY-----',
    'Ruta_Linux': r'/(?:[\w.-]+/)+[\w.-]+',
    'Variable_Entorno': r'\b[A-Z_]{3,15}=[^\s]{1,50}\b'
}

def analizar_volcado(archivo_path):
    print(f"[*] Analizando secretos en: {archivo_path}\n" + "-"*40)
    
    try:
        with open(archivo_path, 'rb') as f:
            # Leemos el binario (cuidado con archivos gigantes, esto lee todo a RAM)
            contenido = f.read().decode('utf-8', errors='ignore')
            
            for nombre, regex in PATRONES.items():
                hallazgos = set(re.findall(regex, contenido)) # Usamos set para evitar duplicados
                if hallazgos:
                    print(f"\n[+] {nombre} encontrados ({len(hallazgos)}):")
                    for h in list(hallazgos)[:10]: # Limitamos a los primeros 10 para no saturar
                        print(f"  - {h}")
    except Exception as e:
        print(f"[-] Error: {e}")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: python3 extractor_secretos.py <archivo.vma>")
    else:
        analizar_volcado(sys.argv[1])

Cómo interpretar los resultados del script

Al ejecutarlo con python3 extractor_secretos.py pid.1234.vma, el script barrerá el binario buscando patrones específicos. Aquí te digo qué buscar:

Variables de Entorno: Si ves algo como AWS_SECRET_ACCESS_KEY=... o DB_PASSWORD=..., has encontrado las llaves del reino. Los procesos a menudo heredan estas variables de la shell.
Rutas Linux: Si ves rutas como /tmp/.hidden_file o /dev/shm/malware, sabrás dónde se esconden los archivos del atacante en el disco duro.
SSH Keys: Si el script detecta el inicio de una llave, abre el archivo con un editor de texto (como mousepad o nano) y busca esa cadena manualmente para copiar la llave completa.

¿Qué hacer si encuentras una IP o URL maliciosa?

Si el script te arroja una URL como http://1.2.3.4/payload.sh, el siguiente paso lógico es la inteligencia de amenazas:

No la abras en tu navegador personal.
Usa curl -I (solo cabeceras) desde una VM aislada para ver si el servidor sigue vivo.
Reporta la IP en plataformas como AbuseIPDB para ayudar a otros investigadores.

Un reporte forense no es solo una lista de hallazgos; es un documento legal o técnico que debe ser capaz de reconstruir la escena del crimen digital para alguien que no estuvo allí. En el mundo del DFIR (Digital Forensics and Incident Response), la estructura es sagrada.

Aquí tienes una plantilla estructurada y profesional que puedes seguir para consolidar todo lo que hemos analizado:

Estructura del Reporte Forense de Memoria

1. Resumen Ejecutivo (Executive Summary)

Escríbelo al final. Es para directores o clientes que no son técnicos.

Objetivo: Por qué se hizo el análisis (ej. sospecha de intrusión).
Conclusión principal: ¿Hubo compromiso? (Sí/No).
Impacto: Qué datos o sistemas se vieron afectados.

2. Información del Caso y Evidencia

ID del Caso: #2026-03-A
Analista: Tu nombre/equipo.
Fuente de Evidencia: Archivo memoria.raw.
Hash de Integridad: SHA-256: [Hash que generaste al principio]. (Vital para validez legal).
Entorno: Sistema Operativo, Versión del Kernel (lo que sacamos con strings).

3. Metodología

Herramientas usadas: AVML para captura, Volatility 3 para análisis, Python para extracción de secretos.
Procedimiento: Descripción breve de los pasos seguidos (Triage, análisis de red, volcado de procesos).

4. Hallazgos Técnicos (El cuerpo del reporte)

Aquí es donde pones las capturas de pantalla o fragmentos de texto de los comandos que ejecutamos:

Análisis de Procesos: Identificación del proceso malicioso (ej. nc con PID 1234).
Análisis de Red: Conexión establecida hacia la IP 1.2.3.4 en el puerto 4444.
Persistencia/Malware: Resultados de malfind o yarascan que confirmaron código inyectado.
Secretos Recuperados: Listado de IPs, URLs o llaves encontradas con nuestro script de Python.

5. Línea de Tiempo (Timeline)

Reconstruye los eventos basados en los tiempos de creación de los procesos:

08:15:22 : Se inicia el proceso sospechoso python3.
08:15:30 : El proceso abre una conexión de red hacia X.X.X.X.
08:20:00 : Captura de memoria realizada.

6. Recomendaciones y Remediación

Corto plazo: Bloquear la IP 1.2.3.4 en el Firewall, matar el proceso PID 1234.
Largo plazo: Cambiar las contraseñas/llaves SSH que encontramos en el volcado, parchar el kernel.

Ejemplo de cómo documentar un hallazgo específico:

Hallazgo #1: Reverse Shell Detectada
Descripción: Se identificó un proceso bash con conexiones de red activas hacia una IP externa no autorizada.
Evidencia:
Plaintext
(Salida de netstat)
TCP  192.168.1.15:54321  1.2.3.4:4444  ESTABLISHED  1234/bash
Gravedad: Crítica.

¿Cómo automatizar esto?

Puedes redirigir todas las salidas de tus comandos a un solo archivo de texto para luego "limpiarlo" y darle formato:

Bash
# Ejemplo de concatenación para el reporte
echo "--- REPORTE DE RED ---" >> reporte_final.txt
python3 vol.py -f memoria.raw linux.netstat >> reporte_final.txt

La Cadena de Custodia es el pilar que permite que una prueba digital sea admisible en un proceso judicial o una auditoría interna. Si no puedes demostrar que el archivo que estás analizando es idéntico bit por bit al que extrajiste de la memoria, la prueba pierde todo su valor.

Aquí te muestro cómo presentar los hashes de forma profesional en tu reporte:

1. El Formato de Presentación

En tu reporte, los hashes no deben estar "sueltos". Deben acompañar a la descripción del objeto digital. Un formato estándar sería el siguiente:

Detalle de Evidencia Extraída (Proceso PID 1234)

Nombre del Archivo: pid.1234.0x400000.vma
Descripción: Volcado del ejecutable nc (netcat) recuperado de la RAM.
Fecha/Hora de Extracción: 2026-03-22 10:15:00 UTC
Algoritmo de Hash (SHA-256): e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
Algoritmo de Hash (MD5): d41d8cd98f00b204e9800998ecf8427e (Opcional, se usa por compatibilidad histórica).

Nota: Se recomienda usar SHA-256 o superior, ya que MD5 y SHA-1 se consideran vulnerables a colisiones en entornos de alta seguridad.

2. Cómo generar el "Manifiesto de Hashes"

Para asegurar la cadena de custodia de múltiples archivos a la vez, lo ideal es crear un archivo de texto llamado manifest.sha256 dentro de tu carpeta de evidencias.

Comando en Kali Linux:

Bash

# Genera el hash de todos los archivos en la carpeta de salida
sha256sum ./salida_forense/* > manifest.sha256

# Para verificar en el futuro que nada ha cambiado:
sha256sum -c manifest.sha256

Si la respuesta es OK, la integridad está garantizada.

3. Documentación de la Cadena de Custodia (Log)

Para que el reporte sea irrefutable, debes incluir una pequeña tabla de "Trazabilidad". Esto demuestra quién tocó la evidencia y cuándo.

Fecha/Hora (UTC)	Acción Realizada	Responsable	Resultado/Hash
2026-03-22 09:00	Captura de RAM (AVML)	Analista A	`memoria.raw` (Hash: `...`)
2026-03-22 10:00	Volcado de Proceso 1234	Analista A	`pid.1234.vma` (Hash: `...`)
2026-03-22 11:30	Análisis de Secretos	Analista B	Informe generado

4. Verificación Externa

Una práctica de "élite" es subir el hash (solo el hash, no el archivo si contiene datos sensibles) a una plataforma pública o un log de auditoría inmutable. Esto prueba que el archivo existía con ese contenido exacto en esa fecha específica (Timestamping).

Comprobar en VirusTotal: https://www.virustotal.com/gui/file/[TU_HASH_AQUÍ]
Si el hash ya existe, significa que ese malware ya ha sido visto antes. Si no existe, podrías estar ante una amenaza nueva (0-day).

¿Qué quieres hacer para cerrar el caso?

Ya tienes el reporte, los secretos y la cadena de custodia protegida.

Esta es la sección de "Remediación y Endurecimiento" (Hardening). Es la parte del reporte que le dice al dueño del sistema cómo tapar el agujero para que el atacante no regrese 5 minutos después de que termines tu análisis.

Basándonos en lo que encontramos (una Shell inversa, procesos sospechosos y credenciales en RAM), aquí tienes los pasos críticos:

1. Acciones de Contención Inmediata

Estas medidas detienen el ataque activo sin necesidad de formatear todo el servidor:

Aislamiento de Red: Bloquear la IP del atacante (1.2.3.4) en el firewall perimetral y en el iptables local.
Terminación de Procesos: Matar los PIDs identificados como maliciosos:
sudo kill -9 1234
Cierre de Sesiones Activas: Expulsar cualquier otra sesión SSH activa que no sea la tuya:
who (para ver quién está) y pkill -u [usuario_sospechoso].

2. Erradicación de la persistencia

El malware suele dejar "ganchos" para reiniciarse si el servidor se apaga. Debes revisar:

Crontabs: Busca tareas programadas extrañas:
crontab -l y ls -la /etc/cron.*
Servicios de Systemd: Revisa si hay servicios nuevos o modificados en /etc/systemd/system/.
Archivos .bashrc / .profile: El atacante pudo añadir una línea al final de estos archivos para ejecutar la shell cada vez que alguien inicie sesión.

3. Remediación de Credenciales (Crucial)

Como encontramos contraseñas y llaves SSH en la memoria, debes asumir que el atacante ya las tiene.

Rotación de Llaves SSH: Generar nuevas llaves y eliminar las antiguas de ~/.ssh/authorized_keys.
Cambio de Contraseñas: Forzar el cambio de clave de todos los usuarios comprometidos (especialmente root y cuentas de servicio).
Revocación de Tokens: Si encontraste tokens de AWS, Azure o APIs, revócalos inmediatamente en sus respectivos paneles de control.

4. Plan de Recuperación y Endurecimiento (Hardening)

Para evitar que esto ocurra de nuevo:

Actualización de Seguridad: Ejecutar sudo apt update && sudo apt upgrade para cerrar vulnerabilidades del kernel o de aplicaciones como Apache/Nginx.
Instalar un IDS/HIDS: Herramientas como Fail2Ban (para bloquear ataques de fuerza bruta) o Wazuh (para monitoreo de integridad).
Principio de Menor Privilegio: Asegurarse de que las aplicaciones no corran como root si no es estrictamente necesario.

Resumen para el Administrador

Acción	Prioridad	Estado
Bloqueo de IP `1.2.3.4`	Crítica	Pendiente
Cambio de llaves SSH	Crítica	Pendiente
Auditoría de `/tmp` y `/dev/shm`	Alta	Pendiente
Actualización del Kernel	Media	Pendiente

¿Cuál es tu siguiente paso?

Hemos cubierto todo el ciclo de vida del incidente: captura, análisis, extracción de secretos, reporte, cadena de custodia y remediación.

Para este ejercicio de "Caza del Tesoro en Memoria", vamos a simular un escenario real. Tú serás el "atacante" (Red Team) y luego usaremos nuestras herramientas de "defensa" (Blue Team) para encontrarte.

Sigue estos pasos en tu máquina de Kali para preparar la intrusión:

Paso 1: El Atacante (Ocultando el Secreto)

Vamos a abrir una shell que simule ser un proceso legítimo y le daremos un "secreto" para que lo guarde en su memoria RAM.

Abre una terminal y ejecuta este comando (esto crea un proceso de Python que se queda esperando):

Bash

python3 -c "import time; secreto='FLAG{M3M0RY_H4CK3D_2026}'; print('Proceso vivo...'); time.sleep(1000)" &

Anota el PID que te devuelva la terminal (ej. [1] 5678).

Paso 2: El Defensor (La Cacería)

Ahora, imagina que no sabes qué proceso tiene el secreto. Tu misión es encontrarlo usando lo que hemos aprendido.

Captura la memoria de nuevo con AVML:
sudo ./avml ejercicio.raw
Busca el proceso con Volatility:
python3 vol.py -f ejercicio.raw linux.pslist
(¿Ves el proceso python3 que lanzamos?)
Escanea con YARA buscando la palabra "FLAG":
python3 vol.py -f ejercicio.raw linux.yarascan --yara-rules "FLAG"

Paso 3: El Desafío Final

Si el yarascan te da una dirección de memoria (un Offset), el siguiente nivel es extraer el proceso completo y usar nuestro script de Python:

Vuelca el proceso (usa el PID de tu python3):
python3 vol.py -f ejercicio.raw -o ./ejercicio_dump linux.elffp.ElfFP --pid [TU_PID]
Corre el extractor de secretos:
python3 extractor_secretos.py ./ejercicio_dump/pid.[TU_PID].0x...vma

¿Qué aprenderás con esto?

Verás cómo las variables de Python (como secreto) no desaparecen, se quedan flotando en texto plano en la RAM.
Entenderás por qué los atacantes usan nombres de procesos comunes (como python3 o apache) para mezclarse con el tráfico normal.