ZIP-Passwörter mit John the Ripper knacken

Einführung

In diesem Lab werden Sie lernen, passwortgeschützte ZIP-Dateien mit John the Ripper zu knacken, einem essentiellen Cybersicherheitstool für Penetrationstests. Sie üben das Extrahieren von Hashes aus ZIP-Dateien und das Durchführen sowohl von Wörterbuch- als auch von Brute-Force-Angriffen, um Passwörter wiederherzustellen.

Das Lab bietet praktische Erfahrungen bei der Installation von John the Ripper, der Erstellung von Testdateien mit schwachen Passwörtern und der Überprüfung der geknackten Zugangsdaten. Durch diese Übung werden Sie die Schwachstellen von schwachen Passwörtern und die Wichtigkeit einer starken Verschlüsselung bei der Dateisicherheit verstehen.

Skills Graph

Installation von John the Ripper

In diesem Schritt werden Sie John the Ripper installieren, ein leistungsstarkes Passwortknackungstool, das in der Cybersicherheit weit verbreitet ist. Bevor wir beginnen, verstehen wir zunächst, was John the Ripper kann: Es hilft Sicherheitsfachleuten, die Stärke von Passwörtern zu testen, indem es verschiedene Kombinationen versucht (Brute-Force) oder Wortlisten verwendet (Wörterbuchangriffe), um Passwörter zu erraten.

Die LabEx VM-Umgebung ist bereits mit allen erforderlichen Abhängigkeiten vorkonfiguriert, was die Installation unkompliziert macht. Wir verwenden Ubuntu's Paketmanager (apt), der Softwareinstallation und -updates verwaltet.

Zunächst müssen wir die Paketliste aktualisieren. Dadurch wird sichergestellt, dass Ihr System über die neuesten verfügbaren Versionen aller Software informiert ist:
```
sudo apt update
```
Der Befehl sudo gibt Ihnen Administratorrechte, während apt update die Liste der verfügbaren Pakete aktualisiert.
Installieren Sie nun John the Ripper mit diesem Befehl:
```
sudo apt install john -y
```
Die Option -y bestätigt die Installation automatisch, sodass Sie nicht während des Prozesses 'yes' eingeben müssen.
Nachdem die Installation abgeschlossen ist, überprüfen wir, ob alles korrekt funktioniert, indem wir die installierte Version prüfen:
```
john --version
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
John the Ripper 1.9.0-jumbo-1
```

Dieser Versionscheck bestätigt, dass John the Ripper zur Verwendung bereit ist. In den folgenden Schritten werden wir dieses Tool nutzen, um zu zeigen, wie passwortgeschützte ZIP-Dateien anfällig für Knackversuche sein können. Stellen Sie sicher, dass Sie die Versionsnummer sehen, bevor Sie fortfahren, da dies auf eine erfolgreiche Installation hinweist.

Erstellen einer passwortgeschützten ZIP-Datei

In diesem Schritt werden Sie eine passwortgeschützte ZIP-Datei erstellen, die wir in den folgenden Schritten zum Üben des Passwortknackens verwenden werden. ZIP ist ein gängiges Archivformat, das Passwortschutz unterstützt, um sensible Dateien zu sichern. Das Verständnis, wie man geschützte ZIP-Dateien erstellt, ist grundlegend, da viele reale Systeme diese Methode zur Dateisicherheit nutzen.

