Lab 5.1: Reconnaissance Réseau avec Nmap

Objectifs d'Apprentissage

À la fin de ce laboratoire, vous serez capable de:

• Installer et configurer Nmap sur Windows et Linux
• Réaliser différents types de scans réseau
• Identifier les hôtes actifs sur un réseau
• Découvrir les ports ouverts et services en écoute
• Détecter les systèmes d'exploitation à distance
• Identifier les vulnérabilités connues avec les scripts NSE
• Interpréter les résultats de scan pour évaluation de sécurité
• Comprendre les techniques d'évasion de détection

Durée Estimée

40 minutes

Prérequis

• 2 VMs: Windows et Kali Linux (ou 2 Windows)
• Réseau interne VirtualBox configuré
• Compréhension du modèle TCP/IP
• Connaissances en ports et services

Contexte Professionnel

Nmap (Network Mapper) est l'outil de scan réseau le plus utilisé au monde par:

• Administrateurs système pour inventaire réseau
• Professionnels de sécurité pour tests de pénétration
• Analystes SOC pour détection d'anomalies
• Auditeurs pour vérification de conformité

Nmap permet de:

• Découvrir tous les appareils sur un réseau
• Identifier les services exposés
• Détecter les systèmes d'exploitation
• Trouver des vulnérabilités connues
• Valider les configurations de pare-feu
• Cartographier l'infrastructure réseau

---

AVERTISSEMENT ÉTHIQUE ET LÉGAL

Scanner un réseau sans autorisation est illégal dans la plupart des juridictions.

AUTORISÉ:

• Sur votre propre réseau de lab (VMs isolées)
• Sur des systèmes dont vous êtes propriétaire
• Dans le cadre de tests de pénétration avec contrat signé
• Sur des plateformes de lab légales (HackTheBox, TryHackMe)

STRICTEMENT INTERDIT:

• Scanner des réseaux d'entreprise sans autorisation écrite
• Scanner des réseaux publics ou d'autrui
• Scanner Internet aléatoirement
• Utiliser pour identifier des cibles à attaquer

CONSÉQUENCES LÉGALES: Scanner sans autorisation = Reconnaissance illégale, prélude à attaque informatique (Code criminel art. 342.1). Détection facile via IDS/IPS. Poursuite criminelle probable.

Configuration requise pour ce lab:

• Réseau de VMs en mode INTERNE uniquement
• Pas d'accès Internet
• Environnement isolé et contrôlé

---

Partie 1: Installation et Configuration

Étape 1.1: Installation sur Windows

Téléchargement:

• Site officiel: https://nmap.org/download.html
• Téléchargez: "Latest stable release self-installer"
• Version recommandée: 7.94 ou plus récente

Installation:

1. Exécutez le fichier .exe téléchargé
2. Acceptez la licence
3. Composants recommandés:
   • Nmap Core Files (obligatoire)
   • Npcap (obligatoire - pour capture de paquets)
   • Zenmap GUI (optionnel mais utile pour débuter)
   • Ndiff (optionnel)
4. Installation complète

Vérification:

nmap --version

Résultat attendu:

