Hashcat : Description, fonctionnement et usage

Vous vous demandez comment les experts en cybersécurité testent la solidité des mots de passe ? Pour cela, il faut comprendre ce qu’est un hash : une empreinte unique, illisible, qui protège les mots de passe sans les stocker en clair. Mais lorsque ces empreintes tombent entre de mauvaises mains, des logiciels spécialisés peuvent tenter de les casser… C’est ici qu’intervient Hashcat, un outil puissant, légal et redoutablement efficace pour auditer vos systèmes de sécurité.

Qu’est-ce que Hashcat ?

Hashcat est un outil open source de récupération de mots de passe, utilisé par les professionnels pour évaluer la robustesse des politiques d’authentification. Multi‑plateforme (Linux, Windows, macOS) et optimisé pour exploiter CPU et GPU, il sert à simuler des attaques contrôlées afin d’identifier des faiblesses et d’améliorer la sécurité.

En pratique, Hashcat ne « dévoile » pas un mot de passe à partir d’une base de données en clair, il teste des candidats face à des empreintes chiffrées pour déterminer si une combinaison est trop faible. Son objectif est pédagogique et défensif lorsqu’il est utilisé par des équipes sécurité dans un cadre autorisé.

Définition d’un hash et rôle dans la sécurité

Avant de comprendre Hashcat, il faut d’abord définir ce qu’est un hash. Lorsqu’un mot de passe est stocké sur un serveur, il est rarement conservé en clair. À la place, une fonction de hachage transforme ce mot de passe en une empreinte unique et irréversible, appelée hash. Cela permet de protéger les mots de passe en les remplaçant par une empreinte illisible, tout en permettant au système de vérifier leur validité sans jamais avoir besoin de connaître ou d’afficher le mot de passe d’origine.

• MD5 (empreinte 128 bits, aujourd’hui déconseillé pour protéger des mots de passe),
• SHA‑1 (160 bits, également obsolète pour les mots de passe),
• SHA‑256 (famille SHA‑2, plus robuste pour l’intégrité),
• bcrypt, scrypt, Argon2 (fonctions de dérivation de clé dites « lentes », plus adaptées à la protection des mots de passe).

En sécurité, on renforce ces empreintes avec un sel (une valeur aléatoire ajoutée au mot de passe avant hachage), et on privilégie des fonctions volontairement coûteuses en temps et en mémoire (comme bcrypt, scrypt ou Argon2). Cela complique fortement les essais automatisés.

Cependant, si un attaquant met la main sur ces empreintes, il peut essayer de retrouver les mots de passe d’origine en testant des milliers de combinaisons grâce à des outils puissants de déchiffrement. C’est exactement le type de tâche que permet Hashcat, dans un cadre légal et maîtrisé.

Hashcat : Un outil d’ethical hacking orienté pentest

Hashcat est un outil de récupération de mots de passe, puissant, rapide et largement utilisé en cybersécurité. Son objectif n’est pas de pirater, mais de tester la robustesse de vos systèmes dans le cadre d’un pentest effectué par un expert, un consultant en cybersécurité ou un Certified Ethical Hacker.

Son utilisation est parfaitement légale, à condition d’avoir l’autorisation explicite du propriétaire du système. Sans ce cadre, son emploi peut être considéré comme une infraction, voire une tentative d’intrusion.

Cas concret : lors d’un audit avec autorisation, l’équipe sécurité exporte des empreintes de mots de passe issues d’un système interne, exécute Hashcat avec une stratégie adaptée (par exemple dictionnaire enrichi de règles), identifie les identifiants faibles, puis recommande des mesures correctives (politiques de complexité, MFA, rotation, durcissement des algorithmes et des paramètres de hachage). Aucune donnée en clair n’est conservée, et les résultats sont documentés dans un rapport d’audit.

Pourquoi utiliser Hashcat ?

Les fuites de données, la réutilisation de mots de passe et des politiques internes peu appliquées exposent les organisations à des compromissions. Tester la robustesse des mots de passe, sur des empreintes récupérées de façon légale, permet de mesurer le risque réel et de prioriser les remédiations.

Hashcat est un outil de récupération de mots de passe, puissant, rapide et largement utilisé en cybersécurité. Son objectif n’est pas de pirater, mais de tester la robustesse de vos systèmes dans le cadre d’un pentest effectué par un expert. Multi‑OS et optimisé pour CPU et GPU, il gère des centaines de formats de hachage, les sessions et la reprise, ainsi que le benchmarking. Utilisé dans un cadre légal et éthique, Hashcat vous aide à identifier les faiblesses dans les politiques de mot de passe et à renforcer vos contrôles d’audit de sécurité.

Quels sont les cas d’usage courants ?

• Audit Active Directory : vérification des mots de passe à partir des hachés NTLM/NT récupérés légalement.
• Applications web : test de hachés issus d’apps et bases utilisateurs, par exemple bcrypt, PBKDF2, scrypt, SHA‑2.
• Réseaux Wi‑Fi : évaluation hors ligne de la robustesse des mots de passe WPA/WPA2 après capture autorisée du handshake.
• Vérifications internes récurrentes : contrôle de conformité des politiques, détection de réutilisations, exercices de sensibilisation et de formation.

