Opération Message Secret

Ce qu'on fait aujourd'hui

Hier, vous avez monté le réseau de la salle et appris à voir qui est connecté (le scan). Aujourd'hui, étape du dessus : on s'intéresse aux données qui voyagent sur ce réseau. On va faire tourner de vrais petits serveurs sur vos postes, s'envoyer des messages pour de bon, et répondre à LA question de sécurité : est-ce que quelqu'un peut lire ce que j'envoie ?

Le scénario GSB

GSB doit faire circuler des informations sensibles entre ses postes (un identifiant, un mot de passe, un numéro). La direction demande : « Prouvez-moi que vos échanges internes ne peuvent pas être lus par le premier venu sur le réseau. » À la fin de la séance, votre binôme sait répondre : le secret arrive lisible chez le bon destinataire, et illisible pour tout serveur ou poste qui le voit passer.

Le projet : protéger un échange, des deux côtés

Sécuriser un échange, c'est deux choses — et dans ce TP, vous faites les deux :

1 · Protéger le contenu

Le chiffrement : rendre le message illisible pour qui le voit passer. Même capté, il ne révèle rien sans la clé.

2 · Protéger l'accès

Le pare-feu : décider qui a le droit de se connecter à ton service. Tout le reste est refusé.

Vous travaillez à deux sur le même projet : chacun monte son serveur, chiffre ses messages et règle son pare-feu, et vous vous servez mutuellement de destinataire pour tester. Les deux volets ensemble = un échange vraiment protégé.

Comment avancer en autonomie

• Tout est à copier-coller dans une fenêtre PowerShell. Chaque bloc est expliqué juste en dessous, et on te montre ce que tu dois voir à l'écran.
• Tu travailles en binôme sur le même projet : vous faites les mêmes étapes et vous vous servez mutuellement de destinataire pour tester.
• Rends tes flags au fur et à mesure : FLAG-X-<valeur>, recopiée ou capturée dans ton compte-rendu.
• Bloqué ? Regarde la boîte « Erreur courante » du chapitre, puis la checklist « Tu es bloqué ? » en fin de doc, puis appelle le prof.

Les 5 parties

Vocabulaire de départ

Partie 0 — Mise en route

