KAPE — Triáje Forense Rápido — GhostAcademy SecLearn

📊

¿Qué es KAPE?

Triáje forense rápido: recolectar artefactos críticos en minutos

KAPE (Kroll Artifact Parser and Extractor) es una herramienta forense desarrollada por Eric Zimmerman (ex analista del FBI y DoD) y actualmente mantenida por Kroll. Es el estándar de la industria para el triáje forense rápido en entornos corporativos: permite recolectar en minutos exactamente los artefactos forenses críticos de un sistema Windows sin necesidad de clonar el disco completo.

La diferencia fundamental con un volcado de disco completo es el tiempo y la precisión:

Clonado de disco completo: 2-8 horas, 100-500 GB de datos, el sistema no puede seguir operando durante la recolección
Triáje con KAPE: 2-10 minutos, 100-500 MB de artefactos seleccionados, el sistema puede continuar operando

KAPE es usado a diario por equipos de DFIR (Digital Forensics and Incident Response) de empresas como Mandiant, CrowdStrike y KPMG, por fuerzas del orden, y por analistas SOC para respuesta rápida a incidentes.

🛡 HERRAMIENTA EXCLUSIVAMENTE DEFENSIVA / FORENSEKAPE es una herramienta de respuesta a incidentes y forense digital defensivo. Recolecta artefactos de sistemas propios o bajo investigación legal. Su uso requiere autorización del propietario del sistema y, en investigaciones formales, debe acompañarse de cadena de custodia documentada.

📊FLUJO DE TRABAJO KAPE: COLECTAR Y PROCESAR

Fase	Componente	Qué hace	Tiempo aprox.
1. Colectar	Targets (.tkape)	Define qué archivos y directorios recolectar	1-5 min
2. Procesar	Modules (.mkape)	Define cómo procesar los artefactos recolectados	1-10 min
3. Analizar	EZ Tools, Plaso, Timesketch	Analizar los artefactos procesados	Variable

🔌

Arquitectura: Targets y Modules

Cómo funciona KAPE: archivos .tkape para recolectar y .mkape para procesar

KAPE se divide en dos componentes independientes que pueden usarse juntos o por separado:

📂TARGETS (.tkape): QUÉ RECOLECTAR

Los Targets son archivos de configuración YAML (.tkape) que definen exactamente qué archivos y directorios copiar del sistema. Pueden referirse a paths absolutos (C:\Windows\Prefetch\), usar wildcards (*.evtx), e incluso acceder a archivos bloqueados por el sistema mediante el Volume Shadow Copy Service (VSS).

KAPE incluye más de 200 targets preconfigurados en el repositorio KapeFiles de GitHub, cubriendo prácticamente todos los artefactos forenses conocidos de Windows.

Estructura de un archivo .tkape

# Ejemplo: Prefetch.tkape
Name: Prefetch
Description: Prefetch files
Author: Eric Zimmerman
Version: 1.0
Id: 9dd2aa5b-7e37-4e20-a18b-10f89d5abfff
RecreateDirectories: true
Targets:
  -
    Name: Prefetch directory
    Category: Execution
    Path: C:\Windows\Prefetch\
    FileMask: '*.pf'
    Recursive: false
    IsDirectory: false

🛠MODULES (.mkape): QUÉ PROCESAR

Los Modules son archivos de configuración YAML (.mkape) que definen cómo procesar los artefactos recolectados. Un módulo especifica qué herramienta ejecutar (ej: PECmd.exe para Prefetch), con qué argumentos, y qué hacer con la salida. Los módulos son independientes de los targets: puedes colectar sin procesar y procesar después, o hacerlo todo en un solo paso.

Estructura de un archivo .mkape

# Ejemplo: PECmd.mkape
Name: PECmd
Description: Parse Prefetch files
Author: Eric Zimmerman  
Version: 1.0
Id: 7b60e5b3...
ExportFormat: csv
Binaries:
  -
    Processor: Prefetch
    Name: PECmd.exe
    Category: Execution
    FilePath: .\tools\PECmd.exe
    CommandLine: '-d %sourceDirectory% --csv %destinationDirectory% -q'
    ExportFormat: csv

Estructura de directorios de KAPE

KAPE/
  kape.exe             <- Binario principal
  Targets/             <- Archivos .tkape organizados por categoria
    Windows/
      EventLogs.tkape
      Prefetch.tkape
      Registry.tkape
      ...
    Browsers/
      Chrome.tkape
      Firefox.tkape
    Compound/           <- Targets que agrupan varios targets (los mas utiles)
      !BasicCollection.tkape
      !SANS_Triage.tkape
      KAPEDefault.tkape
  Modules/             <- Archivos .mkape para procesado
    EZtools.mkape
    Hayabusa.mkape
    Plaso.mkape
  Logs/                <- Logs de ejecucion
  tools/               <- Herramientas de procesado (EZ Tools, etc.)

⚙

Instalación y Preparación

Descargar KAPE, actualizar targets y preparar EZ Tools

💡 KAPE ES GRATUITO PARA USO PERSONAL Y CORPORATIVOKAPE se descarga de forma gratuita desde el sitio de Kroll. Requiere registro con email. El binario es Windows-only ya que analiza artefactos de Windows, pero puede ejecutarse desde una llave USB en el sistema investigado o desde un sistema de análisis forense dedicado.

Descargar e instalar KAPE

# Paso 1: Descargar KAPE desde la pagina oficial:
# https://www.kroll.com/en/insights/publications/cyber/kroll-artifact-parser-extractor-kape
# (requiere registro gratuito con email)

# Paso 2: Extraer el ZIP en C:\KAPE\ o en una llave USB
# Estructura recomendada en una llave USB forense:
# E:\KAPE\
#   kape.exe
#   Targets\
#   Modules\
#   tools\  <- EZ Tools: PECmd, AppCompatCacheParser, etc.

# Paso 3: Actualizar los Targets y Modules desde GitHub:
# (en el sistema de analisis, no en la maquina investigada)
cd C:\KAPE
.\kape.exe --sync
# --sync descarga el ultimo KapeFiles de GitHub

# Paso 4: Descargar y colocar EZ Tools en tools\
# https://ericzimmerman.github.io/#!index.md
# Los modulos de KAPE los esperan en KAPE\tools\

# Verificar la instalacion:
.\kape.exe --help

💻HERRAMIENTAS EZ TOOLS QUE USAN LOS MODULOS DE KAPE

