Comprendre la structure des commandes Hashcat

Introduction

Hashcat est un outil de récupération de mots de passe puissant et polyvalent. Pour l'utiliser efficacement, vous devez d'abord comprendre sa structure en ligne de commande. Une seule commande Hashcat est composée de plusieurs éléments clés qui indiquent au programme exactement quoi cracker et comment le faire.

Dans ce laboratoire, vous apprendrez la structure fondamentale d'une commande Hashcat. Nous allons construire une commande complète et fonctionnelle pièce par pièce, en couvrant les cinq composants essentiels : l'exécutable, le type de hash, le mode d'attaque, le fichier de hash d'entrée et le fichier de mots d'entrée (wordlist). À la fin, vous serez capable de construire des commandes Hashcat de base pour des attaques basées sur un dictionnaire.

Identifier les composants principaux d'une commande Hashcat

Dans cette étape, nous allons identifier la syntaxe de base d'une commande Hashcat. Comprendre cette structure est la première étape pour utiliser l'outil.

Une commande Hashcat typique suit ce schéma :

hashcat [options] fichier_hash [liste_de_mots/masque]

Décomposons ces composants :

• hashcat : C'est le nom du programme exécutable lui-même.
• [options] : Ce sont des indicateurs (flags) qui modifient le comportement du programme. Les options les plus critiques sont -m pour le type de hash et -a pour le mode d'attaque, que nous aborderons dans les étapes suivantes.
• fichier_hash : C'est le chemin vers le fichier qui contient le hash ou les hashes que vous souhaitez cracker.
• [liste_de_mots/masque] : C'est le chemin vers un fichier d'entrée, tel qu'une liste de mots pour une attaque par dictionnaire, ou un modèle de masque pour une attaque par force brute.

Pour commencer, visualisons le menu d'aide intégré pour avoir une idée de l'outil. Cette commande liste toutes les options et informations disponibles.

Exécutez la commande suivante dans votre terminal :

hashcat --help

Vous verrez une longue sortie détaillant toutes les fonctionnalités de Hashcat. Nous nous référerons à ces informations dans les étapes à venir.

hashcat (v6.2.6) starting in help mode

Usage: hashcat [options]... hash|hashfile|hccapxfile [dictionary|mask|directory]...

...
-a,  --attack-mode              | Num    | Attack-mode, see references below.
-m,  --hash-type                | Num    | Hash-type, see references below.
...

Maintenant que nous comprenons la structure de base, nous pouvons commencer à construire notre commande.

Spécifier le type de hash avec l'indicateur -m

Dans cette étape, vous apprendrez comment spécifier le type de hash cible. Hashcat prend en charge des centaines d'algorithmes de hachage différents, et vous devez lui indiquer celui que vous essayez de cracker. Cela se fait en utilisant l'indicateur -m suivi d'un code numérique.

Notre environnement de laboratoire a préparé un fichier nommé hashes.txt qui contient un hash MD5. Pour trouver le code correct pour MD5, vous pouvez parcourir la sortie de hashcat --help.

Utilisez la commande grep pour filtrer le texte d'aide pour "MD5" :

hashcat --help | grep MD5

La sortie vous montrera tous les types de hash liés à MD5, ainsi que leurs codes correspondants.

      0 | MD5                                            | Raw Hash, Salted and/or Iterated
   10 | md5($pass.$salt)                                 | Raw Hash, Salted and/or Iterated
   20 | md5($salt.$pass)                                 | Raw Hash, Salted and/or Iterated
...

Comme vous pouvez le voir, le code pour un hash MD5 standard est 0. Nous pouvons maintenant l'ajouter à notre commande. La commande ressemble actuellement à ceci :

hashcat -m 0 ...

Dans la prochaine étape, nous spécifierons le mode d'attaque.

Spécifier le mode d'attaque avec l'indicateur -a

Dans cette étape, vous apprendrez comment définir le mode d'attaque à l'aide de l'indicateur -a. Le mode d'attaque indique à Hashcat quelle méthode utiliser pour cracker le mot de passe.

Hashcat propose plusieurs modes d'attaque, mais les plus courants sont :

• 0 : Straight (Attaque par dictionnaire) - Compare les hashes à une liste de mots.
• 1 : Combination - Combine des mots provenant de deux dictionnaires différents.
• 3 : Brute-force (Attaque par masque) - Essaie toutes les combinaisons possibles de caractères basées sur un modèle défini (masque).

Pour ce laboratoire, nous effectuerons une attaque Straight (par dictionnaire), nous utiliserons donc le mode d'attaque 0. Vous pouvez trouver la liste de tous les modes d'attaque dans le menu d'aide.

Utilisons à nouveau grep pour trouver la section "Attack-Modes" :

