iphelix/packPACK (Kit d'analyse et de craquage de mots de passe)
PACK (Password Analysis and Cracking Toolkit) est une collection d'utilitaires développés pour faciliter l'analyse de listes de mots de passe afin d'améliorer le cassage de mots de passe via la détection de motifs de masques, de règles, de jeux de caractères et d'autres caractéristiques des mots de passe. La boîte à outils génère des fichiers d'entrée valides pour la famille de craqueurs de mots de passe Hashcat.
REMARQUE : La boîte à outils elle-même n'est pas capable de casser des mots de passe, mais est conçue pour rendre le fonctionnement des craqueurs de mots de passe plus efficace.
Avant de pouvoir utiliser la boîte à outils, nous devons établir un critère de sélection des listes de mots de passe. Puisque nous cherchons à analyser la manière dont les gens créent leurs mots de passe, nous devons obtenir un échantillon aussi large que possible de mots de passe divulgués. Une telle liste excellente est basée sur la compromission de RockYou.com. Cette liste fournit une collection à la fois large et suffisamment diversifiée qui donne de bons résultats pour les mots de passe courants utilisés sur des sites similaires (par exemple, les réseaux sociaux). L'analyse obtenue à partir de cette liste peut ne pas fonctionner pour les organisations ayant des politiques de mots de passe spécifiques. Ainsi, la sélection de l'échantillon d'entrée doit être aussi proche que possible de votre cible. De plus, essayez d'éviter d'obtenir des listes basées sur des mots de passe déjà craqués, car cela générera un biais statistique des règles et des masques utilisés par la ou les personnes craquant la liste et non par les utilisateurs réels.
L'analyse la plus basique que vous puissiez effectuer consiste simplement à obtenir la longueur la plus courante, le jeu de caractères et d'autres caractéristiques des mots de passe dans la liste fournie. Dans l'exemple ci-dessous, nous utiliserons 'rockyou.txt' contenant environ 14 millions de mots de passe. Lancez statsgen.py avec la ligne de commande suivante :
$ python statsgen.py rockyou.txt
Vous trouverez ci-dessous la sortie de la commande ci-dessus :
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analyzing passwords in [rockyou.txt]
[+] Analyzing 100% (14344390/14344390) of passwords
NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords
[*] Length:
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] Character-set:
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] Password complexity:
[+] digit: min(0) max(255)
[+] lower: min(0) max(255)
[+] upper: min(0) max(187)
[+] special: min(0) max(255)
[*] Simple Masks:
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] Advanced Masks:
[+] ?l?l?l?l?l?l?l?l: 04% (687991)
[+] ?l?l?l?l?l?l: 04% (601152)
[+] ?l?l?l?l?l?l?l: 04% (585013)
[+] ?l?l?l?l?l?l?l?l?l: 03% (516830)
[+] ?d?d?d?d?d?d?d: 03% (487429)
...
REMARQUE : Vous pouvez réduire le nombre de valeurs aberrantes affichées en incluant le drapeau --hiderare qui n'affichera aucun élément dont l'occurrence est inférieure à 1 %.
Voici ce que nous pouvons immédiatement apprendre de la liste ci-dessus :
La dernière section, "Advanced Masks", contient les masques les plus fréquents au format Hashcat. Les symboles individuels peuvent être interprétés comme suit :
?l - un seul caractère minuscule
?u - un seul caractère majuscule
?d - un seul chiffre
?s - un seul caractère spécial
Par exemple, le tout premier masque, "?l?l?l?l?l?l?l?l", correspondra à tous les mots de passe alphabétiques minuscules. Compte tenu de la taille de l'échantillon, vous pourrez craquer environ 4 % des mots de passe. Cependant, après avoir généré la sortie initiale, vous souhaiterez peut-être utiliser des filtres pour affiner les données de mots de passe.
Voyons comment les utilisateurs de RockYou ont tendance à sélectionner leurs mots de passe en utilisant le masque simple "stringdigit" (une chaîne suivie de chiffres) :
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] Analyzing passwords in [rockyou.txt]
[+] Analyzing 37% (5339556/14344390) of passwords
NOTE: Statistics below is relative to the number of analyzed passwords, not total number of passwords
[*] Length:
[+] 8: 23% (1267260)
[+] 7: 18% (981432)
[+] 9: 17% (939971)
[+] 10: 14% (750938)
[+] 6: 11% (618983)
[+] 11: 05% (294869)
[+] 12: 03% (175875)
[+] 13: 01% (103047)
[+] 14: 01% (65958)
[*] Character-set:
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] Password complexity:
[+] digit: min(1) max(252)
[+] lower: min(0) max(46)
[+] upper: min(0) max(31)
[+] special: min(0) max(0)
[*] Simple Masks:
[+] stringdigit: 100% (5339556)
[*] Advanced Masks:
[+] ?l?l?l?l?l?l?d?d: 07% (420318)
[+] ?l?l?l?l?l?d?d: 05% (292306)
[+] ?l?l?l?l?l?l?l?d?d: 05% (273624)
[+] ?l?l?l?l?d?d?d?d: 04% (235360)
[+] ?l?l?l?l?d?d: 04% (215074)
...
Le tout début de la sortie spécifie le pourcentage du total des mots de passe analysé. Dans ce cas, en ne craquant que les mots de passe correspondant au masque "stringdigit", il n'est possible de récupérer qu'environ 37 % de l'ensemble total, comme cela était affiché dans la sortie originale. Ensuite, il semble que seulement 11 % de ce type de mot de passe utilisent autre chose que des minuscules. Il serait donc judicieux de se concentrer uniquement sur les chaînes en minuscules correspondant à ce masque. Enfin, dans la section "Advanced Masks", nous pouvons voir que la majorité des mots de passe "stringdigit" sont constitués d'une chaîne avec deux ou quatre chiffres la suivant. Grâce aux informations obtenues à partir de la sortie ci-dessus, nous pouvons commencer à créer une image mentale des schémas de génération de mots de passe des utilisateurs cibles.
Il existe quelques autres filtres disponibles pour la longueur, le masque et les jeux de caractères :
Longueur : --minlength et/ou --maxlength
Masque simple : --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum, etc.]
Jeux de caractères : --charset [digit, string, stringdigit, digitstring, digitstringdigit, etc.]
REMARQUE : Plusieurs filtres de la même classe peuvent être spécifiés sous forme de liste séparée par des virgules :
--simplemask="stringdigit,digitstring"
Bien que la section "Advanced Masks" n'affiche que les motifs correspondant à plus de 1 % de tous les mots de passe, vous pouvez obtenir et sauvegarder une liste complète des masques de mots de passe correspondant à un dictionnaire donné en utilisant la commande suivante :
$ python statsgen.py rockyou.txt -o rockyou.masks
Tous les masques de mots de passe et leurs fréquences seront sauvegardés dans le fichier spécifié au format CSV. Naturellement, vous pouvez fournir des filtres pour ne générer que des fichiers de masques correspondant aux paramètres spécifiés. Le fichier de sortie peut être utilisé comme entrée pour l'outil MaskGen couvert dans la section suivante.
MaskGen vous permet de concevoir des attaques par masque basées sur des motifs pour alimenter la famille de craqueurs de mots de passe Hashcat. L'outil utilise la sortie produite par statsgen ci-dessus avec le drapeau -o afin de produire l'attaque par masque la plus optimale, triée par complexité de masque, occurrence de masque ou rapport des deux (indice optimal).
Lançons MaskGen avec uniquement la sortie de StatsGen comme argument :
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[*] Finished generating masks:
Masks generated: 146578
Masks coverage: 100% (14344390/14344390)
Masks runtime: >1 year
Plusieurs informations sont à noter :
--optindex.Comme vous êtes généralement limité en temps pour effectuer et concevoir des attaques, maskgen vous permet de spécifier le temps dont vous disposez pour effectuer des attaques par masque et générera la collection de masques la plus optimale en fonction du mode de tri. Jouons un peu avec différents modes de tri et temps cibles :
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 779
Masks coverage: 56% (8116195/14344390)
Masks runtime: 0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [complexity].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 5163
Masks coverage: 31% (4572346/14344390)
Masks runtime: 0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [occurrence].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 4
Masks coverage: 16% (2390986/14344390)
Masks runtime: 1:34:05
Toutes les exécutions ci-dessus ont un temps cible de 600 secondes (soit 10 minutes) avec différents modes de tri. D'après nos expériences, les masques générés en mode de tri OptIndex peuvent craquer 56 % des mots de passe RockYou en environ 10 minutes. En même temps, les masques générés en mode de tri Occurrence ont non seulement une couverture assez faible de seulement 16 %, mais ont également dépassé le temps cible spécifié de plus d'une heure.
REMARQUE : Les masques triés par complexité peuvent être très efficaces lors de l'attaque de listes basées sur des politiques.
Voyons certains des masques générés par maskgen en mode optindex à l'aide du drapeau --showmasks :
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[L:] Mask: [ Occ: ] [ Time: ]
...
[ 7] ?l?d?s?l?l?d?d [6 ] [ 0:00:00]
[ 8] ?s?l?l?l?l?l?l?s [3480 ] [ 0:05:36]
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
[ 8] ?d?l?d?d?d?l?l?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?l?d?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?l?d?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?l?d?d?l?l [47 ] [ 0:00:04]
[ 8] ?d?d?l?l?d?l?d?l [47 ] [ 0:00:04]
[ 8] ?d?l?d?d?l?l?l?l [122 ] [ 0:00:11]
[ 8] ?u?u?d?u?d?d?d?d [18 ] [ 0:00:01]
[ 6] ?d?s?s?s?s?s [4 ] [ 0:00:00]
[10] ?l?l?l?l?l?l?l?l?d?d [213109 ] [ 5:48:02]
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 3970
Masks coverage: 74% (10620959/14344390)
Masks runtime: 16:10:38
Les masques affichés suivent un format assez intuitif :
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ masque généré \ _ temps d'exécution du masque
\
_ longueur du masque _ occurrence du masque
Dans l'exemple ci-dessus, vous pouvez voir une partie de la logique qui entre dans la génération de masques. Par exemple, alors que le masque '?s?l?l?l?l?l?l?s' a l'un des temps d'exécution les plus longs de l'échantillon (5 minutes), il a toujours une priorité plus élevée en raison de son occurrence relativement plus élevée que '?l?l?l?l?d?d?d?d?s'. En même temps, bien que '?l?d?s?l?l?d?d' ait une couverture assez faible, il reçoit toujours une priorité plus élevée que d'autres masques car, en tant que masque de seulement six caractères, il s'exécute très rapidement.
Vous pouvez optimiser davantage vos attaques par masque générées en utilisant des filtres. Par exemple, vous pouvez avoir un matériel suffisamment puissant pour simplement bruteforcer tous les mots de passe jusqu'à 8 caractères. Dans ce cas, vous pouvez générer des masques uniquement pour ceux de plus de 8 caractères en utilisant le drapeau --minlength comme suit :
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] Analyzing masks in [rockyou.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 585
Masks coverage: 41% (5905182/14344390)
Masks runtime: 15:50:36
Naturellement, la couverture des masques générés a été réduite, mais ces filtres deviennent utiles lors de la préparation d'une collection de masques pour attaquer des listes de mots de passe autres que celle utilisée pour les générer.
La liste ci-dessous présente des filtres supplémentaires que vous pouvez utiliser :
Options de filtre de masque individuel :
--minlength=8 Longueur minimale du mot de passe
--maxlength=8 Longueur maximale du mot de passe
--mintime=3600 Temps d'exécution minimal du masque (secondes)
--maxtime=3600 Temps d'exécution maximal du masque (secondes)
--mincomplexity=1 Complexité minimale
--maxcomplexity=100
Complexité maximale
--minoccurrence=1 Occurrence minimale
--maxoccurrence=100
Occurrence maximale
Les drapeaux d'occurrence et de complexité peuvent être particulièrement puissants pour affiner les masques générés en utilisant différents modes de tri.
Une fois que vous êtes satisfait des masques générés ci-dessus, vous pouvez les sauvegarder à l'aide du drapeau -o :
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] Analyzing masks in [rockyou.masks]
[*] Saving generated masks to [rockyou.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 3970
Masks coverage: 74% (10620959/14344390)
Masks runtime: 16:10:38
Cela produira un fichier 'rockyou.hcmask' qui peut être utilisé directement par la suite d'outils Hashcat ou dans le cadre d'un script personnalisé qui les parcourt.
Il est souvent utile de voir comment les masques générés se comportent par rapport à des listes déjà craquées. Maskgen peut comparer une collection de masques à d'autres pour voir comment ils se comporteraient si les masques d'une liste de mots de passe étaient essayés sur une autre. Comparons comment les masques générés à partir de la liste RockYou se comportent par rapport à une autre liste compromise telle que Gawker :
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] Analyzing masks in [gawker.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Checking coverage of masks in [rockyou.hcmask]
[*] Finished matching masks:
Masks matched: 1775
Masks coverage: 96% (1048889/1084394)
Masks runtime: 16:25:44
En utilisant le paramètre --checkmasksfile, nous avons tenté d'exécuter les masques contenus dans le fichier 'rockyou.hcmask' généré précédemment contre les masques d'un échantillon de liste divulguée 'gawker.masks'. Cela donne une bonne couverture de 96 %, où 1775 des 3970 masques générés au total basés sur RockYou correspondent aux masques de la liste Gawker.
Il est également possible de voir la couverture d'un ou plusieurs masques en les spécifiant directement sur la ligne de commande comme suit :
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] Analyzing masks in [gawker.masks]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Checking coverage of the these masks [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] Finished matching masks:
Masks matched: 2
Masks coverage: 1% (18144/1084394)
Masks runtime: 0:00:04
Les deux masques spécifiés correspondent avec seulement 1 % de couverture.
En fonction de vos spécifications matérielles exactes et du hash cible, vous souhaiterez peut-être augmenter ou diminuer la vitesse en clés/seconde utilisée lors des calculs à l'aide du paramètre --pps :
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] Analyzing masks in [rockyou.masks]
[*] Using 50,000,000 keys/sec for calculations.
[*] Sorting masks by their [optindex].
[!] Target time exceeded.
[*] Finished generating masks:
Masks generated: 1192
Masks coverage: 61% (8754548/14344390)
Masks runtime: 12:17:31
Utiliser le paramètre --pps pour correspondre à vos performances réelles rend le temps cible plus significatif.
Beaucoup d'attaques par masque et par dictionnaire échoueront dans l'environnement d'entreprise avec des exigences minimales de complexité de mot de passe. Au lieu de recourir à une attaque par force brute pure, nous pouvons tirer parti de règles de complexité de mot de passe connues ou supposées pour éviter d'essayer des candidats de mots de passe qui ne sont pas conformes à la politique, ou inversement, auditer uniquement les mots de passe non conformes. En utilisant PolicyGen, vous serez en mesure de générer une collection de masques suivant la complexité du mot de passe afin de réduire considérablement le temps de craquage.
Vous trouverez ci-dessous un exemple de session où nous générons tous les masques de mots de passe valides pour un environnement exigeant au moins un chiffre, une majuscule et un caractère spécial.
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o complexity.hcmask
_
PolicyGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected][*] Saving generated masks to [complexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 40824 Time: 35 days, 0:33:09
D'après la sortie ci-dessus, on voit que nous avons généré 40824 masques correspondant à la complexité spécifiée, ce qui prendra environ 35 jours à la vitesse de 1 000 000 000 clés/seconde.
Si vous effectuez simplement un audit de mots de passe et devez découvrir uniquement les mots de passe non conformes, vous pouvez spécifier l'option '--noncompliant' pour inverser les masques générés :
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
Voyons quelques-uns des masques non conformes générés ci-dessus en utilisant l'option '--showmasks' :
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --minspecial 1 -o noncompliant.hcmask -q --noncompliant --showmasks
[*] Saving generated masks to [noncompliant.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:1
Max strength: l:None u:None d:None s:None
[*] Generating [non-compliant] masks.
[*] Generating 8 character password masks.
[ 8] ?d?d?d?d?d?d?d?d [l: 0 u: 0 d: 8 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?l [l: 1 u: 0 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?u [l: 0 u: 1 d: 7 s: 0] [ 0:00:00]
[ 8] ?d?d?d?d?d?d?d?s [l: 0 u: 0 d: 7 s: 1] [ 0:00:00]
...
[ 8] ?s?s?s?s?s?s?s?d [l: 0 u: 0 d: 1 s: 7] [ 0:07:06]
[ 8] ?s?s?s?s?s?s?s?l [l: 1 u: 0 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?u [l: 0 u: 1 d: 0 s: 7] [ 0:18:28]
[ 8] ?s?s?s?s?s?s?s?s [l: 0 u: 0 d: 0 s: 8] [ 0:23:26]
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 24712 Time: 41 days, 18:16:55
Comme vous pouvez le constater, tous les masques ont au moins une exigence de complexité manquante. Fait intéressant, avec moins de masques générés, l'attaque prend plus de temps à cause de masques longs comme '?s?s?s?s?s?s?s?s'.
Il est également possible de spécifier la complexité maximale du mot de passe à l'aide des options --maxlower, --maxupper, --maxdigit et --maxspecial afin d'affiner votre attaque. Par exemple, ci-dessous un site exemple qui applique une politique de mot de passe mais n'autorise aucun caractère spécial :
$ python policygen.py --minlength 8 --maxlength 8 --minlower 1 --minupper 1 --mindigit 1 --maxspecial 0 -o maxcomplexity.hcmask -q
[*] Saving generated masks to [maxcomplexity.hcmask]
[*] Using 1,000,000,000 keys/sec for calculations.
[*] Password policy:
Pass Lengths: min:8 max:8
Min strength: l:1 u:1 d:1 s:None
Max strength: l:None u:None d:None s:0
[*] Generating [compliant] masks.
[*] Generating 8 character password masks.
[*] Total Masks: 65536 Time: 76 days, 18:50:04
[*] Policy Masks: 5796 Time: 1 day, 20:20:55
rulegen.py implémente l'analyse des mots de passe et la génération de règles pour le craqueur de mots de passe Hashcat, comme décrit dans l'article Analyse et génération automatiques de règles de mots de passe. Veuillez consulter ce document pour une discussion détaillée sur la théorie de l'analyse et de la génération de règles.
L'inversion des mots sources et des règles de transformation de mots à partir de mots de passe déjà craqués peut être très efficace pour mener des attaques contre des hachages encore cryptés. En recyclant/étendant continuellement les règles et les mots générés, vous pouvez parvenir à craquer un plus grand nombre de mots de passe.
Il y a plusieurs prérequis pour une utilisation efficace de rulegen.py. L'outil utilise la bibliothèque de vérification orthographique Enchant pour s'interfacer avec plusieurs moteurs de vérification tels qu'Aspell, MySpell, etc. Vous devez installer ces outils avant utilisation. Il est également essentiel d'installer les dictionnaires pour le moteur de vérification que vous allez utiliser (sinon, il est possible d'utiliser une liste de mots personnalisée). Enfin, j'ai inclus PyEnchant pour plus de commodité, qui devrait s'interfacer directement avec les bibliothèques partagées d'Enchant ; cependant, en cas de problèmes, supprimez simplement le répertoire 'enchant' inclus et installez PyEnchant pour votre distribution.
Pour plus de détails sur la syntaxe spécifique des règles Hashcat, consultez Hashcat Rule Based Attack.
L'utilisation la plus basique de rulegen.py consiste à analyser un seul mot de passe pour détecter automatiquement les règles. Détectons les règles et le mot source potentiel utilisé pour générer un exemple de mot de passe P@55w0rd123 :
$ python rulegen.py --verbose --password P@55w0rd123
_
RuleGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: P@55w0rd123
[-] Pas sword => {edit distance suboptimal: 8 (7)} => P@55w0rd123
[+] Password => sa@ ss5 so0 $1 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 o81 $2 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 o92 $3 => P@55w0rd123
[+] Passwords => sa@ ss5 so0 i81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 o92 $3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 o81 i92 oA3 => P@55w0rd123
[+] Password's => sa@ ss5 so0 i81 o92 oA3 => P@55w0rd123
Plusieurs options ont été utilisées dans cet exemple :
Le traitement des fichiers de mots de passe est couvert dans la section suivante ; cependant, discutons d'abord de quelques options de réglage fin disponibles en utilisant un seul mot de passe comme exemple.
Remarquez que nous utilisons le module Enchant aspell pour la détection du mot source. Le moteur de vérification exact peut être changé à l'aide de l'option --provider comme suit :
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Using Enchant 'myspell' module. For best results please install
'myspell' module language dictionaries.
...
REMARQUE : La priorité du moteur fournisseur peut être spécifiée à l'aide d'une liste séparée par des virgules (par exemple --provider aspell,myspell).
L'utilisation du moteur de détection de mot source peut être complètement désactivée en spécifiant un mot source avec l'option --word :
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] Analyzing password: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
En spécifiant différents mots sources, vous pouvez vous amuser à expérimenter avec le moteur de génération de règles.
Inévitablement, vous arriverez à un point où la génération de règles à l'aide de la liste de mots standard du moteur de vérification ne sera plus suffisante. Vous pouvez spécifier une liste de mots personnalisée avec l'option --wordlist. Ceci est particulièrement utile lors de la réutilisation de mots sources d'une session d'analyse précédente :
$ python rulegen.py -q --verbose --wordlist rockyou.txt --password 1pa55w0rd1
[*] Using Enchant 'Personal Wordlist' module. For best results please install
'Personal Wordlist' module language dictionaries.
[*] Analyzing password: 1pa55w0rd1
[+] password => ^1 ss5 so0 $1 => 1pa55w0rd1
Une liste de mots personnalisée peut être particulièrement utile lors de l'utilisation de mots peu courants comme l'argot ainsi que de mots de passe déjà craqués.
Bien que rulegen.py tente de générer et d'enregistrer uniquement les meilleurs mots sources et mots de passe, il peut y avoir des cas où vous êtes intéressé par plus de résultats. Utilisez les options --morewords et --morerules pour générer des mots et des règles qui peuvent dépasser la distance d'édition optimale :
$ python rulegen.py -q --verbose --password '$m0n3y$' --morerules --morewords
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[+] money => ^$ so0 se3 $$ => $m0n3y$
[+] moneys => ^$ so0 se3 o6$ => $m0n3y$
[+] mingy => ^$ si0 sg3 $$ => $m0n3y$
[+] many => ^$ sa0 i43 $$ => $m0n3y$
[+] Mooney => sM$ o1m so0 se3 $$ => $m0n3y$
Il est possible d'étendre davantage les mots générés en utilisant les options --maxworddist et --maxwords. De même, vous pouvez produire plus de règles en utilisant les options --maxrulelen et --maxrules.
rulegen.py inclut plusieurs moteurs avancés pour générer des mots et des règles de meilleure qualité. Il est possible de les désactiver pour observer la différence (ou s'ils causent des problèmes) en utilisant les options --simplewords et --simplerules. Observons comment les mots sources et les règles changent avec ces options activées :
$ python rulegen.py -q --verbose --password '$m0n3y$' --simplewords --simplerules
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing password: $m0n3y$
[-] Meany => {edit distance suboptimal: 5 (4)} => $m0n3y$
[+] many => i0$ o20 i43 i6$ => $m0n3y$
[+] mingy => i0$ o20 o43 i6$ => $m0n3y$
[+] money => i0$ o20 o43 i6$ => $m0n3y$
[+] mangy => i0$ o20 o43 i6$ => $m0n3y$
[+] manky => i0$ o20 o43 i6$ => $m0n3y$
Remarquez que la qualité des mots et des règles générés a été considérablement réduite, avec des mots comme 'manky' ayant moins de relation avec le mot source réel 'money'. En même temps, les règles générées ont été réduites à de simples insertions, suppressions et remplacements.
Maintenant que vous maîtrisez toutes les différentes options et commutateurs, nous pouvons essayer de générer des mots et des règles pour une collection de mots de passe. Créons un fichier texte korelogic.txt contenant les mots de passe de test assez complexes suivants :
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
Observons maintenant l'analyse de rulegen.py en spécifiant simplement le fichier de mots de passe comme premier argument :
$ python rulegen.py korelogic.txt -q
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to analysis.rule
[*] Saving words to analysis.word
[*] Finished processing 16 passwords in 1.00 seconds at the rate of 15.94 p/sec
[*] Generating statistics for [analysis] rules and words.
[-] Skipped 0 all numeric passwords (0.00%)
[-] Skipped 2 passwords with less than 25% alpha characters (12.50%)
[-] Skipped 0 passwords with non ascii characters (0.00%)
[*] Top 10 rules
[+] ^3 ^1 o4r - 3 (2.00%)
[+] i61 i79 i86 i98 oA1 - 2 (1.00%)
[+] ^- ^0 ^1 i4' o5A - 2 (1.00%)
[+] sS1 i13 T2 - 1 (0.00%)
[+] i61 se9 i86 i98 oA1 - 1 (0.00%)
[+] o61 i79 i86 i98 oA1 - 1 (0.00%)
[+] ^- ^0 ^1 so' i5A - 1 (0.00%)
[+] D3 si0 i55 $e - 1 (0.00%)
[+] i61 i79 se6 i98 oA1 - 1 (0.00%)
[+] i3a o5y o6a i7% o8] - 1 (0.00%)
[*] Top 10 words
[+] Analyze - 1 (0.00%)
[+] defcon - 1 (0.00%)
[+] Kristen - 1 (0.00%)
[+] Bailey - 1 (0.00%)
[+] Augusts - 1 (0.00%)
[+] Annelid - 1 (0.00%)
[+] Hack's - 1 (0.00%)
[+] antlers - 1 (0.00%)
[+] antelope - 1 (0.00%)
[+] xxxv - 1 (0.00%)
En utilisant tous les paramètres par défaut, nous avons pu produire plusieurs règles de haute qualité. L'application affiche quelques statistiques de base sur les 10 meilleures règles et mots. Toutes les règles et mots générés sont sauvegardés en utilisant le nom de base 'analysis' par défaut :
Remarquez que plusieurs mots de passe comme '#(4)\ et '&a123456 ont été ignorés parce qu'ils ne possèdent pas les caractéristiques suffisantes pour être traités. Outre le nombre de caractères alphabétiques, le programme ignorera tous les mots de passe numériques et ceux contenant des caractères non ASCII. Ce dernier problème est dû à un bogue dans le moteur Enchant que j'espère corriger à l'avenir pour permettre le traitement de mots dans de nombreuses langues.
Comme mentionné précédemment, rulegen.py sauvegarde les fichiers de sortie en utilisant le nom de base 'analysis' par défaut. Vous pouvez changer le nom de base avec l'option --basename ou -b comme suit :
$ python rulegen.py korelogic.txt -q -b korelogic
[*] Using Enchant 'aspell' module. For best results please install
'aspell' module language dictionaries.
[*] Analyzing passwords file: korelogic.txt:
[*] Press Ctrl-C to end execution and generate statistical analysis.
[*] Saving rules to korelogic.rule
[*] Saving words to korelogic.word
Il peut y avoir des situations où vous rencontrez des problèmes pour générer des règles pour le craqueur de mots de passe Hashcat. rulegen.py inclut l'option --hashcat pour valider les mots et règles générés en utilisant hashcat lui-même en mode --stdout. Pour que ce mode fonctionne correctement, vous devez télécharger la dernière version de hashcat-cli et modifier la variable HASHCAT_PATH dans le code source. Par exemple, au moment de la rédaction, j'ai placé le dossier hashcat-0.## dans le répertoire PACK et défini HASHCAT_PATH comme 'hashcat-0.##/'.
Vous pouvez également observer le fonctionnement interne du moteur de génération de règles avec l'option --debug. Ne vous inquiétez pas des messages d'échec de certaines règles ; c'est le résultat du solveur du problème de l'arrêt (halting problem) qui tente de trouver une solution optimale et valide.
Bien que ce guide présente un certain nombre de méthodes pour analyser les mots de passe, inverser les règles et générer des masques, il existe de nombreuses autres astuces qui vous attendent. Je serais ravi que vous me fassiez part d'utilisations inhabituelles ou de suggestions concernant l'un des outils couverts.
Bon craquage !
-Peter