---
title: "Port Scanning avancé — Nmap NSE, Masscan, Évasion"
domain: security
subdomain: pentest
phase: 02-scanning
type: snippet
tags: [nmap, masscan, nse, port-scanning, evasion, ids, firewall, pentest]
difficulty: advanced
status: stable
updated: "2026-05-14"
---
## Nmap — Rappel des modes de scan

```bash
# Scan SYN (half-open) — discret, nécessite root
nmap -sS {{TARGET}}

# Scan TCP Connect (full 3-way) — sans root, plus bruyant
nmap -sT {{TARGET}}

# UDP (lent, nécessite root)
nmap -sU --top-ports 100 {{TARGET}}

# Scan SCTP INIT
nmap -sY {{TARGET}}

# Détection OS + version + scripts par défaut + traceroute
nmap -A {{TARGET}}
```

---

## Masscan — Scan haute vitesse

```bash
# Installer Masscan
apt install masscan -y

# Scanner tout un /16 sur les ports 80,443,8080 à 100k pps
masscan {{TARGET_CIDR}} -p 80,443,8080 --rate=100000

# Scanner les 65535 ports sur une cible (ultra-rapide)
masscan {{TARGET_IP}} -p 0-65535 --rate=50000

# Exporter au format Nmap XML (compatible avec nmap --resume)
masscan {{TARGET_CIDR}} -p 0-65535 --rate=100000 -oX masscan_results.xml

# Reprendre un scan interrompu
masscan --resume paused.conf

# Limiter à une interface et une adresse source
masscan {{TARGET_CIDR}} -p 443 --rate=10000 -e {{INTERFACE}} --source-ip {{SOURCE_IP}}
```

```bash
# Workflow optimal : Masscan découverte → Nmap service scan
masscan {{TARGET_CIDR}} -p 0-65535 --rate=50000 -oG masscan.gnmap
# Extraire les ports ouverts
grep "open" masscan.gnmap | awk '{print $2}' | sort -u > hosts.txt
grep "open" masscan.gnmap | awk -F'/' '{print $1}' | grep -oP '\d+' | sort -un | tr '\n' ',' > ports.txt
# Scan de services Nmap ciblé
nmap -sV -sC -p $(cat ports.txt) -iL hosts.txt -oA services_scan
```

---

## Nmap NSE — Scripts essentiels

### Découverte et énumération

```bash
# Scripts par catégorie
nmap --script "default and not intrusive" {{TARGET}}
nmap --script "discovery" {{TARGET}}
nmap --script "safe" {{TARGET}}

# Bannières et versions détaillées
nmap --script banner -p 21,22,25,80,443 {{TARGET}}

# HTTP — titres des pages, méthodes autorisées, redirections
nmap --script http-title,http-methods,http-headers {{TARGET}} -p 80,443,8080

# SMB — version, OS, utilisateurs, partages
nmap --script smb-os-discovery,smb-enum-shares,smb-enum-users -p 445 {{TARGET}}

# SSL — version, certificat, ciphers faibles
nmap --script ssl-enum-ciphers,ssl-cert -p 443 {{TARGET}}
```

### Détection de vulnérabilités

```bash
# MS17-010 (EternalBlue)
nmap --script smb-vuln-ms17-010 -p 445 {{TARGET}}

# MS08-067 (Conficker)
nmap --script smb-vuln-ms08-067 -p 445 {{TARGET}}

# Heartbleed (OpenSSL)
nmap --script ssl-heartbleed -p 443 {{TARGET}}

# ShellShock (Bash CVE-2014-6271)
nmap --script http-shellshock --script-args uri=/cgi-bin/test.cgi -p 80 {{TARGET}}

# Tous les scripts vuln (agressif)
nmap --script "vuln" {{TARGET}}

# HTTP — détection de vulnérabilités web
nmap --script http-sql-injection,http-xssed,http-csrf -p 80,443 {{TARGET}}
```

### Scripts spécialisés

```bash
# DNS — zone transfer + brute force sous-domaines
nmap --script dns-zone-transfer --script-args dns-zone-transfer.domain={{DOMAIN}} -p 53 {{DNS_SERVER}}
nmap --script dns-brute --script-args dns-brute.domain={{DOMAIN}}

# FTP — accès anonyme
nmap --script ftp-anon,ftp-bounce -p 21 {{TARGET}}

# MySQL — accès sans mot de passe, dump infos
nmap --script mysql-empty-password,mysql-info -p 3306 {{TARGET}}

# RDP — détection BlueKeep, NLA
nmap --script rdp-vuln-ms12-020,rdp-enum-encryption -p 3389 {{TARGET}}

# SNMP — community strings
nmap --script snmp-brute,snmp-info -p 161 --script-args snmp-brute.communitiesdb=/usr/share/seclists/Discovery/SNMP/common-snmp-community-strings.txt -sU {{TARGET}}
```

