Nmap (Network Mapper) est un outil open-source puissant utilisé pour l'exploration réseau et les audits de sécurité. Il permet de détecter les hôtes, les ports ouverts, les services actifs, les systèmes d'exploitation, et même les vulnérabilités. Ce tutoriel complet vous guide pas à pas dans son utilisation dans des contextes DevOps, MLOps, SecOps et DevSecOps modernes.
Nmap, ou Network Mapper, est un outil open source conçu pour l'exploration réseau et les audits de sécurité. Développé initialement par Gordon Lyon (alias Fyodor), Nmap est aujourd'hui un pilier incontournable dans les environnements DevOps, SecOps et plus largement dans la cybersécurité.
Il permet de :
Nmap est extrêmement modulable : il peut être utilisé de manière très simple en ligne de commande pour détecter rapidement si un hôte est actif, ou de manière plus avancée avec des scripts personnalisés capables de simuler des attaques spécifiques.
Traditionnellement utilisé par les pentesters et analystes sécurité, Nmap s'est imposé comme un outil essentiel pour d'autres domaines techniques, notamment :
Apprendre à maîtriser Nmap, ce n’est pas seulement savoir taper quelques commandes. C’est acquérir une capacité d’analyse critique de l’exposition réseau de son système. C’est intégrer une approche préventive et proactive de la sécurité, essentielle dans les environnements modernes.
Le reste du cours vous apprendra à utiliser Nmap non pas comme un gadget ponctuel, mais comme un outil quotidien et intégré à votre cycle de développement, de déploiement et de supervision.
Ouvrez un terminal et tapez :
sudo apt update sudo apt install nmap -y
Cela installera la dernière version disponible dans les dépôts officiels.
sudo dnf install nmap -y
sudo pacman -S nmap
Utilisez Homebrew :
brew install nmap
Assurez-vous que brew est installé avant (voir https://brew.sh/).
cmd.exe et tapez :nmap -v
Vous devriez voir s’afficher la version installée.
C’est l’interface par défaut de Nmap. Elle permet :
Exemple de commande simple :
nmap 192.168.1.1
Zenmap est une interface GUI qui facilite l’usage de Nmap pour les débutants. Elle permet de :
Astuce : même si vous débutez avec Zenmap, entraînez-vous à lire et modifier la commande affichée.
Un scan Nmap se décompose en plusieurs étapes :
Nous abordons ici les bases :
nmap -sS 192.168.1.1
Ce type de scan :
Note : Nécessite les privilèges root/administrateur sur la plupart des OS.
nmap -sT 192.168.1.1
connect() du système d’exploitationnmap -sU 192.168.1.1
Conseil : combiner avec TCP pour un scan complet :
sudo nmap -sS -sU 192.168.1.1
nmap -sn 192.168.1.0/24
Utilité : cartographier les machines d’un réseau local ou cloud
-sS : scan TCP SYN (rapide, discret, nécessite root)sudo nmap -sS 192.168.1.1
-sU : scan UDPsudo nmap -sU 192.168.1.1
-Pn : ne fait pas de ping préalable (utile sur les machines qui ne répondent pas à l’ICMP)nmap -Pn 192.168.1.1
-p : sélectionner les ports à scannernmap -p 22,80,443 192.168.1.1
-p- pour scanner tous les ports (1 à 65535)-T : définir l’agressivité du scan (de T0 à T5)nmap -T4 192.168.1.1
T0 : très lent (furtif)T3 : équilibré (par défaut)T5 : très rapide (bruyant)Recommandé pour CI/CD ou scan rapide :
nmap -T4 -F 192.168.1.1
(-F = fast scan sur les ports les plus communs)
| Objectif | Commande |
|---|---|
| Scan rapide | nmap -T4 -F 192.168.1.1 |
| Scan tous ports TCP | sudo nmap -sS -p- 192.168.1.1 |
| Scan UDP | sudo nmap -sU 192.168.1.1 |
| Ping sweep | nmap -sn 192.168.1.0/24 |
| Sans ping ICMP | nmap -Pn 192.168.1.1 |
| Ports spécifiques | nmap -p 22,80,443 192.168.1.1 |
| Scan lent/discret | nmap -T1 -sS 192.168.1.1 |
Ă€ ce stade, vous ĂŞtes capable de :
Dans la prochaine partie, nous apprendrons à identifier les systèmes, services et applications exposés, et à exporter les résultats pour les intégrer à un processus de supervision ou d’analyse de vulnérabilité.
L’un des grands points forts de Nmap est sa capacité à identifier les systèmes d’exploitation, les services actifs et les applications en réseau. Cela permet de comprendre exactement ce qui tourne sur une machine, pour anticiper les risques ou faire de l’inventaire automatisé.
-O)sudo nmap -O 192.168.1.1
Cette option déclenche une tentative de détection du système d’exploitation distant. Elle s’appuie sur :
Conditions nécessaires :
Conseil : combinez avec -sS et -v pour plus de détails :
sudo nmap -sS -O -v 192.168.1.1
-sV)nmap -sV 192.168.1.1
Cette option permet d’identifier :
Utilité :
Conseil : combinez avec -p pour ne scanner que certains ports :
nmap -sV -p 22,80,443 192.168.1.1
Certaines bannières de services (retours de type "220 OpenSSH 8.2p1 Ubuntu") sont suffisantes pour déduire des informations sensibles.
Pour les afficher manuellement :
nmap -sV --version-all 192.168.1.1
Cela lance tous les tests de version disponibles, ce qui peut être plus long mais plus précis.
nmap -sn 192.168.1.0/24
Conseil : combinez avec -oG pour un résultat facilement analysable :
nmap -sn 192.168.1.0/24 -oG subnet_scan.txt
Une fois un scan complet effectué, vous pouvez filtrer les résultats pour ne garder que certains OS ou services.
Exemple avec grep sur les OS Linux :
grep -i linux subnet_scan.txt
Ou sur les services HTTP :
grep -i http subnet_scan.txt
Pour une approche plus structurée, utilisez le format XML ou JSON (voir section suivante).
Nmap permet d’exporter les résultats dans plusieurs formats.
nmap -oG resultats.txt 192.168.1.0/24
nmap -oX resultats.xml 192.168.1.0/24
nmap2json, un outil externe)Nmap ne supporte pas le JSON nativement, mais vous pouvez convertir :
pip install nmaptocsv nmap -oX resultats.xml 192.168.1.0/24 nmaptocsv -i resultats.xml -o resultats.csv --fields ip-address,ports
Ou utiliser xml2json sur le XML produit.
ndiff (comparaison de scans)ndiff permet de comparer deux fichiers de scan Nmap :
nmap -oX scan1.xml 192.168.1.0/24 # quelques jours plus tard nmap -oX scan2.xml 192.168.1.0/24 ndiff scan1.xml scan2.xml
Cela affiche :
xsltprocPour transformer le XML en page HTML :
xsltproc /usr/share/nmap/nmap.xsl resultats.xml -o rapport.html
Puis ouvrez rapport.html dans un navigateur.
webxmlwebxml est une interface web qui permet de naviguer facilement dans un fichier XML généré par Nmap. Elle peut être auto-hébergée ou utilisée localement.
Installation :
git clone https://github.com/mrschyte/webxml cd webxml # Placez vos .xml dans le dossier prévu, ouvrez index.html
Vous pouvez générer un graphe des relations réseau à partir des données Nmap (avec traitement préalable du XML ou nmap -oG).
Exemple de pipeline :
nmap -oG res.txt 192.168.1.0/24 # Utiliser un script Python pour transformer en .dot # Puis générer l’image neato -Tpng fichier.dot -o reseau.png
Cela permet :
ndiff)| Objectif | Commande ou outil |
|---|---|
| Détecter l’OS | sudo nmap -O IP |
| DĂ©tecter versions services | nmap -sV IP |
| Export XML | nmap -oX fichier.xml IP |
| Comparer deux scans | ndiff scan1.xml scan2.xml |
| HTML Ă partir XML | xsltproc nmap.xsl fichier.xml -o .html |
| Visualisation Web | webxml |
| Analyse structurée | JSON + ELK / CSV |
Ă€ ce stade, vous ĂŞtes capable de :
La prochaine étape consistera à passer à la détection de vulnérabilités, un aspect central du travail SecOps/DevSecOps.
Le Nmap Scripting Engine (NSE) permet d'exécuter des scripts Lua embarqués dans Nmap, conçus pour :
Ces scripts sont classés en catégories :
auth : authentification, brute forcedefault : scripts activés par défautdiscovery : exploration réseauexploit : exploitation de vulnérabilitésvuln : détection de vulnérabilités connuesPour voir tous les scripts disponibles :
ls /usr/share/nmap/scripts/
Ou directement dans Nmap :
nmap --script-help=all
vulnC’est un script « méta » qui regroupe plusieurs tests de vulnérabilités :
nmap --script vuln 192.168.1.1
Il peut détecter :
http-enumListe les répertoires et services d’un serveur web.
nmap -p 80 --script http-enum 192.168.1.1
ftp-anonTeste si l’accès FTP anonyme est activé.
nmap -p 21 --script ftp-anon 192.168.1.1
--script sshv1 # Détection de SSHv1 --script smb-os-discovery # Découverte système via SMB --script dns-zone-transfer # Test de transfert DNS
Pour scanner un hôte et rechercher des vulnérabilités sur certains ports :
sudo nmap -sV --script vuln -p 21,22,80,443 192.168.1.1
Ou pour des catégories spécifiques :
sudo nmap -sV --script "default or vuln" 192.168.1.1
Les IDS (Intrusion Detection Systems) détectent souvent les scans Nmap. Heureusement, Nmap fournit plusieurs options pour rester discret.
--data-length <taille>Ajoute des données aléatoires dans les paquets pour brouiller les signatures.
nmap --data-length 50 192.168.1.1
--randomize-hostsMélange l’ordre des IP scannées (utile dans une plage IP).
nmap --randomize-hosts -iL liste_ips.txt
--spoof-mac <valeur>Change l’adresse MAC source pour chaque scan.
nmap --spoof-mac Apple 192.168.1.1
Ou valeur aléatoire :
nmap --spoof-mac 0 192.168.1.1
-T (Timing template)Utilisez des scans plus lents pour passer sous les radars :
nmap -T1 192.168.1.1
-f (fragmentation)Envoie des paquets fragmentés pour éviter la détection :
sudo nmap -f 192.168.1.1
--scan-delay <temps>Ajoute un délai entre chaque paquet :
nmap --scan-delay 5s 192.168.1.1
Combinaison furtive recommandée :
sudo nmap -sS -T1 -f --data-length 50 --spoof-mac 0 192.168.1.1
Vous pouvez intégrer Nmap dans un pipeline GitLab, GitHub Actions ou Jenkins pour automatiser les scans à chaque build ou déploiement.
.gitlab-ci.ymlstages: - scan nmap_scan: stage: scan image: instrumentisto/nmap script: - nmap -sV --script vuln -oX report.xml 192.168.1.1 artifacts: paths: - report.xml
name: Scan réseau on: [push] jobs: scan: runs-on: ubuntu-latest steps: - name: Installer Nmap run: sudo apt-get install nmap -y - name: Lancer le scan run: nmap -sV --script vuln -oX report.xml 192.168.1.1 - name: Enregistrer le rapport uses: actions/upload-artifact@v2 with: name: rapport-nmap path: report.xml
Ajoutez une Ă©tape dans le pipeline pour :
xsltprocxsltproc /usr/share/nmap/nmap.xsl report.xml -o rapport.html wkhtmltopdf rapport.html rapport.pdf
Utilisez un script Python pour parser le fichier XML et envoyer des alertes si :
import xml.etree.ElementTree as ET arbre = ET.parse("report.xml") racine = arbre.getroot() for hote in racine.findall("host"): for port in hote.findall("ports/port"): state = port.find("state").get("state") if state == "open": service = port.find("service") if service is not None and "vuln" in str(service.attrib): print("Alerte :", port.attrib, service.attrib)
| Objectif | Commande ou outil |
|---|---|
| Scan de vulnérabilité complet | nmap --script vuln -sV IP |
| Scan web | nmap -p 80 --script http-enum IP |
| Scan discret | nmap -sS -f -T1 --spoof-mac 0 IP |
| Export XML | -oX rapport.xml |
| Intégration GitLab / GitHub | .gitlab-ci.yml, GitHub Actions |
| Génération HTML | xsltproc |
| Parsing automatisé + alerting | Python + xml.etree.ElementTree |
À présent, vous êtes capable d’utiliser Nmap pour :
Nous passerons ensuite à des cas d’usage spécifiques DevOps/MLOps, avec des scans adaptés aux environnements en production, cloud ou conteneurisés.
L’usage de Nmap dans une logique DevOps vise à visualiser l’infrastructure réseau, vérifier la disponibilité des services et sécuriser les déploiements à toutes les étapes du cycle de vie applicatif.
Obtenir une vue d’ensemble actualisée des services exposés dans un réseau DevOps (serveurs d'applications, bases de données, outils CI/CD, etc.).
nmap -sn 10.0.0.0/24 -oG hosts.txt
grep Up hosts.txt | cut -d ' ' -f 2 > active_ips.txt
nmap -sV -iL active_ips.txt -oX infra.xml
xsltproc /usr/share/nmap/nmap.xsl infra.xml -o infra.html
Nmap permet de vérifier si un service est présent ET fonctionnel (pas juste ouvert).
nmap -p 5432 --script pgsql-brute 10.0.0.15
nmap -p 80 --script http-title 10.0.0.42
Intégrez les scans dans les étapes clés de votre pipeline :
nmap -sS -p- 10.0.0.0/24 -oG audit_post_deploy.txt
Puis comparer avec l’audit précédent via ndiff.
Les environnements MLOps contiennent souvent des éléments exposés : API de modèles, Jupyter, TensorBoard, services REST… Il est crucial de détecter les ports et services ouverts sur ces machines.
nmap -p 5000 --script http-title 10.0.0.33
-sV pour identifier les frameworksnmap --script http-methods -p 5000 10.0.0.33
Si vous utilisez Docker ou Kubernetes, vous pouvez scanner les conteneurs depuis l’extérieur du cluster (réseau host) ou depuis un conteneur/pod.
nmap -sS 172.17.0.0/16
docker run -it --network host instrumentisto/nmap /bin/sh
# Jupyter Notebook nmap -p 8888 --script http-auth 10.0.0.20 # Airflow Web UI nmap -p 8080 --script http-title 10.0.0.21 # MLflow nmap -p 5000-5001 10.0.0.22
Conseil : créez une liste de ports connus de vos outils ML et scannez-la régulièrement :
nmap -p 8888,5000,5001,8080 -sV 10.0.0.0/24
Dans Kubernetes, vous pouvez scanner le réseau interne depuis un pod Nmap :
kubectl run nmap --rm -it --image=instrumentisto/nmap -- bash
Puis, depuis ce pod :
nmap -sS 10.244.0.0/16
Limites :
Solution : déployer Nmap sur un node avec plus de droits, ou utiliser hostNetwork: true dans votre pod.
Exemple de scan entre 2 VPC peered :
nmap -Pn -sS -p- 172.31.0.0/16
Exemple :
nmap -p- -sV 10.244.0.0/16
Puis chercher :
Conseils :
| Cas d’usage | Commande clé / stratégie |
|---|---|
| Cartographie infra DevOps | nmap -sn, -sV, xsltproc |
| VĂ©rification service post-deploy | nmap -sV -p <port> |
| API ML non sécurisées | --script http-methods, http-auth |
| Scan dans un conteneur | docker run --network host |
| Scan entre pods K8s | kubectl run nmap ... |
| Inter-région cloud | nmap -Pn + config peering |
| Audit surface d’attaque cluster | nmap -p- -sV <range interne> |
Avec ces cas pratiques, vous êtes maintenant capable d’adapter Nmap à votre contexte spécifique — qu’il s’agisse d’un cluster Kubernetes, d’un pipeline DevOps, d’un environnement MLOps sensible ou d’une infrastructure cloud distribuée. La partie suivante vous apprendra à créer vos propres scripts personnalisés avec le moteur NSE pour aller encore plus loin.
Le Nmap Scripting Engine (NSE) permet de créer des scripts personnalisés en Lua pour étendre les fonctionnalités de Nmap : détection spécifique, exploitation, tests de configuration, etc.
Un script NSE est un fichier .nse écrit en Lua. Il doit suivre une structure précise.
mon_script.nselocal nmap = require "nmap" local shortport = require "shortport" local stdnse = require "stdnse" portrule = shortport.http action = function(host, port) return "Mon script personnalisé fonctionne sur " .. host.ip end
require : importer les bibliothèques internes de Nmapportrule : fonction de test de port (ex : shortport.http, port.number == 80...)action : fonction exécutée sur chaque hôte/port correspondant à la règlelocal http = require "http"
Permet d’envoyer des requêtes HTTP, analyser les réponses, headers, etc.
local ssh = require "ssh"
Permet de tester les versions ou de faire du brute-force.
local brute = require "brute"
Librairie spécialisée dans les attaques par dictionnaire (login/password).
Bibliothèque standard NSE (logging, timeout, format, etc.) :
stdnse.debug1("Message de debug")
/status avec un champ "status": "OK"api_status.nse dans /usr/share/nmap/scripts/local http = require "http" local json = require "json" local shortport = require "shortport" portrule = shortport.http action = function(host, port) local path = "/status" local response = http.get(host, port, path) if not response then return nil end local body = response.body local decoded = json.parse(body) if decoded and decoded.status == "OK" then return "API interne opérationnelle (status OK)" else return "API détectée, mais pas de status OK" end end
nmap -p 5000 --script api_status 10.0.0.42
PORT STATE SERVICE
5000/tcp open http
| api_status:
| API interne opérationnelle (status OK)
Important : Nmap est un outil puissant, et son usage sans autorisation explicite peut être considéré comme une intrusion illégale.
Conseil : Utilisez des environnements de test ou des machines virtuelles pour apprendre.
nmap -sV --script default,vuln -p 22,80 IP
masscan 192.168.1.0/24 -p0-65535 --rate=10000
rustscan -a 192.168.1.1 -- -sV
zmap -p 80 0.0.0.0/0
Conseil : utilisez Nmap pour la profondeur (détail), et Masscan/RustScan pour la largeur (vitesse).
| Option | Description |
|---|---|
-sS | Scan TCP SYN (rapide, furtif, nécessite root) |
-sT | Scan TCP connect (standard, sans privilèges root) |
-sU | Scan UDP |
-sV | DĂ©tection de version des services |
-O | Détection de système d’exploitation |
-p | Spécifie les ports à scanner (ex : -p 22,80 ou -p- pour tous) |
-T0 à -T5 | Réglage de la vitesse/agressivité du scan |
-A | Scan avancé : OS + version + script + traceroute |
-Pn | Ne fait pas de ping avant le scan (utilisé sur des machines protégées) |
-sn | Ping sweep (détecte les hôtes actifs sans scanner les ports) |
--script | Active un ou plusieurs scripts NSE |
-oG | Export format grepable |
-oX | Export format XML |
--open | Affiche uniquement les ports ouverts |
-iL | Liste d’IP à scanner (à partir d’un fichier texte) |
--spoof-mac | Change l’adresse MAC pour chaque scan |
--data-length | Ajoute des données dans les paquets pour évasion IDS |
# Scan rapide (100 ports les + courants) nmap -T4 -F 192.168.1.1 # Scan complet TCP (tous les ports) sudo nmap -sS -p- 192.168.1.1 # Scan UDP sudo nmap -sU 192.168.1.1 # Ping sweep (liste des machines actives) nmap -sn 192.168.1.0/24 # Scan de version + OS sudo nmap -sS -sV -O 192.168.1.1 # Scan avec détection de vulnérabilités nmap -sV --script vuln 192.168.1.1 # Scan furtif sudo nmap -sS -T1 --spoof-mac 0 --data-length 50 192.168.1.1 # Export XML pour traitement ou rapport nmap -sS -oX rapport.xml 192.168.1.1 # Comparaison de deux scans ndiff scan1.xml scan2.xml # Script personnalisé (API interne) nmap -p 5000 --script api_status 192.168.1.1
Travailler dans un environnement contrôlé est essentiel pour apprendre Nmap en toute sécurité. Voici plusieurs options :
Créez un réseau privé local avec plusieurs conteneurs :
docker network create testnet # Lancement de 3 conteneurs avec services variés for i in 1 2 3; do \ docker run -d --name host$i --network testnet -p 80$i:80 nginx; \ done # Scanner le réseau Docker (généralement 172.18.0.0/16) nmap -sn 172.18.0.0/24
Créer un environnement multi-VM (Debian, Ubuntu, Windows) sur votre machine locale.
Vagrantfile :Vagrant.configure("2") do |config| config.vm.define "debian" do |debian| debian.vm.box = "debian/bullseye64" debian.vm.network "private_network", ip: "192.168.56.10" end config.vm.define "ubuntu" do |ubuntu| ubuntu.vm.box = "ubuntu/focal64" ubuntu.vm.network "private_network", ip: "192.168.56.11" end end
Puis :
vagrant up nmap -sS 192.168.56.0/24
Ces plateformes offrent des machines virtuelles prêtes à être scannées.
Utilisez un vieux routeur ou switch, branchez plusieurs machines, configurez des IP fixes, puis scannez votre réseau local privé.
Rappel : ne jamais scanner un réseau que vous ne possédez pas ou pour lequel vous n'avez pas l'autorisation explicite.
Avec ces ressources, lexiques et environnements, vous avez tout en main pour progresser rapidement, en toute sécurité, et approfondir vos compétences Nmap dans des contextes réels ou simulés.