EZ Tool	Artefacto que procesa	Salida
`PECmd.exe`	Prefetch (.pf)	CSV con ejecuciones de programas
`AppCompatCacheParser.exe`	ShimCache (Registro)	CSV con programas ejecutados
`AmcacheParser.exe`	Amcache.hve	CSV con programas instalados/ejecutados
`MFTECmd.exe`	$MFT, $LogFile, $UsnJrnl	CSV con metadatos de archivos
`EvtxECmd.exe`	Event Logs (.evtx)	CSV/JSON de eventos
`RECmd.exe`	Registro de Windows	CSV con claves de registro
`RBCmd.exe`	Papelera de reciclaje ($I/$R)	CSV de archivos eliminados
`JLECmd.exe`	Jump Lists	CSV de accesos recientes
`LECmd.exe`	Accesos directos (.lnk)	CSV de archivos accedidos
`SQLECmd.exe`	Bases de datos SQLite (navegadores)	CSV de historial web

📂

Artefactos Críticos de Windows

Qué artefactos existen, qué información contienen y cuándo recolectarlos

Antes de usar KAPE, es fundamental entender qué artefactos forenses existen en Windows y qué información contiene cada uno. Esto permite elegir los targets correctos para cada tipo de investigación.

📄$MFTMaster File Table: metadatos de TODOS los archivos del sistema (timestamps, tamaño, ubicación)

▶PrefetchC:\Windows\Prefetch\*.pf: programas ejecutados con timestamps de primera/última ejecución

🔌Registro WindowsNTUSER.DAT, SYSTEM, SOFTWARE, SAM: persistencia, configuración, programas ejecutados

📄Event Logs*.evtx en C:\Windows\System32\winevt\Logs\ : todos los eventos del sistema

🔌Amcache.hveC:\Windows\AppCompat\Programs\Amcache.hve: historial de programas instalados y ejecutados con hashes SHA1

🔌ShimCacheSYSTEM\CurrentControlSet\Control\Session Manager\AppCompatCache: ejecuciones de programas

🌐Historial NavegadoresChrome History, Firefox places.sqlite, Edge History: URLs, descargas, cookies

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

📄Jump ListsC:\Users\*\AppData\Roaming\Microsoft\Windows\Recent\AutomaticDestinations

🔌Papelera de reciclajeC:\$Recycle.Bin\: archivos eliminados con metadatos de eliminación

📄$UsnJrnlJournal de cambios NTFS: registro de todas las modificaciones de archivos

🔌SRUMC:\Windows\System32\sru\SRUDB.dat: uso de aplicaciones, red y energía (30 días)

📊ARTEFACTOS ORDENADOS POR PRIORIDAD DE TRIAJE

Prioridad	Artefacto	Por qué es crítico	Target KAPE
🔴 ALTA	Event Logs (Security, System)	Autenticación, procesos, servicios, cambios de política	EventLogs
🔴 ALTA	$MFT	Existencia de archivos borrados, timestamps de creación	MFT
🔴 ALTA	Prefetch	Programas ejecutados aunque se hayan borrado	Prefetch
🔴 ALTA	Registro (SYSTEM, SOFTWARE)	Persistencia, servicios instalados, Run keys	RegistryHives
🟨 MEDIA	Amcache.hve	Hashes SHA1 de programas ejecutados (detectar malware)	Amcache
🟨 MEDIA	Historial de navegadores	URLs visitadas, descargas (exfiltración, phishing)	ChromeExtensions, Firefox
🟨 MEDIA	Jump Lists / .lnk	Archivos accedidos recientemente por el usuario	LNKFilesAndJumpLists
🟢 NORMAL	SRUM	Uso de aplicaciones y red en los últimos 30 días	SRUM
🟢 NORMAL	Papelera de reciclaje	Archivos eliminados con fecha y usuario	RecycleBin

⏱

Ejercicio 1 — Triáje en Menos de 5 Minutos

El comando esencial de KAPE para respuesta a incidentes rápida

El escenario más común en respuesta a incidentes: recibes una llamada de que un equipo ha sido comprometido y tienes menos de 10 minutos para recolectar evidencias antes de que el sistema sea restaurado. El target !SANS_Triage y similares están diseñados exactamente para esto.

00:00Conectar la llave USB con KAPE al sistema comprometido

00:30Ejecutar KAPE con el target de triáje completo

02:00KAPE recolecta: MFT, Event Logs, Prefetch, Registro... [~200 MB]

04:00Verificación de hashes de integridad automática

04:30Recoleccion completa, desconectar USB ✅ LISTO

Triáje completo con !SANS_TriageCOMANDOS

Triáje completo en un solo comando

# COMANDO PRINCIPAL: triaje completo con el target SANS
# Ejecutar desde la llave USB (E:\KAPE\) en el sistema investigado:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output\%COMPUTERNAME%_%DATETIME% `
  --target !SANS_Triage `
  --vss `
  --zip %COMPUTERNAME%_triage

# Parametros explicados:
# --tsource C:          <- Disco a analizar
# --tdest E:\Output\..  <- Donde guardar los artefactos
# --target !SANS_Triage <- Target compuesto (agrupa muchos targets)
# --vss                 <- Incluir Volume Shadow Copies (recupera archivos bloqueados)
# --zip nombre          <- Comprimir el resultado en .zip

💡 El %COMPUTERNAME%_%DATETIME% en la ruta de destino crea automáticamente una carpeta única para cada sistema recolectado, evitando mezclar artefactos de diferentes máquinas.

Triáje básico ultrarrrápido (menos de 2 min)2 MINUTOS

Triaje minimo: solo los artefactos mas criticos

# Si el tiempo es extremadamente limitado, recolectar solo lo esencial:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output\%COMPUTERNAME% `
  --target EventLogs,Prefetch,RegistryHives,MFT

# Este comando recolecta en ~90 segundos:
# - Todos los .evtx (Event Logs)
# - Todos los .pf (Prefetch)
# - Todos los hives del Registro
# - El $MFT completo

Triáje con la GUI de KAPE (gkape.exe)GUI

Usar la interfaz grafica de KAPE

# gkape.exe es la GUI de KAPE (mas facil para principiantes)
# Mismas opciones que la CLI pero con interfaz visual

.\gkape.exe

