Chapitre 3.1 - Reconnaissance, Scanning & Enumération

Module 3 : Sécurité Offensive & Exploitation Prérequis : Module 2 terminé - vous comprenez ce que voient les défenseurs ; apprenez maintenant ce que génèrent les attaquants.

Table des matières

Taxonomie de la Reconnaissance - Passive vs Active
OSINT Passif - DNS, WHOIS, Transparence des Certificats & Shodan
Scanning Actif - Mécanismes Nmap, Timing & Empreinte de Détection
Énumération des Services - Bannières, Versions & Empreinte Protocolaire
Reconnaissance d'Application Web - Brute-Force de Répertoires & Détection Technologique
Énumération DNS & Attaques de Transfert de Zone
Énumération SMTP, SMB & LDAP
Cartographie de la Topologie Réseau - Traceroute, Analyse TTL & Chemin AS
Détections Défensives & Durcissement
Correspondance MITRE ATT&CK

1. Taxonomie de la Reconnaissance - Passive vs Active

La reconnaissance est la première phase de chaque mission - et la phase où les défenseurs ont le désavantage asymétrique le plus important. Correctement réalisée, la reconnaissance passive ne laisse aucune empreinte sur l'infrastructure de la cible. Le scanning actif génère des paquets qui atteignent la cible, créant des entrées de journaux, déclenchant des règles IDS et alertant potentiellement les défenseurs.

Cette distinction est importante sur le plan opérationnel :

Dimension	Recon Passive	Recon Active
Visibilité défenseur	Nulle (les requêtes touchent une infrastructure tierce)	Partielle à totale (les paquets atteignent la cible)
Fraîcheur des données	De quelques heures à plusieurs semaines	Temps réel
Portée	À l'échelle de l'infrastructure, historique	Limitée aux hôtes actifs
Vitesse	Lente (limites de débit API)	Rapide (scan parallèle)
Risque de détection	Aucun	Moyen à élevé
Limite légale	Généralement sans risque	Requiert une autorisation

La méthodologie professionnelle séquence ces phases : épuiser d'abord les sources passives, construire une cartographie complète de la cible, puis mener un scanning actif avec l'empreinte minimale nécessaire pour combler les lacunes. Sauter directement à un scan SYN Nmap contre une cible non étudiée est à la fois opérationnellement non fondé et inutile.

Position dans la Kill Chain & ATT&CK

La reconnaissance correspond directement à la Tactique MITRE ATT&CK : Reconnaissance (TA0043). Les sous-techniques de cette tactique se divisent clairement selon la frontière passive/active et correspondent aux sections de ce chapitre.

2. OSINT Passif - DNS, WHOIS, Transparence des Certificats & Shodan

WHOIS & RDAP

# WHOIS classique - registraire, serveurs de noms, dates d'enregistrement
whois target-corp.com

# RDAP (remplacement moderne du WHOIS, sortie JSON structurée)
curl -s "https://rdap.verisign.com/com/v1/domain/target-corp.com" | jq .

# WHOIS inverse - trouver tous les domaines enregistrés par la même personne/organisation
# (utiliser viewdns.io ou l'API DomainTools)
curl -s "https://viewdns.info/reversewhois/?q=admin@target-corp.com&output=json"

# Recherche ASN - trouver toutes les plages IP détenues par l'organisation cible
whois -h whois.radb.net -- '-i origin AS12345'   # Remplacer par l'ASN cible

# Trouver l'ASN à partir du nom de l'entreprise
curl -s "https://api.bgpview.io/search?query_term=target+corporation" | \\
  jq '.data.asns[] | {asn: .asn, name: .name, country: .country_code}'

# Obtenir tous les préfixes (plages IP) annoncés par un ASN
curl -s "https://api.bgpview.io/asn/12345/prefixes" | \\
  jq '.data.ipv4_prefixes[].prefix'

Reconnaissance DNS Passive

# Énumération des enregistrements DNS de base - A, MX, NS, TXT, SOA
for record_type in A AAAA MX NS TXT SOA CNAME; do
    echo "=== $record_type ==="
    dig +noall +answer target-corp.com $record_type
done

# Enregistrement SPF - révèle l'infrastructure mail et les fournisseurs cloud
dig +short TXT target-corp.com | grep "v=spf1"
# Exemple de sortie : v=spf1 include:_spf.google.com include:sendgrid.net ip4:203.0.113.10 ~all
# La cible utilise Google Workspace + SendGrid ; 203.0.113.10 est leur relai mail

# Enregistrement DMARC - montre la maturité de la sécurité email
dig +short TXT _dmarc.target-corp.com
# p=none = DMARC non appliqué = hameçonnage plus facile
# p=reject = application stricte

# Trouver les serveurs de noms (important pour les tentatives de transfert de zone)
dig +short NS target-corp.com

# DNS passif - données de résolution historiques sans interroger la cible
# API SecurityTrails (niveau gratuit disponible)
curl -s "https://api.securitytrails.com/v1/domain/target-corp.com/subdomains" \\
  -H "APIKEY: YOUR_KEY" | jq '.subdomains[]'

# DNS passif VirusTotal
curl -s "https://www.virustotal.com/api/v3/domains/target-corp.com/resolutions" \\
  -H "x-apikey: YOUR_KEY" | jq '.data[].attributes | {date: .date, ip: .ip_address}'

Transparence des Certificats

