Apprendre l'analyse de la sortie et la numérisation Nmap

NmapNmapBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Dans ce laboratoire (lab), vous apprendrez à utiliser Nmap, un puissant outil de numérisation (scanning) de réseau largement utilisé par les professionnels de la sécurité pour découvrir les hôtes et les services sur un réseau informatique. Vous explorerez divers formats de sortie fournis par Nmap, qui sont essentiels pour interpréter les résultats de numérisation et effectuer des analyses supplémentaires.

Nmap, acronyme de Network Mapper, est une utilité gratuite et open - source pour la découverte de réseau et l'audit de sécurité. Il utilise des paquets IP bruts pour recueillir des informations sur les hôtes du réseau, telles que les services disponibles et les systèmes d'exploitation. Ce laboratoire vous guidera tout au long de la configuration d'un service de test et de sa numérisation avec différentes options de sortie de Nmap, ce qui est crucial pour une analyse et une documentation efficaces du réseau.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL nmap(("Nmap")) -.-> nmap/NmapGroup(["Nmap"]) nmap/NmapGroup -.-> nmap/installation("Installation and Setup") 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/scripting_basics("Scripting Engine Basics") subgraph Lab Skills nmap/installation -.-> lab-415926{{"Apprendre l'analyse de la sortie et la numérisation Nmap"}} nmap/output_formats -.-> lab-415926{{"Apprendre l'analyse de la sortie et la numérisation Nmap"}} nmap/save_output -.-> lab-415926{{"Apprendre l'analyse de la sortie et la numérisation Nmap"}} nmap/port_scanning -.-> lab-415926{{"Apprendre l'analyse de la sortie et la numérisation Nmap"}} nmap/scripting_basics -.-> lab-415926{{"Apprendre l'analyse de la sortie et la numérisation Nmap"}} end

Configuration d'un environnement de test pour la numérisation (scanning) avec Nmap

Dans cette étape, nous allons créer un environnement simple où vous pourrez pratiquer la numérisation avec Nmap. Nmap est un outil puissant utilisé pour l'exploration de réseau et l'audit de sécurité. En configurant un serveur web de base sur votre machine locale puis en le numérisant avec Nmap, vous pourrez apprendre à numériser des réseaux dans un environnement sûr et contrôlé. De cette façon, vous pouvez expérimenter sans affecter les réseaux du monde réel.

Configuration d'un serveur web local

Tout d'abord, nous devons configurer un serveur web simple que nous pourrons numériser avec Nmap. Python offre un moyen facile de créer un serveur HTTP de base. Un serveur HTTP est un logiciel qui peut fournir des pages web aux clients, comme les navigateurs.

  1. Ouvrez un terminal et accédez au répertoire de votre projet :

    cd /home/labex/project

    La commande cd signifie "change directory" (changer de répertoire). Elle vous permet de vous déplacer dans votre système de fichiers. Dans ce cas, nous nous déplaçons vers le répertoire /home/labex/project où nous allons configurer notre serveur web.

  2. Créez un fichier HTML simple à servir :

    echo "Welcome to Nmap Testing Environment" > index.html

    La commande echo affiche du texte dans le terminal. Le symbole > redirige cette sortie dans un fichier. Ainsi, nous créons un fichier nommé index.html avec le texte "Welcome to Nmap Testing Environment". Cette page web sera celle que notre serveur servira.

  3. Démarrez un serveur HTTP Python sur le port 8080 :

    python3 -m http.server 8080 &

    La commande python3 -m http.server démarre un serveur HTTP simple en utilisant Python. Le 8080 spécifie le numéro de port sur lequel le serveur écoutera. Un port est comme une porte par laquelle le trafic réseau entre ou sort d'un ordinateur. Le & à la fin de la commande exécute le serveur en arrière - plan, vous permettant de continuer à utiliser le terminal pour d'autres commandes.

  4. Vérifiez que votre serveur web est en cours d'exécution en y accédant :

    curl http://localhost:8080

    La commande curl est utilisée pour transférer des données depuis ou vers un serveur. Ici, nous essayons d'accéder au serveur web que nous venons de configurer à l'adresse http://localhost:8080. localhost fait référence à l'ordinateur actuel.

    Vous devriez voir la sortie suivante :

    Welcome to Nmap Testing Environment

    Si vous voyez cette sortie, cela signifie que votre serveur web fonctionne correctement.

