Casser des hachages avec Hashcat

Introduction

Dans ce laboratoire, vous apprendrez à utiliser Hashcat, l'outil de récupération de mots de passe le plus rapide au monde, pour casser des hachages cryptographiques. Vous allez pratiquer l'installation de Hashcat, la préparation de fichiers de hachage, la configuration de l'accélération GPU et l'exécution d'attaques par force brute contre des exemples de hachages MD5.

Les exercices pratiques vous guideront à travers le cassage d'exemples de mots de passe du monde réel tout en optimisant les performances. Vous acquerrez une expérience pratique des techniques essentielles en cybersécurité pour la récupération de mots de passe et les tests de sécurité.

Skills Graph

Installer Hashcat

Dans cette étape, vous allez installer Hashcat, l'outil de récupération de mots de passe le plus rapide au monde. Hashcat est un utilitaire puissant utilisé pour casser des hachages grâce à diverses méthodes d'attaque telles que les attaques par force brute, les attaques par dictionnaire et les attaques basées sur des règles.

Avant de commencer, comprenons ce qu'est un hachage. Un hachage est une chaîne de caractères de longueur fixe générée par une fonction mathématique qui prend une entrée (comme un mot de passe) et produit une sortie brouillée. Les systèmes de mots de passe stockent ces hachages au lieu des mots de passe en texte brut pour des raisons de sécurité. Hashcat aide à récupérer le mot de passe d'origine en essayant différentes combinaisons pour correspondre au hachage stocké.

Tout d'abord, nous devons nous assurer que nous sommes dans le bon répertoire de travail. Le répertoire ~/project est là où nous effectuerons toutes nos opérations de laboratoire :

cd ~/project

Maintenant, nous allons installer Hashcat en utilisant le gestionnaire de paquets d'Ubuntu. Le gestionnaire de paquets gère le téléchargement et la configuration du logiciel ainsi que ses dépendances. Nous exécutons deux commandes ensemble : tout d'abord, nous mettons à jour la liste des paquets (update), puis nous installons Hashcat (install) :

sudo apt-get update && sudo apt-get install -y hashcat

Le paramètre -y confirme automatiquement l'installation, nous évitant d'avoir à taper 'yes' pendant le processus.

Une fois l'installation terminée, vérifions que Hashcat est correctement installé en vérifiant sa version. C'est une bonne pratique pour confirmer que le logiciel est prêt à être utilisé :

hashcat --version

Vous devriez voir une sortie indiquant le numéro de version installé, par exemple :

v6.2.6

Voir ce numéro de version signifie que Hashcat est correctement installé sur votre système. Dans les étapes suivantes, nous l'utiliserons pour travailler avec des fichiers de hachage réels et effectuer des opérations de cassage. Le numéro de version est également utile lors de la consultation de la documentation ou de la résolution de problèmes, car les fonctionnalités peuvent varier d'une version à l'autre.

Préparer un fichier de hachage

Dans cette étape, vous allez créer un fichier de hachage d'exemple qui sera utilisé pour le cassage dans les étapes suivantes. Un hachage est une chaîne de caractères de longueur fixe générée par un algorithme cryptographique qui représente des données d'entrée. Les fichiers de hachage contiennent ces hachages cryptographiques que nous allons tenter de casser en utilisant Hashcat.

Tout d'abord, assurez-vous que vous êtes dans le bon répertoire de travail. La commande cd permet de changer de répertoire actuel :

cd ~/project

Créons un simple fichier texte contenant des hachages MD5. MD5 est une fonction de hachage cryptographique largement utilisée qui produit une valeur de hachage de 128 bits. Nous allons utiliser l'éditeur de texte nano pour créer et éditer un nouveau fichier :

nano hashes.txt

Ajoutez les hachages MD5 d'exemple suivants au fichier. Ce sont des hachages de test courants avec des valeurs en texte brut connues (appuyez sur Ctrl+O pour enregistrer et Ctrl+X pour quitter nano) :

5f4dcc3b5aa765d61d8327deb882cf99  ## mot de passe : "password"
098f6bcd4621d373cade4e832627b4f6  ## mot de passe : "test"

Alternativement, vous pouvez créer le fichier directement en utilisant des commandes echo. L'opérateur > crée un nouveau fichier, tandis que >> ajoute du contenu à un fichier existant :

echo "5f4dcc3b5aa765d61d8327deb882cf99" > hashes.txt
echo "098f6bcd4621d373cade4e832627b4f6" >> hashes.txt

