Reconnaissance active — Notions

Vous sortez de deux semaines de renseignement silencieux. Cette semaine, on tape. Chaque paquet que vous envoyez peut être vu, journalisé, corrélé. Un scan mal réglé, c'est un IDS qui hurle, un client qui vous appelle, un test qui commence dans le rouge.

Rappel

Un scan de ports sur une IP qui ne vous appartient pas et pour laquelle vous n'avez pas d'autorisation écrite est un acte hostile en droit dans la plupart des juridictions, y compris quand vous ne trouvez rien. Toute cette leçon s'exécute sur votre lab ou sur des cibles couvertes par un RoE.

Ce que vous saurez faire après cette leçon

Choisir le bon scan pour le bon moment (rapide, complet, discret, agressif).
Lire un résultat Nmap ligne par ligne, y compris filtered, open|filtered, unfiltered.
Énumérer un service Windows avec enum4linux-ng, smbclient, crackmapexec.
Utiliser Wireshark pour vérifier ce que votre scan produit réellement sur le fil.
Forger un paquet à la main avec Scapy quand nmap ne fait pas ce qu'on veut.
Estimer le coût en bruit d'un scan avant de le lancer.

1. Le passage passif → actif : ce qui change vraiment

En passif, personne ne sait que vous existez. En actif, votre IP est dans les logs de la cible. Trois conséquences concrètes :

Vos traces sont datées. Un nmap -p- sur victim.com, à 03h14 le 12 avril, ça se retrouve.
Vos traces sont attribuables. IP source, empreinte TCP/IP, User-Agent HTTP, ordre des paquets — tout raconte qui vous êtes.
Les défenses ripostent. Un IDS peut bloquer votre IP à la volée. Un WAF peut vous couper. Un SOC peut appeler votre client pour vérifier.

Bien menée, la reconnaissance active reste indétectable ou négligeable. Mal menée, c'est le paragraphe « incident » dans le rapport du RSSI.

2. La logique du scan en couches

Un pentester ne lance jamais nmap -A --script vuln d'entrée. On avance en couches, du plus fin au plus large. Chaque couche répond à une question.

Couche	Question	Outil	Bruit
1. Découverte d'hôtes	Qui est vivant ?	`nmap -sn`, `arp-scan`	Bas
2. Balayage de ports	Qu'est-ce qui écoute ?	`nmap -sS -p-`	Moyen
3. Détection de version	Qui écoute, en quelle version ?	`nmap -sV`	Moyen-haut
4. Scripts NSE ciblés	Que dit ce service ?	`nmap --script <spécifique>`	Variable
5. Énumération applicative	Comptes, partages, endpoints	`enum4linux-ng`, `gobuster`	Haut

La règle : chaque couche s'appuie sur la précédente. On ne fait le -sV que sur les ports ouverts, pas sur les 65 535 en aveugle. On ne lance les scripts NSE que sur les services identifiés, pas par défaut.

3. Les états de port de Nmap — arrêtez de mal les lire

Six états possibles. Ne les mélangez plus :

État	Ce que ça veut dire
`open`	Un service écoute et répond.
`closed`	Rien n'écoute — la cible répond avec `RST` (TCP) ou `ICMP port unreachable` (UDP).
`filtered`	Un pare-feu absorbe votre paquet. Ni oui, ni non.
`unfiltered`	La cible répond mais on ne sait pas si le port est ouvert (rare, sur `-sA`).
`open\|filtered`	Aucune réponse — soit ouvert, soit filtré (UDP en fait souvent).
`closed\|filtered`	Idem, mais on penche pour fermé (scan zombie).

Ce que ça change pour vous :

Un port filtered est une information : quelqu'un a mis un pare-feu, donc quelque chose de sensible est derrière.
Un port open|filtered en UDP, c'est très courant : refaites un -sU avec --reason pour trancher.
Une plage nmap qui rend filtered partout, c'est souvent un pare-feu réseau, pas un poste éteint.

4. Les techniques de scan TCP — laquelle, pour quoi

