Paketfälschung mit Scapy

Einführung

In diesem Lab lernen Sie, wie Sie Netzwerkpakete mit Scapy, einem leistungsstarken auf Python basierenden Paketmanipulationstool, fälschen können. Sie werden praktische Techniken zur Erstellung und zum Versand benutzerdefinierter TCP-Pakete untersuchen und die Ergebnisse mit Wireshark analysieren.

Das Lab umfasst essentielle Schritte wie die Installation von Scapy, die Einrichtung einer Python-Virtual Environment und Paketfälschungsoperationen. Durch praktische Übungen gewinnen Sie wertvolle Einblicke in die Manipulation von Netzwerkverkehr und Sicherheits-Testmethodologien.

Skills Graph

Scapy installieren

In diesem Schritt installieren Sie Scapy, ein leistungsstarkes auf Python basierendes interaktives Paketmanipulationstool, das für Netzwerkanalyse und Sicherheits-Tests verwendet wird. Scapy ermöglicht es Ihnen, Netzwerkpakete mit feingranularer Kontrolle zu erstellen, zu senden und zu erfassen. Stellen Sie sich Scapy wie ein Multitool für Netzwerkpakete vor - Sie können jeden beliebigen Typ von Netzwerkpaket erstellen, den Sie benötigen.

Bevor wir beginnen, stellen wir sicher, dass wir im richtigen Arbeitsverzeichnis sind. Das Verzeichnis ~/project ist der Ort, an dem wir alle unsere Arbeiten durchführen werden:

cd ~/project

Jetzt installieren wir Scapy mit dem Python-Paketmanager pip. Pip ist wie ein App-Store für Python-Pakete - es lädt Software aus dem Python Package Index (PyPI) herunter und installiert sie:

pip install scapy

Nach Abschluss der Installation ist es eine gute Praxis, zu überprüfen, ob alles korrekt installiert wurde. Wir tun dies, indem wir die Versionsnummer von Scapy überprüfen. Dies bestätigt sowohl, dass Scapy installiert ist, als auch, dass Python es erfolgreich importieren kann:

python -c "import scapy; print(scapy.__version__)"

Sie sollten eine Ausgabe ähnlich dieser sehen (Ihre Versionsnummer kann etwas abweichen):

2.4.5

Schließlich testen wir den interaktiven Modus von Scapy. Dies ist wie ein Spielplatz, auf dem Sie mit der Paketerstellung experimentieren können, bevor Sie vollständige Skripte schreiben. Um in die interaktive Shell zu gelangen:

python -m scapy

Sie wissen, dass es funktioniert, wenn Sie die Befehlseingabeaufforderung von Scapy (>>>) sehen. Sie können exit() eingeben, wenn Sie bereit sind, die interaktive Shell zu verlassen. Sorgen Sie sich nicht darum, sie jetzt zu erkunden - wir werden die interaktiven Funktionen in späteren Schritten behandeln.

Einrichten einer Python-Umgebung

In diesem Schritt erstellen Sie einen dedizierten Arbeitsbereich für Ihre Scapy-Experimente mithilfe von Python's virtueller Umgebung. Stellen Sie sich das wie das Einrichten eines Reinraums vor, in dem Sie arbeiten können, ohne andere Projekte auf Ihrem Computer zu beeinflussen. Virtuelle Umgebungen helfen bei der Verwaltung von Paketversionen und verhindern Konflikte zwischen verschiedenen Python-Projekten.

Zunächst stellen wir sicher, dass wir am richtigen Ort beginnen. Dieser Befehl navigiert in das Standard-Arbeitsverzeichnis, in dem wir unser Projekt einrichten werden:
```
cd ~/project
```
Jetzt erstellen wir die virtuelle Umgebung mit dem Namen scapy-env. Dies erstellt einen neuen Ordner, der alle erforderlichen Python-Dateien für eine isolierte Umgebung enthält:
```
python -m venv scapy-env
```
Um unsere neue Umgebung zu verwenden, müssen wir sie aktivieren. Wenn die Umgebung aktiv ist, sehen Sie (scapy-env) am Anfang Ihrer Terminal-Eingabeaufforderung, was Sie daran erinnert, in welcher Umgebung Sie arbeiten:
```
source scapy-env/bin/activate
```
Auch wenn Scapy möglicherweise bereits auf Ihrem System installiert ist, installieren wir es speziell für diese Umgebung. Dies stellt sicher, dass wir die genaue Version haben, die wir für dieses Projekt benötigen:
```
pip install scapy
```
Lassen Sie uns überprüfen, ob alles korrekt eingerichtet ist. Dieser Befehl zeigt alle in unserer virtuellen Umgebung installierten Python-Pakete an. Sie sollten scapy in der Liste sehen, was bestätigt, dass es zur Verwendung bereit ist:
```
pip list
```
Wenn Sie mit der Arbeit fertig sind (führen Sie diesen Befehl jetzt jedoch nicht aus, da wir die Umgebung in den nächsten Schritten verwenden werden), können Sie die virtuelle Umgebung deaktivieren, um zur normalen System-Python-Umgebung zurückzukehren:
```
deactivate
```

