Falsifier des paquets avec Scapy

Introduction

Dans ce laboratoire (lab), vous apprendrez à falsifier (spoof) des paquets réseau à l'aide de Scapy, un puissant outil de manipulation de paquets basé sur Python. Vous explorerez des techniques pratiques pour créer et envoyer des paquets TCP personnalisés tout en analysant les résultats avec Wireshark.

Le laboratoire couvre les étapes essentielles telles que l'installation de Scapy, la configuration d'un environnement virtuel Python et les opérations de falsification de paquets. Grâce à des exercices pratiques, vous acquerrez des connaissances précieuses sur la manipulation du trafic réseau et les méthodologies de test de sécurité.

Skills Graph

Installer Scapy

Dans cette étape, vous allez installer Scapy, un puissant outil interactif de manipulation de paquets basé sur Python, utilisé pour l'analyse réseau et les tests de sécurité. Scapy vous permet de créer, d'envoyer et de capturer des paquets réseau avec un contrôle précis. Imaginez-le comme un canif suisse pour les paquets réseau - vous pouvez construire n'importe quel type de paquet réseau dont vous avez besoin.

Avant de commencer, assurons-nous que nous sommes dans le bon répertoire de travail. Le répertoire ~/project est là où nous allons effectuer tout notre travail :

cd ~/project

Maintenant, nous allons installer Scapy à l'aide du gestionnaire de paquets Python, pip. Pip est comme une boutique d'applications pour les paquets Python - il télécharge et installe des logiciels depuis l'Index des Paquets Python (Python Package Index, PyPI) :

pip install scapy

Une fois l'installation terminée, il est recommandé de vérifier que tout a été installé correctement. Nous allons le faire en vérifiant le numéro de version de Scapy. Cela confirme à la fois que Scapy est installé et que Python peut l'importer avec succès :

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

Vous devriez voir une sortie similaire à celle-ci (votre numéro de version peut être légèrement différent) :

2.4.5

Enfin, testons le mode interactif de Scapy. C'est comme une aire de jeux où vous pouvez expérimenter la création de paquets avant d'écrire des scripts complets. Pour entrer dans le shell interactif :

python -m scapy

Vous saurez que cela fonctionne lorsque vous verrez l'invite de commande de Scapy (>>>). Vous pouvez taper exit() lorsque vous êtes prêt à quitter le shell interactif. Ne vous inquiétez pas de l'explorer maintenant - nous aborderons les fonctionnalités interactives dans les étapes suivantes.

Configurer un environnement Python

Dans cette étape, vous allez créer un espace de travail dédié pour vos expériences avec Scapy en utilisant l'environnement virtuel de Python. Imaginez cela comme la création d'une salle blanche où vous pouvez travailler sans affecter les autres projets sur votre ordinateur. Les environnements virtuels aident à gérer les versions des paquets et à éviter les conflits entre différents projets Python.

Tout d'abord, assurons-nous de partir du bon emplacement. Cette commande vous amène dans le répertoire de travail par défaut où nous allons configurer notre projet :
```
cd ~/project
```
Maintenant, nous allons créer l'environnement virtuel nommé scapy-env. Cela crée un nouveau dossier contenant tous les fichiers Python nécessaires pour un environnement isolé :
```
python -m venv scapy-env
```
Pour commencer à utiliser notre nouvel environnement, nous devons l'activer. Lorsqu'il est activé, vous verrez (scapy-env) au début de l'invite de votre terminal, vous rappelant dans quel environnement vous travaillez :
```
source scapy-env/bin/activate
```
Même si Scapy peut déjà être installé sur votre système, nous allons l'installer spécifiquement pour cet environnement. Cela garantit que nous avons exactement la version dont nous avons besoin pour ce projet :
```
pip install scapy
```
Vérifions que tout est correctement configuré. Cette commande affiche tous les paquets Python installés dans notre environnement virtuel. Vous devriez voir scapy dans la liste, confirmant qu'il est prêt à être utilisé :
```
pip list
```
Lorsque vous avez terminé de travailler (mais ne l'exécutez pas maintenant car nous allons utiliser l'environnement dans les étapes suivantes), vous pouvez désactiver l'environnement virtuel pour revenir à la version Python normale de votre système :
```
deactivate
```

Créer un paquet TCP

Dans cette étape, vous utiliserez Scapy pour créer un paquet TCP de base. Comprendre comment construire des paquets réseau est essentiel pour l'analyse réseau et les tests de sécurité. Nous allons construire un paquet TCP couche par couche, ce qui imite le fonctionnement de la communication réseau réelle.

Tout d'abord, assurez-vous d'être dans le bon répertoire et que votre environnement virtuel est activé. L'environnement virtuel permet d'isoler vos paquets Python :
```
cd ~/project
source scapy-env/bin/activate
```
Créez un nouveau script Python nommé craft_tcp.py. Nous utiliserons l'éditeur de texte nano, mais vous pouvez utiliser n'importe quel éditeur que vous préférez :
```
nano craft_tcp.py
```
Ajoutez le code suivant pour créer un simple paquet TCP. Décortiquons ce que chaque partie fait :
- La couche IP définit les adresses source et de destination.
- La couche TCP spécifie les ports et les indicateurs de connexion (SYN dans ce cas).
- L'opérateur / combine ces couches pour former un paquet complet.
```
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()
```
Enregistrez le fichier (Ctrl+O, Entrée, Ctrl+X dans nano) et exécutez-le. La méthode .show() affichera la structure du paquet :
```
python craft_tcp.py
```

