Plaso / Log2Timeline — Super Línea de Tiempo DFIR

📊

¿Qué es Plaso / Log2Timeline?

El motor de líneas de tiempo forense más potente del mundo

Plaso (anteriormente llamado Log2Timeline) es el framework de análisis forense digital de referencia mundial. Desarrollado y mantenido por equipos DFIR profesionales, es la herramienta que utilizan analistas forenses, fuerzas del orden, equipos de respuesta a incidentes (CSIRT/CERT) y el FBI para reconstruir la actividad de un sistema en el tiempo.

Su función principal es procesar cientos de fuentes de artefactos distintas (Event Logs de Windows, historial de navegadores, ficheros Prefetch, registros IIS, MFT del sistema de archivos, registros del sistema...) y combinarlas en una única super línea de tiempo ordenada cronológicamente. Esta visión unificada es imprescindible para entender cómo se movió un atacante a través de un sistema o una red entera.

El pipeline tiene tres herramientas principales:

log2timeline.py — El motor de procesado: extrae eventos de las fuentes y los almacena en una base de datos SQLite llamada Plaso Storage File (.plaso)
psort.py — El motor de filtrado y exportación: filtra, ordena y exporta los eventos del .plaso en múltiples formatos (CSV, JSON, Timesketch...)
pinfo.py — El inspector: muestra estadísticas y metadatos de un archivo .plaso

🛡 HERRAMIENTA EXCLUSIVAMENTE DEFENSIVAPlaso analiza artefactos forenses de sistemas ya comprometidos o bajo investigación. Es el equivalente digital de analizar la escena de un crimen. Usada por fuerzas del orden, equipos CSIRT y analistas forenses en todo el mundo.

🔌

Arquitectura y Pipeline

Cómo procesa Plaso los artefactos y genera la línea de tiempo

🔌PIPELINE DE PLASO

Fase	Herramienta	Entrada	Salida
1. Extracción	`log2timeline.py`	Imagen de disco, carpeta, archivo individual	Archivo .plaso (SQLite)
2. Inspección	`pinfo.py`	Archivo .plaso	Estadísticas, parsers usados, rango de fechas
3. Filtrado/Export	`psort.py`	Archivo .plaso + filtros	CSV, JSON, Timesketch, OpenSearch
4. Visualización	Timesketch / Excel / Kibana	CSV o JSON exportado	Línea de tiempo interactiva

📊ARQUITECTURA INTERNA

Plaso funciona con un sistema de parsers y plugins:

Parsers: leen formatos de archivo específicos (evtx, sqlite, csv, lnk, prefetch, registry...) y extraen eventos con timestamp
Plugins de parsers: procesan sub-formatos dentro de un archivo (ej: dentro de un SQLite de Firefox hay plugins para historial, descargas, cookies)
Analizadores: procesan los eventos ya extraídos para detectar patrones (dominios DGA, hashes de malware conocidos, etc.)
Formatters: convierten los eventos al formato de salida deseado

⚙

Instalación de Plaso

Tres métodos: Docker (recomendado), pip, y desde fuentes

💡 RECOMENDACIÓN: USAR DOCKERPlaso tiene muchas dependencias complejas. La forma más fácil y reproducible de instalarlo es con Docker. La imagen oficial está siempre actualizada y evita conflictos de dependencias.

Método 1: Docker (recomendado)

# Descargar la imagen oficial de Plaso
docker pull log2timeline/plaso

# Verificar que funciona
docker run log2timeline/plaso log2timeline.py --version

# Alias para facilitar el uso (anadir al .bashrc)
alias log2timeline='docker run -v $(pwd):/data log2timeline/plaso log2timeline.py'
alias psort='docker run -v $(pwd):/data log2timeline/plaso psort.py'
alias pinfo='docker run -v $(pwd):/data log2timeline/plaso pinfo.py'

# Probar con un archivo de ejemplo:
log2timeline /data/output.plaso /data/archivo.evtx

Método 2: pip (en Kali / Ubuntu)

# Instalar plaso y todas sus dependencias
pip3 install plaso

# O con pipx (entorno aislado, recomendado):
pipx install plaso

# En Kali Linux 2024+:
sudo apt install plaso -y

# Verificar instalacion:
log2timeline.py --version
psort.py --version
pinfo.py --version

Método 3: Desde el repositorio oficial

# Clonar el repositorio
git clone https://github.com/log2timeline/plaso.git
cd plaso

# Instalar dependencias
pip3 install -r requirements.txt
pip3 install -e .

# Verificar:
log2timeline.py --help
psort.py --help

Preparar entorno de laboratorio

# Crear estructura de directorios para el laboratorio
mkdir -p ~/plaso_lab/{artefactos,output,export,case}

# artefactos/ : fuentes (evtx, logs, imagen de disco...)
# output/     : archivos .plaso generados
# export/     : CSV/JSON exportados
# case/       : documentacion del caso

cd ~/plaso_lab
echo 'Laboratorio Plaso - GhostAcademy' > case/README.txt

📂

Fuentes de Artefactos Forenses

Qué puede procesar Plaso y dónde encontrar cada fuente

📄Event Logs Windows.evtx en C:\Windows\System32\winevt\Logs\ — auth, procesos, servicios

🌐Historial navegadoresChrome, Firefox, Edge — SQLite con URLs, descargas, cookies

📊Logs IIS / ApacheLogs de acceso HTTP — peticiones, IPs, user agents, códigos

🔌Registro de WindowsNTUSER.DAT, SYSTEM, SOFTWARE, SAM — persistencia, configuración

▶PrefetchC:\Windows\Prefetch\ — programas ejecutados con timestamps

📄MFT / $MFTMaster File Table NTFS — metadatos de todos los archivos

