EWF-Tools en Español: Guía Rápida

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

EWF-Tools en Español: Guía Rápida

EWF-Tools (Expert Witness Compression Format) es un conjunto de utilidades esenciales en Kali Linux para trabajar con archivos de imagen de disco, específicamente en el formato .E01 (el estándar de EnCase).

Aquí tienes una guía rápida en español sobre qué es y cómo usar sus herramientas principales:

🛠️ Herramientas principales de EWF-Tools

El paquete no es una sola aplicación, sino un conjunto de comandos especializados:

Comando	Función Principal
`ewfacquire`	Se usa para crear una imagen forense desde un medio físico (disco duro, USB).
`ewfexport`	Exporta los datos de un archivo EWF a otros formatos (como RAW/dd).
`ewfinfo`	Muestra los metadatos de la imagen (quién la creó, fecha, hash, etc.).
`ewfmount`	Monta la imagen para que el sistema pueda leer su contenido como un archivo plano.
`ewfverify`	Verifica la integridad de la imagen comparando los hashes MD5/SHA.

🚀 Ejemplos prácticos de uso

1. Ver información de una evidencia

Si tienes un archivo llamado evidencia.E01 y quieres saber de qué disco proviene o si tiene notas del investigador:

Bash

ewfinfo evidencia.E01

2. Adquirir una imagen (Crear el backup forense)

Para copiar un pendrive que está en /dev/sdb y guardarlo como imagen forense:

Bash

sudo ewfacquire /dev/sdb

El sistema te hará preguntas en la terminal como el nombre del caso, el examinador y la compresión que deseas usar.

3. Montar una imagen para análisis

A diferencia de un archivo normal, los .E01 están comprimidos. Para ver el contenido "crudo", usamos ewfmount:

Bash

mkdir /mnt/ewf
ewfmount evidencia.E01 /mnt/ewf

Ahora, dentro de /mnt/ewf, verás un archivo llamado ewf1 que representa el disco completo.

💡 Consejos de "Pro"

Integridad: Siempre usa ewfverify después de mover archivos de un disco a otro para asegurarte de que no hubo corrupción de datos.
Velocidad: Al usar ewfacquire, si no necesitas una compresión extrema, elige niveles bajos (como el 1) para que el proceso termine mucho más rápido.

Perfecto, vamos al grano. Una vez que has usado ewfmount para "desbloquear" el archivo .E01, el siguiente paso es analizar qué hay dentro.

Aquí tienes los pasos exactos para ver el contenido del disco una vez montado en /mnt/ewf:

1. Identificar las particiones

Como el archivo ewf1 (que está dentro de /mnt/ewf) actúa como si fuera un disco duro físico, primero debemos ver qué particiones tiene (NTFS, FAT32, EXT4, etc.).

Usa el comando mmls (de las herramientas Sleuth Kit, que suelen venir con Kali):

Bash

mmls /mnt/ewf/ewf1

Esto te dará una tabla con los sectores de inicio (Start) y fin de cada partición.

2. Montar una partición específica para ver archivos

Si quieres entrar a una partición y ver las carpetas del usuario, necesitas montarla en modo solo lectura (ro).

Supongamos que mmls te dijo que la partición principal empieza en el sector 2048. El comando sería:

Bash

mkdir /mnt/analisis
sudo mount -o loop,ro,show_sys_files,offset=$((2048*512)) /mnt/ewf/ewf1 /mnt/analisis

Nota técnica: Multiplicamos el sector de inicio (2048) por el tamaño del sector (habitualmente 512 bytes) para que Linux sepa exactamente dónde empieza la partición.

3. Explorar el contenido

Ahora ya puedes navegar por los archivos como si fuera una carpeta normal:

Bash

cd /mnt/analisis
ls -la

🛡️ ¿Qué pasa si la partición es Windows (BitLocker)?

Si al intentar montar la partición te da un error de "unknown filesystem" o sabes que está cifrada, necesitarás herramientas adicionales como dislocker.

Para extraer archivos borrados de una imagen forense en Kali Linux, entramos en el terreno del "File Carving". Esta técnica busca firmas de archivos (cabeceras y pies de página) directamente en los datos crudos del disco, ignorando si el sistema de archivos dice que el espacio está "vacío".