Technique	Option `nmap`	Ce qu'elle fait	Quand la choisir
SYN scan (demi-connexion)	`-sS`	Envoie un SYN, lit SYN/ACK, ne finit pas la poignée de main.	Standard. Rapide et discret. Nécessite `root`.
Connect scan	`-sT`	Poignée de main complète (utilise l'OS).	Sans `root`, ou pour éviter certaines empreintes.
ACK scan	`-sA`	Cartographie les pare-feux (pas les ports ouverts).	Détecter un pare-feu à état vs sans état.
FIN / NULL / Xmas	`-sF / -sN / -sX`	Envoie des combinaisons de flags anormales.	Évasion de pare-feux mal configurés (RFC 793).
Idle scan	`-sI zombie`	Utilise une machine tierce comme relais. Votre IP ne parle jamais à la cible.	Extrême furtivité (et complexité).
UDP scan	`-sU`	Force à scanner UDP. Très lent.	Découvrir DNS, SNMP, NTP, IKE, SIP…

Pour 90 % des missions : -sS en TCP, -sU -p <ports UDP intéressants> en UDP quand c'est utile.

5. Les timing templates — comprendre `-T`

nmap propose six vitesses : -T0 à -T5. Ce ne sont pas des cadeaux ; ce sont des choix.

Template	Débit	Usage
`-T0` paranoid	5 min entre paquets	Réservé aux évasions extrêmes contre IDS.
`-T1` sneaky	15 s entre paquets	Toujours pour évasion, mais moins lent.
`-T2` polite	400 ms entre paquets	Matériel fragile, réseaux industriels.
`-T3` normal	Défaut.	Pentest classique en lab ou en LAN.
`-T4` aggressive	Rapide.	Cible robuste, connexion large.
`-T5` insane	Très rapide.	Précision moindre, faux négatifs fréquents.

Règle : -T3 sauf raison précise de faire autrement. -T4 sur des cibles cloud modernes. Jamais -T5 en prod, même bruyante.

Vous pouvez régler finement avec --max-rate, --min-rate, --scan-delay, --host-timeout — mais 95 % du temps un -T suffit.

6. Les scripts NSE — pouvoir énorme, précaution énorme

nmap embarque plus de 600 scripts (/usr/share/nmap/scripts/). Ils sont classés par catégories. Les plus utiles :

Catégorie	Ce qu'elle fait	Prudence
`default` (ou `-sC`)	Scripts communs, non destructeurs.	Faible.
`safe`	Ne dégrade pas le service.	Faible.
`discovery`	Trouve des choses, sans exploiter.	Faible.
`version`	Améliore la détection de version.	Faible.
`auth`	Détecte des configurations d'auth, parfois tente des logins.	Moyenne.
`vuln`	Détecte des vulnérabilités connues. Souvent, elle les déclenche partiellement.	Élevée.
`exploit`	Exploite activement.	Ne pas lancer sans intention claire.
`intrusive`	Peut faire tomber le service.	Ne jamais lancer sur prod.
`dos`	Fait tomber le service.	Interdit hors lab.

Bonne pratique : --script "safe and default" en scan de découverte. Scripts ciblés (smb-vuln-*, http-shellshock, etc.) une fois qu'on a identifié une piste.

Mauvaise pratique : --script vuln en balayage large. Vous cassez des choses et vous ne saurez pas laquelle.

7. L'énumération Windows / SMB

Sur un parc Windows / Active Directory, la vraie mine d'or est SMB (port 445) et LDAP (389, 636). Les outils :

Outil	Ce qu'il fait
`enum4linux-ng`	Énumère utilisateurs, groupes, partages, politique via session nulle ou avec creds.
`smbclient -L //cible/ -N`	Liste les partages sans authentification.
`crackmapexec smb <cible>`	Le couteau suisse SMB : bannière, partages, tests d'auth, exécution à distance.
`nxc smb <cible>`	Successeur maintenu de crackmapexec (NetExec).
`smbmap -H <cible> -u <user> -p <pass>`	Liste les droits sur chaque partage.
`ldapsearch -x -H ldap://<cible>`	Requêtes LDAP anonymes si permises.

Ce qu'on cherche :

Un accès en session nulle (-u '' -p '') qui donne la liste des utilisateurs = or.
Un partage SYSVOL ou NETLOGON lisible sans mot de passe = anormal, sauf sur un DC.
Des partages IPC$, ADMIN$, C$ accessibles avec un compte de domaine standard.
La politique de mot de passe (longueur, expiration, verrouillage) — utile pour le password spraying plus tard.

8. Wireshark — vérifier ce qu'on émet vraiment

Wireshark n'est pas un outil offensif à proprement parler. Mais un pentester qui ne s'en sert pas est un pentester aveugle.

Trois usages :

Vérifier votre propre trafic. Lancer un nmap et regarder Wireshark : voir combien de paquets vous envoyez vraiment. Un nmap -T4 sur un /24 peut envoyer des dizaines de milliers de SYN en 30 secondes.
Comprendre les erreurs. Un scan qui rend filtered — pourquoi ? Est-ce l'ICMP qui est bloqué en retour, ou le RST qui est absorbé ?
Trouver des protocoles surprises. Un nmap classique voit les ports. Wireshark voit les conversations — un mDNS bavard, un LLMNR non désactivé, un Elasticsearch qui répond en broadcast.

Filtres à connaître par cœur :

tcp.flags.syn == 1 and tcp.flags.ack == 0       # SYN sortants
tcp.flags.reset == 1                             # RST reçus
smb2                                             # Trafic SMB2
dns.qry.name contains "internal"                 # Requêtes DNS suspectes

9. Scapy — quand `nmap` ne suffit plus

Scapy est une bibliothèque Python qui laisse fabriquer un paquet à la main, champ par champ. Utile quand :

Vous voulez tester une combinaison de flags spécifique que nmap ne propose pas nativement.
Vous voulez émettre un paquet unique et voir la réponse en clair.
Vous voulez fabriquer un fuzzing léger de protocole.

Le minimum vital :

from scapy.all import IP, TCP, UDP, ICMP, sr1

reponse = sr1(IP(dst="10.10.10.12") / TCP(dport=445, flags="S"), timeout=2, verbose=0)
if reponse and reponse.haslayer(TCP):
    print("Flags reçus :", reponse[TCP].flags)

flags en retour :

0x12 (SYN+ACK) → le port est ouvert.
0x14 (RST+ACK) → le port est fermé.
None → filtré.

Vous venez d'écrire, en trois lignes, un scan de port qui contourne les signatures d'nmap que certains IDS reconnaissent. C'est la puissance de Scapy.

10. Les erreurs qui coûtent

Lancer -A d'entrée. Vous mélangez découverte, versions, OS, scripts et traceroute. Vous ne savez plus quoi vient d'où. Faites en couches.
Croire au premier scan. Un port peut être filtered à cause d'un IPS transitoire. Repassez, corrélez.
Oublier UDP. Vous manquez SNMP, IKE, SIP, TFTP — des services qui contiennent souvent la clé.
Ne pas capturer. Toujours enregistrer les résultats avec -oA <prefix>. Le fichier .xml sert à msfconsole → db_import.
Scanner de nuit sur un LAN d'entreprise. Le SOC ne dort pas. Prévenez le contact d'escalade avant.
Utiliser une seule adresse IP. Une IP grillée en début de mission = mission ralentie. Prévoyez un plan B (VPN, seconde interface).

11. Ce qu'il faut retenir

Actif = paquets chez la cible. Actez-le mentalement à chaque commande.
Scan en couches : découverte → ports → versions → NSE ciblé.
Six états de port. Chacun raconte une histoire.
-T3 par défaut, -sS par défaut. On règle ensuite.
NSE : safe par défaut, vuln seulement sur cibles identifiées, intrusive jamais sans plan.
SMB est la mine d'or Windows — apprenez nxc smb par cœur.
Wireshark pour comprendre, Scapy pour fabriquer.

Prochaine leçon : on reprend notre lab de la semaine 1, on ajoute une deuxième victime Linux, et on cartographie tout, proprement.

Ce que vous saurez faire après cette leçon​

1. Le passage passif → actif : ce qui change vraiment​

2. La logique du scan en couches​

3. Les états de port de Nmap — arrêtez de mal les lire​

4. Les techniques de scan TCP — laquelle, pour quoi​

5. Les timing templates — comprendre -T​

6. Les scripts NSE — pouvoir énorme, précaution énorme​

7. L'énumération Windows / SMB​

8. Wireshark — vérifier ce qu'on émet vraiment​

9. Scapy — quand nmap ne suffit plus​

10. Les erreurs qui coûtent​

11. Ce qu'il faut retenir​