Phishing in SET simulieren

Einführung

In diesem Lab lernen Sie, wie Sie einen Phishing-Angriff mit dem Social Engineer Toolkit (SET) simulieren können, um Techniken zum Sammeln von Anmeldeinformationen zu verstehen. Sie üben das Installieren von SET, das Erstellen gefälschter Anmeldeseiten und das Erfassen von Anmeldeinformationen, um zu analysieren, wie Angreifer menschliche Schwachstellen ausnutzen.

Diese Übung demonstriert reale soziale Engineering-Methoden durch praktische Erfahrungen mit dem Klonen von Phishing-Seiten und der Überwachung von Anmeldeinformationen. Sie werden beobachten, wie leicht Benutzer täuscht werden können, um sensible Informationen auf gefälschten Websites preiszugeben.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL wireshark(("Wireshark")) -.-> wireshark/WiresharkGroup(["Wireshark"]) wireshark/WiresharkGroup -.-> wireshark/export_packets("Exporting Packets") wireshark/WiresharkGroup -.-> wireshark/packet_analysis("Packet Analysis") subgraph Lab Skills wireshark/export_packets -.-> lab-549949{{"Phishing in SET simulieren"}} wireshark/packet_analysis -.-> lab-549949{{"Phishing in SET simulieren"}} end

Installation des SocialEngineer Toolkit

In diesem Schritt installieren Sie das SocialEngineer Toolkit (SET), ein leistungsstarkes Open-Source-Penetration-Testing-Framework, das für soziale Engineering-Angriffe entwickelt wurde. SET bietet verschiedene Angriffsvektoren wie das Sammeln von Anmeldeinformationen, Phishing-Kampagnen und vieles mehr. Für Anfänger ist es wichtig zu verstehen, dass SET ein legitimes Sicherheitstool ist, das von Fachleuten zur Prüfung von Systemschwachstellen verwendet wird, nicht zu böswilligen Zwecken.