🔗Accesos directos (.lnk)C:\Users\*\Recent — archivos accedidos recientemente

📊Logs sistema Linuxsyslog, auth.log, kern.log, wtmp, lastlog

🔌SQLite genéricoCualquier base de datos SQLite: apps de mensajería, correo

📄Jumplist / ShellbagNavegación del sistema de archivos y accesos del explorador

💻Imagen de discoE01, VMDK, raw DD — Plaso monta y procesa todo automáticamente

🌐Capturas de red (.pcap)Metadatos de tráfico de red para integrar en la línea de tiempo

Listar todos los parsers disponibles en Plaso

# Ver todos los parsers que puede usar Plaso:
log2timeline.py --parsers list

# Filtrar por categoria:
log2timeline.py --parsers list | grep -i 'windows'
log2timeline.py --parsers list | grep -i 'browser'
log2timeline.py --parsers list | grep -i 'linux'

# Ver los presets (grupos de parsers por OS):
# win7     : Windows 7
# win_gen  : Windows general
# linux    : Linux
# macos    : macOS
log2timeline.py --parsers list | grep 'Preset'

💻

Ejercicio 1 — Procesar una Imagen de Disco Completa

Objetivo: extraer todos los artefactos de una imagen forense de Windows

Procesado de imagen de disco

log2timeline procesa automáticamente todos los artefactos encontrados

IMAGEN FORENSE

El caso de uso más potente de Plaso es procesar una imagen de disco completa (E01, VMDK, raw DD). Plaso la monta internamente y aplica automáticamente todos los parsers relevantes según el sistema operativo detectado, extrayendo millones de eventos de decenas de fuentes distintas en un solo comando.

Fuentes de imágenes de disco para prácticaPRÁCTICA

Obtener imágenes forenses de práctica gratuitas

# Fuentes de imagenes forenses gratuitas para laboratorio:

# 1. Digital Corpora (coleccion forense academica)
#    https://digitalcorpora.org/corpora/disk-images

# 2. CyberDefenders (challenges DFIR)
#    https://cyberdefenders.org

# 3. BlueTeamLabs Online
#    https://blueteamlabs.online

# 4. NIST Computer Forensics Tool Testing
#    https://www.cftt.nist.gov/disk_imaging.htm

# Crear imagen de tu propia VM de laboratorio con dd:
dd if=/dev/sdb of=~/plaso_lab/artefactos/disco_lab.img bs=4M status=progress

Procesar la imagen completa con log2timelinePROCESADO

Procesar imagen de disco completa

# Sintaxis:
# log2timeline.py [opciones] ARCHIVO_SALIDA.plaso FUENTE

# Procesar imagen con parsers de Windows:
log2timeline.py \
  --parsers win_gen \
  --logfile ~/plaso_lab/output/log2timeline.log \
  ~/plaso_lab/output/caso01.plaso \
  ~/plaso_lab/artefactos/disco.E01

# Con mas informacion de progreso:
log2timeline.py \
  --status_view linear \
  --parsers win_gen \
  ~/plaso_lab/output/caso01.plaso \
  ~/plaso_lab/artefactos/disco.E01

# Con Docker:
docker run -v ~/plaso_lab:/data log2timeline/plaso \
  log2timeline.py \
  --parsers win_gen \
  /data/output/caso01.plaso \
  /data/artefactos/disco.E01

# Usar multiples nucleos de CPU:
log2timeline.py --workers 4 \
  ~/plaso_lab/output/caso01.plaso \
  ~/plaso_lab/artefactos/disco.E01

Inspeccionar el archivo .plaso generadoINSPECCIÓN

Inspeccionar el .plaso con pinfo

# Ver informacion general del archivo .plaso:
pinfo.py ~/plaso_lab/output/caso01.plaso

# Salida esperada:
# Archivo: caso01.plaso
# Parsers usados: evtx, winreg, prefetch, lnk, chrome_history...
# Numero de eventos: 1.847.293
# Rango temporal: 2024-11-01 -- 2025-01-10
# Fuentes procesadas: 47

# Ver estadisticas por parser:
pinfo.py --output parsers ~/plaso_lab/output/caso01.plaso

# Ver el log del procesado:
cat ~/plaso_lab/output/log2timeline.log | tail -50

❓ Ejercicio práctico

Descarga una imagen forense de Digital Corpora o CyberDefenders y procésala con log2timeline. ¿Cuántos eventos extrae? ¿Qué parsers se han activado? ¿Cuál es el rango temporal?

💡 Pista: pinfo.py te da toda esta informacion despues del procesado.

Ver solución

pinfo.py caso.plaso --- La salida muestra: numero total de eventos, rango de fechas, parsers activos y su contribucion. Una imagen de Windows tipica genera entre 500.000 y 5.000.000 de eventos segun la actividad del sistema.

📄

Ejercicio 2 — Procesar Event Logs de Windows (.evtx)

Objetivo: extraer eventos de seguridad de archivos .evtx para la línea de tiempo

Procesado de Event Logs

Los archivos .evtx son una de las fuentes más ricas en información para DFIR

EVENT LOGS

Recolectar los Event Logs del sistema investigadoRECOLECCIÓN

Copiar Event Logs para análisis forense offline

# En el sistema bajo investigacion (Windows PowerShell):
$destino = 'C:\Forensics\evtx'
New-Item -ItemType Directory -Force $destino

$logs = @(
    'Security.evtx',
    'System.evtx',
    'Application.evtx',
    'Microsoft-Windows-PowerShell%4Operational.evtx',
    'Microsoft-Windows-Sysmon%4Operational.evtx',
    'Microsoft-Windows-TaskScheduler%4Operational.evtx'
)
foreach ($log in $logs) {
    $src = "C:\Windows\System32\winevt\Logs\$log"
    Copy-Item $src $destino -ErrorAction SilentlyContinue
}