Vérifiez le contenu de votre fichier de hachage en utilisant la commande cat, qui affiche le contenu d'un fichier dans le terminal :

cat hashes.txt

Vous devriez voir les deux hachages MD5 affichés dans votre terminal. Ce fichier servira de cible pour le cassage de hachage dans les étapes suivantes lorsque nous configurerons Hashcat et exécuterons des attaques par force brute. Avoir des hachages de test connus permet de vérifier que notre configuration de cassage fonctionne correctement.

Configurer le support GPU

Dans cette étape, vous allez configurer Hashcat pour utiliser l'accélération GPU afin de casser les hachages plus rapidement. Hashcat peut exploiter les ressources du CPU et du GPU, mais les GPU sont particulièrement efficaces pour le cassage de mots de passe car ils contiennent des milliers de petits cœurs capables d'effectuer de nombreux calculs simultanément. Cette capacité de traitement parallèle rend les GPU beaucoup plus rapides que les CPU pour les attaques par force brute.

Avant de configurer le support GPU, vérifions d'abord quels périphériques matériels sont disponibles pour Hashcat. Exécutez cette commande pour lister tous les périphériques OpenCL détectés :

hashcat -I

Cette commande affichera les périphériques OpenCL disponibles. Dans l'environnement de la machine virtuelle LabEx, vous devriez voir une sortie similaire à :

OpenCL Platform #1: NVIDIA Corporation
* Device #1: NVIDIA GeForce GTX 1080 Ti, 10240/11264 MB allocatable, 28MCU

La sortie montre les détails de votre GPU, y compris son modèle et sa capacité mémoire. Maintenant, nous allons créer un fichier de configuration pour optimiser les performances de Hashcat. Les fichiers de configuration permettent d'automatiser les paramètres afin que vous n'ayez pas à les taper à chaque fois.

Créez et éditez le fichier de configuration avec :

nano ~/.hashcat/hashcat.conf

Ajoutez la configuration suivante (appuyez sur Ctrl+O pour enregistrer et Ctrl+X pour quitter) :

--force
--opencl-device-types=1,2
--workload-profile=4

Comprenons ce que chaque paramètre fait :

• --force indique à Hashcat de continuer même s'il détecte des problèmes potentiels (utile dans les environnements de laboratoire)
• --opencl-device-types=1,2 active à la fois les périphériques CPU (type 1) et GPU (type 2) pour le traitement
• --workload-profile=4 définit le profil de performance le plus élevé, en priorisant la vitesse plutôt que l'économie d'énergie

Pour confirmer que tout fonctionne correctement, exécutez un test de benchmark :

hashcat -b

Le benchmark testera divers algorithmes de hachage et affichera des métriques de performance telles que :

Speed.#1.........: 12345.7 MH/s (98.23ms) @ Accel:1024 Loops:1024 Thr:256 Vec:1

Ces chiffres montrent combien de hachages votre système peut tester par seconde. Des valeurs plus élevées signifient un cassage plus rapide. Le benchmark confirme que l'accélération GPU est active et prête à être utilisée dans l'étape suivante où nous effectuerons l'attaque par force brute réelle.

Exécuter une attaque par force brute

Dans cette étape, vous allez exécuter une attaque par force brute en utilisant Hashcat pour casser les hachages MD5 que nous avons préparés précédemment. Une attaque par force brute est une méthode d'essais-erreurs qui vérifie systématiquement toutes les combinaisons de caractères possibles jusqu'à trouver le mot de passe correct. Cette approche est particulièrement utile lorsque vous n'avez aucune information sur la structure du mot de passe.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où nous avons stocké le fichier de hachage. Cela permet à Hashcat d'accéder au fichier que nous voulons casser :

cd ~/project

Maintenant, nous allons utiliser Hashcat avec des paramètres spécifiques conçus pour notre attaque :