Ouvrir le terrain (et tester sur soi-même d'abord)

Avant de viser les autres, on prépare son poste et on vérifie que ça marche sur soi. Cette prudence, c'est le métier : on teste en petit avant de déployer.

C'est quoi PowerShell, et comment l'ouvrir ?

PowerShell est la console de commandes moderne de Windows. On va y coller des blocs de code (pas les taper). Ouvre-le en administrateur (il en faut pour régler le pare-feu) :

1. Touche Windows, tape powershell.
2. Clic droit sur « Windows PowerShell » → Exécuter en tant qu'administrateur → Oui.
3. Une fenêtre (souvent bleue) s'ouvre. C'est là qu'on colle le code (clic droit = coller).

Connaître son IP

ipconfig

Ouvrir le port 9000 au pare-feu

Un serveur qui écoute ne sert à rien si le pare-feu de Windows refuse les connexions entrantes. Première étape : autoriser le port 9000. Colle (fenêtre admin) :

New-NetFirewallRule -DisplayName "GSB-9000" -Direction Inbound -Protocol TCP -LocalPort 9000 -Action Allow

Name                  : {xxxxxxxx-....}
DisplayName           : GSB-9000
Enabled               : True
Direction             : Inbound
Action                : Allow

Lancer ton serveur (fenêtre « serveur »)

Voici le mini-serveur GSB : il écoute sur le 9000 et écrit tout ce qu'il reçoit à l'écran et dans un journal sur le Bureau. Colle ce bloc entier :

$port = 9000
$log  = "$env:USERPROFILE\Desktop\journal-serveur.txt"
$listener = New-Object System.Net.Sockets.TcpListener([System.Net.IPAddress]::Any, $port)
$listener.Start()
Write-Host "Serveur GSB en ecoute sur le port $port  (Ctrl+C pour arreter)" -ForegroundColor Green
while ($true) {
  $client = $listener.AcceptTcpClient()
  $reader = New-Object System.IO.StreamReader($client.GetStream())
  $recu   = $reader.ReadLine()
  $de     = $client.Client.RemoteEndPoint.Address.ToString()
  $ligne  = "$(Get-Date -Format HH:mm:ss) ; de $de ; recu : $recu"
  Write-Host $ligne -ForegroundColor Yellow
  Add-Content -Path $log -Value $ligne
  $reader.Close(); $client.Close()
}

Serveur GSB en ecoute sur le port 9000  (Ctrl+C pour arreter)

La fenêtre reste « bloquée » sur cette ligne : c'est bon signe, le serveur attend. Ne la ferme pas. Pour envoyer des messages, on ouvre une deuxième fenêtre PowerShell.

Test sur soi-même (le pré-vol personnel)

Avant de viser un camarade, envoie-toi un message à toi-même. Dans la fenêtre 2, colle (c'est le client) :

$ip  = "127.0.0.1"
$msg = "test depuis mon poste"
$c = New-Object System.Net.Sockets.TcpClient($ip, 9000)
$w = New-Object System.IO.StreamWriter($c.GetStream())
$w.WriteLine($msg); $w.Flush(); $c.Close()
Write-Host "Envoye a $ip : $msg" -ForegroundColor Cyan

# fenetre 2 (client)
Envoye a 127.0.0.1 : test depuis mon poste
# fenetre 1 (serveur)
14:03:11 ; de 127.0.0.1 ; recu : test depuis mon poste

Partie 1 — Le choc

S'envoyer un message… et tout lire

Maintenant, pour de vrai, entre deux postes. Échangez vos IP avec votre binôme (ou un autre îlot désigné). L'un garde son serveur ouvert (fenêtre 1), l'autre envoie depuis sa fenêtre 2.

Envoyer un « identifiant GSB » à ton binôme

Dans ta fenêtre 2 (client), remplace l'IP par celle du serveur de ton binôme, et envoie un faux identifiant (n'utilise jamais un vrai mot de passe) :

$ip  = "192.168.100.XX"
$msg = "login=marc; mdp=GSB2026!"
$c = New-Object System.Net.Sockets.TcpClient($ip, 9000)
$w = New-Object System.IO.StreamWriter($c.GetStream())
$w.WriteLine($msg); $w.Flush(); $c.Close()
Write-Host "Envoye a $ip : $msg" -ForegroundColor Cyan

Partie 2 — Camoufler ne suffit pas

Le piège du base64

Premier réflexe naïf : « je vais transformer le message pour qu'il ne soit plus lisible ». On essaie avec le base64, un encodage très courant… et on va voir pourquoi ça ne protège rien.

Encoder en base64 avant d'envoyer

Dans ta fenêtre 2 (client), transforme le message puis envoie le résultat :

$clair = "login=marc; mdp=GSB2026!"
$b64 = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($clair))
$b64

bG9naW49bWFyYzsgbWRwPUdTQjIwMjYh