# En la GUI:
# 1. Target Source: C:\
# 2. Target Destination: E:\Output
# 3. Marcar los targets: seleccionar de la lista
# 4. Marcar 'Use Volume Shadow Copies' si es necesario
# 5. Clic en 'Execute'

# La GUI genera automaticamente el comando CLI equivalente
# Copiarlo para reutilizarlo en otros sistemas

✅ Un triáje con KAPE recolecta los artefactos críticos de Windows en 2-5 minutos. Un clonado completo del mismo disco habría tardado 4-8 horas.

❓ Ejercicio práctico

Ejecuta un triáje con KAPE en tu propio sistema Windows usando el target !SANS_Triage. ¿Cuánto tiempo tarda? ¿Cuántos MB recolecta? ¿Qué artefactos aparecen en la carpeta de salida?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target !SANS_Triage

Ver solución

.\kape.exe --tsource C: --tdest D:\KapeOutput\Test --target !SANS_Triage --vss --- En un sistema Windows tipico: 2-5 minutos, 150-400 MB. La carpeta de salida contiene: C\Windows\System32\winevt\Logs\ (evtx), C\Windows\Prefetch\ (pf), C\Windows\System32\config\ (hives), C (MFT), y muchos mas segun los targets del compuesto !SANS_Triage.

🔌

Ejercicio 2 — Registro de Windows

Recolectar hives del Registro y detectar persistencia de malware

El Registro de Windows es una de las fuentes de información forense más ricas. Contiene evidencias de programas ejecutados, persistencia de malware, conexiones de red recientes, documentos abiertos y configuración del sistema. KAPE puede recolectar todos los hives aunque estén en uso.

Recolectar los hives del RegistroRECOLECTAR

Target: RegistryHives y hives de usuario

# Recolectar todos los hives del registro del sistema:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target RegistryHives

# Los hives principales que recolecta:
# C:\Windows\System32\config\SYSTEM    <- Servicios, interfaces de red, timezone
# C:\Windows\System32\config\SOFTWARE  <- Software instalado, Run keys
# C:\Windows\System32\config\SAM       <- Cuentas de usuario locales
# C:\Windows\System32\config\SECURITY  <- Politicas de seguridad LSA
# C:\Users\*\NTUSER.DAT               <- Por usuario: MRU, programas, explorer
# C:\Users\*\AppData\Local\Microsoft\Windows\UsrClass.dat  <- ShellBags

# Tambien recolectar Amcache (programas ejecutados con SHA1):
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target RegistryHives,Amcache

Procesar el Registro con RECmd (Module)PROCESAR

Modulo RECmd para procesar hives del Registro

# Una vez recolectados los hives, procesarlos con RECmd:
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module RECmd_AllBatchFiles

# RECmd usa 'batch files' (.reb) que definen que claves extraer
# Incluye batch files para:
# - RunKeys (persistencia)
# - UserAssist (programas ejecutados con GUI)
# - ShimCache (AppCompatCache)
# - MRU Lists (archivos recientes)
# - USB devices (dispositivos conectados)

# Resultado: carpeta E:\Procesado\ con CSV por categoria
# - RunKeys.csv       <- Claves de inicio automatico
# - UserAssist.csv    <- Programas con GUI ejecutados
# - ShimCache.csv     <- AppCompatCache (programas ejecutados)
# - MRU.csv           <- Documentos abiertos recientemente

Analizar resultados: buscar persistenciaANÁLISIS

Analizar los CSV del registro para detectar persistencia

# Ver claves de inicio automatico (Run keys):
# Abrir RunKeys.csv en cualquier visor de CSV
# Buscar entradas:
# - En rutas no estandar (Temp, AppData, Downloads)
# - Con nombres sospechosos (svchost32.exe, updater.exe)
# - Apuntando a scripts PowerShell o VBS

# Desde PowerShell, analizar el CSV:
$runkeys = Import-Csv E:\Procesado\RECmd\RunKeys.csv
$runkeys | Where-Object { $_.ValueData -match 'Temp|AppData|Downloads' } | 
  Select-Object HivePath, KeyPath, ValueName, ValueData | 
  Format-Table -AutoSize

# Buscar persistencia en claves Run:
# HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
# HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce
# HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\Run

❓ Ejercicio práctico

Recolecta los hives del Registro de tu sistema con KAPE y analízalos con RECmd. ¿Qué entradas aparecen en las Run keys? ¿Hay alguna en una ruta sospechosa?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target RegistryHives --- Luego: .\kape.exe --msource D:\Output --mdest D:\Procesado --module RECmd_AllBatchFiles

Ver solución

.\kape.exe --tsource C: --tdest D:\RegOutput --target RegistryHives --- .\kape.exe --msource D:\RegOutput --mdest D:\RegProcesado --module RECmd_AllBatchFiles --- En sistemas normales las Run keys tendran: antivirus, herramientas corporativas, OneDrive. Entradas sospechosas: rutas en %TEMP%, %APPDATA%, cmd /c, powershell -enc (PowerShell codificado).

▶

Ejercicio 3 — Prefetch y Ejecución de Programas

Detectar qué programas se ejecutaron, aunque ya hayan sido borrados

Los archivos Prefetch son uno de los artefactos forenses más valiosos de Windows: registran cada vez que se ejecuta un programa, incluyendo la hora de las últimas 8 ejecuciones, el hash del ejecutable y los archivos que usó. Crucialmente, el Prefetch persiste incluso si el ejecutable fue borrado: si Mimikatz.exe se ejecutó y borró, su archivo .pf seguirá ahí.

Recolectar archivos PrefetchRECOLECTAR

Target: Prefetch

# Recolectar todos los archivos Prefetch:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target Prefetch

# Ubicacion: C:\Windows\Prefetch\*.pf
# Cada archivo se nombra: NOMBREEJEC-HASHPATH.pf
# Ej: MIMIKATZ.EXE-AB1234CD.pf
#     POWERSHELL.EXE-21EA4DA9.pf
#     WMIEXEC.EXE-1A2B3C4D.pf

# NOTA: Prefetch esta deshabilitado por defecto en Windows Server
# Para verificar si esta habilitado:
reg query 'HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\Memory Management\PrefetchParameters' /v EnablePrefetcher
# 0 = deshabilitado, 1 = solo apps, 3 = todo (default en Windows 10/11)

Procesar Prefetch con PECmd (Module)PROCESAR

Modulo PECmd para parsear archivos .pf

