Aller au contenu
Réussir mon BTS SIO

Tape une notion, une commande ou le nom d'une épreuve.

Par exemple

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

ÉtapeTu sauras…
Chapitre 0 — Installer Rustouvrir 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 Rustles 4 briques en vrai code : variables/types, conditions, boucles, fonctions — + vecteurs et gestion d'erreurs
Chapitre 3 — Le réseaucomprendre IP, ports, TCP et ce que veut dire « scanner »
Chapitre 4 — Premier scancoder un scanner de ports complet et le lancer pour de vrai
Chapitre 5 — Côté défenseurvoir 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èmeComment faire
macOSAppuie sur Cmd + Espace, tape « Terminal », Entrée
Linux (Ubuntu)Appuie sur Ctrl + Alt + T
WindowsMenu 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.

bash
pwd
Ce que tu dois voir
/home/utilisateur
bash
ls
Ce que tu dois voir
Bureau  Documents  Images  Téléchargements
powershell
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 :

powershell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Le script demande quoi faire. Tu verras :

Ce que tu dois voir
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 :

Ce que tu dois voir
Rust is installed now. Great!

Activer Rust dans le terminal

bash
source $HOME/.cargo/env

Vérifier l'installation

rustc --version
cargo --version
Ce que tu dois voir
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.

0 sur 9 dans cette étape

Chapitre 0 (suite) — Ton premier programme

0.4 — Créer ton premier projet

cargo new scanner
Ce que tu dois voir
Creating binary (application) `scanner` package

Regardons ce que Cargo a créé :

bash
ls scanner/
Ce que tu dois voir
Cargo.toml  src
bash
ls scanner/src/
Ce que tu dois voir
main.rs

Cargo a créé 2 choses :

FichierRôleAnalogie
Cargo.tomlla carte d'identité du projet (nom, version, dépendances)la couverture d'un livre
src/main.rston code sourceles 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 :

powershell
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
Ce que tu dois voir
   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 :

Ce que tu dois voir
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 sur 9 dans cette étape

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 :

Ce que tu dois voir
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é.

0 sur 9 dans cette étape

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 vieC'est un algorithme parce que…
Une recette de cuisinedes étapes ordonnées → un gâteau
Un itinéraire GPS« tourne à droite, puis tout droit 200 m… » → tu arrives
La notice d'un meublevisse A sur B, puis C… → une étagère
Faire un virement bancaireune 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 :

Étapecompteurcompteur ≤ 3 ?Affiche
départ1——
tour 11 → 2vrai1
tour 22 → 3vrai2
tour 33 → 4vrai3
tour 44faux → 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 ← 20let age = 20;
SI … ALORS … SINON …if … { … } else { … }
POUR n DE 1 À 10for n in 1..=10 { … }
TANT QUE …while … { … }
afficher xprintln!("{}", 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.

0 sur 9 dans cette étape

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);
}
Ce que tu dois voir
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);
}
Ce que tu dois voir
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);
}
Ce que tu dois voir
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);
}
Ce que tu dois voir
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);
}
Ce que tu dois voir
port=22, open=true, temp=-5

Les types de nombres les plus courants :

TypeSignificationPlageUsage typique
u8unsigned 8 bits0 à 255octets (données brutes)
u16unsigned 16 bits0 à 65535numéros de port
u32unsigned 32 bits0 à ~4,3 milliardscompteurs, identifiants
i32signed 32 bits−2,1 G à +2,1 Gnombres généraux (défaut)
boolbooléentrue / falsevrai / 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);
}
Ce que tu dois voir
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.

0 sur 9 dans cette étape

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);
    }
}
Ce que tu dois voir
HTTP (web)

Les opérateurs de comparaison :

OpérateurSignificationExemple vrai
==égal à5 == 5
!=différent de5 != 3
<plus petit que3 < 5
>plus grand que5 > 3
<=plus petit ou égal5 <= 5
>=plus grand ou égal5 >= 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 !");
    }
}
Ce que tu dois voir
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);
    }
}
Ce que tu dois voir
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);
    }
}
Ce que tu dois voir
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);
        }
    }
}
Ce que tu dois voir
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;
    }
}
Ce que tu dois voir
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 ?

0 sur 9 dans cette étape

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);
}
Ce que tu dois voir
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);
}
Ce que tu dois voir
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));
}
Ce que tu dois voir
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.