Numérisation de base avec Nmap

Maintenant que vous avez un serveur web en cours d'exécution, vous pouvez le numériser en utilisant Nmap. La numérisation d'un serveur vous aide à découvrir quels ports sont ouverts et quels services peuvent s'exécuter sur eux.

  1. Exécutez une numérisation de base avec Nmap sur votre serveur web local :

    nmap -p 8080 localhost

    L'option -p dans la commande nmap spécifie le port à numériser. Dans ce cas, nous demandons à Nmap de numériser uniquement le port 8080 sur localhost (qui est l'adresse IP 127.0.0.1).

    Vous devriez voir une sortie similaire à celle - ci :

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 12:34 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    
    Nmap done: 1 IP address (1 host up) scanned in 0.05 seconds

    Cette sortie est au format par défaut de Nmap, qui est lisible par l'homme et affiche les informations de base sur la numérisation.

Compréhension de la sortie par défaut de Nmap

Comprenons ce que la sortie par défaut montre :

  • Starting Nmap : Cette ligne indique la version de Nmap que vous utilisez et l'heure à laquelle la numérisation a commencé. Elle vous aide à suivre le moment où la numérisation a été lancée.
  • Nmap scan report : Cela indique la cible de la numérisation. Dans notre cas, la cible est localhost.
  • Host is up : Cela confirme que la cible est en ligne. Le temps de latence indique combien de temps Nmap a mis pour obtenir une réponse de la cible.
  • PORT : Cela montre le numéro de port qui a été numérisé. Dans notre numérisation, nous avons numérisé le port 8080.
  • STATE : Cela indique si le port est ouvert, fermé ou filtré. Un port ouvert signifie qu'un service écoute sur ce port et accepte les connexions.
  • SERVICE : Nmap essaie de deviner quel service peut s'exécuter sur ce port. Ici, il a deviné http - proxy.
  • Nmap done : C'est un résumé de la numérisation. Il vous indique combien d'adresses IP ont été numérisées et combien de temps a pris la numérisation.

Maintenant, vous avez configuré avec succès un environnement de test et effectué une numérisation de base avec Nmap. Dans l'étape suivante, vous explorerez différents formats de sortie que Nmap propose.

Exploration des différents formats de sortie de Nmap

Dans cette étape, nous allons apprendre à connaître les différents formats de sortie que propose Nmap. Les formats de sortie sont essentiels en cybersécurité car ils nous permettent de présenter les résultats de numérisation (scanning) de différentes manières, en fonction de nos besoins. Par exemple, certains formats sont faciles à lire pour les humains, tandis que d'autres sont conçus pour être analysés par des machines, ce qui est utile lors de l'intégration avec d'autres outils.

Aperçu des formats de sortie de Nmap

Nmap prend en charge plusieurs formats de sortie, chacun ayant ses propres caractéristiques uniques et ses cas d'utilisation :

  1. Sortie normale (par défaut) : C'est un format lisible par l'homme. Il présente les résultats de numérisation d'une manière qui est facile à comprendre d'un coup d'œil, ce qui le rend idéal pour une analyse manuelle rapide.
  2. Sortie XML (-oX) : XML signifie Extensible Markup Language (Langage de balisage extensible). C'est un format structuré, ce qui signifie que les données sont organisées de manière hiérarchique. Cela facilite l'analyse des données par des programmes et des scripts, et il est couramment utilisé lors de l'intégration de Nmap avec d'autres outils de sécurité.
  3. Sortie filtrée (grepable) (-oG) : C'est un format basé sur les lignes. Il est conçu pour être facilement traité avec des outils Unix tels que grep, awk et cut. Ce format est utile lorsque vous souhaitez extraire rapidement des informations spécifiques des résultats de numérisation.
  4. Sortie pour les script - kiddies (-oS) : Ce format est similaire à la sortie normale, mais il inclut des dessins ASCII. Cependant, il est rarement utilisé dans les scénarios pratiques.
  5. Tous les formats (-oA) : Cette option vous permet de sauvegarder les résultats de numérisation simultanément au format normal, XML et filtré. C'est un moyen pratique d'avoir tous les types de sorties disponibles à la fois.