# Trouver tous les sous-domaines via les journaux CT - source gratuite la plus complète
curl -s "https://crt.sh/?q=%.target-corp.com&output=json" | \\
  jq -r '.[].name_value' | \\
  sed 's/\\\\*\\\\.//g' | \\\\           # Supprimer les préfixes génériques
  sort -u | \\\\                    # Dédupliquer
  grep -v '^$'                   # Supprimer les lignes vides

# Filtrer uniquement les certificats récemment émis (90 derniers jours)
curl -s "https://crt.sh/?q=%.target-corp.com&output=json" | \\
  jq -r '.[] | select(.not_before > (now - 7776000 | todate)) | .name_value' | \\
  sort -u

# Croiser les sous-domaines pour trouver les hôtes actifs
curl -s "https://crt.sh/?q=%.target-corp.com&output=json" | \\
  jq -r '.[].name_value' | sed 's/\\\\*\\\\.//g' | sort -u > subdomains.txt

# Résoudre chaque sous-domaine pour trouver les cibles actives
while read subdomain; do
    ip=$(dig +short A "$subdomain" 2>/dev/null | head -1)
    if [ -n "$ip" ]; then
        echo "$ip $subdomain"
    fi
done < subdomains.txt | sort -t. -k1,1n -k2,2n -k3,3n -k4,4n

Shodan & Censys - Bases de Données de Scanning Internet

Shodan et Censys scannent en continu l'espace IPv4 entier et stockent les bannières, certificats et réponses HTTP. Les interroger expose la surface d'attaque exposée sur Internet de la cible sans envoyer un seul paquet à celle-ci.

# CLI Shodan
pip install shodan
shodan init YOUR_API_KEY

# Trouver tous les hôtes d'une entreprise par ASN
shodan search "asn:AS12345" --fields ip_str,port,org,product,version

# Trouver les hôtes par plage réseau
shodan search "net:203.0.113.0/24" --fields ip_str,port,product,version,os

# Trouver des versions logicielles vulnérables spécifiques
shodan search "org:\\"Target Corporation\\" product:\\"Apache httpd\\" version:\\"2.4.49\\""
# CVE-2021-41773 (traversal de chemin) affecte Apache 2.4.49

# Rechercher des interfaces d'administration exposées
shodan search "org:\\"Target Corporation\\" title:\\"Admin\\""
shodan search "org:\\"Target Corporation\\" http.title:\\"phpMyAdmin\\""

# Trouver le RDP exposé sur Internet (cible de haute valeur)
shodan search "org:\\"Target Corporation\\" port:3389"

# Télécharger les résultats complets (requiert API payante)
shodan download target_results "org:\\"Target Corporation\\""
shodan parse --fields ip_str,port,product target_results.json.gz

# Équivalent Censys (trouve souvent des hôtes différents de Shodan)
pip install censys
censys search "autonomous_system.name:\\"Target Corporation\\"" --index hosts \\
  --fields ip,services.port,services.service_name,services.software

# Trouver les hôtes avec un certificat spécifique (ex. : utilisant le cert de la cible)
censys search "parsed.names:\\"*.target-corp.com\\"" --index certificates

OSINT sur GitHub & Dépôts de Code

Les identifiants divulgués, les clés API et les noms d'hôtes internes dans les dépôts publics constituent parmi les cibles de recon passive les plus rentables :

# truffleHog - scanner une organisation GitHub pour trouver des secrets dans les commits
pip install trufflehog
trufflehog github --org=target-corporation \\\\     # Scanner toute l'organisation
  --only-verified \\\\                               # Seulement les secrets vérifiés (moins de faux positifs)
  --json | jq '{file:.SourceMetadata.Data.Github.file,
                secret:.Raw,
                detector:.DetectorName}'

# gitleaks - scanner un dépôt spécifique
gitleaks detect --source /path/to/cloned/repo \\
  --report-format json \\
  --report-path /tmp/leaks.json

# gitrob - analyse GitHub basée sur les profils
gitrob analyze target-corporation

# Rechercher directement sur GitHub des chaînes sensibles (manuelle mais efficace)
# Recherches à effectuer manuellement sur github.com :
# org:target-corporation password
# org:target-corporation "BEGIN RSA PRIVATE KEY"
# org:target-corporation "api_key"
# org:target-corporation "jdbc:mysql"            # Chaînes de connexion DB
# org:target-corporation ".target-corp.com"      # Noms d'hôtes internes

3. Scanning Actif - Mécanismes Nmap, Timing & Empreinte de Détection

Fonctionnement du Scanning SYN Nmap

Le mode par défaut de Nmap (-sS) envoie un paquet TCP SYN. La réponse détermine l'état du port :

Réponse	État Nmap	Signification
SYN-ACK	`open`	Le port est à l'écoute
RST	`closed`	Port accessible, aucun service
Pas de réponse (timeout)	`filtered`	Pare-feu supprime les paquets
ICMP unreachable type 3	`filtered`	Pare-feu rejette les paquets

Le scanning SYN ne complète jamais la poignée de main à trois voies - Nmap envoie un RST après réception du SYN-ACK, empêchant la connexion d'être enregistrée par la couche applicative (seule la couche réseau la voit). C'est pourquoi -sS nécessite les droits root : l'accès aux sockets bruts est nécessaire pour forger le RST.

Types de Scans Nmap - Choisir la Bonne Sonde

# Scan SYN (par défaut, discret, nécessite root)
nmap -sS 192.168.1.0/24

# Scan TCP connect (pas de root nécessaire, entièrement journalisé par la cible)
nmap -sT 192.168.1.100

# Scan UDP (lent, indispensable pour trouver DNS/SNMP/TFTP)
nmap -sU --top-ports 100 192.168.1.100