Exemple : après un test d’intrusion autorisé, l’équipe sécurité évalue la réutilisation de mots de passe entre un CRM, l’AD et un VPN en auditant les hachés collectés de manière encadrée.

Est-ce légal et dans quel cadre l’utiliser ?

Son utilisation est parfaitement légale, à condition d’avoir l’autorisation explicite du propriétaire du système. Sans ce cadre, son emploi peut être considéré comme une infraction. Hashcat doit donc être utilisé dans un périmètre défini, documenté et traçable.

• Autorisation écrite : mandat signé précisant objectifs, responsables et fenêtres de tir.
• Périmètre clair : systèmes, comptes, plages IP, types de hachés, durée et limites d’impact.
• Collecte maîtrisée : travailler sur des hachés obtenus légalement, hors production quand c’est possible, stockage chiffré.
• Journalisation : consigner commandes, listes de mots, règles, horodatage, machines utilisées et résultats.
• Prudence opérationnelle : privilégier le craquage hors ligne, éviter les tentatives en ligne qui déclenchent des verrouillages.
• Confidentialité : clauses NDA, minimisation des données, suppression sécurisée des artefacts en fin de mission.
• Restitution et remédiation : rapport clair, recommandations, plan de durcissement des politiques de mots de passe.

Comment fonctionne Hashcat ?

Hashcat génère des candidats mots de passe et les compare à vos empreintes de hachage. Il s’appuie sur des backends de calcul adaptés à votre matériel (GPU ou CPU), ce qui lui permet d’exécuter des attaques efficaces tout en restant dans un cadre légal et maîtrisé lorsque vous disposez de l’autorisation adéquate.

En synthèse : choisissez d’abord le runtime compatible avec votre carte, puis un mode d’attaque adapté au type de hash et au contexte. Les GPU excellent sur les hashs rapides, les hashs lents exigent des stratégies plus ciblées.

Quels runtimes et drivers (OpenCL, CUDA, HIP/ROCm) ?

Hashcat fonctionne via plusieurs backends de calcul. Selon le constructeur et l’OS, installez le pilote et le SDK adaptés, puis vérifiez la reconnaissance des périphériques avec hashcat -I.

Constructeur / OS	Backend Hashcat	À installer	Documentation officielle
NVIDIA (Windows, Linux)	CUDA	CUDA Toolkit	NVIDIA CUDA Toolkit
AMD (Linux)	HIP via ROCm	AMD Radeon Software for Linux avec ROCm	ROCm sur Linux
AMD (Windows)	HIP	AMD Adrenalin Edition + AMD HIP SDK	HIP SDK Windows
Intel GPU (Windows, Linux)	OpenCL	Intel Graphics Compute Runtime (NEO)	Intel Compute Runtime (NEO)
CPU Intel/AMD	OpenCL	Intel CPU Runtime for OpenCL ou PoCL	Intel OpenCL CPU Runtime

Bonnes pratiques : installez les pilotes officiels et suivez les versions recommandées sur la page Hashcat dans la section « GPU Driver requirements ». Les piles CUDA et HIP/ROCm évoluent régulièrement, vérifiez la compatibilité de votre GPU et de votre OS dans la documentation des éditeurs avant toute mise à jour.

GPU ou CPU : comment Hashcat exploite le matériel ?

GPU : des milliers de cœurs légers traitent des candidats en parallèle. Idéal pour les hashs « rapides » et pour balayer de grands espaces de clés. Les performances dépendent fortement de la VRAM disponible, de la bande passante mémoire et du débit PCIe pour l’alimentation en candidats.

CPU : moins de cœurs mais plus polyvalents. Utile sur des charges à contrôle de flux complexe, sur des environnements sans GPU, ou pour orchestrer des attaques hybrides. Les CPU peuvent toutefois être très loin derrière les GPU sur des algorithmes peu coûteux en mémoire.

Conséquences : sur GPU, privilégiez des attaques massives (dictionnaires + règles, masques ciblés). Sur hashs très coûteux en mémoire, la supériorité du GPU diminue, d’où l’importance d’attaques plus heuristiques et de wordlists de qualité plutôt que de la seule force brute.

Quels modes d’attaque (IDs) ?

Hashcat propose plusieurs modes officiels, identifiés par un ID (-a) et documentés sur le Wiki Hashcat. Voici ceux à connaître pour démarrer :

• 0, Dictionary / Straight : applique une wordlist telle quelle, avec possibilité d’ajouter des règles (-r) pour muter les mots. Usage recommandé en premier passage sur des dictionnaires pertinents.
• 1, Combinator : combine deux dictionnaires en concaténant leurs entrées. Efficace pour tester des constructions naturelles type « mot+année », « prénom+site » (doc).
• 3, Mask : génère des candidats à partir d’un masque (ex. ?u?l?l?l?l?d?d) lorsque vous connaissez une structure probable (doc).
• 6, Hybrid dict + mask : prend une wordlist et ajoute un masque (ex. suffixer par 2 chiffres). Idéal pour tester les variantes courantes d’un mot de base (doc).
• 7, Hybrid mask + dict : préfixe un masque à chaque mot d’une wordlist. Utile si la partie variable se situe au début.
• Rule-based : pas un ID dédié, mais un moteur clé de Hashcat. Il s’utilise surtout avec -a 0/6/7 via -r pour produire des mutations réalistes (capitalisation, leetspeak, suffixes).
• Toggle-case : aujourd’hui couvert par les règles (bascule de casse ciblée) plutôt que par un mode séparé.

