Saltar al contenido principal
Forense Digital: Guía Completa de Análisis de Incidentes
SEGURIDAD EMPRESARIAL#forense-digital#dfir#analisis-incidentes#evidencia-digital#log-analysis

Forense Digital: Guía Completa de Análisis de Incidentes

Dominá el análisis forense digital desde cero: procesos, herramientas, técnicas de memoria y Windows, y un caso práctico de ransomware paso a paso.

29 minCyberFlows Team
[Espacio publicitario — AdSense]

¿Qué es el Análisis Forense Digital?

El análisis forense digital es la disciplina que combina procedimientos técnicos y metodologías científicas para identificar, preservar, recuperar, analizar y presentar evidencia almacenada en dispositivos electrónicos. Su objetivo principal es reconstruir lo que ocurrió en un sistema informático, determinar quién fue responsable y proporcionar hallazgos que puedan tener valor legal o de respuesta a incidentes.

A diferencia de lo que muchos creen, la forense digital no comienza cuando se conecta un disco a una estación de análisis. Comienza en el momento exacto en que se detecta un incidente y se toma la decisión de preservar evidencia. Cada segundo que pasa entre la detección y la recolección correcta de evidencia puede significar la diferencia entre un caso resuelto y evidencia inadmisible.

Relación con DFIR

DFIR (Digital Forensics and Incident Response) es el marco que integra la forense digital con la respuesta a incidentes. Mientras la forense tradicional se enfoca en la cadena de custodia y la presentación legal, DFIR prioriza la velocidad de análisis sin sacrificar la integridad de la evidencia. En entornos empresariales, la mayoría de los analistas forenses trabajan bajo el paradigma DFIR: contienen el incidente, recolectan evidencia de forma forensicamente correcta y analizan para determinar el alcance del compromiso.

Aspecto DFIR Forense Tradicional
Prioridad Velocidad + Legalidad Integridad Legal
Cadena de custodia Flexible Estricta
Herramientas En vivo + offline Solo offline
Salida esperada Reporte interno + Remediación Dictamen pericial
Equipo típico SOC / CSIRT Laboratorio forense

El Proceso Forense: Metodología Paso a Paso

El proceso forense sigue un ciclo definido que garantiza la reproducibilidad y la validez de los hallazgos. Cada fase tiene procedimientos específicos que, si se saltan, pueden invalidar todo el análisis posterior.

1. Identificación

La primera fase consiste en determinar qué evidencia es relevante y dónde se encuentra. Esto implica:

  • Evidencia volátil: datos que se pierden al apagar el sistema (contenido de RAM, conexiones de red activas, procesos en ejecución, valores de registro en memoria).
  • Evidencia no volátil: datos persistentes en disco (archivos, registros, metadatos, logs del sistema).
  • Evidencia en la nube: logs de proveedores, snapshots de instancias, registros de auditoría.

El orden correcto de volatilidad para la recolección es:

Nivel Elemento Volatilidad
1 CPU Registers & Cache ← Menos volátil
2 Routing Tables, ARP Cache, Process Tables
3 RAM (Memory)
4 Temporary File Systems
5 Disk
6 Remote Logging & Monitoring Data
7 Archival Media (Backups, Optical) ← Más volátil

2. Recolección

La recolección es la fase más crítica. Un error aquí puede destruir evidencia para siempre.

Write Blockers: Todo disco que se extraiga de un equipo debe conectarse a través de un write blocker (hardware o software) que impida cualquier escritura accidental. Los write blockers de hardware como el Tableau T356789iu forensic son el estándar de la industria. Para entornos de presupuesto limitado, los write blockers de software como dc3dd o guymager ofrecen protección razonable.

Cadena de Custodia: Cada pieza de evidencia debe documentarse con:

Campo Ejemplo
ID de evidencia EVD-2026-0042
Descripción Disco duro Samsung 870 EVO 1TB
Serial Number S5P8NS0T123456
Fuente Estación de trabajo del empleado Juan Pérez, Escritorio 3A
Fecha/hora de recolección 2026-07-08 14:32 ART
Recolectado por Analista: María López (CSIRT)
Sellado por Custodio: Carlos Ruiz
Hash SHA-256 a3f2b8c9... (completo)
Almacenamiento Evidence Locker #3

Comandos de recolección en vivo (Linux):

# Recolectar evidencia volátil en un equipo Linux
# 1. Información del sistema
uname -a > volatile_info.txt
date >> volatile_info.txt
w >> volatile_info.txt

# 2. Procesos en ejecución
ps auxwwf > processes.txt

# 3. Conexiones de red
netstat -tulpan > network_connections.txt
ss -tulpan >> network_connections.txt

# 4. Contenido de memoria (requiere root)
dd if=/dev/mem of=/mnt/evidence/memdump.raw bs=1M

# 5. Montajes y sistema de archivos
mount > mounts.txt
cat /etc/fstab >> mounts.txt

# 6. Carga del kernel y módulos
lsmod > kernel_modules.txt
dmesg > kernel_messages.txt

Comandos de recolección en vivo (Windows con PowerShell):

# Recolectar evidencia volátil en Windows
# 1. Procesos
Get-Process | Format-Table -AutoSize > processes.txt

# 2. Conexiones de red
netstat -anob > network_connections.txt

# 3. Servicios
Get-Service | Format-Table -AutoSize > services.txt

# 4. Usuarios conectados
query user > logged_in_users.txt

# 5. Variables de entorno
Get-ChildItem Env: > env_variables.txt

# 6. Archivos abiertos
OpenFiles /query /fo CSV > open_files.csv