# Hashes para cadena de custodia:
Get-FileHash $destino\*.evtx -Algorithm SHA256 | Format-Table

Procesar los archivos .evtx con log2timelinePROCESADO

Procesar archivos evtx con Plaso

# Procesar un unico archivo .evtx:
log2timeline.py \
  ~/plaso_lab/output/security_evtx.plaso \
  ~/plaso_lab/artefactos/Security.evtx

# Procesar todos los .evtx de una carpeta:
log2timeline.py \
  ~/plaso_lab/output/todos_evtx.plaso \
  ~/plaso_lab/artefactos/evtx/

# Solo parser de evtx (mas rapido):
log2timeline.py \
  --parsers evtx \
  ~/plaso_lab/output/security.plaso \
  ~/plaso_lab/artefactos/Security.evtx

Exportar y filtrar eventos de seguridadEXPORTADO

Exportar eventos a CSV con psort

# Exportar todos los eventos a CSV:
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/security_timeline.csv \
  ~/plaso_lab/output/security.plaso

# Filtrar solo eventos de autenticacion:
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/auth_events.csv \
  ~/plaso_lab/output/evtx_timeline.plaso \
  "message CONTAINS '4624' OR message CONTAINS '4625'"

# Filtrar por rango de tiempo:
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/semana.csv \
  ~/plaso_lab/output/evtx_timeline.plaso \
  --slice '2025-01-10T00:00:00'

# Con ventana de tiempo alrededor de una fecha (+-5 dias):
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/entorno_incidente.csv \
  ~/plaso_lab/output/evtx_timeline.plaso \
  --slice '2025-01-10T14:30:00' \
  --slice_size 5

❓ Ejercicio práctico

Procesa un archivo Security.evtx con Plaso y exporta solo los eventos de inicio de sesión fallidos (Event ID 4625). ¿Cuántos hay? ¿Desde qué IPs vienen?

💡 Pista: Usa el filtro de psort con la cadena '4625' y exporta a CSV. Luego analiza con grep.

Ver solución

log2timeline.py --parsers evtx output/security.plaso artefactos/Security.evtx --- psort.py -o l2tcsv -w export/fallos.csv output/security.plaso "message CONTAINS '4625'" --- Analizar: grep '4625' export/fallos.csv | wc -l

🌐

Ejercicio 3 — Historial del Navegador

Objetivo: extraer URLs visitadas, descargas y cookies de Chrome, Firefox y Edge

Artefactos de navegador

El historial del navegador revela qué sitios visitó el usuario y qué descargó

BROWSER ARTIFACTS

Localizar archivos de base de datos del navegadorLOCALIZACIÓN

Rutas de los perfiles de navegador en Windows

# Google Chrome:
# C:\Users\<usuario>\AppData\Local\Google\Chrome\User Data\Default\History
# C:\Users\<usuario>\AppData\Local\Google\Chrome\User Data\Default\Downloads

# Mozilla Firefox:
# C:\Users\<usuario>\AppData\Roaming\Mozilla\Firefox\Profiles\<id>\places.sqlite

# Microsoft Edge (Chromium):
# C:\Users\<usuario>\AppData\Local\Microsoft\Edge\User Data\Default\History

# Copiar para analisis offline (PowerShell):
$u = 'jdoe'
$dst = 'C:\Forensics\browsers'
New-Item -ItemType Directory -Force $dst
Copy-Item "C:\Users\$u\AppData\Local\Google\Chrome\User Data\Default\History"
    "$dst\chrome_history"

Procesar el historial con PlasoPROCESADO

Procesar bases de datos de navegadores

# Chrome / Edge:
log2timeline.py \
  --parsers chrome_history \
  ~/plaso_lab/output/chrome.plaso \
  ~/plaso_lab/artefactos/browsers/chrome_history

# Firefox:
log2timeline.py \
  --parsers firefox_history \
  ~/plaso_lab/output/firefox.plaso \
  ~/plaso_lab/artefactos/browsers/firefox_profiles/

# Todos los navegadores de una carpeta:
log2timeline.py \
  --parsers chrome_history,firefox_history,msie_typed_urls \
  ~/plaso_lab/output/navegadores.plaso \
  ~/plaso_lab/artefactos/browsers/

Analizar URLs visitadas buscando indicadores de compromisoANÁLISIS

Exportar y analizar historial de navegacion

# Exportar historial a CSV:
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/historial_web.csv \
  ~/plaso_lab/output/navegadores.plaso

# Buscar URLs de interes forense (exfiltracion, C2):
grep -i 'pastebin\|mega\|dropbox\|transfer.sh\|webhook' \
  ~/plaso_lab/export/historial_web.csv

# Buscar conexiones a IPs directas (posibles C2):
grep -oP 'https?://[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' \
  ~/plaso_lab/export/historial_web.csv | sort -u

# Top dominios visitados:
grep -oP 'https?://([a-zA-Z0-9.-]+)' ~/plaso_lab/export/historial_web.csv | \
  sort | uniq -c | sort -rn | head -20

# Buscar descarga de herramientas de ataque:
grep -iE '(mimikatz|psexec|cobaltstrike|meterpreter|hacktools)' \
  ~/plaso_lab/export/historial_web.csv

❓ Ejercicio práctico

Procesa el historial de Chrome de un sistema y busca si el usuario visitó alguna página de descarga de herramientas de hacking en las 48 horas antes del incidente.

💡 Pista: Filtra el CSV por fecha y busca dominios como github.com o nombres de herramientas conocidas.

Ver solución