Erstellen eines TCP-Pakets

In diesem Schritt verwenden Sie Scapy, um ein einfaches TCP-Paket zu erstellen. Das Verständnis, wie man Netzwerkpakete konstruiert, ist für die Netzwerkanalyse und Sicherheits-Tests unerlässlich. Wir werden ein TCP-Paket Schicht für Schicht aufbauen, was der Funktionsweise der realen Netzwerkkommunikation nachempfunden ist.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden und Ihre virtuelle Umgebung aktiviert ist. Die virtuelle Umgebung hält Ihre Python-Pakete isoliert:
```
cd ~/project
source scapy-env/bin/activate
```
Erstellen Sie ein neues Python-Skript mit dem Namen craft_tcp.py. Wir verwenden den nano-Texteditor, aber Sie können jeden Editor verwenden, den Sie bevorzugen:
```
nano craft_tcp.py
```
Fügen Sie den folgenden Code hinzu, um ein einfaches TCP-Paket zu erstellen. Lassen Sie uns analysieren, was jeder Teil macht:
- Die IP-Schicht definiert Quell- und Zieladressen.
- Die TCP-Schicht gibt Ports und Verbindungsflags an (in diesem Fall SYN).
- Der /-Operator kombiniert diese Schichten zu einem vollständigen Paket.
```
from scapy.all import *

## Create IP layer
ip = IP(src="192.168.1.100", dst="192.168.1.1")

## Create TCP layer
tcp = TCP(sport=1234, dport=80, flags="S")  ## SYN packet

## Combine layers to create packet
packet = ip/tcp

## Display packet details
packet.show()
```
Speichern Sie die Datei (Ctrl+O, Enter, Ctrl+X in nano) und führen Sie sie aus. Die Methode .show() zeigt die Paketstruktur an:
```
python craft_tcp.py
```

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die alle Paketfelder anzeigt. Beachten Sie, wie Scapy automatisch einige Werte ausfüllt, während andere None bleiben (sie werden beim Senden berechnet):

###[ IP ]###
  version= 4
  ihl= None
  tos= 0x0
  len= None
  id= 1
  flags=
  frag= 0
  ttl= 64
  proto= tcp
  chksum= None
  src= 192.168.1.100
  dst= 192.168.1.1
  \options\
###[ TCP ]###
     sport= 1234
     dport= http
     seq= 0
     ack= 0
     dataofs= None
     reserved= 0
     flags= S
     window= 8192
     chksum= None
     urgptr= 0
     options= []

Senden von gefälschten Paketen

In diesem Schritt werden Sie Ihr TCP-Paket-Skript so ändern, dass es gefälschte Pakete mit einer gefälschten Quell-IP-Adresse sendet. Dies zeigt, wie Angreifer ihre Herkunft in der Netzwerkkommunikation verschleiern können. IP-Spoofing (Adressfälschung) ist eine gängige Technik, bei der der Absender absichtlich die Quelladresse in IP-Paketen fälscht, um seine Identität zu verbergen oder ein anderes System zu imitieren.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden und Ihre virtuelle Umgebung aktiviert ist. Die virtuelle Umgebung hält Ihre Python-Pakete für dieses Projekt isoliert:
```
cd ~/project
source scapy-env/bin/activate
```
Erstellen Sie ein neues Python-Skript mit dem Namen send_spoofed.py. Wir verwenden den nano-Texteditor, der für Anfänger einfach zu bedienen ist:
```
nano send_spoofed.py
```

Fügen Sie den folgenden Code hinzu, um gefälschte TCP-Pakete zu senden. Der Code generiert zufällige IP-Adressen aus privaten Adressbereichen (192.168.x.x und 10.x.x.x), die für Tests sicher sind. Das TCP-Paket wird an Google's DNS-Server (8.8.8.8) auf Port 53 mit dem SYN-Flag gesetzt gesendet:

from scapy.all import *
import random

## Spoofed source IP (using private IP range)
spoofed_ip = f"192.168.{random.randint(1,254)}.{random.randint(1,254)}"

## Create and send packet
packet = IP(src=spoofed_ip, dst="8.8.8.8")/TCP(dport=53, flags="S")
send(packet, verbose=False)

print(f"Sent spoofed TCP packet from {spoofed_ip} to 8.8.8.8")