0 sur 9 dans cette étape

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());
}
Ce que tu dois voir
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);
    }
}
Ce que tu dois voir
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),
    }
}
Ce que tu dois voir
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");
    }
}
Ce que tu dois voir
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éelRéseau
Adresse postale (12 rue des Lilas)Adresse IP (10.0.0.3)
La Poste achemine la lettreInternet achemine le paquet de données
Chaque maison a une adresse uniqueChaque 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

AdresseNomSignification
127.0.0.1localhostta propre machine — se parler à soi-même
10.0.0.Xréseau privéréseau local (pas accessible depuis Internet)
192.168.X.Xréseau privéton réseau Wi-Fi à la maison, typiquement
0.0.0.0toutes 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éristiqueIPv4IPv6
Format10.0.0.3 (4 × 8 bits)2001:db8::1 (8 × 16 bits)
Nombre d'adresses~4,3 milliards (2³²)340 sextillions (2¹²⁸)
Adresse loopback127.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'huiencore dominant en entreprise et labrequis 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

PortServiceCe que ça faitRisque défensif si exposé sur Internet
21FTPtransfert de fichiers — non chiffréidentifiants en clair interceptables (MITM) ; remplacé par SFTP (port 22) ou FTPS (port 990)
22SSHterminal 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
23Telnetterminal distant — non chiffré (obsolète)tout passe en clair (login, commandes) ; présence = Security Misconfiguration (OWASP A05) ; ne jamais exposer
25SMTPenvoi d'emails (serveur à serveur)open relay = spam + réputation IP brûlée ; exige SPF, DKIM, DMARC
53DNSrésolution de noms (texte → IP) — UDP+TCPDNS amplification DDoS ; cache poisoning ; filtrer requêtes récursives externes
80HTTPsite web non chiffrétrafic lisible en clair ; rediriger systématiquement vers HTTPS (443)
443HTTPSsite web chiffré (TLS 1.2 / 1.3)certificat expiré = alerte navigateur ; TLS 1.0 et SSLv3 = vulnérables (POODLE, BEAST)
445SMBpartage de fichiers Windowsexploité par WannaCry (2017) ; ne jamais exposer sur Internet
3306MySQLbase de données relationnellebase exposée directement = données personnelles à risque (RGPD) ; accès local ou VPN uniquement
5432PostgreSQLbase de données relationnellemême règle que MySQL ; contrôle fin des accès via pg_hba.conf
6379Rediscache / sessions (clé-valeur)sans authentification exposé = lecture et écriture libres ; CVE critiques fréquentes ; lier à 127.0.0.1 obligatoire
8080HTTP alternatifserveurs de dev, proxies, panneaux d'adminsouvent moins sécurisé que le port 80 principal ; cible courante des scanners automatisés
27017MongoDBbase 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 :

PlageNom IANARègle Linux/macOSExemples
0 – 1 023Well-known ports (ports système)root requis pour ouvrir (écouter)22 SSH, 80 HTTP, 443 HTTPS, 25 SMTP
1 024 – 49 151Registered portstout utilisateur peut écouter3306 MySQL, 5432 PostgreSQL, 8080 HTTP-alt
49 152 – 65 535Dynamic / Ephemeral portsutilisés automatiquement par le système comme port source des connexions sortantesta 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 ?

Schéma : Ton · scanner · SYN · Port · cible · SYN-ACK · RST · silence · OUVERT · un service écoute · FERMÉ · rien n'écoute · TIMEOUT · machine OFF / filtrée

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.

0 sur 9 dans cette étape

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èreTCPUDP
Connexionthree-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 ouvertSYN-ACK = ouvert ; RST = fermé ; silence = filtréréponse UDP = ouvert ; silence = ouvert OU filtré (ambigu !)
Services typiquesSSH (22), HTTP (80), HTTPS (443), MySQL (3306)…DNS (53), NTP (123), SNMP (161), DHCP (67/68)
Scan nmapnmap -sS (SYN stealth, root requis) ou -sTnmap -sU (root requis, 5-10× plus lent)
Faux négatifstrès rarescourants : 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 :

powershell
python3 -m http.server 8888
Ce que tu dois voir
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
Ce que tu dois voir
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 :

Ce que tu dois voir
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
Ce que tu dois voir
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);
}
Ce que tu dois voir
=== 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) :

Ce que tu dois voir
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.

0 sur 9 dans cette étape

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 :

bash
sudo tail -f /var/log/ufw.log

Pendant qu'un scanner tourne sur le réseau local, les logs affichent quelque chose comme :

