Utiliser Nmap pour détecter et contourner les restrictions de pare-feu

NmapBeginner
Pratiquer maintenant

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser Nmap pour détecter et contourner les restrictions des pare - feux dans le domaine de la sécurité réseau. Les pare - feux sont des éléments de sécurité essentiels qui filtrent le trafic réseau selon des règles prédéfinies. En tant que professionnel de la sécurité, il est crucial de comprendre comment contourner les pare - feux pour effectuer des évaluations de sécurité complètes et identifier les vulnérabilités.

Nous explorerons diverses techniques de contournement de pare - feux avec Nmap, un puissant outil de numérisation (scanning) réseau. Ces techniques permettent aux experts en sécurité de tester les défenses réseau en imitant les tentatives potentielles des attaquants pour contourner les mesures de sécurité. À la fin de ce laboratoire, vous aurez acquis une expérience pratique des fonctionnalités de contournement de pare - feux de Nmap et comprendrez leurs applications dans la sécurité réseau.

Configuration d'un service local pour le scan

Avant de pouvoir commencer à pratiquer les techniques de numérisation avec Nmap, il est essentiel d'avoir un service cible à numériser. Imaginez - le comme avoir une cible sur un terrain de tir. Dans cette étape, nous allons créer un simple serveur HTTP sur notre machine locale. Ce serveur servira de cible pour tous nos exercices de numérisation.

Tout d'abord, nous devons ouvrir un terminal. Un terminal est comme un centre de commandes où nous pouvons donner des instructions à notre ordinateur. Une fois le terminal ouvert, nous allons créer une structure de répertoires pour notre service HTTP. Un répertoire est similaire à un dossier sur votre ordinateur, et il nous aide à organiser nos fichiers.

mkdir -p /home/labex/project/http_service

La commande mkdir signifie "make directory" (créer un répertoire). L'option -p garantit que si des répertoires intermédiaires dans le chemin n'existent pas, ils seront créés. Ainsi, cette commande crée un répertoire nommé http_service à l'intérieur du chemin /home/labex/project.

Ensuite, nous devons nous déplacer dans le répertoire nouvellement créé. Tout comme vous ouvrirez un dossier sur votre ordinateur pour accéder à son contenu, nous utilisons la commande cd pour nous déplacer dans le répertoire.

cd /home/labex/project/http_service

Maintenant, nous allons créer un simple fichier HTML. HTML est le langage utilisé pour créer des pages web. Notre serveur HTTP servira ce fichier HTML à quiconque le demande.

echo "<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>" > index.html

La commande echo affiche le texte entre guillemets. Le symbole > redirige cette sortie dans un fichier nommé index.html. Ainsi, cette commande crée un fichier nommé index.html avec le contenu HTML de base spécifié.

Pour nous assurer que le fichier a été créé correctement, nous pouvons afficher son contenu. Nous utilisons la commande cat à cette fin.

cat index.html

La commande cat lit le contenu d'un fichier et l'affiche sur le terminal. Vous devriez voir le contenu HTML que nous venons de créer :

<html><body><h1>Welcome to the StarPath Exploration Server</h1></body></html>

Maintenant, il est temps de démarrer un simple serveur HTTP. Nous allons utiliser le module intégré http.server de Python. Python est un langage de programmation, et ce module nous permet de configurer rapidement un serveur web.

python3 -m http.server 8000

L'option -m en Python est utilisée pour exécuter un module en tant que script. Ici, nous exécutons le module http.server et nous lui demandons d'écouter sur le port 8000. Un port est comme une porte par laquelle les données entrent et sortent d'un ordinateur.

Après avoir exécuté cette commande, vous devriez voir une sortie similaire à :

Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Cette sortie indique que le serveur HTTP est en cours d'exécution et qu'il attend des connexions sur le port 8000. Il est important de laisser cette fenêtre de terminal ouverte car si vous la fermez, le serveur cessera de fonctionner.