3. Preservación

La preservación garantiza que la evidencia no sea alterada desde el momento de la recolección hasta el análisis.

Imageado de Discos: Se crea una copia bit a bit del disco original. El estándar usa el formato E01 (EnCase Evidence File) o raw (dd).

# Crear imagen con dc3dd (con hash incorporado)
dc3dd if=/dev/sda hash=sha256 log=/mnt/evidence/imaging.log of=/mnt/evidence/disk_image.E01

# Crear imagen con Guymager (GUI forense)
guymager

# Verificar imagen con md5sum
md5sum /dev/sda > original_hash.txt
md5sum /mnt/evidence/disk_image.E01 > image_hash.txt
# Los hashes deben coincidir

Timestamps de Preservación: Cada archivo recolectado debe tener su hash calculado inmediatamente. El hash SHA-256 es el estándar actual:

# Calcular hash SHA-256 de toda una evidencia
sha256sum /mnt/evidence/disk_image.E01
# Salida esperada:
# a3f2b8c9d1e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0  disk_image.E01

# Calcular hashes de múltiples archivos
find /mnt/evidence/ -type f -exec sha256sum {} \; > evidence_hashes.txt

4. Análisis

El análisis es donde se extrae información relevante de la evidencia preservada. Las principales técnicas son:

Timeline Analysis: Construir una línea de tiempo cronológica de eventos. Esta es probablemente la técnica más poderosa en forense digital.

# Generar timeline con Plaso/log2timeline
log2timeline.py --storage-file /mnt/analysis/timeline.plaso /mnt/evidence/disk_image.E01

# Convertir a formato legible
psort.py -o l2tcsv /mnt/analysis/timeline.plaso -w /mnt/analysis/timeline.csv

# Filtrar eventos de un rango específico
psort.py -o l2tcsv /mnt/analysis/timeline.plaso \
  "date > '2026-07-01' AND date < '2026-07-10'" \
  -w /mnt/analysis/july_timeline.csv

Keyword Search: Búsqueda de palabras clave en la imagen completa.

# Búsqueda de texto en imagen raw
strings /mnt/evidence/disk_image.E01 | grep -i "password"

# Búsqueda con YARA rules
yara -r /mnt/rules/malware_rules.yar /mnt/evidence/disk_image.E01

# Búsqueda hexadecimal
hexdump -C /mnt/evidence/disk_image.E01 | grep -i "mz"

File System Analysis: Análisis del sistema de archivos para encontrar archivos eliminados, slack space y metadatos ocultos.

5. Reporte

El reporte forense debe ser claro, preciso y reproducible. Cualquier persona con acceso a la misma evidencia y las mismas herramientas debería llegar a las mismas conclusiones.

Estructura de un reporte forense:

  1. Resumen ejecutivo (para audiencia no técnica)
  2. Alcance y objetivos del análisis
  3. Metodología utilizada
  4. Herramientas y versiones
  5. Hallazgos técnicos detallados
  6. Línea de tiempo reconstruida
  7. Conclusiones
  8. Anexos (hashes, cadenas de custodia, capturas)

Tipos de Forense Digital

Forense de Disco

La forense de disco analiza el sistema de archivos para recuperar archivos eliminados, examinar slack space y extraer metadatos.

Conceptos clave:

  • Slack Space: Espacio no utilizado entre el final de un archivo y el final de su bloque asignado. Puede contener datos residuales de archivos anteriores.
  • File System Metadata: Inodos, MFT entries (NTFS), journal entries que registran creación, modificación y eliminación de archivos.
  • Deleted Files: Los archivos eliminados suelen permanecer en disco hasta que su espacio sea reutilizado. Los sistemas NTFS simplemente marcan la entrada MFT como disponible.
# Analizar sistema de archivos con Autopsy CLI (Sleuth Kit)
fls -r -d /mnt/evidence/disk_image.E01
# Lista todos los archivos eliminados (marcados con *)

# Recuperar un archivo eliminado
icat /mnt/evidence/disk_image.E01 [inode_number] > recovered_file.docx

# Analizar MFT con analyzeMFT
analyzeMFT.py -f /mnt/evidence/mft.raw -o /mnt/analysis/mft_output.csv

Tabla de sistemas de archivos y estructuras clave:

Sistema de Archivos Estructura Principal Journal Archivos Eliminados
NTFS MFT ($MFT) $LogFile Entrada MFT marcada como inactiva
ext3/ext4 Inodos + Journal journal inode Inodo marcado como libre
FAT32 FAT Table Sin journal Primera letra cambiada a Ω (0xE5)
HFS+ Catalog B-tree Journal Entrada marcada como no utilizada

Forense de Memoria (RAM)

La forense de memoria analiza el contenido de la memoria RAM de un sistema. Es extraordinariamente valiosa porque contiene:

  • Procesos en ejecución (incluyendo malware en memoria)
  • Contraseñas y tokens de autenticación
  • Claves de cifrado
  • Conexiones de red activas
  • Contenido de llaves de registro en memoria
  • Fragmentos de archivos que nunca se escribieron a disco
Categoría Herramientas Volatility Descripción
Procesos Activos pslist, psscan Procesos en ejecución
Network Connections sockets, netstat Conexiones de red activas
Registry Hives SAM, SYSTEM, SOFTWARE Llaves de registro en memoria
Malware Artifacts malfind Código inyectado o sospechoso
DLLs y Drivers drivers, ldrmodules Módulos cargados en procesos
Command History cmd, ps, powershell Comandos ejecutados recientemente
Clipboard Content — Texto copiado por el usuario
Browser Artifacts — Datos de sesiones del navegador
Crypto Keys — Llaves cifradas en memoria

