Descifrar contraseñas de archivos ZIP con John the Ripper

Introducción

En este laboratorio, aprenderás a descifrar archivos ZIP protegidos con contraseña utilizando John the Ripper, una herramienta esencial de ciberseguridad para pruebas de penetración. Practicarás la extracción de hashes de archivos ZIP y realizarás ataques tanto de diccionario como de fuerza bruta para recuperar contraseñas.

El laboratorio ofrece experiencia práctica en la instalación de John the Ripper, la creación de archivos de prueba con contraseñas débiles y la verificación de las credenciales descifradas. A través de este ejercicio, entenderás las vulnerabilidades de las contraseñas débiles y la importancia de una fuerte encriptación en la seguridad de archivos.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) hydra(("Hydra")) -.-> hydra/HydraGroup(["Hydra"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") wireshark/WiresharkGroup -.-> wireshark/installation("Installation and Setup") hydra/HydraGroup -.-> hydra/installation("Installation and Setup") subgraph Lab Skills nmap/installation -.-> lab-549930{{"Descifrar contraseñas de archivos ZIP con John the Ripper"}} wireshark/installation -.-> lab-549930{{"Descifrar contraseñas de archivos ZIP con John the Ripper"}} hydra/installation -.-> lab-549930{{"Descifrar contraseñas de archivos ZIP con John the Ripper"}} end

Instalar John the Ripper

En este paso, instalarás John the Ripper, una poderosa herramienta de descifrado de contraseñas ampliamente utilizada en ciberseguridad. Antes de comenzar, entendamos lo que hace John the Ripper: ayuda a los profesionales de la seguridad a probar la fortaleza de las contraseñas probando diferentes combinaciones (fuerza bruta) o utilizando listas de palabras (ataques de diccionario) para adivinar contraseñas.

El entorno de la máquina virtual (VM) de LabEx viene preconfigurado con todas las dependencias necesarias, lo que hace que la instalación sea sencilla. Utilizaremos el gestor de paquetes de Ubuntu (apt), que se encarga de las instalaciones y actualizaciones de software.

Primero, necesitamos actualizar la lista de paquetes. Esto asegura que tu sistema sepa sobre las últimas versiones disponibles de todo el software:
```
sudo apt update
```
El comando sudo te otorga privilegios de administrador, mientras que apt update actualiza la lista de paquetes disponibles.
Ahora instala John the Ripper con este comando:
```
sudo apt install john -y
```
La bandera -y confirma automáticamente la instalación, evitándote tener que escribir 'yes' durante el proceso.
Después de que se complete la instalación, verifiquemos que todo funcione correctamente comprobando la versión instalada:
```
john --version
```
Deberías ver una salida similar a:
```
John the Ripper 1.9.0-jumbo-1
```

Esta comprobación de versión confirma que John the Ripper está listo para usar. En los próximos pasos, usaremos esta herramienta para demostrar cómo los archivos ZIP protegidos con contraseña pueden ser vulnerables a intentos de descifrado. Asegúrate de ver el número de versión antes de continuar, ya que esto indica una instalación exitosa.

Crear un archivo ZIP protegido con contraseña

En este paso, crearás un archivo ZIP protegido con contraseña que usaremos para practicar el descifrado de contraseñas en los pasos siguientes. ZIP es un formato de archivo comprimido común que admite la protección con contraseña para asegurar archivos sensibles. Entender cómo crear archivos ZIP protegidos es fundamental, ya que muchos sistemas del mundo real utilizan este método para la seguridad de archivos.

Primero, creemos un archivo de texto de muestra para proteger. Usaremos un archivo de texto simple con fines demostrativos:
```
echo "This is a secret file" > secret.txt
```
Este comando crea un nuevo archivo llamado secret.txt que contiene el texto "This is a secret file". El símbolo > redirige la salida del comando echo al archivo.
Ahora crearemos un archivo ZIP protegido con contraseña utilizando la utilidad zip. La bandera -e habilita la encriptación. Estamos usando "password123" como contraseña de ejemplo con fines de aprendizaje (ten en cuenta que esta es una contraseña débil y nunca debe usarse en escenarios reales):
```
zip -e secret.zip secret.txt
```
El comando te pedirá dos veces que ingreses y verifiques la contraseña. Esta doble entrada ayuda a evitar errores tipográficos en tu contraseña:
```
Enter password:
Verify password:
```
Verifiquemos que el archivo ZIP se haya creado correctamente. El comando ls -l muestra información detallada sobre los archivos en el directorio actual:
```
ls -l secret.zip
```
Deberías ver una salida similar a esta, que muestra que el archivo existe y su tamaño/fecha de modificación:
```
-rw-r--r-- 1 labex labex 210 May 10 10:00 secret.zip
```
Finalmente, probemos la protección con contraseña intentando extraer el archivo sin proporcionar la contraseña. Esto confirma que nuestro archivo ZIP está adecuadamente protegido:
```
unzip secret.zip
```
El sistema debería solicitar una contraseña y mostrar un error si ingresas la contraseña incorrecta o cancelas la operación.

Este archivo ZIP protegido servirá como nuestro caso de prueba en los siguientes pasos, donde extraeremos su hash y intentaremos descifrar la contraseña utilizando John the Ripper. Crear este archivo de prueba por ti mismo te ayuda a entender ambos lados del proceso de seguridad: cómo se aplica la protección y cómo se puede probar.

Extraer el hash del archivo ZIP

En este paso, extraerás el hash criptográfico del archivo ZIP protegido con contraseña que creamos anteriormente. Este proceso convierte la información de seguridad del archivo ZIP en un formato que John the Ripper puede entender y procesar para descifrar la contraseña.

Primero, naveguemos a nuestro directorio de trabajo y verifiquemos que el archivo ZIP exista. Esto asegura que estemos trabajando con el archivo correcto en la ubicación adecuada:
```
cd ~/project
ls secret.zip
```
Ahora usaremos la herramienta especializada de John the Ripper llamada zip2john. Esta utilidad extrae el hash de la contraseña de los archivos ZIP en un formato que John puede descifrar. El símbolo > redirige la salida a un nuevo archivo:
```
zip2john secret.zip > zip_hash.txt
```
Veamos el hash extraído para entender qué información se capturó. El comando cat muestra el contenido del archivo en la terminal:
```
cat zip_hash.txt
```
Deberías ver una salida similar a este ejemplo (tu hash real será diferente):
```
secret.zip:$pkzip$1*2*2*0*1c*1a*5e9b8f7d*0*42*0*1c*5e9b*55dc*secret.txt*$/pkzip$
```
El hash contiene varios componentes importantes:
- secret.zip: El nombre original del archivo ZIP
- $pkzip$ : Identifica que se trata de un hash en formato PKZIP
- La larga cadena de números y letras: Los datos reales de la contraseña encriptada
- secret.txt: El nombre del archivo dentro del archivo ZIP

Este archivo de hash extraído ahora contiene toda la información necesaria sobre la protección con contraseña del archivo ZIP, formateada específicamente para que John the Ripper la procese. En el siguiente paso, usaremos este archivo de hash para intentar recuperar la contraseña a través de varios métodos de descifrado.

Ejecutar John para descifrar la contraseña

En este paso, utilizarás John the Ripper para intentar descifrar la contraseña del archivo ZIP que protegimos anteriormente. John es una poderosa herramienta de descifrado de contraseñas que funciona probando diferentes combinaciones de contraseñas contra el hash que extrajimos. El hash es como una huella digital digital de tu contraseña que John puede analizar sin necesidad del archivo ZIP original.

Primero, asegúrate de estar en el directorio correcto con el archivo de hash. Esto es importante porque John necesita acceder al archivo de hash que creamos en el paso anterior:
```
cd ~/project
ls zip_hash.txt
```
El comando ls simplemente lista los archivos para confirmar que zip_hash.txt existe en tu directorio actual.
Ahora ejecutaremos John the Ripper especificando el formato PKZIP, ya que estamos trabajando con un archivo ZIP. La bandera --format=PKZIP le dice a John qué tipo de encriptación esperar:
```
john --format=PKZIP zip_hash.txt
```
John mostrará el progreso en tiempo real mientras intenta diferentes combinaciones de contraseñas. En nuestro caso, dado que usamos una contraseña débil ("password123"), el descifrado debería completarse casi instantáneamente. Así es como se ve la salida exitosa:
```
Loaded 1 password hash (PKZIP [32/64])
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (secret.zip)
1g 0:00:00:00 DONE (2023-05-10 10:00) 50.00g/s 50.00p/s 50.00c/s 50.00C/s password123
Use the "--show" option to display all of the cracked passwords reliably
Session completed
```
El "1g" indica que John probó 1 conjetura, y "password123" es la contraseña descifrada.
Para ver la contraseña descifrada en un formato limpio, usamos la opción --show. Este comando muestra todas las contraseñas descifradas con éxito del archivo de hash:
```
john --show zip_hash.txt
```
Verás una salida como esta:
```
secret.zip:password123:secret.txt:secret.zip
```
Esta salida muestra cuatro piezas de información separadas por dos puntos: el nombre del archivo ZIP, la contraseña descifrada, el archivo contenido en el archivo comprimido y el nombre del archivo comprimido de nuevo.

Ahora que tenemos la contraseña, podemos proceder a verificar que realmente funcione con nuestro archivo ZIP original en el siguiente paso. Esta verificación es crucial porque confirma que nuestro proceso de descifrado fue exitoso.

Confirmar la contraseña

En este último paso, verificarás que la contraseña descifrada por John the Ripper realmente funciona para extraer el archivo ZIP protegido. Este paso de confirmación es crucial en las evaluaciones de seguridad del mundo real para validar los resultados del descifrado. Piénsalo como probar una llave que has encontrado: necesitas intentar abrir la cerradura para confirmar que funciona.

Primero, revisemos la contraseña descifrada en el paso anterior. El siguiente comando muestra las contraseñas que John ha descifrado con éxito:
```
john --show zip_hash.txt
```
Deberías ver una salida similar a esta, que muestra el nombre del archivo, la contraseña descifrada y el contenido:
```
secret.zip:password123:secret.txt:secret.zip
```
Ahora probaremos si esta contraseña realmente funciona intentando extraer el archivo ZIP. El comando unzip es la herramienta estándar para extraer archivos ZIP en Linux:
```
unzip secret.zip
```
El sistema te pedirá la contraseña. Ingresa "password123" (la que acabamos de descifrar):
```
Archive:  secret.zip
[secret.zip] secret.txt password:
```
Después de ingresar la contraseña correcta, debemos verificar dos cosas: que el archivo se haya extraído y que su contenido coincida con lo que esperamos. Estos comandos listan los archivos en el directorio y muestran el contenido del archivo secreto:
```
ls
cat secret.txt
```
Deberías ver lo siguiente, lo que confirma la extracción exitosa:
```
This is a secret file
```
Finalmente, es una buena práctica limpiar los archivos extraídos una vez que hayas terminado de probar. Esto mantiene tu espacio de trabajo ordenado y evita el reuso accidental de archivos de prueba en futuros ejercicios:
```
rm secret.txt
```

Esta extracción exitosa confirma que John the Ripper descifró correctamente la contraseña del archivo ZIP. En una evaluación de seguridad real, este paso de verificación es esencial antes de reportar los hallazgos. Demuestra que la contraseña descifrada no era solo una coincidencia teórica, sino que realmente proporciona acceso al contenido protegido.

Resumen

En este laboratorio, has aprendido cómo instalar John the Ripper a través del gestor de paquetes apt y verificar que se haya configurado correctamente. También has practicado la creación de un archivo ZIP protegido con contraseña que contiene un documento de texto de muestra para simular escenarios reales de descifrado de contraseñas.

El ejercicio ha presentado técnicas fundamentales de evaluación de ciberseguridad al demostrar la preparación de un archivo objetivo para el descifrado de contraseñas. Estos pasos iniciales, incluyendo la instalación de herramientas y la validación de seguridad, proporcionan la base esencial para operaciones avanzadas de recuperación de contraseñas.