Éviter les pare-feu avec Nmap

Introduction

Dans ce laboratoire, vous apprendrez des techniques avancées de Nmap pour contourner les protections des pare-feu dans des scénarios réels de cybersécurité. Vous pratiquerez des méthodes d'évasion telles que le balayage fragmenté et l'usurpation d'adresse IP factice tout en travaillant avec des pare-feu configurés avec iptables.

Les exercices pratiques vous guideront à travers l'installation de Nmap, la configuration des règles de pare-feu et l'analyse des résultats. Vous acquerrez une expérience pratique dans l'évaluation et le contournement des mesures de sécurité réseau grâce à des expériences de balayage contrôlées.

Installer Nmap

Dans cette étape, vous allez installer Nmap, un puissant outil de balayage réseau utilisé pour l'audit de sécurité et l'exploration de réseau. Nmap permet d'identifier les hôtes et les services sur un réseau en envoyant des paquets et en analysant les réponses. Imaginez-le comme un cartographe numérique qui découvre quels appareils sont connectés à un réseau et quels services ils exécutent.

L'environnement de machine virtuelle (VM) LabEx a déjà les dépendances nécessaires installées, ce qui rend le processus d'installation simple. Suivez ces étapes pour installer Nmap :

Ouvrez le terminal dans votre VM LabEx (vous pouvez utiliser le terminal Xfce ou faire un clic droit sur le bureau et sélectionner "Ouvrir un terminal"). C'est dans le terminal que vous entrerez toutes les commandes pour ce laboratoire.
Tout d'abord, mettez à jour la liste des paquets pour vous assurer d'obtenir la dernière version. C'est comme rafraîchir une boutique d'applications avant de télécharger un nouveau logiciel :
```
sudo apt update
```
Installez Nmap en utilisant la commande suivante. Le paramètre -y confirme automatiquement toutes les invitations pendant l'installation :
```
sudo apt install -y nmap
```
Une fois l'installation terminée, vérifiez que Nmap est correctement installé en vérifiant sa version. Cela confirme que l'installation a réussi :
```
nmap --version
```
Vous devriez voir une sortie similaire à :
```
Nmap version 7.92 ( https://nmap.org )
```
Pour une vérification supplémentaire, exécutez un simple balayage sur l'hôte local (votre propre machine). Cela vous aide à comprendre le fonctionnement de Nmap avant de scanner d'autres cibles :
```
nmap -sV 127.0.0.1
```
Cette commande scanne votre machine locale (127.0.0.1) et affiche les ports ouverts (le paramètre -sV détecte les versions des services). Vous verrez une liste des services exécutés sur votre machine, ce qui est utile pour comprendre le format de sortie de Nmap.

Préparer une cible protégée par un pare-feu

Dans cette étape, vous allez configurer un simple pare-feu en utilisant iptables pour créer un environnement cible protégé pour vos tests de balayage Nmap. Les pare-feu agissent comme des barrières de sécurité qui contrôlent le trafic réseau, et comprendre comment scanner à travers eux est essentiel pour les professionnels de la sécurité réseau. Cette configuration simulera un scénario réel où le balayage réseau doit contourner les protections du pare-feu.

Tout d'abord, vérifions que iptables est disponible sur votre système. iptables est un programme utilitaire en espace utilisateur qui permet aux administrateurs de configurer les règles de pare-feu sous Linux. Il devrait être préinstallé dans la VM LabEx :
```
sudo iptables --version
```
Avant de créer de nouvelles règles, il est recommandé de supprimer toutes les règles de pare-feu existantes. Cela nous permet de partir d'une configuration vierge et d'éviter tout conflit avec les configurations précédentes :
```
sudo iptables -F
sudo iptables -X
```
Maintenant, nous allons définir les politiques par défaut. La politique par défaut détermine ce qui se passe aux paquets qui ne correspondent à aucune règle spécifique. Nous allons rejeter (DROP) tout le trafic entrant et transféré tout en autorisant les connexions sortantes :
```
sudo iptables -P INPUT DROP
sudo iptables -P FORWARD DROP
sudo iptables -P OUTPUT ACCEPT
```
Même avec des règles de pare-feu strictes, nous devons autoriser la communication sur l'hôte local (lo). De nombreux services système dépendent de la communication interne, donc cette exception est nécessaire :
```
sudo iptables -A INPUT -i lo -j ACCEPT
```
Créons des règles spécifiques pour simuler un serveur web protégé. Ces règles permettront le trafic entrant uniquement sur les ports standard pour SSH (22), HTTP (80) et HTTPS (443), imitant ainsi une configuration de serveur de production typique :
```
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT  ## SSH
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT  ## HTTP
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT ## HTTPS
```
Après avoir configuré les règles, il est important de les vérifier. Le paramètre -L liste toutes les règles, -n affiche la sortie numérique (plus rapide et évite les recherches DNS) et -v fournit des informations détaillées :
```
sudo iptables -L -n -v
```
Vous devriez voir une sortie montrant vos règles configurées avec la politique DROP par défaut pour le trafic non correspondant.
Enfin, nous allons enregistrer les règles pour qu'elles soient persistantes. Cette étape est particulièrement importante dans notre environnement LabEx car nous ne pouvons pas utiliser systemctl dans Docker pour maintenir les règles entre les redémarrages :
```
sudo sh -c "iptables-save > /etc/iptables.rules"
```