psort.py -o l2tcsv -w export/chrome_48h.csv output/navegadores.plaso --slice 'FECHA_INCIDENTE' --slice_size 2 --- grep -iE '(mimikatz|psexec|cobaltstrike)' export/chrome_48h.csv

📊

Ejercicio 4 — Logs IIS y Apache

Objetivo: procesar logs de servidores web para detectar ataques y webshells

Logs de servidor web

IIS y Apache registran cada petición HTTP: vector ideal para detectar ataques web

WEB LOGS

Localizar y recolectar los logs del servidor webRECOLECCIÓN

Rutas de logs IIS y Apache

# IIS en Windows:
# C:\inetpub\logs\LogFiles\W3SVC1\
# Formato: u_ex250115.log (fecha en el nombre del archivo)

# Apache en Linux:
# /var/log/apache2/access.log
# /var/log/apache2/error.log

# Nginx:
# /var/log/nginx/access.log

# Copiar para analisis:
sudo cp /var/log/apache2/access.log ~/plaso_lab/artefactos/

# En Windows IIS:
Copy-Item 'C:\inetpub\logs\LogFiles\W3SVC1' C:\Forensics\iis_logs -Recurse

Procesar logs IIS y Apache con PlasoPROCESADO

Procesar logs de servidor web

# Logs IIS (formato W3C):
log2timeline.py \
  --parsers iis \
  ~/plaso_lab/output/iis.plaso \
  ~/plaso_lab/artefactos/iis_logs/

# Logs Apache:
log2timeline.py \
  --parsers apache_access \
  ~/plaso_lab/output/apache.plaso \
  ~/plaso_lab/artefactos/access.log

# Logs Linux (syslog + auth.log):
log2timeline.py \
  --parsers syslog \
  ~/plaso_lab/output/linux_sys.plaso \
  ~/plaso_lab/artefactos/syslog

# Combinar IIS + Apache + EventLogs en una timeline:
log2timeline.py \
  ~/plaso_lab/output/servidor_completo.plaso \
  ~/plaso_lab/artefactos/servidor/

Detectar ataques web en los logs exportadosANÁLISIS

Buscar patrones de ataque en los logs web

# Exportar logs web a CSV:
psort.py \
  -o l2tcsv \
  -w ~/plaso_lab/export/web_logs.csv \
  ~/plaso_lab/output/apache.plaso

# Buscar inyeccion SQL:
grep -i 'UNION\|SELECT\|INSERT\|DROP\|xp_cmd' \
  ~/plaso_lab/export/web_logs.csv

# Buscar webshells (cmd.php, shell.aspx, etc.):
grep -iE '(cmd|shell|upload|webshell|c99|r57)\.php' \
  ~/plaso_lab/export/web_logs.csv

# Buscar path traversal:
grep -E '\.\./' ~/plaso_lab/export/web_logs.csv

# Buscar scanning automatizado:
grep -iE '(nikto|sqlmap|nmap|masscan)' \
  ~/plaso_lab/export/web_logs.csv

# Top IPs por volumen (posible scanner):
grep -oP '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' \
  ~/plaso_lab/export/web_logs.csv | sort | uniq -c | sort -rn | head -10

❓ Ejercicio práctico

Analiza los logs IIS o Apache de un servidor web y busca evidencia de que un atacante subió y ejecutó una webshell. ¿Qué patrones buscarías?

💡 Pista: Una webshell se sube (POST a un script de upload) y luego se accede a ella con GET/POST repetidos con parametros como cmd= o exec=

Ver solución

Patron tipico: (1) POST a upload.php con respuesta 200, (2) GET/POST repetidos a un archivo PHP nuevo con cmd= o c=, (3) Respuestas con Content-Length variable. En la timeline: subida -> accesos a la webshell en minutos u horas.

▶

Ejercicio 5 — Prefetch, MFT y Registro de Windows

Objetivo: recuperar ejecución de programas y actividad del sistema de archivos

Artefactos del sistema Windows

Prefetch, MFT y Registry revelan qué programas se ejecutaron y cuándo

SYSTEM ARTIFACTS

Procesar archivos PrefetchPREFETCH

Prefetch: programas ejecutados con timestamps

# Prefetch registra la ejecucion de programas con timestamps
# Ubicacion: C:\Windows\Prefetch\

# Copiar Prefetch para analisis:
robocopy C:\Windows\Prefetch C:\Forensics\Prefetch /E

# Procesar con Plaso:
log2timeline.py \
  --parsers prefetch \
  ~/plaso_lab/output/prefetch.plaso \
  ~/plaso_lab/artefactos/Prefetch/

# Exportar y buscar herramientas maliciosas:
psort.py -o l2tcsv -w ~/plaso_lab/export/prefetch.csv \
  ~/plaso_lab/output/prefetch.plaso

grep -iE '(mimikatz|meterpreter|cobalt|psexec|wce|procdump|wmiexec|netcat)' \
  ~/plaso_lab/export/prefetch.csv

💡 El Prefetch guarda hasta 8 timestamps de ultima ejecucion por programa. Si Mimikatz.exe aparece en Prefetch, el atacante lo ejecuto aunque lo borrara despues: el archivo Prefetch permanece en el sistema.

Procesar el MFT (Master File Table)MFT

MFT: metadatos de todos los archivos del sistema

# El $MFT contiene timestamps de TODOS los archivos:
# - Created (SI_Created)
# - Modified (SI_Modified)
# - Accessed (SI_Accessed)
# - MFT Modified (SI_MFT)

# Procesar $MFT con Plaso:
log2timeline.py \
  --parsers mft \
  ~/plaso_lab/output/mft.plaso \
  ~/plaso_lab/artefactos/MFT