Las dos herramientas estándar de oro para esto son Photorec (fácil y gráfica) y Foremost (potente y por comandos).

Opción 1: Photorec (La más recomendada)

Es extremadamente eficaz y reconoce más de 480 extensiones de archivos. Aunque se ejecuta en la terminal, tiene un menú interactivo.

Lanza la herramienta apuntando a tu imagen montada:
Bash
```
photorec /mnt/ewf/ewf1
```
Pasos en el menú:
- Selecciona el disco (/mnt/ewf/ewf1).
- Elige la partición (o "Whole disk" para buscar en todo el espacio no asignado).
- Selecciona el sistema de archivos (generalmente Other para NTFS/FAT/EXT).
- Clave: Elige "Free" para buscar solo archivos borrados, o "Whole" si la partición está dañada.
- Selecciona una carpeta de destino en tu máquina para guardar lo que encuentre.

Opción 2: Foremost (Rápida y directa)

Si solo buscas tipos específicos (por ejemplo, solo PDFs y JPGs), Foremost es más directo.

Crea una carpeta para los resultados:
Bash
```
mkdir /home/kali/recuperado
```
Ejecuta el escaneo:
Bash
```
sudo foremost -t jpg,pdf,doc -i /mnt/ewf/ewf1 -o /home/kali/recuperado
```
- -t: Tipos de archivos a buscar.
- -i: Archivo de entrada (tu imagen E01 montada).
- -o: Carpeta de salida.

Opción 3: Autopsy (La interfaz profesional)

Si prefieres no usar la terminal y quieres ver miniaturas de las fotos borradas, línea de tiempo de actividad y bases de datos, Autopsy es la solución completa.