Vous avez configuré avec succès un service local. Dans les étapes suivantes, nous utiliserons ce service comme cible pour nos exercices de numérisation avec Nmap.

Scan Nmap de base avec contournement de la découverte d'hôte

Dans cette étape, nous allons effectuer notre toute première numérisation avec Nmap. Mais avant de commencer, comprenons un concept clé. De nombreux pare - feux sont configurés pour bloquer les requêtes d'écho ICMP, communément connues sous le nom de "ping". Nmap utilise généralement ces requêtes ping pour vérifier si un hôte est en ligne avant de commencer à numériser les ports. Cependant, en contournant cette phase de découverte d'hôtes, nous pouvons toujours numériser les cibles même lorsque le trafic ICMP est bloqué par le pare - feu.

Tout d'abord, assurez - vous de laisser le serveur HTTP en cours d'exécution dans le terminal précédent. Ensuite, ouvrez une nouvelle fenêtre de terminal. Dans ce nouveau terminal, nous devons nous déplacer dans le répertoire du projet. Le répertoire du projet est l'endroit où tous nos fichiers et configurations pertinents pour cette expérience sont stockés. Pour ce faire, nous utiliserons la commande cd, qui signifie "change directory" (changer de répertoire). Voici la commande :

cd /home/labex/project

Maintenant que nous sommes dans le bon répertoire, il est temps d'exécuter une numérisation Nmap de base sur notre serveur HTTP local. Nous utiliserons l'option -Pn dans la commande Nmap. Cette option indique à Nmap de sauter l'étape de découverte d'hôtes et de supposer que la cible est en ligne. Voici la commande :

nmap -Pn --reason -p 8000 localhost

Décortiquons les options de la commande pour comprendre ce que chaque option fait :

  • -Pn : Cette option saute le processus de découverte d'hôtes. Au lieu de vérifier si la cible est en ligne en utilisant le ping, Nmap supposera directement que la cible est en ligne et commencera à numériser les ports.
  • --reason : Cette option demande à Nmap d'afficher la raison pour laquelle un port est dans un état particulier. Par exemple, si un port est ouvert, il nous dira pourquoi il est considéré comme ouvert.
  • -p 8000 : Cette option indique à Nmap de numériser uniquement le port 8000. Nous sommes intéressés par ce port spécifique car notre serveur HTTP local s'exécute sur ce port.
  • localhost : C'est la cible que nous voulons numériser. Dans ce cas, localhost fait référence à notre machine locale.

Après avoir exécuté la commande, vous devriez voir une sortie similaire à celle - ci :