# Procesar todos los .pf con PECmd:
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module PECmd

# Genera un CSV con columnas:
# ExecutableName  <- Nombre del ejecutable
# Hash            <- Hash del path del ejecutable
# RunCount        <- Numero de veces ejecutado
# LastRunTime     <- Ultima vez que se ejecuto
# PreviousRunTime1-7  <- Las 7 ejecuciones anteriores
# FilesLoaded     <- Archivos que carg&oacute; el ejecutable

# Resultado: E:\Procesado\PECmd\PECmd_Output.csv

Detectar herramientas maliciosas por PrefetchANÁLISIS

Buscar herramientas de ataque en el historial de ejecucion

# Analizar el CSV de PECmd con PowerShell:
$prefetch = Import-Csv E:\Procesado\PECmd\PECmd_Output.csv

# Buscar herramientas de ataque conocidas:
$sospechosos = @('mimikatz', 'meterpreter', 'cobalt', 'psexec', 'wce', 'fgdump',
                  'pwdump', 'wmiexec', 'procdump', 'nc.exe', 'netcat')

$prefetch | Where-Object {
  $nombre = $_.ExecutableName.ToLower()
  $sospechosos | Where-Object { $nombre -like "*$_*" }
} | Select-Object ExecutableName, RunCount, LastRunTime | Format-Table

# Buscar ejecutables en rutas sospechosas:
$prefetch | Where-Object {
  $_.FilesLoaded -match 'Temp|Downloads|AppData\\Roaming'
} | Select-Object ExecutableName, LastRunTime, FilesLoaded

✅ Si MIMIKATZ.EXE-XXXXXXXX.pf existe en C:\Windows\Prefetch\, Mimikatz se ejecuto en este sistema, aunque el archivo ya haya sido borrado.

❓ Ejercicio práctico

Recolecta y procesa los archivos Prefetch de tu sistema. ¿Qué programas tienen el mayor RunCount (más veces ejecutados)? ¿Qué ejecutables encontrados tienen timestamps de ejecución fuera del horario laboral?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target Prefetch --- Luego procesar con PECmd module

Ver solución

.\kape.exe --tsource C: --tdest D:\PrefetchOut --target Prefetch --- .\kape.exe --msource D:\PrefetchOut --mdest D:\PrefetchCSV --module PECmd --- Abrir PECmd_Output.csv: buscar por RunCount (orden descendente) para ver los mas frecuentes. Para filtrar horario fuera de negocio: columna LastRunTime con horas entre 22:00-06:00.

📄

Ejercicio 4 — MFT y Sistema de Archivos

Recolectar el $MFT y detectar timestomping y archivos borrados

El $MFT (Master File Table) es la base de datos del sistema de archivos NTFS: contiene una entrada por cada archivo del sistema con sus cuatro timestamps (Created, Modified, Accessed, MFT-changed), tamaño, permisos y ubicación. Con el MFT puedes reconstruir qué archivos existieron en el sistema, incluso después de ser borrados, mientras las entradas no se hayan sobrescrito.

Recolectar el $MFTRECOLECTAR

Target: MFT y metadatos NTFS

# Recolectar el $MFT y archivos relacionados:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target MFT

# Recolecta:
# $MFT      <- Master File Table principal
# $LogFile  <- Journal de transacciones NTFS
# $Boot     <- Sector de arranque

# Para el $UsnJrnl (registro de cambios):
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target MFT,UsnJrnl

# IMPORTANTE: Estos son archivos del sistema protegidos
# KAPE los accede mediante raw disk reads (lectura directa del disco)
# pasando los bloqueos del sistema operativo

Procesar el $MFT con MFTECmdPROCESAR

Modulo MFTECmd para parsear el MFT

# Procesar el $MFT:
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module MFTECmd

# Genera un CSV con una fila por cada archivo:
# EntryNumber, SequenceNumber, ParentEntryNumber, MFTRecordModified,
# Created0x10, Created0x30, LastModified0x10, LastModified0x30,
# LastRecordChange0x10, LastAccess0x10, FileSize, FileName, FilePath

# La diferencia entre 0x10 y 0x30:
# $STANDARD_INFORMATION (0x10) <- la que ve el explorador
# $FILE_NAME (0x30)            <- mas dificil de manipular por malware
# Si 0x10 != 0x30 -> posible timestomping (manipulacion de timestamps por malware)

Detectar timestomping y archivos borradosANÁLISIS

Analizar el MFT para detectar anomalias de timestamps

# Analizar el CSV del MFT con PowerShell:
$mft = Import-Csv E:\Procesado\MFTECmd\MFTECmd_Output.csv

# 1. Detectar timestomping (0x10 != 0x30 difieren mas de 2 segundos):
$mft | Where-Object {
  [datetime]$_.Created0x10 -ne [datetime]$_.Created0x30
} | Select-Object FileName, FilePath, Created0x10, Created0x30 | Head 20

# 2. Buscar archivos .exe en rutas sospechosas:
$mft | Where-Object { 
  $_.FileName -match '\.exe$' -and 
  $_.FilePath -match 'Temp|Downloads|AppData'
} | Select-Object FileName, FilePath, Created0x10, FileSize

# 3. Archivos creados en un rango de tiempo especifico:
$inicio = [datetime]'2025-01-10 14:00:00'
$fin    = [datetime]'2025-01-10 18:00:00'
$mft | Where-Object {
  [datetime]$_.Created0x10 -gt $inicio -and 
  [datetime]$_.Created0x10 -lt $fin
} | Select-Object FileName, FilePath, Created0x10

❓ Ejercicio práctico

Recolecta y procesa el $MFT de tu sistema. Busca archivos .exe creados en las últimas 24 horas. ¿Hay alguno en una ruta inusual? ¿Detectas alguna discrepancia entre timestamps 0x10 y 0x30?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target MFT --- Luego modulo MFTECmd

Ver solución

.\kape.exe --tsource C: --tdest D:\MFTOut --target MFT --- .\kape.exe --msource D:\MFTOut --mdest D:\MFTProcessed --module MFTECmd --- En PowerShell: Import-Csv MFTECmd_Output.csv | Where-Object { $_.FileName -match '.exe' -and [datetime]$_.Created0x10 -gt (Get-Date).AddHours(-24) }

📊

Ejercicio 5 — Event Logs de Windows

Recolectar y analizar Event Logs con EvtxECmd y Hayabusa para detección automática

