Séance 2 sur 218 livrablesQuiz corrigé
Le ver en Rust (2) scanner un réseau
Ton scanner marche, mais lentement et sur une seule machine. Aujourd'hui : on le rend ultra-rapide (scan asynchrone) et on l'étend à TOUT un réseau, dans un lab Docker isolé. La vraie brique « trouver des cibles » d'un ver — pour mieux la détecter. Nouveau (8bis) : une passe offensive encadrée sur tes propres conteneurs — bannières, base ouverte, dictionnaire freiné.
Par Josselyn C., prof de BTS SIO. Publié le .
- Objectif
- scanner en parallèle (async/Tokio), scanner une plage d'hôtes, monter un lab Docker, comprendre la propagation d'un ver pour la contrer — et une passe offensive encadrée dans le lab
- On manipule
- Rust + Tokio (+ crate mongodb), Docker, un réseau de machines de test isolé
- Pré-requis
- la séance « Le ver en Rust (1) » et Docker (séance GLPI)
Lab only : tout se passe dans un réseau Docker isolé, sans accès Internet.
Avant de commencer
Où on en est
Séance 1 : ton scanner teste les ports d'une machine, un par un (lent). Aujourd'hui, deux sauts : le rendre rapide (scanner des centaines de ports en parallèle) et l'étendre à plusieurs machines (tout un réseau). On comprendra enfin comment un ver « trouve » ses victimes — et comment un défenseur repère un scan.
Ce que tu sauras faire à la fin
| Étape | Tu sauras… |
|---|---|
| Scan rapide | scanner en parallèle avec async/Tokio (et savoir pourquoi c'est rapide) |
| Scan robuste | gérer le timeout, distinguer port fermé / filtré, limiter la charge (sémaphore) |
| Scan réseau | balayer une plage d'adresses IP (notation CIDR) |
| Lab Docker | monter un réseau de machines de test |
| Observation | voir le scan « en vrai » dans Wireshark (paquets SYN) |
| Offensive (8bis) | identifier un service (bannière), démontrer une base ouverte, freiner un dictionnaire — sur tes conteneurs |
| Ver & défense | comprendre la propagation et la contrer (fail2ban, segmentation, IDS) |
0. Le problème de la vitesse
Ton scanner de la séance 1 teste un port, attend la réponse, puis passe au suivant. Sur un réseau réel, chaque port filtré fait attendre le programme (timeout). 1024 ports × plusieurs secondes = des minutes. Inutilisable pour scanner un réseau entier.
Séquentiel : on attend chaque port avant le suivant. Asynchrone : on lance tous les tests en même temps et on récupère les réponses au fur et à mesure.
Flag A1
Checkpoint
Pourquoi le scan séquentiel est-il si lent sur une machine distante ? Qu'est-ce que le parallélisme change ? Rends : ta réponse.
1. Le scan asynchrone (Tokio)
D'abord : c'est quoi « asynchrone » ?
Synchrone = tu fais une chose, tu attends qu'elle finisse, puis la suivante. Asynchrone (async) = tu lances une chose, et pendant qu'elle attend (une réponse réseau, par ex.), tu fais autre chose. Analogie : au restaurant, un serveur synchrone prend une commande, va en cuisine, attend le plat planté devant le passe, le sert, puis passe à la table suivante. Un serveur asynchrone prend les commandes de toutes les tables, les passe en cuisine, et sert chaque plat dès qu'il sort. Même serveur, dix fois plus de tables — parce qu'il ne reste jamais planté à attendre.
Un scan de port, c'est 99 % d'attente : on envoie une demande de connexion et on attend la réponse (de quelques millisecondes à plusieurs secondes). Pendant cette attente, le processeur ne fait rien. L'async remplit ces trous : pendant qu'un port « réfléchit », on interroge les 1000 autres. C'est exactement le bon outil ici — et ce sera vrai pour tout code qui passe son temps à attendre le réseau, un disque, une base de données.
Rust gère l'async avec Tokio, la bibliothèque de référence (le runtime async le plus utilisé de l'écosystème). On l'ajoute au projet. Dans Cargo.toml, section [dependencies] :
tokio = { version = "1", features = ["full"] }
Le scanner asynchrone
use tokio::net::TcpStream;
#[tokio::main]
async fn main() {
let cible = "127.0.0.1";
let mut taches = vec![];
for port in 1..1025 {
let adresse = format!("{}:{}", cible, port);
taches.push(tokio::spawn(async move {
if TcpStream::connect(&adresse).await.is_ok() {
println!("Port {} : OUVERT", port);
}
}));
}
for t in taches {
let _ = t.await;
}
println!("Scan terminé.");
}
Flag B1
Production
Ajoute Tokio, écris le scanner asynchrone et lance-le. Rends : ton Cargo.toml (la ligne tokio), ton code, et la sortie. Note la différence de vitesse.
2. Tokio en profondeur
Tu viens de lancer plus de 1000 tâches d'un coup. Question légitime : est-ce que ça crée 1000 threads ? Non — et c'est tout le génie de Tokio. Comprendre ce qui se passe dessous, c'est ce qui sépare « ça marche » de « je sais pourquoi ça marche ».
Une tâche async n'est PAS un thread système
| Thread OS (système) | Tâche async (Tokio) | |
|---|---|---|
| Créé par | le système d'exploitation | Tokio, dans ton programme |
| Coût mémoire (pile) | ~1 à 8 Mo chacun | quelques centaines d'octets |
| Combien réalistes | quelques milliers max | des centaines de milliers |
| Qui décide quand il tourne | l'OS (préemptif, à tout moment) | Tokio, aux points .await (coopératif) |
Fais le calcul : 100 000 threads OS × ~2 Mo de pile = 200 Go de RAM. Impossible. 100 000 tâches Tokio tiennent dans quelques dizaines de Mo. Voilà pourquoi un scanner async passe à l'échelle, et pas un scanner « un thread par port ».
Le runtime : quelques threads, des milliers de tâches
Au démarrage, #[tokio::main] crée par défaut un runtime multi-thread : un petit groupe de threads OS — un par cœur logique de ton processeur (8 threads sur un CPU 8 cœurs). Ces threads (les workers) se partagent une file de tâches (techniquement : une file par worker, plus du work stealing — un worker dont la file est vide pique des tâches à ses voisins). C'est le modèle N threads / M tâches, avec M ≫ N (des milliers de tâches pour une poignée de threads).
Modèle N threads / M tâches : peu de workers (1 par cœur) font tourner des milliers de tâches, en jonglant à chaque attente réseau.
La boucle d'événements (event loop)
Chaque worker tourne une boucle : il prend une tâche prête, l'exécute jusqu'au prochain .await, et là, deux cas :
- la donnée est déjà disponible → la tâche continue tout de suite ;
- ça attend le réseau → Tokio met la tâche de côté, note « réveille-moi quand la socket répond », et le worker prend une autre tâche. Il ne reste jamais bloqué à ne rien faire.
Le « réveille-moi quand » s'appuie sur le système d'exploitation : epoll sous Linux, kqueue sous macOS. L'OS surveille des milliers de sockets à la fois et prévient Tokio dès qu'une répond. C'est ce moteur qui rend le scan massif possible.
Mesurer : séquentiel vs async, chrono en main
On ne va pas te croire sur parole : chronomètre les deux versions avec std::time::Instant.
use std::time::Instant;
// juste avant de lancer le scan :
let debut = Instant::now();
// ... tout le scan (les deux boucles) ...
println!("Durée totale : {:?}", debut.elapsed());
Flag B5
Production (chronométrage)
Chronomètre ta version async avec Instant, puis écris une version séquentielle (une seule boucle, un connect().await à la fois, sans spawn) et chronomètre-la aussi, sur la même cible. Rends : les deux durées mesurées et le facteur d'accélération que tu obtiens.
3. Fiabiliser le scan : le timeout
Ton scanner a un défaut caché : invisible sur localhost, il le rend inutilisable sur un vrai réseau. Corrige-le maintenant — c'est le chapitre le plus important pour un scan qui « marche pour de vrai ».
Le piège : un port filtré bloque… pour toujours
Quand tu appelles TcpStream::connect, trois choses peuvent arriver :
| État du port | Ce que la cible fait | Ce que ton code voit |
|---|---|---|
| OUVERT | répond « OK » (paquet SYN-ACK) | connect réussit → Ok |
| FERMÉ (closed) | refuse poliment (paquet RST) | connect échoue tout de suite → Err « connection refused » |
| FILTRÉ (filtered) | ignore : un pare-feu jette le paquet, aucune réponse | connect attend… indéfiniment |
Le cas FILTRÉ est le tueur. Sans limite de temps, ta tâche reste suspendue jusqu'au timeout par défaut du système — 127 secondes sous Linux par défaut (~75 s sur macOS). Explication : le noyau réémet le SYN avec un backoff exponentiel, contrôlé par /proc/sys/net/ipv4/tcp_syn_retries (valeur par défaut : 6). Séquence des délais : 1 s + 2 s + 4 s + 8 s + 16 s + 32 s + 64 s = 127 s avant abandon. Sur un réseau protégé, la majorité des ports sont filtrés : ton scan ne se termine jamais.
La parade : tokio::time::timeout
use tokio::net::TcpStream;
use tokio::time::{timeout, Duration};
async fn tester_port(adresse: String, port: u16) {
let essai = timeout(
Duration::from_millis(300),
TcpStream::connect(&adresse),
).await;
match essai {
Ok(Ok(_)) => println!("Port {} : OUVERT", port),
Ok(Err(_)) => {} // FERMÉ : RST reçu vite, on ignore
Err(_) => {} // FILTRÉ : délai dépassé, on ignore
}
}
Régler le timeout : le compromis vitesse / fiabilité
Le timeout est un curseur, pas une valeur magique.
| Timeout | Effet | Quand |
|---|---|---|
| 50-100 ms | très rapide, mais rate les hôtes lents/lointains (faux « fermé ») | réseau local (LAN), latence < 1 ms |
| 200-500 ms | bon compromis (notre choix : 300 ms) | la plupart des cas — notre lab |
| 1-3 s | fiable sur liaison lente, mais scan lent | cible distante, réseau chargé |
Règle de pro : le timeout doit couvrir le RTT (temps d'aller-retour réseau) avec de la marge. En LAN, le RTT est < 1 ms : 300 ms est très confortable. Régler trop bas = déclarer « fermés » des ports en fait ouverts mais lents : des faux négatifs, l'erreur la plus grave d'un scan (on rate une cible réelle).
Flag B6
Production (le scan robuste)
Intègre tokio::time::timeout à ton scanner et fais-lui distinguer les trois états. Teste sur 127.0.0.1 (ports fermés → RST) puis sur une adresse libre de ton propre sous-réseau, ex. 172.18.0.250 dans le lab (rien ne répond → filtré). Évite une IP d'un autre réseau (ex. 10.255.255.1) : si ta machine n'a pas de route vers elle, le noyau répond « réseau inaccessible » immédiatement — le port ressort alors « fermé », pas « filtré », et le test ne prouve rien. Rends : ton code, et une phrase expliquant pourquoi l'IP libre ressort « filtrée » et non « fermée ».
4. Limiter la concurrence : le sémaphore
« Tout lancer en même temps », c'est puissant… et dangereux. Scanner les 65 535 ports × 254 hôtes = plus de 16 millions de tâches lancées d'un coup, donc 16 millions de sockets ouvertes en même temps. Le système d'exploitation refuse.
C'est quoi un sémaphore ?
Un sémaphore, c'est le videur d'une boîte de nuit : la salle a une capacité (ex. 500 personnes). À l'entrée, le videur donne un ticket (permit) ; s'il n'en reste plus, tu attends dehors qu'un client sorte et rende le sien. Résultat : jamais plus de 500 personnes dedans, même si 10 000 font la queue.
use std::sync::Arc;
use tokio::sync::Semaphore;
#[tokio::main]
async fn main() {
let limite = Arc::new(Semaphore::new(500)); // 500 connexions max en même temps
let mut taches = vec![];
for port in 1..=65535u16 {
let permis = Arc::clone(&limite);
taches.push(tokio::spawn(async move {
let _ticket = permis.acquire().await.unwrap(); // attend un ticket libre
// ... ici : le connect avec timeout du chapitre 3 ...
// le ticket est rendu tout seul à la fin de la tâche
}));
}
for t in taches { let _ = t.await; }
}
Flag E1
Extension
Ajoute un sémaphore à ton scanner et fais varier la limite (ex. 50, puis 500, puis 2000) en chronométrant à chaque fois (Flag B5). Indice : à 2000, tu dépasseras probablement ulimit -n (1024) — observe l'erreur, c'est instructif, ou relance après ulimit -n 4096. Rends : un petit tableau limite → durée, et la valeur qui te semble le meilleur compromis vitesse/stabilité sur ta machine, avec une phrase de justification.
5. Le lab : un réseau de machines
Pour scanner un réseau, il faut… un réseau. On en crée un, isolé, avec Docker (comme pour GLPI). Au terminal :
docker network create labnet
docker run -d --name cible1 --network labnet nginx
docker run -d --name cible2 --network labnet httpd
docker run -d --name cible3 --network labnet -e MYSQL_ROOT_PASSWORD=test mysql:8.0
Trouver les IP du réseau
docker network inspect labnet
Flag B2
Production
Monte le lab (réseau + 3 conteneurs) et relève leurs IP. Rends : la sortie de docker network inspect labnet (les IP des cibles).
6. Scanner tout le réseau
On combine ce qu'on a construit : async + timeout (le sémaphore du chap. 4 n'est pas indispensable ici — 19 hôtes × 4 ports = 76 tâches seulement — mais il le deviendrait pour un /24 entier, cf. l'encadré plus bas) : pour chaque IP de la plage, on scanne les ports clés. C'est la vraie fonction « découverte de cibles » — celle qu'un défenseur doit savoir reconnaître.
use tokio::net::TcpStream;
use tokio::time::{timeout, Duration};
#[tokio::main]
async fn main() {
let base = "172.18.0"; // la plage du lab
let ports = [22, 80, 443, 3306]; // services à chercher
let mut taches = vec![];
for hote in 1..20 {
for &port in &ports {
let adresse = format!("{}.{}:{}", base, hote, port);
taches.push(tokio::spawn(async move {
// timeout du chap. 3 OBLIGATOIRE ici : sans lui, chaque IP vide
// (.5 à .19) ferait attendre sa tâche ~127 s au lieu de 300 ms
if timeout(Duration::from_millis(300), TcpStream::connect(&adresse)).await.is_ok() {
println!("CIBLE {} → port {} OUVERT", adresse, port);
}
}));
}
}
for t in taches { let _ = t.await; }
println!("Découverte terminée.");
}
Flag B3
Mini-projet (production)
Scanne ton réseau de lab et dresse la carte : quelle cible expose quel service. Rends : ton code et la carte du réseau obtenue (IP → ports ouverts → service deviné).
7. Observer le scan : atelier Wireshark
Un scan, ce sont des paquets réseau. Pour vraiment comprendre — et surtout pour te mettre dans la peau du défenseur qui repère l'attaque — on va regarder ces paquets avec Wireshark, l'analyseur réseau de référence (gratuit, open source). C'est de la pure observation défensive : on ne fabrique rien de nouveau, on lit ce que ton scanner produit déjà.
Rappel : le « three-way handshake » TCP
Ouvrir une connexion TCP, c'est une poignée de main en 3 temps. C'est ce que ton connect déclenche à chaque port.
Port ouvert : SYN → SYN-ACK → ACK. Port fermé : SYN → RST (refus immédiat). Port filtré : le SYN part, rien ne revient.
Capturer le trafic du scan
Wireshark (interface graphique) sait écouter une interface réseau. Le réseau Docker apparaît comme une interface br-XXXXXX. En ligne de commande, tcpdump fait la même capture, plus léger :
# 1. repérer l'interface du réseau Docker
ip addr | grep -B1 172.18 # cherche le "br-..." qui porte ta plage
# 2. capturer UNIQUEMENT les demandes de connexion (paquets SYN)
sudo tcpdump -i br-XXXXXX -n 'tcp[tcpflags] & tcp-syn != 0 and tcp[tcpflags] & tcp-ack == 0'
Lance la capture, puis cargo run sur ton scanner dans un autre terminal. Regarde la capture se remplir :
10:42:01.001 IP 172.18.0.1.51002 > 172.18.0.2.22: Flags [S]
10:42:01.001 IP 172.18.0.1.51003 > 172.18.0.2.80: Flags [S]
10:42:01.002 IP 172.18.0.1.51004 > 172.18.0.2.443: Flags [S]
10:42:01.002 IP 172.18.0.1.51005 > 172.18.0.3.22: Flags [S]
10:42:01.002 IP 172.18.0.1.51006 > 172.18.0.3.80: Flags [S]
...
Flag D1
Investigation
Capture le trafic pendant un scan de ton lab, puis identifie dans la capture : (1) un port ouvert (retrouve les 3 paquets SYN / SYN-ACK / ACK) et (2) un port fermé (SYN suivi d'un RST). Rends : une capture d'écran annotée (ou les lignes copiées) montrant ces deux cas, et une phrase décrivant la signature qui trahit le scan.
8. Comment un ver se propage
Ton scanner est la première brique d'un ver. Dans ce chapitre, on assemble la chaîne complète en trois temps : on la comprend (le schéma ci-dessous), on l'écrit en pseudo-code (8.1), et on en fait même tourner une version inoffensive dans ton lab (8.2) — sans jamais construire d'arme réelle. On termine par l'étape qu'on ne code pas, forcer le login (8.3), car c'est là que la défense du chapitre 9 frappe le plus fort.
La boucle d'un ver : scanner → trouver un accès → forcer l'authentification → se copier → recommencer depuis la nouvelle machine. La propagation est exponentielle.
Flag A2
Checkpoint
Explique, avec tes mots, les 5 étapes d'un ver réseau. Pourquoi sa propagation est-elle « exponentielle » ? Rends : ta réponse.
8.1 · L'algorithme d'un ver (en pseudo-code)
Tu sais déjà écrire du pseudo-code (Rust 1, chap. 1). Voici l'algorithme complet d'un ver réseau. Lis-le bien : tu vas y reconnaître ton chapitre 6.
FONCTION propager(plage_reseau)
cibles ← scanner(plage_reseau) // ← TON chapitre 6 !
POUR CHAQUE cible DANS cibles
SI un accès est ouvert (ex. port 22, SSH) ALORS
secret ← forcer_le_login(cible) // essaie une liste de mots de passe
SI secret trouvé ALORS
copier_le_ver(cible) // se recopie sur la cible
lancer_le_ver(cible) // la cible exécute propager(...) à son tour
FINSI
FINSI
FIN POUR
FIN FONCTION
Flag B7
Conception (pseudo-code)
Réécris l'algorithme propager(...) avec tes mots, et ajoute une 6e étape qui manque ci-dessus : ne pas réinfecter une machine déjà infectée (comment le ver pourrait-il le savoir avant de se recopier ?). Indice : le vrai ver Morris a planté des milliers de machines justement parce qu'il les réinfectait en boucle. Rends : ton pseudo-code complété + ta phrase sur l'anti-réinfection.
8.2 · Voir la propagation en vrai — version inoffensive
On fait tourner la boucle du ver dans ton lab Docker, mais on remplace l'arme par un témoin : au lieu de forcer un login et de copier un vrai programme, le code dépose un simple fichier-texte « témoin » pour chaque cible atteignable. Tu vois la boucle scan → liste → « infection » se dérouler, sans rien casser ni rien forcer.
use std::collections::HashSet;
use std::fs;
use tokio::net::TcpStream;
use tokio::time::{timeout, Duration};
#[tokio::main]
async fn main() {
let base = "172.18.0"; // la plage du lab (adapte, cf. chap. 5)
let ports = [22, 80, 443, 3306];
let mut taches = vec![];
// 1. RECONNAISSANCE — exactement le scan du chapitre 6
for hote in 1..20 {
for &port in &ports {
let adresse = format!("{}.{}:{}", base, hote, port);
taches.push(tokio::spawn(async move {
// timeout du chap. 3 : les IP vides ne répondent jamais
match timeout(Duration::from_millis(300), TcpStream::connect(&adresse)).await {
Ok(Ok(_)) => Some(format!("{}.{}", base, hote)), // OUVERT : cible trouvée
_ => None, // fermé ou filtré : rien
}
}));
}
}
// 2. on rassemble les IP UNIQUES ayant au moins un port ouvert
let mut cibles = HashSet::new();
for t in taches {
if let Ok(Some(ip)) = t.await {
cibles.insert(ip);
}
}
// 3. PROPAGATION SIMULÉE : au lieu de forcer+copier (interdit),
// on dépose un fichier-témoin EN LOCAL pour chaque cible.
for ip in &cibles {
let nom = format!("temoin_{}.txt", ip.replace('.', "_"));
fs::write(&nom, "Si ceci etait un vrai ver, je me serais copie ici.\n")
.expect("ecriture du temoin");
println!("VER (simule) -> {} : temoin {} depose", ip, nom);
}
println!("Propagation simulee : {} machine(s) infectee(s).", cibles.len());
}
Flag B8
Production (la propagation, inoffensive)
Monte le lab (chap. 5), écris le propagateur simulé et lance-le. Rends : la sortie du programme + le résultat de ls temoin_*.txt (un témoin par cible). Bonus (type E) : ajoute l'anti-réinfection du Flag B7 — ne dépose pas de témoin si le fichier existe déjà (std::path::Path::new(&nom).exists()), et affiche « déjà infectée » à la place. Bonus (type E, plus difficile) : transforme le HashSet en HashMap<String, u32> qui compte le nombre de ports ouverts par cible, et affiche à la fin la « cible la plus intéressante » — celle qui expose le plus de services.
8.3 · L'étape qu'on saute : forcer le login
Dans l'algo, une ligne cache tout le danger : forcer_le_login(cible). C'est l'étape 3 — celle qu'on ne code pas, mais qu'il faut comprendre pour la bloquer.
« Forcer » un login, c'est une attaque par dictionnaire : le ver essaie une liste de secrets courants, un par un, jusqu'à ce qu'un fonctionne. Pas de magie ni de faille complexe — juste la vitesse d'une machine qui teste des milliers de combinaisons.
Pourquoi un mot de passe faible tombe en secondes
Tout est une question de nombre de combinaisons à essayer (l'« espace de recherche »). Une machine moderne teste des milliards d'essais par seconde contre un secret volé hors-ligne :
| Mot de passe | Combinaisons à essayer | Temps (ordre de grandeur) |
|---|---|---|
1234 (4 chiffres) | 10^4 = 10 000 | instantané |
password (dans toutes les listes) | 1 essai | instantané |
| 8 lettres minuscules | 26^8 ≈ 2×10^(11) | secondes à minutes |
| 12 car. (maj + min + chiffres + symboles) | 95^(12) ≈ 5×10^(23) | siècles |
| Clé SSH Ed25519 | 2^(256) | hors d'atteinte (aucun brute-force possible) |
Chaque caractère en plus multiplie l'espace de recherche. C'est pour ça que longueur + variété battent tout, et qu'une clé cryptographique est, en pratique, impossible à forcer.
Flag D2
Investigation
Cherche en ligne deux identifiants/mots de passe par défaut d'un vrai appareil (box Internet, caméra IP, routeur, imprimante…). Rends : tes 2 exemples (appareil → login par défaut) + une phrase : lequel de TES appareils as-tu (ou pas) protégé en changeant son secret par défaut ?
Chapitre 8bis — Passer à l'offensive (toujours dans le lab)
Jusqu'ici, tu as observé : scanner, regarder les paquets, simuler. Un attaquant, lui, agit après le scan. Ce chapitre ajoute trois mouvements offensifs classiques — identifier le service, lire ce qui est ouvert, tenter des secrets — tous codés en Rust, tous dirigés vers tes propres conteneurs. Le contrat ne change pas : chaque mouvement se termine par sa contre-mesure, et tout sert au plan de défense du chapitre 9.
Petit geste d'abord : ajoute 27017 au tableau ports de ton scanner (chap. 6) et relance-le — la nouvelle cible apparaît dès qu'elle existe. C'est exactement ça, élargir la liste des services recherchés. (Sur Docker Desktop ? Lance le code attaquant en conteneur sur labnet, cf. l'encadré du chap. 5.)
8bis.1 · Banner grabbing — demander au service qui il est
Le scan dit « port 80 ouvert ». L'attaquant veut savoir qui répond : quel logiciel, quelle version exacte. Le truc : certains services se présentent spontanément à la connexion (le vrai « banner grabbing »), d'autres — comme HTTP — exigent qu'on leur parle d'abord. On envoie donc une sonde (une requête HTTP minimale) et on lit la première réponse :
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::{timeout, Duration};
// Envoie une sonde (ou rien) et renvoie ce que le service répond en premier.
async fn sonder(adresse: &str, sonde: Option<&str>) -> Option<String> {
timeout(Duration::from_millis(500), async {
let mut flux = TcpStream::connect(adresse).await.ok()?;
if let Some(s) = sonde {
flux.write_all(s.as_bytes()).await.ok()?; // HTTP : on parle le premier
}
let mut tampon = vec![0u8; 512];
let n = flux.read(&mut tampon).await.ok()?;
Some(String::from_utf8_lossy(&tampon[..n]).to_string())
}).await.ok().flatten()
}
#[tokio::main]
async fn main() {
// (adresse, sonde) — HTTP exige une requête ; MySQL parle tout seul.
for (adresse, sonde) in [
("172.18.0.2:80", Some("HEAD / HTTP/1.0\r\n\r\n")),
("172.18.0.3:80", Some("HEAD / HTTP/1.0\r\n\r\n")),
("172.18.0.4:3306", None),
] {
let brut = sonder(adresse, sonde).await.unwrap_or_default();
// on ne garde que ce qui trahit le serveur : statut + en-tête Server:
let empreinte: Vec<&str> = brut
.lines()
.filter(|l| l.starts_with("HTTP/") || l.to_lowercase().starts_with("server:"))
.collect();
if empreinte.is_empty() {
// pas du HTTP ? on montre le début des octets bruts (cas MySQL)
let apercu: String = brut.chars().take(50).collect();
println!("{} → {:?}", adresse, apercu);
} else {
println!("{} → {}", adresse, empreinte.join(" | "));
}
}
}
Flag B9
Production (empreintes de services)
Lance le sondeur sur les 3 cibles du lab. Rends : ton code + la sortie, et une phrase : quelle information l'empreinte donne-t-elle à l'attaquant, et quel réglage du serveur la contrecarre ?
8bis.2 · La base de données ouverte — lire ce qui n'était pas verrouillé
La vague MongoDB de janvier 2017 (plus de 28 000 bases effacées et rançonnées, cf. tableau du chap. 6) n'a exploité aucune faille : les bases écoutaient sur Internet, sans mot de passe. L'image mongo fait pareil par défaut. On crée donc une base « ouverte » dans le lab, puis on constate ce qu'un attaquant voit depuis sa machine :
# cible4 : MongoDB SANS authentification (comportement par défaut de l'image !)
docker run -d --name cible4 --network labnet mongo:7
# attendre ~10 s que mongo démarre, puis peupler une fausse base « boutique »
docker exec cible4 mongosh --quiet --eval '
db = db.getSiblingDB("boutique");
db.clients.insertMany([
{ nom: "Client Test 1", email: "c1@exemple.fr", carte: "4929 0000 0000 0000" },
{ nom: "Client Test 2", email: "c2@exemple.fr", carte: "4929 0000 0000 0001" },
{ nom: "Client Test 3", email: "c3@exemple.fr", carte: "4929 0000 0000 0002" }
])'
Côté attaquant, la crate officielle mongodb (async — parfaite avec Tokio). Ajoute-la (cargo add mongodb@3) ou complète ton Cargo.toml :
[dependencies]
tokio = { version = "1", features = ["full"] }
mongodb = "3"
use mongodb::bson::{doc, Document};
use mongodb::Client;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// la cible du lab : aucune authentification demandée
let client = Client::with_uri_str("mongodb://172.18.0.5:27017").await?;
println!("== bases visibles sans identifiant ==");
for b in client.list_database_names().await? {
println!(" - {}", b);
}
let clients = client.database("boutique").collection::<Document>("clients");
let total = clients.count_documents(doc! {}).await?;
println!("== {} documents dans « clients » : accès total ==", total);
if let Some(doc) = clients.find_one(doc! {}).await? {
println!("document lu : {:?}", doc);
}
Ok(())
}
Flag B10
Production (la base ouverte)
Lance la lecture de cible4. Rends : la sortie, et les deux réglages qui auraient tout bloqué — l'authentification obligatoire dès la création, et le fait de n'exposer la base qu'à son propre réseau (segmentation, cf. chap. 9).
8bis.3 · Le dictionnaire, en vrai — avec le frein à main
En 8.3, tu as compris pourquoi la liste de Mirai suffisait — sans la coder (« c'est l'étape qu'on saute »). On la code maintenant : contre ta propre base, avec un mot de passe faible exprès, et un frein à main — quelques essais par seconde, pas des milliers. On crée cible5 avec une authentification activée… et un secret déplorable :
# cible5 : MongoDB AVEC mot de passe... faible, exprès (c'est TA base de test)
docker run -d --name cible5 --network labnet \
-e MONGO_INITDB_ROOT_USERNAME=root \
-e MONGO_INITDB_ROOT_PASSWORD=admin123 \
mongo:7
use mongodb::bson::doc;
use mongodb::Client;
use std::time::Duration;
const CIBLE: &str = "172.18.0.6:27017"; // cible5 (vérifie avec docker network inspect)
const UTILISATEUR: &str = "root";
const DICO: &[&str] = &[
"root", "admin", "123456", "password", "admin123",
"motdepasse", "azerty", "qwerty", "test", "root123",
];
#[tokio::main]
async fn main() {
for (n, mdp) in DICO.iter().enumerate() {
// le frein à main : 200 ms entre chaque essai (~5 essais/s, pas plus)
tokio::time::sleep(Duration::from_millis(200)).await;
let uri = format!("mongodb://{}:{}@{}", UTILISATEUR, mdp, CIBLE);
let client = match Client::with_uri_str(&uri).await {
Ok(c) => c,
Err(_) => continue,
};
// la commande ping n'aboutit que si l'authentification passe
let reussi = client.database("admin")
.run_command(doc! { "ping": 1 })
.await
.is_ok();
println!("essai {:>2}/{} : {:?} → {}",
n + 1, DICO.len(), mdp,
if reussi { "TROUVÉ" } else { "refusé" });
if reussi { break; }
}
}
Flag B11
Production (dictionnaire freiné)
Lance le dictionnaire contre cible5. Rends : la sortie, puis recrée cible5 avec un mot de passe fort (openssl rand -base64 18) et montre que le dictionnaire échoue intégralement — avec une phrase : pourquoi la longueur bat le dictionnaire (cf. tableau 8.3).
Flag D3
Investigation (la vue du défenseur)
Ton dictionnaire vient de laisser des traces : docker logs cible5 2>&1 | grep -i auth (ou simplement docker logs cible5 | tail -20). Rends : une capture annotée des échecs d'authentification provoqués par ton propre code — c'est exactement ce qu'un administrateur voit de son côté. Une attaque bruyante se trahit aussitôt ; une lente se trahit moins, mais prend un temps fou.
Flag E2
Extension (paralléliser… et se faire repérer)
Reprends le sémaphore du chap. 4 et parallélise le dictionnaire (10 essais simultanés). Chronomètre, compare avec la version freinée, puis relis les logs de cible5 : le bruit est immédiat. Écris trois phrases : à partir de quel rythme un IDS/fail2ban devrait-il alerter, et pourquoi un attaquant « intelligent » préfère-t-il être lent ?
9. Se défendre d'un ver
C'est tout l'intérêt d'avoir compris l'attaquant : savoir comment l'arrêter. À chaque étape du ver, une parade — et cette fois, avec des configs et des chiffres concrets, pas des principes flous.
| Étape du ver | Parade côté défense |
|---|---|
| 1. Scanner | fermer les ports inutiles, segmenter le réseau, détecter les scans (beaucoup de connexions = alerte) |
| 2. Trouver un accès | réduire la surface : pas de service exposé sans raison, mises à jour |
| 3. Forcer le mot de passe | mots de passe forts, 2FA, fail2ban (bloque après N échecs), clés SSH |
| 4. Se copier | droits limités, antivirus/EDR, intégrité des fichiers surveillée |
| 5. Recommencer | segmentation : une machine compromise ne voit pas tout le réseau |
Durcir concrètement (configs et chiffres)
1. fail2ban — casser le forçage de mot de passe (étape 3)
fail2ban lit les logs et bannit une IP qui échoue trop souvent. Extrait de /etc/fail2ban/jail.local :
[sshd]
enabled = true
maxretry = 5 # 5 échecs de login autorisés...
findtime = 10m # ...dans une fenêtre de 10 minutes
bantime = 1h # puis IP bannie 1 h (-1 = bannissement permanent)
2. Segmentation + iptables — couper la propagation latérale (étape 5)
Si une machine tombe, il faut qu'elle ne puisse pas scanner ni attaquer ses voisines (le fameux mouvement latéral). On n'autorise que le strict nécessaire, on jette le reste :
# n'autoriser que le port applicatif attendu, depuis le proxy connu
iptables -A INPUT -p tcp --dport 443 -s 10.0.0.10 -j ACCEPT
# refuser toute autre connexion venant des autres machines internes
iptables -A INPUT -s 10.0.0.0/24 -j DROP
3. IDS / IPS — détecter automatiquement le scan (étape 1)
Un IDS (Intrusion Detection System) surveille le trafic et alerte ; un IPS bloque en plus. Deux références open source :
- Suricata — moderne, multi-thread, comprend les protocoles applicatifs.
- Snort — l'ancêtre, immense base de règles communautaires.
La logique d'une règle anti-scan : « si une IP source ouvre > 20 connexions vers > 20 ports en < 5 s → alerte portscan ». C'est précisément le comportement que tu as vu dans Wireshark au chap. 7. Côté preuve, on journalise ces alertes (horodatées, IP source) : ce sont les traces qui serviront à caractériser l'attaque après coup.
Exemple d'une règle Suricata anti-scan (fichier /etc/suricata/rules/local.rules) :
alert tcp any any -> $HOME_NET any (
msg:"SCAN SYN flood portscan";
flags:S,12;
threshold: type threshold, track by_src, count 20, seconds 5;
classtype:attempted-recon;
sid:1000001; rev:1;
)
Flag B4
Production (le plan de défense)
Tu es l'admin du réseau de GSB (Galaxy Swiss Bourdin, l'entreprise fictive des études de cas du BTS SIO). Rédige un plan de défense en 5 points contre un ver qui scanne et se propage (une parade par étape). Rends : ton plan.
Pour finir (séance 2/2)
Ce que tu as construit & compris
| Brique | Tu sais… |
|---|---|
| Scan asynchrone (Tokio) | scanner vite, en parallèle — et expliquer le modèle N threads / M tâches |
| Timeout & sémaphore | rendre le scan fiable (fermé vs filtré) et maîtrisé (concurrence plafonnée) |
| Scan réseau | cartographier les services d'une plage d'IP (CIDR) |
| Lab Docker | monter un terrain d'entraînement isolé |
| Wireshark | lire les paquets SYN et reconnaître la signature d'un scan |
| Propagation d'un ver | écrire son algorithme en pseudo-code, le simuler sans arme (fichiers-témoins), et expliquer l'attaque par dictionnaire |
| Offensive encadrée (8bis) | lire la bannière d'un service, démontrer une base ouverte, freiner un dictionnaire — et citer chaque contre-mesure |
| Défense | contrer chaque étape (fail2ban, clés SSH, iptables, IDS Suricata) |
Glossaire
| Mot | Définition |
|---|---|
| Asynchrone (async) | lancer plusieurs tâches sans attendre chacune à la suite |
| Tokio / runtime | la bibliothèque async de Rust ; le runtime fait tourner N threads pour M tâches |
| Tâche (task) | unité de travail légère lancée par tokio::spawn (≠ thread OS) |
| Event loop | boucle qui exécute chaque tâche jusqu'à un .await, puis passe à une autre |
| Timeout | limite de temps sur une opération ; sans elle, un port filtré bloque à l'infini |
| RST | paquet TCP de refus : la cible dit « port fermé » tout de suite |
| Filtré (filtered) | port derrière un pare-feu qui ne répond pas → détecté par expiration du timeout |
| Three-way handshake | ouverture TCP en 3 temps : SYN → SYN-ACK → ACK |
| Sémaphore | plafond de tâches simultanées (des « tickets ») pour ne pas saturer l'OS |
| Descripteur de fichier | ressource OS consommée par chaque socket ; limitée (ulimit -n, souvent 1024) |
| CIDR (/16, /24) | notation d'une plage d'IP : nombre de bits fixes du réseau |
| Ver (worm) | malware qui se propage seul de machine en machine |
| Attaque par dictionnaire | essayer une liste de mots de passe courants jusqu'à en trouver un qui marche |
| Espace de recherche | nombre total de combinaisons à essayer pour forcer un secret ; chaque caractère en plus le multiplie |
| Segmentation | découper un réseau pour limiter la propagation latérale |
| fail2ban | bannit une IP après N échecs de login (maxretry / bantime) |
| Banner grabbing | lire ce qu'un service annonce spontanément (ou après une sonde) : logiciel, version |
| Pentest (test d'intrusion) | attaques pratiquées sur mandat écrit, dans un périmètre signé — le métier derrière ce TP |
| IDS / IPS | détecte (IDS) ou bloque (IPS) les attaques ; ex. Suricata, Snort |
Mini-quiz — vérifie-toi (auto-correction)
Exercice Réussi À revoir
Réponds de tête, puis compare au corrigé juste en dessous. Si tu bloques sur une question, relis le chapitre concerné.
- Une tâche Tokio, est-ce la même chose qu'un thread système ? Pourquoi peut-on en lancer 100 000 ?
- Ton scan se fige sur une cible protégée par un pare-feu. Cause la plus probable, et correctif ?
- Au niveau des paquets, quelle est la différence entre un port fermé et un port filtré ?
- À quoi sert un sémaphore dans le scanner ? Que se passe-t-il sans lui à grande échelle ?
- Cite deux réglages fail2ban et leur rôle contre un ver qui force SSH.
- Après le scan, pourquoi l'attaquant lit-il d'abord la « bannière » du service ? Quel réglage défensif répond à cela ?
- Ta base de lab répond sans identifiant. Deux réglages auraient tout bloqué — lesquels ?
- Pourquoi un dictionnaire « en ligne » est-il bien plus lent qu'une attaque « hors ligne » sur un hash volé, et quelles défenses en découlent ?
Voir le corrigéMasquer le corrigé de l'exercice
1. Non : une tâche async est gérée par Tokio (pas par l'OS), coûte quelques centaines d'octets (vs 1-8 Mo pour un thread) et rend la main à chaque .await. Quelques threads (1 par cœur) font tourner des milliers de tâches → modèle N threads / M tâches.
2. Un port filtré ne répond jamais ; sans tokio::time::timeout, connect attend le timeout système (> 2 min). Correctif : envelopper connect dans timeout(Duration::from_millis(300), …).
3. FERMÉ = la cible renvoie un paquet RST immédiatement (refus poli, échec rapide). FILTRÉ = un pare-feu jette le paquet, aucune réponse → on ne le détecte que par l'expiration du délai.
4. Il plafonne le nombre de connexions simultanées (ex. 500). Sans lui, on épuise les descripteurs de fichiers → Too many open files (limite ulimit -n, souvent 1024).
5. maxretry = nombre d'échecs tolérés (ex. 5) ; bantime = durée de bannissement de l'IP (ex. 1 h). Ensemble, ils cassent l'étape « forcer le mot de passe » du ver.
6. La bannière révèle le logiciel et sa version exacte → chercher immédiatement les CVE connues de cette version. Côté défense : cacher la version (nginx server_tokens off, Apache ServerTokens Prod) et patcher.
7. L'authentification obligatoire dès la création (MONGO_INITDB_ROOT_USERNAME/_PASSWORD) et la base jamais exposée hors de son réseau (bind interne, segmentation, iptables). Une base « ouverte » = fuite de données, sans aucune faille exploitée.
8. En ligne, chaque essai traverse le réseau et un service qui peut freiner (délais, verrouillage, fail2ban) → quelques essais/s. Hors ligne (hash volé), des milliards d'essais/s. D'où : en ligne → fail2ban et rate-limiting ; hors ligne → seule la longueur du secret protège.
Tu avais trouvé ?
Connecte-toi pour lire tout le TP
C'est gratuit, avec ton compte Google : un clic, et tu reviens ici. Ta progression te suit ensuite sur tous tes appareils.
Le site garde ton nom et ton email, rien d'autre. Tes données