Exécuter un balayage fragmenté

Dans cette étape, vous allez apprendre à effectuer un balayage fragmenté en utilisant Nmap pour contourner les protections de base des pare-feu. Les pare-feu inspectent souvent les paquets réseau complets, mais la fragmentation divise les paquets en morceaux plus petits, les rendant plus difficiles à détecter par les règles simples de pare-feu qui ne réassemblent pas les fragments.

Tout d'abord, vérifiez que les règles de pare-feu de l'étape précédente sont toujours actives. Cela permet d'établir une référence avant de tester les techniques d'évasion :
```
sudo iptables -L -n -v
```
Effectuez un balayage SYN standard de Nmap sur l'hôte local pour voir comment le pare-feu répond sans aucune technique d'évasion. Cela nous montrera quels ports sont activement bloqués :
```
nmap -sS 127.0.0.1
```
Notez quels ports sont affichés comme filtrés ou fermés - ce sont ceux que le pare-feu protège.
Exécutez maintenant un balayage fragmenté en utilisant l'option -f. Cela indique à Nmap de diviser les en-têtes TCP en plusieurs paquets plus petits (fragments de 8 octets) :
```
nmap -f -sS 127.0.0.1
```
Certains pare-feu peuvent ne pas réassembler correctement ces fragments, permettant au balayage de passer à travers.
Pour une fragmentation plus agressive, utilisez des tailles de paquets plus petites avec l'option --mtu. Cela définit l'Unité Maximale de Transmission à 16 octets, créant des fragments encore plus petits :
```
nmap --mtu 16 -sS 127.0.0.1
```
Des fragments plus petits peuvent contourner des implémentations de pare-feu plus primitives.
Combinez la fragmentation avec le contrôle du timing pour plus de discrétion. L'option -T2 ralentit le balayage et le rend moins susceptible de déclencher les systèmes de détection d'intrusion :
```
nmap -f -T2 -sS 127.0.0.1
```
Cette approche imite des modèles de trafic réseau plus normaux.
Comparez les résultats des différents types de balayage pour évaluer l'efficacité de la fragmentation :
```
nmap -sS 127.0.0.1 | grep filtered
nmap -f -sS 127.0.0.1 | grep filtered
```
Remarquez les différences dans le nombre de ports filtrés - un nombre inférieur de ports filtrés indique une évasion réussie du pare-feu.

Ajouter des IP de ruse

Dans cette étape, vous allez apprendre à utiliser la technique de balayage avec des adresses de ruse (decoy) de Nmap pour masquer votre véritable adresse IP parmi plusieurs fausses adresses sources. Cela permet d'échapper à la détection en rendant plus difficile l'identification de la machine effectuant le balayage. Lorsque les systèmes de sécurité voient le trafic provenir de plusieurs adresses IP, ils ne peuvent pas facilement déterminer laquelle est le véritable scanner.

Tout d'abord, vérifiez votre adresse IP actuelle pour comprendre ce que nous allons cacher. Cela établit une référence afin que vous puissiez voir comment les adresses IP de ruse vont obscurcir votre véritable adresse :
```
ip a
```
Notez votre véritable adresse IP (généralement commençant par 172 ou 192). C'est l'adresse que nous allons cacher parmi les adresses de ruse.
Effectuez un balayage de base avec des adresses IP de ruse en utilisant l'option -D. Ici, nous spécifions trois adresses IP fausses et incluons notre véritable adresse IP avec le mot-clé ME :
```
sudo nmap -D 192.168.1.1,192.168.1.2,192.168.1.3,ME 127.0.0.1
```
Le mot-clé ME représente votre véritable adresse IP, qui sera mélangée avec les adresses de ruse.
Pour des adresses de ruse plus réalistes, utilisez des adresses IP aléatoires. Cela est souvent meilleur que d'utiliser des modèles d'adresses IP prévisibles :
```
sudo nmap -D RND:5 127.0.0.1
```
Cela génère 5 adresses IP de ruse aléatoires qui semblent plus naturelles pour les systèmes de surveillance.
Combinez les adresses de ruse avec les techniques d'évasion précédentes telles que la fragmentation (-f) et le contrôle du timing (-T2) :
```
sudo nmap -D 10.0.0.1,10.0.0.2,10.0.0.3 -f -T2 127.0.0.1
```
En combinant plusieurs méthodes d'évasion, la détection devient encore plus difficile.
Vérifiez l'effet des adresses de ruse en vérifiant les journaux du pare-feu (simulés). Cela montre comment le pare-feu voit plusieurs adresses IP sources :
```
sudo iptables -L -n -v | grep -E "192.168|10.0"
```
Vous devriez voir des entrées pour toutes les adresses IP de ruse que nous avons utilisées dans nos balayages.
Pour une utilisation avancée, spécifiez des réseaux de ruse. Cela crée une plage d'adresses de ruse provenant du même réseau :
```
sudo nmap -D 192.168.1.1-10 127.0.0.1
```
Cela génère 10 adresses IP de ruse séquentielles du réseau 192.168.1.0.