Los Event Logs de Windows son la fuente de información más rica para la respuesta a incidentes. KAPE puede recolectarlos todos en segundos y el módulo EvtxECmd los convierte a CSV para análisis inmediato. La herramienta Hayabusa puede analizar directamente los .evtx con reglas Sigma para detección automática de amenazas.

Recolectar Event LogsRECOLECTAR

Target: EventLogs

# Recolectar todos los Event Logs:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target EventLogs

# Recolecta todos los .evtx de:
# C:\Windows\System32\winevt\Logs\*

# Los mas importantes:
# Security.evtx   <- Autenticacion, cambios de privilegios, objetos auditados
# System.evtx     <- Servicios, drivers, cambios de hardware
# Application.evtx <- Eventos de aplicaciones
# Microsoft-Windows-PowerShell%4Operational.evtx <- Comandos PS ejecutados
# Microsoft-Windows-Sysmon%4Operational.evtx     <- Sysmon (si esta instalado)
# Microsoft-Windows-TaskScheduler%4Operational.evtx <- Tareas programadas

Procesar con EvtxECmd + HayabusaPROCESAR Y DETECTAR

Modulos para analisis de Event Logs

# Opcion 1: Procesar con EvtxECmd (EZ Tools) a CSV:
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module EvtxECmd

# Opcion 2: Analizar con Hayabusa (deteccion automatica con reglas Sigma):
# Descargar Hayabusa: https://github.com/Yamato-Security/hayabusa
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module Hayabusa

# Hayabusa genera un CSV con:
# - Nivel de alerta (critical, high, medium, low)
# - Nombre de la regla Sigma que activo la alerta
# - Event ID
# - Descripcion del evento sospechoso
# - Timestamps

# Es el 'threat hunting automatico' de los Event Logs

Análisis manual de eventos claveANÁLISIS

Buscar eventos criticos en el CSV de EvtxECmd

# Analizar el CSV de EvtxECmd con PowerShell:
$evtx = Import-Csv E:\Procesado\EvtxECmd\Security.csv

# Inicios de sesion exitosos (4624):
$evtx | Where-Object { $_.EventId -eq '4624' } |
  Select-Object TimeCreated, TargetUserName, IpAddress, LogonType |
  Sort-Object TimeCreated -Descending | Head 20

# Intentos de inicio de sesion fallidos (4625):
$evtx | Where-Object { $_.EventId -eq '4625' } |
  Group-Object IpAddress | Sort-Object Count -Descending | Head 10

# Nuevos servicios instalados (7045):
$syslog = Import-Csv E:\Procesado\EvtxECmd\System.csv
$syslog | Where-Object { $_.EventId -eq '7045' } |
  Select-Object TimeCreated, ServiceName, ImagePath

# PowerShell ejecutado con script codificado en base64:
$pslog = Import-Csv 'E:\Procesado\EvtxECmd\PowerShell-Operational.csv'
$pslog | Where-Object { $_.Payload -match 'EncodedCommand|-enc|-e ' } |
  Select-Object TimeCreated, Payload

❓ Ejercicio práctico

Recolecta los Event Logs con KAPE y procésalos con EvtxECmd o Hayabusa. ¿Cuantos eventos 4624 (inicio de sesión exitoso) hay en las últimas 24 horas? ¿Aparece algún inicio de sesión de tipo 3 (red) desde una IP inesperada?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target EventLogs --- Luego modulo EvtxECmd

Ver solución

.\kape.exe --tsource C: --tdest D:\EvtxOut --target EventLogs --- .\kape.exe --msource D:\EvtxOut --mdest D:\EvtxProcessed --module EvtxECmd --- PowerShell: Import-Csv Security.csv | Where-Object { $_.EventId -eq '4624' -and [datetime]$_.TimeCreated -gt (Get-Date).AddHours(-24) } | Select TimeCreated, TargetUserName, IpAddress, LogonType

🌐

Ejercicio 6 — Historial de Navegadores

Recolectar y analizar el historial web para detectar exfiltración y descarga de malware

El historial de navegación puede revelar si el usuario descargó herramientas maliciosas, visitó sites de phishing, o exfiltro datos a servicios en la nube. KAPE puede recolectar todas las bases de datos SQLite de los navegadores incluso si están en uso.

Recolectar artefactos de navegadoresRECOLECTAR

Targets para Chrome, Firefox y Edge

# Recolectar historial de todos los navegadores principales:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target Chrome,Firefox,Edge

# Target Chrome recolecta:
# C:\Users\*\AppData\Local\Google\Chrome\User Data\Default\History
# C:\Users\*\AppData\Local\Google\Chrome\User Data\Default\Cookies
# C:\Users\*\AppData\Local\Google\Chrome\User Data\Default\Downloads
# C:\Users\*\AppData\Local\Google\Chrome\User Data\Default\Bookmarks

# Para todos los navegadores a la vez:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target ChromeExtensions,Firefox,Edge,InternetExplorer

Procesar con SQLECmdPROCESAR

Modulo SQLECmd para historial de navegadores