Forense de Red

La forense de red examina el tráfico de red capturado para reconstruir comunicaciones, identificar exfiltración de datos y rastrear actividad maliciosa.

# Capturar tráfico con tcpdump
tcpdump -i eth0 -w /mnt/evidence/capture.pcap -s 0

# Analizar con tshark (Wireshark CLI)
# Filtrar tráfico HTTP
tshark -r capture.pcap -Y "http.request" -T fields \
  -e frame.time -e ip.src -e ip.dst -e http.host -e http.request.uri

# Exportar archivos transferidos via HTTP
tshark -r capture.pcap --export-objects "http,/mnt/evidence/extracted_files/"

# Analizar conversaciones
tshark -r capture.pcap -z conv,ip -q > conversations.txt

Forense Móvil

La extracción de evidencia de dispositivos móviles se clasifica en tres niveles:

Tipo Método Información Obtenida Dificultad
Lógica Backup/protocolo del fabricante Contactos, SMS, fotos, apps instaladas Baja
File System Jailbreak/Root + acceso a sistema de archivos Bases de datos SQLite, archivos de app, caché Media
Physical/Chip-off Desoldering del chip de memoria Datos completos, incluyendo eliminados Muy Alta

Extracción lógica con ADB (Android):

# Extraer datos lógicos de Android
adb pull /sdcard/ /mnt/evidence/android_dump/

# Extraer base de datos de WhatsApp
adb pull /data/data/com.whatsapp/databases/msgstore.db /mnt/evidence/

# Extraer logs del sistema
adb logcat -d > /mnt/evidence/android_logs.txt

Forense en la Nube

La forense en la nube presenta desafíos únicos: no hay acceso físico a los servidores, y la evidencia está distribuida entre múltiples servicios y regiones.

AWS CloudTrail:

# Listar eventos recientes de CloudTrail
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=ConsoleLogin \
  --start-time 2026-07-01T00:00:00Z \
  --end-time 2026-07-10T23:59:59Z \
  --output json > aws_login_events.json

# Analizar accesos desde IPs no reconocidas
aws cloudtrail lookup-events \
  --lookup-attributes AttributeKey=EventName,AttributeValue=AssumeRole \
  --output table

Azure Activity Log:

# Listar actividades de Azure
az monitor activity-log list \
  --start-time 2026-07-01T00:00:00Z \
  --query "[?status.value=='Failed']" \
  --output table > azure_failed_activities.txt

GCP Audit Log:

# Leer logs de auditoría de GCP
gcloud logging read "protoPayload.methodName:compute.instances.delete" \
  --project=my-project \
  --format=json > gcp_audit_logs.json

Forense de Registros (Logs)

Los registros son la columna vertebral de la mayoría de investigaciones forenses. Están presentes en cada sistema operativo, aplicación y dispositivo de red.

Herramientas Esenciales del Analista Forense

Autopsy / Sleuth Kit

Autopsy es la plataforma de análisis forense de disco de código abierto más utilizada. Proporciona una interfaz gráfica sobre The Sleuth Kit (TSK), una colección de herramientas de línea de comandos.

# Analizar imagen de disco con TSK
# Listar archivos (incluso eliminados)
fls -r -m "/" /mnt/evidence/disk_image.E01

# Buscar archivos por nombre
tsk_recover /mnt/evidence/disk_image.E01 /mnt/recovered/

# Extraer cadena de directorios completa
tsk_loaddb -a -i raw -d /mnt/analysis/tsk.db /mnt/evidence/disk_image.E01

Volatility 3

Volatility 3 es el framework estándar para análisis de memoria. A continuación se muestra su uso con comandos reales y salidas esperadas.

Comandos fundamentales:

# 1. Listar procesos (equivalente a pslist)
vol3 -f /mnt/evidence/memory.raw windows.pslist

Salida esperada:

PID     PPID    ImageFileName   Offset(V)       CreateTime              ExitTime
4       0       System          0xfa80002648c0  2026-07-08 08:00:01     N/A
88      4       smss.exe        0xfa80002d6040  2026-07-08 08:00:03     N/A
348     336     csrss.exe       0xfa800031e8c0  2026-07-08 08:00:15     N/A
512     504     wininit.exe     0xfa8000369040  2026-07-08 08:00:16     N/A
580     348     csrss.exe       0xfa8000371040  2026-07-08 08:00:15     N/A
632     512     services.exe    0xfa80003b7040  2026-07-08 08:00:16     N/A
676     512     lsass.exe       0xfa80003c1040  2026-07-08 08:00:16     N/A
780     632     svchost.exe     0xfa8000432040  2026-07-08 08:00:18     N/A

# 2. Listar procesos ocultos (evasion de malware)
vol3 -f /mnt/evidence/memory.raw windows.psscan

Salida esperada (procesos que no aparecen en pslist):

PID     PPID    ImageFileName   Offset(V)       CreateTime              ExitTime
2244    632     svchost.exe     0xfa80005f4040  2026-07-08 10:15:22     N/A
4512    780     explorer.exe    0xfa80006d2040  2026-07-08 09:30:45     N/A
8832    4512    cmd.exe         0xfa80007c8040  2026-07-08 14:22:11     N/A
8896    8832    powershell.exe  0xfa80007e0040  2026-07-08 14:22:13     N/A

# 3. Ver conexiones de red activas
vol3 -f /mnt/evidence/memory.raw windows.netscan

Salida esperada:

