análisis-de-archivos-prefetch-para-historial-de-ejecución

Análisis de Archivos Prefetch para Historial de Ejecución

Cuándo Usar

• Cuando se necesita determinar qué programas se ejecutaron en un sistema Windows y cuándo
• Durante investigaciones de malware para confirmar la ejecución de binarios sospechosos
• Para establecer una línea de tiempo de uso de aplicaciones durante un incidente
• Al correlacionar la ejecución de programas con otros artefactos forenses
• Para identificar herramientas anti-forenses o software no autorizado que se haya ejecutado

Requisitos Previos

• Acceso al directorio Prefetch de Windows (C:\Windows\Prefetch) desde una imagen forense
• PECmd (Eric Zimmerman), WinPrefetchView o el analizador python-prefetch
• Comprensión del formato del archivo Prefetch (versiones 17, 23, 26, 30)
• Sistema Windows con Prefetch habilitado (por defecto en SO cliente, deshabilitado en servidores)
• Conocimiento de las convenciones de nomenclatura de Prefetch (APPNAME-HASH.pf)

Flujo de Trabajo

Paso 1: Extraer Archivos Prefetch de la Imagen Forense

# Montar la imagen forense
mount -o ro,loop,offset=$((2048*512)) /cases/case-2024-001/images/evidence.dd /mnt/evidence