Speichern Sie die Datei (Ctrl+O, Enter, Ctrl+X in nano) und führen Sie sie aus. Das Skript wird ein gefälschtes Paket generieren und senden:
```
python send_spoofed.py
```
Sie sollten eine Ausgabe ähnlich der folgenden sehen, die die generierte gefälschte Quell-IP anzeigt:
```
Sent spoofed TCP packet from 192.168.45.123 to 8.8.8.8
```

Um mehrere Pakete zu senden und verschiedene gefälschte IP-Adressen in Aktion zu sehen, ändern Sie das Skript, um eine Schleife einzufügen. Dies sendet 3 Pakete mit verschiedenen zufälligen Quell-IP-Adressen aus dem 10.x.x.x-Bereich:

for i in range(3):
    spoofed_ip = f"10.0.{random.randint(1,254)}.{random.randint(1,254)}"
    packet = IP(src=spoofed_ip, dst="8.8.8.8")/TCP(dport=53, flags="S")
    send(packet, verbose=False)
    print(f"Sent packet {i+1} from {spoofed_ip}")

Mit Wireshark überprüfen

In diesem Schritt verwenden Sie Wireshark, um die gefälschten Pakete zu überprüfen, die Sie im vorherigen Schritt gesendet haben. Wireshark ist ein leistungsstarker Netzwerkprotokoll-Analyzer, der es Ihnen ermöglicht, Netzwerkverkehr in Echtzeit zu erfassen und zu untersuchen. Dieser Überprüfungsprozess ist von entscheidender Bedeutung, da er Ihnen hilft zu bestätigen, ob Ihre gefälschten Pakete tatsächlich mit den modifizierten Quell-IP-Adressen im Netzwerk übertragen werden.

Stellen Sie zunächst sicher, dass Sie sich im richtigen Verzeichnis befinden und Ihre virtuelle Umgebung aktiviert ist. Die virtuelle Umgebung enthält alle erforderlichen Python-Pakete für dieses Lab:
```
cd ~/project
source scapy-env/bin/activate
```
Installieren Sie Wireshark in der LabEx-VM. Wireshark ist nicht vorinstalliert, daher müssen wir es zuerst installieren:
```
sudo apt-get update
sudo apt-get install -y wireshark
```
Starten Sie Wireshark im Hintergrund. Das '&'-Symbol ermöglicht es Ihnen, das Terminal weiterhin zu verwenden, während Wireshark läuft:
```
wireshark &
```
In der Wireshark-Schnittstelle:
- Wählen Sie die aktive Netzwerkschnittstelle aus (normalerweise eth0) – dies repräsentiert Ihre Netzwerkverbindung.
- Starten Sie die Paketerfassung, indem Sie auf das Hai-Fin-Symbol klicken – damit beginnt die Aufzeichnung des gesamten Netzwerkverkehrs.
- Legen Sie einen Anzeigefilter fest: tcp.port == 53 – dieser Filter zeigt nur TCP-Verkehr auf Port 53 (DNS-Port) an.
Führen Sie in einem separaten Terminal erneut Ihr Skript zum Senden von gefälschten Paketen aus. Dadurch wird neuer Verkehr erzeugt, den Wireshark erfassen kann:
```
python send_spoofed.py
```
Beobachten Sie die Ergebnisse in Wireshark:
- Sie sollten TCP-SYN-Pakete an Port 53 sehen – dies sind die Verbindungsinitialisierungspakete.
- Überprüfen Sie, ob die Quell-IP-Adressen mit Ihren gefälschten IPs übereinstimmen – damit bestätigen Sie, dass die Adressfälschung funktioniert hat.
- Beachten Sie die TCP-Handshake-Versuche (SYN-Pakete) – diese zeigen die Verbindungsversuche an.
Um die Erfassung für eine spätere Analyse zu speichern:
- Klicken Sie auf Datei → Speichern.
- Speichern Sie die Datei als spoofed_capture.pcap in ~/project – PCAP-Dateien enthalten die Rohdaten der Pakete für die spätere Referenz.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie Scapy in einer isolierten Python-Virtuellen Umgebung installieren und konfigurieren, um Netzwerkpakete zu manipulieren. Der Prozess umfasste die Einrichtung der Umgebung, die Installation von Scapy und die Überprüfung seiner Funktionalität durch Versionsprüfungen und interaktive Tests.

Sie haben auch praktische Erfahrungen in der Erstellung von TCP-Paketen, dem Senden von gefälschten Paketen zur Simulation von Netzwerkverkehr und der Analyse der Ergebnisse mit Wireshark gesammelt. Diese Fähigkeiten bilden die Grundlage für Netzwerksicherheitstests und Techniken zur Paketmanipulation.