Conseil pratique : enchaînez 0 + règles, puis 6/7 avec masques ciblés, et ne réservez 3 (masque exhaustif) qu’aux espaces de recherche étroits ou bien contraints.

Hashs rapides vs hashs lents : quelle différence pratique ?

Hashs rapides (ex. NTLM, MD5, SHA1) : très peu coûteux en mémoire et en itérations, ils se prêtent à un parallélisme massif. Les GPU atteignent des débits élevés, ce qui favorise les dictionnaires riches, les règles agressives et des masques plus larges.

Hashs lents (ex. bcrypt, scrypt, Argon2) : conçus pour ralentir le craquage grâce à des itérations élevées et une mémoire dédiée. Même avec de gros GPU, la vitesse chute fortement. Stratégie recommandée : privilégier des attaques connaissance‑driven (dictionnaires spécialisés, règles fines, masques très ciblés), mesurer le --benchmark pour estimer la faisabilité et ajuster la priorité des scénarios d’attaque.

Quels algorithmes sont supportés ?

Hashcat prend en charge des centaines d’algorithmes et de formats d’empreintes. Chaque type de hash est identifié par un hash‑mode numérique, sélectionné avec l’option -m (ex. -m 0 pour MD5). Choisir le bon mode est essentiel, sinon vous obtiendrez souvent une erreur liée à la longueur ou au format de la ligne. Le wiki officiel publie des exemples qui permettent de vérifier rapidement la correspondance entre votre empreinte et le bon mode.

En pratique, Hashcat couvre à la fois les algorithmes rapides (MD5, SHA‑1, NTLM), de nombreux formats applicatifs, et des KDF lents conçus pour freiner les attaques (bcrypt, scrypt, Argon2, PBKDF2). Pour tout doute de format, référez‑vous aux example_hashes du wiki, qui listent les signatures attendues et les modes correspondants.

Références : modes et exemples officiels, page Example hashes du wiki Hashcat. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=example_hashes))

Exemples courants (MD5, SHA1, NTLM)

Algorithme	hash‑mode à utiliser (option -m)
MD5	0
SHA‑1	100
NTLM	1000

Exemple rapide : hashcat -m 1000 -a 0 ntlm.txt /usr/share/wordlists/rockyou.txt pour tenter un dictionnaire sur des empreintes NTLM. Les mêmes correspondances figurent dans la page example_hashes, utile pour valider votre format avant de lancer l’attaque.

Références : MD5 → 0, SHA‑1 → 100, NTLM → 1000, confirmés dans example_hashes. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=example_hashes))

Hashs lents et KDF (bcrypt, scrypt, Argon2, PBKDF2)

Contrairement aux empreintes rapides, les KDF sont coûteux en calcul, parfois aussi gourmands en mémoire, afin de rendre les essais massifs beaucoup plus lents. Par exemple, scrypt est explicitement conçu pour exiger une grande quantité de mémoire, et Argon2 expose des paramètres de coût (mémoire, itérations, parallélisme) qui durcissent l’attaque hors‑ligne. bcrypt et PBKDF2 reposent sur un comptage d’itérations qui ralentit chaque tentative.

Bonnes pratiques côté pentest : commencez par un dictionnaire avec règles, puis évaluez la faisabilité avec le banc d’essai intégré (hashcat -b -m 3200 pour bcrypt, par exemple). Attendez‑vous à des vitesses très inférieures à MD5/NTLM, ce qui impacte fortement la taille de l’espace de recherche et la durée d’exécution.

Données/repères : scrypt est mémoire‑dur par conception ; Argon2 documente des paramètres m/t/p qui augmentent le coût ; l’usage du benchmark Hashcat permet d’estimer les vitesses avant un run. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=example_hashes))

Wi‑Fi (WPA/WPA2/WPA3) et formats HC22000/HC22001

Depuis la version 6.0.0, Hashcat utilise les modes 22000/22001 qui remplacent les anciens formats Wi‑Fi. Le mode 22000 unifie les PMKID et EAPOL dans un seul fichier texte .hc22000 pour la récupération d’une clé partagée (PSK). Le mode 22001 sert à vérifier une PMK déjà connue. L’ancien .hccapx est déprécié et n’est plus supporté. Pour l’extraction, utilisez hcxdumptool et hcxpcapngtool afin de convertir vos captures pcapng en .hc22000 prêt à l’emploi.

• Ligne PMKID : WPA*01*PMKID*MAC_AP*MAC_CLIENT*ESSID***MESSAGEPAIR
• Ligne EAPOL : WPA*02*MIC*MAC_AP*MAC_CLIENT*ESSID*NONCE_AP*EAPOL_CLIENT*MESSAGEPAIR