# Buscar archivos creados en una fecha especifica:
psort.py -o l2tcsv -w ~/plaso_lab/export/mft.csv \
  ~/plaso_lab/output/mft.plaso \
  --slice '2025-01-10T00:00:00' --slice_size 1

# Buscar archivos sospechosos por ruta:
grep -iE '(\.exe|\.dll|\.ps1|\.bat|\.vbs)' \
  ~/plaso_lab/export/mft.csv | \
  grep -i 'temp\|appdata\|public\|programdata' | head -20

Procesar el Registro de WindowsREGISTRY

Registro de Windows: persistencia y configuracion

# Hives mas importantes para forense:
# NTUSER.DAT : por usuario (MRU, programas ejecutados, run keys)
# SYSTEM     : servicios, interfaces de red, timezone
# SOFTWARE   : software instalado, run keys globales
# SAM        : usuarios y hashes

# Procesar el registro:
log2timeline.py \
  --parsers winreg \
  ~/plaso_lab/output/registry.plaso \
  ~/plaso_lab/artefactos/registry/

# Exportar y buscar persistencia (Run keys):
psort.py -o l2tcsv -w ~/plaso_lab/export/registry.csv \
  ~/plaso_lab/output/registry.plaso

grep -i 'HKLM.*Run\|HKCU.*Run\|CurrentVersion.*Run' \
  ~/plaso_lab/export/registry.csv | head -20

# Buscar servicios instalados recientemente:
grep -i 'SYSTEM.*Services' ~/plaso_lab/export/registry.csv | \
  grep -v 'EventLog' | head -20

❓ Ejercicio práctico

Procesa los archivos Prefetch de un sistema y lista todos los ejecutables que corrieron en las 24 horas del incidente. ¿Aparece alguno desde una ruta sospechosa?

💡 Pista: log2timeline + psort con filtro de fecha y busqueda de rutas sospechosas en el CSV.

Ver solución

log2timeline.py --parsers prefetch output/prefetch.plaso artefactos/Prefetch/ --- psort.py -o l2tcsv -w export/prefetch_dia.csv output/prefetch.plaso --slice 'FECHA' --slice_size 1 --- grep -i 'temp\|appdata\|downloads\|public' export/prefetch_dia.csv

🔎

Ejercicio 6 — psort: Filtrado y Análisis Avanzado

Objetivo: dominar el lenguaje de filtros de psort para extraer evidencia precisa

psort.py es la herramienta de post-procesado de Plaso. Permite filtrar los eventos del archivo .plaso con una sintaxis muy expresiva y exportarlos en múltiples formatos. Dominar sus filtros es clave para trabajar eficientemente con líneas de tiempo grandes.

Filtros básicos de psortFILTROS BÁSICOS

Sintaxis de filtros psort y ejemplos practicos

# OPERADORES:
# campo CONTAINS 'texto'           : busca texto en el campo
# campo IS 'valor_exacto'           : igualdad exacta
# campo IS NOT 'valor'              : diferente
# timestamp > 'YYYY-MM-DDTHH:MM:SS' : despues de esta fecha
# AND, OR, NOT                      : operadores logicos

# CAMPOS MAS UTILES:
# message    : descripcion completa del evento
# parser     : nombre del parser que genero el evento
# timestamp  : marca de tiempo
# hostname   : nombre del equipo
# username   : usuario asociado
# filename   : archivo asociado

# EJEMPLOS:

# Solo eventos del dia del incidente:
psort.py -o l2tcsv -w export/dia.csv caso.plaso \
  "timestamp > '2025-01-10T00:00:00' AND timestamp < '2025-01-10T23:59:59'"

# Solo eventos de autenticacion:
psort.py -o l2tcsv -w export/auth.csv caso.plaso \
  "message CONTAINS '4624' OR message CONTAINS '4625'"

# Solo un parser especifico:
psort.py -o l2tcsv -w export/prefetch.csv caso.plaso \
  "parser IS 'prefetch'"

# Prefetch del dia del incidente:
psort.py -o l2tcsv -w export/prefetch_dia.csv caso.plaso \
  "parser IS 'prefetch' AND timestamp > '2025-01-10T00:00:00'"

Filtros avanzados y combinadosFILTROS AVANZADOS

Filtros avanzados con multiples condiciones

# Filtrar por hostname (eventos de multiples hosts mezclados):
psort.py -o l2tcsv -w export/server01.csv caso.plaso \
  "hostname CONTAINS 'SERVER01'"

# Buscar una IP especifica:
psort.py -o l2tcsv -w export/ip_atacante.csv caso.plaso \
  "message CONTAINS '192.168.1.100'"

# Excluir parsers de poco interes para reducir ruido:
psort.py -o l2tcsv -w export/sin_mft.csv caso.plaso \
  "parser IS NOT 'filestat' AND parser IS NOT 'mft'"

# Combinar host + periodo + parser:
psort.py -o l2tcsv -w export/web01_security.csv caso.plaso \
  "hostname CONTAINS 'WEB01' AND parser IS 'evtx' \
  AND timestamp > '2025-01-10T14:00:00' AND timestamp < '2025-01-10T18:00:00'"

# Buscar eventos con tags asignadas por los analizadores:
psort.py -o l2tcsv -w export/sospechosos.csv caso.plaso \
  "tag CONTAINS 'malware' OR tag CONTAINS 'authentication'"

Exportar en diferentes formatosFORMATOS DE SALIDA

Todos los formatos de exportacion de psort

# CSV (el mas comun para Excel/LibreOffice/grep):
psort.py -o l2tcsv -w export/timeline.csv caso.plaso

# JSON (para scripts Python o importar en herramientas):
psort.py -o json -w export/timeline.json caso.plaso