Vous devriez voir une sortie similaire à celle-ci, affichant tous les champs du paquet. Remarquez comment Scapy remplit automatiquement certaines valeurs tandis que d'autres restent à None (elles seront calculées lors de l'envoi) :

###[ 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= []

Envoyer des paquets falsifiés

Dans cette étape, vous allez modifier votre script de paquet TCP pour envoyer des paquets falsifiés avec une adresse IP source fausse. Cela démontre comment les attaquants peuvent masquer leur origine dans les communications réseau. Le spoofing (falsification d'adresse) est une technique courante où l'émetteur falsifie intentionnellement l'adresse source dans les paquets IP pour dissimuler son identité ou imiter un autre système.

Tout d'abord, assurez-vous d'être dans le bon répertoire et que votre environnement virtuel est activé. L'environnement virtuel isole vos paquets Python pour ce projet :
```
cd ~/project
source scapy-env/bin/activate
```
Créez un nouveau script Python nommé send_spoofed.py. Nous utiliserons l'éditeur de texte nano, qui est simple pour les débutants :
```
nano send_spoofed.py
```

Ajoutez le code suivant pour envoyer des paquets TCP falsifiés. Le code génère des adresses IP aléatoires dans les plages privées (192.168.x.x et 10.x.x.x), qui sont sûres pour les tests. Le paquet TCP est envoyé au serveur DNS de Google (8.8.8.8) sur le port 53 avec le drapeau SYN activé :

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")

Enregistrez le fichier (Ctrl+O, Entrée, Ctrl+X dans nano) et exécutez-le. Le script générera et enverra un paquet falsifié :
```
python send_spoofed.py
```
Vous devriez voir une sortie similaire à celle-ci, montrant l'adresse IP source fausse qui a été générée :
```
Sent spoofed TCP packet from 192.168.45.123 to 8.8.8.8
```

Pour envoyer plusieurs paquets et voir différentes adresses IP falsifiées en action, modifiez le script pour inclure une boucle. Cela envoie 3 paquets avec différentes adresses IP source aléatoires de la plage 10.x.x.x :

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}")

Vérifier avec Wireshark

Dans cette étape, vous utiliserez Wireshark pour vérifier les paquets falsifiés que vous avez envoyés à l'étape précédente. Wireshark est un puissant analyseur de protocoles réseau qui vous permet de capturer et d'inspecter le trafic réseau en temps réel. Ce processus de vérification est crucial car il vous aide à confirmer si vos paquets falsifiés sont réellement transmis sur le réseau avec les adresses IP source modifiées.

Tout d'abord, assurez-vous d'être dans le bon répertoire et que votre environnement virtuel est activé. L'environnement virtuel contient tous les paquets Python nécessaires pour ce laboratoire :
```
cd ~/project
source scapy-env/bin/activate
```
Installez Wireshark dans la machine virtuelle LabEx. Wireshark n'est pas préinstallé, donc nous devons l'installer d'abord :
```
sudo apt-get update
sudo apt-get install -y wireshark
```
Démarrez Wireshark en arrière-plan. Le symbole '&' vous permet de continuer à utiliser le terminal tandis que Wireshark s'exécute :
```
wireshark &
```
Dans l'interface de Wireshark :
- Sélectionnez l'interface réseau active (généralement eth0) - cela représente votre connexion réseau
- Démarrez la capture de paquets en cliquant sur l'icône de requin - cela commence l'enregistrement de tout le trafic réseau
- Appliquez un filtre d'affichage : tcp.port == 53 - cela filtre la vue pour n'afficher que le trafic TCP sur le port 53 (port DNS)
Dans un terminal séparé, exécutez à nouveau votre script de paquets falsifiés. Cela génère un nouveau trafic pour Wireshark à capturer :
```
python send_spoofed.py
```
Observez les résultats dans Wireshark :
- Vous devriez voir des paquets TCP SYN vers le port 53 - ce sont les paquets d'initiation de connexion
- Vérifiez que les adresses IP source correspondent à vos adresses IP falsifiées - confirmant que le spoofing a fonctionné
- Notez les tentatives d'établissement de la main - courante TCP (paquets SYN) - cela montre les tentatives de connexion
Pour enregistrer la capture pour une analyse ultérieure :
- Cliquez sur Fichier → Enregistrer
- Enregistrez sous spoofed_capture.pcap dans ~/project - les fichiers PCAP contiennent les données brutes des paquets pour référence future

Résumé

Dans ce laboratoire, vous avez appris à installer et configurer Scapy pour la manipulation de paquets réseau dans un environnement virtuel Python isolé. Le processus a inclus la configuration de l'environnement, l'installation de Scapy et la vérification de sa fonctionnalité grâce à des vérifications de version et des tests interactifs.

Vous avez également acquis une expérience pratique dans la création de paquets TCP, l'envoi de paquets falsifiés pour simuler le trafic réseau et l'analyse des résultats à l'aide de Wireshark. Ces compétences constituent une base pour les tests de sécurité réseau et les techniques de manipulation de paquets.