iphelix/packPACK (Passwortanalyse- und Knack-Kit)
PACK (Password Analysis and Cracking Toolkit) ist eine Sammlung von Dienstprogrammen, die entwickelt wurden, um die Analyse von Passwortlisten zu unterstützen, um das Knacken von Passwörtern durch Mustererkennung von Masken, Regeln, Zeichensätzen und anderen Passworteigenschaften zu verbessern. Das Toolkit erzeugt gültige Eingabedateien für die Hashcat-Familie von Passwort-Knackprogrammen.
HINWEIS: Das Toolkit selbst ist nicht in der Lage, Passwörter zu knacken, sondern wurde entwickelt, um den Betrieb von Passwort-Knackprogrammen effizienter zu gestalten.
Bevor wir das Toolkit verwenden können, müssen wir ein Auswahlkriterium für Passwortlisten festlegen. Da wir analysieren möchten, wie Menschen ihre Passwörter erstellen, müssen wir eine möglichst große Stichprobe von durchgesickerten Passwörtern erhalten. Eine solche hervorragende Liste basiert auf dem RockYou.com-Kompromiss. Diese Liste bietet sowohl eine große als auch vielfältige Sammlung, die gute Ergebnisse für häufig verwendete Passwörter auf ähnlichen Websites (z. B. soziale Netzwerke) liefert. Die aus dieser Liste gewonnene Analyse funktioniert möglicherweise nicht für Organisationen mit spezifischen Passwortrichtlinien. Daher sollte die ausgewählte Stichprobeneingabe Ihrem Ziel so nahe wie möglich kommen. Versuchen Sie außerdem, Listen zu vermeiden, die auf bereits geknackten Passwörtern basieren, da dies eine Verzerrung der Statistiken zu den Regeln und Masken verursacht, die von der/dem Einzelperson(en) verwendet wurden, die die Liste geknackt hat, und nicht von den tatsächlichen Benutzern.
Die grundlegendste Analyse, die Sie durchführen können, besteht darin, einfach die häufigste Länge, den Zeichensatz und andere Eigenschaften von Passwörtern in der bereitgestellten Liste zu ermitteln. Im folgenden Beispiel verwenden wir die Datei 'rockyou.txt', die etwa 14 Millionen Passwörter enthält. Starten Sie statsgen.py mit der folgenden Befehlszeile:
$ python statsgen.py rockyou.txt
Unten ist die Ausgabe des obigen Befehls:
_
StatsGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analysiere Passwörter in [rockyou.txt]
[+] Analysiere 100% (14344390/14344390) der Passwörter
HINWEIS: Die folgenden Statistiken beziehen sich auf die Anzahl der analysierten Passwörter, nicht auf die Gesamtzahl der Passwörter
[*] Länge:
[+] 8: 20% (2966037)
[+] 7: 17% (2506271)
[+] 9: 15% (2191039)
[+] 10: 14% (2013695)
[+] 6: 13% (1947798)
...
[*] Zeichensatz:
[+] loweralphanum: 42% (6074867)
[+] loweralpha: 25% (3726129)
[+] numeric: 16% (2346744)
[+] loweralphaspecialnum: 02% (426353)
[+] upperalphanum: 02% (407431)
...
[*] Passwortkomplexität:
[+] digit: min(0) max(255)
[+] lower: min(0) max(255)
[+] upper: min(0) max(187)
[+] special: min(0) max(255)
[*] Einfache Masken:
[+] stringdigit: 37% (5339556)
[+] string: 28% (4115314)
[+] digit: 16% (2346744)
[+] digitstring: 04% (663951)
[+] othermask: 04% (576324)
...
[*] Erweiterte Masken:
[+] ?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)
...
HINWEIS: Sie können die Anzahl der angezeigten Ausreißer reduzieren, indem Sie das Flag --hiderare verwenden, das Elemente mit einer Häufigkeit von weniger als 1% nicht anzeigt.
Hier ist, was wir sofort aus der obigen Liste lernen können:
Der letzte Abschnitt, "Erweiterte Masken", enthält die am häufigsten vorkommenden Masken im Hashcat-Format. Einzelne Symbole können wie folgt interpretiert werden:
?l - ein einzelnes Kleinbuchstabe
?u - ein einzelner Großbuchstabe
?d - eine einzelne Ziffer
?s - ein einzelnes Sonderzeichen
Beispielsweise passt die allererste Maske "?l?l?l?l?l?l?l?l" auf alle aus Kleinbuchstaben bestehenden Passwörter. Angesichts der Stichprobengröße können Sie etwa 4% der Passwörter knacken. Nach der ersten Ausgabe möchten Sie jedoch möglicherweise Filter verwenden, um die Passwortdaten einzugrenzen.
Lassen Sie uns sehen, wie RockYou-Benutzer ihre Passwörter tendenziell mit der einfachen Maske "stringdigit" (eine Zeichenfolge gefolgt von Zahlen) auswählen:
$ python statsgen.py ../PACK-0.0.3/archive/rockyou.txt --simplemask stringdigit -q --hiderare
[*] Analysiere Passwörter in [rockyou.txt]
[+] Analysiere 37% (5339556/14344390) der Passwörter
HINWEIS: Die folgenden Statistiken beziehen sich auf die Anzahl der analysierten Passwörter, nicht auf die Gesamtzahl der Passwörter
[*] Länge:
[+] 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)
[*] Zeichensatz:
[+] loweralphanum: 88% (4720184)
[+] upperalphanum: 06% (325941)
[+] mixedalphanum: 05% (293431)
[*] Passwortkomplexität:
[+] digit: min(1) max(252)
[+] lower: min(0) max(46)
[+] upper: min(0) max(31)
[+] special: min(0) max(0)
[*] Einfache Masken:
[+] stringdigit: 100% (5339556)
[*] Erweiterte Masken:
[+] ?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)
...
Ganz oben in der Ausgabe wird angegeben, welcher Prozentsatz der Gesamtpasswörter analysiert wurde. In diesem Fall können durch das Knacken nur der Passwörter, die der Maske "stringdigit" entsprechen, nur etwa 37% des Gesamtsatzes wiederhergestellt werden, wie bereits in der ursprünglichen Ausgabe angezeigt. Als nächstes scheint es, dass nur 11% dieses Passworttyps etwas anderes als Kleinbuchstaben verwenden. Es wäre also klug, sich nur auf Kleinbuchstaben zu konzentrieren, die dieser Maske entsprechen. Schließlich sehen wir im Abschnitt "Erweiterte Masken", dass die Mehrheit der "stringdigit"-Passwörter aus einer Zeichenfolge mit zwei oder vier nachgestellten Ziffern besteht. Mit den aus der obigen Ausgabe gewonnenen Informationen können wir beginnen, ein mentales Bild der Passwortgenerierungsmuster der Zielbenutzer zu erstellen.
Es gibt einige weitere Filter für Passwortlänge, Maske und Zeichensätze:
Länge: --minlength und/oder --maxlength
Einfache Maske: --simplemask [numeric, loweralpha, upperalpha, mixedalpha, loweralphanum, etc.]
Zeichensätze: --charset [digit, string, stringdigit, digitstring, digitstringdigit, etc.]
HINWEIS: Mehr als ein Filter derselben Klasse kann als kommagetrennte Liste angegeben werden:
--simplemask="stringdigit,digitstring"
Während der Abschnitt "Erweiterte Masken" nur Muster anzeigt, die mehr als 1% aller Passwörter ausmachen, können Sie eine vollständige Liste der Passwortmasken, die zu einem bestimmten Wörterbuch passen, mit dem folgenden Befehl abrufen und speichern:
$ python statsgen.py rockyou.txt -o rockyou.masks
Alle Passwortmasken und ihre Häufigkeiten werden im CSV-Format in der angegebenen Datei gespeichert. Natürlich können Sie Filter bereitstellen, um nur eine Maskendatei zu generieren, die bestimmten Parametern entspricht. Die Ausgabedatei kann als Eingabe für das im nächsten Abschnitt behandelte MaskGen-Tool verwendet werden.
MaskGen ermöglicht es Ihnen, musterbasiere Maskenangriffe für die Eingabe in die Hashcat-Familie von Passwort-Knackprogrammen zu erstellen. Das Tool verwendet die von statsgen oben mit dem Flag '-o' erzeugte Ausgabe, um den optimalsten Maskenangriff zu erzeugen, sortiert nach Maskenkomplexität, Maskenvorkommen oder dem Verhältnis der beiden (optimaler Index).
Lassen Sie uns MaskGen nur mit der Ausgabe von StatGen als Argument ausführen:
$ python maskgen.py rockyou.masks
_
MaskGen #.#.# | |
_ __ __ _ ___| | _
| '_ \ / _` |/ __| |/ /
| |_) | (_| | (__| <
| .__/ \__,_|\___|_|\_\
| |
|_| [email protected]
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 146578
Maskenabdeckung: 100% (14344390/14344390)
Laufzeit aller Masken: >1 Jahr
Es gibt mehrere Informationen, die Sie beachten sollten:
Da Sie bei der Durchführung und Erstellung von Angriffen normalerweise zeitlich begrenzt sind, ermöglicht maskgen Ihnen, anzugeben, wie viel Zeit Sie für Maskenangriffe haben, und generiert die optimalste Sammlung von Masken basierend auf dem Sortiermodus. Lassen Sie uns ein wenig mit verschiedenen Sortiermodi und Zielzeiten spielen:
$ python maskgen.py rockyou.masks --targettime 600 --optindex -q
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 779
Maskenabdeckung: 56% (8116195/14344390)
Laufzeit aller Masken: 0:11:36
$ python maskgen.py rockyou.masks --targettime 600 --complexity -q
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrer [complexity].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 5163
Maskenabdeckung: 31% (4572346/14344390)
Laufzeit aller Masken: 0:10:01
$ python maskgen.py rockyou.masks --targettime 600 --occurrence -q
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [occurrence].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 4
Maskenabdeckung: 16% (2390986/14344390)
Laufzeit aller Masken: 1:34:05
Alle obigen Durchläufe haben eine Zielzeit von 600 Sekunden (oder 10 Minuten) mit verschiedenen Sortiermodi. Basierend auf unseren Experimenten können mit Masken, die mit dem OptIndex-Sortiermodus generiert wurden, etwa 56% der RockYou-Passwörter in etwa 10 Minuten geknackt werden. Gleichzeitig haben Masken, die mit dem Occurrence-Sortiermodus generiert wurden, nicht nur eine recht schwache Abdeckung von nur 16%, sondern auch die angegebene Zielzeit um mehr als eine Stunde überschritten.
HINWEIS: Nach Komplexität sortierte Masken können bei Angriffen auf richtlinienbasierte Listen sehr effektiv sein.
Lassen Sie uns einige der von maskgen im optindex-Modus generierten Masken mit dem Flag --showmasks ansehen:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --showmasks
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[L:] Maske: [ Vor.:] [ Zeit:]
...
[ 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]
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 3970
Maskenabdeckung: 74% (10620959/14344390)
Laufzeit aller Masken: 16:10:38
Die angezeigten Masken folgen einem recht intuitiven Format:
[ 9] ?l?l?l?l?d?d?d?d?s [1553 ] [ 0:02:30]
\ \ \
\ _ generierte Maske \ _ Laufzeit der Maske
\
_ Maskenlänge _ Maskenvorkommen
Im obigen Beispiel können Sie etwas von der Logik sehen, die in die Maskengenerierung einfließt. Während die Maske '?s?l?l?l?l?l?l?s' eine der längsten Laufzeiten im Beispiel hat (5 Minuten), hat sie dennoch eine höhere Priorität aufgrund ihres relativ höheren Vorkommens im Vergleich zu '?l?l?l?l?d?d?d?d?s'. Gleichzeitig hat '?l?d?s?l?l?d?d' eine recht geringe Abdeckung, erhält aber dennoch eine höhere Priorität als andere Masken, da sie als nur sechs Zeichen lange Maske sehr schnell ausgeführt wird.
Sie können Ihre generierten Maskenangriffe weiter optimieren, indem Sie Filter verwenden. Beispielsweise verfügen Sie möglicherweise über ausreichend leistungsstarke Hardware, um alle Passwörter bis zu 8 Zeichen einfach bruteforcen zu können. In diesem Fall können Sie nur Masken größer als 8 Zeichen mit dem Flag --minlength wie folgt generieren:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q --minlength 8
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 585
Maskenabdeckung: 41% (5905182/14344390)
Laufzeit aller Masken: 15:50:36
Natürlich wurde die Abdeckung der generierten Masken reduziert, aber diese Filter werden nützlich, wenn Sie eine Sammlung von Masken für Angriffe auf andere Passwortlisten als die zur Generierung verwendete vorbereiten.
Die folgende Liste zeigt zusätzliche Filter, die Sie verwenden können:
Optionen für einzelne Maskenfilter:
--minlength=8 Minimale Passwortlänge
--maxlength=8 Maximale Passwortlänge
--mintime=3600 Minimale Maskenlaufzeit (Sekunden)
--maxtime=3600 Maximale Maskenlaufzeit (Sekunden)
--mincomplexity=1 Minimale Komplexität
--maxcomplexity=100
Maximale Komplexität
--minoccurrence=1 Mindestvorkommen
--maxoccurrence=100
Maximales Vorkommen
Die Flags für Vorkommen und Komplexität können besonders leistungsstark sein, um generierte Masken mit verschiedenen Sortiermodi feinabzustimmen.
Sobald Sie mit den oben generierten Masken zufrieden sind, können Sie sie mit dem Flag -o speichern:
$ python maskgen.py rockyou.masks --targettime 43200 --optindex -q -o rockyou.hcmask
[*] Analysiere Masken in [rockyou.masks]
[*] Speichere generierte Masken in [rockyou.hcmask]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 3970
Maskenabdeckung: 74% (10620959/14344390)
Laufzeit aller Masken: 16:10:38
Dies erzeugt die Datei 'rockyou.hcmask', die direkt von der Hashcat-Suite von Tools oder als Teil eines benutzerdefinierten Skripts verwendet werden kann, das sie durchläuft.
Es ist oft nützlich zu sehen, wie gut generierte Masken gegen bereits geknackte Listen performen. Maskgen kann eine Sammlung von Masken mit anderen vergleichen, um zu sehen, wie gut sie abschneiden würden, wenn Masken von einer Passwortliste gegen eine andere versucht würden. Lassen Sie uns vergleichen, wie gut Masken, die aus der RockYou-Liste generiert wurden, gegen eine andere kompromittierte Liste wie Gawker abschneiden:
$ python statsgen.py ../PACK-0.0.3/archive/gawker.dic -o gawker.masks
$ python maskgen.py gawker.masks --checkmasksfile rockyou.hcmask -q
[*] Analysiere Masken in [gawker.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Überprüfe Abdeckung der Masken in [rockyou.hcmask]
[*] Maskenabgleich abgeschlossen:
Übereinstimmende Masken: 1775
Maskenabdeckung: 96% (1048889/1084394)
Laufzeit aller Masken: 16:25:44
Mit dem Parameter '--checkmasksfile' haben wir versucht, die Masken in der zuvor generierten Datei 'rockyou.hcmask' gegen Masken aus einer beispielhaften durchgesickerten Liste 'gawker.masks' auszuführen. Dies ergibt eine gute Abdeckung von 96%, wobei 1775 der insgesamt 3970 generierten RockYou-basierten Masken mit Masken in der Gawker-Liste übereinstimmen.
Es ist auch möglich, die Abdeckung einer oder mehrerer Masken zu sehen, indem sie direkt auf der Befehlszeile wie folgt angegeben werden:
$ python maskgen.py gawker.masks --checkmasks="?u?l?l?l?l?l?d,?l?l?l?l?l?d?d" -q
[*] Analysiere Masken in [gawker.masks]
[*] Verwende 1.000.000.000 Keys/sec für Berechnungen.
[*] Überprüfe Abdeckung dieser Masken [?u?l?l?l?l?l?d, ?l?l?l?l?l?d?d]
[*] Maskenabgleich abgeschlossen:
Übereinstimmende Masken: 2
Maskenabdeckung: 1% (18144/1084394)
Laufzeit aller Masken: 0:00:04
Beide angegebenen Masken stimmten mit nur 1% Abdeckung überein.
Abhängig von Ihrer genauen Hardware-Spezifikation und dem Ziel-Hash möchten Sie möglicherweise die Keys/sec-Geschwindigkeit, die bei Berechnungen verwendet wird, mit dem Parameter '--pps' erhöhen oder verringern:
$ python maskgen.py rockyou.masks --targettime 43200 --pps 50000000 -q
[*] Analysiere Masken in [rockyou.masks]
[*] Verwende 50.000.000 Keys/sec für Berechnungen.
[*] Sortiere Masken nach ihrem [optindex].
[!] Zielzeit überschritten.
[*] Maskengenerierung abgeschlossen:
Generierte Masken: 1192
Maskenabdeckung: 61% (8754548/14344390)
Laufzeit aller Masken: 12:17:31
Die Verwendung des Parameters '--pps' zur Anpassung an Ihre tatsächliche Leistung macht die Zielzeit aussagekräftiger.
Viele Masken- und Wörterbuchangriffe werden in der Unternehmensumgebung mit Mindestanforderungen an die Passwortkomplexität scheitern. Anstatt auf einen reinen Brute-Force-Angriff zurückzugreifen, können wir bekannte oder vermutete Passwortkomplexitätsregeln nutzen, um Passwortkandidaten zu vermeiden, die nicht der Richtlinie entsprechen, oder umgekehrt nur auf nicht konforme Passwörter zu prüfen. Mit PolicyGen können Sie eine Sammlung von Masken generieren, die der Passwortkomplexität folgen, um die Knackzeit erheblich zu verkürzen.
Unten ist eine Beispielsitzung, in der wir alle gültigen Passwortmasken für eine Umgebung generieren, die mindestens eine Ziffer, einen Großbuchstaben und ein Sonderzeichen erfordert.
$ 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
Anhand der obigen Ausgabe sehen wir, dass 40824 Masken generiert wurden, die die angegebene Komplexität erfüllen. Bei einer Geschwindigkeit von 1.000.000.000 Schlüsseln pro Sekunde würde das etwa 35 Tage dauern.
Falls Sie lediglich ein Passwort-Audit durchführen und nur nicht-konforme Passwörter finden sollen, können Sie das Flag --noncompliant verwenden, um die generierten Masken umzukehren:
$ 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
Sehen wir uns einige der oben generierten nicht-konformen Masken mit dem Flag --showmasks an:
$ 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
Wie Sie sehen, fehlt bei allen Masken mindestens eine Komplexitätsanforderung. Interessanterweise dauert der Angriff mit weniger generierten Masken länger, da langlaufende Masken wie ?s?s?s?s?s?s?s?s darin enthalten sind.
Es ist auch möglich, die maximale Passwortkomplexität mit den Flags --maxlower, --maxupper, --maxdigit und --maxspecial anzugeben, um Ihren Angriff zu verfeinern. Nachfolgend sehen Sie ein Beispiel für eine Website, die eine Passwortrichtlinie durchsetzt, aber keine Sonderzeichen zulässt:
$ 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 implementiert die Passwortanalyse und Regelgenerierung für den Hashcat-Passwortknacker, wie im Artikel Automatic Password Rule Analysis and Generation beschrieben. Bitte lesen Sie dieses Dokument für eine detaillierte Erläuterung der Theorie der Regelanalyse und -generierung.
Das Rückgängigmachen von Quellwörtern und Wortveränderungsregeln aus bereits geknackten Passwörtern kann bei Angriffen auf noch verschlüsselte Hashes sehr effektiv sein. Durch kontinuierliches Recycling/Erweitern generierter Regeln und Wörter können Sie möglicherweise eine größere Anzahl von Passwörtern knacken.
Für die effektive Nutzung von rulegen.py gibt es mehrere Voraussetzungen. Das Tool nutzt die Enchant-Rechtschreibprüfungsbibliothek, um mit einer Reihe von Rechtschreibprüfungs-Engines wie Aspell, MySpell usw. zu kommunizieren. Sie müssen diese Tools vor der Verwendung installieren. Es ist auch wichtig, Wörterbücher für die von Ihnen verwendete Rechtschreibprüfungs-Engine zu installieren (alternativ ist es möglich, eine benutzerdefinierte Wortliste zu verwenden). Schließlich habe ich PyEnchant der Einfachheit halber beigelegt, das direkt mit den gemeinsam genutzten Bibliotheken von Enchant kommunizieren sollte; falls es dennoch Probleme geben sollte, entfernen Sie einfach das beigelegte 'enchant'-Verzeichnis und installieren Sie PyEnchant für Ihre Distribution.
Weitere Details zur spezifischen Syntax der Hashcat-Regeln finden Sie unter Hashcat Rule Based Attack.
Die grundlegendste Verwendung von rulegen.py ist die Analyse eines einzelnen Passworts, um automatisch Regeln zu erkennen. Lassen Sie uns Regeln und das potenzielle Quellwort für das Beispielpasswort P@55w0rd123 erkennen:
$ 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
In diesem Beispiel haben wir mehrere Flags verwendet:
Die Verarbeitung von Passwortdateien wird in einem späteren Abschnitt behandelt; lassen Sie uns jedoch zunächst einige der verfügbaren Feineinstellungsoptionen anhand eines einzelnen Passworts als Beispiel besprechen.
Beachten Sie, dass wir das Enchant-Modul aspell zur Erkennung von Quellwörtern verwenden. Die genaue Rechtschreibprüfungs-Engine kann mit dem Flag --provider wie folgt geändert werden:
$ python rulegen.py --verbose --provider myspell --password P@55w0rd123 -q
[*] Using Enchant 'myspell' module. For best results please install
'myspell' module language dictionaries.
...
HINWEIS: Die Priorität der Engine kann durch eine kommagetrennte Liste angegeben werden (z. B. --provider aspell,myspell).
Die Verwendung der Quellworterkennungs-Engine kann vollständig deaktiviert werden, indem ein Quellwort mit dem Flag --word angegeben wird:
$ python rulegen.py -q --verbose --word word --password P@55w0rd123
[*] Analyzing password: P@55w0rd123
[+] word => ^5 ^5 ^@ ^P so0 $1 $2 $3 => P@55w0rd123
Durch die Angabe verschiedener Quellwörter können Sie viel Spaß beim Experimentieren mit der Regelgenerierungs-Engine haben.
Irgendwann werden Sie an einen Punkt kommen, an dem die Verwendung der Standard-Wortliste der Rechtschreibprüfungs-Engine nicht mehr ausreicht. Sie können mit dem Flag --wordlist ein benutzerdefiniertes Wörterbuch angeben. Dies ist besonders nützlich, wenn Sie Quellwörter aus einer vorherigen Analysesitzung wiederverwenden:
$ 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
Benutzerdefinierte Wortlisten können besonders nützlich sein, wenn Sie normalerweise nicht vorkommende Wörter wie Slang oder bereits geknackte Passwörter verwenden.
Obwohl rulegen.py versucht, nur die besten Quellwörter und Passwörter zu generieren und aufzuzeichnen, kann es Fälle geben, in denen Sie an weiteren Ergebnissen interessiert sind. Verwenden Sie die Flags --morewords und --morerules, um Wörter und Regeln zu generieren, die den optimalen Bearbeitungsabstand überschreiten können:
$ 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$
Es ist möglich, die generierten Wörter mit den Flags --maxworddist und --maxwords weiter zu erweitern. Ebenso können Sie mit den Flags --maxrulelen und --maxrules weitere Regeln erzeugen.
rulegen.py enthält eine Reihe erweiterter Engines, um qualitativ hochwertigere Wörter und Regeln zu generieren. Sie können deaktiviert werden, um die Unterschiede zu beobachten (oder falls sie Probleme verursachen), indem Sie die Flags --simplewords und --simplerules verwenden. Lassen Sie uns beobachten, wie sich sowohl Quellwörter als auch Regeln mit diesen Flags ändern:
$ 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$
Beachten Sie, dass die Qualität der generierten Wörter und Regeln erheblich reduziert wurde – Wörter wie 'manky' haben einen geringeren Bezug zum eigentlichen Quellwort 'money'. Gleichzeitig wurden die generierten Regeln auf einfache Einfügungen, Löschungen und Ersetzungen reduziert.
Nachdem Sie nun alle verschiedenen Flags und Schalter beherrschen, können wir versuchen, Wörter und Regeln für eine Sammlung von Passwörtern zu generieren. Lassen Sie uns eine Textdatei korelogic.txt mit den folgenden recht komplexen Testpasswörtern erstellen:
&~defcon
'#(4)\
August19681
'&a123456
10-D'Ann
~|Bailey
Krist0f3r
f@cebOOK
Nuclear$(
zxcvbn2010!
13Hark's
NjB3qqm
Sydney93?
antalya%]
Annl05de
;-Fluffy
Lassen Sie uns nun die Analyse von rulegen.py beobachten, indem wir einfach die Passwortdatei als erstes Argument angeben:
$ 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%)
Mit den Standardeinstellungen konnten wir mehrere qualitativ hochwertige Regeln erstellen. Die Anwendung zeigt eine grundlegende Statistik der Top 10 Regeln und Wörter an. Alle generierten Regeln und Wörter werden standardmäßig unter dem Basisnamen 'analysis' gespeichert:
Beachten Sie, dass mehrere Passwörter wie '#(4)\ und '&a123456 übersprungen wurden, da sie nicht die erforderlichen Merkmale für die Verarbeitung aufweisen. Neben der Anzahl der Buchstabenzeichen überspringt das Programm alle numerischen Passwörter und Passwörter, die nicht-ASCII-Zeichen enthalten. Letzteres ist auf einen Fehler in der Enchant-Engine zurückzuführen, den ich hoffentlich in Zukunft beheben kann, um die Wortverarbeitung in vielen Sprachen zu ermöglichen.
Wie bereits erwähnt, speichert rulegen.py Ausgabedateien standardmäßig mit dem Basisnamen 'analysis'. Sie können den Basisnamen der Datei mit dem Flag --basename oder -b wie folgt ändern:
$ 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
Es kann Situationen geben, in denen Probleme bei der Generierung von Regeln für den Hashcat-Passwortknacker auftreten. rulegen.py enthält das Flag --hashcat, um generierte Wörter und Regeln mit Hashcat selbst im --stdout-Modus zu validieren. Damit dieser Modus korrekt funktioniert, müssen Sie die neueste Version von hashcat-cli herunterladen und die Variable HASHCAT_PATH im Quellcode bearbeiten. Zum Zeitpunkt der Erstellung dieses Handbuchs habe ich den Ordner hashcat-0.## im PACK-Verzeichnis abgelegt und HASHCAT_PATH als 'hashcat-0.##/' definiert.
Sie können die inneren Abläufe der Regelgenerierungs-Engine auch mit dem Flag --debug beobachten. Machen Sie sich keine Sorgen über Meldungen zu bestimmten Regelausfällen – dies ist das Ergebnis des Lösers für das Halteproblem, der eine optimale und gültige Lösung finden soll.
Während dieses Handbuch eine Reihe von Methoden zur Analyse von Passwörtern, zum Rückgängigmachen von Regeln und zum Generieren von Masken vorstellt, gibt es noch eine Reihe weiterer Tricks, die darauf warten, von Ihnen entdeckt zu werden. Ich würde mich freuen, wenn Sie mir von ungewöhnlichen Anwendungen oder Vorschlägen für eines der vorgestellten Tools berichten würden.
Viel Spaß beim Knacken!
-Peter