Offset          Proto   LocalAddr       LocalPort   ForeignAddr      ForeignPort State           PID   Owner
0xfa80005a8b10  TCPv4   192.168.1.50    49832       185.220.100.252   443         ESTABLISHED     8896  powershell.exe
0xfa80005a8c20  TCPv4   192.168.1.50    49833       10.0.0.5          445         ESTABLISHED     8896  powershell.exe
0xfa80004b2340  TCPv4   192.168.1.50    445         192.168.1.100     49701       ESTABLISHED     4     System
0xfa80006c1a50  TCPv4   192.168.1.50    53          8.8.8.8           53          ESTABLISHED     780   svchost.exe

# 4. Detectar código inyectado en procesos sospechosos
vol3 -f /mnt/evidence/memory.raw windows.malfind --pid 8896

Salida esperada:

PID: 8896
Process: powershell.exe
Base: 0x10000000
Protection: PAGE_EXECUTE_READWRITE
Flags: MemCommit, PrivateMemory

Hexdump:
0x01000000  4d 5a 90 00 03 00 00 00  MZ........
0x01000008  04 00 00 00 ff ff 00 00  ........
0x01000010  b8 00 00 00 00 00 00 00  ........
...
[Posible shellcode o DLL inyectada detectada]

# 5. Extraer llaves de registro de la memoria
vol3 -f /mnt/evidence/memory.raw windows.registry.hivelist

Salida esperada:

Offset      File                      Hivename
0x8241c0a0  \SystemRoot\System32\config\SAM       SAM
0x8241c4e0  \SystemRoot\System32\config\SECURITY  SECURITY
0x824b4660  \SystemRoot\System32\config\SOFTWARE  SOFTWARE
0x824d8990  \SystemRoot\System32\config\SYSTEM    SYSTEM
0x8e4f2498  \Device\HarddiskVolume1\Users\admin\NTUSER.DAT  ntuser.dat

# 6. Extraer archivos de la memoria
vol3 -f /mnt/evidence/memory.raw windows.dumpfiles --pid 8896 --dump-dir /mnt/analysis/dumped_files/

# 7. Ver historial de comandos ejecutados
vol3 -f /mnt/evidence/memory.raw windows.cmdline

Salida esperada:

PID    Process          Args
4      System           System
632    services.exe     C:\Windows\system32\services.exe
676    lsass.exe        C:\Windows\system32\lsass.exe
780    svchost.exe      C:\Windows\system32\svchost.exe -k netsvcs
8896   powershell.exe   powershell.exe -nop -w hidden -enc SQBmACgA...

Plaso / log2timeline

Plaso es la herramienta estándar para generar timelines forenses. Consolida eventos de múltiples fuentes en una única línea de tiempo.

# Crear timeline completa desde imagen de disco
log2timeline.py \
  --storage-file /mnt/analysis/case001.plaso \
  /mnt/evidence/disk_image.E01

# Agregar logs adicionales
log2timeline.py \
  --storage-file /mnt/analysis/case001.plaso \
  /mnt/evidence/additional_logs.evtx

# Generar reporte en formato CSV
psort.py -o l2tcsv /mnt/analysis/case001.plaso -w /mnt/analysis/full_timeline.csv

# Filtrar solo eventos sospechosos
psort.py -o l2tcsv /mnt/analysis/case001.plaso \
  "date > '2026-07-08 14:00:00' AND date < '2026-07-08 16:00:00'" \
  -w /mnt/analysis/incident_window.csv

KAPE (Kroll Artifact Parser and Extractor)

KAPE es una herramienta de triage que permite recolectar rápidamente evidencia de un sistema en vivo.

# Ejecutar KAPE en modo triage (copia solo artefactos esenciales)
kape.exe --tsource C: --target C:\Temp\evidence --module "ForensicCopy"

# Ejecutar módulos de análisis de Windows
kape.exe --tsource C: --target C:\Temp\artifacts \
  --module "LNK,JumpLists,Amcache,AppCompatCache,Prefetch,Registry,Shellbags,SrumEva"

# Generar reporte HTML
kape.exe --tsource C:\Temp\artifacts --target C:\Temp\report \
  --module "HTMLReport"

Eric Zimmerman Tools

Eric Zimmerman desarrolló un conjunto de herramientas especializadas en forense de Windows que son indispensables para cualquier investigador:

# Analizar MFT con MFTECmd
MFTECmd.exe -f "C:\$MFT" --csv "C:\Analysis" --csvf mft_output.csv

# Analizar Prefetch con PECmd
PECmd.exe -d "C:\Windows\Prefetch" --csv "C:\Analysis" --csvf prefetch_output.csv

# Analizar Shellbags con ShellBagsExplorer
ShellBagsExplorer.exe

# Analizar LNK files con LECmd
LECmd.exe -d "C:\Users" --csv "C:\Analysis" --csvf lnk_output.csv

# Analizar Amcache
AmcacheParser.exe -f "C:\Windows\appcompat\Programs\Amcache.hve" \
  --csv "C:\Analysis" --csvf amcache_output.csv

Forense de Memoria: Análisis Profundo

La memoria es el tesoro del analista forense. Contiene el estado exacto del sistema en el momento de la captura, incluyendo información que nunca llegó a disco.

Detección de Malware en Memoria

# Detectar procesos con código inyectado
vol3 -f mem.raw windows.malfind

# Buscar DLLs sospechosas no cargadas desde disco
vol3 -f mem.raw windows.ldrmodules

# Buscar handles abiertos por procesos sospechosos
vol3 -f mem.raw windows.handles --pid 8896