# JSONL dinamico (para Timesketch):
psort.py -o dynamic -w export/timesketch.jsonl caso.plaso

# Excel directamente:
psort.py -o xlsx -w export/timeline.xlsx caso.plaso

# TLN (para Timeline Explorer de Eric Zimmerman):
psort.py -o tln -w export/timeline.tln caso.plaso

# Texto legible en terminal (revision rapida):
psort.py -o huma caso.plaso | head -100

# Ver todos los formatos disponibles:
psort.py --output-format list

❓ Ejercicio práctico

Tienes un .plaso de un servidor web Windows comprometido. Construye un filtro psort que extraiga solo eventos de los parsers evtx e iis del dia del incidente y los exporte a CSV en orden cronologico.

💡 Pista: Combina filtros de parser con filtros de timestamp usando AND y OR.

Ver solución

psort.py -o l2tcsv -w export/incidente_web.csv servidor.plaso "(parser IS 'evtx' OR parser IS 'iis') AND timestamp > '2025-01-10T00:00:00' AND timestamp < '2025-01-10T23:59:59'" --- El CSV resultante tiene ambas fuentes mezcladas cronologicamente, permitiendo correlacionar peticiones HTTP con eventos del sistema.

🔗

Ejercicio 7 — Exportar a Timesketch

Objetivo: visualizar la línea de tiempo en la plataforma colaborativa Timesketch

Visualización en Timesketch

La plataforma colaborativa de DFIR creada por Google para análisis de timelines

TIMESKETCH

Timesketch es una plataforma web open source creada por Google para el análisis colaborativo de líneas de tiempo forenses. Permite visualizar los eventos de Plaso en una interfaz gráfica interactiva, añadir comentarios, etiquetar eventos sospechosos, colaborar con otros analistas y ejecutar queries de búsqueda avanzada. Es la plataforma usada por los equipos de Google Mandiant.

Instalar Timesketch con DockerINSTALACIÓN

Instalar Timesketch

# Instalacion con Docker Compose (la mas sencilla):
curl -s -O https://raw.githubusercontent.com/google/timesketch/master/contrib/deploy/docker-compose.yml
docker compose up -d

# Crear usuario administrador:
docker compose exec timesketch tsctl create-user admin

# Acceder en el navegador:
# http://localhost:5000
# Usuario: admin / contrasena: la que elegiste

Exportar el .plaso a formato TimesketchEXPORTADO

Exportar a Timesketch JSONL

# Exportar desde psort al formato que Timesketch acepta:
psort.py \
  -o dynamic \
  -w ~/plaso_lab/export/timesketch_import.jsonl \
  ~/plaso_lab/output/caso01.plaso

# Importar directamente con el CLI de Timesketch:
pip3 install timesketch-import-client

timesketch_importer \
  --host http://localhost:5000 \
  --username admin \
  --password tu_password \
  --sketch_id 1 \
  --timeline_name 'Caso 01 - Incidente Enero' \
  ~/plaso_lab/export/timesketch_import.jsonl

Analizar en la interfaz web de TimesketchANÁLISIS VISUAL

Queries de Timesketch (sintaxis Lucene/OpenSearch)

# En la interfaz web de Timesketch, las queries usan sintaxis Lucene:

# Buscar eventos de autenticacion:
message:"4624" OR message:"4625"

# Buscar actividad de una IP especifica:
message:"192.168.1.100"

# Buscar ejecucion de herramientas sospechosas:
message:"mimikatz" OR message:"psexec" OR message:"meterpreter"

# Buscar eventos de un host especifico:
hostname:"WORKSTATION01"

# Combinar host + periodo:
hostname:"WORKSTATION01" AND timestamp:[2025-01-10T00:00:00 TO 2025-01-10T23:59:59]

# Etiquetar eventos como sospechosos:
# Click en el evento -> 'Add tag' -> 'malicious'

# Anadir comentario a un evento:
# Click en el evento -> 'Add comment' -> descripcion del hallazgo

🔴

Caso Práctico — Trazar el Movimiento Lateral de un Atacante

Reconstruir paso a paso cómo se movió el atacante entre sistemas

Escenario: el CSIRT recibe una alerta de que el servidor FILESERVER01 fue comprometido. Tienes disponibles los Event Logs de tres servidores (DC01, WEBSERVER01, FILESERVER01), los logs IIS del servidor web y los archivos Prefetch de FILESERVER01. Tu misión: reconstruir exactamente cómo entró el atacante, cómo se movió lateralmente y qué acciones realizó.

Procesado multi-host: crear una timeline unificadaPASO 1

Procesar artefactos de multiples hosts en un solo .plaso

# Estructura del caso:
# artefactos/
#   DC01/     -> evtx del controlador de dominio
#   WEB01/    -> evtx + logs IIS del servidor web
#   FILE01/   -> evtx + prefetch + registry del fileserver

# Procesar todos en UN SOLO archivo .plaso:
log2timeline.py \
  --status_view linear \
  ~/plaso_lab/output/caso_lateral.plaso \
  ~/plaso_lab/artefactos/

# Plaso anade el campo 'hostname' a cada evento
# para distinguir el origen de cada uno

pinfo.py ~/plaso_lab/output/caso_lateral.plaso

✅ Un solo .plaso con eventos de los 3 hosts mezclados y ordenados cronologicamente

Fase 1: Detectar el punto de entrada en WEBSERVER01ENTRADA

Buscar el punto de entrada inicial

# Exportar logs IIS de WEB01 buscando el ataque inicial:
psort.py -o l2tcsv -w export/web_attack.csv caso_lateral.plaso \
  "hostname CONTAINS 'WEB01' AND parser IS 'iis'"