• -m 0 indique à Hashcat que nous travaillons avec des hachages MD5 (chaque type de hachage a un numéro spécifique dans Hashcat)
• -a 3 définit le mode d'attaque sur force brute
• ?a?a?a?a définit notre masque de mot de passe - cela signifie que nous recherchons des mots de passe de exactement 4 caractères qui peuvent inclure :
  • Des lettres minuscules (a-z)
  • Des lettres majuscules (A-Z)
  • Des chiffres (0-9)
  • Des caractères spéciaux (!@#$% etc.)

Exécutez l'attaque par force brute avec cette commande :

hashcat -m 0 -a 3 hashes.txt ?a?a?a?a --force

Au fur et à mesure que Hashcat s'exécute, il affichera des statistiques en temps réel dans votre terminal. Cette sortie vous permet de suivre la progression du cassage :

Session..........: hashcat
Status...........: Running
Hash.Name........: MD5
Hash.Target......: hashes.txt
Time.Started.....: [timestamp]
Speed.#1.........: [speed] H/s
Recovered........: 0/2 (0.00%)
Progress.........: [progress]
Rejected.........: 0
Restore.Point....: 0

La vitesse de cassage (H/s) montre combien de calculs de hachage votre système effectue par seconde. L'indicateur de progression permet d'estimer le temps restant. Pour un mot de passe de 4 caractères, cela peut prendre plusieurs minutes en fonction de votre matériel.

Lorsque l'attaque est terminée, nous pouvons vérifier les résultats. La commande suivante affiche tous les mots de passe cassés avec succès :

hashcat -m 0 hashes.txt --show

Une sortie réussie associera chaque hachage avec le mot de passe en texte brut découvert :

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Cette sortie confirme que Hashcat a réussi à inverser les deux hachages MD5 de notre fichier de test pour retrouver les mots de passe originaux. La première colonne montre le hachage avec lequel nous avons commencé, tandis que la deuxième colonne révèle le mot de passe réel qui a créé ce hachage.

Vérifier les hachages cassés

Dans cette étape finale, vous allez vérifier et analyser les résultats de votre attaque par force brute. Hashcat stocke automatiquement les mots de passe cassés avec succès dans un fichier spécial appelé le "potfile". Ce fichier agit comme une base de données de tous les mots de passe que vous avez récupérés lors de vos sessions de cassage. Nous allons l'examiner pour confirmer quels mots de passe ont été cassés avec succès.

Tout d'abord, naviguons jusqu'à notre répertoire de travail où nous avons stocké notre fichier de hachage. Cela garantit que nous travaillons avec les bons fichiers :

cd ~/project

Pour afficher tous les hachages cassés de votre attaque, nous utilisons le flag --show avec Hashcat. Cette commande recherche spécifiquement les hachages MD5 (mode 0) dans notre fichier hashes.txt et affiche toutes les correspondances trouvées dans le potfile :

hashcat -m 0 hashes.txt --show

Vous devriez voir une sortie similaire à celle-ci, montrant le hachage original suivi de son mot de passe en texte brut cassé :

5f4dcc3b5aa765d61d8327deb882cf99:password
098f6bcd4621d373cade4e832627b4f6:test

Pour une compréhension plus complète de votre session de cassage, le flag --status fournit des statistiques précieuses. Cela montre combien de hachages ont été cassés, le type de hachage et les métriques de performance :

hashcat -m 0 hashes.txt --status

Cela affichera des informations importantes, notamment :

Session.Name.....: hashcat
Status..........: Exhausted
Hash.Name.......: MD5
Hash.Target.....: hashes.txt
Time.Started....: [timestamp]
Time.Estimated..: [timestamp]
Recovered.......: 2/2 (100.00%)
Progress.......: [progress]
Speed.#1.......: [speed] H/s

Pour générer un rapport complet de votre session de cassage que vous pouvez enregistrer et consulter plus tard, utilisez les commandes suivantes. La première crée un fichier de rapport formaté, et la deuxième affiche son contenu :

hashcat -m 0 hashes.txt --outfile-format=2 --outfile=results.txt
cat results.txt

Le rapport contiendra des informations détaillées sur chaque hachage cassé, y compris le type de hachage, le mot de passe en texte brut et le temps exact qu'il a fallu pour le casser. Cette documentation est particulièrement utile lorsque vous devez analyser vos performances de cassage ou partager les résultats avec d'autres personnes.

Résumé

Dans ce laboratoire, vous avez appris à installer et configurer Hashcat, un outil puissant de récupération de mots de passe, en mettant à jour le gestionnaire de paquets et en vérifiant sa version. Vous avez également préparé un fichier de hachage contenant des exemples de hachages MD5 et confirmé son contenu à l'aide de commandes Linux de base.

De plus, vous avez exploré le support GPU de Hashcat pour optimiser les performances et effectué une attaque par force brute pour casser les hachages d'exemple. Cette exercice pratique a démontré le rôle essentiel de Hashcat en cybersécurité pour les scénarios de récupération de mots de passe et d'évaluation de vulnérabilité.