Envoie cette chaîne au serveur du binôme (remplace $msg par $b64 dans le bloc d'envoi). Sur le serveur, la ligne reçue ressemble à du charabia… en apparence.

La douche froide : n'importe qui le redécode

Celui qui tient le serveur colle ceci avec la chaîne reçue :

[Text.Encoding]::UTF8.GetString([Convert]::FromBase64String("bG9naW49bWFyYzsgbWRwPUdTQjIwMjYh"))

login=marc; mdp=GSB2026!

Partie 3 — Chiffrer pour de vrai

Une clé, et le serveur ne voit plus rien

Pour vraiment protéger, il faut un secret partagé entre l'expéditeur et le destinataire : une clé. Sans la clé, impossible de relire. On va chiffrer avec un procédé simple (le XOR) : à comprendre, pas à réinventer.

Les deux fonctions (expéditeur ET destinataire les collent)

function Chiffre($msg,$cle){
  $b=[Text.Encoding]::UTF8.GetBytes($msg)
  $k=[Text.Encoding]::UTF8.GetBytes($cle)
  for($i=0;$i -lt $b.Length;$i++){ $b[$i]=$b[$i] -bxor $k[$i % $k.Length] }
  [Convert]::ToBase64String($b)
}
function Dechiffre($b64,$cle){
  $b=[Convert]::FromBase64String($b64)
  $k=[Text.Encoding]::UTF8.GetBytes($cle)
  for($i=0;$i -lt $b.Length;$i++){ $b[$i]=$b[$i] -bxor $k[$i % $k.Length] }
  [Text.Encoding]::UTF8.GetString($b)
}

Se mettre d'accord sur une clé, puis envoyer

Le binôme choisit une clé commune (ex. cle-gsb-2026). L'expéditeur chiffre :

$secret = Chiffre "login=marc; mdp=GSB2026!" "cle-gsb-2026"
$secret

Dw8CRAlODwIeBhZH...   (du charabia : c'est ca qu'on envoie)

Envoie $secret au serveur du binôme. Sur le serveur, la ligne reçue est illisible :

14:21:07 ; de 192.168.100.XX ; recu : Dw8CRAlODwIeBhZH...

Le destinataire, lui, a la clé. Il déchiffre :

Dechiffre "Dw8CRAlODwIeBhZH..." "cle-gsb-2026"

login=marc; mdp=GSB2026!

Partie 4 — Verrouiller l'accès

Le pare-feu : seul le binôme entre

Chiffrer protège le contenu. Mais on veut aussi contrôler qui a le droit de se connecter au service : c'est le rôle du pare-feu. On va n'autoriser que l'IP du binôme, et prouver qu'un troisième poste est refusé.

Remplacer l'autorisation large par une autorisation ciblée

Colle (fenêtre admin), en mettant l'IP de ton binôme :

Remove-NetFirewallRule -DisplayName "GSB-9000" -ErrorAction SilentlyContinue
New-NetFirewallRule -DisplayName "GSB-9000-binome" -Direction Inbound -Protocol TCP -LocalPort 9000 -RemoteAddress 192.168.100.XX -Action Allow

Prouver le verrou

Demande à un troisième poste (pas ton binôme) de tester l'accès à ton serveur :

Test-NetConnection 192.168.100.<toi> -Port 9000

# depuis le binome autorise :
TcpTestSucceeded : True
# depuis un poste tiers :
TcpTestSucceeded : False

Partie 5 — Le défi final

Le secret sous le nez du serveur central

On assemble tout. Le prof (ou un élève volontaire par îlot) lance un « serveur central GSB » par lequel passent les messages de l'îlot — il logue tout, comme un intermédiaire réel (un proxy, un fournisseur d'accès…). Votre mission de binôme :

Autrement dit : l'intermédiaire voit passer votre message, mais ne doit rien comprendre. C'est très exactement ce que fait HTTPS sur Internet : vos données traversent des dizaines d'intermédiaires qui ne voient que du chiffré.

Le serveur central voit passer le message mais ne lit que du charabia. Seuls l'expéditeur et le destinataire, qui partagent la clé, comprennent.

Défi bonus

Remise en état — OBLIGATOIRE

Vérifie-toi (auto-correction)

1. Quand tu envoies un message « en clair » à un serveur, qui peut le lire ?
2. Pourquoi le base64 ne protège-t-il pas un secret ?
3. Qu'est-ce qu'il faut partager entre expéditeur et destinataire pour chiffrer/déchiffrer ?
4. Comment n'autoriser qu'une seule machine à se connecter à ton service ?
5. Dans le défi final, pourquoi le serveur central « voit passer » le message sans le comprendre ?

Tu es bloqué ? La checklist

Glossaire

Synthèse — ce que tu sais faire

Compétences mobilisées (référentiel BTS SIO)

Bloc 3 · Cybersécurité des services informatiques

Prolongement : introduit la notion de chiffrement de bout en bout, socle de l'E7 (confidentialité, TLS) et du futur module web 2A (HTTPS, sécurisation d'une API).