# Buscar peticiones anomalas:
grep -iE '(\.php.*cmd=|SELECT|UNION|../|%2e%2e)' export/web_attack.csv

# Buscar la IP del atacante (muchas peticiones seguidas):
grep -oP '[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}' \
  export/web_attack.csv | sort | uniq -c | sort -rn | head -5

# Con la IP del atacante identificada (ej: 10.0.0.50):
grep '10.0.0.50' export/web_attack.csv | head -20

💡 El punto de entrada suele ser la primera peticion HTTP con codigo 200 a un archivo PHP/ASPX no estandar, o el primer error 500 seguido de un 200 (SQLi exitosa).

Fase 2: Post-explotación en WEBSERVER01POST-EXPLOT

Detectar actividad post-explotacion en el servidor web

# Buscar en EventLogs de WEB01 inmediatamente despues del ataque:
psort.py -o l2tcsv -w export/web01_postexp.csv caso_lateral.plaso \
  "hostname CONTAINS 'WEB01' AND parser IS 'evtx' \
  AND timestamp > '2025-01-10T14:30:00' AND timestamp < '2025-01-10T16:00:00'"

# Buscar nuevos procesos creados (Event ID 4688):
grep '4688' export/web01_postexp.csv | grep -i 'w3wp\|apache\|php'

# Buscar PowerShell ejecutado (Event ID 4104):
grep '4104' export/web01_postexp.csv | head -20

# Buscar conexiones de red salientes (Sysmon Event ID 3):
grep -i 'sysmon.*network\|EventID.*3' export/web01_postexp.csv | head -10

Fase 3: Movimiento lateral hacia DC01 o FILESERVER01MOVIMIENTO LATERAL

Detectar movimiento lateral entre hosts

# El movimiento lateral deja estas huellas:
# - En el HOST ORIGEN:  proceso crea conexion SMB/WinRM/RDP
# - En el HOST DESTINO: Event ID 4624 LogonType=3 desde la IP del origen

# Buscar en DC01 logons desde la IP de WEB01:
psort.py -o l2tcsv -w export/dc01_logons.csv caso_lateral.plaso \
  "hostname CONTAINS 'DC01' AND parser IS 'evtx' \
  AND message CONTAINS '4624' AND message CONTAINS '10.0.1.100'"

# Buscar en FILESERVER01 logons desde IPs inesperadas:
psort.py -o l2tcsv -w export/file01_logons.csv caso_lateral.plaso \
  "hostname CONTAINS 'FILE01' AND message CONTAINS '4624'"

# Buscar herramientas de movimiento lateral en el Prefetch de FILE01:
psort.py -o l2tcsv -w export/file01_prefetch.csv caso_lateral.plaso \
  "hostname CONTAINS 'FILE01' AND parser IS 'prefetch'"

grep -iE '(psexec|wmiexec|smbexec|atexec|winrm|wmic)' \
  export/file01_prefetch.csv

Construir la super línea de tiempo del ataque completaTIMELINE FINAL

Timeline unificada del movimiento lateral

# Exportar TODOS los eventos relevantes del caso:
psort.py -o l2tcsv \
  -w export/TIMELINE_COMPLETA.csv \
  caso_lateral.plaso \
  "timestamp > '2025-01-10T14:00:00' AND timestamp < '2025-01-10T18:00:00'"

# La timeline deberia mostrar algo como:
# 14:32:01  WEB01    [IIS]     POST /upload.php -> 200 OK
# 14:32:15  WEB01    [EVTX]    4688: w3wp.exe -> cmd.exe
# 14:33:45  WEB01    [EVTX]    4688: cmd.exe -> powershell.exe (encoded)
# 14:35:20  WEB01    [SYSMON]  Network: WEB01 -> DC01:445 (SMB)
# 14:35:22  DC01     [EVTX]    4624: CONTOSO\Administrator LogonType=3 from WEB01
# 14:36:10  DC01     [EVTX]    4688: net group Domain Admins
# 14:37:00  DC01     [EVTX]    4688: new service svc_backdoor created
# 14:40:30  FILE01   [EVTX]    4624: CONTOSO\svc_backdoor LogonType=3
# 14:41:00  FILE01   [EVTX]    4688: robocopy -> datos_confidenciales
# 14:45:00  FILE01   [EVTX]    4688: certutil -encode datos.zip -> exfil.b64

✅ La super linea de tiempo unificada muestra el movimiento del atacante entre hosts en orden cronologico exacto, cruzando Event Logs, IIS y Prefetch

🔎

Referencia: Consultas psort Avanzadas

Filtros y operadores para extraer exactamente lo que necesitas

Consultas psort de referencia para DFIR

# CAMPOS DISPONIBLES:
# timestamp, message, parser, source, hostname, username, filename, tag

# 1. Todos los eventos de un usuario especifico:
psort.py -o l2tcsv -w user_jdoe.csv caso.plaso \
  "username CONTAINS 'jdoe'"

# 2. Nuevos servicios instalados (Event 7045):
psort.py -o l2tcsv -w servicios.csv caso.plaso \
  "message CONTAINS '7045'"

# 3. Fuera de horario laboral (23:00-06:00):
psort.py -o l2tcsv -w noche.csv caso.plaso \
  "timestamp > '2025-01-10T23:00:00' AND timestamp < '2025-01-11T06:00:00'"

# 4. Solo eventos con tags del analizador:
psort.py -o l2tcsv -w malware.csv caso.plaso \
  "tag CONTAINS 'malware'"

# 5. Buscar hash de malware en eventos:
psort.py -o l2tcsv -w hash.csv caso.plaso \
  "message CONTAINS 'e3b0c44298fc1c149afb'"