Zunächst erstellen wir eine Beispiel-Text-Datei, die wir schützen möchten. Wir verwenden eine einfache Text-Datei zu Demonstrationszwecken:
```
echo "This is a secret file" > secret.txt
```
Dieser Befehl erstellt eine neue Datei namens secret.txt, die den Text "This is a secret file" enthält. Das >-Symbol leitet die Ausgabe des echo-Befehls in die Datei um.
Jetzt erstellen wir eine passwortgeschützte ZIP-Datei mit dem zip-Hilfsprogramm. Die Option -e aktiviert die Verschlüsselung. Wir verwenden "password123" als Beispielpasswort zu Lernzwecken (beachten Sie, dass dies ein schwaches Passwort ist und niemals in realen Szenarien verwendet werden sollte):
```
zip -e secret.zip secret.txt
```
Der Befehl fordert Sie zweimal auf, das Passwort einzugeben und zu bestätigen. Diese doppelte Eingabe hilft, Tippfehler im Passwort zu vermeiden:
```
Enter password:
Verify password:
```
Überprüfen wir, ob die ZIP-Datei erfolgreich erstellt wurde. Der Befehl ls -l zeigt detaillierte Informationen zu den Dateien im aktuellen Verzeichnis an:
```
ls -l secret.zip
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen, die zeigt, dass die Datei existiert und ihre Größe/Zeitstempel anzeigt:
```
-rw-r--r-- 1 labex labex 210 May 10 10:00 secret.zip
```
Abschließend testen wir den Passwortschutz, indem wir versuchen, die Datei ohne Angabe des Passworts zu extrahieren. Dies bestätigt, dass unsere ZIP-Datei ordnungsgemäß gesichert ist:
```
unzip secret.zip
```
Das System sollte Sie nach dem Passwort fragen und einen Fehler anzeigen, wenn Sie entweder das falsche Passwort eingeben oder den Vorgang abbrechen.

Diese geschützte ZIP-Datei wird in den nächsten Schritten als Testfall dienen, in denen wir ihren Hash extrahieren und versuchen, das Passwort mit John the Ripper zu knacken. Das Erstellen dieser Testdatei selbst hilft Ihnen, beide Seiten des Sicherheitsvorgangs zu verstehen - wie der Schutz angewendet wird und wie er getestet werden kann.

Extrahieren des ZIP-Hashes

In diesem Schritt werden Sie den kryptografischen Hash aus der passwortgeschützten ZIP-Datei extrahieren, die wir zuvor erstellt haben. Dieser Prozess wandelt die Sicherheitsinformationen der ZIP-Datei in ein Format um, das John the Ripper verstehen und für das Passwortknacken verarbeiten kann.

Zunächst navigieren wir in unser Arbeitsverzeichnis und überprüfen, ob die ZIP-Datei existiert. Dies stellt sicher, dass wir mit der richtigen Datei am richtigen Ort arbeiten:
```
cd ~/project
ls secret.zip
```
Jetzt verwenden wir John the Ripper's spezielles Tool namens zip2john. Dieses Hilfsprogramm extrahiert den Passwort-Hash aus ZIP-Dateien in einem Format, das John knacken kann. Das >-Symbol leitet die Ausgabe in eine neue Datei um:
```
zip2john secret.zip > zip_hash.txt
```
Sehen wir uns den extrahierten Hash an, um zu verstehen, welche Informationen erfasst wurden. Der cat-Befehl zeigt den Dateiinhalt im Terminal an:
```
cat zip_hash.txt
```
Sie sollten eine Ausgabe ähnlich diesem Beispiel sehen (Ihr tatsächlicher Hash wird unterschiedlich sein):
```
secret.zip:$pkzip$1*2*2*0*1c*1a*5e9b8f7d*0*42*0*1c*5e9b*55dc*secret.txt*$/pkzip$
```
Der Hash enthält mehrere wichtige Komponenten:
- secret.zip: Der ursprüngliche Name der ZIP-Datei
- $pkzip$ : Identifiziert dies als einen PKZIP-Format-Hash
- Die lange Zeichenkette aus Zahlen und Buchstaben: Die eigentlichen verschlüsselten Passwortdaten
- secret.txt: Der Name der Datei innerhalb des ZIP-Archivs

Diese extrahierte Hash-Datei enthält nun alle erforderlichen Informationen über den Passwortschutz der ZIP-Datei, speziell für die Verarbeitung durch John the Ripper formatiert. Im nächsten Schritt werden wir diese Hash-Datei nutzen, um über verschiedene Knackmethoden die Passwortwiederherstellung zu versuchen.

John ausführen, um das Passwort zu knacken

In diesem Schritt werden Sie John the Ripper verwenden, um zu versuchen, das Passwort für die ZIP-Datei zu knacken, die wir zuvor geschützt haben. John ist ein leistungsstarkes Passwortknackungstool, das arbeitet, indem es verschiedene Passwortkombinationen gegen den von uns extrahierten Hash testet. Der Hash ist wie ein digitaler Fingerabdruck Ihres Passworts, den John analysieren kann, ohne die ursprüngliche ZIP-Datei zu benötigen.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis mit der Hash-Datei befinden. Dies ist wichtig, da John auf die Hash-Datei zugreifen muss, die wir im vorherigen Schritt erstellt haben:
```
cd ~/project
ls zip_hash.txt
```
Der ls-Befehl listet einfach die Dateien auf, um zu bestätigen, dass zip_hash.txt in Ihrem aktuellen Verzeichnis existiert.
Jetzt führen wir John the Ripper aus und geben das PKZIP-Format an, da wir mit einer ZIP-Datei arbeiten. Die Option --format=PKZIP teilt John mit, welche Art von Verschlüsselung er erwarten soll:
```
john --format=PKZIP zip_hash.txt
```
John zeigt den Fortschritt in Echtzeit an, während er verschiedene Passwortkombinationen testet. In unserem Fall, da wir ein schwaches Passwort ("password123") verwendet haben, sollte die Knackung fast sofort abgeschlossen sein. So sieht die erfolgreiche Ausgabe aus:
```
Loaded 1 password hash (PKZIP [32/64])
Will run 2 OpenMP threads
Press 'q' or Ctrl-C to abort, almost any other key for status
password123      (secret.zip)
1g 0:00:00:00 DONE (2023-05-10 10:00) 50.00g/s 50.00p/s 50.00c/s 50.00C/s password123
Use the "--show" option to display all of the cracked passwords reliably
Session completed
```
Das "1g" zeigt an, dass John 1 Vermutung getestet hat, und "password123" ist das geknackte Passwort.
Um das geknackte Passwort in einem übersichtlichen Format anzuzeigen, verwenden wir die Option --show. Dieser Befehl zeigt alle erfolgreich geknackten Passwörter aus der Hash-Datei an:
```
john --show zip_hash.txt
```
Sie werden eine Ausgabe wie diese sehen:
```
secret.zip:password123:secret.txt:secret.zip
```
Diese Ausgabe zeigt vier Informationen, getrennt durch Doppelpunkte: den Namen der ZIP-Datei, das geknackte Passwort, die Datei im Archiv und den Namen des Archivs erneut.

Jetzt, da wir das Passwort haben, können wir im nächsten Schritt fortfahren und überprüfen, ob es tatsächlich mit unserer ursprünglichen ZIP-Datei funktioniert. Diese Überprüfung ist von entscheidender Bedeutung, da sie bestätigt, dass unser Knackprozess erfolgreich war.

Das Passwort bestätigen

In diesem letzten Schritt werden Sie überprüfen, ob das von John the Ripper geknackte Passwort tatsächlich funktioniert, um die geschützte ZIP-Datei zu extrahieren. Dieser Bestätigungsschritt ist in realen Sicherheitsbewertungen von entscheidender Bedeutung, um die Ergebnisse des Knackens zu validieren. Stellen Sie sich vor, Sie hätten einen Schlüssel gefunden - Sie müssen die Tür tatsächlich öffnen, um zu bestätigen, dass er funktioniert.

Zunächst überprüfen wir das geknackte Passwort aus dem vorherigen Schritt. Der folgende Befehl zeigt die von John erfolgreich geknackten Passwörter an:
```
john --show zip_hash.txt
```
Sie sollten eine Ausgabe ähnlich dieser sehen, die den Dateinamen, das geknackte Passwort und den Inhalt anzeigt:
```
secret.zip:password123:secret.txt:secret.zip
```
Jetzt testen wir, ob dieses Passwort tatsächlich funktioniert, indem wir versuchen, die ZIP-Datei zu extrahieren. Der unzip-Befehl ist das Standardtool zum Extrahieren von ZIP-Archiven unter Linux:
```
unzip secret.zip
```
Das System wird Sie nach dem Passwort fragen. Geben Sie "password123" ein (das Passwort, das wir gerade geknackt haben):
```
Archive:  secret.zip
[secret.zip] secret.txt password:
```
Nachdem Sie das richtige Passwort eingegeben haben, sollten wir zwei Dinge überprüfen: dass die Datei extrahiert wurde und dass ihr Inhalt mit dem übereinstimmt, was wir erwarten. Diese Befehle listen die Dateien im Verzeichnis auf und zeigen den Inhalt der geheimen Datei an:
```
ls
cat secret.txt
```
Sie sollten Folgendes sehen, was die erfolgreiche Extraktion bestätigt:
```
This is a secret file
```
Abschließend ist es eine gute Praxis, die extrahierten Dateien zu löschen, wenn Sie mit dem Test fertig sind. Dies hält Ihren Arbeitsbereich ordentlich und verhindert, dass Testdateien versehentlich in zukünftigen Übungen wiederverwendet werden:
```
rm secret.txt
```

Diese erfolgreiche Extraktion bestätigt, dass John the Ripper das ZIP-Passwort korrekt geknackt hat. In einer realen Sicherheitsbewertung ist dieser Überprüfungsschritt unerlässlich, bevor die Ergebnisse gemeldet werden. Es beweist, dass das geknackte Passwort nicht nur theoretisch passt, sondern tatsächlich Zugang zum geschützten Inhalt gewährt.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie John the Ripper über den apt-Paketmanager installieren und die erfolgreiche Einrichtung überprüfen können. Sie haben auch gelernt, wie Sie eine mit einem Passwort geschützte ZIP-Datei mit einer Beispieltext-Datei erstellen, um reale Passwortknackungsszenarien zu simulieren.

Diese Übung hat Ihnen grundlegende Techniken der Cybersicherheitsbewertung vermittelt, indem sie gezeigt hat, wie man eine Ziel-Datei für die Passwortknackung vorbereitet. Diese ersten Schritte, einschließlich der Tool-Installation und der Sicherheitsüberprüfung, bilden die wesentliche Grundlage für fortgeschrittene Passwortwiederherstellungsoperationen.