Explorons ces formats en numérisant à nouveau votre serveur web local.

Format de sortie XML

XML, ou Extensible Markup Language, est un format structuré largement utilisé pour le stockage et l'échange de données. Sa structure hiérarchique facilite l'analyse des données par les programmes, c'est pourquoi il est couramment utilisé pour l'intégration avec d'autres outils de sécurité.

  1. Exécutez une numérisation avec Nmap et sauvegardez la sortie au format XML :

    nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml

    Dans cette commande, -p 8080 spécifie que nous numérisons le port 8080, localhost est la cible que nous numérisons (notre machine locale), et -oX indique à Nmap de sauvegarder la sortie au format XML dans le chemin de fichier spécifié.

  2. Affichez la sortie XML :

    cat /home/labex/project/scan_results.xml

    La commande cat est utilisée pour afficher le contenu d'un fichier. Lorsque vous exécutez cette commande, vous verrez une sortie au format XML qui ressemble à ceci (abrégé) :

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE nmaprun>
    <nmaprun scanner="nmap" args="nmap -p 8080 localhost -oX /home/labex/project/scan_results.xml" ...>
      <scaninfo type="connect" protocol="tcp" .../>
      <verbose level="0"/>
      <debugging level="0"/>
      <host>
        <status state="up" reason="conn - refused" reason_ttl="0"/>
        <address addr="127.0.0.1" addrtype="ipv4"/>
        <hostnames>
          <hostname name="localhost" type="user"/>
          <hostname name="localhost" type="PTR"/>
        </hostnames>
        <ports>
          <port protocol="tcp" portid="8080">
            <state state="open" reason="syn - ack" reason_ttl="0"/>
            <service name="http - proxy" method="table" conf="3"/>
          </port>
        </ports>
        <times srtt="97" rttvar="5000" to="100000"/>
      </host>
      <runstats>...</runstats>
    </nmaprun>
  3. Le format XML inclut des informations détaillées organisées dans une structure hiérarchique. Extraitons les informations spécifiques sur le port :

    grep -A5 "<port " /home/labex/project/scan_results.xml > /home/labex/project/port_details.txt

    La commande grep est utilisée pour rechercher un motif spécifique dans un fichier. -A5 signifie afficher 5 lignes après la ligne qui correspond au motif. Nous recherchons les lignes contenant <port dans le fichier XML et sauvegardons les résultats dans un nouveau fichier appelé port_details.txt.

  4. Affichez les détails du port extraits :

    cat /home/labex/project/port_details.txt

    L'exécution de cette commande vous montrera la section d'informations sur le port à partir du XML.

Format de sortie filtrée (grepable)

La sortie filtrée est spécifiquement conçue pour être facilement traitée avec des outils tels que grep, awk et cut. Ces outils Unix sont très puissants pour le traitement de texte et peuvent nous aider à extraire rapidement les informations dont nous avons besoin des résultats de numérisation.

  1. Exécutez une numérisation avec Nmap et sauvegardez la sortie au format filtré :

    nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep

    Ici, -oG indique à Nmap de sauvegarder la sortie au format filtré dans le fichier spécifié.

  2. Affichez la sortie filtrée :

    cat /home/labex/project/scan_results.grep

    La sortie ressemblera à ceci :

    ## Nmap 7.80 scan initiated Wed Nov 8 12:40:00 2023 as: nmap -p 8080 localhost -oG /home/labex/project/scan_results.grep
    Host: 127.0.0.1 (localhost)   Status: Up
    Host: 127.0.0.1 (localhost)   Ports: 8080/open/tcp//http - proxy///
    ## Nmap done at Wed Nov 8 12:40:00 2023 -- 1 IP address (1 host up) scanned in 0.05 seconds
  3. Le format filtré met toutes les informations sur l'hôte sur une seule ligne, ce qui le rend facile à utiliser avec des outils de traitement de texte. Par exemple, vous pouvez extraire seulement la ligne contenant les informations sur le port :

    grep "Ports:" /home/labex/project/scan_results.grep > /home/labex/project/ports_info.txt

    Cette commande recherche les lignes contenant le mot "Ports:" dans le fichier de sortie filtré et sauvegarde la ligne correspondante dans un nouveau fichier appelé ports_info.txt.

  4. Affichez les informations sur les ports extraites :

    cat /home/labex/project/ports_info.txt

