Dépannage des analyses Nmap

Introduction

Dans ce laboratoire, vous allez apprendre à résoudre les problèmes de balayage Nmap en utilisant des techniques de traçage de paquets et de débogage. Le laboratoire vous guide dans l'exécution de balayages Nmap avec l'option --packet-trace pour observer les paquets réseau, en activant le niveau de débogage 2 avec -d2, et en combinant le traçage et le débogage.

Vous allez également apprendre à enregistrer la sortie de traçage dans un fichier à l'aide de -oN et à analyser les détails des paquets dans le terminal Xfce pour identifier les problèmes de balayage. Le laboratoire utilise des commandes telles que nmap --packet-trace 192.168.1.1, nmap -d2 127.0.0.1 et nmap --packet-trace -oN trace.txt 127.0.0.1 pour fournir une expérience pratique dans le diagnostic des problèmes de balayage Nmap.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/output_formats("Output Formats") nmap/NmapGroup -.-> nmap/save_output("Save Output to File") nmap/NmapGroup -.-> nmap/port_scanning("Port Scanning Methods") nmap/NmapGroup -.-> nmap/target_specification("Target Specification") nmap/NmapGroup -.-> nmap/verbosity("Verbosity Levels") nmap/NmapGroup -.-> nmap/service_detection("Service Detection") nmap/NmapGroup -.-> nmap/stealth_scanning("Stealth and Covert Scanning") subgraph Lab Skills nmap/output_formats -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/save_output -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/port_scanning -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/target_specification -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/verbosity -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/service_detection -.-> lab-547117{{"Dépannage des analyses Nmap"}} nmap/stealth_scanning -.-> lab-547117{{"Dépannage des analyses Nmap"}} end

Exécuter un balayage avec traçage de paquets à l'aide de nmap --packet-trace 192.168.1.1

Dans cette étape, nous allons utiliser l'option --packet-trace avec Nmap pour observer les paquets envoyés et reçus pendant un balayage. Il s'agit d'un outil de débogage puissant qui vous permet de comprendre exactement ce que fait Nmap au niveau réseau.

Avant de commencer, parlons brièvement de ce qu'est le traçage de paquets. Le traçage de paquets consiste à capturer et à analyser les paquets réseau pour comprendre la communication entre deux ou plusieurs dispositifs. L'option --packet-trace de Nmap fournit un moyen simplifié de visualiser directement ces paquets depuis Nmap.

Pour effectuer un balayage avec traçage de paquets, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Exécuter la commande Nmap : Dans le terminal, tapez la commande suivante et appuyez sur Entrée :
```
sudo nmap --packet-trace 192.168.1.1
```
- sudo : Cette commande nécessite des privilèges root pour capturer les paquets réseau.
- nmap : C'est le scanner Nmap en ligne de commande.
- --packet-trace : Cette option indique à Nmap d'imprimer une trace des paquets qu'il envoie et reçoit.
- 192.168.1.1 : C'est l'adresse IP cible. Si cette adresse IP n'est pas disponible sur votre réseau, vous pouvez la remplacer par l'adresse IP d'un dispositif accessible depuis votre VM LabEx. Une alternative commune est 127.0.0.1 (localhost).
Observer la sortie : Nmap effectuera maintenant un balayage de l'adresse IP cible et imprimera des informations détaillées sur chaque paquet envoyé et reçu. La sortie montrera le type de paquet (par exemple, SYN, ACK), les adresses IP source et destination et les ports, ainsi que d'autres informations pertinentes.