# Procesar todos los SQLite de navegadores:
.\kape.exe `
  --msource E:\Output `
  --mdest E:\Procesado `
  --module SQLECmd_AllProfiles

# Genera CSV por navegador y categoria:
# Chrome_History.csv    <- URLs visitadas con timestamps
# Chrome_Downloads.csv  <- Archivos descargados
# Chrome_Cookies.csv    <- Cookies de sesion
# Firefox_History.csv   <- URLs Firefox
# Edge_History.csv      <- URLs Edge

# Buscar IOCs en el historial de Chrome:
$hist = Import-Csv E:\Procesado\SQLECmd\Chrome_History.csv

# URLs de servicios de exfiltracion conocidos:
$hist | Where-Object {
  $_.url -match 'mega\.nz|pastebin|transfer\.sh|wetransfer|sendspace|gofile'
} | Select-Object last_visit_time, url, title

❓ Ejercicio práctico

Recolecta el historial de Chrome con KAPE y procésalo con SQLECmd. ¿Hay visitas a páginas de descarga de herramientas de seguridad o servicios de almacenamiento en la nube en las últimas 48 horas?

💡 Pista: .\kape.exe --tsource C: --tdest D:\Output --target Chrome --- Luego modulo SQLECmd

Ver solución

.\kape.exe --tsource C: --tdest D:\BrowserOut --target Chrome --- .\kape.exe --msource D:\BrowserOut --mdest D:\BrowserCSV --module SQLECmd_AllProfiles --- Import-Csv Chrome_History.csv | Where-Object { [datetime]$_.last_visit_time -gt (Get-Date).AddHours(-48) } | Select url, last_visit_time | Sort last_visit_time -Descending

🛠

Ejercicio 7 — Targets y Modules Personalizados

Crear archivos .tkape y .mkape para recolectar artefactos específicos de tu entorno

Aunque KAPE incluye más de 200 targets preconfigurados, a veces necesitarás crear targets personalizados para: aplicaciones corporativas propietarias, artefactos específicos de tu entorno, o rutas personalizadas que no están en los targets estándar.

Crear un Target personalizado (.tkape)TARGET CUSTOM

Ejemplo: Target para logs de aplicacion corporativa

# Crear un nuevo target personalizado:
# Guardar como: KAPE\Targets\Custom\MiEmpresa_AppLogs.tkape

Name: MiEmpresa Application Logs
Description: Recolecta logs de la aplicacion corporativa MiApp
Author: Analista Forense
Version: 1.0
Id: a1b2c3d4-e5f6-7890-abcd-ef1234567890
RecreateDirectories: true
Targets:
  -
    Name: MiApp Main Log
    Category: ApplicationLogs
    Path: C:\ProgramData\MiEmpresa\MiApp\Logs\
    FileMask: '*.log'
    Recursive: true
    IsDirectory: false
  -
    Name: MiApp Config
    Category: ApplicationLogs
    Path: C:\ProgramData\MiEmpresa\MiApp\
    FileMask: '*.conf'
    Recursive: false
    IsDirectory: false

Crear un Compound Target (agrupador)COMPOUND TARGET

Target compuesto que agrupa varios targets

# Un Compound Target referencia otros targets
# Util para crear paquetes de triaje personalizados

# Guardar como: KAPE\Targets\Compound\!MiEmpresa_Triage.tkape

Name: MiEmpresa Standard Triage
Description: Triaje estandar para incidentes en MiEmpresa
Author: SOC MiEmpresa
Version: 1.0  
Id: b2c3d4e5-f6a7-8901-bcde-f12345678901
RecreateDirectories: true
Targets:
  -
    Name: EventLogs
    Category: Windows
    TargetFile: EventLogs.tkape
  -
    Name: Prefetch
    Category: Windows  
    TargetFile: Prefetch.tkape
  -
    Name: RegistryHives
    Category: Windows
    TargetFile: RegistryHives.tkape
  -
    Name: MiApp Logs
    Category: ApplicationLogs
    TargetFile: MiEmpresa_AppLogs.tkape

Usar el target personalizadoUSO

Ejecutar KAPE con el target personalizado

# Usar el target compuesto personalizado:
.\kape.exe `
  --tsource C: `
  --tdest E:\Output `
  --target !MiEmpresa_Triage

# Actualizar desde el repositorio oficial (no sobrescribe los custom):
.\kape.exe --sync

# Verificar que KAPE reconoce el nuevo target:
.\kape.exe --tlist
# Debe aparecer en la lista: !MiEmpresa_Triage

❓ Ejercicio práctico

Crea un Target personalizado que recolecte los logs de IIS de tu sistema (ruta: C:\inetpub\logs\LogFiles\). Comprueba que KAPE lo reconoce y ejecuatalo.

💡 Pista: Crear KAPE\Targets\Custom\IIS_Logs.tkape con Path: C:\inetpub\logs\LogFiles\ y FileMask: *.log

Ver solución

Crear IIS_Logs.tkape con el YAML del ejemplo --- Cambiar Path a C:\inetpub\logs\LogFiles\ y FileMask a '*.log' --- .\kape.exe --tlist | Select-String 'IIS' para verificar --- .\kape.exe --tsource C: --tdest D:\Output --target IIS_Logs para ejecutar

💻

Ejercicio 8 — KAPE + Plaso + Timesketch

El flujo de trabajo DFIR profesional completo: recolectar, procesar y visualizar

KAPE y Plaso son herramientas complementarias perfectas: KAPE recolecta los artefactos del sistema vivo en minutos, y Plaso los procesa para generar la super línea de tiempo forense. Esta combinación es el flujo de trabajo estándar en DFIR profesional.

Paso 1: Recolectar con KAPE (en el sistema investigado)KAPE

Recoleccion con KAPE en el sistema investigado

# En el sistema comprometido:
.\kape.exe `
  --tsource C: `
  --tdest E:\KapeOutput `
  --target !SANS_Triage `
  --vss `
  --zip KapeCollection

# Resultado: E:\KapeOutput\KapeCollection.zip
# Llevar el .zip al sistema de analisis

Paso 2: Procesar con Plaso (en el sistema de análisis)PLASO

Procesar los artefactos de KAPE con Plaso

# Extraer el ZIP de KAPE en el sistema de analisis:
Expand-Archive KapeCollection.zip -DestinationPath C:\Analysis\KapeData

# Procesar con log2timeline (Plaso) desde Kali/Linux:
docker run -v /mnt/analysis:/data log2timeline/plaso \
  log2timeline.py \
  --status_view linear \
  /data/caso01.plaso \
  /data/KapeData

# Plaso reconoce y parsea automaticamente:
# - Los .evtx (parser evtx)
# - Los hives del Registro (parser winreg)
# - Los .pf de Prefetch (parser prefetch)
# - Los SQLite de navegadores (parsers chrome_history, firefox_history)
# - El $MFT (parser mft)
# - Y muchos mas...

Paso 3: Exportar a Timesketch y analizarTIMESKETCH

Generar la timeline y exportar a Timesketch

# Exportar a formato Timesketch:
psort.py \
  -o dynamic \
  -w /data/caso01_timesketch.jsonl \
  /data/caso01.plaso

# Importar en Timesketch:
timesketch_importer \
  --host http://localhost:5000 \
  --username admin \
  --password password \
  --sketch_id 1 \
  --timeline_name 'Caso 01 - Triaje KAPE' \
  /data/caso01_timesketch.jsonl

# En Timesketch:
# - Todos los artefactos recolectados por KAPE aparecen en una sola timeline
# - Puedes buscar por fecha, host, usuario, herramienta
# - Colaboracion en tiempo real con el equipo DFIR

✅ KAPE (recoleccion en minutos) + Plaso (procesado) + Timesketch (visualizacion) = el flujo de trabajo DFIR profesional completo.

🔴

Caso Práctico — Respuesta a Incidente Real

Flujo completo: triáje de emergencia + análisis + timeline en menos de 30 minutos

Escenario: El SOC recibe una alerta de que la estación de trabajo WS-CONTABILIDAD-03 del departamento de contabilidad ha establecido conexiones salientes a una IP desconocida. El usuario informa que en los últimos días ha recibido emails con archivos adjuntos que ha abierto. El sistema debe permanecer operativo. Tiempo disponible para la recolección: 10 minutos.

Recolección de emergencia (0-5 minutos)FASE 1: RECOLECTAR

Triaje de emergencia en el sistema comprometido

# En WS-CONTABILIDAD-03 (con llave USB forense):

# Paso 1: Recolectar volatil (RAM) primero - fuera del scope de KAPE
# Usar WinPmem o Magnet RAM Capture ANTES de KAPE si hay tiempo

# Paso 2: Triaje KAPE con enfoque en indicadores de compromiso:
.\kape.exe `
  --tsource C: `
  --tdest E:\Triaje_WS03_%DATETIME% `
  --target EventLogs,Prefetch,RegistryHives,MFT,Chrome,Firefox `
  --vss `
  --zip WS03_triage