Note importante : la récupération hors‑ligne d’une PSK WPA3‑SAE n’est pas supportée par Hashcat à ce jour. Les réseaux WPA3‑only ne produisent donc pas de matériel exploitable en hc22000 pour une attaque hors‑ligne standard.

Références : définition et champs des formats 22000/22001, outils d’extraction, fin du support .hccapx ; précisions sur l’absence de prise en charge WPA3‑SAE en PSK hors‑ligne. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=cracking_wpawpa2)) ([hashcat.net](https://hashcat.net/forum/printthread.php?tid=12080&utm_source=openai))

Comment choisir le bon hash‑mode ?

1. Identifier le format : regardez la source (Windows, Linux, base de données, Wi‑Fi) et la signature du hash (préfixes $1$, $2a$, $6$, longueur hexadécimale, présence d’un sel, etc.).
2. Comparer avec les exemples officiels : ouvrez la page example_hashes, trouvez la signature identique et relevez le hash‑mode associé.
3. Valider avant d’attaquer : testez votre commande sur l’exemple fourni par le wiki, puis lancez un petit hashcat -b -m <mode> pour estimer la vitesse et ajuster votre stratégie (dictionnaire, règles, masque).
4. Cas particuliers : si un outil d’extraction est requis (ex. Wi‑Fi), suivez les indications de la documentation dédiée et préparez un fichier d’entrée conforme au format attendu.

Références : méthodes de vérification et exemples fournis sur la page Example hashes du wiki Hashcat. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=example_hashes))

Comment installer Hashcat ?

Hashcat est un outil d’audit puissant, à utiliser uniquement avec l’autorisation explicite du propriétaire du système. L’installation se déroule en deux volets distincts, matériel puis logiciel, avant une courte vérification. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=frequently_asked_questions&utm_source=openai))

1. Préparer le matériel: vérifier la carte graphique disponible, la VRAM et, si besoin, prévoir plusieurs GPU.
2. Installer le runtime/driver adapté à votre OS et à votre matériel (CUDA, ROCm/HIP, OpenCL, Metal).
3. Installer Hashcat depuis un paquet, une archive officielle ou en compilation.
4. Vérifier la détection des périphériques et un benchmark rapide.

Quels prérequis matériels (GPU, VRAM) ?

• Compatibilité GPU: Hashcat fonctionne sur CPU et GPU, dont NVIDIA, AMD et Intel. Le multi‑GPU est pris en charge. ([en.wikipedia.org](https://en.wikipedia.org/wiki/Hashcat?utm_source=openai))
• VRAM: plus la VRAM est élevée, plus les attaques disposent d’espace pour les kernels et buffers. En pratique, visez 4 Go ou plus pour un usage confortable, davantage pour des algorithmes mémoire‑durs comme scrypt, bcrypt ou Argon2.
• CPU uniquement: possible via OpenCL CPU runtime, mais bien plus lent que le GPU.

Comparaison rapide: un GPU moderne correctement piloté (CUDA/HIP/Metal) offre des débits très supérieurs à un CPU, surtout sur les hash peu coûteux. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=frequently_asked_questions&utm_source=openai))

Quels prérequis logiciels et drivers ?

Installez le runtime correspondant à votre couple OS/GPU, puis redémarrez la session. Utilisez ensuite hashcat -I pour confirmer que votre matériel apparaît bien sous CUDA, HIP/ROCm, OpenCL ou Metal. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=hashcat&utm_source=openai))