Nmap version 7.94 ( https://nmap.org )
Platform: x86_64-w64-mingw32
Compiled with: ...

Étape 1.2: Installation sur Kali Linux

Nmap est préinstallé sur Kali Linux!

Vérification:

nmap --version

Mise à jour si nécessaire:

sudo apt update
sudo apt install nmap -y

Étape 1.3: Configuration Réseau du Lab

Architecture du lab:

VM1 (Kali Linux - Scanner):
  IP: 192.168.100.10
  Rôle: Effectuer les scans

VM2 (Windows - Cible):
  IP: 192.168.100.20
  Rôle: Système à scanner
  Services: Plusieurs ports ouverts

Réseau: Internal Network "LabNet"

Sur chaque VM, vérifiez la connectivité:

ping 192.168.100.20  # Depuis Kali
ping 192.168.100.10  # Depuis Windows

Questions:

1. Quelle version de Nmap avez-vous installée?
2. Les deux VMs peuvent-elles communiquer?

---

Partie 2: Découverte d'Hôtes (Host Discovery)

Étape 2.1: Ping Scan Basique

Le scan le plus simple:

nmap 192.168.100.20

Résultat:

Starting Nmap 7.94
Nmap scan report for 192.168.100.20
Host is up (0.00050s latency).
Not shown: 995 closed ports
PORT     STATE SERVICE
135/tcp  open  msrpc
139/tcp  open  netbios-ssn
445/tcp  open  microsoft-ds
3389/tcp open  ms-wbt-server
5357/tcp open  wsdapi

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

Analyse:

• Hôte actif (up)
• 5 ports ouverts détectés
• Services identifiés
• Temps de scan: ~2 secondes

Étape 2.2: Scan d'un Réseau Complet

Scanner toute une plage d'IPs:

nmap 192.168.100.0/24

Options:

• /24 = 256 adresses (192.168.100.0 à 192.168.100.255)
• /16 = 65,536 adresses
• /8 = 16,777,216 adresses

Résultat:

Nmap scan report for 192.168.100.1
Host is up (0.00010s latency).

Nmap scan report for 192.168.100.10
Host is up (0.00012s latency).

Nmap scan report for 192.168.100.20
Host is up (0.00015s latency).

Nmap done: 256 IP addresses (3 hosts up) scanned in 4.21 seconds

3 hôtes actifs découverts en 4 secondes sur 256 IPs scannées!

Étape 2.3: Host Discovery Sans Scan de Ports

Juste découvrir quels hôtes sont actifs (pas de scan de ports):

nmap -sn 192.168.100.0/24

Option -sn: Ping scan seulement (no port scan)

Plus rapide: Scan complet en moins de 2 secondes!

Questions: 3. Combien d'hôtes actifs avez-vous découverts sur votre réseau de lab? 4. Quelle est la différence de temps entre scan avec et sans ports?

---

Partie 3: Scan de Ports

Étape 3.1: Types de Scans

TCP Connect Scan (par défaut pour non-root):

nmap -sT 192.168.100.20

• Connexion TCP complète (3-way handshake)
• Fiable mais détectable
• Ne nécessite pas de privilèges root

TCP SYN Scan (furtif, root requis):

sudo nmap -sS 192.168.100.20

• Connexion TCP incomplete (SYN seulement)
• Plus furtif
• Requiert privilèges root/admin

UDP Scan:

sudo nmap -sU 192.168.100.20

• Scanne les ports UDP
• Plus lent que TCP
• Important pour DNS, DHCP, SNMP

Étape 3.2: Scan de Tous les Ports

Par défaut: Nmap scanne seulement les 1000 ports les plus courants

Scanner TOUS les 65535 ports:

nmap -p- 192.168.100.20

Option -p-: Tous les ports (1-65535)

ATTENTION: Peut prendre 10-20 minutes!

Alternative rapide:

nmap -p- --min-rate 5000 192.168.100.20

--min-rate 5000: Minimum 5000 paquets/seconde = Scan en 30-60 secondes!

Étape 3.3: Scan de Ports Spécifiques

Ports spécifiques:

nmap -p 80,443,3389,445 192.168.100.20

Plage de ports:

nmap -p 1-1000 192.168.100.20

Combinaison:

nmap -p 22,80,443,1000-2000,3389,8080 192.168.100.20

Questions: 5. Quels sont les ports ouverts sur votre VM Windows? 6. Combien de temps prend un scan complet de tous les ports?

---

Partie 4: Détection de Services et Versions

Étape 4.1: Service Version Detection

Scanner avec détection de versions:

nmap -sV 192.168.100.20

Option -sV: Version detection

Résultat détaillé:

PORT     STATE SERVICE       VERSION
135/tcp  open  msrpc         Microsoft Windows RPC
139/tcp  open  netbios-ssn   Microsoft Windows netbios-ssn
445/tcp  open  microsoft-ds  Microsoft Windows Server 2016 microsoft-ds
3389/tcp open  ms-wbt-server Microsoft Terminal Services
5357/tcp open  http          Microsoft HTTPAPI httpd 2.0 (SSDP/UPnP)

Informations obtenues:

• Nom exact du service
• Version du logiciel
• Informations additionnelles

Intensité de détection:

nmap -sV --version-intensity 9 192.168.100.20

• 0 = Léger (rapide)
• 9 = Intensif (complet mais lent)

Étape 4.2: Détection du Système d'Exploitation

OS Detection:

sudo nmap -O 192.168.100.20

Option -O: OS detection (requiert root)

Résultat:

Running: Microsoft Windows 10|2016|2019
OS CPE: cpe:/o:microsoft:windows_10 cpe:/o:microsoft:windows_server_2016
OS details: Microsoft Windows 10 1709 - 1909, or Windows Server 2016 - 2019
Network Distance: 1 hop

Précision typique: 85-95%

Étape 4.3: Scan Agressif Complet

Combinaison de toutes les options:

sudo nmap -A 192.168.100.20

Option -A: Aggressive scan (équivalent à -sV -O -sC --traceroute)

Inclut:

• Version detection
• OS detection
• Script scanning
• Traceroute

Questions: 7. Quel système d'exploitation Nmap a-t-il détecté? 8. Quelle est la version de SMB (port 445) installée?

---

Partie 5: Scripts NSE (Nmap Scripting Engine)

Étape 5.1: Qu'est-ce que NSE?

NSE: Scripts Lua pour automatiser des tâches avancées:

• Détection de vulnérabilités
• Brute-forcing
• Énumération avancée
• Exploitation de services

Catégories de scripts:

• auth - Authentication
• brute - Brute force
• discovery - Découverte
• exploit - Exploitation
• vuln - Vulnérabilités

Étape 5.2: Scan avec Scripts Par Défaut

nmap -sC 192.168.100.20

Option -sC: Script scan (scripts par défaut)

Résultat exemple:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb2-security-mode: 
|   2.02: 
|     Message signing enabled but not required
| smb2-time: 
|   date: 2024-11-08T15:30:45

Informations additionnelles obtenues!

Étape 5.3: Scripts de Vulnérabilités

Scanner pour vulnérabilités connues:

nmap --script vuln 192.168.100.20

Résultat si vulnérable:

PORT    STATE SERVICE
445/tcp open  microsoft-ds

Host script results:
| smb-vuln-ms17-010: 
|   VULNERABLE:
|   Remote Code Execution vulnerability in Microsoft SMBv1 servers (ms17-010)
|     State: VULNERABLE
|     IDs:  CVE:CVE-2017-0143
|     Risk factor: HIGH
|       EternalBlue / MS17-010

CRITIQUE: Vulnérabilité EternalBlue détectée (celle de WannaCry!)

Étape 5.4: Scripts SMB Enum

Énumération complète de SMB:

nmap --script smb-enum-shares,smb-enum-users,smb-os-discovery 192.168.100.20

Informations obtenues:

Host script results:
| smb-enum-shares: 
|   account_used: guest
|   \\192.168.100.20\ADMIN$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\C$: 
|     Type: STYPE_DISKTREE_HIDDEN
|   \\192.168.100.20\IPC$: 
|     Type: STYPE_IPC_HIDDEN
|     
| smb-os-discovery: 
|   OS: Windows 10 Pro (build 19041)
|   Computer name: DESKTOP-ABC123
|   Domain name: WORKGROUP

Énumération complète du système cible!

Questions: 9. Quels partages SMB sont disponibles? 10. Quelles vulnérabilités Nmap a-t-il détectées?

---

Partie 6: Techniques de Scan Avancées

Étape 6.1: Scan Rapide (Top Ports)

Scanner seulement les ports les plus courants:

nmap --top-ports 20 192.168.100.0/24

Scanne les 20 ports les plus communs sur tout le réseau

Encore plus rapide:

nmap --top-ports 100 --min-rate 10000 192.168.100.0/24

• Top 100 ports
• Minimum 10,000 paquets/seconde
• Scan complet réseau en quelques secondes!

Étape 6.2: Timing Templates

Nmap offre 6 templates de vitesse:

nmap -T0 target  # Paranoid (très lent, furtif)
nmap -T1 target  # Sneaky (lent, furtif)
nmap -T2 target  # Polite (lent, moins de charge)
nmap -T3 target  # Normal (défaut)
nmap -T4 target  # Aggressive (rapide)
nmap -T5 target  # Insane (très rapide, peut manquer des ports)

Pour ce lab, utilisez T4:

nmap -T4 -sV -O 192.168.100.20

Scan complet et rapide!

Étape 6.3: Output et Formats de Résultats

Sauvegarder résultats dans fichier:

Format normal (lisible):

nmap 192.168.100.20 -oN scan_results.txt

Format XML (pour outils):

nmap 192.168.100.20 -oX scan_results.xml

Format Grepable (pour parsing):

nmap 192.168.100.20 -oG scan_results.gnmap

Tous les formats en même temps:

nmap 192.168.100.20 -oA scan_complete

Génère: scan_complete.nmap, scan_complete.xml, scan_complete.gnmap

Questions: 11. Quel format de sortie est le plus utile pour analyse automatisée? 12. Comment parseriez-vous les résultats avec PowerShell?

---

Partie 7: Scénarios d'Utilisation Réels

Étape 7.1: Scan de Réseau d'Entreprise (Simulation)

Scénario: Audit de sécurité d'un réseau d'entreprise

Phase 1 - Découverte initiale:

nmap -sn 192.168.100.0/24 -oA discovery

Phase 2 - Scan rapide des hôtes actifs:

nmap -iL discovery.gnmap -sV --top-ports 1000 -T4 -oA quick_scan

Phase 3 - Scan approfondi des serveurs:

nmap -iL servers.txt -sV -sC -O -p- -T4 -oA deep_scan

Phase 4 - Scan de vulnérabilités:

nmap -iL servers.txt --script vuln -oA vuln_scan

Résultat: Rapport complet de sécurité du réseau!

Étape 7.2: Identification de Machines Vulnérables

Script pour trouver systèmes vulnérables:

# Chercher Windows XP/7/8 (non supportés)
nmap -O 192.168.100.0/24 | grep -B 5 "Windows XP\|Windows 7\|Windows 8"

# Chercher SMBv1 (vulnérable à EternalBlue)
nmap --script smb-protocols 192.168.100.0/24 | grep -B 10 "SMBv1"

# Chercher services avec versions anciennes
nmap -sV 192.168.100.0/24 | grep -i "apache 2.2\|openssh 7.4"

Priorisation des cibles:

1. OS non supportés
2. Services avec CVE connues
3. Ports sensibles ouverts (RDP, SMB, etc.)

Étape 7.3: Cartographie Réseau Complète

Scan exhaustif pour documentation:

nmap -sV -sC -O -p- --script discovery -T4 192.168.100.0/24 -oA network_map

Puis analysez avec Zenmap (GUI):

zenmap

File → Open → network_map.xml

Visualisation graphique du réseau!

Questions: 13. Combien de temps prend un scan complet de votre réseau de lab? 14. Quelles informations critiques avez-vous découvertes?

---

Partie 8: Techniques Offensives

Étape 8.1: Brute Force de Services

SSH Brute Force:

nmap --script ssh-brute --script-args userdb=users.txt,passdb=passwords.txt -p 22 target

RDP Brute Force:

nmap --script rdp-brute -p 3389 target

SMB Brute Force:

nmap --script smb-brute -p 445 target

ATTENTION: Brute force génère beaucoup de logs! Détection facile.

Étape 8.2: Exploitation avec Scripts NSE

Chercher exploits disponibles:

ls /usr/share/nmap/scripts/*exploit*

Exemple - MS08-067 (ancien mais pour démonstration):

nmap --script smb-vuln-ms08-067 192.168.100.20

Si vulnérable, le script l'indiquera!

Liste des scripts vulns:

nmap --script-help vuln

Étape 8.3: Firewall Evasion

Techniques pour contourner détection:

Fragment packets:

nmap -f 192.168.100.20

Decoy scans (faux scans depuis autres IPs):

nmap -D RND:10 192.168.100.20

Spoof source IP:

sudo nmap -S 192.168.100.50 -e eth0 192.168.100.20

Randomize scan order:

nmap --randomize-hosts 192.168.100.0/24

Questions: 15. Pourquoi utiliser des techniques d'évasion? 16. Un pare-feu peut-il bloquer complètement Nmap?

---

Partie 9: Automatisation et Reporting

Étape 9.1: Script de Scan Automatisé

Créez auto_scan.sh:

#!/bin/bash

TARGET=$1
OUTPUT_DIR="nmap_scans_$(date +%Y%m%d_%H%M%S)"

mkdir -p $OUTPUT_DIR

echo "[*] Starting automated scan of $TARGET"
echo "[*] Output directory: $OUTPUT_DIR"

# Phase 1: Host Discovery
echo "[*] Phase 1: Host Discovery"
nmap -sn $TARGET -oA $OUTPUT_DIR/01_discovery

# Phase 2: Quick Scan
echo "[*] Phase 2: Quick Port Scan"
nmap -sV --top-ports 1000 -T4 $TARGET -oA $OUTPUT_DIR/02_quick_scan

# Phase 3: Full Port Scan
echo "[*] Phase 3: Full Port Scan"
nmap -p- --min-rate 5000 $TARGET -oA $OUTPUT_DIR/03_full_scan

# Phase 4: Vulnerability Scan
echo "[*] Phase 4: Vulnerability Scan"
nmap --script vuln $TARGET -oA $OUTPUT_DIR/04_vuln_scan

# Phase 5: OS Detection
echo "[*] Phase 5: OS Detection"
sudo nmap -O $TARGET -oA $OUTPUT_DIR/05_os_detection

echo "[*] Scan complete! Results in: $OUTPUT_DIR/"

Utilisation:

chmod +x auto_scan.sh
./auto_scan.sh 192.168.100.0/24

Scan complet automatisé du réseau!

Étape 9.2: Parsing et Analyse avec PowerShell

Sur Windows, analysez les résultats XML:

[xml]$nmapResults = Get-Content scan_results.xml

# Extraire tous les hôtes et ports ouverts
$nmapResults.nmaprun.host | ForEach-Object {
    $ip = $_.address.addr
    $hostname = $_.hostnames.hostname.name
    
    Write-Host "Host: $ip ($hostname)"
    
    $_.ports.port | Where-Object {$_.state.state -eq "open"} | ForEach-Object {
        Write-Host "  $($_.portid)/$($_.protocol) - $($_.service.name) $($_.service.version)"
    }
}

Étape 9.3: Génération de Rapport HTML

Convertir XML en HTML:

xsltproc scan_results.xml -o report.html

OU utiliser un script Python:

import nmap
import datetime

nm = nmap.PortScanner()
nm.scan('192.168.100.0/24', arguments='-sV')

html = "<html><head><title>Nmap Scan Report</title></head><body>"
html += f"<h1>Network Scan Report</h1>"
html += f"<p>Date: {datetime.datetime.now()}</p>"

for host in nm.all_hosts():
    html += f"<h2>Host: {host}</h2>"
    html += "<table border='1'><tr><th>Port</th><th>Service</th><th>Version</th></tr>"
    
    for proto in nm[host].all_protocols():
        ports = nm[host][proto].keys()
        for port in ports:
            service = nm[host][proto][port]['name']
            version = nm[host][proto][port]['version']
            html += f"<tr><td>{port}</td><td>{service}</td><td>{version}</td></tr>"
    
    html += "</table>"

html += "</body></html>"

with open('nmap_report.html', 'w') as f:
    f.write(html)

print("Report generated: nmap_report.html")

Questions: 17. Comment présenteriez-vous les résultats à un client? 18. Quelles informations sont les plus critiques à inclure?

---

Livrables

À remettre:

1. Rapport de scan réseau (Word/PDF, 5-6 pages):

   • Réponses aux 18 questions
   • Méthodologie de scan utilisée
   • Résultats de chaque phase de scan
   • Analyse des vulnérabilités trouvées
   • Cartographie réseau (schéma)

2. Captures d'écran (minimum 8):

   • Scan de découverte d'hôtes
   • Scan de ports complet
   • Détection de versions (-sV)
   • Détection d'OS (-O)
   • Script vuln en action
   • Résultats de scripts NSE
   • Zenmap visualization
   • Rapport généré

3. Fichiers de résultats Nmap:

   • Formats .nmap, .xml, .gnmap
   • Pour au moins 3 types de scans différents

4. Script d'automatisation:

   • Script bash ou PowerShell
   • Scan complet automatisé
   • Génération de rapport

5. Analyse de sécurité (2-3 pages):

   • Vulnérabilités critiques identifiées
   • Risques associés
   • Recommandations de remédiation priorisées

---

Critères d'Évaluation

Critère	Points
Maîtrise des différents types de scans	25%
Utilisation correcte des options Nmap	20%
Détection et analyse de vulnérabilités	25%
Script d'automatisation fonctionnel	15%
Qualité du rapport et analyse	15%

---

Commandes de Référence Rapide

Scans de Base

nmap target                    # Scan simple
nmap -sn target                # Host discovery seulement
nmap -p- target                # Tous les ports
nmap -p 80,443 target          # Ports spécifiques
nmap 192.168.1.0/24            # Scanner un réseau

Scans Avancés

nmap -sV target                # Version detection
nmap -O target                 # OS detection
nmap -sC target                # Script scan
nmap -A target                 # Aggressive (tout)
nmap -T4 target                # Timing template

Scripts NSE

nmap --script vuln target                  # Vulnérabilités
nmap --script smb-enum-shares target       # SMB shares
nmap --script http-enum target             # HTTP enumeration
nmap --script ssl-heartbleed target        # Heartbleed

Output

nmap target -oN file.nmap      # Normal output
nmap target -oX file.xml       # XML output
nmap target -oG file.gnmap     # Grepable output
nmap target -oA basename       # Tous les formats

Optimisation

nmap --min-rate 5000 target              # Vitesse minimum
nmap --max-retries 1 target              # Moins de retry
nmap --host-timeout 5m target            # Timeout par host
nmap -n target                           # Pas de résolution DNS

---

Dépannage

Problème: "You requested a scan type which requires raw sockets"

Solution: Exécutez avec sudo (Linux) ou en tant qu'administrateur (Windows) pour scans SYN (-sS) et OS detection (-O).

Problème: Scan très lent

Solutions:

• Utilisez -T4 pour vitesse
• Limitez aux top ports: --top-ports 100
• Augmentez min-rate: --min-rate 5000
• Désactivez résolution DNS: -n

Problème: Aucun port détecté mais hôte up

Solutions:

• Pare-feu bloque probablement
• Essayez scan UDP: -sU
• Essayez différents types de scans: -sT, -sS
• Vérifiez connectivité de base: ping

---

Aller Plus Loin (Optionnel)

Challenge 1: Nmap Scripting

Créez votre propre script NSE pour:

• Énumération personnalisée
• Détection de configuration spécifique
• Extraction d'informations custom

Challenge 2: Integration avec Metasploit

Utilisez résultats Nmap dans Metasploit:

db_nmap -sV 192.168.100.0/24
hosts
services
vulns

Challenge 3: Comparaison Temporelle

Scannez le même réseau à différents moments:

• Identifier nouveaux hôtes
• Détecter changements de configuration
• Monitoring de sécurité continu

ndiff scan1.xml scan2.xml

---

Ressources Additionnelles

• Nmap Official Documentation
• NSE Script Documentation
• Nmap Cheat Sheet
• Nmap Network Scanning (Book)

---

Conclusion

Ce lab vous a enseigné:

• Installation et configuration de Nmap
• Différents types de scans réseau
• Détection de services et systèmes d'exploitation
• Utilisation des scripts NSE pour vulnérabilités
• Automatisation et reporting
• Méthodologie de reconnaissance professionnelle

Leçons clés:

1. Nmap est l'outil standard de l'industrie pour reconnaissance réseau
2. Différents types de scans pour différents objectifs
3. Scripts NSE multiplient les capacités de Nmap
4. Automatisation essentielle pour réseaux de taille
5. Documentation et reporting critiques pour audit professionnel

Dans un pentest réel:

• Nmap est toujours la première étape (reconnaissance)
• Résultats guident le reste de l'attaque
• Détection facile si pas de précautions (IDS/IPS)
• Timing et discrétion importants en engagement Red Team

Prochaine étape: Lab 5.2 où vous apprendrez l'énumération DNS avancée pour découvrir des sous-domaines cachés et des informations sensibles!

---

Lab développé dans le cadre du cours Systèmes d'Exploitation - MODULE 5