# Combiné TCP SYN + UDP
nmap -sS -sU --top-ports 200 192.168.1.100

# Scan ACK - déterminer les règles du pare-feu (pas de découverte de services)
# les ports ouverts et fermés renvoient tous deux RST ; les ports filtrés ne répondent pas
nmap -sA 192.168.1.0/24

# Scan Window - la taille de la fenêtre de réponse RST différencie ouvert/fermé sur certains OS
nmap -sW 192.168.1.100

# Scan SCTP INIT (moins courant, environnements télécom/SS7)
nmap --scanflags INIT 192.168.1.100

Découverte d'Hôtes

# Balayage ping - trouver les hôtes actifs avant le scanning de ports (plus rapide)
nmap -sn 10.0.0.0/24              # Pas de scan de ports ; ICMP echo + TCP 443/80 + ARP (sur LAN)

# Désactiver la résolution DNS (plus rapide, moins de bruit dans les journaux du résolveur)
nmap -sn -n 10.0.0.0/24

# Scan ARP (le plus rapide sur LAN local - ne peut pas être bloqué par un pare-feu)
nmap -sn --send-eth 192.168.1.0/24   # Forcer ARP Ethernet au lieu des sondes IP
# Ou utiliser arp-scan :
arp-scan --localnet                   # Scanner le sous-réseau local via ARP

# TCP ping (quand ICMP est bloqué)
nmap -sn -PS22,80,443 10.0.0.0/24    # SYN vers les ports 22, 80, 443
nmap -sn -PA80,443 10.0.0.0/24       # ACK ping (contourne certains pare-feux sans état)

# Variantes ICMP
nmap -sn -PE 10.0.0.0/24    # ICMP Echo (ping standard)
nmap -sn -PP 10.0.0.0/24    # ICMP Timestamp
nmap -sn -PM 10.0.0.0/24    # ICMP Address Mask

Templates de Timing & Empreinte de Détection

Le flag -T de Nmap contrôle les délais entre les sondes. Comprendre l'empreinte générée par chaque niveau de timing est crucial pour éviter la détection :

Template	Nom	RTT Min	Retentatives Max	Parallèle	Risque de Détection IDS
`-T0`	Paranoïaque	5 min/sonde	1	1	Quasi-nul
`-T1`	Furtif	15s/sonde	1	1	Très faible
`-T2`	Poli	400ms	2	1	Faible
`-T3`	Normal (défaut)	100ms	6	Plusieurs	Moyen
`-T4`	Agressif	10ms	3	Plusieurs	Élevé
`-T5`	Insensé	5ms	2	Maximum	Très élevé

# Scan distribué lent sur un /16 - contourne les IDS basés sur des seuils
nmap -sS -T1 -n \\
  --randomize-hosts \\\\               # Ne pas scanner séquentiellement
  --data-length 25 \\\\                # Ajouter 25 octets aléatoires (casse certaines signatures IDS)
  --source-port 53 \\\\                # Usurper le port source 53 (peut contourner des pare-feux mal configurés)
  -p 22,80,443,3389,445,8080 \\
  10.0.0.0/16 \\
  -oG /tmp/scan_results.gnmap       # Sortie au format Grepable

# Paquets fragmentés - contourner les IDS basés sur les signatures qui réassemblent mal
nmap -sS -f 192.168.1.100          # Fragmenter les paquets IP en fragments de 8 octets
nmap -sS --mtu 24 192.168.1.100    # Définir un MTU personnalisé (doit être multiple de 8)

# Scan par leurres - insérer de fausses IP sources pour dissimuler la vraie source
nmap -sS -D 10.0.0.1,10.0.0.2,ME,10.0.0.3 192.168.1.100
# ME = votre vraie IP mélangée parmi les leurres ; la cible voit des scans depuis toutes les IP listées

# Scan inactif/zombie - cache complètement votre IP (utiliser un hôte "zombie" avec IPID prévisible)
# 1. Trouver un zombie (hôte inactif avec une séquence d'ID IP prévisible)
nmap -O --script ipidseq 192.168.1.50   # Vérifier si l'hôte a un ID IP incrémental
# 2. Effectuer le scan inactif en utilisant le zombie
nmap -sI 192.168.1.50 192.168.1.100     # Scanner la cible en utilisant le zombie comme intermédiaire

Flux de Travail de Scan Ciblé Complet

# Phase 1 : Découverte rapide des ports - tous les 65535 ports, pas de détection de services
nmap -sS -p- \\\\                    # Scanner tous les ports
  -T4 \\\\                           # Timing agressif
  --min-rate 1000 \\\\               # Minimum 1000 paquets/seconde
  -n \\\\                            # Pas de DNS
  --open \\\\                        # Afficher uniquement les ports ouverts
  -oG /tmp/all_ports.gnmap \\\\      # Sauvegarder pour la phase 2
  192.168.1.100

# Extraire les ports ouverts de la sortie de la phase 1
ports=$(grep -oP '(?<=\\\\d/open)[^,]*' /tmp/all_ports.gnmap | \\
  grep -oP '\\\\d+(?=/)' | sort -nu | tr '\\n' ',' | sed 's/,$//')

# Phase 2 : Scan profond ciblé - détection de versions + scripts sur les ports ouverts uniquement
nmap -sS -sV \\\\                    # Détection de versions
  -sC \\\\                           # Scripts NSE par défaut
  -O \\\\                            # Empreinte OS
  -p $ports \\\\                     # Seulement les ports ouverts de la phase 1
  --version-intensity 7 \\\\         # Sondage de versions agressif (0-9)
  -oA /tmp/deep_scan \\\\            # Tous les formats de sortie (nmap, gnmap, xml)
  192.168.1.100