Ce que tu dois voir
[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 :

OutilRôleType de détectionRéponse automatique possible
UFW / iptablespare-feu Linuxrègles statiques (IP, port, protocole)bloquer le paquet, logger
Fail2banprotection brute-forcelit les logs Apache/SSH/UFW, compte les tentatives par IPban automatique de l'IP source (configurable : 10 min, 24 h, permanent)
Snort / SuricataIDS/IPS réseausignatures (patterns de paquets), analyse comportementalealerte, coupure de flux (mode IPS)
SIEM (Splunk, ELK)agrégation de logscorré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-mesureCe qu'elle faitConfig type
Fermer tous les ports inutilesmoins de ports ouverts = moins de vecteurs d'attaqueufw default deny incoming, puis ouvrir seulement le nécessaire
Rate-limiting SSHlimite les connexions par IP et par minuteufw limit ssh — 6 tentatives / 30 s, puis ban temporaire
Fail2banban auto de l'IP après X échecs consécutifsmaxretry = 5, bantime = 3600 (1 h)
VPN ou bastionSSH n'écoute que sur le réseau interne — invisible depuis InternetWireGuard, OpenVPN, Tailscale
Authentification par cléélimine le brute-force de mots de passeclé Ed25519 ou RSA 4096 bits ; PasswordAuthentication no dans sshd_config

5.4 — Ce qu'on comprend en construisant l'attaque

En codant ce scanner, tu comprends exactement pourquoi chaque contre-mesure existe :

Contre-mesurePourquoi elle existe — ce que tu viens de coder
Fail2banun scanner teste des centaines de ports ; un brute-force SSH suivrait le même pattern sur le port 22
Rate-limitingnotre boucle for port in 1u16..=1024 enverrait 1024 SYN en quelques secondes sans aucune limite
VPN / bastionun port ouvert sur Internet est soumis à des millions de scanners en permanence (24h/24)
Auth par clé SSHtrouver le port 22 ouvert est la première étape ; le mot de passe est la deuxième cible
Logs et SIEMsans log, l'attaque est invisible ; avec log, elle laisse une trace et déclenche une réponse

Pour finir (séance 1/2)

Ton antisèche Rust

NotionSyntaxe
variablelet x = …; / let mut x = …;
type explicitelet port: u16 = 22;
texte dynamiqueformat!("{}:{}", ip, port)
conditionif … { } else if … { } else { }
ET / OU&& / ||
bouclefor p in 1u16..=1024 { }
fonctionfn f(x: u16) -> bool { … }
vecteurVec::new() · .push(x) · {:?}
gérer une erreurmatch r { Ok(v) => …, Err(e) => … } · .is_ok()
connexion TCPTcpStream::connect_timeout(&addr, t)
compiler & lancercargo run

Vérifie tes acquis

  1. À quoi sert cargo run ? Et cargo new ?
  2. Différence entre let et let mut ?
  3. Pourquoi un port est-il un u16 et pas un u8 ?
  4. Différence entre = et == ?
  5. Que représentent une IP et un port ? Que veut dire 127.0.0.1 ?
  6. Que signifie « le port est ouvert » en termes de handshake TCP ?
  7. Que retourne TcpStream::connect_timeout, et comment on le teste ?
  8. Pourquoi scanner une machine distante est-il lent sans parallélisme ?

Corrigé du quiz (auto-correction)

QRéponse attendue
1cargo 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).
2let 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.
3Un 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).
5L'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.
7TcpStream::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).
8Sans 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.

Glossaire

MotDéfinition
terminalfenêtre où l'on tape des commandes textuelles
compilateurtraduit le code (texte) en programme exécutable (binaire)
Rustlangage compilé, système, sûr en mémoire
cargol'outil qui crée, compile et lance les projets Rust
variableboîte étiquetée qui stocke une valeur (let)
typela forme d'une donnée (u16, bool, &str, String)
fonctionbloc de code nommé, réutilisable (fn)
vecteurliste qui peut grandir (Vec)
Resultrésultat qui est soit Ok (succès) soit Err (erreur)
emprunt (&)prêter une valeur à une fonction sans la lui donner
IPadresse d'une machine sur le réseau (4 nombres, ex. 10.0.0.3)
portnuméro identifiant un service sur une machine (0-65535)
localhost127.0.0.1 — ta propre machine
TCPprotocole de connexion fiable (handshake SYN / SYN-ACK / ACK)
timeoutdurée max d'attente avant d'abandonner une connexion
scanner de portsprogramme qui teste quels ports sont ouverts

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

Séance 1 terminé ?

Coche chaque livrable quand tu l'as : c'est la preuve que l'étape est acquise.

livrables
–
de série
–
Passer à la séance 2 : Le ver en Rust (2) scanner un réseauVoir toutes les étapes du TP