# Copiar todos los archivos prefetch
mkdir -p /cases/case-2024-001/prefetch/
cp /mnt/evidence/Windows/Prefetch/*.pf /cases/case-2024-001/prefetch/

# Contar y listar archivos prefetch
ls -la /cases/case-2024-001/prefetch/ | wc -l
ls -la /cases/case-2024-001/prefetch/ | head -30

# Generar hash de todos los archivos prefetch para integridad
sha256sum /cases/case-2024-001/prefetch/*.pf > /cases/case-2024-001/prefetch/pf_hashes.txt

# Nota: El formato del nombre del archivo Prefetch es NOMBRE_EJECUTABLE-XXXXXXXX.pf
# El hash (XXXXXXXX) se basa en la ruta del ejecutable
# El mismo ejecutable desde diferentes rutas crea diferentes archivos prefetch

Paso 2: Analizar Archivos Prefetch con PECmd

# Usando PECmd de Eric Zimmerman (Windows o mediante Mono/Wine en Linux)
# Descargar desde https://ericzimmerman.github.io/

# Analizar un solo archivo prefetch
PECmd.exe -f "C:\cases\prefetch\POWERSHELL.EXE-A]B2C3D4.pf"

# Analizar todos los archivos prefetch y exportar a CSV
PECmd.exe -d "C:\cases\prefetch\" --csv "C:\cases\analysis\" --csvf prefetch_results.csv

# Analizar con salida JSON
PECmd.exe -d "C:\cases\prefetch\" --json "C:\cases\analysis\" --jsonf prefetch_results.json

# La salida incluye para cada archivo:
# - Nombre y ruta del ejecutable
# - Número de ejecuciones
# - Último tiempo de ejecución (hasta 8 marcas de tiempo en Windows 10)
# - Archivos y directorios referenciados durante la ejecución
# - Información del volumen (número de serie, fecha de creación)
# - Hora de creación del archivo Prefetch

Paso 3: Analizar con Python para Análisis en Linux

pip install prefetch

python3 << 'PYEOF'
import os
import json
from datetime import datetime

# Analizar archivos prefetch usando python
import struct

def parse_prefetch(filepath):
    """Analiza un archivo Prefetch de Windows."""
    with open(filepath, 'rb') as f:
        data = f.read()

    # Verificar formato comprimido MAM (Windows 10)
    if data[:4] == b'MAM\x04':
        import lznt1  # o usar DecompressBuffer
        # Los archivos prefetch de Windows 10 están comprimidos
        print(f"  [Formato Win10 comprimido - usar PECmd para análisis completo]")
        return None

    # Versión 17 (XP), 23 (Vista/7), 26 (8.1), 30 (10)
    version = struct.unpack('<I', data[0:4])[0]
    signature = data[4:8]

    if signature != b'SCCA':
        print(f"  Firma de Prefetch inválida")
        return None

    file_size = struct.unpack('<I', data[8:12])[0]
    exec_name = data[16:76].decode('utf-16-le').strip('\x00')
    run_count = struct.unpack('<I', data[208:212])[0] if version >= 23 else struct.unpack('<I', data[144:148])[0]

    result = {
        'version': version,
        'executable': exec_name,
        'file_size': file_size,
        'run_count': run_count,
    }

    # Extraer últimas marcas de tiempo de ejecución
    if version == 23:  # Vista/7 - 1 marca de tiempo
        ts = struct.unpack('<Q', data[128:136])[0]
        result['last_run'] = filetime_to_datetime(ts)
    elif version >= 26:  # Win8+ - hasta 8 marcas de tiempo
        timestamps = []
        for i in range(8):
            ts = struct.unpack('<Q', data[128+i*8:136+i*8])[0]
            if ts > 0:
                timestamps.append(filetime_to_datetime(ts))
        result['last_run_times'] = timestamps

    return result

def filetime_to_datetime(ft):
    """Convierte FILETIME de Windows a cadena de fecha y hora."""
    if ft == 0:
        return None
    timestamp = (ft - 116444736000000000) / 10000000
    try:
        return datetime.utcfromtimestamp(timestamp).strftime('%Y-%m-%d %H:%M:%S UTC')
    except (OSError, ValueError):
        return None

# Procesar todos los archivos prefetch
prefetch_dir = '/cases/case-2024-001/prefetch/'
results = []

for filename in sorted(os.listdir(prefetch_dir)):
    if filename.lower().endswith('.pf'):
        filepath = os.path.join(prefetch_dir, filename)
        print(f"\n=== {filename} ===")
        result = parse_prefetch(filepath)
        if result:
            print(f"  Ejecutable: {result['executable']}")
            print(f"  Núm. Ejecuciones: {result['run_count']}")
            if 'last_run' in result:
                print(f"  Última Ejecución: {result['last_run']}")
            elif 'last_run_times' in result:
                for i, ts in enumerate(result['last_run_times']):
                    print(f"  Hora Ejecución {i+1}: {ts}")
            results.append(result)

# Guardar resultados
with open('/cases/case-2024-001/analysis/prefetch_analysis.json', 'w') as f:
    json.dump(results, f, indent=2)
PYEOF

Paso 4: Identificar Evidencia de Ejecución Sospechosa

# Buscar nombres de herramientas maliciosas conocidas en prefetch
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(MIMIKATZ|PSEXEC|WMIC|COBALT|BEACON|PWDUMP|PROCDUMP|LAZAGNE|RUBEUS|BLOODHOUND|SHARPHOUND|CERTUTIL|BITSADMIN)'

# Buscar intérpretes de scripts (posible ejecución maliciosa)
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(POWERSHELL|CMD\.EXE|WSCRIPT|CSCRIPT|MSHTA|REGSVR32|RUNDLL32|MSIEXEC)'

# Buscar herramientas de acceso remoto
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(TEAMVIEWER|ANYDESK|LOGMEIN|VNC|SPLASHTOP|SCREENCONNECT|AMMYY)'

# Buscar herramientas de exfiltración de datos
ls /cases/case-2024-001/prefetch/ | grep -iE \
   '(RAR|7Z|ZIP|RCLONE|MEGA|DROPBOX|ONEDRIVE|GDRIVE|FTP|CURL|WGET)'

# Encontrar archivos prefetch creados recientemente (ejecutables más nuevos)
ls -lt /cases/case-2024-001/prefetch/ | head -20

# Cruzar referencias con Shimcache y Amcache para confirmación
# La existencia de Prefetch = el programa se ejecutó al menos una vez

Paso 5: Construir Línea de Tiempo de Ejecución

# Crear línea de tiempo a partir de datos prefetch
python3 << 'PYEOF'
import json
import csv

with open('/cases/case-2024-001/analysis/prefetch_analysis.json') as f:
    data = json.load(f)

timeline = []
for entry in data:
    if 'last_run_times' in entry:
        for ts in entry['last_run_times']:
            if ts:
                timeline.append({
                    'timestamp': ts,
                    'executable': entry['executable'],
                    'run_count': entry['run_count'],
                    'source': 'Prefetch'
                })
    elif 'last_run' in entry and entry['last_run']:
        timeline.append({
            'timestamp': entry['last_run'],
            'executable': entry['executable'],
            'run_count': entry['run_count'],
            'source': 'Prefetch'
        })

# Ordenar cronológicamente
timeline.sort(key=lambda x: x['timestamp'])

# Escribir CSV de la línea de tiempo
with open('/cases/case-2024-001/analysis/execution_timeline.csv', 'w', newline='') as f:
    writer = csv.DictWriter(f, fieldnames=['timestamp', 'executable', 'run_count', 'source'])
    writer.writeheader()
    writer.writerows(timeline)

# Imprimir ventana de tiempo sospechosa
for entry in timeline:
    if '2024-01-15' in entry['timestamp'] or '2024-01-16' in entry['timestamp']:
        print(f"  {entry['timestamp']} | {entry['executable']} (x{entry['run_count']})")
PYEOF

Conceptos Clave

Concepto	Descripción
Prefetch	Optimización de rendimiento de Windows que precarga datos de aplicaciones y rastrea la ejecución
Firma SCCA	Bytes mágicos que identifican un archivo Prefetch válido
Hash de ruta	Hash basado en CRC de la ruta del ejecutable que forma parte del nombre del archivo .pf
Número de ejecuciones	Número de veces que se ha lanzado el ejecutable (puede reiniciarse)
Marcas de tiempo de última ejecución	Windows 8+ almacena hasta 8 marcas de tiempo de ejecución más recientes
Archivos referenciados	Lista de archivos y directorios accedidos durante los primeros 10 segundos de ejecución
Información del volumen	Número de serie de la unidad y fecha de creación que identifican el volumen de origen
Compresión MAM	Los archivos Prefetch de Windows 10 usan compresión MAM4 que requiere descompresión antes del análisis

Herramientas y Sistemas

Herramienta	Propósito
PECmd	Analizador de Prefetch de Eric Zimmerman con salida CSV/JSON
WinPrefetchView	Herramienta GUI de NirSoft para ver archivos Prefetch
python-prefetch	Librería Python para analizar archivos Prefetch
Prefetch Hash Calculator	Herramienta para calcular el hash esperado a partir de rutas de ejecutables
KAPE	Recopilación automatizada de artefactos, incluyendo Prefetch
Autopsy	Plataforma forense con módulo de análisis de Prefetch
Plaso/log2timeline	Herramienta de super-línea de tiempo que incluye analizador de Prefetch
Velociraptor	Agente de endpoint con artefactos de recopilación y análisis de Prefetch

Escenarios Comunes

Escenario 1: Confirmar Ejecución de Malware Buscar en el directorio Prefetch el nombre del ejecutable de malware, confirmar la ejecución mediante la existencia del Prefetch, extraer el número de ejecuciones y la última hora de ejecución, identificar DLLs referenciados para entender el comportamiento del malware, correlacionar con entradas de ejecución automática del registro.

Escenario 2: Línea de Tiempo de Uso de Herramientas del Atacante Identificar archivos Prefetch de PsExec, Mimikatz, BloodHound y otras herramientas del atacante, construir una línea de tiempo cronológica de la ejecución de herramientas, determinar la secuencia del ataque (reconocimiento, robo de credenciales, movimiento lateral), coincidir marcas de tiempo con registros de conexión de red.

Escenario 3: Preparación y Exfiltración de Datos Buscar entradas Prefetch de herramientas de compresión (7z, WinRAR, zip), identificar ejecución de utilidades de transferencia de archivos (rclone, clientes FTP), verificar ejecución de clientes de almacenamiento en la nube, cronologizar cuándo ocurrieron la preparación y transferencia de datos.

Escenario 4: Detección de Anti-Forense Verificar la ejecución de herramientas anti-forenses conocidas (CCleaner, Eraser, SDelete), identificar si el directorio Prefetch fue limpiado recientemente (menos archivos de los esperados para un sistema activo), anotar marcas de tiempo de ejecución de herramientas anti-forenses en relación con otra evidencia.

Formato de Salida

Resumen de Análisis Prefetch:
  Sistema: Windows 10 Pro (Build 19041)
  Archivos Prefetch: 234
  Período de Análisis: Todo el historial de ejecución disponible

  Estadísticas de Ejecución:
    Ejecutables únicos totales: 234
    Primera ejecución: 2023-06-15 (instalación del sistema)
    Última ejecución: 2024-01-18 23:45 UTC

  Ejecuciones Sospechosas:
    MIMIKATZ.EXE-5F2A3B1C.pf
      Núm. Ejecuciones: 3 | Última: 2024-01-16 02:30:15 UTC
    PSEXEC.EXE-AD70946C.pf
      Núm. Ejecuciones: 7 | Última: 2024-01-16 02:45:30 UTC
    RCLONE.EXE-1F3E5A2B.pf
      Núm. Ejecuciones: 2 | Última: 2024-01-17 03:15:00 UTC
    POWERSHELL.EXE-022A1004.pf
      Núm. Ejecuciones: 145 | Última: 2024-01-18 14:00:00 UTC

  Línea de Tiempo del Ataque (desde Prefetch):
    2024-01-15 14:32 - POWERSHELL.EXE (acceso inicial)
    2024-01-16 02:30 - MIMIKATZ.EXE (robo de credenciales)
    2024-01-16 02:45 - PSEXEC.EXE (movimiento lateral)
    2024-01-17 03:15 - RCLONE.EXE (exfiltración de datos)

  Informe: /cases/case-2024-001/analysis/execution_timeline.csv