# Phase 3 : Scripts de vulnérabilité ciblés sur des services spécifiques
nmap -sV \\
  --script "vuln,exploit,auth" \\\\  # Exécuter des scripts NSE vuln/exploit/auth
  -p 445 \\\\                        # SMB spécifiquement
  192.168.1.100

# Analyser la sortie XML pour les outils en aval
python3 -c "
import xml.etree.ElementTree as ET
tree = ET.parse('/tmp/deep_scan.xml')
for host in tree.findall('.//host'):
    addr = host.find('address').get('addr')
    for port in host.findall('.//port[@state=\\"open\\"]'):
        portnum = port.get('portid')
        service = port.find('service')
        sname = service.get('name','') if service is not None else ''
        sver  = service.get('version','') if service is not None else ''
        print(f'{addr}:{portnum} {sname} {sver}')
"

4. Énumération des Services - Bannières, Versions & Empreinte Protocolaire

Une fois les ports ouverts connus, l'énumération des services extrait les versions exactes des logiciels - l'entrée pour la correspondance des vulnérabilités.

Capture de Bannières

# Capture de bannière Netcat (TCP brut)
nc -nv 192.168.1.100 22           # Bannière SSH
nc -nv 192.168.1.100 21           # Bannière FTP
nc -nv 192.168.1.100 25           # Bannière SMTP (envoyer "EHLO test" après connexion)

# Capture de bannière avec timeout
echo "" | nc -w 3 192.168.1.100 80 | head -5

# Capture de bannière HTTP
curl -si http://192.168.1.100/ | head -20   # -s: silencieux, -i: inclure les en-têtes
# Rechercher : Server: Apache/2.4.49, X-Powered-By: PHP/7.4.3

# Capture de bannière automatisée avec Nmap NSE
nmap -sV --script banner 192.168.1.100

# Capture d'en-tête HTTP avec Netcat
printf 'HEAD / HTTP/1.0\\r\\nHost: 192.168.1.100\\r\\n\\r\\n' | \\
  nc -w 5 192.168.1.100 80

# Version du service SSL/TLS via openssl
openssl s_client -connect 192.168.1.100:443 2>/dev/null | \\
  grep -E "Protocol|Cipher|subject|issuer"

NSE Nmap - Scripts Spécifiques aux Services

# Lister tous les scripts NSE pour une catégorie spécifique
ls /usr/share/nmap/scripts/ | grep smb
ls /usr/share/nmap/scripts/ | grep http

# Énumération de la clé hôte SSH et des algorithmes
nmap -p 22 --script ssh-hostkey,ssh2-enum-algos 192.168.1.100
# Algorithmes faibles (diffie-hellman-group1-sha1, arcfour) = vulnérabilité

# Énumération HTTP - informations serveur, méthodes, en-têtes
nmap -p 80,443,8080 \\
  --script http-server-header,http-methods,http-headers,http-title \\
  192.168.1.100

# Détection de version SMB et vérification des vulnérabilités
nmap -p 445 \\
  --script smb-protocols,smb-security-mode,smb2-security-mode \\
  192.168.1.100
# smb-protocols indiquera si SMBv1 est activé = candidat EternalBlue

# Brute-force des chaînes de communauté SNMP (mauvaise configuration courante)
nmap -sU -p 161 \\
  --script snmp-brute \\
  --script-args snmp-brute.communitiesdb=/usr/share/nmap/nselib/data/snmpcommunities.lst \\
  192.168.1.100

# Lire les OID SNMP une fois la chaîne de communauté trouvée
nmap -sU -p 161 \\
  --script snmp-sysdescr,snmp-interfaces,snmp-processes,snmp-netstat \\
  192.168.1.100

# Ou utiliser snmpwalk directement
snmpwalk -v2c -c public 192.168.1.100   # Parcourir le MIB entier avec la chaîne de communauté "public"
snmpwalk -v2c -c public 192.168.1.100 1.3.6.1.2.1.1   # OID d'informations système
snmpwalk -v2c -c public 192.168.1.100 1.3.6.1.2.1.25.4.2  # Processus en cours d'exécution

Empreinte du Système d'Exploitation

La détection d'OS de Nmap envoie une série de sondes et compare les réponses à une base de données d'environ 5000 signatures OS basées sur le comportement de la pile TCP/IP :

# Empreinte OS (nécessite root pour les sockets bruts)
nmap -O 192.168.1.100

# Détection d'OS agressive (devine même avec une faible confiance)
nmap -O --osscan-guess 192.168.1.100

# p0f - empreinte OS passive (aucun paquet envoyé à la cible)
# Écoute sur l'interface et identifie l'OS à partir du trafic observé
p0f -i eth0 -p               # Mode passif, promiscuité
# Ou analyser un PCAP :
p0f -r /captures/traffic.pcap -o /tmp/p0f_output.txt

# Xprobe2 - empreinte OS active utilisant ICMP
xprobe2 -v 192.168.1.100

5. Reconnaissance d'Application Web - Brute-Force de Répertoires & Détection Technologique

Détection de la Pile Technologique

# whatweb - identifier les technologies à partir des réponses HTTP
whatweb -a 3 http://target.example.com    # Niveau d'agression 3 (actif, envoie plus de requêtes)
whatweb --log-json=/tmp/whatweb.json http://target.example.com

# CLI Wappalyzer
npx wappalyzer http://target.example.com