Stellen Sie zunächst sicher, dass Sie sich im Standardarbeitsverzeichnis befinden. Hier werden wir SET herunterladen und installieren, um Ihre Dateien organisiert zu halten:
```
cd ~/project
```
Klonen Sie das SET-Repository von GitHub. Dieser Befehl lädt die neueste Version von SET von seiner offiziellen Quelle herunter:
```
git clone https://github.com/trustedsec/social-engineer-toolkit.git
```
Navigieren Sie in das SET-Verzeichnis. Nach dem Herunterladen müssen wir in den Ordner wechseln, in dem SET installiert wurde:
```
cd social-engineer-toolkit
```
Installieren Sie SET mit dem Python-Installer. Der Befehl 'sudo' gibt uns die administrativen Rechte, die für die Installation erforderlich sind, während 'python3' sicherstellt, dass wir die richtige Python-Version verwenden:
```
sudo python3 setup.py install
```
Warten Sie, bis die Installation abgeschlossen ist. Dieser Vorgang kann einige Minuten dauern, da alle erforderlichen Komponenten installiert werden. Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
[*] Social Engineer Toolkit (SET) has been installed.
[*] You can now launch setoolkit by typing 'setoolkit' in your terminal.
```
Überprüfen Sie die Installation, indem Sie die SET-Version prüfen. Dies bestätigt, dass SET korrekt installiert wurde und zeigt, welche Version Sie verwenden:
```
setoolkit --version
```
Sie sollten eine Ausgabe sehen, die die installierte Versionsnummer anzeigt, was bedeutet, dass SET einsatzbereit ist.

Konfiguration einer Phishing-Seite

In diesem Schritt konfigurieren Sie eine Phishing-Seite mit dem Social Engineer Toolkit (SET), um einen Angriff zum Sammeln von Anmeldeinformationen zu simulieren. Phishing ist ein häufiger Cyberangriff, bei dem Angreifer gefälschte Anmeldeseiten erstellen, um Benutzeranmeldeinformationen zu stehlen. SET erleichtert es, zu demonstrieren, wie dies in einer kontrollierten Umgebung funktioniert.

Wir werden eine gefälschte Anmeldeseite erstellen, die einem beliebten Service nachempfunden ist. Diese geklonte Seite wird identisch mit der echten Website aussehen, aber alle eingegebenen Anmeldeinformationen werden von unserem System erfasst, anstatt an den legitimen Service gesendet zu werden.

Stellen Sie zunächst sicher, dass Sie sich im SET-Verzeichnis befinden. Hier ist das Toolkit auf Ihrem System installiert:
```
cd ~/project/social-engineer-toolkit
```
Starten Sie das SET-Toolkit mit Root-Rechten. SET benötigt administrative Zugriffsrechte, um Netzwerkeinstellungen und Web-Services zu konfigurieren:
```
sudo setoolkit
```
Navigieren Sie im SET-Menü durch die Angriffsoptionen:
- Wählen Sie 1) Social-Engineering Attacks - Dies ist die Hauptkategorie für Phishing-Angriffe
- Wählen Sie dann 2) Website Attack Vectors - Wir erstellen eine gefälschte Website
- Wählen Sie 3) Credential Harvester Attack Method - Wir zielen speziell auf Anmeldeinformationen ab
- Wählen Sie 2) Site Cloner - Wir kopieren das Design einer bestehenden Website
Wenn Sie zur Eingabe der IP-Adresse für die POST-Rückgabe aufgefordert werden, drücken Sie die Eingabetaste, um die Standardeinstellung (die IP-Adresse Ihrer virtuellen Maschine) zu verwenden. Hier werden die gestohlenen Anmeldeinformationen gesendet.
Geben Sie die URL ein, die geklont werden soll (wir verwenden eine Demoseite). Bei einem echten Angriff wäre dies die Zielwebsite, die Sie nachahmen:
```
https://example.com
```
SET wird die Seite klonen und den Phishing-Angriff konfigurieren. Der Klonierungsprozess kopiert das HTML, CSS und die Bilder der Website, um sie authentisch aussehen zu lassen. Sie sollten eine Ausgabe ähnlich der folgenden sehen:
```
[*] Cloning the website: https://example.com
[*] This could take a little bit...
[*] Files have been imported to the Apache web root.
```
Die Phishing-Seite ist jetzt konfiguriert und bereit, gehostet zu werden (was wir im nächsten Schritt tun werden). An diesem Punkt hat SET eine perfekte Kopie der Zielseite erstellt, die alle in ihr Anmeldeformular eingegebenen Anmeldeinformationen erfassen wird.

Hosting der gefälschten Seite

In diesem Schritt machen wir Ihre Phishing-Seite im Netzwerk verfügbar, indem wir sie mit dem Apache-Webserver hosten. Apache ist ein beliebter Webserver, der Ihre gefälschte Anmeldeseite an alle Personen liefert, die die IP-Adresse Ihrer virtuellen Maschine besuchen. So funktionieren reale Phishing-Angriffe – indem legitime Websites auf von Angreifern kontrollierten Servern nachgeahmt werden.

Zunächst müssen wir Apache installieren, wenn es noch nicht auf Ihrem System vorhanden ist. Führen Sie diesen Befehl aus, um Ihre Paketliste zu aktualisieren und Apache zu installieren:
```
sudo apt-get update && sudo apt-get install -y apache2
```
Die Option -y bestätigt die Installation automatisch, sodass Sie nicht manuell zustimmen müssen.
Überprüfen Sie nach der Installation, ob Apache läuft, mit:
```
sudo service apache2 status
```
Wenn der Dienst nicht läuft (was nach einer frischen Installation üblich ist), starten Sie ihn mit:
```
sudo service apache2 start
```
Das Social Engineer Toolkit (SET) speichert automatisch die Dateien Ihrer Phishing-Seite im Standard-Webverzeichnis von Apache. Lassen Sie uns überprüfen, ob diese Dateien existieren:
```
ls /var/www/html
```
Sie sollten index.html (die Haupt-Phishing-Seite) sowie andere Dateien sehen, die die Seite authentisch aussehen lassen, wie Bilder und Stylesheets von der geklonten Website.
Um anderen Personen den Zugang zu Ihrer Phishing-Seite zu ermöglichen, müssen Sie die IP-Adresse Ihrer virtuellen Maschine kennen. Finden Sie sie mit:
```
hostname -I
```
Notieren Sie sich diese IP-Adresse (wir bezeichnen sie als YOUR_VM_IP), da Sie sie benötigen, um die Phishing-Link zu testen und zu teilen.
Testen Sie die Seite lokal, bevor Sie sie teilen, um sicherzustellen, dass sie korrekt lädt:
```
curl http://localhost
```
Dieser Befehl ruft den Seiteninhalt ab. Sie sollten eine HTML-Ausgabe sehen, die mit Ihrer geklonten Seite übereinstimmt. Wenn Sie einen Fehler erhalten, läuft Apache möglicherweise nicht richtig.
Ihre Phishing-Seite ist jetzt live und unter folgender Adresse erreichbar:
```
http://YOUR_VM_IP
```
Jeder in Ihrem Netzwerk, der diese Adresse besucht, wird Ihre gefälschte Anmeldeseite sehen.
Lassen Sie Apache laufen – schließen Sie nicht das Terminal oder stoppen Sie den Dienst. In den nächsten Schritten werden wir diese gehostete Seite nutzen, um Anmeldeinformationen zu erfassen, wenn Opfer ihre Daten eingeben.

Erfassung von Anmeldeinformationen

In diesem Schritt lernen Sie, wie Phishing-Angriffe Anmeldeinformationen erfassen, indem Sie sowohl die Perspektive des Angreifers als auch die des Opfers simulieren. Wenn Opfer unbewusst ihre Daten auf gefälschten Anmeldeseiten (wie der von uns zuvor erstellten) eingeben, speichert SET diese sensiblen Informationen für den Angreifer.

Zunächst überprüfen wir, ob SET noch aus unserer vorherigen Einrichtung läuft. Wenn Sie es geschlossen haben oder die Sitzung abgelaufen ist, müssen wir das Tool neu starten. Dies stellt sicher, dass unser Phishing-Server aktiv ist und auf Verbindungen von Opfern wartet:
```
cd ~/project/social-engineer-toolkit
sudo setoolkit
```
Jetzt konfigurieren wir SET, um Anmeldeinformationen zu erfassen. Wählen Sie im SET-Hauptmenü nacheinander diese Optionen aus:
- 4) Create a Payload and Listener - Dies bereitet SET darauf vor, Daten zu empfangen
- 2) Website Attack Vectors - Wir konzentrieren uns auf webbasierte Angriffe
- 3) Credential Harvester Attack Method - Zielt speziell auf Anmeldeinformationen ab
- 1) Web Templates - Nutzt vorgefertigte Phishing-Seitenvorlagen
Lassen Sie dieses Terminalfenster geöffnet - SET überwacht jetzt aktiv den Netzwerkverkehr und wartet darauf, dass Opfer ihre Anmeldeinformationen über unsere gefälschte Anmeldeseite senden.
Simulieren wir nun die Aktion eines Opfers. Öffnen Sie einen neuen Terminal-Tab (Ctrl+Shift+T in den meisten Linux-Umgebungen) und verwenden Sie curl, um Test-Anmeldeinformationen an unseren lokalen Phishing-Server zu senden. Dies imitiert, was passiert, wenn jemand ein Anmeldeformular ausfüllt und absendet:
```
curl -X POST -d "username=testuser&password=Test123!" http://localhost
```
Überprüfen Sie sofort Ihr SET-Terminal. Sie sollten eine Bestätigung sehen, dass Anmeldeinformationen erfasst wurden, in folgendem klaren Format angezeigt:
```
[*] WE GOT A HIT!
Username: testuser
Password: Test123!
```
SET protokolliert automatisch alle erfassten Anmeldeinformationen für die spätere Überprüfung. Um das vollständige Angriffsprotokoll einschließlich unseres Test-Eintrags anzuzeigen, führen Sie aus:
```
sudo cat /var/lib/set/logs/set.log
```
Die Protokolldatei zeigt Ihre Test-Anmeldeinformationen zusammen mit der genauen Zeit an, zu der sie erfasst wurden. Bei realen Angriffen würde diese Datei alle im Laufe der Zeit erfolgreich phishen Anmeldeinformationen enthalten.

Überprüfung der erfassten Daten

Nachdem Sie die Phishing-Simulation abgeschlossen haben, lassen Sie uns die Ergebnisse untersuchen. Dieser letzte Schritt zeigt Ihnen, wie Sie auf die von Social Engineer Toolkit (SET) gesammelten Daten zugreifen und interpretieren können, sowie wie Sie Ihre Testumgebung ordnungsgemäß aufräumen, um die besten Sicherheitsverfahren einzuhalten.

Zunächst betrachten wir die vollständige SET-Protokolldatei, die alle erfassten Anmeldeinformationen im Rohformat enthält. Diese Datei wird an einem geschützten Systemort gespeichert, daher müssen wir sudo verwenden:
```
sudo cat /var/lib/set/logs/set.log
```
Dieser Befehl zeigt den Inhalt der Hauptprotokolldatei von SET an, in der alle erfassten Anmeldeinformationen während der Phishing-Simulation automatisch gespeichert werden.
Für eine bessere Organisation und zur späteren Referenz erstellen wir eine Arbeitskopie dieser Daten in Ihrem Projektverzeichnis. Wir ändern auch die Dateibesitzrechte auf Ihr Lab-Benutzerkonto:
```
cd ~/project
sudo cp /var/lib/set/logs/set.log captured_credentials.txt
sudo chown labex:labex captured_credentials.txt
```
Der chown-Befehl stellt sicher, dass Sie die richtigen Berechtigungen haben, um mit dieser Datei zu arbeiten, ohne sudo für nachfolgende Operationen benötigen zu müssen.
Jetzt betrachten wir den von uns gerade erstellten formatierten Bericht:
```
cat captured_credentials.txt
```
Sie sollten eine strukturierte Ausgabe ähnlich diesem Beispiel sehen, die die erfassten Anmeldeinformationen zusammen mit Zeitstempeln und Quellinformationen anzeigt:
```
[*] 2023-11-15 14:30:22 - Credentials captured:
Username: testuser
Password: Test123!
IP Address: 127.0.0.1
```
Es ist wichtig, Ihre Testumgebung nach Abschluss der Übung aufzuräumen. Dies entfernt die von uns erstellte Phishing-Seite und stoppt den Webserver:
```
sudo rm /var/www/html/index.html
sudo service apache2 stop
```
Diese Befehle stellen sicher, dass keine verbleibenden Testmaterialien übrig bleiben, die ein Sicherheitsrisiko darstellen könnten.
Schließlich dokumentieren wir unsere Ergebnisse, indem wir einen Zusammenfassungsbericht erstellen, der zählt, wie viele Anmeldeinformationen erfasst wurden:
```
echo "Phishing Test Results" > test_summary.txt
echo "Total credentials captured: $(grep -c 'Username' captured_credentials.txt)" >> test_summary.txt
cat test_summary.txt
```
Dies erstellt einen einfachen Bericht, der die Gesamtzahl der während Ihres Tests erfassten Anmeldeinformationspaare anzeigt. Der grep -c-Befehl zählt, wie oft 'Username' in Ihrer Datei mit den erfassten Daten vorkommt.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Phishing-Angriffe mit dem Social Engineer Toolkit (SET) simulieren können. Der Prozess umfasste die Installation von SET, die Konfiguration von Phishing-Seiten durch das Sammeln von Anmeldeinformationen und das Klonen von Ziel-Websites, um täuschende Anmeldeschnittstellen zu erstellen.

Diese Übung bot praktische Erfahrungen mit Penetrationstest-Tools und Social-Engineering-Techniken. Sie haben untersucht, wie Angreifer Anmeldeinformationen erfassen, und sind sich der Verteidigungsstrategien gegen solche Sicherheitsbedrohungen bewusst geworden.