# Extraer y analizar archivos sospechosos
vol3 -f mem.raw windows.dumpfiles --pid 8896 --dump-dir /tmp/suspicious/

# Verificar integridad de DLLs cargadas
vol3 -f mem.raw windows.dlllist --pid 8896

Análisis de Procesos

# Ver árbol completo de procesos
vol3 -f mem.raw windows.pslist --tree

# Identificar procesos padre-hijo anómalos
# Ejemplo sospechoso: svchost.exe como hijo de powershell.exe
vol3 -f mem.raw windows.pslist | grep -A2 -B2 "suspicious"

# Verificar firmas digitales de procesos
vol3 -f mem.raw windows.vadinfo --pid 8896

# Analizar memoria de un proceso específico
vol3 -f mem.raw windows.memmap --pid 8896 --dump --dump-dir /tmp/memdump/

Extracción de Artefactos de Red

# Ver todas las conexiones de red
vol3 -f mem.raw windows.netscan

# Filtrar conexiones a IPs externas
vol3 -f mem.raw windows.netscan | awk '{print $4, $5, $6, $7}' | sort -u

# Verificar si hay conexiones a IPs conocidas maliciosas
# Exportar IPs y verificar contra Threat Intelligence
vol3 -f mem.raw windows.netscan | awk '{print $6}' | sort -u > external_ips.txt

Extracción de Hashes de Credenciales

# Extraer hashes NTLM de la memoria (requiere imagen de memoria)
vol3 -f mem.raw windows.hashdump

# Extraer credenciales de memoria
vol3 -f mem.raw windows.cachedump

# Buscar tokens de autenticación
vol3 -f mem.raw windows.tokens

Forense de Windows: Análisis Profundo

Windows es el sistema operativo más analizado en forense corporativa. Su riqueza de artefactos lo convierte en un campo fértil para la investigación.

Análisis del Registro de Windows

El registro de Windows contiene información sobre configuración, usuario, red y actividad del sistema. Los cinco hives principales son:

Hive Ubicación Contenido
SAM C:\Windows\System32\config\SAM Usuarios locales, grupos, hashes NTLM
SYSTEM C:\Windows\System32\config\SYSTEM Configuración del sistema, clave de boot
SOFTWARE C:\Windows\System32\config\SOFTWARE Configuración de software instalado
SECURITY C:\Windows\System32\config\SECURITY Políticas de seguridad, tokens LSA
NTUSER.DAT C:\Users\<usuario>\NTUSER.DAT Configuración por usuario 
# Extraer usuarios locales del SAM
regdump.py SYSTEM SOFTWARE SAM

# Analizar con Registry Explorer (Eric Zimmerman)
# Buscar USB devices conectados
# HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR

# Buscar programas auto-ejecutados
# HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
# HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

Prefetch, ShimCache y AmCache

Estos tres artefactos registran la ejecución de programas:

Prefetch (Windows XP - 8.1):

# Ubicación: C:\Windows\Prefetch\
# Formato: PROGRAMA-RANDOM.pf
# Contiene: nombre del ejecutable, tiempos de ejecución, número de veces ejecutado
# Analyze con PECmd
PECmd.exe -f "C:\Windows\Prefetch\CHROME.EXE-3A2F5E9B.pf"

ShimCache (Windows 7+):

# Ubicación: HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache
# Contiene: lista de aplicaciones ejecutadas, tamaño del archivo, último tiempo de modificación
# No contiene tiempos de ejecución específicos, pero indica que la app existió

AmCache (Windows 8+):

# Ubicación: C:\Windows\appcompat\Programs\Amcache.hve
# Contiene: SHA-1 hash del ejecutable, tiempos de compilación, instalación
# Muy valioso para correlacionar con IOC de malware
AmcacheParser.exe -f "C:\Windows\appcompat\Programs\Amcache.hve" \
  --csv "C:\Analysis" --csvf amcache.csv

USN Journal y $LogFile

El USN (Update Sequence Number) Journal de NTFS registra cambios en archivos. Es extraordinariamente valioso porque contiene historial de creación, eliminación y modificación de archivos.

# Analizar USN Journal
# La ubicación es: C:\$UsnJrnl:$J
# Se extrae con TSK o herramientas específicas

# Con analyzeMFT + USN Journal
analyzeMFT.py -f "$MFT" -j "$UsnJrnl" -o timeline.csv

# $LogFile contiene transacciones NTFS pendientes
# Útil para ver cambios que no se completaron (intento de eliminación fallido)

Análisis de Windows Event Logs

Windows Event Logs son una fuente invaluable de evidencia. Los IDs más relevantes para forense son:

Event ID Log Descripción
4624 Security Inicio de sesión exitoso
4625 Security Inicio de sesión fallido
4634 Security Cierre de sesión
4648 Security Inicio de sesión con credenciales explícitas
4672 Security Privilegios especiales asignados
4688 Security Nuevo proceso creado
4689 Security Proceso terminado
4697 Security Servicio instalado en el sistema
4698 Security Tarea programada creada
4720 Security Usuario creado
4732 Security Miembro agregado a grupo local
7045 System Nuevo servicio instalado
1102 Security Registro de auditoría borrado
4104 PowerShell Bloque de script executed
1 Sysmon Creación de proceso
3 Sysmon Conexión de red saliente
7 Sysmon Carga de imagen (DLL)
8 Sysmon CreateRemoteThread 
# Consultar eventos de inicio de sesión fallidos
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4625} |
  Select-Object TimeCreated, Message | Format-Table -Wrap