# 6. Eventos de red de Sysmon (Event ID 3):
psort.py -o l2tcsv -w red_sysmon.csv caso.plaso \
  "message CONTAINS 'Sysmon' AND message CONTAINS 'Network'"

# 7. Logs de IIS y EVTX juntos de un host:
psort.py -o l2tcsv -w web01_todo.csv caso.plaso \
  "hostname CONTAINS 'WEB01' AND (parser IS 'iis' OR parser IS 'evtx')"

# 8. Slice (ventana de tiempo alrededor de un evento):
psort.py -o l2tcsv -w entorno.csv caso.plaso \
  --slice '2025-01-10T14:32:01' --slice_size 1

📚

Parsers Clave de Plaso

Las fuentes más importantes para investigaciones DFIR

Parser	Fuente	Artefactos extraídos
`evtx`	Windows Event Logs (.evtx)	Todos los eventos de Windows: auth, procesos, red, servicios
`prefetch`	Windows Prefetch (.pf)	Programas ejecutados + timestamps de primera/ultima ejecución
`winreg`	Windows Registry (NTUSER.DAT, SYSTEM...)	Run keys, MRU, servicios, timezone, USB, shellbags
`mft`	NTFS Master File Table	Timestamps de todos los archivos (creación, modificación, acceso)
`lnk`	Accesos directos Windows (.lnk)	Archivos accedidos recientemente con timestamps
`chrome_history`	Google Chrome / Edge (SQLite)	URLs visitadas, descargas, cookies, búsquedas
`firefox_history`	Mozilla Firefox (SQLite)	URLs visitadas, descargas, cookies, marcadores
`iis`	Microsoft IIS logs (W3C format)	Peticiones HTTP: URL, IP, user agent, código de respuesta
`apache_access`	Apache/Nginx access logs	Peticiones HTTP en formato Combined Log
`syslog`	Linux syslog, auth.log	Autenticación SSH, sudo, inicio de servicios
`utmp`	Linux wtmp/utmp/btmp	Logins de consola y SSH con timestamps
`sqlite`	Cualquier base de datos SQLite	Contenido de tablas con timestamps
`pe`	Ejecutables PE (.exe/.dll)	Metadata de compilación, timestamps, imports
`olecf`	Documentos Office (.doc, .xls, .ppt)	Timestamps de modificación, metadata de autor

Seleccionar parsers especificos para optimizar el tiempo de procesado

# Investigar actividad de usuario:
log2timeline.py \
  --parsers 'evtx,prefetch,lnk,winreg,chrome_history,firefox_history' \
  output/usuario.plaso artefactos/

# Investigar servidor web comprometido:
log2timeline.py \
  --parsers 'evtx,iis,apache_access,syslog' \
  output/webserver.plaso artefactos/

# Investigar persistencia de malware:
log2timeline.py \
  --parsers 'evtx,prefetch,winreg,mft' \
  output/persistencia.plaso artefactos/

# Investigar exfiltracion de datos:
log2timeline.py \
  --parsers 'evtx,prefetch,chrome_history,firefox_history,mft' \
  output/exfil.plaso artefactos/

📄

Formatos de Salida de psort

Cómo exportar la línea de tiempo según la herramienta de análisis

Formato (-o)	Herramienta destino	Extensión	Mejor para
`l2tcsv`	Excel, LibreOffice, grep, Python	.csv	Análisis manual, filtrado rápido
`json`	Scripts Python, jq, OpenSearch	.json	Procesado programático
`dynamic`	Timesketch, OpenSearch	.jsonl	Visualización colaborativa
`xlsx`	Excel (directo)	.xlsx	Informes formateados
`tln`	Timeline Explorer (Eric Zimmerman)	.tln	Análisis con Timeline Explorer
`huma`	Terminal / revisión rápida	(stdout)	Visualización rápida en terminal

🏆

MITRE ATT&CK — Qué detecta Plaso en cada fase

Correlación entre artefactos forenses y tácticas del atacante

Táctica MITRE	Artefactos que deja	Parser Plaso	Campo a buscar
Initial Access (TA0001)	Peticiones HTTP al vector de entrada	`iis, apache_access`	URL del exploit, IP atacante
Execution (TA0002)	Nuevos procesos creados	`evtx, prefetch`	Event ID 4688, archivos .pf
Persistence (TA0003)	Run keys, servicios, tareas programadas	`winreg, evtx`	7045, 4698, Registry Run keys
Privilege Escalation (TA0004)	Cuentas añadidas a grupos admin	`evtx`	4728, 4732, 4672
Defense Evasion (TA0005)	Logs borrados, timestamps manipulados	`evtx, mft`	1102, 104, discrepancias de timestamps
Credential Access (TA0006)	Ejecución de Mimikatz, volcado LSASS	`prefetch, evtx`	mimikatz.pf, acceso a lsass.exe
Lateral Movement (TA0008)	Logons de red desde otros hosts	`evtx`	4624 LogonType=3, IP de origen
Collection (TA0009)	Acceso masivo a archivos	`mft, evtx`	Timestamps MFT, 4663 (Object Access)
Exfiltration (TA0010)	Uploads en historial web, transferencias	`chrome_history, evtx`	URLs de servicios de almacenamiento

✓ CONCLUSIÓNHas completado el laboratorio de Plaso / Log2Timeline. Ahora sabes: instalar Plaso con Docker, procesar fuentes múltiples (Event Logs, IIS, Prefetch, MFT, historial de navegador), usar psort para filtrar con precisión quirurgica, exportar a Timesketch para visualización colaborativa, y aplicar este flujo a un caso real de movimiento lateral. Plaso es la herramienta que transforma el caos de miles de logs dispersos en una narrativa forense coherente y procesable.