Starting Nmap 7.80 ( https://nmap.org ) at 2023-09-05 15:30 UTC
Nmap scan report for localhost (127.0.0.1)
Host is up, received localhost-response (0.000097s latency).

PORT     STATE SERVICE      REASON
8000/tcp open  http-alt     syn-ack

Nmap done: 1 IP address (1 host up) scanned in 0.03 seconds

La sortie montre que le port 8000 est ouvert et exécute un service HTTP. La colonne "REASON" indique "syn - ack", ce qui signifie que lorsque Nmap a essayé de se connecter au port, le port a répondu avec un paquet SYN - ACK. C'est un moyen standard pour un serveur d'accepter une demande de connexion dans le protocole TCP.

Ensuite, nous voulons enregistrer les résultats de la numérisation dans un fichier. Enregistrer les résultats est utile car cela nous permet de les analyser plus tard, de les partager avec d'autres personnes ou de les comparer avec des numérisations futures. Pour enregistrer les résultats, nous utiliserons le symbole >, qui redirige la sortie de la commande Nmap vers un fichier. Voici la commande :

nmap -Pn --reason -p 8000 localhost > /home/labex/project/nmap_scan.txt

Enfin, vérifions les résultats de la numérisation enregistrés. Nous utiliserons la commande cat, qui signifie "concatenate" (concaténer). Cette commande lit le contenu d'un fichier et l'affiche dans le terminal. Voici la commande :

cat /home/labex/project/nmap_scan.txt

Vous devriez voir les mêmes résultats de numérisation qui ont été précédemment affichés dans le terminal.

Cette numérisation de base nous montre comment l'option -Pn peut être utilisée pour contourner les règles de pare - feu qui bloquent les sondes ping. Dans une situation réelle, cette technique peut être très utile lorsque vous avez besoin de numériser des hôtes protégés par des pare - feux qui bloquent le trafic ICMP.

Évasion avancée de pare-feu avec fragmentation de paquets

Dans cette étape, nous allons explorer une technique plus avancée d'évasion des pare - feux appelée fragmentation de paquets. Avant de plonger dans le sujet, comprenons ce que signifie la fragmentation de paquets. Lorsque des données sont envoyées sur un réseau, elles sont divisées en unités plus petites appelées paquets. Certains pare - feux et systèmes de détection d'intrusion (Intrusion Detection Systems - IDS) sont conçus pour inspecter ces paquets à la recherche de tout signe d'activité malveillante. Cependant, ces systèmes de sécurité peuvent avoir des difficultés à traiter les paquets fragmentés, qui sont des paquets qui ont été divisés en morceaux encore plus petits. Cette difficulté peut nous offrir une opportunité de contourner certaines mesures de sécurité lors de nos numérisations.

Nous continuerons à utiliser notre serveur HTTP local comme cible pour notre numérisation. Tout d'abord, nous devons nous déplacer dans le répertoire approprié dans le terminal où nous avons effectué notre numérisation précédente. C'est dans ce répertoire que se trouvent nos fichiers de projet, et il est important d'être dans ce répertoire pour que nos commandes fonctionnent correctement. Pour ce faire, nous exécuterons la commande suivante :

cd /home/labex/project

Maintenant que nous sommes dans le bon répertoire, nous sommes prêts à exécuter une numérisation en utilisant l'option de fragmentation de Nmap. Cette option va diviser les paquets IP en fragments plus petits, rendant plus difficile la détection de notre numérisation par les filtres de paquets. Voici la commande que nous allons utiliser :

sudo nmap -f -Pn --reason -p 8000 localhost

Décortiquons l'option supplémentaire -f dans cette commande. L'option -f indique à Nmap de fragmenter les paquets IP. En faisant cela, nous rendons plus difficile l'analyse des paquets par les filtres de paquets et la détection de notre numérisation.

Après avoir exécuté la commande, vous devriez voir une sortie similaire à la suivante :

Starting Nmap 7.80 ( https://nmap.org ) at 2025-03-18 16:46 CST
Nmap scan report for localhost (127.0.0.1)
Host is up, received user-set (0.000062s latency).
Other addresses for localhost (not scanned): ::1

PORT     STATE SERVICE  REASON
8000/tcp open  http-alt syn-ack ttl 64

Nmap done: 1 IP address (1 host up) scanned in 0.08 seconds

Cette sortie nous montre les résultats de notre numérisation. Elle nous indique que l'hôte (localhost) est en ligne et que le port 8000 est ouvert.

Ensuite, nous voulons enregistrer ces résultats dans un fichier séparé. Ainsi, nous pourrons y faire référence plus tard et les comparer avec d'autres résultats de numérisation. Pour enregistrer les résultats, nous exécuterons la commande suivante :

sudo nmap -f -Pn --reason -p 8000 localhost > /home/labex/project/nmap_frag_scan.txt

Le symbole > dans cette commande redirige la sortie de la numérisation Nmap vers le fichier spécifié.

Maintenant, vérifions le contenu de ce fichier pour nous assurer que les résultats ont été enregistrés correctement. Nous utiliserons la commande cat, qui est utilisée pour afficher le contenu d'un fichier :

cat /home/labex/project/nmap_frag_scan.txt

Les résultats de la numérisation peuvent ressembler à ceux de notre numérisation précédente, mais la technique sous - jacente est différente. Dans ce cas, Nmap a fragmenté les paquets IP en morceaux plus petits, ce qui rend plus difficile la détection de la numérisation par les filtres de paquets sans état.

Comparons les deux méthodes de numérisation que nous avons utilisées jusqu'à présent : la numérisation classique et la numérisation fragmentée. Nous allons créer un nouveau fichier pour stocker cette comparaison. Voici les commandes pour cela :

echo "Comparing regular scan vs. fragmented scan:" > /home/labex/project/scan_comparison.txt
echo "---------------------------------------------" >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "1. Regular scan with -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_scan.txt >> /home/labex/project/scan_comparison.txt
echo "" >> /home/labex/project/scan_comparison.txt
echo "2. Fragmented scan with -f -Pn:" >> /home/labex/project/scan_comparison.txt
cat /home/labex/project/nmap_frag_scan.txt >> /home/labex/project/scan_comparison.txt

Ces commandes écrivent d'abord un en - tête dans le fichier de comparaison, puis ajoutent les résultats de la numérisation classique et de la numérisation fragmentée au fichier.

Maintenant, examinons notre comparaison en affichant le contenu du fichier de comparaison :

cat /home/labex/project/scan_comparison.txt

Dans notre environnement contrôlé, les résultats des deux numérisations peuvent ressembler. Cependant, dans des scénarios réels, ces différentes techniques peuvent avoir des niveaux de réussite variables en fonction des configurations de pare - feux. La fragmentation de paquets (-f) est particulièrement efficace contre les filtres de paquets sans état. Les filtres de paquets sans état examinent chaque paquet indépendamment et ne peuvent souvent pas réassembler les fragments pour inspecter le paquet complet, ce qui donne à notre numérisation fragmentée de meilleures chances de contourner ces filtres.

Pour encore plus de fragmentation, Nmap vous permet d'augmenter le niveau en utilisant plusieurs indicateurs -f (par exemple, -ff) ou en spécifiant une taille de Unité Maximale de Transmission (Maximum Transmission Unit - MTU) personnalisée avec l'option --mtu. L'MTU est la taille maximale d'un paquet qui peut être transmis sur un réseau. En spécifiant une MTU personnalisée, vous pouvez contrôler la façon dont les paquets sont fragmentés.

Cette technique démontre comment la fragmentation de paquets peut être utilisée comme méthode supplémentaire pour éviter la détection par les pare - feux lors de l'exécution d'évaluations de sécurité.

Résumé

Dans ce laboratoire, vous avez appris à identifier et à contourner les restrictions des pare - feux en utilisant les techniques d'évasion des pare - feux de Nmap. Tout d'abord, vous avez configuré un serveur HTTP local comme cible pour la numérisation, créant ainsi un environnement sûr pour pratiquer différentes méthodes de numérisation sans avoir d'impact sur les systèmes externes. Ensuite, vous avez effectué une numérisation Nmap de base avec l'option -Pn pour contourner la découverte d'hôtes, ce qui est utile lorsque les pare - feux bloquent les requêtes d'écho ICMP. Cela vous a permis de numériser les ports qui pourraient être masqués derrière les règles de pare - feu.

Ensuite, vous avez exploré une technique d'évasion avancée : la fragmentation de paquets en utilisant l'option -f. Cette méthode fragmente les paquets IP, rendant plus difficile la détection et le blocage de la numérisation par les filtres de paquets sans état. En comparant les résultats des deux techniques, vous avez compris leurs différences et leurs applications. Ces techniques sont essentielles pour les professionnels de la sécurité afin de réaliser des évaluations de sécurité approfondies. Cependant, n'oubliez pas de les utiliser uniquement dans le cadre d'évaluations autorisées avec les autorisations appropriées pour éviter de violer les lois et les politiques.