Craquer des archives ZIP protégées par mot de passe avec Hashcat

Introduction

Dans ce laboratoire, vous apprendrez le processus fondamental de craquage d'une archive ZIP protégée par mot de passe. Il s'agit d'une tâche courante en criminalistique numérique et en tests d'intrusion. Vous utiliserez une combinaison d'outils en ligne de commande disponibles sous Linux pour y parvenir. Le processus implique la création d'un fichier protégé d'exemple, l'extraction de son hash de mot de passe, puis l'utilisation d'un puissant outil de récupération de mot de passe, Hashcat, pour craquer le hash et révéler le mot de passe d'origine.

À la fin de ce laboratoire, vous serez familiarisé avec :

La création de fichiers ZIP cryptés.
L'utilisation de zip2john pour extraire les hashes de mots de passe.
La préparation des hashes pour une utilisation avec Hashcat.
L'exécution d'une attaque par dictionnaire avec Hashcat pour récupérer un mot de passe.

Créer un fichier ZIP protégé par mot de passe

Dans cette étape, vous allez créer un fichier ZIP protégé par mot de passe. Il servira de cible pour l'exercice de craquage de mot de passe. Nous utiliserons la commande standard zip avec l'option -e, qui signifie "encrypt" (chiffrer).

Tout d'abord, assurez-vous d'être dans le répertoire ~/project. Nous avons déjà créé un fichier nommé secret.txt pour vous lors du processus de configuration.

Exécutez maintenant la commande suivante pour créer une archive ZIP cryptée nommée secret.zip à partir du fichier secret.txt.

zip -e secret.zip secret.txt

Le système vous demandera d'entrer et de vérifier un mot de passe. Pour ce laboratoire, utilisez le mot de passe labex. Tapez labex, appuyez sur Entrée, puis tapez-le à nouveau pour vérifier.

Enter password:
Verify password:
  adding: secret.txt (stored 0%)

Une fois la commande terminée, vous pouvez utiliser la commande ls pour vérifier que le fichier secret.zip a été créé dans votre répertoire actuel.

ls -l

Vous devriez voir secret.zip listé dans la sortie.

-rw-r--r-- 1 labex labex  218 May 20 10:00 secret.zip
-rw-r--r-- 1 labex labex   23 May 20 10:00 secret.txt
-rw-r--r-- 1 labex labex   32 May 20 10:00 wordlist.txt

Utiliser zip2john pour extraire le hash du fichier ZIP

Dans cette étape, vous utiliserez l'utilitaire zip2john pour extraire le hash du mot de passe du fichier secret.zip. Les outils de craquage de mots de passe comme Hashcat ne fonctionnent pas directement sur le fichier crypté ; ils fonctionnent sur son hash. zip2john est un outil de la suite John the Ripper conçu spécifiquement à cet effet.

Exécutez la commande suivante pour traiter secret.zip et enregistrer le hash résultant dans un nouveau fichier nommé zip_hash.txt.

zip2john secret.zip > zip_hash.txt

Cette commande ne produit aucune sortie directe dans le terminal car nous l'avons redirigée vers le fichier zip_hash.txt. Pour voir le hash extrait, vous pouvez afficher le contenu du nouveau fichier en utilisant la commande cat.

cat zip_hash.txt

La sortie ressemblera à ce qui suit. Cette chaîne contient toutes les informations nécessaires pour craquer le mot de passe.

secret.zip:$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$

Formater le hash pour la compatibilité avec Hashcat

Dans cette étape, vous allez formater le hash extrait pour le rendre compatible avec Hashcat. La sortie de zip2john inclut le nom du fichier d'origine (secret.zip:) comme préfixe de la chaîne de hash. Hashcat ne nécessite que les données de hash pures.

Examinons à nouveau le contenu de zip_hash.txt : secret.zip:$pkzip2$1*1*2*0*8*24*...

Nous devons supprimer la partie secret.zip:. Une façon simple de le faire est d'utiliser la commande cut, qui peut diviser le texte en fonction d'un délimiteur. Nous utiliserons le deux-points (:) comme délimiteur et sélectionnerons le deuxième champ.

Exécutez la commande suivante pour extraire le hash et l'enregistrer dans un nouveau fichier appelé hashcat_ready.txt.

cut -d':' -f2 zip_hash.txt > hashcat_ready.txt

cut : La commande pour découper des parties de lignes.
-d':' : Spécifie que le délimiteur est un deux-points.
-f2 : Spécifie que nous voulons le deuxième champ.

Maintenant, affichez le contenu du nouveau fichier pour confirmer qu'il ne contient que le hash.

cat hashcat_ready.txt

La sortie devrait être la chaîne de hash sans le préfixe du nom de fichier.

$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$