# Buscar creación de procesos sospechosos
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4688} |
  Where-Object { $_.Message -match "powershell.exe|cmd.exe|mshta.exe" } |
  Select-Object TimeCreated, Message

# Verificar si alguien borró los logs
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=1102}

# Analizar PowerShell Script Block Logging (Event ID 4104)
Get-WinEvent -FilterHashtable @{LogName='Microsoft-Windows-PowerShell/Operational'; ID=4104} |
  Select-Object TimeCreated, Message | Format-Table -Wrap

# Extraer logs con wevtutil
wevtutil epl Security C:\Evidence\Security.evtx /ow:true
wevtutil epl System C:\Evidence\System.evtx /ow:true
wevtutil epl "Microsoft-Windows-PowerShell/Operational" C:\Evidence\PowerShell.evtx /ow:true

# Analizar EVTX con EvtxECmd (Eric Zimmerman)
EvtxECmd.exe -f "C:\Evidence\Security.evtx" --csv "C:\Analysis" --csvf security_events.csv

# Buscar eventos específicos
EvtxECmd.exe -f "C:\Evidence\Security.evtx" --xml "C:\Analysis\security_full.xml"
grep -i "4688" C:\Analysis\security_full.xml

Forense de Linux

Linux es predominante en servidores, dispositivos de red e infraestructura cloud. Su forense tiene particularidades importantes.

Análisis de /var/log

Los logs de Linux son la principal fuente de evidencia:

Archivo Descripción
/var/log/auth.log Autenticaciones, sudo, SSH
/var/log/syslog o /var/log/messages Eventos generales del sistema
/var/log/kern.log Mensajes del kernel
/var/log/dmesg Buffer del kernel al inicio
/var/log/cron Tareas cron ejecutadas
/var/log/apache2/access.log Accesos a Apache
/var/log/nginx/access.log Accesos a Nginx
/var/log/secure (RHEL/CentOS) Autenticaciones en RHEL
/var/log/faillog Intentos de login fallidos
/var/log/lastlog Último login de cada usuario
/var/log/wtmp Historial de logins y logouts 
# Analizar auth.log para accesos sospechosos
grep "Accepted" /var/log/auth.log | awk '{print $1, $2, $3, $9, $11}'

# Buscar sudo no autorizado
grep "sudo:" /var/log/auth.log | grep -i "not allowed"

# Ver logins fallidos
lastb | head -20

# Ver historial de logins exitosos
last -f /var/log/wtmp | head -20

# Buscar conexiones SSH
grep "sshd" /var/log/auth.log | grep "Accepted"

Bash History

El historial de bash es una ventana directa a la actividad del usuario:

# Bash history de todos los usuarios
cat /home/*/.bash_history

# Historial con timestamps (si está habilitado)
HISTTIMEFORMAT="%F %T " history

# Buscar comandos sospechosos
grep -E "(curl|wget|nc|netcat|python|perl|ruby|base64|eval)" /home/*/.bash_history

# Buscar descarga y ejecución de malware
grep -E "(curl.*\|.*sh|wget.*\|.*bash)" /home/*/.bash_history

# Verificar si se borró el historial
ls -la /home/*/.bash_history
stat /home/*/.bash_history

Forense de SSH

# Verificar claves SSH autorizadas
cat /home/*/.ssh/authorized_keys

# Buscar claves SSH no autorizadas
find / -name "authorized_keys" -type f 2>/dev/null

