Séance 1 sur 29 livrables
Le ver en Rust (1) Rust & premier scan
Pour comprendre un malware, on en construira un — dans un labo isolé, légalement. Mais séance 1, c'est d'abord une vraie initiation à la programmation et à l'algorithmique : on apprend à coder depuis zéro — variables, conditions, boucles, fonctions — en Rust, avec pour fil un scanner de ports, la brique de base de tout ver réseau, codé ligne par ligne.
Par Josselyn C., prof de BTS SIO. Publié le .
- Objectif
- t'initier à la programmation et à l'algorithmique avec Rust (variables, conditions, boucles, fonctions), comprendre IP/ports/TCP, et coder ton premier scanner de ports
- On manipule
- le terminal, Rust (cargo), un scanner exécuté sur ta propre machine
- Durée
- ~3 h 30 · Pré-requis : savoir ouvrir un terminal. Aucun prérequis en programmation.
DEGENAGENCY — Offensive Security Lab. De zéro absolu à un scanner fonctionnel.
Avant de commencer
Pourquoi coder un (bout de) ver ?
Un ver (worm) est un malware qui se propage tout seul de machine en machine. Sa toute première étape : trouver des cibles en scannant le réseau. En construisant cette brique toi-même, tu comprends de l'intérieur comment ça marche — et donc comment le détecter et le bloquer.
Ce que tu sauras faire à la fin
| Étape | Tu sauras… |
|---|---|
| Chapitre 0 — Installer Rust | ouvrir un terminal, installer Rust, écrire et lancer un programme |
| Chapitre 1 — Penser en algorithmes (sans code) | ce qu'est un algorithme, les 3 structures (séquence, décision, répétition), la variable, écrire et dérouler un pseudo-code |
| Chapitre 2 — Les bases de Rust | les 4 briques en vrai code : variables/types, conditions, boucles, fonctions — + vecteurs et gestion d'erreurs |
| Chapitre 3 — Le réseau | comprendre IP, ports, TCP et ce que veut dire « scanner » |
| Chapitre 4 — Premier scan | coder un scanner de ports complet et le lancer pour de vrai |
| Chapitre 5 — Côté défenseur | voir ton propre scan dans les logs et comprendre comment on le bloque |
0. Installer Rust
Objectif : ouvrir un terminal, comprendre ce qu'est un compilateur, installer Rust, créer et lancer ton premier programme. Durée : ~30 min.
0.1 — C'est quoi le « terminal » ?
Le terminal (aussi appelé « console » ou « invite de commandes ») est une fenêtre où tu tapes des commandes textuelles pour parler à ton ordinateur. Pas de souris, pas de boutons : juste du texte.
Analogie : avec l'interface graphique (Finder, Bureau), tu montres ce que tu veux à l'ordinateur. Avec le terminal, tu lui écris ce que tu veux. C'est plus précis et plus puissant.
Comment ouvrir le terminal
| Système | Comment faire |
|---|---|
| macOS | Appuie sur Cmd + Espace, tape « Terminal », Entrée |
| Linux (Ubuntu) | Appuie sur Ctrl + Alt + T |
| Windows | Menu Démarrer → tape « PowerShell » → clique dessus |
Tu vois une fenêtre avec un curseur qui clignote, du genre :
utilisateur@machine:~$
Tes premières commandes
Tape chaque commande puis Entrée. On se familiarise.
pwd
/home/utilisateur
ls
Bureau Documents Images Téléchargements
mkdir mes-projets
cd mes-projets
0.2 — C'est quoi un langage de programmation ?
Un ordinateur ne comprend qu'une chose : des 0 et des 1 (le « binaire »). C'est le seul langage que le processeur parle.
Écrire directement en binaire est impossible pour un humain. Un langage de programmation est un intermédiaire : tu écris dans un langage lisible, puis un outil le transforme en binaire.
Ce que TU écris :
println!("Bonjour"); ← lisible par un humain
Ce que le COMPILATEUR produit :
01001000 01101001 ... ← lisible par le processeur
Ce que le PROCESSEUR fait :
→ affiche "Bonjour" à l'écran
C'est quoi un compilateur ?
Le compilateur est le traducteur. Il lit ton code (texte lisible) et le transforme en un fichier exécutable (binaire).
Analogie : tu écris une lettre en français, mais ton ami ne parle que japonais. Le compilateur est le traducteur. Et s'il y a des fautes de grammaire dans ta lettre, le traducteur refuse de traduire et te dit exactement où sont les erreurs.
0.3 — Installer Rust
On installe Rust avec rustup (l'installeur officiel). Dans ton terminal, tape cette commande en entier puis Entrée :
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Le script demande quoi faire. Tu verras :
1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation
Tape 1 puis Entrée (ou juste Entrée). L'installation prend 1-2 minutes. À la fin :
Rust is installed now. Great!
Activer Rust dans le terminal
source $HOME/.cargo/env
Vérifier l'installation
rustc --version
cargo --version
rustc 1.78.0 (9b00956e5 2024-04-29)
cargo 1.78.0 (54d8815d0 2024-03-26)
Si tu vois deux numéros de version, Rust est prêt. (Ta version peut être plus récente, c'est normal.)
Flag B1
Production
Installe Rust et vérifie-le.
Rends : une capture de la sortie de rustc --version et cargo --version sur ta machine.
Chapitre 0 (suite) — Ton premier programme
0.4 — Créer ton premier projet
cargo new scanner
Creating binary (application) `scanner` package
Regardons ce que Cargo a créé :
ls scanner/
Cargo.toml src
ls scanner/src/
main.rs
Cargo a créé 2 choses :
| Fichier | Rôle | Analogie |
|---|---|---|
Cargo.toml | la carte d'identité du projet (nom, version, dépendances) | la couverture d'un livre |
src/main.rs | ton code source | les pages du livre |
Ouvre Cargo.toml : c'est un petit fichier de configuration. Tu y verras :
[package]
name = "scanner"
version = "0.1.0"
edition = "2021"
[dependencies]
Entre dans le projet :
cd scanner
0.5 — Ton premier code : Hello World
Ouvre src/main.rs dans un éditeur de texte. Tu peux utiliser :
• VS Code (recommandé) : code src/main.rs
• nano (dans le terminal) : nano src/main.rs
• n'importe quel éditeur de texte.
Cargo y a déjà écrit un « Hello, world » :
fn main() {
println!("Hello, world!");
}
Ce programme fait UNE chose : afficher « Hello, world! ». Décortiquons chaque élément.
0.6 — Lancer le programme
cargo run
Compiling scanner v0.1.0 (/home/utilisateur/mes-projets/scanner)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/scanner`
Hello, world!
Maintenant, modifie le message. Remplace la ligne println! par :
fn main() {
println!("Bienvenue dans le lab GSB !");
}
Sauvegarde, relance cargo run :
Bienvenue dans le lab GSB !
Flag B2
Production
Modifie le message pour afficher ton prénom et le mot « scanner ». Lance-le.
Rends : ton code (les 3 lignes) et la sortie obtenue.
0.7 — Quand le compilateur se plaint
Cassons le code exprès pour voir ce qui se passe. Enlève le ! après println :
fn main() {
println("Hello");
}
Lance cargo run. Le compilateur refuse :
error[E0423]: expected function, found macro `println`
--> src/main.rs:2:5
|
2 | println("Hello");
| ^^^^^^^ not a function
help: use `!` to invoke the macro
|
2 | println!("Hello");
Flag C1
Debug
Ce programme ne compile pas. Copie-le, lance cargo run, lis l'erreur, corrige-la :
fn main() {
let a: u16 = 22;
let b: u16 = 80;
let somme = a + b
println!("FLAG-C1 = {}", somme * 2);
}
Rends : ce qui n'allait pas, et la valeur FLAG-C1 affichée une fois corrigé.
1. Penser en algorithmes (sans code)
Objectif : apprendre à raisonner comme un programmeur — sans écrire une seule ligne de Rust. Durée : ~1 h.
1.1 — C'est quoi un algorithme ?
Un algorithme, c'est une suite d'étapes précises, dans l'ordre, qui résout un problème. Tu en suis déjà des dizaines par jour sans y penser :
| Dans la vie | C'est un algorithme parce que… |
|---|---|
| Une recette de cuisine | des étapes ordonnées → un gâteau |
| Un itinéraire GPS | « tourne à droite, puis tout droit 200 m… » → tu arrives |
| La notice d'un meuble | visse A sur B, puis C… → une étagère |
| Faire un virement bancaire | une suite d'étapes → l'argent part |
Un bon algorithme a 4 qualités : précis (aucune étape floue), ordonné (l'ordre compte), non ambigu (une seule interprétation possible) et fini (il se termine un jour).
Un premier algorithme, en français
Problème : traverser une rue en sécurité. Un humain dirait « regarde et traverse ». Trop flou pour une machine. Décomposons :
1. Aller au bord du trottoir
2. Regarder à gauche
3. Regarder à droite
4. SI une voiture arrive ALORS attendre, puis recommencer à l'étape 2
5. SINON traverser
Remarque déjà deux choses : il y a une décision (étape 4, le « SI ») et un retour en arrière (« recommencer à l'étape 2 ») — une répétition. Ce sont exactement les briques qu'on voit maintenant.
Chapitre 1 (suite) — Les 3 structures + la variable
Toute l'informatique du monde — un jeu vidéo, ta banque en ligne, un ver — est construite avec seulement 3 structures et des variables. Rien d'autre. On les prend une par une.
1.2 — La séquence : des étapes dans l'ordre
La plus simple : on fait les étapes l'une après l'autre, de haut en bas.
verser le café dans la tasse
ajouter le sucre
touiller
L'ordre compte : « touiller » avant « ajouter le sucre » ne sert à rien. En algorithmique, l'ordre des lignes, c'est le déroulé du temps.
1.3 — La condition : décider (SI… ALORS… SINON)
Souvent, la suite dépend d'une situation. On teste quelque chose, et on part dans une branche ou dans l'autre.
SI il pleut
ALORS prendre un parapluie
SINON prendre des lunettes de soleil
FINSI
Pour notre scanner, la décision-clé sera : « SI le port répond → il est ouvert, SINON il est fermé. »
1.4 — La répétition : recommencer (POUR / TANT QUE)
Quand on doit refaire la même chose plusieurs fois, on ne réécrit pas tout : on boucle. Deux formes utiles :
POUR chaque numéro DE 1 À 1000
tester le port « numéro »
FIN POUR
TANT QUE le bol n'est pas plein
ajouter une cuillère de farine
FIN TANT QUE
1.5 — La variable : la mémoire de l'algorithme
Un algorithme a besoin de retenir des choses au fil des étapes : un score, un compteur, une adresse. Pour ça, la variable : une boîte étiquetée où l'on range une valeur et qu'on retrouve par son nom.
score ← 0 (crée la boîte "score", met 0 dedans)
score ← score + 1 (nouvelle valeur : l'ancienne + 1, donc 1)
score ← score + 1 (encore : 2)
Chapitre 1 (suite) — Écrire et dérouler un pseudo-code
1.6 — Le pseudo-code : l'algo écrit proprement
Le pseudo-code, c'est un algorithme écrit en français structuré, avec quelques mots-clés, avant de le traduire dans un vrai langage. Ça te laisse réfléchir sans te battre avec la syntaxe. Exemple complet :
DÉBUT
age ← 20
SI age ≥ 18
ALORS afficher "majeur"
SINON afficher "mineur"
FINSI
FIN
Les conventions qu'on utilisera : DÉBUT/FIN, ← (affecter), SI/ALORS/SINON/FINSI, POUR … FIN POUR, TANT QUE … FIN TANT QUE, afficher. Pas besoin que ce soit parfait : le but est d'être clair et sans ambiguïté.
1.7 — Dérouler à la main : la table de trace
La compétence n°1 du débutant : jouer l'ordinateur dans sa tête, ligne par ligne, pour vérifier qu'un algo fait bien ce qu'on croit. L'outil pour ça : la table de trace. On note, à chaque étape, la valeur de chaque variable et ce qui s'affiche. Déroulons cet algo :
DÉBUT
compteur ← 1
TANT QUE compteur ≤ 3
afficher compteur
compteur ← compteur + 1
FIN TANT QUE
FIN
La table de trace, tour par tour :
| Étape | compteur | compteur ≤ 3 ? | Affiche |
|---|---|---|---|
| départ | 1 | — | — |
| tour 1 | 1 → 2 | vrai | 1 |
| tour 2 | 2 → 3 | vrai | 2 |
| tour 3 | 3 → 4 | vrai | 3 |
| tour 4 | 4 | faux → on sort | — |
Résultat affiché : 1 2 3. Note le détail qui piège tout le monde : au tour 3 on affiche 3 puis compteur passe à 4 ; c'est au tour suivant que le test devient faux. Dérouler à la main, c'est voir ces détails avant que la machine ne te les montre sous forme de bug.
Chapitre 1 (suite) — Entraîne-toi, puis cap sur Rust
Trois exercices, uniquement sur papier, en pseudo-code. Essaie d'abord, puis lis le corrigé juste en dessous. Il n'y a pas une seule bonne écriture : si ton déroulé donne le bon résultat, c'est juste.
Corrigé :
DÉBUT
age ← 20
SI age ≥ 18 ALORS afficher "majeur"
SINON afficher "mineur"
FINSI
FIN
Corrigé (deux écritures possibles, les deux justes) :
POUR n DE 1 À 10
afficher n
FIN POUR
ou, avec une boucle TANT QUE et un compteur :
n ← 1
TANT QUE n ≤ 10
afficher n
n ← n + 1
FIN TANT QUE
Corrigé :
SI a ≥ b ALORS afficher a
SINON afficher b
FINSI
1.8 — Du pseudo-code au Rust : la table de traduction
Bonne nouvelle : tu viens de faire le plus dur (penser). Traduire en Rust, c'est surtout changer les mots. Voici la correspondance qu'on utilisera dès le chapitre 2 :
| En pseudo-code (l'idée) | En Rust (le code) |
|---|---|
age ← 20 | let age = 20; |
SI … ALORS … SINON … | if … { … } else { … } |
POUR n DE 1 À 10 | for n in 1..=10 { … } |
TANT QUE … | while … { … } |
afficher x | println!("{}", x); |
Au chapitre 2, chaque brique que tu viens de penser devient du vrai code — et tu la lanceras pour de vrai sur ta machine.
Flag B7
Production (conception)
Avant d'écrire la moindre ligne de Rust, conçois ton scanner en pseudo-code. Il doit : tester les ports de 1 à 1000 sur une cible ; pour chaque port, décider s'il est ouvert ou fermé ; afficher les ports ouverts. Sers-toi d'une variable, d'une boucle POUR et d'une condition SI.
Rends : ton pseudo-code (papier ou tapé). Pas de Rust ici — on veut voir ton algorithme.
2. Les bases de Rust
Objectif : maîtriser les briques du langage, une par une. Durée : ~1 h 15.
Règle d'or : pour chaque concept, on écrit le code, on le lance, on observe le résultat, puis on explique. Teste chaque exemple dans src/main.rs avec cargo run — ne te contente pas de lire.
2.1 — Les variables : stocker une valeur
Une variable, c'est une boîte étiquetée. Tu mets une valeur dedans, et plus tard tu la récupères par son nom.
fn main() {
let cible = "127.0.0.1";
println!("La cible est : {}", cible);
}
La cible est : 127.0.0.1
Les variables sont immuables par défaut
En Rust, une fois qu'une variable a une valeur, on ne peut plus la changer. Essaie :
fn main() {
let cible = "127.0.0.1";
cible = "10.0.0.4";
println!("{}", cible);
}
error[E0384]: cannot assign twice to immutable variable `cible`
Rendre une variable modifiable avec mut
Si tu VEUX pouvoir changer la valeur, ajoute mut (mutable = modifiable) :
fn main() {
let mut compteur = 0;
println!("Avant : {}", compteur);
compteur = compteur + 1;
println!("Après : {}", compteur);
}
Avant : 0
Après : 1
Les opérations
fn main() {
let mut x = 10;
x = x + 5; // addition
x = x * 2; // multiplication
println!("x = {}", x);
}
x = 30
2.2 — Les types : chaque boîte a une forme
En Rust, chaque variable a un type qui détermine quel genre de données elle contient. Un carré ne rentre pas dans un trou rond.
fn main() {
let port: u16 = 22;
let is_open: bool = true;
let temperature: i32 = -5;
println!("port={}, open={}, temp={}", port, is_open, temperature);
}
port=22, open=true, temp=-5
Les types de nombres les plus courants :
| Type | Signification | Plage | Usage typique |
|---|---|---|---|
u8 | unsigned 8 bits | 0 à 255 | octets (données brutes) |
u16 | unsigned 16 bits | 0 à 65535 | numéros de port |
u32 | unsigned 32 bits | 0 à ~4,3 milliards | compteurs, identifiants |
i32 | signed 32 bits | −2,1 G à +2,1 G | nombres généraux (défaut) |
bool | booléen | true / false | vrai / faux |
Le texte : &str vs String
Il y a DEUX types de texte en Rust. C'est déroutant au début, on démystifie :
fn main() {
let ip = "10.0.0.3"; // type &str : texte FIXE
let nom = String::from("worm"); // type String : texte MODIFIABLE
println!("IP : {} — Nom : {}", ip, nom);
}
Construire du texte avec format!
On aura souvent besoin de construire une adresse comme "127.0.0.1:22" à partir de morceaux. C'est le rôle de format! :
fn main() {
let ip = "127.0.0.1";
let port = 22;
let adresse = format!("{}:{}", ip, port);
println!("Adresse : {}", adresse);
}
Adresse : 127.0.0.1:22
Flag B3
Production
Crée deux variables ip (un &str de ton choix) et port (un u16). Avec format!, construis une variable cible de la forme ip:port, et affiche-la.
Rends : ton code et la sortie.
Chapitre 2 (suite) — Conditions & boucles
2.3 — Les conditions : if / else
On a constamment besoin de prendre des décisions : « SI le port est ouvert, ALORS afficher un message, SINON passer au suivant ».
fn main() {
let port = 80;
if port == 22 {
println!("SSH");
} else if port == 80 {
println!("HTTP (web)");
} else if port == 443 {
println!("HTTPS (web sécurisé)");
} else {
println!("Service inconnu sur le port {}", port);
}
}
HTTP (web)
Les opérateurs de comparaison :
| Opérateur | Signification | Exemple vrai |
|---|---|---|
== | égal à | 5 == 5 |
!= | différent de | 5 != 3 |
< | plus petit que | 3 < 5 |
> | plus grand que | 5 > 3 |
<= | plus petit ou égal | 5 <= 5 |
>= | plus grand ou égal | 5 >= 5 |
Combiner des conditions avec && et ||
fn main() {
let port = 22;
let is_open = true;
if port == 22 && is_open {
println!("SSH ouvert — cible intéressante !");
}
}
SSH ouvert — cible intéressante !
2.4 — Les boucles : répéter des actions
Un scanner doit tester des centaines de ports. On ne va pas écrire 100 if. On utilise des boucles.
La boucle for sur une liste
fn main() {
let ports = [22, 80, 443, 8080];
for port in ports {
println!("Test du port {}", port);
}
}
Test du port 22
Test du port 80
Test du port 443
Test du port 8080
La boucle for sur un intervalle de nombres
fn main() {
for port in 1..5 {
println!("port {}", port);
}
}
port 1
port 2
port 3
port 4
Une boucle dans une boucle
fn main() {
let ports = [22, 80];
for host in 3..=5 {
for port in ports {
println!("10.0.0.{}:{}", host, port);
}
}
}
10.0.0.3:22
10.0.0.3:80
10.0.0.4:22
10.0.0.4:80
10.0.0.5:22
10.0.0.5:80
La boucle while : le TANT QUE de Rust
Le for couvre « je sais combien de fois ». Quand tu veux « répéter tant qu'une condition reste vraie » (le TANT QUE du chapitre 1), Rust a while :
fn main() {
let mut compteur = 1;
while compteur <= 3 {
println!("{}", compteur);
compteur = compteur + 1;
}
}
1
2
3
C'est mot pour mot la table de trace que tu as déroulée à la main au chapitre 1 — sauf que cette fois, c'est la machine qui la déroule.
Flag B4
Production
Écris une boucle qui affiche les adresses 10.0.0.1 à 10.0.0.254, une par ligne, sous la forme Scan de 10.0.0.X ....
Rends : ton code et les 3 premières + 3 dernières lignes de la sortie. Combien de lignes au total ?
Chapitre 2 (suite) — Fonctions, vecteurs, erreurs
2.5 — Les fonctions : découper le code en morceaux
Quand un programme grandit, tout mettre dans main devient un chaos. Les fonctions découpent le code en morceaux réutilisables.
Analogie : une fonction est une recette. Elle a un nom (« crêpes »), des ingrédients (paramètres) et produit quelque chose (une pile de crêpes). Tu peux l'utiliser autant de fois que tu veux.
Une fonction avec paramètres
fn afficher_cible(ip: &str, port: u16) {
println!("Cible : {}:{}", ip, port);
}
fn main() {
afficher_cible("10.0.0.3", 22);
afficher_cible("10.0.0.4", 80);
}
Cible : 10.0.0.3:22
Cible : 10.0.0.4:80
Une fonction qui RETOURNE une valeur
fn build_address(ip: &str, port: u16) -> String {
format!("{}:{}", ip, port)
}
fn main() {
let addr = build_address("10.0.0.3", 22);
println!("Adresse construite : {}", addr);
}
Adresse construite : 10.0.0.3:22
Une fonction qui retourne un booléen
fn est_connu(port: u16) -> bool {
port == 22 || port == 80 || port == 443
}
fn main() {
println!("22 → {}", est_connu(22));
println!("8080 → {}", est_connu(8080));
}
22 → true
8080 → false
Flag B5
Production
Écris une fonction est_web(port: u16) -> bool qui retourne true pour les ports 80 ou 443, et false sinon. Teste-la dans main avec deux ports différents.
Rends : ton code et la sortie.
2.6 — Les vecteurs : des listes qui grandissent
Un tableau [22, 80, 443] a une taille fixe. Mais quand on scanne, on ne sait pas à l'avance combien de ports ouverts on va trouver. On a besoin d'une liste qui peut grandir : un vecteur.
fn main() {
let mut ports_ouverts: Vec<u16> = Vec::new();
ports_ouverts.push(22);
ports_ouverts.push(80);
println!("Ports : {:?}", ports_ouverts);
println!("Combien : {}", ports_ouverts.len());
}
Ports : [22, 80]
Combien : 2
Parcourir un vecteur
fn main() {
let ports_ouverts = vec![22, 80, 443];
for port in &ports_ouverts {
println!("Port {} est ouvert", port);
}
}
Port 22 est ouvert
Port 80 est ouvert
Port 443 est ouvert
2.7 — Gérer les erreurs : quand ça peut rater
Quand on fait du réseau, tout peut échouer : la connexion expire, le serveur refuse, le fichier n'existe pas. Rust te force à penser à ces cas — c'est sa grande force pour la sécurité.
Le type Result
Beaucoup de fonctions retournent un Result. C'est comme un colis : soit il contient ce que tu as commandé (Ok), soit un message d'erreur (Err).
use std::fs;
fn main() {
let resultat = fs::read_to_string("fichier_inexistant.txt");
match resultat {
Ok(contenu) => println!("Contenu : {}", contenu),
Err(erreur) => println!("Erreur : {}", erreur),
}
}
Erreur : No such file or directory (os error 2)
Le raccourci .is_ok()
Souvent, on ne veut pas le détail de l'erreur : juste savoir si ça a marché ou pas. .is_ok() retourne un booléen :
fn main() {
let resultat = std::fs::read_to_string("fichier_inexistant.txt");
if resultat.is_ok() {
println!("Lecture réussie");
} else {
println!("Lecture échouée");
}
}
Lecture échouée
3. Le réseau pour les nuls
Objectif : comprendre les 3 concepts réseau nécessaires au scanner. Durée : ~25 min (lecture, pas de code).
3.1 — L'adresse IP : l'adresse postale d'une machine
Chaque appareil connecté à un réseau a un numéro unique : son adresse IP (Internet Protocol).
| Monde réel | Réseau |
|---|---|
| Adresse postale (12 rue des Lilas) | Adresse IP (10.0.0.3) |
| La Poste achemine la lettre | Internet achemine le paquet de données |
| Chaque maison a une adresse unique | Chaque machine a une IP unique |
Une adresse IPv4 est composée de 4 nombres séparés par des points. Chaque nombre va de 0 à 255 :
10 . 0 . 0 . 3
└┬┘ └┬┘ └┬┘ └┬┘
partie réseau └─ numéro de la machine sur le réseau local
Les adresses spéciales à connaître
| Adresse | Nom | Signification |
|---|---|---|
127.0.0.1 | localhost | ta propre machine — se parler à soi-même |
10.0.0.X | réseau privé | réseau local (pas accessible depuis Internet) |
192.168.X.X | réseau privé | ton réseau Wi-Fi à la maison, typiquement |
0.0.0.0 | toutes les interfaces | « écoute sur tout » |
IPv4 vs IPv6 — le changement de génération
Ce TP utilise IPv4 (4 octets → ~4,3 milliards d'adresses). Le problème : les adresses IPv4 publiques sont épuisées depuis 2019. IPv6 prend le relais.
| Caractéristique | IPv4 | IPv6 |
|---|---|---|
| Format | 10.0.0.3 (4 × 8 bits) | 2001:db8::1 (8 × 16 bits) |
| Nombre d'adresses | ~4,3 milliards (2³²) | 340 sextillions (2¹²⁸) |
| Adresse loopback | 127.0.0.1 | ::1 |
| Réseau privé | 192.168.x.x, 10.x.x.x, 172.16-31.x.x (RFC 1918) | fd00::/8 (ULA) |
| Usage aujourd'hui | encore dominant en entreprise et lab | requis sur Internet public |
La notation CIDR — lire une plage réseau d'un coup
Un scanner travaille souvent sur une plage d'adresses, pas une seule. La notation CIDR (Classless Inter-Domain Routing) l'exprime en une ligne :
10.0.0.0/24 → adresses 10.0.0.0 à 10.0.0.255 (256 adresses, 254 machines)
10.0.0.0/16 → adresses 10.0.0.0 à 10.0.255.255 (65 536 adresses)
192.168.1.0/24 → ton réseau Wi-Fi classique à la maison
3.2 — Les ports : les portes d'un immeuble
Une IP identifie une machine. Mais une machine fait tourner plusieurs programmes en même temps (serveur web, serveur SSH, base de données…). Comment savoir à QUEL programme envoyer les données ? C'est le rôle du port.
L'IMMEUBLE (= la machine, IP : 10.0.0.3)
┌──────────────────────────────────────┐
│ Porte 22 → SSH (terminal distant)│
│ Porte 80 → HTTP (site web) │
│ Porte 443 → HTTPS (site sécurisé) │
│ Porte 3306 → MySQL (base de données) │
│ │
│ Portes 1-1023 : réservées (système)│
│ Portes 1024-65535: libres (utilisateur)│
└──────────────────────────────────────┘
L'adresse complète d'un service est donc IP:PORT :
10.0.0.3:22 → SSH sur la machine 10.0.0.3
10.0.0.3:80 → le site web sur la machine 10.0.0.3
10.0.0.4:22 → SSH sur une AUTRE machine
Ports courants à connaître — tableau pro
| Port | Service | Ce que ça fait | Risque défensif si exposé sur Internet |
|---|---|---|---|
| 21 | FTP | transfert de fichiers — non chiffré | identifiants en clair interceptables (MITM) ; remplacé par SFTP (port 22) ou FTPS (port 990) |
| 22 | SSH | terminal distant chiffré | brute-force automatisé massif (millions de tentatives/jour sur un serveur exposé) ; mitiger : Fail2ban + clé RSA 4096 bits ou Ed25519 au lieu du mot de passe |
| 23 | Telnet | terminal distant — non chiffré (obsolète) | tout passe en clair (login, commandes) ; présence = Security Misconfiguration (OWASP A05) ; ne jamais exposer |
| 25 | SMTP | envoi d'emails (serveur à serveur) | open relay = spam + réputation IP brûlée ; exige SPF, DKIM, DMARC |
| 53 | DNS | résolution de noms (texte → IP) — UDP+TCP | DNS amplification DDoS ; cache poisoning ; filtrer requêtes récursives externes |
| 80 | HTTP | site web non chiffré | trafic lisible en clair ; rediriger systématiquement vers HTTPS (443) |
| 443 | HTTPS | site web chiffré (TLS 1.2 / 1.3) | certificat expiré = alerte navigateur ; TLS 1.0 et SSLv3 = vulnérables (POODLE, BEAST) |
| 445 | SMB | partage de fichiers Windows | exploité par WannaCry (2017) ; ne jamais exposer sur Internet |
| 3306 | MySQL | base de données relationnelle | base exposée directement = données personnelles à risque (RGPD) ; accès local ou VPN uniquement |
| 5432 | PostgreSQL | base de données relationnelle | même règle que MySQL ; contrôle fin des accès via pg_hba.conf |
| 6379 | Redis | cache / sessions (clé-valeur) | sans authentification exposé = lecture et écriture libres ; CVE critiques fréquentes ; lier à 127.0.0.1 obligatoire |
| 8080 | HTTP alternatif | serveurs de dev, proxies, panneaux d'admin | souvent moins sécurisé que le port 80 principal ; cible courante des scanners automatisés |
| 27017 | MongoDB | base NoSQL (documents JSON) | instances exposées sans authentification rançonnées en masse (2017) ; lier à 127.0.0.1 + activer l'auth |
Les trois catégories IANA — ce que veut dire « port réservé »
L'IANA (Internet Assigned Numbers Authority) gère la liste officielle des ports. Elle les divise en trois catégories :
| Plage | Nom IANA | Règle Linux/macOS | Exemples |
|---|---|---|---|
| 0 – 1 023 | Well-known ports (ports système) | root requis pour ouvrir (écouter) | 22 SSH, 80 HTTP, 443 HTTPS, 25 SMTP |
| 1 024 – 49 151 | Registered ports | tout utilisateur peut écouter | 3306 MySQL, 5432 PostgreSQL, 8080 HTTP-alt |
| 49 152 – 65 535 | Dynamic / Ephemeral ports | utilisés automatiquement par le système comme port source des connexions sortantes | ta machine en choisit un au hasard dans cette plage quand elle se connecte à un serveur |
Chapitre 3 (suite) — TCP & « scanner »
3.3 — TCP : comment les machines se parlent
TCP (Transmission Control Protocol) est le protocole de communication le plus utilisé. Il garantit que les données arrivent correctement et dans l'ordre.
Analogie : TCP, c'est comme un appel téléphonique. 1. tu composes le numéro (demande de connexion) ; 2. ça sonne chez l'autre ; 3. l'autre décroche (connexion établie) ; 4. vous parlez (échange de données) ; 5. vous raccrochez (fermeture).
Le « three-way handshake » (poignée de main en 3 étapes)
Avant d'échanger des données, TCP fait une poignée de main :
TA MACHINE LE SERVEUR
(10.0.0.2) (10.0.0.3:22)
| |
1. |------------ SYN ------------->| "Salut ! Je veux te parler"
| |
2. |<--------- SYN-ACK -------------| "OK, je suis prêt"
| |
3. |------------ ACK ------------->| "Parfait, c'est parti !"
| |
|======= CONNEXION ÉTABLIE ======|
Et si le port est FERMÉ, ou la machine absente ?
Flag A1
Checkpoint
Avec tes mots (2-3 phrases) :
• Quelle est la différence entre une adresse IP et un port ?
• Que veut dire concrètement « le port 22 est ouvert sur 10.0.0.3 » ?
Rends : ta réponse rédigée.
3.4 — TCP vs UDP : ce que ton scanner ne voit pas
Notre scanner utilise uniquement TCP. Beaucoup de services critiques utilisent UDP (User Datagram Protocol). Comprendre la différence est essentiel pour un défenseur — et pour interpréter correctement les résultats d'un scan.
| Critère | TCP | UDP |
|---|---|---|
| Connexion | three-way handshake (SYN → SYN-ACK → ACK) | aucune — envoi direct du datagramme |
| Fiabilité | garantie (accusé de réception, retransmission) | aucune (fire-and-forget) |
| Détection port ouvert | SYN-ACK = ouvert ; RST = fermé ; silence = filtré | réponse UDP = ouvert ; silence = ouvert OU filtré (ambigu !) |
| Services typiques | SSH (22), HTTP (80), HTTPS (443), MySQL (3306)… | DNS (53), NTP (123), SNMP (161), DHCP (67/68) |
| Scan nmap | nmap -sS (SYN stealth, root requis) ou -sT | nmap -sU (root requis, 5-10× plus lent) |
| Faux négatifs | très rares | courants : paquet perdu → port semble fermé alors qu'il est ouvert |
4. Ton premier scanner de port
Objectif : écrire un programme qui détecte quels ports sont ouverts sur ta propre machine. Durée : ~1 h.
4.1 — Préparer une cible
Pour avoir un port ouvert à trouver, on lance un mini serveur web. Ouvre un DEUXIÈME terminal (garde le premier pour ton code Rust) et tape :
python3 -m http.server 8888
Serving HTTP on 0.0.0.0 port 8888 (http://0.0.0.0:8888/) ...
Ta machine a maintenant le port 8888 ouvert. Ton scanner devra le trouver.
4.2 — La stratégie
Notre plan est simple. Pour chaque port à tester : 1. tenter une connexion TCP (le handshake) ; 2. si elle réussit → port ouvert ; 3. si elle échoue → port fermé.
4.3 — Importer l'outil réseau
Retourne dans ton premier terminal (le projet Rust). Ouvre src/main.rs et commence par :
use std::net::TcpStream;
4.4 — Tester UN seul port
Avant d'écrire une fonction, testons juste si le port 8888 est ouvert :
use std::net::TcpStream;
fn main() {
let result = TcpStream::connect("127.0.0.1:8888");
match result {
Ok(_) => println!("Port 8888 : OUVERT"),
Err(_) => println!("Port 8888 : fermé"),
}
}
Lance :
cargo run
Port 8888 : OUVERT
Maintenant teste un port que tu sais fermé (par ex. 9999, sur lequel rien ne tourne). Remplace 8888 par 9999 dans le code et relance :
Port 9999 : fermé
Chapitre 4 (suite) — Timeout & fonction
4.5 — Ajouter un timeout
Le problème avec TcpStream::connect : si la machine ne répond pas (cas « silence/timeout » du chapitre 3), le programme peut attendre très longtemps. On veut abandonner après 1 seconde. On utilise connect_timeout :
use std::net::{TcpStream, SocketAddr};
use std::time::Duration;
fn main() {
let timeout = Duration::from_secs(1);
let addr: SocketAddr = "127.0.0.1:8888".parse().unwrap();
match TcpStream::connect_timeout(&addr, timeout) {
Ok(_) => println!("Port 8888 : OUVERT"),
Err(_) => println!("Port 8888 : fermé"),
}
}
4.6 — Créer la fonction is_port_open
Transformons ça en une fonction réutilisable. On la construit pas à pas.
Étape 1 — la signature :
fn is_port_open(ip: &str, port: u16) -> bool {
Étape 2 — construire l'adresse et le timeout :
let adresse = format!("{}:{}", ip, port);
let timeout = Duration::from_secs(1);
Étape 3 — parser puis tenter la connexion :
match adresse.parse::<SocketAddr>() {
Ok(addr) => TcpStream::connect_timeout(&addr, timeout).is_ok(),
Err(_) => false,
}
}
Le code complet (assemble les 3 étapes) :
use std::net::{TcpStream, SocketAddr};
use std::time::Duration;
fn is_port_open(ip: &str, port: u16) -> bool {
let adresse = format!("{}:{}", ip, port);
let timeout = Duration::from_secs(1);
match adresse.parse::<SocketAddr>() {
Ok(addr) => TcpStream::connect_timeout(&addr, timeout).is_ok(),
Err(_) => false,
}
}
fn main() {
if is_port_open("127.0.0.1", 8888) {
println!("Port 8888 : OUVERT");
} else {
println!("Port 8888 : fermé");
}
}
cargo run
Port 8888 : OUVERT
Chapitre 4 (suite) — Scanner une plage
4.7 — Scanner une liste de ports
Un seul port, c'est peu. On combine notre fonction avec une boucle et un vecteur — la vraie utilité d'un scanner. Garde la fonction is_port_open du dessus, et remplace seulement main :
fn main() {
let ip = "127.0.0.1";
let ports = [22, 80, 443, 3306, 8080, 8888, 9999];
let mut ouverts: Vec<u16> = Vec::new();
println!("=== Scan de {} ===", ip);
for port in ports {
if is_port_open(ip, port) {
println!("Port {} : OUVERT", port);
ouverts.push(port);
}
}
println!("Terminé : {} ports ouverts → {:?}", ouverts.len(), ouverts);
}
=== Scan de 127.0.0.1 ===
Port 8888 : OUVERT
Terminé : 1 ports ouverts → [8888]
4.8 — Scanner un intervalle complet
Au lieu d'une liste fixe, scannons tous les ports connus (1 à 1024) avec un intervalle :
fn main() {
let ip = "127.0.0.1";
println!("Scan des ports 1-1024 sur {} ...", ip);
let mut total = 0;
for port in 1u16..=1024 {
if is_port_open(ip, port) {
println!("Port {} : OUVERT", port);
total = total + 1;
}
}
println!("Scan terminé : {} ports ouverts.", total);
}
Exemple de sortie possible (lis bien l'encadré : chez toi, ce sera sûrement autre chose) :
Scan des ports 1-1024 sur 127.0.0.1 ...
Port 631 : OUVERT
Scan terminé : 1 ports ouverts.
Flag B6
Mini-projet (production)
Améliore ton scanner : écris une fonction nom_service(port: u16) -> &'static str qui retourne le nom du service pour les ports connus (22→SSH, 80→HTTP, 443→HTTPS, 3306→MySQL, sinon « inconnu »). Affiche, pour chaque port ouvert, son numéro ET son service.
Indice : réutilise le schéma if / else if du chapitre 2 ; pour le type de retour, inspire-toi de la signature donnée.
Rends : ton code complet et la liste des ports ouverts avec leur service.
5. Ton scan vu du côté défenseur
Objectif : comprendre comment notre scanner est perçu par la machine cible, et ce qu'un administrateur met en place pour s'en protéger. Durée : ~25 min (lecture + analyse — pas de code).
5.1 — Ce que le serveur cible voit dans ses logs
À chaque tentative de connexion, le système d'exploitation cible enregistre un événement. Sur Linux Ubuntu avec UFW actif, un administrateur peut surveiller en temps réel :
sudo tail -f /var/log/ufw.log
Pendant qu'un scanner tourne sur le réseau local, les logs affichent quelque chose comme :
[UFW BLOCK] IN=eth0 SRC=10.0.0.2 DST=10.0.0.3 PROTO=TCP SPT=54101 DPT=22 FLAGS=SYN
[UFW BLOCK] IN=eth0 SRC=10.0.0.2 DST=10.0.0.3 PROTO=TCP SPT=54102 DPT=80 FLAGS=SYN
[UFW BLOCK] IN=eth0 SRC=10.0.0.2 DST=10.0.0.3 PROTO=TCP SPT=54103 DPT=443 FLAGS=SYN
[UFW BLOCK] IN=eth0 SRC=10.0.0.2 DST=10.0.0.3 PROTO=TCP SPT=54104 DPT=3306 FLAGS=SYN
[UFW BLOCK] IN=eth0 SRC=10.0.0.2 DST=10.0.0.3 PROTO=TCP SPT=54105 DPT=8080 FLAGS=SYN
... (1019 lignes supplémentaires si scan 1-1024)
5.2 — Comment un IDS détecte et réagit
Un IDS (Intrusion Detection System) surveille le trafic réseau en temps réel et compare les paquets à des règles ou des comportements connus. Les outils de l'écosystème défensif :
| Outil | Rôle | Type de détection | Réponse automatique possible |
|---|---|---|---|
| UFW / iptables | pare-feu Linux | règles statiques (IP, port, protocole) | bloquer le paquet, logger |
| Fail2ban | protection brute-force | lit les logs Apache/SSH/UFW, compte les tentatives par IP | ban automatique de l'IP source (configurable : 10 min, 24 h, permanent) |
| Snort / Suricata | IDS/IPS réseau | signatures (patterns de paquets), analyse comportementale | alerte, coupure de flux (mode IPS) |
| SIEM (Splunk, ELK) | agrégation de logs | corrélation d'événements (scan simultané sur plusieurs serveurs) | alerte SecOps, ticket d'incident |
5.3 — Les contre-mesures défensives
Voici ce qu'un administrateur met en place pour réduire la surface d'attaque et rendre les scans moins informatifs :
| Contre-mesure | Ce qu'elle fait | Config type |
|---|---|---|
| Fermer tous les ports inutiles | moins de ports ouverts = moins de vecteurs d'attaque | ufw default deny incoming, puis ouvrir seulement le nécessaire |
| Rate-limiting SSH | limite les connexions par IP et par minute | ufw limit ssh — 6 tentatives / 30 s, puis ban temporaire |
| Fail2ban | ban auto de l'IP après X échecs consécutifs | maxretry = 5, bantime = 3600 (1 h) |
| VPN ou bastion | SSH n'écoute que sur le réseau interne — invisible depuis Internet | WireGuard, OpenVPN, Tailscale |
| Authentification par clé | élimine le brute-force de mots de passe | clé Ed25519 ou RSA 4096 bits ; PasswordAuthentication no dans sshd_config |
Sécurité par obscurité ≠ sécurité réelle
Changer le port SSH de 22 à 2222 n'empêche pas un scanner de le trouver : un scan complet (ports 1–65535) le découvre en quelques secondes. C'est une couche supplémentaire (defense-in-depth), pas une protection suffisante seule. La vraie sécurité repose sur : accès restreint par IP + authentification par clé + Fail2ban. L'obscurité réduit le bruit, pas le risque.
5.4 — Ce qu'on comprend en construisant l'attaque
En codant ce scanner, tu comprends exactement pourquoi chaque contre-mesure existe :
| Contre-mesure | Pourquoi elle existe — ce que tu viens de coder |
|---|---|
| Fail2ban | un scanner teste des centaines de ports ; un brute-force SSH suivrait le même pattern sur le port 22 |
| Rate-limiting | notre boucle for port in 1u16..=1024 enverrait 1024 SYN en quelques secondes sans aucune limite |
| VPN / bastion | un port ouvert sur Internet est soumis à des millions de scanners en permanence (24h/24) |
| Auth par clé SSH | trouver le port 22 ouvert est la première étape ; le mot de passe est la deuxième cible |
| Logs et SIEM | sans log, l'attaque est invisible ; avec log, elle laisse une trace et déclenche une réponse |
Le principe fondamental du curseur attaque/défense
Un développeur qui comprend l'attaque écrit du code plus sûr. C'est le principe du cours : on construit le scanner (attaque en lab) pour comprendre le firewall, l'IDS, le Fail2ban (défense en production). La connaissance est la même des deux côtés du miroir — c'est l'usage qui diffère.
Pour finir (séance 1/2)
Ton antisèche Rust
| Notion | Syntaxe |
|---|---|
| variable | let x = …; / let mut x = …; |
| type explicite | let port: u16 = 22; |
| texte dynamique | format!("{}:{}", ip, port) |
| condition | if … { } else if … { } else { } |
| ET / OU | && / || |
| boucle | for p in 1u16..=1024 { } |
| fonction | fn f(x: u16) -> bool { … } |
| vecteur | Vec::new() · .push(x) · {:?} |
| gérer une erreur | match r { Ok(v) => …, Err(e) => … } · .is_ok() |
| connexion TCP | TcpStream::connect_timeout(&addr, t) |
| compiler & lancer | cargo run |
Vérifie tes acquis
- À quoi sert
cargo run? Etcargo new? - Différence entre
letetlet mut? - Pourquoi un port est-il un
u16et pas unu8? - Différence entre
=et==? - Que représentent une IP et un port ? Que veut dire
127.0.0.1? - Que signifie « le port est ouvert » en termes de handshake TCP ?
- Que retourne
TcpStream::connect_timeout, et comment on le teste ? - Pourquoi scanner une machine distante est-il lent sans parallélisme ?
Corrigé du quiz (auto-correction)
| Q | Réponse attendue |
|---|---|
| 1 | cargo run = compile le code ET lance l'exécutable résultant. cargo new nom = crée un nouveau projet Rust (dossier nom/ avec Cargo.toml + src/main.rs). |
| 2 | let x = variable immuable : sa valeur est fixée à la déclaration et ne peut plus changer. let mut x = variable mutable : on peut modifier sa valeur avec = plus tard dans le code. |
| 3 | Un numéro de port va de 0 à 65535. u8 ne peut stocker que 0 à 255 — trop petit. u16 (0 à 65 535 = 2¹⁶ − 1) couvre exactement la plage des ports TCP/UDP. Utiliser u8 provoquerait une erreur de type à la compilation si on essaie d'écrire port 443. |
| 4 | = = assignation : place une valeur dans une variable (let x = 5). == = comparaison : vérifie si deux valeurs sont égales, retourne true ou false. Confondre les deux est l'erreur n°1 : if x = 5 ne compile pas en Rust (contrairement à C). |
| 5 | L'IP identifie la machine sur le réseau (ex. 10.0.0.3 = une adresse parmi les 4,3 milliards IPv4 possibles). Le port identifie le service sur cette machine (ex. 22 = SSH). 127.0.0.1 = adresse de loopback = ta propre machine ; les paquets vers cette adresse ne quittent jamais la machine. |
| 6 | « Port 22 ouvert » = un service (ici SSH) écoute sur ce port ET a répondu SYN-ACK à notre SYN. Le three-way handshake s'est déroulé : SYN → SYN-ACK → ACK. Si rien n'écoutait, on aurait reçu un RST à la place. |
| 7 | TcpStream::connect_timeout retourne un Result<TcpStream, Error>. On le teste avec match (Ok(_) = connexion réussie = port ouvert ; Err(_) = échec = port fermé ou filtré) ou avec .is_ok() (retourne directement un bool). |
| 8 | Sans parallélisme, les ports sont testés un par un (séquentiel). Un port filtré attend le timeout entier (1 s dans notre code). 1024 ports × 1 s = ~17 minutes dans le pire cas. Avec Tokio (séance 2), toutes les connexions sont tentées simultanément → ~1 seconde. |
Tu es bloqué ?
« cargo : command not found » → source $HOME/.cargo/env, ou rouvre le terminal.
Erreur de compilation ? → lis la 1re ligne du message et la flèche --> (ligne/colonne). Vérifie les ;, les ! de println!, les &, et les use. Reporte-toi à « Les 5 erreurs Rust » (chap. 0).
« mismatched types » ? → tu mélanges deux types (souvent i32 au lieu de u16). Annote le type ou ajoute u16 au nombre.
Aucun port ouvert trouvé ? → vérifie que ton serveur Python (port 8888) tourne toujours dans l'autre terminal.
Un mot incompris ? → glossaire ci-dessous.
Glossaire
| Mot | Définition |
|---|---|
| terminal | fenêtre où l'on tape des commandes textuelles |
| compilateur | traduit le code (texte) en programme exécutable (binaire) |
| Rust | langage compilé, système, sûr en mémoire |
| cargo | l'outil qui crée, compile et lance les projets Rust |
| variable | boîte étiquetée qui stocke une valeur (let) |
| type | la forme d'une donnée (u16, bool, &str, String) |
| fonction | bloc de code nommé, réutilisable (fn) |
| vecteur | liste qui peut grandir (Vec) |
| Result | résultat qui est soit Ok (succès) soit Err (erreur) |
emprunt (&) | prêter une valeur à une fonction sans la lui donner |
| IP | adresse d'une machine sur le réseau (4 nombres, ex. 10.0.0.3) |
| port | numéro identifiant un service sur une machine (0-65535) |
| localhost | 127.0.0.1 — ta propre machine |
| TCP | protocole de connexion fiable (handshake SYN / SYN-ACK / ACK) |
| timeout | durée max d'attente avant d'abandonner une connexion |
| scanner de ports | programme qui teste quels ports sont ouverts |
La prochaine fois (séance 2)
Ton scanner marche, mais il est lent et ne vise qu'une machine. On le rendra rapide (scan asynchrone avec Tokio) et on l'étendra pour scanner tout un réseau, dans un lab Docker isolé. C'est la brique « trouver des cibles » d'un vrai ver.
Compétences mobilisées
référentiel BTS SIO SLAM
Bloc 2 · Conception et développement d'applications — C2.1
→ Développer des applications en respectant les standards de programmation
→ Analyser les besoins fonctionnels et techniques des utilisateurs (protocole TCP, ports, scanner)
Bloc 3 · Cybersécurité des services informatiques — C3.5
→ Prévenir les attaques et analyser les incidents de sécurité
→ Prendre en compte la sécurité dans un projet de développement d'une solution applicative
Bloc 3 · Cybersécurité des services informatiques — C3.4
→ Caractériser les risques liés à l'utilisation malveillante d'un service
→ Recenser les conséquences d'une perte de DIC (disponibilité, intégrité, confidentialité)
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