Sauvegarde dans tous les formats simultanément

Nmap propose une option pratique pour sauvegarder la sortie dans plusieurs formats à la fois en utilisant l'option -oA. Cela peut vous faire gagner du temps si vous avez besoin de différents types de sorties pour différentes finalités.

  1. Exécutez une numérisation avec Nmap et sauvegardez la sortie dans tous les formats :

    nmap -p 8080 localhost -oA /home/labex/project/all_formats

    Cette commande numérise le port 8080 sur la machine locale et sauvegarde les résultats au format normal, XML et filtré.

  2. Vérifiez les fichiers créés :

    ls -la /home/labex/project/all_formats.*

    La commande ls -la liste tous les fichiers dans un répertoire avec des informations détaillées. Lorsque vous exécutez cette commande, vous devriez voir trois fichiers :

    • all_formats.nmap (sortie normale)
    • all_formats.xml (sortie XML)
    • all_formats.gnmap (sortie filtrée)

Maintenant, vous comprenez les différents formats de sortie que propose Nmap et comment les utiliser. Chaque format a ses propres avantages :

  • La sortie normale est facile à lire pour les humains.
  • La sortie XML est structurée pour l'analyse par des machines et l'intégration avec d'autres outils.
  • La sortie filtrée est conçue pour une analyse rapide avec des outils de traitement de texte Unix.

Dans l'étape suivante, vous apprendrez à analyser ces sorties plus en détail.

Analyse des sorties de Nmap et extraction d'informations utiles

Dans cette étape, vous apprendrez à extraire et à analyser des informations spécifiques des résultats de numérisation (scanning) de Nmap. Il s'agit d'une compétence essentielle pour les administrateurs de réseau et les professionnels de la sécurité. Lorsque vous effectuez des numérisations de réseau, vous obtenez souvent une grande quantité de données. Être capable d'extraire efficacement les parties pertinentes vous aide à comprendre l'état de sécurité du réseau et à identifier les problèmes potentiels.

Analyse de la sortie XML

La sortie XML est très utile pour une analyse détaillée et peut être facilement intégrée avec d'autres outils. XML est un format structuré qui organise les données de manière hiérarchique, ce qui facilite la localisation et l'extraction d'informations spécifiques. Explorons comment extraire des informations spécifiques de la sortie XML.

  1. Tout d'abord, examinons la structure de la sortie XML pour comprendre quelles informations sont disponibles. Nous utiliserons la commande grep pour trouver le début de la section hôte dans le fichier XML. La commande grep recherche un motif spécifié dans un fichier.

    grep "<host" -A2 /home/labex/project/scan_results.xml

    Cette commande recherche la balise <host> dans le fichier scan_results.xml et affiche les deux lignes suivantes après la correspondance. Cela nous aide à voir le début de la section hôte dans le fichier XML.

  2. Maintenant, extrayons des informations sur l'état du port. Nous utiliserons à nouveau grep pour trouver toutes les lignes contenant la balise <state et sauvegarder les résultats dans un nouveau fichier.

    grep "<state " /home/labex/project/scan_results.xml > /home/labex/project/port_state.txt
  3. Affichons l'état du port extrait. Nous utiliserons la commande cat, qui est utilisée pour afficher le contenu d'un fichier.

    cat /home/labex/project/port_state.txt

    Vous devriez voir quelque chose comme :

    <state state="open" reason="syn-ack" reason_ttl="0"/>

    Cela nous indique que le port est ouvert. Nmap a déterminé cela car il a reçu un paquet SYN - ACK en réponse à son paquet SYN. Cela fait partie de l'échange de trois paquets (TCP three - way handshake) qui est la manière dont une connexion TCP est établie entre deux appareils sur un réseau.

Utilisation d'expressions régulières pour des extractions plus complexes