# Analizar known_hosts
cat /home/*/.ssh/known_hosts

# Verificar configuración SSH del servidor
cat /etc/ssh/sshd_config | grep -v "^#" | grep -v "^$"

Timestamps en Linux (atime, mtime, ctime)

Linux maneja tres timestamps por archivo que son fundamentales en forense:

Timestamp Significado Cuándo cambia
atime Último acceso (lectura) Al leer el archivo
mtime Última modificación del contenido Al modificar contenido
ctime Último cambio de metadatos Al cambiar permisos, owner, contenido o nombre 
# Ver los tres timestamps de un archivo
stat /etc/passwd

# Salida:
#   File: /etc/passwd
#   Size: 2841       Blocks: 8          IO Block: 4096   regular file
# Access: 2026-07-10 10:15:22.123456789 -0300
# Modify: 2026-07-05 14:30:11.987654321 -0300
# Change: 2026-07-05 14:30:11.987654321 -0300
#  Birth: 2026-01-15 08:00:00.000000000 -0300

# Buscar archivos modificados en las últimas 24 horas
find / -mtime -1 -type f 2>/dev/null

# Buscar archivos con ctime sospechoso (posible anti-forense)
find / -ctime -0 -type f 2>/dev/null

# Detectar archivos con timestamps alterados (touch)
find / -newer /tmp/reference_file -type f 2>/dev/null

Detección de Rootkits

# Usar rkhunter para detección de rootkits
rkhunter --check --skip-keypress

# Usar chkrootkit
chkrootkit

# Verificar integridad de binarios del sistema
rpm -Va 2>/dev/null || dpkg --verify 2>/dev/null

# Buscar binarios con SETUID sospechosos
find / -perm -4000 -type f 2>/dev/null

# Verificar módulos del kernel cargados
lsmod

# Buscar procesos ocultos (comparar /proc con ps)
for pid in /proc/[0-9]*; do
  if [ ! -d "$pid" ]; then continue; fi
  name=$(cat "$pid/comm" 2>/dev/null)
  if [ -z "$name" ]; then continue; fi
  echo "$pid: $name"
done | sort -t: -k1 -n > /tmp/proc_ps_compare.txt

Construyendo un Laboratorio Forense

Un laboratorio forense debe ser un entorno aislado, seguro y con las herramientas necesarias para realizar análisis completos.

Requisitos del Hardware

Componente Mínimo Recomendado
CPU 4 cores 8+ cores (Intel/AMD con VT-x)
RAM 16 GB 64 GB+
Almacenamiento 1 TB SSD 4+ TB NVMe RAID
Red 1 Gbps 10 Gbps (aislada)
Write Blockers 1 HW Múltiples HW + SW
Monitor 1x 24" 2x 27" 4K

Software del Laboratorio

Componente Herramientas / Configuración
Estación Windows Autopsy, FTK Imager, Eric Zimmerman, Wireshark, KAPE
Estación Linux Volatility 3, Sleuth Kit, Plaso, YARA, ClamAV
Servidor de Almacén Evidencia cruda, análisis activo, backups offsite
Red Aislada Sin acceso a Internet, VLAN dedicada

Configuración de Red Aislada

El laboratorio debe operar en una red completamente aislada de la producción:

  1. VLAN dedicada sin rutas hacia Internet
  2. Switch de administración independiente
  3. Proxy forense para análisis de malware controlado (solo si se necesita CONNECTividad limitada)
  4. Logs de toda actividad de red del laboratorio

Consideraciones Legales

Cadena de Custodia

La cadena de custodia documenta quién tuvo acceso a la evidencia y cuándo. Es esencial para la admisibilidad legal.

Fase Acción Detalle
Detección Documentar hora y lugar Registrar cuándo y dónde se encontró la evidencia
Recolección Sellado con hash + sello numérico Asegurar integridad criptográfica
Transporte Transporte asegurado Cadena física documentada
Almacenamiento Evidence Locker con acceso restringido Control de quién accede
Análisis Workstation forense aislada Sin conexión a red de producción
Reporte Firmado por analista Documento con hash de integridad
Presentación Testimonio pericial Declaración bajo juramento

Admisibilidad de Evidencia

Para que la evidencia digital sea admisible en un tribunal:

  1. Integridad: Los hashes deben coincidir con los calculados durante la recolección
  2. Autenticidad: Debe demostrarse que la evidencia no fue alterada
  3. Relevancia: La evidencia debe ser directamente relevante al caso
  4. Metodología: El análisis debe seguir metodologías aceptadas (NIST, ISO 27037)
  5. Documentación: La cadena de custodia debe estar completa

RGPD / Protección de Datos

El análisis forense puede involucrar datos personales protegidos por el RGPD:

  • Base legal: Interés legítimo (Art. 6.1.f RGPD) para investigar incidentes de seguridad
  • Minimización: Solo recolectar datos estrictamente necesarios para la investigación
  • Almacenamiento: Definir períodos de retención para la evidencia
  • Privacidad: Proteger datos de terceros no involucrados que puedan aparecer en la evidencia
  • DPO: Consultar al Delegado de Protección de Datos antes del análisis

Caso Práctico: Investigación de Ransomware

Este caso práctico simula una investigación real de un incidente de ransomware en una empresa mediana.

Escenario

Fecha: 8 de julio de 2026, 09:15 ART Reporte: Un empleado reporta que no puede acceder a archivos en el servidor de archivos. Aparece un archivo READ_ME_DECRYPT.txt en cada carpeta. Alcance: 3 servidores de archivos, 45 estaciones de trabajo, servidor de base de datos.

Fase 1: Contención Inmediata

# 1. Desconectar sistemas afectados de la red (pero NO apagarlos)
# En el servidor de archivos afectado:
Get-NetAdapter | Disable-NetAdapter -Confirm:$false

# 2. Capturar evidencia volátil ANTES de cualquier acción
# (del equipo de respuesta)
# PowerShell en modo remoto o USB de forense

# Capturar procesos
Get-Process | Out-File "\\forensics\cases\case042\vol\tasks.txt"

# Capturar conexiones de red
netstat -anob > "\\forensics\cases\case042\vol\netstat.txt"

# Capturar servicios
Get-Service | Out-File "\\forensics\cases\case042\vol\services.txt"

# Capturar memoria (con FTK Imager o herramienta similar)
# FTK Imager CLI:
ftkimager.exe --source "C:" --dest "\\forensics\cases\case042\evidence" \
  --type raw --segments 1GB

Fase 2: Recolección de Evidencia

# Extraer imagen del disco del servidor comprometido
dc3dd if=\\.\PhysicalDrive0 hash=sha256 log=imaging.log \
  of=\\forensics\cases\case042\evidence\server_image.E01

# Recolectar logs de Windows del servidor
wevtutil epl Security "\\forensics\cases\case042\logs\Security.evtx"
wevtutil epl System "\\forensics\cases\case042\logs\System.evtx"
wevtutil epl "Microsoft-Windows-PowerShell/Operational" "\\forensics\cases\case042\logs\PowerShell.evtx"

# Recolectar logs de los controladores de dominio
# (usando KAPE desde USB forense)
kape.exe --tsource D:\Windows --target D:\Evidence\dc01 \
  --module "LNK,JumpLists,Amcache,AppCompatCache,Prefetch,Registry" \
  --csvout

# Recolectar logs de firewalls e IDS
scp admin@firewall:/var/log/firewall.log /forensics/cases/case042/logs/
scp admin@ids:/var/log/snort/alert /forensics/cases/case042/logs/

Fase 3: Análisis

Paso 1: Timeline inicial

# Crear timeline con Plaso
log2timeline.py --storage-file /cases/case042/timeline.plaso \
  /cases/case042/evidence/server_image.E01

# Generar CSV y filtrar ventana del incidente
psort.py -o l2tcsv /cases/case042/timeline.plaso \
  "date > '2026-07-07 20:00:00' AND date < '2026-07-08 12:00:00'" \
  -w /cases/case042/incident_timeline.csv

Paso 2: Análisis de logs de seguridad

# Buscar inicios de sesión anómalos antes del ransomware
Get-WinEvent -FilterHashtable @{LogName='Security'; ID=4624} |
  Where-Object { $_.TimeCreated -gt (Get-Date "2026-07-07") -and
    $_.TimeCreated -lt (Get-Date "2026-07-08") } |
  ForEach-Object {
    $xml = [xml]$_.ToXml()
    $ip = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'IpAddress'} | Select-Object -ExpandProperty '#text'
    [PSCustomObject]@{
      Time = $_.TimeCreated
      User = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'TargetUserName'} | Select-Object -ExpandProperty '#text'
      IP = $ip
      LogonType = $xml.Event.EventData.Data | Where-Object {$_.Name -eq 'LogonType'} | Select-Object -ExpandProperty '#text'
    }
  } | Where-Object { $_.LogonType -eq 10 -or $_.LogonType -eq 3 } |
  Format-Table -AutoSize

Paso 3: Análisis de memoria

# Analizar memoria capturada del servidor
vol3 -f /cases/case042/evidence/server_mem.raw windows.pslist --tree

# Buscar procesos de cifrado
vol3 -f /cases/case042/evidence/server_mem.raw windows.pslist | \
  grep -iE "(encrypt|crypto|lock|dead|ryuk|blackcat|cl0p)"

# Ver conexiones de red desde la memoria
vol3 -f /cases/case042/evidence/server_mem.raw windows.netscan | \
  grep "ESTABLISHED"

# Extraer hash del ransomware
vol3 -f /cases/case042/evidence/server_mem.raw windows.hashdump

Paso 4: Análisis de prefetch y ejecución

# Analizar qué ejecutables corrieron
PECmd.exe -d "/cases/case042/evidence/Windows/Prefetch" \
  --csv "/cases/case042/analysis" --csvf prefetch.csv

# Buscar ejecutables sospechosos en Amcache
AmcacheParser.exe -f "/cases/case042/evidence/Windows/appcompat/Programs/Amcache.hve" \
  --csv "/cases/case042/analysis" --csvf amcache.csv

Fase 4: Indicadores de Compromiso (IOC)

Del análisis se extraen los siguientes IOC:

Archivos

Ruta Hash (SHA256)
c:\windows\temp\svchost.exe a1b2c3d4...
c:\windows\temp\decrypt.exe e5f6g7h8...
README_DECRYPT.txt (en cada carpeta cifrada) —

Red

IOC Detalle
IP del C2 185.220.100.252:443
Dominio update-service[.]xyz
DNS queries update-service[.]xyz (10:15 – 14:22)

Usuarios

IOC Detalle
Cuenta creada svc-backup (2026-07-07 22:15, Event ID 4720)
Inicio de sesión RDP Desde 192.168.5.100

Técnicas MITRE ATT&CK

  • PowerShell inverso para descarga inicial
  • PsExec para movimiento lateral
  • vssadmin delete shadows (eliminación de backups)
  • bcdedit /set {default} recoveryenabled no

Línea de Tiempo

Hora Evento
2026-07-07 21:00 Phishing email recibido
2026-07-07 21:15 Empleado hace clic en enlace
2026-07-07 21:17 PowerShell descarga payload
2026-07-07 22:15 Cuenta svc-backup creada
2026-07-07 23:00 Movimiento lateral inicia
2026-07-08 00:30 Cifrado de archivos comienza
2026-07-08 02:00 Backups eliminados (VSS + bcdedit)
2026-07-08 09:15 Reporte inicial del incidente

Fase 5: Reporte y Remediación

El reporte final incluye:

  1. Resumen ejecutivo: Ransomware del tipo X cifró 3 servidores y 45 estaciones de trabajo. punto de entrada fue phishing. Duración del compromiso: ~12 horas antes de detección.
  2. IOC completos: Archivos, hashes, IPs, dominios, técnicas MITRE ATT&CK.
  3. Línea de tiempo detallada: Cronología de eventos con evidencia que soporta cada hallazgo.
  4. Recomendaciones: Eliminar cuenta svc-backup, actualizar reglas de firewall, implementar MFA, capacitar usuarios en phishing.

Métricas del Proceso Forense

Para mejorar continuamente, los equipos de DFIR deben trackear estas métricas:

Métrica Objetivo
Tiempo de detección (MTTD) < 24 horas
Tiempo de contención (MTTC) < 4 horas desde detección
Tiempo de análisis completo < 72 horas
Imagenado de disco < 2 horas por disco
Generación de timeline < 4 horas
Reporte final < 5 días hábiles

Artículos Relacionados

Fuentes y Referencias

Aviso legal: Este contenido es estrictamente educativo. CyberFlows no apoya actividades ilegales. Úsalo solo en entornos autorizados.

[Espacio publicitario — AdSense]

Artículos Relacionados

Passkeys y FIDO2: El Fin de las Contraseñas y la Autenticación sin Contraseña

10/7/2026 · 11 min

Prompt Injection y Seguridad en LLMs: La Nueva Frontera de la Ciberseguridad

10/7/2026 · 15 min

Newsletter de Ciberseguridad

Resumen semanal con los mejores artículos, CVEs críticos y tendencias del mercado. Sin spam.

🔒 Tu email no se compartirá. Puedes darte de baja en cualquier momento.