# Inspection manuelle des en-têtes - révèle les frameworks, serveurs, cookies
curl -si http://target.example.com | grep -iE \\
  "server:|x-powered-by:|x-generator:|set-cookie:|via:|x-aspnet"

# Vérifier robots.txt et sitemap.xml - révèle souvent des chemins internes
curl -s http://target.example.com/robots.txt
curl -s http://target.example.com/sitemap.xml
curl -s http://target.example.com/sitemap_index.xml

Brute-Force de Répertoires & Fichiers

# ffuf - fuzzer web rapide (recommandé)
# Installation : go install github.com/ffuf/ffuf/v2@latest

# Découverte de répertoires de base
ffuf -u http://target.example.com/FUZZ \\
  -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt \\
  -mc 200,204,301,302,307,401,403 \\\\   # Correspondre à ces codes de statut
  -t 50 \\\\                              # 50 threads
  -o /tmp/ffuf_dirs.json \\\\             # Sortie JSON
  -of json

# Brute-force des extensions de fichiers (trouver fichiers de sauvegarde, fichiers de configuration)
ffuf -u http://target.example.com/FUZZ \\
  -w /usr/share/wordlists/common.txt \\
  -e .php,.bak,.txt,.conf,.old,.sql,.zip,.tar.gz \\
  -mc 200,204 \\
  -fs 0                                # Filtrer les réponses vides

# Énumération des hôtes virtuels (trouver des sous-domaines cachés sur la même IP)
ffuf -u http://target.example.com/ \\
  -H "Host: FUZZ.target.example.com" \\
  -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-5000.txt \\
  -mc 200,204,301,302 \\
  -fs 4242                             # Filtrer par taille commune (taille de la page 404 par défaut)

# gobuster - alternative à ffuf
gobuster dir \\
  -u http://target.example.com \\
  -w /usr/share/wordlists/dirb/common.txt \\
  -x php,html,txt,bak \\
  -t 30 \\
  -o /tmp/gobuster.txt \\
  --no-error

# Feroxbuster - brute-force de répertoires récursif
feroxbuster -u http://target.example.com \\
  -w /usr/share/seclists/Discovery/Web-Content/raft-large-directories.txt \\
  -x php,html,js,txt \\
  --depth 3 \\\\                          # Récursion sur 3 niveaux de profondeur
  --filter-status 404 \\
  -o /tmp/ferox.txt

Recon JavaScript & Code Source

Les SPA modernes et les applications web exposent des renseignements significatifs dans leurs bundles JavaScript :

# getjs - extraire tous les fichiers JS d'un site
getjs --url http://target.example.com --output /tmp/js_files.txt

# Extraire les endpoints des fichiers JS
cat /tmp/js_files.txt | while read url; do
    curl -s "$url" | \\
    grep -oE '(api|v[0-9])/[a-zA-Z0-9/_-]+' | \\\\  # Trouver les chemins API
    sort -u
done

# linkfinder - extraire les endpoints du JS
python3 linkfinder.py -i http://target.example.com -d \\\\   # -d: mode domaine (exploration)
  -o /tmp/endpoints.html

# secretfinder - trouver des clés API dans les fichiers JS
python3 secretfinder.py -i http://target.example.com/app.js \\
  -o cli                              # Sortie vers CLI

6. Énumération DNS & Attaques de Transfert de Zone

Énumération des Sous-Domaines

# dnsx - résolveur DNS rapide et brute-force de sous-domaines
# Installation : go install github.com/projectdiscovery/dnsx/cmd/dnsx@latest

# Résoudre une liste de sous-domaines
cat subdomains.txt | dnsx -a -resp     # -a: enregistrements A, -resp: afficher la réponse

# Brute-force de sous-domaines avec liste de mots
dnsx -d target-corp.com \\
  -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-20000.txt \\
  -a -resp \\\\                           # Résoudre les enregistrements A
  -o /tmp/dns_results.txt

# amass - énumération complète des sous-domaines (passif + actif)
amass enum -passive -d target-corp.com   # Passif uniquement (sources OSINT)
amass enum -active -d target-corp.com \\\\  # Actif (brute-force + transferts de zone)
  -brute -w /usr/share/seclists/Discovery/DNS/bitquark-subdomains-top100000.txt \\
  -o /tmp/amass_results.txt

# subfinder - découverte passive de sous-domaines depuis 50+ sources
subfinder -d target-corp.com -all -o /tmp/subdomains.txt
subfinder -d target-corp.com -sources shodan,crtsh,virustotal -o /tmp/subdomains_focused.txt

# massdns - résolveur DNS haute vitesse (millions de requêtes)
massdns -r /opt/massdns/lists/resolvers.txt \\\\   # Liste de résolveurs publics
  -t A \\\\                                          # Type de requête
  -o S \\\\                                          # Sortie simple
  /tmp/subdomains.txt > /tmp/resolved.txt

Transfert de Zone (AXFR)

Un transfert de zone DNS réplique la zone DNS entière du serveur de noms primaire vers le secondaire. Lorsqu'il est mal configuré pour autoriser les transferts depuis n'importe quelle source, il fournit à un attaquant une carte complète de chaque nom d'hôte et adresse IP dans la zone.

# Vérifier tous les serveurs de noms pour la vulnérabilité de transfert de zone
domain="target-corp.com"

# Étape 1 : Obtenir tous les serveurs de noms
nameservers=$(dig +short NS $domain)
echo "Serveurs de noms : $nameservers"