Pour des extractions de données plus complexes, vous pouvez utiliser des expressions régulières avec des outils tels que grep, sed ou awk. Les expressions régulières sont un moyen puissant de rechercher et de correspondre des motifs dans le texte. Elles vous permettent de définir des critères de recherche complexes.

  1. Extrayons à la fois le numéro de port et son état. Nous utiliserons grep avec une expression régulière pour trouver les informations pertinentes dans le fichier XML et les sauvegarder dans un nouveau fichier.

    grep -o 'portid="[0-9]*".*state="[^"]*"' /home/labex/project/scan_results.xml > /home/labex/project/port_and_state.txt
  2. Affichons les informations extraites en utilisant la commande cat.

    cat /home/labex/project/port_and_state.txt

    Vous devriez voir une sortie comme :

    portid="8080" state="open"

Analyse de la sortie filtrée (grepable)

Le format de sortie filtrée est conçu pour être facilement traité avec des outils Unix standard. C'est un format basé sur le texte qui rend simple la recherche d'informations spécifiques à l'aide de commandes telles que grep.

  1. Extrayons seulement les ports ouverts de la sortie filtrée. Nous utiliserons grep pour trouver toutes les lignes contenant le mot "open" et sauvegarder les résultats dans un nouveau fichier.

    grep "open" /home/labex/project/scan_results.grep > /home/labex/project/open_ports.txt
  2. Affichons les informations extraites en utilisant la commande cat.

    cat /home/labex/project/open_ports.txt

    Cela devrait vous montrer la ligne contenant tous les ports ouverts.

  3. Vous pouvez traiter cela plus loin pour extraire seulement les numéros de port. Nous utiliserons une combinaison des commandes grep et cut. La commande cut est utilisée pour extraire des parties spécifiques d'une ligne en fonction d'un délimiteur.

    grep "open" /home/labex/project/scan_results.grep | grep -o "8080/open" | cut -d "/" -f1 > /home/labex/project/port_numbers.txt
  4. Affichons les numéros de port extraits en utilisant la commande cat.

    cat /home/labex/project/port_numbers.txt

    Vous devriez voir :

    8080

Création d'un rapport de synthèse simple

Maintenant, créons un rapport de synthèse simple qui combine des informations de différentes parties de la numérisation. Un rapport de synthèse vous aide à comprendre rapidement les principaux résultats de la numérisation.

  1. Créons un rapport de synthèse. Nous utiliserons la commande echo pour écrire du texte dans un fichier. L'opérateur >> ajoute le texte à la fin du fichier.

    echo "Nmap Scan Summary" > /home/labex/project/scan_summary.txt
    echo "----------------" >> /home/labex/project/scan_summary.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/scan_summary.txt
    echo "Open ports:" >> /home/labex/project/scan_summary.txt
    grep "open" /home/labex/project/scan_results.grep | grep -o "[0-9]*/open/tcp//[^/]*" >> /home/labex/project/scan_summary.txt
  2. Affichons le rapport de synthèse en utilisant la commande cat.

    cat /home/labex/project/scan_summary.txt

    La sortie devrait ressembler à :

    Nmap Scan Summary
    ----------------
    Target: localhost (127.0.0.1)
    Open ports:
    8080/open/tcp//http - proxy

En apprenant à extraire et à analyser des informations spécifiques des résultats de numérisation de Nmap, vous pouvez traiter et interpréter efficacement les données de reconnaissance de réseau. Cette compétence est particulièrement précieuse lors de la numérisation de grands réseaux avec de nombreux hôtes et services.

Dans l'étape suivante, vous apprendrez des techniques de numérisation plus avancées avec Nmap.

Techniques avancées de numérisation avec Nmap

Dans cette étape, nous allons explorer des techniques de numérisation plus avancées avec Nmap. Ces techniques sont essentielles car elles peuvent fournir des informations supplémentaires et détaillées sur les services réseau. Plus précisément, nous allons nous concentrer sur la détection de la version des services et la numérisation avec des scripts. Comprendre ces techniques vous aidera à mieux comprendre les services réseau que vous numérisez, ce qui est essentiel pour les évaluations de sécurité, l'inventaire du réseau et la résolution de problèmes.

Détection de la version des services