hashcat --help | grep "Attack-Modes" -A 10

L'indicateur -A 10 demande à grep d'afficher les 10 lignes suivant la correspondance, vous donnant ainsi la liste complète.

- [ Attack-Modes ] -

  ## | Mode
 ===+======
  0 | Straight
  1 | Combination
  3 | Brute-force
  6 | Hybrid dict + mask
  7 | Hybrid mask + dict

Nous avons maintenant identifié notre mode d'attaque. Ajoutons-le à notre commande, qui devient alors :

hashcat -m 0 -a 0 ...

Ensuite, nous fournirons le fichier contenant le hash que nous voulons cracker.

Fournir le fichier de hash d'entrée

Dans cette étape, vous spécifierez le fichier d'entrée qui contient le hash à cracker. Cet argument vient après les options.

Le script de configuration de ce laboratoire a déjà créé un fichier nommé hashes.txt dans votre répertoire actuel (~/project). Ce fichier contient un seul hash MD5.

Visualisons le contenu de ce fichier à l'aide de la commande cat :

cat hashes.txt

Vous devriez voir la sortie suivante :

5f4dcc3b5aa765d61d8327deb882cf99

C'est le hash que nous allons cracker. Pour l'ajouter à notre commande, nous plaçons simplement le nom du fichier après les options. Notre commande ressemble maintenant à ceci :

hashcat -m 0 -a 0 hashes.txt ...

La dernière étape consiste à fournir la liste de mots (wordlist) pour notre attaque par dictionnaire.

Fournir la liste de mots ou le masque d'entrée

Dans cette dernière étape, vous fournirez le dernier composant requis pour notre attaque par dictionnaire : la liste de mots (wordlist). Une liste de mots est un fichier texte où chaque ligne représente un mot de passe potentiel.

L'environnement de laboratoire inclut une liste de mots simple nommée wordlist.txt. Examinons son contenu :

cat wordlist.txt

La sortie sera :

test
hello
password
123456

Cette liste de mots sera utilisée par Hashcat pour tester le hash. Le fichier de liste de mots est le dernier argument de notre commande.

Maintenant, assemblons et exécutons la commande complète :

hashcat -m 0 -a 0 hashes.txt wordlist.txt

Hashcat va démarrer. Comme notre hash et notre liste de mots sont très simples, il se terminera presque instantanément. La sortie affichera l'état de la session de cracking.

...
Session..........: hashcat
Status...........: Cracked
Hash.Name........: MD5
Hash.Target......: 5f4dcc3b5aa765d61d8327deb882cf99
Time.Started.....: ...
Time.Estimated...: 0 secs (0.00ms)
Guess.Base.......: File (wordlist.txt)
Guess.Queue......: 1/1 (100.00%)
Speed.#1.........:   496.9 kH/s (0.00ms) @ Accel:128 Loops:1 Thr:1 Vec:8
Recovered........: 1/1 (100.00%) Digests
Progress.........: 4/4 (100.00%)
Rejected.........: 0/4 (0.00%)
Restore.Point....: 4/4 (100.00%)
Restore.Sub.#1...: Salt:0 Amplifier:0-1 Iteration:0-1
Candidates.#1....: test -> 123456
Hardware.Mon.#1..: Util: 99%
...

La ligne Status...........: Cracked confirme le succès. Pour voir le mot de passe cracké, vous pouvez exécuter la même commande à nouveau avec l'indicateur --show.

hashcat -m 0 -a 0 hashes.txt wordlist.txt --show

La sortie affichera clairement le hash et son mot de passe en clair correspondant :

5f4dcc3b5aa765d61d8327deb882cf99:password

Félicitations, vous avez construit et exécuté avec succès une commande Hashcat complète !

Résumé

Dans ce laboratoire, vous avez appris la structure de commande fondamentale de Hashcat en construisant une commande à partir de zéro. Vous avez réussi à cracker un hash MD5 en utilisant une attaque par dictionnaire.

Vous comprenez maintenant les cinq composants essentiels d'une commande Hashcat de base :

1. Exécutable : hashcat
2. Type de Hash : Spécifié avec -m (par exemple, -m 0 pour MD5).
3. Mode d'Attaque : Spécifié avec -a (par exemple, -a 0 pour une attaque par dictionnaire).
4. Fichier de Hash : Le fichier contenant les hashes cibles (par exemple, hashes.txt).
5. Liste de Mots/Masque : L'entrée pour l'attaque (par exemple, wordlist.txt).

La structure de commande finale que vous avez apprise est : hashcat -m <type_de_hash> -a <mode_attaque> <fichier_hash> <liste_de_mots>. Ces connaissances vous fournissent une base solide pour explorer les fonctionnalités plus avancées de Hashcat.