# Étape 2 : Tenter AXFR contre chaque serveur de noms
for ns in $nameservers; do
    echo "=== Tentative AXFR depuis $ns ==="
    dig axfr @$ns $domain
    # Un transfert réussi liste tous les enregistrements : A, AAAA, MX, CNAME, TXT, PTR, etc.
done

# Utilisation de la commande host (alternative)
host -l target-corp.com ns1.target-corp.com   # Transfert de zone depuis un NS spécifique

# fierce - transfert de zone automatisé + brute-force
fierce --domain target-corp.com \\
  --dns-servers 8.8.8.8 \\\\            # Utiliser un résolveur public pour la recherche NS initiale
  --subdomains /usr/share/fierce/hosts.txt

# Vérification défensive - tester votre propre zone
dig axfr @your-primary-ns yourdomain.com
# Réponse attendue : "Transfer failed" ou "REFUSED" si correctement verrouillé

Reconnaissance DNS avec dig

# Trouver les serveurs mail et leurs IP (utile pour l'évaluation hameçonnage/usurpation)
dig MX target-corp.com +short | sort -n | while read prio mx; do
    ip=$(dig +short A "$mx")
    echo "Priorité $prio : $mx - $ip"
done

# Recherche DNS inverse (enregistrements PTR) - mapper les plages IP aux noms d'hôtes
dig -x 203.0.113.1 +short             # IP unique
# Plage inverse (en utilisant dnsx)
echo "203.0.113.0/24" | dnsx -ptr -resp   # Recherche inverse en masse

# Vérifier le DNS générique (affecte les résultats du brute-force)
dig A doesnotexist123456.target-corp.com +short
# Si cela renvoie une IP = DNS générique configuré = résultats du brute-force peu fiables

# Énumération DNSSEC - parcourir les zones signées (NSEC walking)
ldns-walk target-corp.com             # Énumérer tous les enregistrements dans une zone signée DNSSEC
# NSEC3 empêche le parcours direct mais NSEC1 permet la reconstruction complète de la zone

7. Énumération SMTP, SMB & LDAP

Énumération des Utilisateurs SMTP

Les serveurs SMTP peuvent divulguer des noms d'utilisateur valides via VRFY, EXPN, ou des réponses différentielles RCPT TO :

# Énumération SMTP manuelle
nc -nv 192.168.1.100 25

# Après connexion :
EHLO test.com            # Nous annoncer, voir les capacités du serveur
VRFY root                # Vérifier si 'root' est un destinataire valide
VRFY admin@target-corp.com
EXPN staff               # Développer la liste de diffusion

# Énumération automatisée des utilisateurs SMTP avec smtp-user-enum
smtp-user-enum -M VRFY \\\\                      # Méthode : VRFY
  -U /usr/share/seclists/Usernames/top-usernames-shortlist.txt \\
  -t 192.168.1.100                             # Cible

smtp-user-enum -M RCPT \\\\                      # Méthode RCPT TO (la plus fiable)
  -U /usr/share/wordlists/users.txt \\
  -D target-corp.com \\\\                         # Domaine pour RCPT TO: user@domain
  -t 192.168.1.100 \\
  -p 25

# Script NSE Nmap
nmap -p 25 --script smtp-enum-users \\
  --script-args smtp-enum-users.methods=VRFY,RCPT,EXPN \\
  192.168.1.100

Énumération SMB

SMB est l'une des cibles d'énumération les plus riches dans les réseaux internes - les partages, utilisateurs, groupes, version OS et informations de domaine sont tous accessibles :

# Énumération de session nulle (accès anonyme - courant sur les anciens systèmes)
smbclient -N -L //192.168.1.100      # Lister les partages sans identifiants

# Énumérer avec des identifiants
smbclient -U 'DOMAIN\\username%password' -L //192.168.1.100

# Monter un partage
smbclient -U 'user%pass' //192.168.1.100/SYSVOL    # Accéder au partage SYSVOL (Stratégie de groupe)

# enum4linux - énumération complète SMB/NetBIOS
enum4linux -a 192.168.1.100         # -a: effectuer toutes les vérifications
# Résultats : version OS, informations domaine, partages, utilisateurs, groupes, politique de mot de passe, imprimantes

# enum4linux-ng (réécriture Python moderne)
enum4linux-ng -A 192.168.1.100 \\\\    # Toutes les vérifications
  -oJ /tmp/enum_results.json        # Sortie JSON

# crackmapexec - test d'identifiants + énumération à grande échelle
# Installation : pipx install crackmapexec
cme smb 192.168.1.0/24                         # Balayage SMB - informations OS, statut de signature
cme smb 192.168.1.100 -u '' -p '' --shares     # Énumération de partages en session nulle
cme smb 192.168.1.100 -u user -p pass --shares # Énumération de partages authentifiée
cme smb 192.168.1.100 -u user -p pass --users  # Énumération des utilisateurs
cme smb 192.168.1.100 -u user -p pass --groups # Énumération des groupes
cme smb 192.168.1.100 -u user -p pass --pass-pol  # Politique de mot de passe

# rpcclient - énumération RPC brute
rpcclient -U "user%pass" 192.168.1.100
# Dans rpcclient :
# enumdomusers         - Lister les utilisateurs du domaine
# enumdomgroups        - Lister les groupes du domaine
# querydominfo         - Informations domaine (politique de verrouillage, etc.)
# enumprinters         - Lister les imprimantes
# netshareenum         - Lister les partages
# getdompwinfo         - Politique de mot de passe

# Scripts SMB Nmap
nmap -p 445 \\
  --script smb-enum-shares,smb-enum-users,smb-enum-domains,smb-os-discovery \\
  192.168.1.100