La sortie ressemblera à ceci (la sortie exacte variera selon votre réseau et l'hôte cible) :
```
Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-27 10:00 UTC
SENT (0.0034s) to 192.168.1.1: TCP 192.168.1.100:54321 > 192.168.1.1:80 S ttl=64 id=12345 win=65535
RECV (0.0045s) from 192.168.1.1: TCP 192.168.1.1:80 > 192.168.1.100:54321 SA ttl=64 id=67890 win=14600
SENT (0.0045s) to 192.168.1.1: TCP 192.168.1.100:54321 > 192.168.1.1:80 A ttl=64 id=12346 win=65535
...
Nmap done: 1 IP address (1 host up) scanned in 0.123 seconds
```
Chaque ligne représente un paquet. SENT indique un paquet envoyé par Nmap, et RECV indique un paquet reçu par Nmap. Les informations suivantes SENT ou RECV décrivent le protocole du paquet (TCP), les adresses IP source et destination et les ports, les drapeaux (S pour SYN, A pour ACK, SA pour SYN-ACK), le TTL (Time To Live), l'ID et la taille de fenêtre.
Interrompre le balayage : Le balayage continuera quelques instants. Vous pouvez l'interrompre en appuyant sur Ctrl+C.

Cette étape a montré comment utiliser l'option --packet-trace pour avoir une vue des activités réseau de Nmap. Dans les étapes suivantes, nous explorerons d'autres options et techniques de débogage.

Activer le niveau de débogage 2 avec nmap -d2 127.0.0.1

Dans cette étape, nous allons activer le niveau de débogage 2 dans Nmap. La sortie de débogage fournit des informations détaillées sur les opérations internes de Nmap, ce qui peut être utile pour comprendre comment Nmap fonctionne et résoudre les problèmes.

Les niveaux de débogage de Nmap vont de 1 à 9. Les niveaux plus élevés fournissent une sortie plus détaillée. Pour cette étape, nous utiliserons le niveau de débogage 2, qui offre un bon compromis entre le détail et la lisibilité.

Pour activer le niveau de débogage 2, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Exécuter la commande Nmap : Dans le terminal, tapez la commande suivante et appuyez sur Entrée :
```
sudo nmap -d2 127.0.0.1
```
- sudo : Cette commande peut nécessiter des privilèges root selon le type de balayage.
- nmap : C'est le scanner Nmap en ligne de commande.
- -d2 : Cette option définit le niveau de débogage sur 2.
- 127.0.0.1 : C'est l'adresse IP cible, qui est l'adresse de bouclage (localhost).
Observer la sortie : Nmap effectuera maintenant un balayage de localhost et imprimera des informations de débogage dans le terminal. La sortie inclura des détails sur la configuration de Nmap, les sondes qu'il envoie et les réponses qu'il reçoit.

La sortie ressemblera à ceci (la sortie exacte variera) :
```
Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-27 10:05 UTC
--------------- Timing report ---------------
  hostgroups: min 1, max 1024
  rtt-timeouts: init 1250, min 100, max 10000
  max-scan-delay: 0 ms, brtt 1250 ms, rttvar 625 ms
  parallelism: min 1, max 256
---------------------------------------------
...
Nmap done: 1 IP address (1 host up) scanned in 0.123 seconds
```
La sortie montre divers paramètres internes et décisions prises par Nmap pendant le balayage. Ce niveau de détail peut être utile pour comprendre comment Nmap fonctionne et pour diagnostiquer les problèmes.
Interrompre le balayage : Le balayage continuera quelques instants. Vous pouvez l'interrompre en appuyant sur Ctrl+C.

Cette étape a montré comment activer le niveau de débogage 2 dans Nmap. Dans l'étape suivante, nous allons combiner le traçage de paquets et la sortie de débogage pour une analyse encore plus détaillée.

Combiner le traçage et le débogage avec nmap --packet-trace -d 192.168.1.1

Dans cette étape, nous allons combiner les options --packet-trace et -d pour avoir une vue globale de l'opération de Nmap. Cela fournira à la fois des détails au niveau des paquets et des informations de débogage internes, ce qui peut être très utile pour le dépannage avancé et la compréhension du comportement de Nmap.

Pour combiner le traçage de paquets et le débogage, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Exécuter la commande Nmap : Dans le terminal, tapez la commande suivante et appuyez sur Entrée :
```
sudo nmap --packet-trace -d 192.168.1.1
```
- sudo : Cette commande nécessite des privilèges root pour capturer les paquets réseau.
- nmap : C'est le scanner Nmap en ligne de commande.
- --packet-trace : Cette option indique à Nmap d'imprimer une trace des paquets qu'il envoie et reçoit.
- -d : Cette option active la sortie de débogage. Par défaut, elle définit le niveau de débogage sur 1. Vous pouvez utiliser -d2, -d3, etc., pour augmenter le niveau de débogage. Dans ce cas, nous utilisons le niveau 1 par défaut.
- 192.168.1.1 : C'est l'adresse IP cible. Si cette adresse IP n'est pas disponible sur votre réseau, vous pouvez la remplacer par l'adresse IP d'un dispositif accessible depuis votre VM LabEx. Une alternative commune est 127.0.0.1 (localhost).
Observer la sortie : Nmap effectuera maintenant un balayage de l'adresse IP cible et imprimera à la fois les traces de paquets et les informations de débogage dans le terminal. La sortie sera un mélange de détails de paquets (comme vu dans l'étape 1) et de messages internes de Nmap (comme vu dans l'étape 2).

La sortie ressemblera à ceci (la sortie exacte variera selon votre réseau et l'hôte cible) :
```
Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-27 10:10 UTC
SENT (0.0034s) to 192.168.1.1: TCP 192.168.1.100:54321 > 192.168.1.1:80 S ttl=64 id=12345 win=65535
RECV (0.0045s) from 192.168.1.1: TCP 192.168.1.1:80 > 192.168.1.100:54321 SA ttl=64 id=67890 win=14600
NSE: Using Lua engine for script processing.
SENT (0.0045s) to 192.168.1.1: TCP 192.168.1.100:54321 > 192.168.1.1:80 A ttl=64 id=12346 win=65535
...
Nmap done: 1 IP address (1 host up) scanned in 0.123 seconds
```
Vous verrez les lignes SENT et RECV entrelacées avec des messages de débogage comme NSE: Using Lua engine for script processing..
Interrompre le balayage : Le balayage continuera quelques instants. Vous pouvez l'interrompre en appuyant sur Ctrl+C.

Cette étape a montré comment combiner le traçage de paquets et la sortie de débogage dans Nmap. Cette combinaison fournit un outil puissant pour la compréhension et le dépannage des balayages Nmap.

Sauvegarder la sortie de traçage avec nmap --packet-trace -oN trace.txt 127.0.0.1

Dans cette étape, nous allons sauvegarder la sortie du traçage de paquets dans un fichier pour une analyse ultérieure. Cela est utile lorsque vous voulez examiner plus attentivement les détails des paquets ou partager la sortie avec d'autres. Nmap propose plusieurs options pour sauvegarder les résultats du balayage dans différents formats. Ici, nous utiliserons le format de sortie normal (-oN) pour sauvegarder le traçage de paquets.

Pour sauvegarder la sortie du traçage de paquets dans un fichier, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Exécuter la commande Nmap : Dans le terminal, tapez la commande suivante et appuyez sur Entrée :
```
sudo nmap --packet-trace -oN trace.txt 127.0.0.1
```
- sudo : Cette commande peut nécessiter des privilèges root selon le type de balayage.
- nmap : C'est le scanner Nmap en ligne de commande.
- --packet-trace : Cette option indique à Nmap d'imprimer une trace des paquets qu'il envoie et reçoit.
- -oN trace.txt : Cette option spécifie que la sortie doit être sauvegardée au format normal dans le fichier trace.txt. Le fichier sera créé dans votre répertoire actuel (~/projet).
- 127.0.0.1 : C'est l'adresse IP cible, qui est l'adresse de bouclage (localhost).

Observer la sortie : Nmap effectuera un balayage de localhost et imprimera le traçage de paquets dans le terminal, ainsi que le sauvegardera dans le fichier trace.txt.

La sortie du terminal sera similaire à ceci :

Starting Nmap 7.80 ( https://nmap.org ) at 2023-10-27 10:15 UTC
SENT (0.0034s) to 127.0.0.1: TCP 127.0.0.1:54321 > 127.0.0.1:80 S ttl=64 id=12345 win=65535
RECV (0.0045s) from 127.0.0.1: TCP 127.0.0.1:80 > 127.0.0.1:54321 SA ttl=64 id=67890 win=14600
SENT (0.0045s) to 127.0.0.1: TCP 127.0.0.1:54321 > 127.0.0.1:80 A ttl=64 id=12346 win=65535
...
Nmap done: 1 IP address (1 host up) scanned in 0.123 seconds

Vérifier la création du fichier : Après la fin du balayage, vérifiez que le fichier trace.txt a été créé dans votre répertoire ~/projet. Vous pouvez utiliser la commande ls pour vérifier :
```
ls ~/projet
```
Vous devriez voir trace.txt dans la sortie.
Voir le contenu du fichier : Vous pouvez voir le contenu du fichier trace.txt à l'aide de la commande cat ou d'un éditeur de texte comme nano :
```
cat ~/projet/trace.txt
```
ou
```
nano ~/projet/trace.txt
```
Le fichier contiendra la même sortie de traçage de paquets qui a été imprimée dans le terminal.

Cette étape a montré comment sauvegarder la sortie du traçage de paquets de Nmap dans un fichier. Dans l'étape suivante, nous analyserons les détails des paquets dans le terminal Xfce.

Analyser les détails des paquets dans le terminal Xfce

Dans cette étape, nous allons analyser les détails des paquets capturés par l'option --packet-trace de Nmap. Comprendre la sortie du traçage de paquets peut vous aider à diagnostiquer les problèmes de réseau, à comprendre comment fonctionnent les sondes de Nmap et à identifier les vulnérabilités de sécurité potentiellement dangereuses. Nous utiliserons la commande grep dans le terminal Xfce pour filtrer et examiner des paquets spécifiques.

Pour analyser les détails des paquets, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Revoir le fichier trace.txt : Dans l'étape précédente, vous avez sauvegardé la sortie du traçage de paquets dans le fichier trace.txt dans votre répertoire ~/projet. Si vous n'avez pas effectué cette étape, veuillez revenir en arrière et la compléter d'abord.
Utiliser grep pour filtrer les paquets : La commande grep est un outil puissant pour rechercher dans des fichiers texte. Nous pouvons l'utiliser pour filtrer le fichier trace.txt et trouver les paquets qui correspondent à des critères spécifiques.

Par exemple, pour trouver tous les paquets envoyés vers le port 80, vous pouvez utiliser la commande suivante :
```
grep " > 127.0.0.1:80" ~/projet/trace.txt
```
- grep : Il s'agit de l'utilitaire en ligne de commande pour rechercher dans du texte.
- " > 127.0.0.1:80" : C'est le motif de recherche. Il cherche les lignes qui contiennent " > 127.0.0.1:80", ce qui indique des paquets envoyés vers le port 80 sur l'ordinateur local (127.0.0.1). L'espace avant > est important pour éviter de correspondre aux ports sources.
- ~/projet/trace.txt : C'est le chemin vers le fichier contenant la sortie du traçage de paquets.
La sortie montrera toutes les lignes dans le fichier trace.txt qui correspondent au motif de recherche. Par exemple :
```
SENT (0.0034s) to 127.0.0.1: TCP 127.0.0.1:54321 > 127.0.0.1:80 S ttl=64 id=12345 win=65535
RECV (0.0045s) from 127.0.0.1: TCP 127.0.0.1:80 > 127.0.0.1:54321 SA ttl=64 id=67890 win=14600
SENT (0.0045s) to 127.0.0.1: TCP 127.0.0.1:54321 > 127.0.0.1:80 A ttl=64 id=12346 win=65535
```
Analyser les détails des paquets : Examinez la sortie pour comprendre les détails des paquets. La sortie montre la direction du paquet (SENT ou RECV), les adresses IP source et destination et les ports, le protocole (TCP) et d'autres drapeaux et options.
- SENT : Indique un paquet envoyé par Nmap.
- RECV : Indique un paquet reçu par Nmap.
- TCP 127.0.0.1:54321 > 127.0.0.1:80 : Montre l'adresse IP source et le port (127.0.0.1:54321) et l'adresse IP destination et le port (127.0.0.1:80).
- S : Indique que le drapeau SYN est défini, qui est utilisé pour initier une connexion TCP.
- SA : Indique que les drapeaux SYN-ACK sont définis, qui est une réponse à un paquet SYN.
- A : Indique que le drapeau ACK est défini, qui est utilisé pour confirmer la réception des données.
- ttl : Durée de vie.
- id : Numéro d'identification IP.
- win : Taille de fenêtre.
Expérimenter avec différents motifs grep : Essayez différents motifs grep pour filtrer la sortie du traçage de paquets selon vos besoins spécifiques. Par exemple :
- Pour trouver tous les paquets SYN :
```
grep "S ttl=" ~/projet/trace.txt
```
- Pour trouver tous les paquets reçus du port 80 :
```
grep "from 127.0.0.1:80" ~/projet/trace.txt
```
- Pour trouver tous les paquets avec un ID IP spécifique :
```
grep "id=12345" ~/projet/trace.txt
```

En utilisant grep pour filtrer et analyser la sortie du traçage de paquets, vous pouvez mieux comprendre le comportement de Nmap et le trafic réseau qu'il génère.

Identifier les problèmes de balayage dans le terminal Xfce

Dans cette étape, nous allons utiliser le traçage de paquets et la sortie de débogage de Nmap pour identifier les problèmes potentiels de balayage. Cela implique de chercher des anomalies dans l'échange de paquets, telles que des retransmissions, des réponses inattendues ou l'absence de réponses. En analysant ces problèmes, vous pouvez résoudre les problèmes de balayage et améliorer la précision et la fiabilité de vos balayages Nmap.

Pour identifier les problèmes de balayage, suivez ces étapes :

Ouvrir un terminal : Si vous n'en avez pas déjà un ouvert, lancez le terminal Xfce.
Revoir le fichier trace.txt : Dans les étapes précédentes, vous avez sauvegardé la sortie du traçage de paquets dans le fichier trace.txt dans votre répertoire ~/projet. Vérifiez que ce fichier existe et contient les informations de traçage de paquets.
Chercher des retransmissions : Les retransmissions se produisent lorsqu'un paquet n'est pas reconnu par l'hôte cible et que Nmap renvoie le paquet. Cela peut indiquer une congestion réseau, une perte de paquets ou un pare-feu bloquant le trafic. Utilisez grep pour rechercher des retransmissions :
```
grep "Retransmission" ~/projet/trace.txt
```
Si vous voyez des lignes contenant "Retransmission", cela indique que Nmap a dû renvoyer des paquets. Cela pourrait être un signe de problèmes réseau ou d'un pare-feu.
Analyser les drapeaux TCP : Examinez les drapeaux TCP dans le traçage de paquets pour comprendre l'état de la connexion TCP. Cherchez des combinaisons de drapeaux inattendues ou des drapeaux manquants. Par exemple, un paquet SYN sans réponse SYN-ACK correspondante pourrait indiquer qu'un pare-feu bloque la connexion.

Vous pouvez utiliser grep pour filtrer pour des drapeaux TCP spécifiques. Par exemple, pour trouver des paquets SYN :
```
grep "S ttl=" ~/projet/trace.txt
```
Et pour trouver des paquets SYN-ACK :
```
grep "SA ttl=" ~/projet/trace.txt
```
Comparez le nombre de paquets SYN envoyés avec le nombre de paquets SYN-ACK reçus. Si le nombre de paquets SYN-ACK est considérablement inférieur au nombre de paquets SYN, cela pourrait indiquer un problème.
Vérifier les réponses inattendues : Parfois, l'hôte cible peut envoyer des réponses inattendues, telles que des messages d'erreur ICMP. Ces réponses peuvent fournir des informations précieuses sur pourquoi un balayage échoue.

Pour chercher des paquets ICMP, utilisez la commande suivante :
```
grep "ICMP" ~/projet/trace.txt
```
Analysez les messages ICMP pour comprendre la nature de l'erreur. Par exemple, "Destination Unreachable" indique que l'hôte cible n'est pas accessible.
Chercher des réponses manquantes : Si Nmap envoie une sonde et ne reçoit pas de réponse, cela peut indiquer que l'hôte cible est éteint, qu'un pare-feu bloque le trafic ou que la sonde a été perdue en transit.

Examinez le traçage de paquets pour identifier les sondes qui n'ont pas reçu de réponse. Par exemple, si vous avez envoyé un paquet SYN vers le port 80 mais n'avez pas reçu de paquet SYN-ACK, cela pourrait indiquer que le port 80 est fermé ou filtré.
Considérez la sortie de débogage : Bien que les étapes précédentes se soient concentrées sur le traçage de paquets, rappelez-vous que la sortie de débogage (à partir de -d ou -d2) peut également fournir des indices précieux. Elle contient souvent des informations sur le processus de décision interne de Nmap, ce qui peut vous aider à comprendre pourquoi il se comporte d'une certaine manière. Malheureusement, nous n'avons pas sauvegardé la sortie de débogage dans un fichier dans les étapes précédentes, mais dans un scénario réel, vous analyseriez cette sortie en même temps que le traçage de paquets.

En analysant soigneusement le traçage de paquets et la sortie de débogage, vous pouvez identifier les problèmes potentiels de balayage et prendre des mesures pour les résoudre. Cela améliorera la précision et la fiabilité de vos balayages Nmap.

Sommaire

Dans ce laboratoire, nous avons exploré les capacités de débogage de Nmap en utilisant l'option --packet-trace pour observer les paquets réseau échangés lors d'un balayage. Cela a consisté à exécuter la commande sudo nmap --packet-trace 192.168.1.1 (ou 127.0.0.1 en alternative) dans le terminal Xfce et à analyser la sortie détaillée, qui comprenait les types de paquets, les adresses IP source et destination et les ports, ainsi que d'autres informations pertinentes.

Le principal enseignement est de comprendre comment --packet-trace fournit un moyen simplifié pour visualiser directement les paquets réseau à partir de Nmap, permettant de mieux comprendre les opérations au niveau réseau de Nmap et facilitant l'identification de problèmes potentiels de balayage.