---

## Techniques d'évasion IDS/Firewall

### Fragmentation des paquets

```bash
# Fragmenter les paquets IP en 8 bytes (-f) ou 16 bytes (-ff)
nmap -f {{TARGET}}
nmap -ff {{TARGET}}

# Taille de fragment personnalisée (multiple de 8)
nmap --mtu 24 {{TARGET}}
```

### Decoy — Masquer la vraie source

```bash
# Utiliser des leurres (IPs fictives mélangées à la vraie)
nmap -D {{DECOY1}},{{DECOY2}},ME {{TARGET}}

# Générer des IPs aléatoires comme leurres
nmap -D RND:10 {{TARGET}}

# Spoof d'IP source (la réponse ne revient pas — scan blind)
nmap -S {{SPOOFED_IP}} -e {{INTERFACE}} -Pn {{TARGET}}
```

### Timing et rythme

```bash
# Timing templates (T0=paranoid, T5=insane)
nmap -T0 {{TARGET}}    # 5 min entre chaque sonde — très lent, très discret
nmap -T1 {{TARGET}}    # "Sneaky" — passe sous les seuils IDS basés sur le temps
nmap -T2 {{TARGET}}    # "Polite" — réduit la charge réseau
nmap -T5 {{TARGET}}    # "Insane" — très rapide, très détectable

# Contrôle fin du timing
nmap --scan-delay 1s --max-retries 1 {{TARGET}}
nmap --min-rate 1 --max-rate 5 {{TARGET}}   # max 5 paquets/seconde
```

### Source port et data length

```bash
# Utiliser un port source connu (parfois whitelisté en firewall)
nmap --source-port 53 {{TARGET}}    # source port DNS
nmap --source-port 80 {{TARGET}}    # source port HTTP

# Ajouter des données aléatoires pour modifier la taille des paquets
nmap --data-length 15 {{TARGET}}

# Randomiser l'ordre des cibles (évite les patterns séquentiels)
nmap --randomize-hosts {{TARGET_CIDR}}
```

### Firewall bypass — ports filtrés

```bash
# ACK scan — déterminer les règles du firewall (filtered vs unfiltered)
nmap -sA {{TARGET}}

# FIN scan (passe certains firewalls stateless)
nmap -sF {{TARGET}}

# NULL scan
nmap -sN {{TARGET}}

# Xmas scan (FIN+PSH+URG)
nmap -sX {{TARGET}}

# Idle scan (zombie) — ultra-furtif, utilise une IP tierce
# Trouver un hôte zombie avec IP ID prévisible :
nmap --script ipidseq {{ZOMBIE_IP}}
# Lancer l'idle scan
nmap -sI {{ZOMBIE_IP}}:{{ZOMBIE_PORT}} {{TARGET}}
```

---

## Contournement de pare-feu applicatif (WAF)

```bash
# Détecter un WAF
nmap --script http-waf-detect {{TARGET}} -p 80,443

# Identifier le WAF
nmap --script http-waf-fingerprint {{TARGET}} -p 80,443

# Wafw00f (outil dédié)
wafw00f {{TARGET_URL}}
```

---

## Sorties et formats

```bash
# Sortie dans tous les formats (recommandé)
nmap -oA scan_{{TARGET}} {{TARGET}}
# → scan.nmap (texte), scan.xml, scan.gnmap (grepable)

# Conversion XML → HTML (rapport lisible)
xsltproc scan_{{TARGET}}.xml -o scan_{{TARGET}}.html

# Parser avec python-nmap
python3 -c "
import nmap
nm = nmap.PortScanner()
nm.scan('{{TARGET}}', '1-1024')
for host in nm.all_hosts():
    for proto in nm[host].all_protocols():
        for port in nm[host][proto].keys():
            state = nm[host][proto][port]['state']
            print(f'{host}:{port}/{proto} → {state}')
"
```

<Tip>
Pour un scan discret en environnement surveillé : combiner `-T1 --source-port 53 --data-length 20 -f -D RND:5`. Aucune technique seule n'est suffisante — c'est la combinaison qui passe sous les seuils des IDS modernes. Sur un vrai engagement, valider d'abord sur une cible de test avant de scanner la production.
</Tip>