Énumération LDAP

LDAP est l'épine dorsale du service d'annuaire d'Active Directory. Les liaisons LDAP anonymes - bien que de plus en plus rares - exposent la structure entière du répertoire :

# Tester la liaison LDAP anonyme
ldapsearch -x \\\\                       # -x: auth simple (pas SASL)
  -h 192.168.1.10 \\\\                   # Serveur LDAP (généralement le DC)
  -b "DC=target,DC=corp" \\\\            # DN de base
  -s sub "(objectclass=*)" |          # Rechercher tous les objets
  head -50

# Énumérer les utilisateurs
ldapsearch -x -h 192.168.1.10 \\
  -D "CN=user,DC=target,DC=corp" \\\\   # DN de liaison (identifiants)
  -w 'Password123' \\
  -b "DC=target,DC=corp" \\
  "(objectclass=user)" \\\\              # Filtre : objets utilisateur
  sAMAccountName mail memberOf        # Retourner uniquement ces attributs

# Trouver les comptes sans pré-authentification Kerberos (candidats AS-REP Roasting)
ldapsearch -x -h 192.168.1.10 \\
  -D "user@target.corp" -w 'Password' \\
  -b "DC=target,DC=corp" \\
  "(&(objectclass=user)(userAccountControl:1.2.840.113556.1.4.803:=4194304))" \\
  sAMAccountName

# Trouver les SPN (candidats Kerberoasting)
ldapsearch -x -h 192.168.1.10 \\
  -D "user@target.corp" -w 'Password' \\
  -b "DC=target,DC=corp" \\
  "(&(objectclass=user)(servicePrincipalName=*))" \\
  sAMAccountName servicePrincipalName

# ldapdomaindump - analyser et visualiser AD via LDAP
ldapdomaindump -u 'target.corp\\\\user' -p 'Password' 192.168.1.10 \\
  -o /tmp/ldap_dump/
# Génère des rapports HTML : domain_users.html, domain_groups.html, domain_computers.html

8. Cartographie de la Topologie Réseau - Traceroute, Analyse TTL & Chemin AS

# Traceroute standard (sondes UDP, certains pare-feux bloquent)
traceroute target.example.com

# Traceroute TCP sur le port 80 (pénètre davantage de pare-feux)
traceroute -T -p 80 target.example.com    # -T: sondes TCP SYN

# Traceroute ICMP
traceroute -I target.example.com          # -I: sondes ICMP echo

# Paris traceroute - évite l'asymétrie de chemin due aux équilibreurs de charge
paris-traceroute target.example.com

# MTR - traceroute continu avec statistiques de perte/latence
mtr --report --report-cycles 10 \\
  --tcp -P 443 \\\\                          # Mode TCP, port 443
  target.example.com

# hping3 - traceroute avec sonde personnalisée
hping3 -S \\\\                               # Flag SYN
  --traceroute \\\\                          # Mode traceroute
  -p 443 \\\\                               # Port 443
  target.example.com

# Analyse du chemin AS - comprendre l'infrastructure de routage entre vous et la cible
# Cela révèle les fournisseurs cloud, les réseaux CDN, l'infrastructure ISP
curl -s "https://api.bgpview.io/ip/203.0.113.1" | \\
  jq '.data.prefixes[0] | {prefix:.prefix, asn:.asn.asn, name:.asn.name}'

# Visualisation de route
curl -s "https://stat.ripe.net/data/traceroute/data.json?resource=203.0.113.1" | \\
  jq '.data.result[0].hops[].result[0].from'

# Identifier les équilibreurs de charge (plusieurs IP pour le même nom d'hôte, TTL différents)
for i in {1..10}; do
    dig +short A target.example.com
done | sort | uniq -c    # Plusieurs IP = DNS round-robin ou CDN

9. Détections Défensives & Durcissement

Détecter l'Activité de Reconnaissance

# Détecter le scanning de ports dans Suricata/Snort - utiliser le préprocesseur portscan
# suricata.yaml:
# app-layer:
#   protocols:
#     dns: ...
# Remarque : Suricata dispose d'une détection de portscan intégrée via le moteur stream

# Détection de portscan Snort (préprocesseur)
# /etc/snort/snort.conf:
preprocessor sfportscan: \\
    proto  { all } \\
    memcap { 10000000 } \\
    sense_level { low } \\\\       # Sensibilité : low/medium/high
    logfile { /var/log/snort/portscan.log }

# Détecter les sondes d'empreinte OS Nmap (séquence de sondes caractéristique)
# Règle Suricata :
alert tcp any any -> $HOME_NET any (
  msg:"Nmap OS Fingerprint Probe - XMAS scan";
  flags:FPU;                    # FIN+PSH+URG = scan XMAS
  classtype:network-scan;
  sid:9003001; rev:1;
)

# Détecter le scan NULL Nmap
alert tcp any any -> $HOME_NET any (
  msg:"Nmap NULL Scan Probe";
  flags:0;                      # Aucun flag TCP défini
  classtype:network-scan;
  sid:9003002; rev:1;
)

# psad - Détecteur d'Attaques par Scan de Ports (analyse les journaux iptables)
# Configurer iptables pour journaliser les paquets supprimés d'abord :
iptables -A INPUT -j LOG --log-prefix "IPTABLES_DROP: " --log-level 4
iptables -A INPUT -j DROP

# psad lit syslog et corrèle les paquets supprimés
psad --Status                   # Afficher les alertes de scan actives
psad -A                         # Analyser les journaux immédiatement
cat /var/log/psad/status        # Statut du scan en cours