OS / GPU	Runtime/driver attendu	Références
Windows + NVIDIA	CUDA Toolkit	([docs.nvidia.com](https://docs.nvidia.com/cuda/archive/12.9.0/pdf/CUDA_Installation_Guide_Windows.pdf?utm_source=openai))
Windows + AMD	AMD Software Adrenalin + AMD HIP SDK	([rocm.docs.amd.com](https://rocm.docs.amd.com/projects/install-on-windows/en/docs-6.1.2/reference/system-requirements.html?utm_source=openai))
Windows + Intel GPU	Intel Graphics Driver incluant OpenCL	([intel.com](https://www.intel.com/content/www/us/en/developer/articles/tool/opencl-drivers.html?utm_source=openai))
Windows + CPU (Intel/AMD)	Intel CPU Runtime for OpenCL ou PoCL	([intel.com](https://www.intel.com/content/dam/develop/external/us/en/documents/opencl-runtime-14-2-release-notes-515177.pdf?utm_source=openai))
Linux + NVIDIA	Pilote propriétaire NVIDIA + CUDA Toolkit	([docs.nvidia.com](https://docs.nvidia.com/cuda/archive/11.5.2/pdf/CUDA_Installation_Guide_Linux.pdf?utm_source=openai))
Linux + AMD	ROCm (HIP + OpenCL ROCr)	([rocm.docs.amd.com](https://rocm.docs.amd.com/en/7.13.0-preview/install/rocm.html?utm_source=openai))
Linux + Intel GPU	Intel Graphics Compute Runtime (NEO)	([github.com](https://github.com/intel/compute-runtime?utm_source=openai))
Linux + CPU	Intel CPU Runtime for OpenCL ou PoCL	([intel.com](https://www.intel.com/content/dam/develop/external/us/en/documents/opencl-runtime-14-2-release-notes-515177.pdf?utm_source=openai))
macOS (Apple Silicon)	Metal backend (détection automatique)	([github.com](https://github.com/hashcat/hashcat/blob/master/docs/changes.txt?utm_source=openai))
macOS (Intel + AMD)	OpenCL Apple, support limité	([hashcat.net](https://hashcat.net/forum/thread-11705-post-59608.html?utm_source=openai))

Astuce: sur Linux avec AMD ROCm, ajoutez l’utilisateur aux groupes video et render ou appliquez la règle udev proposée par AMD pour accéder à /dev/kfd et /dev/dri. Déconnectez‑vous puis reconnectez‑vous. ([rocm.docs.amd.com](https://rocm.docs.amd.com/en/7.13.0-preview/install/rocm.html?utm_source=openai))

Installer Hashcat sur Windows

1. Installez le driver/runtime adapté: CUDA Toolkit pour NVIDIA, AMD Adrenalin + HIP SDK pour AMD, pilote Intel pour GPU Intel, ou Intel CPU OpenCL si vous visez CPU. ([docs.nvidia.com](https://docs.nvidia.com/cuda/archive/12.9.0/pdf/CUDA_Installation_Guide_Windows.pdf?utm_source=openai))
2. Téléchargez la dernière release officielle de Hashcat et décompressez l’archive dans un dossier sans espace, par exemple C:\Tools\hashcat. ([github.com](https://github.com/hashcat/hashcat?utm_source=openai))
3. (Optionnel) Ajoutez le dossier au PATH utilisateur: Paramètres système avancés → Variables d’environnement → Path → Nouveau → C:\Tools\hashcat. Rouvrez PowerShell.
4. Vérifiez l’installation: hashcat -I doit lister votre backend (CUDA/HIP/OpenCL). Lancez un benchmark rapide: hashcat -b. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=hashcat&utm_source=openai))

Remarque: Hashcat avertit les utilisateurs NVIDIA utilisant uniquement OpenCL. L’installation du CUDA Toolkit débloque des optimisations mémoire et de meilleures performances. ([hashcat.net](https://hashcat.net/forum/thread-9303.html?utm_source=openai))

Installer Hashcat sur macOS

Sur Apple Silicon, Hashcat utilise le backend Metal. Selon les versions de macOS et de drivers, le support GPU reste plus limité que sous Windows ou Linux. Sur d’anciens Mac Intel, l’OpenCL Apple est déprécié et parfois restreint. ([github.com](https://github.com/hashcat/hashcat/blob/master/docs/changes.txt?utm_source=openai))

• Installation via Homebrew: brew install hashcat. ([formulae.brew.sh](https://formulae.brew.sh/formula/hashcat?utm_source=openai))
• Vérification: hashcat -I doit afficher METAL API sur Apple Silicon, puis exécutez hashcat -b pour un test rapide. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=hashcat&utm_source=openai))
• Alternatives si le GPU n’est pas exploitable: utiliser Hashcat en mode CPU, ou privilégier un environnement Linux ou Windows sur une machine dédiée pour le GPU. ([hashcat.net](https://hashcat.net/forum/thread-11705-post-59608.html?utm_source=openai))

Installer Hashcat sur Linux

1. Installez Hashcat depuis votre distribution: par exemple Debian/Ubuntu sudo apt install hashcat, Arch sudo pacman -S hashcat, Fedora sudo dnf install hashcat. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=frequently_asked_questions&utm_source=openai))
2. Installez les drivers adaptés:
   • NVIDIA: pilote propriétaire et CUDA Toolkit. ([docs.nvidia.com](https://docs.nvidia.com/cuda/archive/11.5.2/pdf/CUDA_Installation_Guide_Linux.pdf?utm_source=openai))
   • AMD: ROCm depuis les dépôts AMD, puis ajoutez l’utilisateur aux groupes video et render ou appliquez la règle udev. ([rocm.docs.amd.com](https://rocm.docs.amd.com/en/7.13.0-preview/install/rocm.html?utm_source=openai))
   • Intel GPU: Intel Graphics Compute Runtime (NEO). ([github.com](https://github.com/intel/compute-runtime?utm_source=openai))
3. Vérifiez la détection: hashcat -I, puis un benchmark hashcat -b. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=hashcat&utm_source=openai))

Bon à savoir: après ajout aux groupes video/render, une reconnexion est nécessaire pour que les permissions sur /dev/kfd et /dev/dri s’appliquent. ([wiki.debian.org](https://wiki.debian.org/ROCm?utm_source=openai))

Peut-on compiler depuis la source ?

1. Prérequis: outils de build (cmake, make, build‑essential/Visual Studio Build Tools), Python requis par le build, dépendances listées dans BUILD.md. ([cocalc.com](https://cocalc.com/github/hashcat/hashcat/blob/master/BUILD.md?utm_source=openai))
2. Récupérer le code: git clone https://github.com/hashcat/hashcat.git. ([github.com](https://github.com/hashcat/hashcat?utm_source=openai))
3. Compiler: cd hashcat && make ou suivez les instructions spécifiques à votre OS dans BUILD.md. ([cocalc.com](https://cocalc.com/github/hashcat/hashcat/blob/master/BUILD.md?utm_source=openai))
4. Vérifier: ./hashcat -I et ./hashcat -b pour s’assurer que les backends et performances sont corrects. ([hashcat.net](https://hashcat.net/wiki/doku.php?id=hashcat&utm_source=openai))

Intégrité des releases: si vous téléchargez une archive, comparez sa somme SHA‑256 à celle publiée par la source officielle. Exemples d’outils intégrés: sha256sum sous Linux, shasum -a 256 sous macOS, certutil -hashfile fichier.zip SHA256 sous Windows. ([niccs.cisa.gov](https://niccs.cisa.gov/sites/default/files/documents/pdf/dhs_pushbuttonpd_gen4_beta21_checksum_verification_20170810.pdf?trackDocs=dhs_pushbuttonpd_gen4_beta21_checksum_verification_20170810.pdf&utm_source=openai))

Comment utiliser Hashcat efficacement ?

Pour tirer le meilleur de Hashcat dans un cadre légal et autorisé, structurez votre approche par piliers: maîtriser la syntaxe, préparer correctement les fichiers de hash, choisir la stratégie d’attaque adaptée, optimiser le GPU, mesurer la performance puis gérer les sessions et la reprise.

• Syntaxe et options clés: modes d’attaque, modes de hash, sortie et aide.
• Fichiers et formats: lignes username:hash, sels, potfile, formats spéciaux comme HC22000.
• Stratégies d’attaque: wordlists, masks, rules, hybrides.
• Optimisation GPU: kernels optimisés, workload, pilotes, gestion thermique et puissance.
• Benchmarks et estimations: vitesses en H/s et temps réalistes.
• Sessions et reprise: session, potfile, restore.

Quelle est la syntaxe de base et les commandes essentielles ?

La commande Hashcat suit le schéma général: hashcat [options] hash(es) [dictionnaire|mask]. Commencez toujours par identifier le type de hash et le mode d’attaque, puis définissez un fichier de sortie et consultez l’aide intégrée si besoin.

• -a (attack mode): 0 straight/dictionnaire, 1 combinator, 3 brute-force/mask, 6 hybride dict+mask, 7 hybride mask+dict.
• -m (hash-mode): identifie l’algorithme, par exemple NTLM 1000, bcrypt 3200, WPA/WPA2 PMKID/EAPOL 22000. Utilisez --example-hashes pour valider le format.
• -o (output): enregistre les couples trouvés, par exemple -o found.txt.
• --help: liste toutes les options et exemples utiles.
• --example-hashes: affiche des exemples de lignes valides par mode.

Commande type: hashcat -a 0 -m 1000 hashes.txt wordlists/rockyou.txt -r rules/best64.rule -o found.txt

Comment gérer les fichiers de hash et formats d’entrée ?

Hashcat lit des lignes structurées, une entrée par ligne. Respecter le format demandé par -m évite les erreurs de type « line length exception ». Le potfile enregistre automatiquement les trouvailles pour éviter de retester des couples déjà découverts.

• Formats simples: un hash par ligne, par exemple 5f4dcc3b5aa765d61d8327deb882cf99.
• username:hash: fréquent en environnements Windows et LDAP, par exemple alice:8846f7eaee8fb117ad06bdd830b7586c.
• hash:salt ou variantes spécifiques selon l’algorithme. Hashcat gère aussi --hex-salt si le sel est encodé en hexadécimal.
• WPA2/WPA3: format .hc22000 (PMKID/EAPOL). Travaillez à partir d’un fichier HC22000 prêt à l’emploi, sans détailler ici les étapes de capture.
• Potfile: par défaut hashcat.potfile dans le répertoire courant. Personnalisez avec --potfile-path ou désactivez via --potfile-disable si nécessaire.

Quelles stratégies d’attaque choisir (wordlists, masks, rules, hybrids) ?

Adaptez la stratégie au contexte: commencez par ce qui est le plus probable, élargissez ensuite. Combinez dictionnaires pertinents, règles, masques ciblés et attaques hybrides pour couvrir efficacement l’espace de recherche.

• Wordlists (attaque -a 0): utilisez des listes de référence (par exemple SecLists, rockyou) et des listes contextualisées à l’entreprise (politique de complexité, terminologie interne).
• Rules (-r rules/*.rule): génèrent des variantes réalistes, par exemple best64.rule ou dive.rule pour capitalisations, suffixes numériques et substitutions.
• Masks (attaque -a 3): ciblez des patrons connus. Exemples: ?l?l?l?l?d?d (4 lettres minuscules puis 2 chiffres), ?u?l?l?l?l?l?d?d (1 majuscule, 5 minuscules, 2 chiffres). ?d=chiffre, ?l=minuscule, ?u=majuscule, ?s=symbole, ?a=tous.
• Hybrides: -a 6 (dictionnaire + masque suffixe/préfixe, ex. ajout de ?d?d) et -a 7 (masque + dictionnaire). Idéal quand un schéma partiel est connu.
• Combinatoire (-a 1): concatène deux dictionnaires pour couvrir des constructions de type « mot+année » ou « prénom+terme interne ».

Comment optimiser les performances GPU ?

• Kernels optimisés: -O accélère de nombreux algorithmes, avec des limites de longueur pour certains. Évitez -O si l’algorithme ne le supporte pas bien ou si vos candidats sont très longs.
• Workload: -w ajuste l’intensité: -w 1 (léger), -w 2 (équilibré), -w 3 (agressif), -w 4 (maximal, moins réactif en poste de travail).
• Thermique et sécurité: servez-vous du watchdog intégré et, si besoin, fixez des seuils avec --hwmon-temp-abort=85. Nettoyez les filtres, augmentez la ventilation, surveillez la stabilité.
• Puissance et fréquences: sur NVIDIA, des limites raisonnables via nvidia-smi (power limit, fan) stabilisent le débit H/s. Privilégiez la constance à la pointe de performance.
• Pilotes et runtimes (prérequis courants): NVIDIA (CUDA Toolkit), AMD Linux (ROCm), AMD Windows (Adrenalin + HIP SDK), Intel GPU (NEO), CPU Intel/AMD (OpenCL Runtime ou PoCL). Un écosystème à jour évite des pertes de performance et d’étranges erreurs.
• Multi‑périphériques: sélectionnez ou excluez des devices avec -d et répartissez intelligemment la charge si vous avez plusieurs GPU.

Astuce pratique: testez d’abord sur un échantillon réduit avec --runtime ou une liste restreinte pour valider réglages et stabilité avant d’attaquer le jeu de données complet.

Comment évaluer et comparer les performances (benchmarks) ?

Utilisez --benchmark ou -b pour mesurer les vitesses théoriques par algorithme. En exécution réelle, suivez la ligne de statut (Speed, Recovered, Progress, Time.Estimated) et gardez en tête que les vitesses varient selon la longueur moyenne et la complexité des candidats.

Estimation rapide du temps: temps ≈ taille de l’espace de clés / vitesse (H/s). Par exemple, un masque ?l?l?l?l?d?d représente 26^4 × 10^2 ≈ 45 697 600 combinaisons. À 300 MH/s, comptez environ 0,15 seconde en conditions idéales, mais davantage avec sels, I/O ou règles lourdes.

Comment gérer sessions, potfile et reprise ?

• Sessions: démarrez avec --session nom pour nommer une exécution.
• Reprise: redémarrez proprement une session interrompue avec --restore (et éventuellement --restore-timer).
• Potfile: centralisez avec --potfile-path /chemin/potfile afin d’éviter les doublons entre machines ou dossiers.

Bonne hygiène: conservez un répertoire par campagne avec scripts, wordlists, masks, rules, potfile et logs associés, ce qui facilite l’auditabilité et la reprise.

Exemples concrets par type de hash

1. NTLM (rapide)
   hashcat -a 0 -m 1000 ntlm.txt wordlists/rockyou.txt -r rules/best64.rule -O -w 3 -o found_ntlm.txt
   Idéal pour un premier passage à haut débit avec règles légères.
2. bcrypt (lent, dérivation coûteuse)
   hashcat -a 0 -m 3200 bcrypt.txt wordlists/top100k.txt -w 4 -o found_bcrypt.txt
   Privilégiez des listes ciblées et des règles parcimonieuses. L’option -O n’apporte pas toujours de gain utile ici.
3. WPA2 (HC22000)
   hashcat -a 3 -m 22000 wifi.hc22000 ?u?l?l?l?l?l?d?d -w 3 -o found_wifi.txt
   Travaillez sur un fichier HC22000 prêt à l’emploi. Préférez des masques plausibles ou une attaque hybride dict+mask.

Rappel éthique et légal: testez uniquement des systèmes pour lesquels vous avez une autorisation écrite explicite.

Peut-on utiliser Hashcat en multi‑GPU ou de manière distribuée ?

Oui. Hashcat sait exploiter plusieurs processeurs de calcul dans une même machine (multi‑GPU et même types de périphériques mixtes), et il peut être intégré à une orchestration distribuée pour répartir la charge sur plusieurs hôtes, dans un cadre légal et maîtrisé. Cette approche accélère fortement les audits de mots de passe lors d’un pentest ou d’un audit de sécurité, à condition de préparer l’infrastructure et les dépendances correctement.

Outils et approches possibles

• Multi‑GPU natif dans Hashcat : activation de plusieurs périphériques de calcul dans le même système, y compris des types mélangés selon le runtime disponible (GPU NVIDIA, AMD, Intel, voire CPU). Hashcat gère l’ordonnancement du travail, la pause et reprise, les sessions et la restauration, avec un mécanisme de surveillance thermique intégré.
• Orchestration distribuée : usage d’un gestionnaire pour piloter de nombreux nœuds de calcul, synchroniser dictionnaires et règles, planifier les tâches et agréger les résultats. Exemple côté open source : Hashtopolis, souvent utilisé pour coordonner des agents Hashcat à l’échelle d’un parc.

Précautions essentielles avant de passer en multi‑GPU ou distribué

• Cadre légal et éthique : son utilisation est parfaitement légale, à condition d’avoir l’autorisation explicite du propriétaire du système. Sans ce cadre, l’emploi de l’outil peut être considéré comme une infraction.
• Hygiène des données : ne traiter que des empreintes autorisées, chiffrer les dumps et limiter l’accès aux listes de mots et règles. Journaliser qui lance quoi, où et quand.
• Pilotes et runtimes : installer des dépendances adaptées au matériel et à l’OS pour bénéficier du multi‑GPU et des performances attendues. Exemples courants : NVIDIA CUDA Toolkit, AMD ROCm sous Linux, AMD Adrenalin Edition et HIP SDK sous Windows, Intel Graphics Compute Runtime pour GPU Intel, runtimes OpenCL pour CPU comme l’Intel CPU Runtime ou PoCL.
• Cohérence logicielle : aligner versions de Hashcat, règles, masques et dictionnaires sur tous les nœuds. Éviter les écarts de versions qui cassent la reprise de session ou la restitution des résultats.
• Stabilité et reprise : s’appuyer sur les sessions et la fonction restore de Hashcat, ou sur les points de contrôle fournis par l’orchestration, pour reprendre un calcul après incident sans perdre de travail.
• Surveillance thermique et alimentation : vérifier températures, limites de puissance et espace VRAM, prévoir un refroidissement et une alimentation adaptés. Le watchdog thermique intégré aide, mais un monitoring externe reste recommandé.
• Performance pratique : tester et étalonner. Mélanger des GPU très hétérogènes, ou des nœuds reliés par un réseau lent, peut dégrader le rendement. Mieux vaut des lots de travail calibrés et des benchmarks préalables.
• Sécurité réseau : isoler les workers, chiffrer les communications de contrôle, cloisonner les partages de fichiers et appliquer le principe du moindre privilège sur l’orchestrateur.

Quelles sont les alternatives à Hashcat ?

Hashcat n’est pas le seul outil d’audit de mots de passe. Selon vos objectifs, votre matériel et le cadre légal, d’autres solutions peuvent mieux convenir. Voici un aperçu bref, avec un focus sur John the Ripper, ainsi que des options orientées forensic.

Outil	Licence	Accélération matérielle	Points forts	Limites	Cas d’usage conseillés
John the Ripper (Jumbo)	Open source	CPU, OpenCL sur GPU selon la build	Très flexible, règles et masques puissants, nombreux formats, s’intègre bien dans des scripts et environnements serveurs.	Prise en main plus technique, performances GPU variables selon les algorithmes et le matériel.	Audits sur postes ou serveurs, jobs CPU, scénarios personnalisés et automatisation en pentest.
Passware Kit Forensic	Commercial	CPU et GPU multi‑constructeurs, mode distribué	Interface graphique, workflows forensic, agents distribués, support large d’écosystèmes bureautiques.	Payant, centré sur des formats et environnements spécifiques.	Laboratoires forensic, équipes réponse à incident, délais serrés pour l’analyse de preuves.
Elcomsoft Distributed Password Recovery	Commercial	GPU, orchestration sur cluster et cloud	Très bonne montée en charge, distribution de tâches, formats bureautiques et archives bien couverts.	Payant, ciblé investigation et e‑discovery.	Récupérations à grande échelle, environnements d’enquête légaux, besoin de puissance à la demande.
RainbowCrack	Gratuit	CPU/GPU selon configuration	Attaques par tables arc‑en‑ciel, très rapide sur anciens algorithmes sans sel.	Peu pertinent sur les schémas modernes salés, nécessite des tables volumineuses.	Tests pédagogiques, audits ciblés sur anciens schémas de hachage.

En synthèse : si vous disposez d’un GPU et que vous visez la vitesse brute sur de nombreux formats, Hashcat reste une référence. John the Ripper convient très bien pour des scénarios CPU, des pipelines scriptés et des règles avancées. Pour des besoins d’investigation out‑of‑the‑box, la priorisation d’un outil commercial orienté forensic peut accélérer les opérations. Dans tous les cas, intervenez uniquement avec une autorisation explicite et dans un cadre légal, que ce soit pour un pentest ou un audit de sécurité.

Conclusion

Hashcat est avant tout un outil d’audit de sécurité: il sert à tester la robustesse des mots de passe en travaillant sur leurs empreintes de hachage. Utilisé dans un cadre légal et éthique, il permet de simuler des attaques réalistes (brute force, dictionnaire, masque, hybride, combinée) afin d’identifier des faiblesses et de renforcer les politiques de mots de passe. Son emploi reste légal uniquement avec l’autorisation explicite du propriétaire du système, en dehors de ce cadre il peut constituer une infraction.

• Cadre légal: intervention autorisée et documentée uniquement, sinon usage illégal.
• Objectif: auditer la solidité des mots de passe, soutenir les pentests et la formation technique.
• Modes d’attaque: choisissez le mode adapté à votre scénario (-a brute-force, dictionnaire, masque, hybride, combinatoire).
• Hash modes/IDs: identifiez correctement le type de hash attendu avec l’ID (-m) et validez le format des empreintes avant test.
• Références officielles: détails, exemples et paramètres sont décrits dans la documentation Hashcat, la page Example hashes pour les IDs -m, et sur la page du projet. Utilisez aussi l’aide intégrée (hashcat --help) et le fichier examples.txt fourni.