Ce fichier est maintenant prêt à être utilisé avec Hashcat.

Sélectionner le bon mode Hashcat pour PKZIP

Dans cette étape, vous apprendrez à identifier le bon mode de hash pour Hashcat. Hashcat prend en charge le craquage de centaines de types de hash différents, et vous devez spécifier le type que vous fournissez à l'aide d'un numéro de mode.

Le hash que nous avons extrait commence par $pkzip2$ . Cela indique le type de chiffrement ZIP utilisé. Nous pouvons rechercher dans la documentation d'aide de Hashcat les modes liés à "PKZIP" pour trouver le bon numéro.

Utilisez la commande suivante pour rechercher "pkzip" dans la sortie d'aide de Hashcat.

hashcat --help | grep -i "pkzip"

La sortie listera plusieurs modes de hash liés à différentes versions du chiffrement PKZIP.

17200 | PKZIP (legacy)                                       | Archives
17210 | PKZIP (legacy) (Compressed)                            | Archives
17220 | PKZIP (legacy) (Mixed)                                 | Archives
17225 | PKZIP (legacy) (Mixed + Compressed)                    | Archives
20500 | PKZIP Master Key                                       | Archives
20510 | PKZIP Master Key (Compressed)                          | Archives

Notre hash, généré à partir d'un simple ZIP protégé par mot de passe, correspond au type "PKZIP (legacy)". Comme vous pouvez le voir dans la sortie, le numéro de mode pour celui-ci est 17200. Nous utiliserons ce mode dans la prochaine étape pour lancer notre attaque.

Lancer une attaque pour récupérer le mot de passe ZIP

Dans cette étape, vous allez lancer l'attaque de craquage de mot de passe à l'aide de Hashcat. Nous allons effectuer une attaque "straight" ou par dictionnaire, où Hashcat essaie chaque mot de passe d'une liste donnée. Nous avons déjà préparé une liste simple nommée wordlist.txt.

La structure de la commande pour Hashcat est la suivante : hashcat [options] <fichier_hash> <fichier_liste_de_mots>

Sur la base de nos étapes précédentes, la commande complète est :

hashcat -m 17200 -a 0 hashcat_ready.txt wordlist.txt

Décomposons la commande :

-m 17200 : Spécifie le mode de hash pour PKZIP (legacy), que nous avons identifié à l'étape précédente.
-a 0 : Spécifie le mode d'attaque. 0 représente une attaque Straight (par dictionnaire).
hashcat_ready.txt : Le fichier contenant notre hash cible.
wordlist.txt : Le fichier contenant la liste des mots de passe potentiels.

Exécutez la commande. Hashcat démarrera, initialisera son backend et commencera l'attaque.

hashcat (v6.2.6) starting

...

Session..........: hashcat
Status...........: Cracked
Hash.Name........: PKZIP (legacy)
Hash.Target......: $pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$
Time.Started.....: ...
Time.Estimated...: 0 secs
Guess.Base.......: File (wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   248.2 kH/s (0.10ms) @ Accel:128 Loops:128 Thr:1
Recovered........: 1/1 (100.00%) Digests
Progress.........: 4/4 (100.00%)
Rejected.........: 0/4 (0.00%)
Restore.Point....: 3/4 (75.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: labex -> zzzzzzz
Hardware.Mon.#1..: Temp: 48c

$pkzip2$1*1*2*0*8*24*7b4f4718*0*28*0*8*24*7b4f*53a9*$/pkzip2$:labex

Started: ...
Stopped: ...

Hashcat a trouvé le mot de passe très rapidement car notre liste de mots était petite. La dernière ligne de la sortie montre le hash suivi du mot de passe récupéré : labex.

Félicitations, vous avez réussi à craquer le mot de passe de l'archive ZIP !

Résumé

Dans ce laboratoire, vous avez mené à bien l'ensemble du flux de travail pour craquer une archive ZIP protégée par mot de passe à l'aide d'outils en ligne de commande courants.

Vous avez appris à :

Créer un fichier ZIP chiffré à l'aide de la commande zip.
Extraire le hash du mot de passe du fichier ZIP à l'aide de zip2john.
Formater le hash extrait pour le rendre compatible avec Hashcat.
Identifier le bon mode de type de hash pour votre cible dans Hashcat.
Lancer une attaque par dictionnaire avec Hashcat pour récupérer avec succès le mot de passe.

Ces compétences constituent une compréhension fondamentale des techniques de récupération de mot de passe qui sont cruciales dans les domaines de la cybersécurité tels que la criminalistique numérique et le piratage éthique. Bien que nous ayons utilisé un mot de passe simple et une petite liste de mots à des fins éducatives, les mêmes principes s'appliquent à des scénarios plus complexes du monde réel.