# Détecter les IP de scanning Shodan/Censys
# Ces IP scannent tout Internet - elles sont publiquement connues
# Télécharger la liste des IP de scanner Shodan et bloquer/alerter
curl -s "https://www.shodan.io/files/scanner-ip-list.txt" | \\
  while read ip; do
    iptables -A INPUT -s "$ip" -j LOG --log-prefix "SHODAN: "
  done

Durcissement Contre l'Énumération

# Désactiver SMBv1 (requis pour les environnements modernes)
# Windows (PowerShell):
Set-SmbServerConfiguration -EnableSMB1Protocol $false

# Linux Samba
# /etc/samba/smb.conf:
[global]
    min protocol = SMB2           # Désactiver SMBv1
    ntlm auth = no                # Désactiver NTLMv1

# Désactiver l'accès en session nulle dans Samba
[global]
    restrict anonymous = 2        # Empêcher l'énumération anonyme

# Désactiver SMTP VRFY et EXPN (Postfix)
# /etc/postfix/main.cf:
disable_vrfy_command = yes        # Désactiver la commande VRFY
smtpd_discard_ehlo_keywords = expn, silent-discard  # Désactiver EXPN

# Restreindre les liaisons LDAP anonymes (OpenLDAP)
# /etc/ldap/slapd.conf:
access to * by anonymous none    # Refuser tout accès anonyme
access to * by users read        # Autoriser les utilisateurs authentifiés à lire

# Restriction du transfert de zone DNS (BIND)
# /etc/named.conf:
zone "target-corp.com" {
    type master;
    file "/etc/bind/zones/target-corp.com";
    allow-transfer { 192.168.1.2; };   # Autoriser le transfert uniquement vers l'IP du NS secondaire
    allow-query { any; };
};

# Masquer les versions logicielles dans les en-têtes HTTP (Apache)
# /etc/apache2/conf-enabled/security.conf:
ServerTokens Prod              # Seulement "Apache" - pas de version
ServerSignature Off            # Supprimer la version des pages d'erreur
Header unset X-Powered-By      # Supprimer l'en-tête de version PHP

10. Correspondance MITRE ATT&CK

Technique	ID	Outil/Méthode	Défense
Scanning Actif : Scanning de Ports	T1595.001	Nmap, masscan	psad, préprocesseur portscan Snort
Scanning Actif : Scanning de Vulnérabilités	T1595.002	NSE vuln Nmap, Nessus	WAF, limitation de débit
Collecte d'Info Réseau Victime : DNS	T1590.002	dig, amass, dnsx	Restreindre les transferts de zone
Collecte d'Info Réseau Victime : Topologie Réseau	T1590.004	traceroute, mtr	Limitation de débit ICMP
Collecte d'Info Organisation Victime : Noms Employés	T1591.004	LinkedIn, OSINT	Limiter les informations org publiques
Recherche dans les Bases de Données Techniques Ouvertes	T1596	Shodan, Censys, crt.sh	Minimiser l'exposition Internet
Recherche sur Sites Web Ouverts : Réseaux Sociaux	T1593.001	LinkedIn, GitHub	Formation à la sécurité des développeurs
Hameçonnage pour Informations	T1598	Énumération SMTP	Application SPF/DKIM/DMARC
Recherche sur Sites Web de la Victime	T1594	ffuf, gobuster, whatweb	WAF, discipline robots.txt
Collecte d'Info Hôte Victime : Logiciels	T1592.002	Nmap -sV, capture bannière	Supprimer les en-têtes de version

Fin du Chapitre 3.1 - Reconnaissance, Scanning & Enumération

Suivant : Chapitre 3.2 - Techniques d'Exploitation : De la Couche Réseau à la Couche Application

Table des matières​

1. Taxonomie de la Reconnaissance - Passive vs Active​

Position dans la Kill Chain & ATT&CK​

2. OSINT Passif - DNS, WHOIS, Transparence des Certificats & Shodan​

WHOIS & RDAP​

Reconnaissance DNS Passive​

Transparence des Certificats​

Shodan & Censys - Bases de Données de Scanning Internet​

OSINT sur GitHub & Dépôts de Code​

3. Scanning Actif - Mécanismes Nmap, Timing & Empreinte de Détection​

Fonctionnement du Scanning SYN Nmap​

Types de Scans Nmap - Choisir la Bonne Sonde​

Découverte d'Hôtes​

Templates de Timing & Empreinte de Détection​

Flux de Travail de Scan Ciblé Complet​

4. Énumération des Services - Bannières, Versions & Empreinte Protocolaire​

Capture de Bannières​

NSE Nmap - Scripts Spécifiques aux Services​

Empreinte du Système d'Exploitation​

5. Reconnaissance d'Application Web - Brute-Force de Répertoires & Détection Technologique​

Détection de la Pile Technologique​

Brute-Force de Répertoires & Fichiers​

Recon JavaScript & Code Source​

6. Énumération DNS & Attaques de Transfert de Zone​

Énumération des Sous-Domaines​

Transfert de Zone (AXFR)​

Reconnaissance DNS avec dig​

7. Énumération SMTP, SMB & LDAP​

Énumération des Utilisateurs SMTP​

Énumération SMB​

Énumération LDAP​

8. Cartographie de la Topologie Réseau - Traceroute, Analyse TTL & Chemin AS​

9. Détections Défensives & Durcissement​

Détecter l'Activité de Reconnaissance​

Durcissement Contre l'Énumération​

10. Correspondance MITRE ATT&CK​