Nmap dispose d'une fonctionnalité puissante qui lui permet d'essayer de déterminer la version spécifique d'un service exécuté sur un port. Cela se fait en utilisant l'option -sV. Connaître la version du service peut être très utile, car différentes versions peuvent avoir des vulnérabilités de sécurité ou des fonctionnalités différentes.

  1. Exécutez une numérisation avec Nmap en activant la détection de la version des services :

    nmap -p 8080 -sV localhost -oN /home/labex/project/version_scan.txt

    Dans cette commande, l'option -sV indique à Nmap de tester les ports ouverts. Ainsi, Nmap peut collecter des informations sur les services exécutés sur ces ports, y compris leurs versions. L'option -oN est utilisée pour sauvegarder la sortie de la numérisation au format normal dans le fichier spécifié /home/labex/project/version_scan.txt. Sauvegarder la sortie dans un fichier vous permet de consulter les résultats plus tard.

  2. Affichez les résultats de la numérisation :

    cat /home/labex/project/version_scan.txt

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

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:20:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE VERSION
    8080/tcp open  http    Python/3.10 aiohttp/3.8.1 (Python httpd)
    
    Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
    Nmap done: 1 IP address (1 host up) scanned in 6.52 seconds

    Notez que Nmap affiche désormais non seulement le nom du service, mais également des informations sur la version. Dans ce cas, il a détecté que le serveur HTTP s'exécute avec Python 3.10. Ces informations détaillées peuvent être utilisées pour identifier des risques de sécurité potentiels ou pour comprendre les capacités du service.

Utilisation des scripts Nmap (NSE)

