Password Strength Meter

Lehrstuhl für Informatik 1
Friedrich-Alexander-Universität
Erlangen-Nürnberg
Bachelorarbeit
Password Strength Meter
Bernd Grillenberger
Roßtal, 30.11.2014
Examiner:
Advisor:
Prof. Dr. Felix Freiling
Michael Gruhn, M. Sc.
Eidesstattliche Erklärung / Statutory Declaration
Hiermit versichere ich eidesstattlich, dass die vorliegende Arbeit von mir selbständig, ohne Hilfe Dritter und
ausschließlich unter Verwendung der angegebenen Quellen angefertigt wurde. Alle Stellen, die wörtlich
oder sinngemäß aus den Quellen entnommen sind, habe ich als solche kenntlich gemacht. Die Arbeit
wurde bisher in gleicher oder ähnlicher Form keiner anderen Prüfungsbehörde vorgelegt.
I hereby declare formally that I have developed and written the enclosed thesis entirely by myself and have
not used sources or means without declaration in the text. Any thoughts or quotations which were inferred
from the sources are marked as such. This thesis was not submitted in the same or a substantially similar
version to any other authority to achieve an academic grading.
Der Friedrich-Alexander-Universität, vertreten durch den Lehrstuhl für Informatik 1, wird für Zwecke der
Forschung und Lehre ein einfaches, kostenloses, zeitlich und örtlich unbeschränktes Nutzungsrecht an den
Arbeitsergebnissen der Arbeit einschließlich etwaiger Schutz- und Urheberrechte eingeräumt.
Roßtal, 30.11.2014
Bernd Grillenberger
i
Zusammenfassung
Passwörter sind als Authentifikationsmechanismus nicht mehr wegzudenken. Daher beschäftigten sich
bereits einige Studien mit der Analyse von verwendeten Passwörtern. Dabei werden die Passwörter hinsichtlich ihrer Länge und ihrem Aufbau untersucht. Diese Studien ergaben, dass sehr oft kurze Passwörter
oder Passwörter, die aus einer Character-Klasse bestehen, verwendet werden und diese unsicher sind.
Dadurch, dass Crackprogramme wie Hashcat oder John the Ripper Wörterbücher Regeln verwenden, um
ihre Passwortkandidaten zu erzeugen, sind auch diejenigen Passwörter, die in diesem Wörterbuch vorkommen oder leicht mit Standardregeln herzuleiten sind, als unsicher einzustufen. In dieser Arbeit wird ein
Password Strength Meter in Python implementiert, das ein Passwort hinsichtlich der Sicherheit gegenüber
Hashcat und John the Ripper bewertet. Das Wörterbuch wird importiert, die verschiedenen Regeln implementiert und Benchmarks von John the Ripper/Hashcat zur Zeitabschätzung herangezogen. Am Ende
werden Schätzwerte zu verschiedene Angreifern und Hashfunktionen ausgegeben.
Abstract
Passwords are indispensable as an authentication mechanism. Therefore, some studies have already addressed the analysis of used passwords. In this case, the passwords are examined with regard to their
length and their structure. These studies found out that passwords or passwords that consist of only one
character class are very often used. These passwords are mostly unsafe. Cracking tools such as Hashcat
or John the Ripper use dictionaries and rules to generate their password candidates. Because of this fact
those passwords that are found in this dictionary or easily to derive with standard rules are also classified as
unsafe. In this work a Password Strength Meter is implemented, which assesses a password regarding to its
safety against Hashcat and John the Ripper. The dictionary is imported, the various rules implemented and
benchmarks by John the Ripper/Hashcat used for time estimation. At the end estimated values are output
to various types of attackers and hash functions.
ii
Liste von Tabellen
2.1
2.2
2.3
Regeln, die Hashcat und John the Ripper unterstützt . . . . . . . . . . . . . . . . . . . . .
Regeln, um Kandidaten abzulehnen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Regeln, die nur Hashcat bietet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
Benchmarks Multi Processing John the Ripper
Benchmarks ONE-CPU John the Ripper . . .
Benchmarks GPU Hashcat . . . . . . . . . .
Benchmark John the Ripper: Heimnutzer . .
Brute-Force: Heimnutzer . . . . . . . . . . .
Benchmark John the Ripper: Kleine Firma . .
Brute-Force: Kleine Firma . . . . . . . . . .
Benchmark John the Ripper: Große Firma . .
Brute-Force: Große Firma . . . . . . . . . .
Brute-Force: Geheimdienst GPU-Angriff . .
Worst Case Regeln . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
17
18
18
19
19
20
20
20
21
21
22
5.1
Evaluierung: Online PSM vs. eigenes PSM . . . . . . . . . . . . . . . . . . . . . . . . .
23
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8
8
9
iii
CONTENTS
1 Einleitung
1
1.1
Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1
1.2
Hintergrund . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.3
Definitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
1.4
Aufgabenstellung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.5
Verwandte Arbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
1.6
Überblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2 Technischer Hintergrund
5
2.1
Hashcat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.2
John the Ripper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
9
2.3
Hash Typen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
10
3 Implementierung
11
3.1
Beschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.2
Übersicht der Einordnung der Passwortstärke . . . . . . . . . . . . . . . . . . . . . . . .
15
4 Zeitabschätzung
16
4.1
Benchmarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
16
4.2
Modellieren von Angreifern . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
4.2.1
Heimnutzer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
4.2.2
Kleine Firma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
4.2.3
Große Firma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
20
4.2.4
Geheimdienst GPU-Angriff . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
Worst Case Regeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
4.3
5 Evaluierung
23
6 Fazit
24
Literaturverzeichnis
26
iv
E INLEITUNG
1
Passwort Authentifikation ist der aktuell meist verwendete Authentifikationsmechanismus in Computer
Systemen. Dabei möchte sich der Benutzer (Prover) in einem System (Verifier) authentisieren, indem er
durch die Kombination Benutzername und Passwort seine Identität preisgibt. Die vorgegebene Identität
wird dann durch den Verifier überprüft, d.h. ob das zum Benutzernamen passendes Passwort eingegeben
wurde. Nach der erfolgreichen Authentifikation erhält der Benutzer seine Berechtigungen im System.
Das Passwort wird hierbei vom Benutzer vergeben und sollte einige Anforderungen erfüllen. Dazu gehört
z.B. eine gewisse Passwortlänge, Groß- und Kleinschreibung, Ziffern und Sonderzeichen, um die Komplexität zu steigern.
Wie in [2] beschrieben besitzen die vergebenen Passwörter eine zu geringe Komplexität, was sie anfällig
gegen Angriffe macht. Oft werden sehr schwache Passwörter aus Bequemlichkeit des Benutzers vergeben.
Ein bekanntes Beispiel für ein unsicher vergebenes Passwort ist der Launch-Code für US-Atomraketen
während des Kalten Krieges. Zu dieser Zeit lautete das Passwort, um die Atomwaffe zu starten, 00000000
vergeben. Dies sollte vermutlich einen schnellen Start im Notfall ermöglichen, lässt jedoch die mangelnde
Sicherheit des Passworts außer Acht.
1.1 Motivation
Aktuell gibt es einige Tools, um einen Angriff auf Nutzerdaten zu vollziehen. Dazu zählen beispielsweise
John the Ripper und Hashcat. Diese bedienen sich im groben zweierlei Techniken.
Zum einen den Brute-Force-Modus, was bedeutet, dass alle möglichen Kombinationen ausprobiert werden.
Beinhaltet das Passwort ASCII [23] Groß- und Kleinschreibung, Ziffern und Sonderzeichen so stehen für
jedes einzelne Zeichen 95 Möglichkeiten zur Verfügung. So multipliziert sich die Anzahl der Möglichkeiten
mit jedem weiteren Zeichen um den Faktor 95.
Zum anderen erzeugt John the Ripper die Passwortkandidaten durch Wörterbücher und Regeln. Dabei wird
auch in den Regeln beachtet, wie Personen meistens ihre Passwörter zusammensetzen.
Bei Ausführung des Crackprogrammes werden Hashwerte gebildet und diese mit der Hash-Liste oder einem
Passwort-Hash verglichen. Falls es zu einer Hashkollision kommt, wurde das gesuchte Passwort gefunden.
1
CHAPTER 1. EINLEITUNG
Würden unendlich schnelle Rechner zur Verfügung stehen, könnte jedes Passwort gecracked werden. Zur
Beschleunigung der Berechnung werden auch GPUs zur Unterstützung herangezogen [22].
1.2 Hintergrund
Tendenziell neigt der Mensch dazu, einfache und leicht zu merkende und eher kurze Passwörter zu verwenden. Prinzipiell jedoch gilt: Die Passwortlänge spielt eine entscheidende Rolle für die Stärke eines
Passworts, welche durch die Verwendung von Klein- und Großbuchstaben, Zahlen und Sonderzeichen erhöht wird.
Doch aufgrund der Tatsache, dass Crackprogramme mit Wörterbüchern und Regeln arbeiten, werden Passwörter, die im vorhandenen Wörterbuch vorkommen oder durch Anwenden einer Standard-Regel erzeugbar
sind, deutlich schneller gecracked. In diesen Wörterbüchern sind Namen, sehr oft verwendete Passwörter
und vor allem Wörter, die einen Sinn ergeben, enthalten. Da viele Password Strength Meter wie [13]
jedoch ein Passwort danach bewerten, ob genügend Zeichen, Klein- und Großbuchstaben, Zahlen oder
Sonderzeichen darin vorkommen, ist die Aussage, die diese Password Strength Meter über die Sicherheit
des Passworts treffen, oftmals hinsichtlich der Crackbarkeit durch Crackprogramme nicht ganz richtig.
So kommt es dazu, dass ein Passwort wie beispielsweise sample123! als stark bezeichnet wird, da es aus
Kleinbuchstaben, drei Zahlen, Sonderzeichen aus 10 Zeichen besteht. Doch mit dem Standard Wörterbuch
von John the Ripper kann dieses Passwort durch Verwendung von einer Regel schnell gecracked werden.
Denn: sample123 ist im Standard Wörterbuch von Openwall vorhanden und nach Anwenden der Regel
Append Character ist das Passwort gecracked und kann daher nicht als stark bezeichnet werden.
1.3 Definitionen
• Basis:
Als Basis wird ein Wort bezeichnet, das im Wörterbuch vorkommt, ein Teilstring des Passworts ist
und eine minimale Länge von drei Zeichen aufweist. Wird beispielsweise das Passwort abcpassword1abc entgegengenommen und das Wörterbuch enthält unter anderem den Eintrag password, so
ist dieser Eintrag die Basis. Ein Passwort kann innerhalb eines Wörterbuchs auch mehrere Basen
besitzen.
• Maske:
Moderne Passwort Cracker benutzen Masken, welche die Muster der Passwortkandidaten darstellen.
Eine Maske ist ein String, der aus Platzhalter in Form eines ? gefolgt vom Zeichentyp besteht. Zeichentypen sind wie folgt vordefiniert:
- ?u = abcdefghijklmnopqrstuvwxyz (nur Kleinbuchstaben)
- ?l = ABCDEFGHIJKLMNOPQRSTUVWXYZ (nur Kleinbuchstaben)
- ?d = 0123456789 (nur Zahlen)
- ?s = «space»!"’#$%&’()*+,-./:;<=>?@[]ˆ_’{|}~(nur Sonderzeichen)
- ?a = ?l?u?d?s
Somit lautet die Maske für das Passwort "123Passwort!" ?d?d?d?u?l?l?l?l?l?l?l?s
• Brute-Force:
Brute-Force bedeutet alle Möglichkeiten von potenziellen Lösungen auf Kosten von Zeit und Ressourcen
durchzuprobieren. Es müssen also alle möglichen Kombinationen von Zahlen, Sonderzeichen, Großund Kleinbuchstaben auf Kosten von Effizienz erzeugt werden.
2
CHAPTER 1. EINLEITUNG
1.4 Aufgabenstellung
Das Ziel der Arbeit ist, auf den beschriebenen Hintergrund einzugehen und ein Password Strength Meter
zu entwickeln, das die Crackbarkeit eines Passwortes durch Programme wie John the Ripper oder HashCat
ermittelt und dann auf dieser Basis eine Aussage trifft, ob das Passwort eher schwach oder stark ist.
Dabei sollen sich die Regeln, die John the Ripper und HashCat auf das Wörterbuch anwendet, betrachtet
werden. Denn diese dienen zur Erzeugung der Passwortkandidaten.
Die Implementierung erfolgt in Python. Das Python Script erhält als Eingabe ein Passwort und nach der
Analyse eine Aussage über die Stärke des Passworts treffen. Da für die Zeit, die diese Crackprogramme
benötigen, einige Faktoren eine Rolle spielen, sollen verschieden Szenarien ausgegeben werden. Einer
dieser Faktoren ist die verwendete Hashfunktion, denn unterschiedliche Hashfunktionen benötigen unterschiedlich lange für die Berechnung des jeweiligen Hashwertes. Außerdem ist die Hardware entscheidend,
mit der die Hashwerte erzeugt werden.
1.5 Verwandte Arbeiten
Einige Studien haben sich bereits mit der Analyse von Passwörtern, die von Nutzer verwendet werden,
beschäftigt.
In Analyzing Password Strength [4] wird bereits auf das Problem eingegangen, dass sehr viele Benutzer unsichere Passwörter verwenden. Dabei wurde eine große Datenbank mit Passwörtern mittels eines Password
Checkers getestet. Das Ergebnis offenbarte, dass mehr als 90% aller untersuchten Passwörter als unsicher
einzustufen waren.
Des Weiteren werden in Guess again (and again and again): Measuring password strength by simulating
password-cracking algorithms [12] 12000 Passwörter, die während einer Online-Studie gesammelt wurden,
unter anderem mit verschiedenen password-guessing algorithms hinsichtlich ihrer Passwortstärke untersucht.
In Improving computer security for authentication of users: Influence of proactive password restrictions
[20] geht es um den Einfluss von Passwortbedingungen auf die Crackbarkeit. So wurden 75% der Passwörter, die keine Bedingungen erfüllten und aus fünf Zeichen bestanden, gecracked. Mit Bedingungen
waren es nur 33%. Bei einer Passwortlänge von acht Zeichen waren es 17% und mit Bedingungen 12,5%.
Zu den Bedingungen gehörten, dass das Passwort Klein-und Großschreibung, eine Zahl, keine Wiederholung eines Zeichens hintereinander und weniger als zwei Zeichen des Benutzernamens enthalten musste.
In Analysis of Login Credentials in Keylogger Dropzones [2] wurden Zugangsdaten aus 30 GB Logdateien
analysiert. Dabei wurden die Passwörter auf ihre Häufigkeit, durchschnittliche Länge, Zeichensatz, Struktur und dem Vorkommen in der Openwall Wortliste untersucht.
Diese Openwall Wortliste wird auch von John the Ripper verwendet, die das Cracken der Passwörter
beschleunigt. Daher ist auch die Statistik über das Vorkommen in der Wortliste für diese Arbeit von Bedeutung. Die Ergebnisse besagen, dass in 19,1% die Passwörter auch in der Wortliste vorkamen, somit
hätte fast jedes fünfte Passwort innerhalb kürzester Zeit gecracked werden können. In weiteren 16,4% kam
das Basiswort in der Wortliste vor. Das Basiswort musste mindestens drei Zeichen lang sein und nur aus
Kleinbuchstaben bestehen. Beim Finden einer Basis kann John the Ripper durch Anwenden von Regeln
schneller als durch reines Brute-Forcen das gesuchte Passwort erzeugen.
80% der Top20 Passwörter bestanden ausschließlich nur aus Zahlen. 58,8% waren zwischen 6 und 8 Zeichen lang. Des Weiteren waren 94,4% alphanumerisch, d.h. lediglich 5,6% enthielten Sonderzeichen.
Außerdem wurde auch der Kontext zwischen dem Benutzernamen und dem gewählten Passwort analysiert.
Dabei wählten 1,68% Benutzernamen und Passwort gleich, bei 0,61% war das Passwort eine Teilmenge
des Benutzernamens und bei 1,49% war der Benutzername eine Teilmenge des Passwortes. Somit waren in
3,78% der Benutzername und das Passwort ähnlich.
Die Abgrenzung zu diesen Arbeiten ist, dass sich darauf konzentriert wird, die Passwortstärke dahingehend
zu bewerten, dass wir als Basis die Zeit, die Cracking-Tools wie John the Ripper oder HashCat benötigen,
betrachten und nicht nur die Bedingungen, die Passwörter erfüllen. Außerdem legen wir unseren Fokus
auf die Implementierung eines Password Strength Meter und nicht auf die Auswertung und Analyse bereits
benutzter Passwörter.
3
CHAPTER 1. EINLEITUNG
1.6 Überblick
Die Abschlussarbeit ist folgendermaßen gegliedert. Zuerst wird auf die beiden Tools Hashcat und John the
Ripper genauer eingegangen. Dabei sollen vor allem die Regeln, die Hashcat und John the Ripper verwendet, genauer betrachtet werden. Denn diese Regeln werden dann im Script implementiert. Außerdem wird
kurz der Unterschied zwischen langsamen und schnellen Hashes beleuchtet.
Im dritten Kapitel wird die Vorgehensweise erläutert bzw. die Implementierung des Scripts beschrieben.
Das nachfolgende Kapitel erläutert die Zeitabschätzung. Dazu werden zunächst die verwendeten Benchmarks in Tabellen dargestellt. Dann werden verschiedene Angreifer für unterschiedliche Hashwerte und
reines Brute-Force modelliert. Anschließend wird in einer Tabelle der Worst Case der Regeln festgehalten.
Das darauffolgende Kapitel beinhaltet den Vergleich von einigen Passwörtern mit einem bisherigen online
zur Verfügung stehenden Password Strength Meter und dem Password Strength Meter dieser Arbeit.
Das letzte Kapitel enthält eine kurze Zusammenfassung und Ausblick.
4
T ECHNISCHER H INTERGRUND
2
Dieses Kapitel soll die verschiedenen Anfgriffs-Modi und Besonderheiten zweier von Hashcat und John the
Ripper erläutern.
2.1 Hashcat
Hashcat unterstützt folgende Angriffs-Modi, die auf der offiziellen Website von Hashcat [7] zu finden sind:
• Brute-Force attack:
In diesem Modus werden sämtliche Kombinationen aller Zeichen gebildet. Es werden sozusagen alle
Möglichkeiten von Passwörtern, die sich mit der Zunahme jedes Zeichens vervielfachen, erzeugt.
Der Nachteil dieses Angriffs ist die Performance.
• Combinatory attack:
Diese Attacke beinhaltet, dass sämtliche Wörterbucheinträge erneut an jeden Wörterbucheintrag
angehängt werden. Dies ermöglicht, dass Wortwiederholungen, sofern das einzelne Wort im Wörterbuch vorhanden ist, schneller gecracked werden. Als kleines Beispiel: Unser Wörterbuch besitzt nur
vier Einträge und sieht folgendermaßen aus:
Max
Mustermann
Passwort
123456
Hashcat erzeugt daraus AnzahlEinträge2 Passwortkandidaten:
MaxMax
MaxMustermann
MaxPasswort
5
2.1. HASHCAT
Max123456
MustermannMax
MustermannMustermann
MustermannPasswort
Mustermann123456
PasswortMax
PasswortMustermann
PasswortPasswort
Passwort123456
123456Max
123456Mustermann
123456Passwort
123456123456
• Dictionary attack:
Dies ist wohl neben dem Brute-Force einer der bekanntesten Modi. Hierbei verwendet Hashcat einfach sämtliche Einträge eines Wörterbuchs als Passwortkandidaten. Wichtig hierbei ist, dass jedes
Wort in einer separaten Zeile steht.
• Fingerprint attack:
Er ist eine Verschmelzung der Ergebnisse des Expanders mit einer Kombinationsmaschine. Dieser
Modus wird nicht genauer erläutert, da er für unser Password Strength Meter nicht weiter relevant ist.
• Hybrid attack:
Im Prinzip eine Combinary attack. Dazu wird das Wörterbuch und Brute-Force attack genutzt. An
die Einträge des Wörterbuchs werden Zeichen vorangestellt oder angehängt.
• Mask attack:
Dieser Modus ist im Prinzip ein spezifizierter Brute-Force attack. Der Unterschied liegt darin, dass
ein jedes einzelnes Zeichen auf einen bestimmten Schlüsselraum eingeschränkt wird und sich somit
die Anzahl der Möglichkeiten enorm verkürzen lassen. Die vordefinierten Zeichensätze wurden bereits in 1.3 erläutert. Bei der Maskenbildung wird dabei ausgenutzt, wie Menschen normalerweise
ihre Passwörter bilden. Viele Menschen bilden ihr Passwort durch einen Namen gefolgt von einer
Jahresangabe, z.B. Bernd1991. Dieses Passwort hat eine Länge von 9 Zeichen. Angenommen man
möchte dieses Passwort brute-forcen, dann müsste man 959 mögliche Passwortkandidaten erzeugen.
Bei einer Erzeugung von 100 Millionen Hashwerten pro Sekunde würde man über 199 Jahre benötigen, um das Password zu cracken. Würde man jedoch die Maske ?u?l?l?l?l?l?d?d?d?d benutzen, so
hätte man 26 ∗ 26 ∗ 26 ∗ 26 ∗ 26 ∗ 10 ∗ 10 ∗ 10 ∗ 10 Möglichkeiten . Dies würde lediglich knapp 20
Minuten benötigen.
• Permutation attack:
Hier werden alle Permutationen jedes einzelnen Wörterbucheintrages erzeugt. Ein Nachteil davon ist,
dass bei vielen langen Einträgen enorm viele Möglichkeiten gebildet werden müssen. Unser Wörterbuch enthält beispielsweise den Eintrag PWD. Dann erhält man AnzahlZeichen! Passwortkandidaten:
PWD
PDW
WPD
WDP
DPW
DWP
• Rule-based attack:
Der komplizierteste aber auch mächtigste Angriffsmodus, denn dieser erzeugt mit Hilfe von Modifikationen und Erweiterungen nach bestimmten Regeln neue Passwortkandidaten. Dieser Modus
wird genauer beschrieben, da diese Regeln, bis auf die letzten vier Regeln wegen Speicherzugriffe,
6
CHAPTER 2. TECHNISCHER HINTERGRUND
im Script implementiert werden. Folgende Tabelle enthält Regeln, die auch von John the Ripper unterstützt werden. Bei Positionsangaben mittels N startet N bei Null.
Name
Fkt.
Nothing
Lowercase
:
l
Uppercase
u
Capitalize
c
Invert
Capitalize
Toggle
Case
Toggle @
C
t
TN
Reverse
Duplicate
Duplicate
N
Reflect
r
d
pN
Rotate
Left
Rotate
Right
Append
Character
Prepend
Character
Truncate
left
Truncate
right
Delete @
N
Delete
range
Insert @
N
Overwrite
@N
Replace
Purge
Duplicate
first N
Duplicate
last N
Duplicate
all
{
f
Beschreibung
Tut nichts
Wandelt alle Buchstaben in
Kleinbuchstaben um
Wandelt alle Buchstaben in
Großbuchstaben um
Macht erstes Zeichen groß,
Rest klein
Macht erstes Zeichen klein,
Rest groß
Kehrt
Klein/Großschreibung um
Kehrt
Klein/Großschreibung an Stelle N
um
Kehrt Eingabe um
Dupliziert Eingabe
Hängt Duplikat N mal an
Bsp.Regel
:
l
Eingabe
Ausgabe
Pwd1234
Pwd1234
Pwd1234
pwd1234
u
Pwd1234
PWD1234
c
pwD1234
Pwd1234
C
Pwd1234
pWD1234
t
Pwd1234
pWD1234
T2
Pwd1234
PWd1234
r
d
p1
Pwd1234
Pwd1234
Pwd1234
4321dwP
Pwd1234Pwd1234
Pwd1234Pwd1234
f
Pwd1234
Pwd12344321dwP
{
Pwd1234
wd1234P
}
Pwd1234
4Pwd123
$X
Hängt umgekehrtes Duplikat der Eingabe an
Schiebt Eingabe um eine
Stelle nach links
Schiebt Eingabe um eine
Stelle nach rechts
Hängt Zeichen X an
$!
Pwd1234
Pwd1234!
ˆX
Stellt Zeichen X voran
ˆ!
Pwd1234
!Pwd1234
[
Löscht erstes Zeichen
[
Pwd1234
wd1234
]
Löscht letztes Zeichen
]
Pwd1234
Pwd123
}
DN
Löscht Zeichen an Stelle N
D2
Pwd1234
Pw1234
xNM
Löscht M Zeichen ab Stelle
N
Setzt Zeichen X an Stelle N
ein
Überschreibt Zeichen an
Stelle N mit X
Ersetzt alle X durch Y
Eliminiert alle X
Dupliziert erstes Zeichen N
mal
Dupliziert letztes Zeichen N
mal
Dupliziert jedes Zeichen
x03
Pwd1234
1234
i3A
Pwd1234
PwdA1234
o3!
Pwd1234
Pwd!234
sws
@w
z2
Pwwd1234
Pwwd1234
Pwd1234
Pssd1234
Pd1234
PPPwd1234
Z2
Pwd1234
Pwd123444
q
Pwd1234
PPwwdd11223344
iNX
oNX
sXY
@X
zN
ZN
q
7
2.1. HASHCAT
Extract
memory
XNMI
Append
memory
4
Prepend
memory
6
Memorize
M
Fügt einen Teilstring des im
Speicher an Position i stehenden Wortes der Länge M
beginnend ab Position N ein
Fügt das im Speicher stehende Wort an aktuelles
Wort an
Stellt das im Speicher stehende Wort vor aktuelles
Wort
Behält aktuelles Wort
lMX428
p@ssW0rd
p@ssw0rdw0
uMl4
p@ssW0rd
p@ssw0rdP@SSW0RD
rMr6
p@ssW0rd
dr0Wss@pp@ssW0rd
lMuX084 p@ssW0rd
P@SSp@ssw0rdW0RD
Tabelle 2.1: Regeln, die Hashcat und John the Ripper unterstützt
Des Weiteren gibt es noch Regeln, die den Nutzen haben, bestimmte Kandidaten abzulehnen:
Name
Fkt.
Beschreibung
Reject less
Reject greater
Reject contain
Reject not contain
Reject equal first
Reject equal last
Reject equal at
Reject contains
Reject contains
<N
>N
!X
/X
(X
)X
=NX
%NX
Q
Lehnt ab, die größer N sind
Lehnt ab, die kleiner N sind
Lehnt ab, die X enthalten
Lehnt ab, die X nicht enthalten
Lehnt ab, die nicht mit X beginnen
Lehnt ab, die nicht mit X enden
Lehnt ab, bei denen an Postion N nicht X steht
Lehnt ab, die X weniger als N mal enthalten
Lehnt ab, wo der Speicher aktuelles Wort matched
Bsp.Regel
<16
>7
!a
/b
(c
)d
3e
%2f
rMrQ
Tabelle 2.2: Regeln, um Kandidaten abzulehnen
Außerdem stellt Hashcat folgende Regeln zur Verfügung, die jedoch in John the Ripper nicht vorhanden sind und deshalb in unserem Script nicht implementiert werden:
Name
Fkt.
Beschreibung
Swap
front
Swap
back
Swap @ N
k
Tauscht ersten zwei Zeichen
K
Tauscht letzten zwei Zeichen
Tauscht Zeichen an Stelle X
mit Stelle Y
Shiftet Zeichen an Stelle N
bitweise nach links
Shiftet Zeichen an Stelle N
bitweise nach rechts
Inkrementiert Zeichen an
Stelle N um 1 Ascii-Wert
Dekrementiert Zeichen an
Stelle N um 1 Ascii-Wert
Ersetzt Zeichen an Stelle N
mit Wert an Stelle N+1
Bitwise
shift left
Bitwise
shift right
Ascii
increment
Ascii
decrement
Replace N
+1
8
*XY
LN
RN
+N
-N
.N
Bsp.Regel
k
Eingabe
Ausgabe
Pwd1234
wPd1234
K
Pwd1234
Pwd1243
*02
Pwd1234
dwP1234
L2
Pwd1234
R2
Pwd1234
+2
Pwd1234
-2
Pwd1234
.2
Pwd1234
Pw11234
CHAPTER 2. TECHNISCHER HINTERGRUND
Replace N
-1
Duplicate
block
front
Duplicate
block
back
Title
,N
,2
Pwd1234
Pww1234
yN
Ersetzt Zeichen an Stelle N
mit Wert an Stelle N-1
Dupliziert ersten N Zeichen
y2
Pwd1234
PwPwd1234
YN
Dupliziert letzten N Zeichen
Y2
Pwd1234
Pwd123434
E
Wandelt Zeile in Kleinbuchstaben um, erstes Zeichen in
Großbuchstaben und jedes
Zeichen nach einem Leerzeichen
E
pwD1234 pwd
Pwd1234 Pwd
Tabelle 2.3: Regeln, die nur Hashcat bietet
• Table-Lookup attack:
In diesem Modus wird für jeden Eintrag unseres Wörterbuch die entsprechende Maske generiert.
Genauer wird auf den Modi nicht eingegangen, da dieser für unser Password Strength Meter keine
Rolle spielt.
• Toggle-Case attack:
Dies bewirkt, dass alle möglichen Varianten von Groß- und Kleinbuchstaben eines jeden einzelnen
Wörterbucheintrag gebildet werden. Beispiel: Das Wörterbuch enthält pwd1234. Daraus werden
2AnzahlBuchstaben Passwortkandidaten erzeugt:
pwd1234
Pwd1234
PWd1234
PwD1234
PWD1234
pWd1234
pwD1234
pWD1234
2.2 John the Ripper
Bei John the Ripper stehen 4 verschiedene Modi zur Verfügung [17]:
• Single crack mode:
Dies ist der Modus mit dem begonnen werden sollte. Er benutzt den Benutzername und andere
Heimverzeichnis-Namen als potentielle Kandidaten und wendet einige Regeln auf diese an. Außerdem ist er deutlich schneller als der Wordlist mode, da weniger Regeln und Wörter verwendet werden.
Erfolgreich gecrackte Passwörter werden ebenfalls geprüft, in Vermutung, dass mehrere Benutzer das
gleiche Passwort verwenden.
• Wordlist mode:
Man benötigt ein Wörterbuch, das einen Eintrag pro Zeile enthält. Diese Einträge werden sowohl
eins zu eins geprüft als auch verschiedenste Regeln auf diese angewendet. Das Wörterbuch wird
nicht sortiert und von der ersten bis zur letzten Zeile durchlaufen. Falls die Passwörter nicht aus
einem bestimmten Grund so angereiht sind, sollten die Passwörter alphabetisch sortiert werden, da
9
2.3. HASH TYPEN
bei manchen Hashtypen John the Ripper schneller arbeitet, wenn sich das nachfolgende Passwort nur
in wenige Zeichen unterscheidet.
• Incremental mode:
Dieser Modus probiert alle möglichen Kombinationen von Zeichen als Passwortkandidaten. Er ist
somit identisch zum Brute-Force attack bei Hashcat. In der Regel wird dieser Modus nur bei relativ
kurzen Passwörtern zum Erfolg führen, da es eine so große Anzahl an Möglichkeiten gibt und dies
zu viel Zeit benötigt. Für diesen Modus sollten daher spezifische Definitionen getroffen werden wie
etwa Passwortlängenlimits oder Zeichensatz (Masken).
• External mode:
Man kann bei John auch einen externen Cracking-Modus definieren. Die Definition erfolgt in der
Konfigurationsdatei. In der Sektion [List.External:MODE] kann Programmcode in C hinterlegt werden, den John the Ripper dann benutzt, um die Passwortkandidaten zu generieren.
2.3 Hash Typen
Da, wie bereits angesprochen, die Hashfunktion eine Bedeutung für die Performance spielt, soll folgend
kurz die prinzipiell zwei verschiedenen Gruppen von Hashes erläutert werden [16] :
• Schnelle Hashes:
Diese sind typischerweise kryptographische Hashes und sollen schnell und effizient berechenbar sein,
um beispielsweise in Authentifikationssystemen verwendet werden zu können. Zu diesen gehören
unter anderem MD4, MD5 und SHA-1. Der Vorteil der Performance wird zum Nachteil gegenüber
der Crackbarkeit. Denn umso schneller Hashes berechnet werden können, umso mehr können durch
Hashcat oder John the Ripper erzeugt und geprüft werden. Dies wiederum erhöht die Wahrscheinlichkeit das Passwort zu cracken.
• Langsame Hashes:
Diese sind dadurch charakterisiert, dass sie ineffizient und schwer zu erzeugen sind. Beispiele dazu
sind unter anderem bcrypt, PBKDF2 und scrypt. Dadurch kann eine höhere Sicherheit gegenüber
Angreifern gewährleistet werden, da die Anzahl der Hashes, die pro Sekunde erzeugt werden können
deutlich abnimmt.
Insgesamt gibt es eine große Anzahl verschiedener Hashes, die jeweils unterschiedliche Performance aufweisen.
Eine beschränkte Übersicht zu den Benchmarks einiger Hashes wird in 4.1 gegeben.
10
I MPLEMENTIERUNG
3
3.1 Beschreibung
In diesem Abschnitt wird der Programmablauf und die Implementierung der Regeln beschrieben.
Mit dem Start des Scripts wird das Wörterbuch mit dem Dateinamen password.lst zeilenweise durchlaufen
und jeder Eintrag in einem Array und die Anzahl der Einträge für spätere Überprüfungen gespeichert. Hierbei ist es wichtig, dass pro Zeile nur ein Passwort und keine leeren Zeilen vorhanden sind, um die richtige
Funktion des Scripts zu gewährleisten. Die Tests wurden mit dem Standard Wörterbuch [18] zu finden ist,
durchgeführt. Dort sind auch weitere länderspezifische Wörterbücher vorhanden, welche die Erfolgschancen wahrscheinlich im jeweiligen Land erhöhen.
Nach dem Abspeichern der Einträge der Wortliste wird das zu untersuchende Passwort entgegengenommen.
Dieses wird zu Beginn auf Länge und Character-Klassen untersucht. Da Passwörter, die unter sechs Zeichen lang sind, selbst via Brute-Force Heimnutzer 4.2.1 und langsamer Hashfunktion in annehmbarer Zeit
gecracked werden würden, werden Passwörter unter dieser Länge gleich als sehr schwach eingestuft und
nicht weiter analysiert.
Außerdem spielt es eine Rolle, ob ein Passwort nur aus einer Character-Klasse besteht. Denn diese Passwörter sind deutlich anfälliger gegenüber eines Angriffs via Masken. Somit werden Passwörter, die nur aus
einer Character-Klasse und aus weniger als acht Zeichen bestehen, als schwach eingestuft. Die Funktion
einheitlich(passwort) gibt True zurück, falls das Passwort mittels der Methoden isalpha(), islower(), isupper(), isdigit(), isalnum() auf eine Character-Klasse festgelegt werden kann.
Danach wird überprüft, ob das Passwort eins-zu-eins im Wörterbuch vorkommt, also im Prinzip die Regel
Nothing angewandt. Wenn dem so ist, kann das Passwort mittels Dictionary attack sehr schnell gecracked
werden. Denn dazu müssen im Worst Case lediglich zu jedem Eintrag der Hashwert gebildet werden. Das
Standard Wörterbuch enthält 3545 Passwortkandidaten. Somit kann auch ein solches Passwort, das einszu-eins im verwendeten Wörterbuch vorkommt, als schwach bezeichnet werden.
Sofern keiner dieser Fälle zuvor zutrifft, wird zunächst die Funktion maskepw(passwort) ausgeführt. Diese
prüft jedes einzelne Zeichen des Passworts auf ihre Character-Klasse, gibt die Maske des Passworts aus und
die Anzahl der Möglichkeiten bei einer Mask attack zurück.
11
3.1. BESCHREIBUNG
Danach wird mittels der Funktion regelnMatchen(passwort, wortListe, anzWorte) überprüft, ob das Anwenden der einzelnen Standard Regeln auf das Wörterbuch das Passwort matchen können. Dabei werden die
jeweiligen Regeln durchlaufen. Als Parameter wird das Passwort, die Wortliste, die das Wörterbuch enthält
und die Anzahl der Einträge des Wörterbuchs mitgegeben. Falls eine Regel matchen kann, wird ausgegeben,
welche Regel matchen konnte und True zurückgeliefert. Kann eine Standard Regel matchen, so ist das
Passwort ebenfalls als schwach einzustufen. Folgende Regeln konnten aufgrund von Speicherzugriffen, die
dort verwendet werden, nicht implementiert werden: Extract memory, Append memory, Prepend memory,
Memorize. Ansonsten sind alle Regeln, die sowohl von Hashcat als auch John the Ripper unterstützt werden (siehe 2.1), implementiert. Bei manchen Regeln konnte die Implementierung mittels Umkehrschluss
realisiert werden, um nicht die Regel auf jeden Wörterbucheintrag anwenden zu müssen. Bei den meisten Regeln war dies jedoch nicht möglich und so musste die Regel auf alle Einträge angewandt und mit
dem Passwort verglichen werden. Im Folgenden werden die einzelnen Implementierungen der Regeln
beschrieben.
• Lowercase:
Auf die Einträge des Wörterbuchs wird die Methode lower(), die alle Buchstaben in Kleinbuchstaben
wandelt, angewandt.
• Uppercase:
Hier wird statt lower() die Methode upper(), die alle Buchstaben zu Großbuchstaben wandelt, verwendet. Ansonsten ist die Implementierung identisch.
• Capitalize:
Statt upper() wird die Methode capitalize(), die das erste Zeichen in Großbuchstabe und den Rest in
Kleinbuchstaben wandelt. Ansonsten ist die Vorgehensweise gleich.
• Invert Capitalize:
Es wird eine Hilfsmethode icapitalize(wort) implementiert, die als Parameter wort den jeweiligen
Eintrag übergeben bekommt. Das erste Zeichen wird in Kleinbuchstabe, der Rest in Großbuchstaben
gewandelt und als String zurückgegeben.
• Toggle Case:
Dafür wird die Methode swapcase() verwendet, die jeden Kleinbuchstabe in Großbuchstabe und
jeden Großbuchstabe in Kleinbuchstabe wandelt.
• Toggle @:
Die Hilfsmethode toggleAt(wort, i) erhält den Wörterbucheintrag und den Index, an dem der Buchstabe gewechselt werden soll, als Parameter und gibt den String zurück.
• Reverse:
Hier wird eine neue Reverse-Wortliste erstellt, welche die Wörterbucheinträge von rechts nach links
enthält. Diese Liste wird dann mit dem Passwort verglichen.
• Rotate Left:
Hier wird zum ersten mal der Umkehrschluss genutzt. Bei dieser Regel werden alle Zeichen nach
links verschoben, wobei das erste zum letzten Zeichen wird. Daher kann durch das Verschieben der
Zeichen des Passworts nach rechts, wobei das letzte zum ersten Zeichen wird und anschließendem
Vergleich mit der Wortliste auf diese Regel geschlossen werden.
• Rotate Right:
Im Prinzip wie Rotate Left über Umkehrschluss implementiert. Diesmal wird das erste zum letzten
Zeichen des Passworts.
• Duplicate:
Es wird mittels *2 auf den jeweiligen Wörterbucheintrag der Wörterbucheintrag verdoppelt.
• Reflect:
Die zuvor in der Regel Reverse angelegte Reverse-Wortliste wird hier nochmals verwendet. An jeden
Wörterbucheintrag wird mittels + Operand der passende Eintrag der Reverse-Wortliste angehängt.
12
CHAPTER 3. IMPLEMENTIERUNG
• Duplicate all:
Es wird erneut der Umkehrschluss genutzt. Beim Anwenden von Modulo 2 auf die Länge des Passworts darf es keinen Rest geben, denn alle Zeichen müssen dupliziert vorkommen. Dann werden in
zweier Schritte die Zeichen des Passworts verglichen und bei Gleichheit einmal in eine Liste eingefügt. Diese Listeneinträge werden einem String zugewiesen. Die Länge des Strings muss gleich der
halben Länge des Passworts sein, damit gewährleistet ist, dass jedes Zeichen dupliziert enthalten ist.
Ist dies der Fall wird der String mit der Wortliste verglichen.
• Duplicate N:
Die Länge des Passworts muss dazu ein Vielfaches von der Länge des Wörterbucheintrags sein und
mindestens dreimal so lang, da sonst bereits die Regel Duplicate matchen kann. Dann wird der Faktor
n bestimmt und mittels *n auf den jeweiligen Wörterbucheintrag dieser vervielfacht.
• Append Character:
Mittels Umkehrschluss wird geprüft, ob das Passwort ohne das letzte Zeichen im Wörterbuch vorkommt.
• Prepend Character:
Diese ist identisch zu Append Character mit dem Unterschied, dass diesmal ohne das erste Zeichen
des Passworts geprüft wird.
• Duplicate first N:
Auch hier wird der Umkehrschluss genutzt. Zunächst wird die Anzahl der wiederholenden Zeichen
des Passworts von Beginn an bestimmt. Die Hilfsmethode duplicateFirstN(wort, n) bekommt den
Wörterbucheintrag und den Faktor, wie viele Zeichen dupliziert werden sollen, übergeben und gibt
den String mit den ersten n duplizierten Zeichen zurück. Da im Passwort auch duplizierte Zeichen
enthalten sein können, die beim Wörterbucheintrag nicht dupliziert werden müssen, muss für n gleich
eins gestartet werden. Zum Beispiel hat das Passwort hheello als n drei, auf den Wörterbucheintrag
hello müssen jedoch nur die ersten beiden Zeichen dupliziert werden. Außerdem muss vor Aufruf der
Hilfsmethode geprüft werden, ob die Länge des Wörterbucheintrags mindestens gleich n ist, damit
nicht auf einen ungültigen Index zugegriffen wird.
• Duplicate last N:
Diese wurde identisch zu Duplicate first N implementiert, nur dass der Faktor n vom Ende beginnend bestimmt wird. Die Hilfsmethode duplicateLastN(wort, n) gibt den String mit den letzten n
duplizierten Zeichen zurück.
• Truncate left:
Es wird jeder Wörterbucheintrag ohne das erste Zeichen mit dem Passwort verglichen.
• Truncate right:
Jeder Wörterbucheintrag wird ohne das letzte Zeichen mit dem Passwort verglichen.
• Delete @ N:
Die Hilfsmethode deleteAt(wort, i) bekommt den Wörterbucheintrag und einen Index übergeben, an
welcher Stelle gelöscht werden soll und gibt den String ohne das Zeichen an Index zurück.
• Delete range:
Die Hilfsmethode deleteRange(wort, start, laenge) bekommt als Parameter den Wörterbucheintrag,
den Start und die Länge des Bereichs übergeben und gibt den String mit gelöschtem Bereich zurück.
Dieser Bereich muss mindestens eine Länge von zwei haben, da sonst die Regel Delete @ greift.
• Purge:
Es wird zunächst eine Zeichenliste angelegt, in der alle druckbaren 95 ASCII-Zeichen enthalten sind.
Für jedes dieser Zeichen wird geprüft, ob dieses im jeweiligen Wörterbucheintrag enthalten ist. Falls
ja, wird mittels der Methode replace(old, new) das jeweilige Zeichen durch nichts ersetzt.
• Overwrite @ N und Replace:
Diese beiden Regeln wurden zusammen implementiert, da diese sich vom Algorithmus ähneln. Dazu
muss die Länge des Wörterbucheintrags gleich der Länge des Passworts sein. Es wird erneut die
Zeichenliste benötigt. Diesmal muss das Zeichen im Passwort enthalten sein. Auf jeden Wörterbucheintrag wird die Methode replace(old, new) das Zeichen des Wörterbucheintrags durch das Ze-
13
3.1. BESCHREIBUNG
ichen der Zeichenliste ersetzt. Mittels der Methode count(obj) wird dann noch zwischen Overwrite
@ N und Replace unterschieden. Falls das Zeichen genau einmal im Wörterbucheintrag vorkommt,
ist die Regel Overwrite @ N möglich. Wenn es mehr als einmal vorkommt, kann die Regel Replace
matchen.
• Insert @ N:
Dazu muss die Länge des Passworts um eins größer sein als die Länge des jeweilige Wörterbucheintrags. Die Hilfsmethode insertAt(wort, zeichen, i) erhält als Parameter den Wörterbucheintrag, das
Zeichen der Zeichenliste, den Index, an dem eingefügt werden soll und gibt den String mit eingefügtem Zeichen an richtiger Stelle zurück. Für jede Stelle bis auf die Stelle Null wird jedes Zeichen
eingesetzt. Denn Stelle Null ist bereits durch Prepend Character abgehandelt. Die letzte Stelle ist
jedoch nötig, da das letzte Zeichen dann rechts verschoben wird und nicht durch Append Character
abgedeckt ist.
Sofern keine Standard-Regel zum gewünschten Passwort führen konnte, werden verschiedenen Angreifer
und deren Werte zu verschiedenen Hashfunktionen angelegt 4.2.
Danach wird nach einer möglichen Basis gesucht. Die Hilfsmethode basisSuchen(passwort, wortListe, anzWorte) erhält als Parameter das Passwort, die Wortliste und die Anzahl der Einträge in der Wortliste und
gibt die größte gefundene Basis, die mehr als zwei Zeichen lang ist, zurück.
Zuerst wird das Passwort von hinten immer wieder um ein Zeichen gekürzt und verglichen, ob das verkürzte
Passwort in der Wortliste vorhanden ist. So wird der Fall abgedeckt, dass an die Basis mittels Append Character lediglich Zeichen angehängt werden müssen.
Folgend wird das Passwort von vorne immer wieder um ein Zeichen gekürzt und erneut verglichen, damit
der Fall, dass lediglich mittels Prepend Character Zeichen vorangestellt werden müssen.
Zuletzt fehlt noch der Fall, dass die Basis nicht mit dem ersten Zeichen beginnt und nicht mit dem letzten
Zeichen endet, sodass sowohl Append Character als auch Prepend Character angewandt werden müssen.
Dazu wird für jeden Bereich des Passwort mit der Länge drei gegen das Wörterbuch geprüft.
Falls eine Basis gefunden wurde, wird die Basis und die Zeichen, die nicht in der Basis enthalten sind ausgegeben. Die nicht enthaltenen Zeichen müssen durch die Regeln Append/Prepend Character hinzugefügt
werden. Also im Prinzip im Worst Case mittels Brute-Force erraten werden. Da die Basis dem Crackprogramm nicht bekannt ist, kann es dazu kommen, dass erst der letzte Wörterbucheintrag das Passwort
matchen kann. Bei der Zeitschätzung dafür wird vom Average Case ausgegangen.
Wird hingegen keine Basis gefunden, muss das komplette Passwort mittels Brute-Force gecracked werden.
Die Schätzung auch hier ebenfalls nach Average Case.
Für die Umrechnung der Möglichkeiten und Hashwertbildung pro Sekunde wird die Hilfsmethode zeitUmrechnen(moeglichkeiten, benchmark) verwendet. Diese bekommt als Parameter die Anzahl der Möglichkeiten
und den Benchmark des jeweiligen Angreifers zu einer bestimmten Hashfunktion. Mittels Umrechnungen
wird dann entschieden, welche Einheit für die Dauer angegeben wird. Dabei wird zwischen Sekunden,
Minuten, Stunden, Tage und Jahre unterschieden. Ist die Dauert größer als 100 Jahre, so wird sich auf >100
Jahre festgelegt. Als Rückgabe wird dann der Wert inklusive Einheit als String geliefert.
14
CHAPTER 3. IMPLEMENTIERUNG
3.2 Übersicht der Einordnung der Passwortstärke
In der nachfolgenden Abbildung wird die Einordnung der Passwortstärke des Scripts, wie sie in der Implementierung realisiert wurde, noch einmal verdeutlicht.
Passwort einlesen
Nein
Länge < 6
Einfache
Stringtests
zutreffend
Ja
Ja
Nein
Passwort sehr schwach
Nein
Länge < 8
Ja
1:1 im Wörterbuch
Ja
Passwort schwach
Nein
Standard
Regel matcht
Nein
Basis
vorhanden
Ja
Ja
Nein
Zeichen brute-forcen
Regel ausgeben
Passwort schwach
Passwort brute-forcen
Geschätzte Dauer
ausgeben
Abbildung 3.1: Einordnung Passwortstärke
15
4
Z EITABSCHÄTZUNG
4.1 Benchmarks
Folgende Benchmarks sind auf der Website von Openwall [15] zu finden. In den folgenden Auflistungen
wurde sich nur auf die Benchmarks beschränkt, die für jeden der aufgelisteten Hashes einen Wert enthielten.
Betriebssystem wurde auf Linux eingegrenzt. Des weiteren wurden unterschiedliche Compiler benutzt, die
hier nicht mit aufgelistet werden. Falls nur der Compiler einen Unterschied ausmachte, wurde der bessere
Wert genommen.
DES
crypt()
many /
one salt
117315K /
23130K
73334K /
27426K
73098K /
26699K
61675K /
31241K
50017K /
29746K
46153K /
30965K
36667K /
27349K
22773K /
18284K
16
MD5
crypt()
bcrypt
x32
Windows
LanMan
CPUs & clock rate
Threads
JtR Version
1953K
56320
33410K
128
1.7.9-jumbo-6
850944
23808
42630K
16x X7550, 2.0 GHz, HAT
disabled
4x X7560, 2.27 GHz
64
1.7.9-jumbo-5
344603
23500
40540K
4x X7560, 2.27 GHz
64
1.7.9
325558
18510
55030K
4x X7560, 2.27 GHz
32
1.7.9
404352
10800
72351K
24
1.7.9-jumbo-6
333504
7488
87244K
12
1.7.9-jumbo-6
493056
14112
74514K
2x E5-2630, 2.3 GHz +
turbo
2x E5-2630, 2.3 GHz +
turbo
2x X5690, 3.47 GHz
24
1.7.9-jumbo-5
66914
4800
88834K
Core i7-2600K 3.4 GHz
8
1.7.9
CHAPTER 4. ZEITABSCHÄTZUNG
22193K /
16377K
21561K /
16187K
21430K /
15446K
20334K /
15499K
18527K /
14247K
17758K /
14091K
17530K /
14516K
17039K /
12124K
16578K /
14581K
16442K /
12792K
14648K /
12288K
11599K /
9928K
9410K /
8601K
8867K /
7058K
6852K /
6366K
6650K /
5468K
1335K /
1228K
292K /
278K
95389
7003
54214K
2x E5620, 2.4 GHz + turbo
16
1.7.9.6-owl1
216192
5568
59244K
2x E5420, 2.5 GHz
8
1.7.9-jumbo-5
205708
6302
26682K
2x E5520, 2.27 GHz + turbo
16
1.7.9-jumbo-5
85844
5135
54027K
2x E5420, 2.5 GHz
8
1.7.9
87305
5539
48044K
FX-8120, o/c 3.6 GHz
8
1.7.9
80325
5367
60707K
6
1.7.9
150144
4419
79069K
Phenom II X6 1090T, 3.21
GHz
E31230, 3.2 GHz + turbo
8
1.7.9-jumbo-5
203264
5300
44826K
FX-8120, 3.1 GHz + turbo
8
1.7.9-jumbo-6
60235
4419
78610K
E31230, 3.2 GHz + turbo
8
1.7.9
87305
5537
43692K
FX-8120, 3.1 GHz + turbo
8
1.7.9
58368
3730
81674K
Q8400, o/c 3.4 GHz
4
45623
2952
64978K
Q8400, 2.66 GHz
4
91903
2115
66972K
Celeron E3200, oc 4.0 GHz
2
1.7.9.4-owl1,
Owl package
1.7.9.4-owl1,
Owl package
1.7.9-jumbo5
33969
2110
68012K
Celeron E3200, oc 4.0 GHz
2
1.7.9
27033
1740
63317K
2
1.7.9
29271
1872
54290K
Core 2 Duo E6550, o/c to
3.15 GHz
Celeron E3200, oc 3.33 GHz
2
1.7.9
14304
840
15548K
AMD E-450, 1.65 GHz
2
1.7.9-jumbo-6
2953
166
3596K
2x Cortex-A9 666 MHz, (in
Xilinx Zynq 7020)
2
1.8.0.1
Tabelle 4.1: Benchmarks Multi Processing John the Ripper
Außerdem sind auch Benchmarks für ONE-CPUs zu finden.
DES crypt()
many / one salt
6200K / 5898K
5802K / 5491K
5731K / 4647K
5723K / 5518K
MD5
crypt()
17418
14766
14648
14642
bcrypt
x32
1046
940
918
918
Windows
LanMan
80981K
71238K
26852K
74812K
4738K / 4390K
4463K / 4261K
4452K / 4275K
4381K / 4195K
39584
17279
45328
12388
946
1119
1122
786
57165K
61836K
61470K
60186K
CPUs & clock rate
Core i7-3770, 3.4 GHz
Core i7-2600K, 3.4 GHz
Core i7-2600K, 3.4 GHz
Core i7-2600K, 3.4 GHz
FX-8120, 4.0 GHz turbo
Celeron E3200, oc 4.0 GHz
Celeron E3200, oc 4.0 GHz
E31230, 3.2 GHz + turbo
JtR Version
1.8.0
1.7.9
1.7.8
1.7.8-fast-deskey-setup-3
1.7.9-jumbo-6
1.7.9
1.7.9-jumbo5
1.7.9
17
4.1. BENCHMARKS
4370K / 4186K
3951K / 3786K
3828K / 3673K
3713K / 3561K
3500K / 3369K
35340
14636
39348
14733
13300
792
950
904
944
882
60199K
53934K
51187K
50995K
48700K
3486K / 2989K
3429K / 3014K
15580
15696
943
924
17754K
21567K
E31230, 3.2 GHz + turbo
FX-8120, 4.0 GHz turbo
X5690, 3.47 GHz
Celeron E3200, oc 3.33 GHz
Core 2 Duo E6550, o/c to 3.15
GHz
E6750, o/c to 3.6 GHz
Core i7 920, o/c to 3.6 GHz
3376K / 3218K
3296K / 3213K
16089
13564
1070
790
43999K
47566K
Phenom II X6 1090T, 3.21 GHz
X5650, 2.67 GHz
3116K / 2843K
3017K / 2588K
3013K / 2531K
13599
13644
11257
791
825
745
20379K
14938K
16649K
X5650, 2.67 GHz
X5460, 3.16 GHz
X5460, 3.16 GHz
2965K / 2504K
...
45K / 43K
44K / 43K
10K / 9K
9438 / 8654
15530
...
740
645
201
254
1011
...
53.5
42.2
17.3
16.6
14997K
...
600K
804K
224K
202K
Phenom II X6 1075T, 3.0 GHz
...
Pentium II, 350 MHz
SD5113, 530 MHz
K5 PR75, 75 MHz
Pentium, 100 MHz
1.7.9-jumbo-5
1.7.9
1.7.9-jumbo-5
1.7.9
1.7.9
1.7.3.1
1.7.6-jumbo12
1.7.9
1.7.8-fast-deskey-setup-3
1.7.8
1.7.4.2
1.7.3.1-owl1
package
1.7.8
...
1.7.3.1
1.8.0.2
1.8.0
1.8.0
Tabelle 4.2: Benchmarks ONE-CPU John the Ripper
Des Weiteren unterstützt die Version oclHashcat auch die Hashwertbildung durch GPUs. Dazu sind folgende Benchmarks veröffentlicht [8].
Hash Type
MD4
MD5
SHA1
SHA256
SHA512
SHA3(Keccak)
RipeMD160
Whirlpool
LM
NTLM
NetNTLMv1
NetNTLMv2
WPA/WPA2
Windows 7,
64 bit, 1x
AMD
hd7970
15445M c/s
7893M c/s
2495M c/s
1036M c/s
179M c/s
157M c/s
Windows 7,
32 bit, 1x
Nvidia
gtx580
4245M c/s
2802M c/s
879M c/s
337M c/s
103M c/s
91M c/s
Ubuntu, 64
bit, 1x AMD
hd6990
Ubuntu, 64
bit, 8x AMD
R9 290X
19868M c/s
10436M c/s
3833M c/s
1413M c/s
383M c/s
277M c/s
Ubuntu, 64
bit, 1x
Nvidia
gtx750Ti
5718M c/s
3178M c/s
1103M c/s
406M c/s
90M c/s
111M c/s
1690M c/s
41281k c/s
1271M c/s
14789M c/s
7912M c/s
545M c/s
130k c/s
615M c/s
94752k c/s
412M c/s
4059M c/s
1844M c/s
205M c/s
47k c/s
2255M c/s
91128k c/s
967M c/s
19011M c/s
8605M c/s
491M c/s
181k c/s
677M c/s
54138k c/s
398M c/s
5708M c/s
1355M c/s
135M c/s
54k c/s
20008M c/s
507744k c/s
15176M c/s
174152M c/s
91984M c/s
6456M c/s
1454k c/s
Tabelle 4.3: Benchmarks GPU Hashcat
18
183232M c/s
93800M c/s
29528M c/s
12328M c/s
1952M c/s
2005M c/s
CHAPTER 4. ZEITABSCHÄTZUNG
4.2 Modellieren von Angreifern
In diesem Script werden verschiedene Szenarien modelliert. So spielt es eine Rolle, ob beispielsweise
ein Heimnutzer, eine Firma oder ein darauf spezialisierter Dienst einen Angriff durchführt. Denn diese
besitzen unterschiedliche Ressourcen und Hardware. Für unsere Angriffstypen werden zur Einstufung nur
der Wert der dafür nötigen Prozessoren betrachtet. Wie aus den Benchmarks ersichtlich ist die Anzahl
der zu erzeugenden Hashes pro Sekunde nicht nur von der Hardware sondern auch von der gewählten
Hashfunktion abhängig. Heutzutage sollte kein DES crypt() mehr verwendet werden, da dieser Hash sehr
schnell zu berechnen ist. Für unsere Schätzungen werden Windows LanMan, MD5 und bcrypt genauer
betrachtet. Die Tabellen zum Brute-Force attack sollen einen Einblick geben, bis zu welcher Passwortlänge
der jeweilige Angreifer Erfolgschance hat. Dabei wird vom Worst Case, dass sämtliche Kombinationen
gebildete werden müssen ausgegangen. Für die Zeitabschätzung im Script wird jedoch mit dem Average
Case gerechnet.
4.2.1 Heimnutzer
Bei einem Heimnutzer wird davon ausgegangen, dass dieser eine zeitgemäße und preislich angemessene
Hardware zur Verfügung hat. In diesem Fall wird folgender Datensatz aus den Benchmarks verwendet, da
die Kosten des Prozessors bei ca. 300 Euro [10] liegen:
DES
crypt()
many /
one salt
22773K /
18284K
MD5
crypt()
bcrypt
x32
Windows
LanMan
66914
4800
88834K
CPUs & clock rate
Core i7-2600K 3.4 GHz
Threads
8
JtR Version
1.7.9
Tabelle 4.4: Benchmark John the Ripper: Heimnutzer
Brute-Force attack
Die nachfolgende Tabelle zeigt, dass für einen Heimnutzer ein Brute-Force attack erst bei einer Passwortlänge kleiner acht im Falle eines Windows LanMan Hash Erfolg in annehmbarer Zeit verspricht. Bei
den anderen beiden Hashes muss die Passwortlänge sogar noch kleiner sein.
Zeichen
95
95
95
95
95
95
95
95
Passwortlänge
1
2
3
4
5
6
7
8
Windows
LanMan
0
0
0
1 Sekunde
1 Minute
2 Stunden
9 Tage
2 Jahre
MD5 crypt()
bcrypt x32
0
0
13 Sekunden
20 Minuten
32 Stunden
127 Tage
33 Jahre
0
2 Sekunden
3 Minuten
5 Stunden
19 Tage
5 Jahre
Tabelle 4.5: Brute-Force: Heimnutzer
4.2.2 Kleine Firma
Einer kleinen Firma steht in der Regel mehr Ressourcen und Hardware als einem Heimnutzer zur Verfügung. Diesmal werden für die Kosten von vier Prozessoren, die einen Einzelpreis von ca. 400 Euro [11]
19
4.2. MODELLIEREN VON ANGREIFERN
besitzen, herangezogen. Damit belaufen sich die Gesamtkosten auf ca. 2000 Euro. Dazu passt folgender
Datensatz aus den Benchmarks:
DES
crypt()
many /
one salt
73098K /
26699K
MD5
crypt()
bcrypt
x32
Windows
LanMan
344603
23500
40540K
CPUs & clock rate
Threads
4x X7560, 2.27 GHz
64
JtR Version
1.7.9
Tabelle 4.6: Benchmark John the Ripper: Kleine Firma
Brute-Force attack
Auch für eine kleine Firma ist ein Brute-Force attack erst bei einer Passwortlänge kleiner acht bei Windows
LanMan Hash in annehmbarer Zeit sinnvoll.
Zeichen
Passwortlänge
1
2
3
4
5
6
7
8
95
95
95
95
95
95
95
95
Windows
LanMan
0
0
0
2 Sekunden
3 Minuten
5 Stunden
20 Tage
5 Jahre
MD5 crypt()
bcrypt x32
0
0
2 Sekunden
4 Minuten
6 Stunden
25 Tage
6 Jahre
0
0
36 Sekunden
58 Minuten
91 Stunden
362 Tage
94 Jahre
Tabelle 4.7: Brute-Force: Kleine Firma
4.2.3 Große Firma
Für eine große Firma wird davon ausgegangen, dass dieser Ressourcen und Hardware der besten Benchmarks zur Verfügung hat. Dazu sind 16 Prozessoren nötig, die einen Einzelpreis von ca. 400 Euro [9]
besitzen. Die Gesamtkosten dafür belaufen sich somit auf ca. 6400 Euro. Dies ergibt folgenden Datensatz:
DES
crypt()
many /
one salt
117315K /
23130K
MD5
crypt()
bcrypt
x32
Windows
LanMan
CPUs & clock rate
Threads
JtR Version
1953K
56320
33410K
16x X7550, 2.0 GHz, HAT
disabled
128
1.7.9-jumbo-6
Tabelle 4.8: Benchmark John the Ripper: Große Firma
Brute-Force attack
Selbst für ein große Firma ändert sich nichts an der maximalen Passwortlänge. Bei MD5 crypt() und bcrypt
x32 wird jedoch eine deutlich verkürzte Dauer im Gegensatz zu Heimnutzer und kleiner Firma erreicht.
20
CHAPTER 4. ZEITABSCHÄTZUNG
Zeichen
Passwortlänge
1
2
3
4
5
6
7
8
95
95
95
95
95
95
95
95
Windows
LanMan
0
0
0
2 Sekunden
4 Minuten
6 Stunden
24 Tage
6 Jahre
MD5 crypt()
bcrypt x32
0
0
0
42 Sekunden
66 Minuten
105 Stunden
414 Tage
108 Jahre
0
0
15 Sekunden
24 Minuten
38 Stunden
151 Tage
39 Jahre
Tabelle 4.9: Brute-Force: Große Firma
4.2.4 Geheimdienst GPU-Angriff
Bei einem Geheimdienst wird davon ausgegangen, dass dieser die beste Hardware, zu denen es Benchmarks
gibt, zur Verfügung hat und die Hashwerte mittels GPUs erzeugt werden. Dazu sind acht AMD R9 290X
nötig. In Tabelle 4.3 ist die Hashfunktion bcrypt x32 nicht aufgelistet. Deshalb werden nur die Werte für
Windows LanMan und MD5 crypt() verwendet:
• Windows LanMan: 15176M
• MD5 crypt(): 93800M
Brute-Force attack
Im Falle eines derart starken Angriff mittels 16 GPUs würde sogar ein Brute-Force attack bei einer Passwortlänge kleiner neun in annehmbarer Zeit einen Erfolg bringen.
Zeichen
95
95
95
95
95
95
95
95
95
95
Passwortlänge
1
2
3
4
5
6
7
8
9
10
MD5 crypt()
0
0
0
0
0
8 Sekunden
12 Minuten
20 Stunden
78 Tage
20 Jahre
Windows
LanMan
0
0
0
0
1 Sekunde
1 Minute
1 Stunde
5 Tage
1 Jahr
Tabelle 4.10: Brute-Force: Geheimdienst GPU-Angriff
4.3 Worst Case Regeln
In der folgenden Tabelle soll eine Worst Case Übersicht zu jeder einzelnen Regel in Abhängigkeit vom
Wörterbuch gegeben werden. Also wie viele Hashes erzeugt werden müssen, damit das Passwort, sofern es
mit der Regel erreichbar ist, auf jeden Fall gefunden wird. Dabei wird die jeweilige Regel nur einmal angewandt, d.h. nicht mit anderen Regeln kombiniert. Denn bei mehrmaliger Anwendung unterschiedlichster
Regeln könnte man prinzipiell irgendwann auf jedes Passwort matchen, doch diese Dauer würde sich immer
21
4.3. WORST CASE REGELN
mehr dem Brute-Force nähern. In unserem Password Strength Meter wird ein Passwort daher als schwach
bezeichnet, sofern man es mittels Anwenden einer Regel matchen kann. Als Basis dazu dient das Standard
Wörterbuch mit 3545 Einträgen. Bei einem utopisch großen Wörterbuch, das sich einem Brute-Force attack
nähert, kann davon nicht mehr ausgegangen werden.
Regel
Nothing
Lowercase
Uppercase
Capitalize
Invert Capitalize
Toggle Case
Toggle @
Reverse
Rotate Left
Rotate Right
Duplicate
Reflect
Duplicate all
Duplicate N
Append Character
Prepend Character
Duplicate first N
Duplicate last N
Truncate left
Truncate right
Delete @ N
Delete range
Purge
Overwrite @ N
Replace
Worst Case
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Buchstaben
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge
Anzahl Einträge*ASCII-Zeichen
Anzahl Einträge*ASCII-Zeichen
Anzahl der Summe aus jedem Eintrag*Länge
Anzahl der Summe aus jedem Eintrag*Länge
Anzahl Einträge
Anzahl Einträge
Anzahl der Summe aus jedem Eintrag*Länge
Anzahl der Summe aus jedem Eintrag*mögliche ranges
Anzahl der Summe aus jedem Eintrag*jedes unterschiedliche Zeichen
Anzahl der Summe aus jedem Eintrag*jede Stelle*ASCII-Zeichen
Anzahl der Summe aus jedem Eintrag*jedes unterschiedliche
Zeichen*ASCII-Zeichen
Tabelle 4.11: Worst Case Regeln
22
5
E VALUIERUNG
Da für die Evaluierung der geschätzten Dauer des Password Strength Meter und der Dauer der Crackprogramme die Hardware, die den Benchmarks zu Grunde liegt, nicht vorhanden ist, wird sich auf die
Benchmarks verlassen.
In der folgenden Tabelle werden jedoch ein paar Beispiele von Passwörtern, die sowohl mit dem Password Strength Meter dieser Arbeit als auch einem Online Password Strength Meter [13] bewertet werden,
verglichen. Vor allem bei Passwörtern, die im Wörterbuch direkt oder die Basis darin vorkommt, ist es
zu erwarten, dass dabei durchaus unterschiedliche Ergebnisse hinsichtlich der Passwortstärke dabei zum
Vorschein kommen.
Als Werte für die Berechnung der Dauer der Hashwertbildung wird beispielsweise MD5 und große Firma
herangezogen. Für den Vergleich ist bei unserem Password Strength Meter natürlich das verwendete
Wörterbuch entscheidend. Beim Verwenden eines anderen Wörterbuchs können sich die Ergebnisse hingegen ändern.
Passwort
!Az0"
1357924
dkgnrfhdt1
123456789!
Password123
!@#$%ˆ]&
Volleyball
Elizabeth123!
ecLipse
4ugH391!
Michael1!
thunderBird
Pa!!word
Online PSM
gut
sehr schwach
schwach
stark
stark
stark
schwach
sehr stark
schwach
sehr stark
stark
schwach
stark
Eigenes PSM
sehr schwach
schwach
>100 Jahre
schwach
12 Minuten
schwach
schwach
20 Stunden
schwach
53 Jahre
8 Sekunden
schwach
schwach
Begründung
Brute-Force bis 5 Zeichen
Weniger als 8 Zeichen und nur Zahlen
Komplett mittels Brute-Force
Standard Regel Append Character $!
Basis Password gefunden, Brute-Force von 3 Zeichen
1:1 im Wörterbuch
Standard Regel Capitalize
Basis Elizabeth gefunden, Brute-Force von 4 Zeichen
Standard Regel Toggle @2
Komplett mittels Brute-Force
Basis Michael gefunden, Brute-Force von 2 Zeichen
Standard Regel Toggle @7
Standard Regel Replace ss!
Tabelle 5.1: Evaluierung: Online PSM vs. eigenes PSM
23
FAZIT
6
Mit dieser Arbeit wurde ein Password Strength Meter entwickelt, das die gemeinsamen Regeln zweier
bekannter Crackprogramme umsetzt. Dadurch kann die Passwortstärke nun auch dahingehend bewertet
werden, wie sicher man gegen mögliche Angriffe durch diese Programme ist. Für die Zeitabschätzung
konnten jedoch nur Benchmarks zu aktueller Hardware und beschränkt vielen unterschiedlichen Hashfunktionen verwendet werden.
Im Laufe der Zeit wird sich die Hardware höchstwahrscheinlich erneut verbessern, weshalb die Zeitabschätzungen zu den modellierten Angreifern dann nur noch bedingt der Realität entsprechen werden. Außerdem können neue bzw. extrem langsame Hashfunktionen hinzukommen, was die Anzahl an Hashwertbildungen enorm senkt und die Sicherheit gegenüber solcher Angriffe erhöht.
Generell kann man jedoch davon ausgehen, dass Passwörter, die durch einfaches Anwenden der Standard
Regeln auf das Wörterbuch, auch in Zukunft in annehmbarer Zeit gecracked werden. Voraussetzung dafür
ist natürlich, dass das Wörterbuch nicht utopisch viele Einträge enthält.
Die Evaluierung macht deutlich, dass Passwörter ohne Sinn oder Struktur schwerer zu cracken sind. Die
Unterschiede in der Bewertung der Passwortstärke gingen hauptsächlich bei Passwörtern, die eins-zu-eins
im Wörterbuch oder eine verhältnismäßig große Basis im Wörterbuch gefunden wurde, auseinander.
In [6] werden ein paar Tipps aufgeführt, die bei der Wahl zu einem sicheren Passwort helfen sollen. Da
Passwörter mit Sinn oder Struktur leichter zu merken sind, werden solche Passwörter auf Grund ihrer Praktikabilität jedoch gern verwendet. Merksätze unterstützen dabei, sich leichter auf den ersten Blick sinnfrei
erscheinende Passwörter zu merken. Dazu benötigt man einen beliebigen Beispielsatz wie Ich kann mir
dieses Passwort unter keinen Umständen nicht einmal merken!. Falls ein Wort etwas mit einer Zahl zu tun
hat, wird diese auch als Zahl verwendet. Ansonsten wird von jedem Wort der Anfangsbuchstabe und das
Satzzeichen am Ende benutzt und zu einem Passwort zusammengesetzt. In diesem Beispiel würde das Passwort IkmdPukUn1m! lauten. Es muss dann im Nachhinein natürlich verglichen werden, ob dieses Passwort
wirklich keinen Sinn ergibt und auch genügend Zeichen enthält.
Außerdem ist dazu zu raten, für unterschiedliche Dienste unterschiedliche Zugangsdaten zu verwenden.
Angenommen ein Angreifer konnte beispielsweise einen E-Mail Account erfolgreich hacken und der Benutzer verwendet die identischen Zugangsdaten zu seinem Paypal Account. So besitzt der Angreifer auch
24
CHAPTER 6. FAZIT
ebenfalls Zugriff auf den Paypal Account, was zu einem großen finanziellen Schaden führen kann.
Daher ist die Sicherheit eines Passworts von großer Bedeutung, um sich präventiv gegen Angreifer zu
schützen.
25
Literaturverzeichnis
[1] Claude Castelluccia, Markus Dürmuth, and Daniele Perito. Adaptive password-strength meters from
markov models. In NDSS, 2012.
[2] M.Sc. Michael Gruhn Dr. Zinaida Benenson Daniel Günzel, Prof. Dr.-Ing. Felix Freiling. Analysis of
login credentials in keylogger dropzones. 2014.
[3] Matteo Dell’Amico, Pietro Michiardi, and Yves Roudier. Password strength: An empirical analysis.
In INFOCOM, 2010 Proceedings IEEE, pages 1–9. IEEE, 2010.
[4] Martin MA Devillers. Analyzing password strength. Radboud University Nijmegen, Tech. Rep, 2010.
[5] Dinei Florencio and Cormac Herley. A large-scale study of web password habits. In Proceedings of
the 16th international conference on World Wide Web, pages 657–666. ACM, 2007.
[6] Surfer haben Rechte. Website. URL http://www.surfer-haben-rechte.de/content/
tipps-und-tricks-fuer-sichere-passwoerter. Zuletzt besucht: 25.11.2014.
[7] Hashcat. Website, . URL http://hashcat.net/wiki/doku.php?id=start. Zuletzt besucht: 25.11.2014.
[8] Hashcat. Website, . URL http://hashcat.net/oclhashcat/. Zuletzt besucht: 25.11.2014.
[9] Idealo. Website, . URL http://www.idealo.de/preisvergleich/OffersOfProduct/
2962374_-xeon-x7550-intel.html. Zuletzt besucht: 25.11.2014.
[10] Idealo. Website, . URL http://www.idealo.de/preisvergleich/OffersOfProduct/
2356374_-core-i7-2600k-intel.html. Zuletzt besucht: 25.11.2014.
[11] Idealo. Website, . URL http://www.idealo.de/preisvergleich/OffersOfProduct/
3000732_-xeon-x7560-intel.html. Zuletzt besucht: 25.11.2014.
[12] Patrick Gage Kelley, Saranga Komanduri, Michelle L Mazurek, Richard Shay, Timothy Vidas, Lujo
Bauer, Nicolas Christin, Lorrie Faith Cranor, and Julio Lopez. Guess again (and again and again):
Measuring password strength by simulating password-cracking algorithms. In Security and Privacy
(SP), 2012 IEEE Symposium on, pages 523–537. IEEE, 2012.
[13] Online Password Strength Meter. Website. URL http://www.passwordmeter.com/. Zuletzt
besucht: 25.11.2014.
[14] OpenWall. Website, . URL http://www.openwall.com/john/doc/. Zuletzt besucht:
25.11.2014.
[15] OpenWall. Website, . URL http://openwall.info/wiki/john/benchmarks. Zuletzt
besucht: 25.11.2014.
[16] OpenWall.
Website, .
URL http://openwall.info/wiki/john/essays/
fast-and-slow-hashes. Zuletzt besucht: 25.11.2014.
[17] OpenWall. Website, . URL http://www.openwall.com/john/doc/MODES.shtml.
Zuletzt besucht: 25.11.2014.
[18] OpenWall.
Website, .
URL http://download.openwall.net/pub/wordlists/
passwords/. Zuletzt besucht: 25.11.2014.
[19] Benny Pinkas and Tomas Sander. Securing passwords against dictionary attacks. In Proceedings of
the 9th ACM conference on Computer and communications security, pages 161–170. ACM, 2002.
26
Literaturverzeichnis
[20] Robert W Proctor, Mei-Ching Lien, Kim-Phuong L Vu, E Eugene Schultz, and Gavriel Salvendy.
Improving computer security for authentication of users: Influence of proactive password restrictions.
Behavior Research Methods, Instruments, & Computers, 34(2):163–169, 2002.
[21] Python. Website.
25.11.2014.
URL https://docs.python.org/2/library/.
Zuletzt besucht:
[22] Riebartsch.
Website, 2013.
URL http://www.macwelt.de/ratgeber/
Bruteforce-Angriff-auf-die-Daten-7847259.html. Zuletzt besucht: 25.11.2014.
[23] Wikipedia. Website. URL http://de.wikipedia.org/wiki/American_Standard_
Code_for_Information_Interchange. Zuletzt besucht: 25.11.2014.
27