Escribe autopsy en tu terminal de Kali.
Abre el navegador en la dirección que te indique (normalmente http://localhost:9999/autopsy).
Crea un "Nuevo Caso" y añade el archivo /mnt/ewf/ewf1 como "Disk Image".
Autopsy analizará automáticamente los archivos borrados y los marcará con una cruz roja en el explorador de archivos.

⚠️ Regla de Oro Forense

Nunca guardes los archivos recuperados dentro de la misma partición que estás analizando. Siempre expórtalos a una carpeta distinta en tu sistema Kali para evitar sobrescribir datos que aún no has recuperado.

Entrar en una partición cifrada (especialmente si es BitLocker de Windows) es un paso clásico en informática forense. En Kali Linux, la herramienta estándar para esto es Dislocker.

Aquí tienes el procedimiento para "romper" o abrir ese cifrado si tienes la contraseña o la clave de recuperación.

1. Instalar Dislocker (si no lo tienes)

Primero, asegúrate de tener la herramienta necesaria:

Bash

sudo apt update && sudo apt install dislocker

2. Identificar la partición cifrada

Usa fdisk o mmls para saber en qué sector empieza la partición de Windows. Supongamos de nuevo que es el sector 2048.

3. Desbloquear la capa de cifrado

Necesitas crear una carpeta donde Dislocker "desencriptará" el volumen virtualmente.

Bash

sudo mkdir /mnt/bitlocker
sudo mkdir /mnt/disco_abierto

Ahora, usa uno de estos dos métodos según lo que tengas:

Si tienes la contraseña de usuario:
Bash
```
sudo dislocker -V /mnt/ewf/ewf1 -o 1048576 -- user-password -- /mnt/bitlocker
```
(Nota: 1048576 es el resultado de $2048 \times 512$ . Es el "offset" en bytes).

Si tienes la clave de recuperación (48 dígitos):

Bash

sudo dislocker -V /mnt/ewf/ewf1 -o 1048576 -- recovery-password=TU-CLAVE-AQUÍ -- /mnt/bitlocker

4. Montar el archivo resultante

Dislocker no te da los archivos directamente, sino que crea un archivo virtual llamado dislocker-file dentro de /mnt/bitlocker. Ahora debemos montar ese archivo:

Bash

sudo mount -o loop,ro /mnt/bitlocker/dislocker-file /mnt/disco_abierto

¡Listo! Ahora, si entras en /mnt/disco_abierto, verás las carpetas de Users, Windows, Program Files, etc.

🕵️ ¿Y si NO tengo la contraseña? (Ataque de fuerza bruta)

Si no tienes la clave, la cosa se pone seria. Tendrías que:

Extraer el hash del volumen usando una herramienta como bitlocker2john.
Usar Hashcat o John the Ripper con un diccionario potente y una buena GPU para intentar dar con la clave por fuerza bruta.

Advertencia: Si la contraseña es compleja, este proceso puede tardar años. Por eso, en forense, siempre se busca primero el archivo de "Recovery Key" en las cuentas de Microsoft o documentos físicos del sospechoso.

Para intentar romper el cifrado de BitLocker sin la contraseña, necesitamos "robar" el hash del volumen y luego atacarlo con potencia de cálculo (GPU). Este es el procedimiento estándar en auditoría forense:

1. Extraer el Hash (El "ADN" de la contraseña)

Usaremos una herramienta llamada bitlocker2john (parte de la suite John the Ripper). Esta utilidad escanea la partición y extrae los metadatos necesarios para el ataque.

Ejecuta el siguiente comando apuntando a tu imagen montada:

Bash

# Recuerda que el offset (1048576) depende de dónde empieza tu partición
bitlocker2john -o 1048576 /mnt/ewf/ewf1 > hash_bitlocker.txt

Esto creará un archivo llamado hash_bitlocker.txt. Si lo abres con cat, verás una cadena larga de caracteres que empieza por $bitlocker$ . Ese es tu objetivo.

2. Limpiar el archivo para Hashcat

Hashcat es mucho más rápido que John para BitLocker, pero necesita el hash limpio. Abre el archivo y deja solo la cadena que empieza por $bitlocker$ .

3. Lanzar el ataque de fuerza bruta

BitLocker usa un algoritmo de derivación de claves muy pesado, por lo que la velocidad de prueba es lenta (pocos miles de contraseñas por segundo, comparado con los millones de MD5).

Usa el modo 22100 en Hashcat:

Bash

hashcat -m 22100 -a 3 hash_bitlocker.txt ?d?d?d?d?d?d?d?d

-m 22100: Especifica que el hash es de BitLocker.
-a 3: Ataque de máscara (fuerza bruta pura).
?d?d...: En este ejemplo, intenta todas las combinaciones de 8 números (típico PIN).

💡 Estrategia de Diccionario (Más efectiva)

Si crees que la contraseña es una palabra real, usa un diccionario como rockyou.txt:

Bash

hashcat -m 22100 -a 0 hash_bitlocker.txt /usr/share/wordlists/rockyou.txt

⚠️ Consideración importante

Si la contraseña tiene más de 10-12 caracteres aleatorios, la fuerza bruta es matemáticamente inviable con hardware convencional. En forense real, solemos buscar:

Archivos .BEK (BitLocker Encryption Key) en otros USB del sospechoso.
Claves en la cuenta de Microsoft (si se tiene acceso al correo).
Hacer un volcado de RAM del ordenador si todavía está encendido (para sacar la clave maestra de la memoria).

Buscar la Recovery Key (esa clave de 48 dígitos) es como buscar una aguja en un pajar, pero en informática forense hay "escondites" típicos donde los usuarios suelen guardarla por accidente o por precaución.

Si has logrado montar alguna partición pequeña (como la de System Reserved) o tienes acceso a otros archivos del usuario, aquí te digo dónde buscar:

1. Buscar archivos de texto con nombres clave

Los usuarios suelen guardar la clave en un .txt generado automáticamente por Windows. Vamos a usar find y grep para rastrear cualquier archivo que contenga el patrón de la clave (grupos de 6 dígitos separados por guiones).

Bash
# Busca archivos que se llamen "BitLocker" o "Recovery"
find /mnt/otra_particion -iname "*bitlocker*" -o -iname "*recovery*"

# Busca dentro de TODOS los archivos de texto el patrón de la clave (48 dígitos)
grep -rE "([0-9]{6}-){7}[0-9]{6}" /mnt/otra_particion

2. El registro de Windows (SYSTEM y SOFTWARE)

A veces, la clave o identificadores de BitLocker quedan registrados en las colmenas (hives) del registro. Si puedes extraer los archivos SYSTEM y SOFTWARE de C:\Windows\System32\config, puedes usar herramientas como RegRipper:

Bash

rip.pl -r /ruta/al/archivo/SYSTEM -p bitlocker

3. Archivos de Hibernación y Pagefile

Si el ordenador estaba encendido o entró en hibernación mientras el disco estaba desbloqueado, la clave maestra (FVEK - Full Volume Encryption Key) podría estar en la memoria RAM volcada al disco.

Archivo: hiberfil.sys o pagefile.sys.
Herramienta: bitlocker-dump o volatility.

🔍 ¿Qué pasa si encuentras un archivo .BEK?

Si en un USB del sospechoso encuentras un archivo con extensión .BEK (Bitlocker External Key), ¡tienes un tesoro! Es una "llave física". Puedes usarla con dislocker directamente:

Bash

sudo dislocker -V /mnt/ewf/ewf1 -o 1048576 --prok /ruta/al/archivo.BEK -- /mnt/bitlocker

⚖️ El último recurso: Análisis de Metadatos

Si nada de esto funciona, lo ideal es usar Autopsy (que viene en Kali). Es una interfaz gráfica que automatiza todo lo que hemos hecho:

Añades el .E01 como "Data Source".
Él solo busca archivos borrados, palabras clave como "password" o "recovery" y te organiza todo en una interfaz fácil de leer.

Configurar Autopsy en Kali Linux es la mejor decisión cuando ya has agotado los comandos manuales, porque automatiza la búsqueda de esa "aguja en el pajar" (la Recovery Key) y reconstruye archivos borrados que podrían contenerla.

Aquí tienes los pasos para pasar de la terminal a la interfaz gráfica:

🖥️ Paso 1: Lanzar Autopsy

Autopsy es una herramienta basada en navegador. Para abrirla en Kali:

Abre una terminal y escribe: autopsy.
Te dará una dirección URL (normalmente http://localhost:9999/autopsy).
Abre Firefox en Kali y pega esa dirección.

📁 Paso 2: Crear el Caso Forense

Una vez en la interfaz:

New Case: Ponle un nombre (ej. Caso_Bitlocker_01).
Add Host: Añade un nombre para el equipo examinado.
Add Image File: Aquí es donde seleccionas tu archivo .E01.
- Importante: Selecciona "Symlink" o "Copy" según prefieras, pero asegúrate de que el tipo de archivo sea Disk Image.

🔍 Paso 3: Configurar los "Ingest Modules"

Esta es la parte mágica. Autopsy pasará varios filtros a tu imagen. Asegúrate de marcar:

Keyword Search: Configúralo para buscar patrones como [0-9]{6}-.
Recent Activity: Extraerá historiales de búsqueda y documentos recientes.
Extension Mismatch: Busca archivos .txt que alguien haya renombrado a .jpg para esconderlos.

🕵️ Paso 4: Dónde buscar la clave en la interfaz

Una vez que Autopsy termine el análisis (verás una barra de progreso abajo a la derecha), revisa estas secciones en el árbol de la izquierda:

Keyword Hits: Mira si el patrón de la Recovery Key (8 grupos de 6 dígitos) aparece en algún lugar del disco, incluso en el espacio no asignado (archivos borrados).
Interesting Items: Autopsy suele marcar archivos que parecen ser llaves de cifrado o backups de seguridad.
Data Artifacts -> Operating System: Aquí puedes ver cuentas de usuario. A veces, la clave está en el historial de "Documentos Recientes" o en archivos de texto dentro de la carpeta Documents.

💡 Un truco final: Búsqueda en "Unallocated Space"

Si el usuario borró el archivo de texto que contenía la clave de BitLocker, Autopsy lo buscará en el espacio no asignado.

Ve a la sección File Views -> File Types -> Deleted Files.
Filtra por extensión .txt o .pdf.
¡Excelente! Extraer un archivo desde Autopsy para usarlo en la terminal (ya sea una llave .BEK, un diccionario de contraseñas personalizado o el propio hash) es muy sencillo pero requiere precisión.
Aquí tienes los pasos para sacarlo de la "jaula" de Autopsy y llevarlo a tu sistema de archivos de Kali:
📥 Paso 1: Exportar el archivo desde Autopsy
Una vez que hayas localizado el archivo sospechoso (por ejemplo, Recuperacion_Bitlocker.txt o un archivo .bek en el espacio no asignado):
1. Haz clic derecho sobre el archivo en el listado de resultados de Autopsy.
2. Selecciona la opción "Extract File(s)".
3. Elige una ruta accesible, como tu carpeta /home/kali/Desktop/evidencia/.
🔑 Paso 2: Usar el archivo extraído en la Terminal
Si lo que extrajiste fue una Llave Externa (.BEK), ahora puedes volver a usar dislocker pero apuntando a este archivo real:
Bash
# Supongamos que guardaste la llave en tu escritorio sudo dislocker -V /mnt/ewf/ewf1 -o 1048576 --prok /home/kali/Desktop/evidencia/archivo.BEK -- /mnt/bitlocker
Si lo que extrajiste fue un texto con la clave de 48 dígitos, simplemente cópiala y úsala con el parámetro --recovery-password:
Bash
sudo dislocker -V /mnt/ewf/ewf1 -o 1048576 --recovery-password=XXXXXX-XXXXXX-... -- /mnt/bitlocker
🛡️ Paso 3: Verificar el montaje final
Una vez que dislocker termine (no da error si la llave es correcta), el último paso es montar el volumen "desbloqueado" para navegar por él:
Bash
sudo mount -o loop,ro /mnt/bitlocker/dislocker-file /mnt/disco_abierto ls -la /mnt/disco_abierto
💡 Consejo de Experto: El Timeline
Si no encuentras la clave, usa la función "Timeline" de Autopsy. Te permite ver qué archivos se crearon o modificaron justo antes de que el disco fuera cifrado o entregado. A veces, el usuario imprime la clave a un PDF justo antes de activar BitLocker, y ese PDF aparece en el Timeline de eventos de creación de archivos.
Analizar el registro de Windows (Registry) es una mina de oro. Aunque los navegadores modernos (Chrome, Edge, Firefox) no guardan las contraseñas en texto plano dentro del registro, sí guardan configuraciones, rutas de perfiles y credenciales de red que son vitales.
Para extraer contraseñas de navegadores, combinaremos el análisis del registro con el examen de las bases de datos Login Data.
🛠️ 1. Extraer las "Colmenas" (Hives) del Registro
Desde tu imagen montada en /mnt/disco_abierto, necesitas copiar estos archivos para analizarlos localmente en Kali:
- SYSTEM y SOFTWARE: Para ver qué navegadores están instalados y sus versiones.
- SAM y SECURITY: Para obtener los hashes de las contraseñas del sistema.
- NTUSER.DAT: (Ubicado en Users/[Nombre]/NTUSER.DAT). Este es el más importante, contiene el perfil específico del usuario.
Bash
cp /mnt/disco_abierto/Windows/System32/config/SYSTEM ~/evidencia/ cp /mnt/disco_abierto/Users/Suspect/NTUSER.DAT ~/evidencia/
🔍 2. Buscar rutas de perfiles con RegRipper
Usa RegRipper (rip.pl) para buscar actividad de navegadores. Esto te dirá dónde están las bases de datos de contraseñas:
Bash
# Buscar aplicaciones instaladas y rutas de ejecución rip.pl -r ~/evidencia/SOFTWARE -p applications # Buscar historial de TypedURLs (lo que el usuario escribió) rip.pl -r ~/evidencia/NTUSER.DAT -p typedurls
🌐 3. Extraer contraseñas de Chrome/Edge (Bases de Datos SQLite)
Los navegadores basados en Chromium guardan las credenciales en un archivo llamado Login Data.
Ruta típica: /Users/[Usuario]/AppData/Local/Google/Chrome/User Data/Default/Login Data
Pasos para extraer:
1. Copia el archivo:
  Bash
  cp "/mnt/disco_abierto/Users/Suspect/AppData/Local/Google/Chrome/User Data/Default/Login Data" ~/evidencia/
2. Consulta la base de datos:
  Como es un archivo SQLite, puedes ver las URLs y los nombres de usuario, pero la contraseña estará cifrada (blobs):
  Bash
  sqlite3 ~/evidencia/Login\ Data "SELECT origin_url, username_value, password_value FROM logins;"
🔓 4. Cómo descifrar las contraseñas
Aquí es donde el registro de Windows es clave. Chrome usa la API DPAPI de Windows para cifrar las contraseñas. Para descifrarlas fuera del sistema original, necesitas:
1. El valor password_value (del archivo Login Data).
2. El archivo Local State (ubicado en la carpeta de Chrome).
3. La Master Key del usuario (que se extrae de la carpeta AppData/Roaming/Microsoft/Protect).
Herramienta recomendada: Mimikatz o DonPapi
En Kali, puedes usar DonPapi para automatizar esto si tienes las colmenas del registro y los archivos de protección:
Bash
# Ejemplo de uso de DonPapi apuntando al directorio de la evidencia python3 DonPapi.py /mnt/disco_abierto -p "contraseña_del_usuario_si_la_tienes"
📝 Resumen de hallazgos
Si no logras descifrar el "blob" de la contraseña, el registro te habrá dado:
- TypedURLs: Qué páginas de bancos o correos visitó.
- UserAssist: Cuántas veces abrió el navegador.
- AutoRun: Si tiene algún gestor de contraseñas que se inicia solo.
  Para automatizar la extracción de datos de navegadores basados en Chromium (como Chrome o Edge) en un entorno forense, lo más eficiente es usar un script de Python que consulte la base de datos Login Data.
  Como estamos en Kali Linux y trabajando sobre una imagen montada, el script debe leer los tres campos clave: la URL, el usuario y el password_value (que estará cifrado).
  🐍 Script de Python para extraer credenciales
  Copia este código en un archivo llamado extractor_forense.py:
  Python
  import sqlite3 import os # Ruta al archivo extraído de la imagen forense ruta_db = os.path.expanduser("~/evidencia/Login Data") def extraer_datos(): if not os.path.exists(ruta_db): print(f"[-] Error: No se encuentra el archivo en {ruta_db}") return # Conexión a la base de datos SQLite conn = sqlite3.connect(ruta_db) cursor = conn.cursor() # Consulta para obtener las credenciales query = "SELECT origin_url, username_value, password_value FROM logins" try: cursor.execute(query) print(f"{'URL ORIGEN':<50} | {'USUARIO':<30} | {'ESTADO PASSWORD'}") print("-" * 100) for row in cursor.fetchall(): url = row[0] user = row[1] pwd_blob = row[2] # El password_value es un BLOB cifrado por Windows DPAPI estado = "CIFRADO (Requiere Master Key)" if pwd_blob else "VACÍO" print(f"{url[:48]:<50} | {user[:28]:<30} | {estado}") except sqlite3.Error as e: print(f"[-] Error al leer la base de datos: {e}") finally: conn.close() if __name__ == "__main__": extraer_datos()
  🚀 Cómo ejecutarlo en tu flujo de trabajo
  Asegúrate de tener el archivo: Primero debes haber copiado el archivo de la imagen montada a tu carpeta de evidencia:
  Bash
  cp "/mnt/disco_abierto/Users/NombreUsuario/AppData/Local/Google/Chrome/User Data/Default/Login Data" ~/evidencia/
  Ejecuta el script:
  Bash
  python3 extractor_forense.py
  🔬 ¿Qué obtendrás con esto?
  Este script te dará una lista limpia de todos los sitios donde el usuario tiene cuentas. En forense, esto es vital porque:
  Te da una lista de objetivos adicionales (correos, redes sociales, nubes).
  Los nombres de usuario suelen repetirse; si el usuario usa juanito_perez88 en un sitio, es probable que sea su alias en otros.
  Incluso sin descifrar la contraseña, ya tienes el mapa de la vida digital del sospechoso.
  🔓 El siguiente nivel: Descifrar el BLOB
  Para convertir ese "CIFRADO" en texto plano, necesitarías usar la librería pycryptodomex y el archivo Local State (que contiene la clave de cifrado AES protegida por DPAPI).
  
  Para llevar el script al siguiente nivel y ver las contraseñas en texto plano, necesitamos "desenvolver" la llave maestra que Chrome guarda en el archivo Local State.
  En versiones modernas de Chrome (v80+), las contraseñas se cifran con AES-256-GCM, y la clave para este cifrado está protegida por la API de Windows (DPAPI).
  📋 Requisitos Previos
  Archivo Local State: Cópialo de la imagen montada:
  cp "/mnt/disco_abierto/Users/Suspect/AppData/Local/Google/Chrome/User Data/Local State" ~/evidencia/
  Librerías de Python: Necesitas instalar pycryptodomex en tu Kali:
  Bash
  pip install pycryptodomex
  🐍 Script Avanzado de Descifrado
  Este script lee la llave de Local State, la intenta descifrar (esto solo funcionará si el script se ejecuta en un sistema donde la DPAPI sea accesible o si emulamos el entorno) y luego procesa el archivo Login Data.
  Nota Forense: En Linux, descifrar DPAPI de Windows es complejo porque requiere las llaves privadas del usuario que están en el registro (Protect). Aquí te muestro la lógica que usaría una herramienta como DonPapi o hashcat:
  Python
  import json import base64 import sqlite3 from Crypto.Cipher import AES # 1. Obtener la clave maestra de "Local State" def get_master_key(path): with open(path, "r", encoding="utf-8") as f: local_state = json.load(f) # La clave está en base64 dentro de os_crypt master_key = base64.b64decode(local_state["os_crypt"]["encrypted_key"]) # En Windows, los primeros 5 bytes son "DPAPI", los quitamos return master_key[5:] # 2. Descifrar el valor de la contraseña def decrypt_password(buff, master_key): try: iv = buff[3:15] payload = buff[15:] cipher = AES.new(master_key, AES.MODE_GCM, iv) decrypted_pass = cipher.decrypt(payload) decrypted_pass = decrypted_pass[:-16].decode() # Quitar el tag de auth return decrypted_pass except Exception as e: return f"Error al descifrar: {e}" # [Lógica para conectar a la DB y recorrer filas similar al script anterior]
  🛠️ El "Obstáculo" de la DPAPI
  Como estás en Kali Linux, no puedes ejecutar directamente la función de Windows que descifra la master_key. Tienes dos opciones profesionales:
  Usar DonPapi (Recomendado): Es un script ya listo en Kali que automatiza la búsqueda de las llaves maestras en las colmenas del registro que extrajimos antes.
  Bash
  # Solo necesitas apuntar a la carpeta donde tienes SYSTEM, SECURITY y los archivos de Chrome donpapi ~/evidencia/
  Extraer el hash de la Master Key: Puedes usar dpapick para extraer el hash de la clave de Windows e intentar romperlo con Hashcat (modo 15900).
  💡 ¿Por qué es útil esto?
  Si logras descifrar una sola contraseña, a menudo esa misma contraseña es la que el sospechoso usa para:
  Desbloquear otros archivos cifrados.
  Su correo electrónico (donde podrías encontrar más Recovery Keys de BitLocker).
  Entrar en sesiones remotas.
  
  DonPapi es la herramienta "navaja suiza" en Kali para estos casos. A diferencia del script manual, DonPapi sabe cómo buscar las llaves maestras de Windows (DPAPI) en los archivos del registro y usarlas para abrir las contraseñas de Chrome, Edge e incluso de Outlook o redes Wi-Fi.
  Como ya tienes la imagen montada y los archivos copiados, vamos a configurar el ataque:
  1. Preparar el "Directorio de Evidencia"
  Para que DonPapi funcione bien, necesita una estructura específica (o que le apuntes a la raíz del disco montado). Lo más fácil es apuntar directamente a tu montaje de la imagen:
  Rutas necesarias dentro de la imagen:
  Windows/System32/config/ (Contiene SYSTEM, SECURITY, SAM)
  Users/[Usuario]/AppData/Roaming/Microsoft/Protect/ (Contiene las Master Keys de DPAPI)
  Users/[Usuario]/AppData/Local/Google/Chrome/User Data/ (Contiene las contraseñas)
  2. Ejecutar DonPapi (El comando mágico)
  Si ya tienes instalado DonPapi (sudo apt install donpapi), ejecuta esto en tu terminal de Kali:
  Bash
  # Apuntamos al disco montado donde está todo donpapi /mnt/disco_abierto/ -o ~/evidencia/resultados_passwords.txt
  ¿Qué hará el programa?
  Extraerá los LSA Secrets del archivo SECURITY.
  Buscará las Master Keys en la carpeta Protect.
  Usará esas llaves para "abrir" el archivo Login Data de Chrome automáticamente.
  3. ¿Qué pasa si te pide la contraseña del usuario?
  Si el usuario de Windows tenía una contraseña, las Master Keys están cifradas con ella. DonPapi te la pedirá.
  Si la tienes: Escríbela y verás como empieza a "escupir" todas las contraseñas en texto plano.
  Si NO la tienes: DonPapi intentará usar los hashes que extraiga de la colmena SAM para ver si puede autodescifrarlas o te dará los hashes para que los rompas con Hashcat.
  4. Analizar el Reporte Final
  Una vez termine, abre tu archivo de resultados:
  Bash
  cat ~/evidencia/resultados_passwords.txt | grep -A 2 "Chrome"
  Verás un formato similar a este:
  URL: https://facebook.com
  User: juan.perez@email.com
  Pass: Temporada2024!
  💡 Un último recurso: "Browsing History"
  Si por alguna razón las contraseñas están borradas, recuerda que en la misma carpeta de Chrome tienes el archivo History. Es otra base de datos SQLite. Puedes usarla para ver qué buscó el usuario en Google minutos antes de la captura, lo cual da mucho contexto legal.
  
  El historial de navegación es una de las piezas de evidencia más críticas, ya que permite reconstruir la intencionalidad del usuario (por ejemplo, si buscó "cómo borrar huellas digitales" o "acceso a BitLocker").
  En Chrome/Edge, el archivo se llama simplemente History y, al igual que el de contraseñas, es una base de datos SQLite.
  1. Localizar y Extraer el Historial
  El archivo se encuentra en la misma ruta que el de logins. Vamos a copiarlo a nuestra carpeta de trabajo:
  Bash
  cp "/mnt/disco_abierto/Users/Suspect/AppData/Local/Google/Chrome/User Data/Default/History" ~/evidencia/
  2. Script de Python para Generar el Timeline
  Este script extraerá las URLs visitadas, el título de la página y la hora exacta (convertida de formato WebKit/Chrome a formato humano).
  Crea un archivo llamado analisis_historial.py:
  Python
  import sqlite3 import datetime import os ruta_history = os.path.expanduser("~/evidencia/History") def cromo_to_human(timestamp): # Chrome usa microsegundos desde el 1 de enero de 1601 return datetime.datetime(1601, 1, 1) + datetime.timedelta(microseconds=timestamp) def extraer_historial(): if not os.path.exists(ruta_history): print("[-] No se encontró el archivo History.") return conn = sqlite3.connect(ruta_history) cursor = conn.cursor() # Query para unir visitas con URLs y tiempo query = """ SELECT last_visit_time, url, title FROM urls ORDER BY last_visit_time DESC """ try: cursor.execute(query) print(f"{'FECHA Y HORA':<25} | {'TÍTULO / URL'}") print("-" * 100) for row in cursor.fetchall(): fecha = cromo_to_human(row[0]) url = row[1] titulo = row[2] if row[2] else "Sin título" print(f"{str(fecha):<25} | {titulo[:50]}") print(f"{' ':<25} | {url[:70]}...") print("-" * 100) except Exception as e: print(f"Error: {e}") finally: conn.close() if __name__ == "__main__": extraer_historial()
  3. ¿Qué buscar en el Historial?
  Una vez que ejecutes el script (python3 analisis_historial.py), fíjate en estos patrones:
  Descargas: Si ves URLs que terminan en .zip, .exe o .pdf, busca esos archivos en la carpeta Downloads de la imagen.
  Búsquedas en Google: Las URLs que contienen google.com/search?q=... te dirán exactamente qué estaba pensando el usuario.
  Accesos a Webmail: Entradas a Gmail o Outlook pueden indicar que hay evidencia en la nube que aún no has recolectado.
  4. Recuperar Historial Borrado
  Si el historial está vacío porque el usuario lo borró, todavía hay una oportunidad.
  Autopsy: Como vimos antes, Autopsy analiza el "Slack Space" (espacio entre archivos) y puede recuperar registros de SQLite que fueron marcados como borrados pero no sobrescritos.
  DNS Cache: En Kali, si el sistema estuviera vivo, usaríamos ipconfig /displaydns, pero en forense "muerto", buscamos en el archivo de hibernación o RAM.