Le moteur de scripts Nmap (Nmap Script Engine - NSE) est un outil puissant qui vous permet d'exécuter des scripts pour effectuer diverses tâches. Ces tâches vont de la détection de services à la numérisation des vulnérabilités. En utilisant les scripts NSE, vous pouvez étendre les fonctionnalités de Nmap et collecter plus d'informations sur le réseau cible.

  1. Exécutez un script de base pour obtenir des informations HTTP sur votre serveur web :

    nmap -p 8080 --script=http-title localhost -oN /home/labex/project/script_scan.txt

    Le script http-title est conçu pour récupérer le titre des pages web HTTP. Cela peut être utile pour identifier rapidement le contenu ou le but d'une page web. L'option -oN sauvegarde la sortie de la numérisation avec le script au format normal dans le fichier spécifié /home/labex/project/script_scan.txt.

  2. Affichez les résultats de la numérisation avec le script :

    cat /home/labex/project/script_scan.txt

    La sortie devrait inclure quelque chose comme :

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:25:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-title: Directory listing for /
    
    Nmap done: 1 IP address (1 host up) scanned in 0.42 seconds

    Le script http-title a récupéré le titre de la page web, qui dans ce cas est une liste de répertoire. Ces informations peuvent vous aider à comprendre la structure et le contenu du serveur web.

  3. Essayons un autre script qui fournit plus d'informations sur le serveur HTTP :

    nmap -p 8080 --script=http-server-header localhost -oN /home/labex/project/server_header_scan.txt

    Le script http-server-header est utilisé pour récupérer l'en-tête du serveur HTTP. L'en-tête du serveur contient souvent des informations sur le logiciel du serveur, telles que la version et le type. Ces informations peuvent être précieuses pour les évaluations de sécurité et l'inventaire du réseau. L'option -oN sauvegarde la sortie de la numérisation au format normal dans le fichier spécifié /home/labex/project/server_header_scan.txt.

  4. Affichez les résultats de la numérisation de l'en-tête du serveur :

    cat /home/labex/project/server_header_scan.txt

    La sortie devrait inclure des informations sur le logiciel du serveur :

    Starting Nmap 7.80 ( https://nmap.org ) at 2023-11-08 13:30:00 UTC
    Nmap scan report for localhost (127.0.0.1)
    Host is up (0.000097s latency).
    
    PORT     STATE SERVICE
    8080/tcp open  http-proxy
    |_http-server-header: SimpleHTTP/0.6 Python/3.10.12
    
    Nmap done: 1 IP address (1 host up) scanned in 0.13 seconds

Combinaison de plusieurs techniques

Vous pouvez combiner plusieurs techniques de numérisation dans une seule commande Nmap pour effectuer une numérisation plus complète. Cela vous permet de collecter une grande variété d'informations sur le réseau cible en une seule fois.

  1. Exécutez une numérisation complète qui inclut la numérisation des ports, la détection de la version des services et la numérisation avec des scripts :

    nmap -p 8080 -sV --script=http-title,http-server-header localhost -oA /home/labex/project/comprehensive_scan

    Cette commande effectue plusieurs opérations :

    • Elle numérise le port 8080 (-p 8080), ce qui signifie qu'elle vérifie si ce port est ouvert sur l'hôte cible.
    • Elle détecte les versions des services (-sV), fournissant des informations sur les versions spécifiques des services exécutés sur le port.
    • Elle exécute les scripts http-title et http-server-header (--script=http-title,http-server-header), qui récupèrent respectivement le titre de la page web et les informations de l'en-tête du serveur.
    • Elle sauvegarde les résultats dans tous les formats (-oA). Sauvegarder dans tous les formats garantit que vous avez différentes représentations des résultats de la numérisation pour différents usages.
  2. Affichez les résultats de la numérisation complète :

    cat /home/labex/project/comprehensive_scan.nmap

    La sortie inclura toutes les informations des numérisations précédentes combinées. Cela vous donne une vue globale du service réseau cible exécuté sur le port 8080.

  3. Créez un rapport d'analyse final qui résume tous vos résultats :

    echo "Final Nmap Analysis Report" > /home/labex/project/final_report.txt
    echo "------------------------" >> /home/labex/project/final_report.txt
    echo "Target: localhost (127.0.0.1)" >> /home/labex/project/final_report.txt
    echo "Port: 8080/tcp (open)" >> /home/labex/project/final_report.txt
    echo "Service:" >> /home/labex/project/final_report.txt
    grep "SERVICE VERSION" -A1 /home/labex/project/version_scan.txt | tail -1 >> /home/labex/project/final_report.txt
    echo "HTTP Server Header:" >> /home/labex/project/final_report.txt
    grep "http-server-header:" /home/labex/project/server_header_scan.txt >> /home/labex/project/final_report.txt
    echo "HTTP Page Title:" >> /home/labex/project/final_report.txt
    grep "http-title:" /home/labex/project/script_scan.txt >> /home/labex/project/final_report.txt

    Cet ensemble de commandes crée un fichier texte nommé final_report.txt et le remplit avec un résumé de toutes les informations collectées lors des numérisations précédentes. Il inclut des détails sur la cible, le port, la version du service, l'en-tête du serveur et le titre de la page web.

  4. Affichez votre rapport final :

    cat /home/labex/project/final_report.txt

    Votre rapport final devrait contenir un résumé complet de toutes les informations que vous avez collectées sur le serveur web exécuté sur le port 8080. Ce rapport peut être utilisé pour une analyse plus approfondie, des évaluations de sécurité ou à des fins de documentation.

En apprenant ces techniques avancées de numérisation avec Nmap, vous pouvez collecter des informations détaillées sur les services réseau qui sont précieuses pour les évaluations de sécurité, l'inventaire du réseau et la résolution de problèmes.

Résumé

Dans ce laboratoire (lab), vous avez appris à utiliser Nmap, un outil puissant de numérisation de réseau pour la découverte de réseau et l'audit de sécurité. Vous avez acquis une expérience pratique dans diverses opérations Nmap, notamment la configuration d'un environnement de test avec un serveur web local, l'exécution de numérisations de ports de base, l'exploration de différents formats de sortie, l'extraction et l'analyse des résultats de numérisation, ainsi que l'utilisation de techniques avancées telles que la détection de la version des services et la numérisation avec des scripts.

Ces compétences sont essentielles pour les administrateurs de réseau, les analystes en sécurité et les testeurs de pénétration. Elles vous permettent de découvrir les hôtes et les services réseau, de documenter l'infrastructure réseau, d'identifier les problèmes de sécurité et d'automatiser la numérisation et la génération de rapports. Maîtriser Nmap et ses formats de sortie permet d'effectuer une reconnaissance réseau efficace, d'intégrer d'autres outils de sécurité et de construire des inventaires réseau complets. Les compétences en ligne de commande que vous avez pratiquées sont également transférables à d'autres tâches d'administration système et de sécurité.