# En 3-5 minutos tenemos todos los artefactos clave
# Verificar hashes automaticos generados en el ZIP

Análisis inmediato (5-30 minutos)FASE 2: ANALIZAR

Analisis rapido de los artefactos recolectados

# Llevar el ZIP al sistema de analisis
# Extraer y procesar con KAPE modules:
.\kape.exe `
  --msource .\ExtractedTriage `
  --mdest .\Processed `
  --module PECmd,EvtxECmd,RECmd_AllBatchFiles

# 1. Revisar Prefetch: buscar ejecutables sospechosos
$prefetch = Import-Csv .\Processed\PECmd\PECmd_Output.csv
$prefetch | Where-Object {
  $_.LastRunTime -gt (Get-Date).AddDays(-7)
} | Sort-Object LastRunTime -Descending | Head 30

# 2. Revisar Event Logs Security: logins recientes
$sec = Import-Csv .\Processed\EvtxECmd\Security.csv
$sec | Where-Object { $_.EventId -in '4624','4688','7045' } |
  Sort-Object TimeCreated -Descending | Head 20

# 3. Revisar PowerShell Operational
$ps = Import-Csv '.\Processed\EvtxECmd\PowerShell-Operational.csv'
$ps | Where-Object { $_.Payload -match 'encoded|Invoke|IEX|DownloadString' } |
  Select TimeCreated, Payload

Construir la línea de tiempo del ataqueFASE 3: TIMELINE

Procesar con Plaso para la super-timeline

# Procesar todos los artefactos de KAPE con Plaso:
log2timeline.py `
  --status_view linear `
  --parsers win_gen `
  WS03_timeline.plaso `
  .\ExtractedTriage

# Exportar a CSV para analisis rapido:
psort.py `
  -o l2tcsv `
  -w WS03_timeline.csv `
  WS03_timeline.plaso `
  "timestamp > '2025-01-08T00:00:00' AND timestamp < '2025-01-11T23:59:59'"

# La timeline revelara el orden de los eventos:
# 1. Email recibido con adjunto .xlsx (probablemente via historial del navegador o Outlook)
# 2. Archivo .xlsx abierto -> proceso sospechoso creado (Event ID 4688)
# 3. PowerShell ejecutado con parametro EncodedCommand (PowerShell Operational Log)
# 4. Nuevo archivo .exe creado en C:\Users\*\AppData\Roaming\ (MFT)
# 5. Nuevo servicio o Run key instalado (Registro)
# 6. Conexion saliente al C2 (logs de red o Sysmon Event ID 3)

✅ La super-timeline muestra exactamente la secuencia del ataque: email -> apertura -> ejecucion de macro -> descarga de payload -> persistencia -> C2. Todo en 15-30 minutos de analisis.

📚

Referencia: Targets Principales

Los targets KAPE más utilizados en respuesta a incidentes

Target	Tipo	Qué recolecta	Uso
`!SANS_Triage`	Compound	Artefactos SANS de triaje estándar (75+ targets)	Triáje completo
`!BasicCollection`	Compound	Coleccion básica de artefactos Windows críticos	Triáje rápido
`KAPEDefault`	Compound	Conjunto por defecto recomendado por Eric Zimmerman	Uso general
`EventLogs`	Individual	Todos los .evtx del sistema	Investigación de eventos
`MFT`	Individual	$MFT, $LogFile, $Boot	Análisis de sistema de archivos
`Prefetch`	Individual	C:\Windows\Prefetch\*.pf	Ejecución de programas
`RegistryHives`	Individual	SYSTEM, SOFTWARE, SAM, SECURITY, NTUSER.DAT	Persistencia, configuración
`Amcache`	Individual	Amcache.hve	Hashes SHA1 de ejecutables
`Chrome`	Individual	History, Downloads, Cookies, Bookmarks	Historial web Chrome
`Firefox`	Individual	places.sqlite, cookies.sqlite	Historial web Firefox
`Edge`	Individual	Artefactos de Microsoft Edge	Historial web Edge
`SRUM`	Individual	SRUDB.dat (30 dias de actividad)	Uso de apps y red
`RecycleBin`	Individual	C:\$Recycle.Bin\	Archivos eliminados
`LNKFilesAndJumpLists`	Individual	.lnk y AutomaticDestinations	Archivos accedidos
`UsnJrnl`	Individual	$UsnJrnl (journal de cambios NTFS)	Historial de cambios de archivos

🔧

Referencia: Módulos Principales

Los módulos KAPE más utilizados y sus herramientas de procesado

Módulo	EZ Tool / Herramienta	Procesa	Salida
`PECmd`	PECmd.exe	Prefetch (.pf)	CSV con ejecuciones, timestamps, archivos cargados
`MFTECmd`	MFTECmd.exe	$MFT, $LogFile, $UsnJrnl	CSV con metadatos de todos los archivos
`EvtxECmd`	EvtxECmd.exe	Event Logs (.evtx)	CSV/JSON de eventos por log
`RECmd_AllBatchFiles`	RECmd.exe	Registry Hives	CSV por categoría (RunKeys, UserAssist, etc.)
`AppCompatCacheParser`	AppCompatCacheParser.exe	ShimCache (SYSTEM hive)	CSV con programas del ShimCache
`AmcacheParser`	AmcacheParser.exe	Amcache.hve	CSV con SHA1 de ejecutables
`SQLECmd_AllProfiles`	SQLECmd.exe	SQLite de navegadores y SRUM	CSV por navegador y tabla
`JLECmd`	JLECmd.exe	Jump Lists (.automaticDestinations)	CSV con accesos recientes
`LECmd`	LECmd.exe	Accesos directos (.lnk)	CSV con archivos accedidos
`RBCmd`	RBCmd.exe	Papelera de reciclaje	CSV con archivos eliminados
`Hayabusa`	Hayabusa.exe	Event Logs (.evtx)	CSV con alertas de reglas Sigma
`Plaso`	log2timeline.py	Todos los artefactos KAPE	.plaso (SQLite) para Timesketch

📚

Cheatsheet de Comandos KAPE

Referencia rápida de los comandos más usados

KAPE CLI Cheatsheet completo

# ── TRIAJE RAPIDO ────────────────────────────────────
.\kape.exe --tsource C: --tdest E:\Output --target !SANS_Triage
.\kape.exe --tsource C: --tdest E:\Output --target !BasicCollection
.\kape.exe --tsource C: --tdest E:\Output --target EventLogs,Prefetch,RegistryHives,MFT

# ── CON VOLUME SHADOW COPIES ────────────────────────
.\kape.exe --tsource C: --tdest E:\Output --target !SANS_Triage --vss

# ── COMPRIMIR LA SALIDA ─────────────────────────────
.\kape.exe --tsource C: --tdest E:\Output --target !SANS_Triage --zip NombreArchivo

# ── RECOLECTAR ARTEFACTOS ESPECIFICOS ───────────────
.\kape.exe --tsource C: --tdest E:\Out --target Prefetch
.\kape.exe --tsource C: --tdest E:\Out --target EventLogs
.\kape.exe --tsource C: --tdest E:\Out --target RegistryHives
.\kape.exe --tsource C: --tdest E:\Out --target MFT
.\kape.exe --tsource C: --tdest E:\Out --target Chrome,Firefox,Edge
.\kape.exe --tsource C: --tdest E:\Out --target SRUM

# ── PROCESAR CON MODULOS ────────────────────────────
.\kape.exe --msource E:\Output --mdest E:\Processed --module PECmd
.\kape.exe --msource E:\Output --mdest E:\Processed --module EvtxECmd
.\kape.exe --msource E:\Output --mdest E:\Processed --module RECmd_AllBatchFiles
.\kape.exe --msource E:\Output --mdest E:\Processed --module MFTECmd
.\kape.exe --msource E:\Output --mdest E:\Processed --module SQLECmd_AllProfiles
.\kape.exe --msource E:\Output --mdest E:\Processed --module Hayabusa

# ── RECOLECTAR Y PROCESAR EN UN SOLO COMANDO ────────
.\kape.exe `
  --tsource C: --tdest E:\Output `
  --target !SANS_Triage `
  --msource E:\Output --mdest E:\Processed `
  --module PECmd,EvtxECmd,RECmd_AllBatchFiles,MFTECmd

# ── UTILIDADES ──────────────────────────────────────
.\kape.exe --sync              # Actualizar targets y modules desde GitHub
.\kape.exe --tlist             # Listar todos los targets disponibles
.\kape.exe --mlist             # Listar todos los modules disponibles
.\kape.exe --tdetail NOMBRE    # Detalles de un target especifico
.\kape.exe --mdetail NOMBRE    # Detalles de un module especifico
.\gkape.exe                    # Abrir la GUI grafica

# ── VARIABLES UTILES EN EL DESTINO ─────────────────
# %COMPUTERNAME%  <- Nombre del equipo investigado
# %DATETIME%      <- Timestamp de la recoleccion (YYYYMMDDHHMMSS)
# Ejemplo:
.\kape.exe --tsource C: --tdest E:\Output\%COMPUTERNAME%_%DATETIME% --target !SANS_Triage

🔗

Cadena de Custodia

Cómo KAPE gestiona la integridad y documentación de la evidencia recolectada

En cualquier investigación forense formal, la cadena de custodia es tan importante como los propios artefactos. Sin ella, la evidencia puede ser inadmisible en procedimientos legales. KAPE genera automáticamente hashes y logs de todo lo que recolecta.

🔗CADENA DE CUSTODIA CON KAPE

Hashes y documentacion automatica de KAPE

# KAPE genera automaticamente:
# 1. Hash MD5 y SHA1 de cada archivo recolectado
# 2. Log de ejecucion detallado (KAPE\Logs\)
# 3. Lista de todos los archivos copiados con timestamps

# Ver el log de ejecucion:
Get-Content KAPE\Logs\*.log | Select-String 'Copied|Error|Hash'

# El archivo de hashes se genera en la carpeta de destino:
# E:\Output\_kape_log.txt o E:\Output\Hash.txt

# Para uso forense formal, documenta ademas:
# 1. Nombre del analista que ejecuto KAPE
# 2. Fecha y hora exacta de inicio y fin
# 3. Numero de serie de la llave USB usada
# 4. Hash del propio kape.exe (integridad de la herramienta)
# 5. Estado del sistema (encendido/apagado, red conectada/desconectada)

# Hash de la herramienta KAPE:
Get-FileHash .\kape.exe -Algorithm SHA256

⚠ EVIDENCIA EN SISTEMA VIVO vs APAGADOKAPE opera sobre un sistema vivo (live response), lo que significa que el sistema operativo puede modificar timestamps durante la recolección. Para una investigación forense formal que requiera admisibilidad legal, combina KAPE (para respuesta rápida) con una imagen forense completa posterior (FTK Imager, dc3dd) cuando el tiempo lo permita.

✓ CONCLUSIÓNKAPE transforma la respuesta a incidentes: en lugar de esperar horas para clonar un disco, en 5 minutos tienes los artefactos críticos de Windows listos para analizar. Combinado con EZ Tools para procesado rápido, Plaso para la super-timeline y Timesketch para visualización colaborativa, KAPE es la piedra angular del flujo de trabajo DFIR moderno. Es la herramienta que usan Mandiant, CrowdStrike y los equipos forenses del FBI para respuesta a incidentes corporativos.