Vérifier le succès de l'évasion

Dans cette étape finale, vous allez évaluer l'efficacité de vos techniques d'évasion de balayage en analysant les journaux du pare-feu et en comparant les résultats des balayages obtenus avec différentes méthodes. Cela vous permet de comprendre quelles techniques ont réussi à contourner la détection du pare-feu et lesquelles ont été signalées comme des activités suspectes.

Tout d'abord, vérifiez les journaux actuels du pare-feu pour voir les tentatives de balayage détectées. Cela vous donne une référence de ce à quoi ressemble une activité normale du pare-feu avant de tester les méthodes d'évasion :
```
sudo iptables -L -n -v | grep -E "DROP|REJECT"
```
Cette commande montre combien de paquets ont été bloqués par vos règles de pare-feu, les compteurs indiquant les tentatives de détection.
Maintenant, créez deux rapports de balayage pour comparaison - l'un en utilisant un balayage de base et l'autre avec des techniques d'évasion. La différence entre ces deux rapports montrera l'efficacité de votre évasion :
```
nmap -sS 127.0.0.1 -oN basic_scan.txt
nmap -f -D RND:3 127.0.0.1 -oN evasion_scan.txt
```
La première commande effectue un balayage SYN standard, tandis que la deuxième utilise la fragmentation (-f) et des adresses IP de ruse (-D RND:3).
Analysez les différences entre les résultats des balayages pour voir quels ports ont été filtrés dans chaque cas :
```
diff basic_scan.txt evasion_scan.txt
```
Accordez une attention particulière au nombre de ports "filtrés" dans chaque rapport - un nombre inférieur de ports filtrés dans le balayage d'évasion indique une éviction réussie.
Pour vérifier spécifiquement la réussite de l'évasion, réinitialisez les compteurs du pare-feu et exécutez un balayage d'évasion tout en surveillant la détection :
```
sudo iptables -Z && sudo nmap -f -D RND:3 127.0.0.1 && sudo iptables -L -n -v
```
Les valeurs des compteurs montrent combien de paquets ont été détectés par le pare-feu lors de votre tentative d'évasion.
Pour des tests complets, combinez plusieurs techniques d'évasion pour maximiser vos chances de contourner la sécurité :
```
sudo nmap -f -D RND:5 -T2 --data-length 24 127.0.0.1 -oN final_scan.txt
```
Cela utilise la fragmentation, 5 adresses IP de ruse, un timing plus lent (-T2) et un remplissage de données aléatoire (--data-length 24).
Enfin, générez un rapport de synthèse comparant les ports filtrés entre le balayage de base et le balayage d'évasion :
```
echo "Basic scan filtered ports:" && grep filtered basic_scan.txt | wc -l
echo "Evasion scan filtered ports:" && grep filtered evasion_scan.txt | wc -l
```
Une réduction significative du nombre de ports filtrés entre les deux balayages démontre une éviction réussie du pare-feu.

Résumé

Dans ce laboratoire, vous avez appris les techniques essentielles d'évasion de pare-feu avec Nmap pour les évaluations de cybersécurité. Les exercices vous ont guidé à travers l'installation de Nmap, les balayages de base et la création d'un environnement de test contrôlé en utilisant iptables pour simuler des réseaux protégés.

Vous avez pratiqué deux méthodes d'évasion principales : la fragmentation de paquets pour contourner les systèmes de détection et l'utilisation d'adresses IP de ruse pour dissimuler l'origine des balayages. Ces compétences vous permettent d'évaluer les défenses réseau en reproduisant des modèles d'attaque réels tout en respectant les normes de test éthiques.