Explorer et créer des scripts Nmap

Introduction

Dans ce laboratoire, vous allez apprendre sur le moteur de scripts de Nmap (Nmap's Scripting Engine - NSE) et comment catégoriser et mettre à jour les scripts Nmap. Nmap, un puissant outil open - source de découverte de réseau et d'audit de sécurité, voit ses fonctionnalités étendues par le NSE. Le NSE permet aux utilisateurs d'écrire et de partager des scripts pour automatiser diverses tâches réseau.

Ce laboratoire vous guidera dans l'exploration des catégories de scripts Nmap, la création de répertoires de scripts personnalisés, l'ajout de vos propres scripts et la mise à jour de la base de données de scripts Nmap. Ces compétences sont essentielles pour les administrateurs de réseau et les professionnels de la sécurité afin de scanner efficacement les réseaux et d'identifier les vulnérabilités.

Skills Graph

Exploration des catégories de scripts Nmap

Dans cette étape, nous allons explorer les catégories de scripts Nmap préinstallés sur votre système. Les scripts Nmap sont des outils puissants dans le domaine de la cybersécurité. Ils sont organisés en fonction de leur fonctionnalité. Par exemple, certains scripts sont utilisés pour la découverte, ce qui signifie qu'ils peuvent trouver des appareils et des services sur un réseau. D'autres sont destinés à l'évaluation des vulnérabilités, ce qui aide à identifier les faiblesses de sécurité des systèmes.

Tout d'abord, nous devons ouvrir un terminal. Un terminal est une interface basée sur du texte où vous pouvez entrer des commandes pour interagir avec votre système. Une fois le terminal ouvert, nous devons nous assurer que nous sommes dans le bon répertoire. Un répertoire est comme un dossier sur votre ordinateur où sont stockés des fichiers et d'autres dossiers. Exécutez la commande suivante dans le terminal :

cd /home/labex/project

Cette commande change le répertoire de travail actuel pour /home/labex/project.

Maintenant, vérifions la version de Nmap installée sur notre système. Connaître la version est important car différentes versions peuvent avoir des fonctionnalités et une compatibilité différentes. Exécutez cette commande dans le terminal :

nmap --version

La sortie ressemblera à ceci :

Nmap version 7.80 ( https://nmap.org )
Platform: x86_64-pc-linux-gnu
Compiled with: liblua-5.3.3 openssl-1.1.1f libpcre-8.39 libpcap-1.9.1 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select

Ensuite, nous examinerons les catégories de scripts Nmap disponibles. Les scripts Nmap sont stockés dans le répertoire /usr/share/nmap/scripts/. Pour avoir une idée des scripts disponibles, nous pouvons les lister et les trier par leur nom. Exécutez cette commande dans le terminal :

ls /usr/share/nmap/scripts/ | grep -v .lua | sort | head -10

Cette commande liste d'abord tous les fichiers dans le répertoire /usr/share/nmap/scripts/. Ensuite, elle utilise grep -v .lua pour exclure les fichiers avec l'extension .lua. Ensuite, elle trie les fichiers restants par leur nom et affiche les 10 premiers résultats. La sortie sera similaire à :

address-info.nse
afp-brute.nse
afp-ls.nse
afp-path-vuln.nse
afp-serverinfo.nse
afp-showmount.nse
ajp-auth.nse
ajp-brute.nse
ajp-headers.nse
ajp-methods.nse

Pour voir toutes les catégories de scripts, nous pouvons utiliser la commande suivante :

grep -r categories /usr/share/nmap/scripts/*.nse | grep -o "categories = {[^}]*}" | sort | uniq | head -10

Cette commande recherche dans tous les fichiers de script .nse du répertoire /usr/share/nmap/scripts/ la chaîne "categories". Elle extrait ensuite les informations de catégorie, les trie, supprime les entrées en double et affiche les 10 premiers résultats. La sortie ressemblera à ceci :

categories = {"auth", "brute", "intrusive"}
categories = {"auth", "default", "discovery", "safe"}
categories = {"auth", "discovery", "safe"}
categories = {"auth", "intrusive"}
categories = {"auth", "safe"}
categories = {"broadcast", "discovery"}
categories = {"broadcast", "discovery", "safe"}
categories = {"default", "discovery"}
categories = {"default", "discovery", "safe"}
categories = {"default", "discovery", "safe", "version"}

Pour une meilleure organisation, nous allons créer une structure de répertoires pour catégoriser les scripts en fonction de leur fonctionnalité. Cela facilitera la recherche et l'utilisation des scripts plus tard. Nous allons créer des répertoires séparés pour différentes catégories. Exécutez ces commandes dans le terminal :

mkdir -p /home/labex/project/NmapScripts/vulnerability
mkdir -p /home/labex/project/NmapScripts/discovery
mkdir -p /home/labex/project/NmapScripts/authentication

La commande mkdir -p crée des répertoires. Si les répertoires parents n'existent pas, elle les crée également.

Maintenant, copions quelques scripts liés aux vulnérabilités dans notre nouveau répertoire de vulnérabilités. Exécutez cette commande dans le terminal :

cp /usr/share/nmap/scripts/smb-vuln* /home/labex/project/NmapScripts/vulnerability/

Cette commande copie tous les scripts dans le répertoire /usr/share/nmap/scripts/ dont les noms commencent par smb - vuln dans le répertoire /home/labex/project/NmapScripts/vulnerability/.

Vérifions que les fichiers ont été copiés correctement. Exécutez cette commande dans le terminal :

ls -la /home/labex/project/NmapScripts/vulnerability/

La sortie affichera les scripts de vulnérabilité copiés :

total 88
drwxr-xr-x 2 labex labex  4096 Mar 15 12:30 .
drwxr-xr-x 4 labex labex  4096 Mar 15 12:30 ..
-rw-r--r-- 1 labex labex  3355 Mar 15 12:30 smb-vuln-conficker.nse
-rw-r--r-- 1 labex labex  8045 Mar 15 12:30 smb-vuln-cve2009-3103.nse
-rw-r--r-- 1 labex labex  5100 Mar 15 12:30 smb-vuln-cve-2017-7494.nse
-rw-r--r-- 1 labex labex  9595 Mar 15 12:30 smb-vuln-ms06-025.nse
-rw-r--r-- 1 labex labex 11645 Mar 15 12:30 smb-vuln-ms07-029.nse
-rw-r--r-- 1 labex labex 12558 Mar 15 12:30 smb-vuln-ms08-067.nse
-rw-r--r-- 1 labex labex  9719 Mar 15 12:30 smb-vuln-ms10-054.nse
-rw-r--r-- 1 labex labex  7326 Mar 15 12:30 smb-vuln-ms10-061.nse
-rw-r--r-- 1 labex labex  8091 Mar 15 12:30 smb-vuln-ms17-010.nse
-rw-r--r-- 1 labex labex  4245 Mar 15 12:30 smb-vuln-regsvc-dos.nse

De même, copions quelques scripts de découverte et d'authentification dans leurs répertoires respectifs. Exécutez ces commandes dans le terminal :

cp /usr/share/nmap/scripts/dns-* /home/labex/project/NmapScripts/discovery/
cp /usr/share/nmap/scripts/ssh-* /home/labex/project/NmapScripts/authentication/

Maintenant, vous avez organisé certains scripts Nmap en catégories en fonction de leur fonctionnalité, ce qui facilite leur recherche et leur utilisation pour des tâches spécifiques.

Comprendre la fonctionnalité des scripts

Dans cette étape, nous allons apprendre à examiner et comprendre les scripts Nmap pour savoir ce qu'ils peuvent faire. Savoir cela est très important car cela vous aide à choisir les bons scripts pour différentes tâches de scan de réseau.

Commençons par examiner de près l'un des scripts de vulnérabilité que nous avons copiés à l'étape précédente. Nous utiliserons la commande cat pour afficher le contenu du script, puis head -20 pour afficher seulement les 20 premières lignes. De cette façon, nous pouvons rapidement voir les informations importantes au début du script.

cat /home/labex/project/NmapScripts/vulnerability/smb-vuln-ms17-010.nse | head -20

La sortie affichera le début du script. Cette partie contient généralement des détails sur ce que le script fait et comment l'utiliser.

local smb = require "smb"
local vulns = require "vulns"
local stdnse = require "stdnse"
local string = require "string"

description = [[
Attempts to detect if a Microsoft SMBv1 server is vulnerable to a remote code
execution vulnerability (ms17-010, a.k.a. EternalBlue). The vulnerability affects
Windows Vista, 7, 8.1, 10, Server 2008, Server 2008 R2, Server 2012 Gold and R2, and Server 2016.

The script connects to the $IPC tree, executes a transaction on FID 0 and
checks if the error "STATUS_INSUFF_SERVER_RESOURCES" is returned to
determine if the target is not patched against ms17-010. Additionally it checks
for a matching error code on EternalChampion.

References:
* https://technet.microsoft.com/en-us/library/security/ms17-010.aspx
* https://blogs.technet.microsoft.com/msrc/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://msrc-blog.microsoft.com/2017/05/12/customer-guidance-for-wannacrypt-attacks/
* https://github.com/rapid7/metasploit-framework/pull/8654/files

Ce script est conçu pour vérifier si un serveur Microsoft SMBv1 est vulnérable à la faille MS17-010, également connue sous le nom d'EternalBlue.

Maintenant, examinons la structure d'un script Nmap pour comprendre ses différentes parties. La plupart des scripts Nmap ont ces composants clés :

1. Une section de description : Cela vous indique ce que le script fait. C'est comme un résumé court qui vous aide à comprendre rapidement le but du script.
2. Une section d'auteur : Cela reconnaît la personne qui a créé le script. Il est important de savoir qui a fait le script, surtout si vous avez besoin de le contacter ou de rechercher plus de scripts du même auteur.
3. Catégories : Elles regroupent des scripts similaires. Par exemple, les scripts liés à la détection de vulnérabilités peuvent être dans la catégorie "vuln". Cela facilite la recherche et la gestion des scripts.
4. Règles : Elles déterminent quand le script doit être exécuté. Il existe différents types de règles, comme portrule et hostrule. Par exemple, une hostrule peut spécifier que le script ne doit être exécuté que sur certains hôtes.
5. La fonction d'action principale : C'est là que le travail réel du script se déroule. Elle contient le code qui effectue la tâche, comme vérifier une vulnérabilité ou obtenir des informations sur un hôte.

Créons notre propre script Nmap de base pour voir cette structure en action. Nous utiliserons la commande cat pour créer un nouveau fichier et écrire le script dedans.

cat << 'EOF' > /home/labex/project/my-ping-check.nse
description = [[
A simple script that checks if a host responds to ICMP echo requests (ping).
]]

author = "LabEx User"

categories = {"discovery", "safe"}

-- The rule section determines when the script should be run
hostrule = function(host)
  return true  -- Run the script for all hosts
end

-- The action section contains the main function of the script
action = function(host)
  local output = "Host status: "
  
  if host.pingresponse then
    output = output .. "Responds to ping"
  else
    output = output .. "Does not respond to ping"
  end
  
  return output
end
EOF

Décortiquons ce script :

• La section description explique clairement que le script vérifie si un hôte répond aux requêtes ping.
• La section author indique que le script a été créé par un utilisateur LabEx.
• La section categories regroupe ce script avec d'autres scripts de découverte et de sécurité. Les scripts de découverte sont utilisés pour trouver des informations sur les hôtes, et les scripts de sécurité sont ceux qui ne causent aucun dommage à la cible.
• La fonction hostrule est configurée pour retourner true, ce qui signifie que le script sera exécuté pour tous les hôtes.
• La fonction action contient la logique principale. Elle vérifie si l'hôte a une réponse ping, puis retourne un message indiquant si l'hôte répond ou non aux requêtes ping.

Maintenant, exécutons notre script personnalisé sur le localhost (127.0.0.1). Nous utiliserons la commande nmap avec l'option --script pour spécifier notre script personnalisé.

nmap --script /home/labex/project/my-ping-check.nse 127.0.0.1

Vous devriez voir une sortie similaire à ceci :

Starting Nmap 7.80 ( https://nmap.org )
Nmap scan report for localhost (127.0.0.1)
Host is up (0.000091s latency).
Not shown: 998 closed ports
PORT     STATE SERVICE
22/tcp   open  ssh
| my-ping-check: Host status: Responds to ping
3001/tcp open  nessus
|_my-ping-check: Host status: Responds to ping

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

Cette sortie montre que notre script fonctionne correctement. Il a détecté que le localhost répond aux requêtes ping. C'est un exemple simple, mais il vous montre la structure et la fonction de base d'un script Nmap.

Création et ajout de scripts personnalisés à Nmap

Dans cette étape, nous allons apprendre à créer un script Nmap personnalisé et à l'ajouter à la base de données des scripts Nmap. Nmap est un outil de scan de réseau puissant, et en ajoutant des scripts personnalisés, vous pouvez étendre ses fonctionnalités pour répondre à vos besoins spécifiques. Cela signifie que vous pouvez effectuer des tâches uniques lors des scans de réseau qui ne sont pas couvertes par les scripts Nmap par défaut.

Tout d'abord, créons un nouveau script un peu plus complexe. Ce script vérifiera si un port spécifique est ouvert. Les ports sont comme des portes dans un réseau ; ils permettent différents types de trafic réseau d'entrer ou de sortir d'un appareil. En vérifiant si un port est ouvert, nous pouvons savoir si un service particulier est en cours d'exécution sur un appareil.

cat << 'EOF' > /usr/share/nmap/scripts/port-check.nse
description = [[
A script that checks if a specific port is open and reports its status.
]]

author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}

-- The portrule determines when the script should be run
portrule = function(host, port)
  return port.protocol == "tcp" and port.state == "open"
end

-- The action section contains the main function of the script
action = function(host, port)
  local output = string.format("Port %d is open on host %s", port.number, host.ip)
  return output
end
EOF

Dans le code ci-dessus, nous définissons d'abord une description de ce que le script fait. Ensuite, nous définissons l'auteur et les informations sur la licence. La fonction portrule décide quand le script doit être exécuté. Ici, elle vérifie si le port utilise le protocole TCP et est ouvert. La fonction action est la partie principale du script. Elle crée un message indiquant qu'un port spécifique est ouvert sur un hôte particulier.

Notez que nous avons créé ce script directement dans le répertoire des scripts Nmap (/usr/share/nmap/scripts/). Cela est important car Nmap recherche les scripts dans ce répertoire. Cependant, simplement créer le script n'est pas suffisant. Nmap doit être informé de ce nouveau script, nous devons donc mettre à jour la base de données des scripts Nmap.

Pour mettre à jour la base de données des scripts Nmap, exécutez la commande suivante :

sudo nmap --script-updatedb

La sortie devrait être similaire à :

Starting Nmap 7.80 ( https://nmap.org )
NSE: Updating rule database.
NSE: Script Database updated successfully.
Nmap done: 0 IP addresses (0 hosts up) scanned in 0.36 seconds

Cette sortie montre que la base de données des scripts a été mise à jour avec succès. Maintenant, vérifions que notre script a été ajouté à la base de données des scripts Nmap. Nous pouvons le faire en recherchant notre script dans le fichier script.db.

grep port-check /usr/share/nmap/scripts/script.db

Vous devriez voir une sortie similaire à :

Entry { filename = "port-check.nse", categories = { "discovery", "safe", } }

Cela confirme que notre script a été ajouté avec succès à la base de données des scripts Nmap.

Maintenant, créons un autre script qui montre comment utiliser des bibliothèques dans les scripts Nmap. Les bibliothèques sont des codes pré-écrits que nous pouvons utiliser pour rendre nos scripts plus puissants. Ce script vérifiera les en-têtes HTTP sur les serveurs web. Les en-têtes HTTP contiennent des informations importantes sur une page web, comme le type de serveur, la date de sa dernière modification, etc.

cat << 'EOF' > /usr/share/nmap/scripts/http-headers-check.nse
description = [[
A script that retrieves and displays HTTP headers from web servers.
]]

author = "LabEx User"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"discovery", "safe"}

local http = require "http"
local shortport = require "shortport"
local stdnse = require "stdnse"

-- The portrule determines when the script should be run
portrule = function(host, port)
  return shortport.http(host, port)
end

-- The action section contains the main function of the script
action = function(host, port)
  local response = http.get(host, port, "/")
  
  if not response or not response.status then
    return "Failed to retrieve HTTP headers"
  end
  
  local output = stdnse.output_table()
  output["Status"] = response.status
  
  if response.header then
    output["Headers"] = {}
    for name, value in pairs(response.header) do
      output["Headers"][name] = value
    end
  end
  
  return output
end
EOF

Ce script utilise plusieurs bibliothèques Nmap :

• http pour effectuer des requêtes HTTP. Cette bibliothèque permet à notre script de communiquer avec les serveurs web et d'obtenir des informations d'eux.
• shortport pour déterminer si un port exécute probablement un service HTTP. Elle nous aide à savoir si un port particulier sur un hôte est utilisé pour le trafic web.
• stdnse pour formater la sortie. Cela rend les informations que nous obtenons du serveur web plus faciles à lire.

Mettons à jour à nouveau la base de données des scripts afin que Nmap soit informé de notre nouveau script :

sudo nmap --script-updatedb

Maintenant, exécutons notre nouveau script sur un serveur web. À des fins de démonstration, nous utiliserons un serveur web local sur le port 3001 (qui est souvent utilisé par les serveurs de développement).

nmap --script http-headers-check -p 3001 127.0.0.1

Si aucun serveur web n'est en cours d'exécution sur le port 3001, la sortie indiquera que le port est fermé ou filtré. S'il y a un serveur web, vous verrez les en-têtes HTTP qui ont été récupérés.

Enfin, exécutons nos deux scripts personnalisés ensemble. De cette façon, nous pouvons voir les résultats des deux scripts à la fois.

nmap --script "port-check,http-headers-check" -p 22,3001 127.0.0.1

Cette commande exécutera nos deux scripts personnalisés sur les ports 22 et 3001 du localhost. Le port 22 est couramment utilisé pour les connexions SSH (Secure Shell).

La sortie montrera si ces ports sont ouverts et, si le port 3001 exécute un service HTTP, elle affichera les en-têtes HTTP.

En créant et en ajoutant des scripts personnalisés à Nmap, vous pouvez étendre ses fonctionnalités pour effectuer des tâches spécifiques nécessaires pour vos besoins de scan de réseau et d'évaluation de sécurité.

Exécution de catégories de scripts et gestion de la sortie des scripts

Dans cette étape, nous allons explorer comment exécuter des scripts Nmap par catégorie et gérer la sortie de ces scans de scripts. Cette compétence est très utile car elle vous permet d'exécuter plusieurs scripts liés sans avoir à spécifier chacun d'eux séparément.

Les scripts Nmap sont regroupés en différentes catégories en fonction de ce qu'ils font. Comprendre ces catégories vous aide à trouver et à exécuter rapidement les scripts dont vous avez besoin. Voici quelques catégories courantes :

• auth : Ce sont des scripts liés à l'authentification. Ils peuvent vous aider à vérifier si les mécanismes d'authentification sur une cible sont sécurisés.
• broadcast : Les scripts de cette catégorie envoient des diffusions (broadcasts) sur le réseau local. Ils sont utiles pour découvrir les appareils et les services sur le même réseau.
• brute : Ce sont des scripts d'audit de mot de passe par force brute. Ils essaient différents mots de passe pour voir s'ils peuvent accéder de manière non autorisée à un service.
• default : Lorsque vous utilisez l'option -sC dans Nmap, ce sont ces scripts qui s'exécutent par défaut. Ils constituent un bon point de départ pour un scan de base.
• discovery : Ces scripts sont utilisés pour la découverte d'hôtes et de services. Ils peuvent découvrir quels hôtes sont disponibles sur un réseau et quels services ils exécutent.
• dos : Les scripts de déni de service (Denial of Service) sont conçus pour surcharger un système cible et le rendre indisponible. Soyez prudent lors de leur utilisation, car ils peuvent causer des dommages réels.
• exploit : Les scripts d'exploitation sont utilisés pour tirer parti de vulnérabilités connues dans un système. Ils peuvent être utilisés pour des tests de sécurité, mais doivent être utilisés de manière responsable.
• external : Ces scripts peuvent envoyer des données à des bases de données tierces. Ils peuvent fournir des informations supplémentaires sur la cible, mais vous devez être conscient des implications en matière de confidentialité.
• fuzzer : Les scripts de fuzzing utilisent des techniques de fuzzing. Ils envoient des données aléatoires ou mal formées à une cible pour voir s'ils peuvent faire apparaître des erreurs ou des vulnérabilités.
• intrusive : Les scripts de cette catégorie peuvent faire planter des services ou être considérés comme intrusifs. Utilisez - les avec prudence, surtout dans un environnement de production.
• malware : Les scripts de détection de malware sont utilisés pour vérifier si un système cible est infecté par un malware.
• safe : Ces scripts sont considérés comme sûrs et non intrusifs. Ils ne causeront aucun dommage au système cible.
• version : Les scripts de détection de version vous aident à découvrir la version du logiciel exécuté sur un service cible. Cette information peut être utile pour identifier des vulnérabilités potentielles.
• vuln : Les scripts de détection de vulnérabilités sont utilisés pour trouver des faiblesses de sécurité dans un système cible.

Maintenant, voyons comment exécuter des scripts d'une catégorie spécifique. Par exemple, si vous souhaitez exécuter tous les scripts de la catégorie "discovery", vous pouvez utiliser la commande suivante :

nmap --script discovery 127.0.0.1

Cette commande demande à Nmap d'exécuter tous les scripts de découverte sur le localhost (127.0.0.1). La sortie sera assez longue car elle montre les résultats de tous les scripts de découverte.

Parfois, vous pouvez vouloir exécuter des scripts de plusieurs catégories. Vous pouvez le faire en utilisant une virgule pour séparer les noms de catégories. Voici un exemple :

nmap --script "discovery,safe" -p 1-100 127.0.0.1

Cette commande exécute tous les scripts des catégories discovery et safe sur les ports 1 - 100 du localhost.

Vous pouvez également exclure des catégories spécifiques en utilisant l'opérateur not. Par exemple :

nmap --script "discovery and not broadcast" 127.0.0.1

Cette commande exécute les scripts de découverte, mais exclut ceux qui appartiennent également à la catégorie broadcast.

Ensuite, regardons différentes façons de formater et de sauvegarder la sortie des scans de scripts Nmap. Nmap propose plusieurs formats de sortie, utiles pour différents objectifs :

1. Sortie normale (par défaut) : C'est la sortie texte standard que Nmap affiche à l'écran.
2. Sortie XML : XML est un format structuré qui peut être facilement analysé par d'autres outils.
3. Sortie grepable : Ce format est conçu pour être facilement recherché à l'aide d'outils comme grep.
4. Sortie JSON (avec le script approprié) : JSON est un autre format structuré largement utilisé pour l'échange de données.

Pour sauvegarder la sortie au format XML, vous pouvez utiliser la commande suivante :

nmap --script vuln -p 1-1000 127.0.0.1 -oX /home/labex/project/scan_results.xml

Cette commande exécute tous les scripts de vulnérabilité sur les ports 1 - 1000 du localhost et sauvegarde les résultats au format XML dans le fichier /home/labex/project/scan_results.xml.

Vérifions le contenu du fichier XML :

head -20 /home/labex/project/scan_results.xml

Cette commande affiche les 20 premières lignes de la sortie formatée en XML. Vous verrez des informations sur le scan, les options utilisées et les résultats du scan.

Pour une sortie grepable, vous pouvez utiliser cette commande :

nmap --script "default" 127.0.0.1 -oG /home/labex/project/scan_results.gnmap

Cette commande sauvegarde les résultats dans un format facilement analysable avec des outils comme grep.

Vérifions le contenu du fichier gnmap :

cat /home/labex/project/scan_results.gnmap

Vous verrez que chaque hôte est sur une seule ligne, ce qui facilite la recherche d'informations spécifiques.

Si vous souhaitez sauvegarder la sortie à la fois au format normal et au format XML, vous pouvez utiliser cette commande :

nmap --script "default" 127.0.0.1 -oX /home/labex/project/scan_results2.xml -oN /home/labex/project/scan_results.txt

Cette commande sauvegarde la sortie à la fois au format texte normal et au format XML simultanément.

Enfin, vous pouvez utiliser l'option -oA pour sauvegarder la sortie dans les trois formats (normal, XML et grepable) à la fois :

nmap --script "default" 127.0.0.1 -oA /home/labex/project/all_formats

Cette commande crée trois fichiers :

• /home/labex/project/all_formats.nmap (sortie normale)
• /home/labex/project/all_formats.xml (sortie XML)
• /home/labex/project/all_formats.gnmap (sortie grepable)

En maîtrisant ces techniques pour exécuter des catégories de scripts et gérer la sortie des scripts, vous pouvez effectuer efficacement des scans de réseau et organiser les résultats pour une analyse plus approfondie.

Résumé

Dans ce laboratoire, vous avez appris les compétences essentielles pour travailler avec le moteur de script de Nmap (Nmap Scripting Engine - NSE). Vous avez exploré comment catégoriser et organiser les scripts Nmap en fonction de leur fonctionnalité, ce qui est essentiel pour des scans de réseau et des évaluations de sécurité efficaces.

Vous avez acquis une expérience pratique dans de nombreux domaines, notamment l'exploration des catégories de scripts, la création de répertoires organisés, la compréhension de la structure des scripts, la création de scripts personnalisés, leur ajout à la base de données, l'exécution de scripts par catégorie avec des opérateurs logiques et la gestion de la sortie dans différents formats. Ces compétences vous permettent d'étendre les fonctionnalités de Nmap pour répondre à des besoins spécifiques. En maîtrisant la création, la catégorisation et la mise à jour des scripts, vous pouvez développer des flux de travail de scan plus ciblés et efficaces. La capacité à organiser et à formater les résultats de scan est également utile pour la documentation et la communication avec les membres de l'équipe et les parties prenantes. Au fur et à mesure que vous continuerez à utiliser Nmap, vous pourrez vous appuyer sur ces compétences pour des scripts et des stratégies de scan plus complexes.