Un code irréprochable sur un serveur mal configuré reste vulnérable. Le durcissement ferme les portes inutiles.
⏱️ Durée : environ 95 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Durcisseur de systèmes
🎬 L'histoire
Après l'audit, HashBox découvre un autre problème : le serveur de test faisait tourner SSH avec connexion root par mot de passe, une base de données écoutait sur toutes les interfaces, et une bibliothèque vieille de trois ans avait une faille publique connue.
« Le code était correct, dit Sam. Mais la machine autour ne l'était pas. La sécurité, c'est aussi la configuration, les mises à jour et les accès. On appelle ça le durcissement (hardening). »
Tu apprends à auditer et durcir un système : ports, permissions, SSH, TLS, conteneurs, dépendances.
🎯 Ta mission
À la fin, je serai capable de :
- lister les principes du durcissement d'un système
- auditer ports ouverts, permissions et configuration SSH avec des scripts
- vérifier une configuration TLS et des paramètres de conteneur
- contrôler les dépendances vulnérables et la chaîne d'approvisionnement
- définir une politique de mise à jour
🧩 Défi d'échauffement (5 XP)
Tu emménages dans une maison ancienne. Avant de t'y installer : (1) tu changes les serrures (clés inconnues), (2) tu fermes les pièces inutiles, (3) tu répares ce qui est cassé, (4) tu installes une alarme, (5) tu notes qui a quelle clé. Fais le parallèle avec un serveur : à quoi correspond chaque action ? Quelle action est la plus souvent oubliée ?
💡 Le concept
Le durcissement : principes
| Principe | Application |
|---|---|
| Réduire la surface | désinstaller les services inutiles, fermer les ports non nécessaires |
| Moindre privilège | pas de root, comptes dédiés, droits de fichiers stricts |
| Configuration sûre par défaut | changer les mots de passe par défaut, désactiver les fonctions risquées |
| Mises à jour | correctifs de sécurité appliqués rapidement et de façon contrôlée |
| Segmentation | zones réseau séparées, pare-feu entre elles |
| Journalisation et supervision | savoir ce qui se passe |
| Reproductibilité | configuration versionnée (infrastructure as code) |
Réseau : ports et services
Un port ouvert est un point d'entrée potentiel. On compare toujours l'inventaire attendu à l'observé :
| Écart | Signification |
|---|---|
| ouvert mais non attendu | service oublié ou intrus |
| attendu mais fermé | panne ou changement non voulu |
| attendu mais exposé trop largement | écoute sur 0.0.0.0 au lieu de 127.0.0.1 ou du réseau privé |
⚖️ Cadre : n'analyse que tes propres machines (ou celles pour lesquelles tu as une autorisation écrite). Une analyse de ports sur un système tiers est illégale dans de nombreux pays.
SSH
| Réglage | Recommandation |
|---|---|
PermitRootLogin | no |
PasswordAuthentication | no (clés uniquement) |
PermitEmptyPasswords | no |
X11Forwarding | no si inutile |
AllowUsers / AllowGroups | liste restreinte |
MaxAuthTries | faible (3) |
| Port | changer n'est pas une sécurité, mais réduit le bruit ; ce qui compte : les clés, le pare-feu, la surveillance |
Permissions du système de fichiers
- Fichiers de configuration avec secrets :
600(ou640avec groupe dédié). - Aucune écriture pour « tout le monde » (
o+w) sauf dossiers à bit sticky comme/tmp. - Pas de programmes
setuidinutiles. - Clés SSH privées en
600.
TLS : bien configurer
| Contrôle | Attendu |
|---|---|
| Versions | TLS 1.2 minimum, idéalement 1.3 ; SSLv3, TLS 1.0 et 1.1 désactivés |
| Suites de chiffrement | AEAD (AES-GCM, ChaCha20-Poly1305), échange à confidentialité persistante (ECDHE) |
| Certificat | valide, non expiré, chaîne complète, nom correct |
| HSTS | activé |
| Vérification côté client | jamais verify=False ou CERT_NONE en production |
En Python, ssl.create_default_context() active par défaut la vérification du certificat et du nom d'hôte.
Conteneurs
| Pratique | Raison |
|---|---|
Ne pas exécuter en root (USER non privilégié) | limite l'impact d'une compromission |
Images minimales, épinglées par version/digest (pas latest) | moins de composants, reproductibilité |
Pas de secrets dans l'image ni dans ENV | ils fuient dans les couches |
| Système de fichiers en lecture seule, capacités retirées | moindre privilège |
| Analyse des images et des dépendances | détecter les composants vulnérables |
Dépendances et chaîne d'approvisionnement
La plupart du code d'une application vient de tiers. Risques : bibliothèque vulnérable (A06), paquet malveillant imitant un nom connu (typosquatting), compromission d'un mainteneur, dépendance abandonnée.
Mesures :
- inventaire (SBOM : liste des composants) ;
- verrouiller les versions (fichier de verrouillage) et vérifier les empreintes (
pip install --require-hashes) ; - analyse automatique des vulnérabilités connues (CVE) en intégration continue ;
- mises à jour régulières et revues ;
- limiter les dépendances.
Une politique de correctifs
| Gravité | Délai de correction cible |
|---|---|
| Critique, exploitée activement | 24 à 72 h |
| Haute | 7 jours |
| Moyenne | 30 jours |
| Basse | prochain cycle |
La rapidité vient d'une chaîne de déploiement fiable : si déployer fait peur, on corrige trop tard.
🧠 Astuce : la sécurité de l'infrastructure se mesure à la facilité de refaire la configuration à l'identique : si tu ne peux pas la reconstruire, tu ne peux pas la vérifier.
🔍 Exemple pas à pas
Problème : écrire des audits automatisés (SSH, permissions, ports, Dockerfile, dépendances) et les tester.
import os, re, socket, stat, tempfile
from pathlib import Path
# ---------- 1. Audit de configuration SSH ----------
RECOMMANDATIONS_SSH = {
"permitrootlogin": ("no", "la connexion root directe est interdite"),
"passwordauthentication": ("no", "authentification par clés uniquement"),
"permitemptypasswords": ("no", "pas de mot de passe vide"),
"x11forwarding": ("no", "désactiver les fonctions inutiles"),
}
def auditer_sshd(config):
valeurs = {}
for ligne in config.splitlines():
ligne = ligne.split("#")[0].strip()
if ligne:
cle, _, valeur = ligne.partition(" ")
valeurs[cle.lower()] = valeur.strip().lower()
problemes = []
for cle, (attendu, raison) in RECOMMANDATIONS_SSH.items():
reel = valeurs.get(cle, "(défaut)")
if reel != attendu:
problemes.append(f"{cle} = {reel} (attendu : {attendu}) — {raison}")
return problemes
print(auditer_sshd("PermitRootLogin yes\nPasswordAuthentication yes\nX11Forwarding no\n"))
# ---------- 2. Audit de permissions ----------
def auditer_permissions(dossier):
problemes = []
chemin Path(dossier).rglob():
mode = chemin.stat().st_mode
chemin.is_file() mode & stat.S_IWOTH:
problemes.append(((chemin.relative_to(dossier)), ))
chemin.is_file() re.search(, chemin.name) mode & (stat.S_IRGRP | stat.S_IROTH):
problemes.append(((chemin.relative_to(dossier)), ))
problemes
tempfile.TemporaryDirectory() d:
nom, mode ((, ), (, ), (, ), (, )):
(Path(d) / nom).write_text()
os.chmod(Path(d) / nom, mode)
chemin, raison (auditer_permissions(d)):
()
():
ouverts = ()
port ports:
socket.socket() s:
s.settimeout(delai)
s.connect_ex((hote, port)) == :
ouverts.add(port)
ouverts
serveur = socket.socket()
serveur.bind((, ))
serveur.listen()
port_attendu = serveur.getsockname()[]
port_ferme = port_attendu + port_attendu < port_attendu -
observes = ports_ouverts(, [port_attendu, port_ferme])
attendus = {port_attendu}
(, observes - attendus, , attendus - observes)
serveur.close()
():
problemes, a_user = [],
numero, ligne (texte.splitlines(), ):
l = ligne.strip()
re.(, l) (re.(, l) l):
problemes.append((numero, ))
re.(, l):
a_user =
re.(, l):
problemes.append((numero, ))
re.(, l):
problemes.append((numero, ))
re.(, l):
problemes.append((numero, ))
a_user:
problemes.append((, ))
problemes
DOCKERFILE =
numero, probleme linter_dockerfile(DOCKERFILE):
()
AVIS = {: [(, , )],
: [(, , )]}
():
((x) x v.split())
():
resultats = []
ligne lignes:
nom, _, v = ligne.strip().partition()
contrainte, description, gravite AVIS.get(nom, []):
borne = contrainte.replace(, ).strip()
version(v) < version(borne):
resultats.append((nom, v, description, gravite, ))
resultats
ligne auditer_dependances([, , ]):
(ligne)
Lecture : chaque contrôle est automatisable, rapide, et peut tourner à chaque déploiement :
- SSH :
PermitRootLogin yesetPasswordAuthentication yessont signalés ; - permissions :
.envlisible par d'autres etexport.csvmodifiable par tous ; - ports : aucun écart sur la machine locale (c'est un inventaire attendu contre observé) ;
- Dockerfile : image
latest, secret dansENV,ADDdepuis une URL, pas d'USER; - dépendances :
vieillelib 2.3.0critique,parseurxmlà jour.
✍️ À toi, avec aide (10 XP)
Écris auditer_tls(configuration) qui prend un dictionnaire décrivant la configuration TLS d'un serveur et renvoie des problèmes :
{"protocoles": ["TLSv1.0", "TLSv1.2"], "suites": ["ECDHE-RSA-AES128-GCM-SHA256", "RC4-SHA"],
"certificat": {"expire": "2024-01-15", "nom": "hashbox.example", "auto_signe": False}, "hsts": False}
Règles : refuser SSL/TLS 1.0/1.1, signaler les suites avec RC4, 3DES, NULL, MD5 ou sans GCM/CHACHA20/ECDHE, certificat expiré à une date de référence, auto-signé en production, HSTS absent. Teste sur une configuration très mauvaise, une moyenne et une bonne.
💡 Indice 1
Compare les dates au format ISO avec des chaînes ('2024-01-15' < '2025-01-01').
💡 Indice 2
Une suite sans ECDHE n'a pas de confidentialité persistante.
💡 Indice 3
Renvoie des tuples (gravité, message).
✅ Réponse
FAIBLES = ("RC4", "3DES", "NULL", "MD5", "DES-CBC")
def auditer_tls(c, aujourdhui="2025-06-01"):
p = []
for proto in c["protocoles"]:
if proto in ("SSLv2", "SSLv3", "TLSv1.0", "TLSv1.1"):
p.append(("haute", f"protocole obsolète activé : {proto}"))
for suite in c["suites"]:
if any(f in suite for f in FAIBLES):
p.append(("haute", f"suite faible : {suite}"))
elif "ECDHE" not in suite:
p.append(("moyenne", f"pas de confidentialité persistante : {suite}"))
elif "GCM" not in suite and "CHACHA20" not in suite:
p.append((, ))
cert = c[]
cert[] < aujourdhui:
p.append((, ))
cert[]:
p.append((, ))
c.get():
p.append((, ))
p
mauvaise = {: [, ], : [, ],
: {: , : , : }, : }
bonne = {: [, ], : [, ],
: {: , : , : }, : }
gravite, message auditer_tls(mauvaise):
(gravite, , message)
auditer_tls(bonne) == []
(auditer_tls(mauvaise)) ==
🚀 À toi, en solo (20 XP)
Politique de correctifs. Écris un petit module qui, à partir d'un inventaire de composants et d'une base d'avis (comme dans l'exemple, avec gravité, date de publication, indicateur « exploité activement »), produit un plan de mise à jour :
- échéance de correction selon la gravité et l'exploitation active (24 h, 7 j, 30 j, prochain cycle) ;
- tri par urgence ;
- détection des composants sans mainteneur actif (dernière version > 2 ans) à remplacer ;
- un rapport indiquant les retards par rapport à la date du jour ;
- un test avec 10 composants et 6 avis.
✅ Pistes de correction
from datetime import date, timedelta
DELAIS = {"critique": 3, "haute": 7, "moyenne": 30, "basse": 90}
def echeance(avis):
jours = 1 if avis["exploite"] and avis["gravite"] in ("critique", "haute") else DELAIS[avis["gravite"]]
return date.fromisoformat(avis["publie"]) + timedelta(days=jours)
def plan(inventaire, avis_par_composant, aujourdhui):
lignes = []
for nom, info in inventaire.items():
v = tuple(int(x) for x in info["version"].split("."))
for a in avis_par_composant.get(nom, []):
if v < tuple(int(x) for x in a["corrige_en"].split(".")):
e = echeance(a)
lignes.append({: nom, : a[], : e,
: (, (aujourdhui - e).days), : })
(aujourdhui - date.fromisoformat(info[])).days > :
lignes.append({: nom, : , : aujourdhui + timedelta(days=),
: , : })
(lignes, key= l: (l[], l[]))
INVENTAIRE = {
: {: , : },
: {: , : },
: {: , : },
: {: , : },
: {: , : },
}
AVIS = {
: [{: , : , : , : }],
: [{: , : , : , : }],
: [{: , : , : , : }],
}
resultat = plan(INVENTAIRE, AVIS, date(, , ))
l resultat:
(l[], l[], l[], , , l[])
(l[] == l[] > l resultat)
(l[] == l resultat)
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Services et ports inutiles | Chaque port est une porte | Inventaire attendu contre observé |
| Mots de passe et comptes par défaut | Exploités en minutes par les scans automatiques | Changer, désactiver, clés uniquement |
| Ne pas mettre à jour | Failles publiques exploitées en masse | Politique de correctifs avec délais |
| Désactiver la vérification TLS « pour tester » | Cela finit en production | Certificats de test valides ou autorité interne |
🐉 Mini-boss (40 XP)
Dossier de durcissement d'un serveur d'application. À partir d'un « état du serveur » décrit en données (config SSH, liste de services écoutant, permissions de fichiers, Dockerfile, requirements.txt, configuration TLS, politique de mises à jour), construis un outil audit_serveur.py qui :
- exécute les contrôles de la mission (SSH, ports, permissions, TLS, Dockerfile, dépendances) ;
- calcule un score de conformité pondéré par gravité ;
- produit un rapport Markdown classé par gravité avec la correction recommandée pour chaque écart ;
- génère un script de correction (liste de commandes) pour les écarts simples, mais sans l'exécuter ;
- compare deux états (avant/après) et montre les écarts corrigés ;
- 20 tests, dont des états « bons » (aucun écart) et « terribles » (au moins 12 écarts).
✅ Pistes de correction
Un bon travail : une fonction par contrôle qui renvoie une liste d'écarts (domaine, gravité, message, correction); un score 100 - somme(pondération[gravité]) borné à 0; le rapport trie par gravité puis par domaine; les corrections proposées sont des chaînes (sed -i 's/^PermitRootLogin.*/PermitRootLogin no/' /etc/ssh/sshd_config, chmod 600 .env, pip install 'vieillelib>=2.4.1') jamais exécutées automatiquement (revue humaine); la comparaison avant/après calcule l'ensemble des écarts résolus, persistants, nouveaux; les tests vérifient qu'un état conforme donne 100 et aucun écart, et qu'un état dégradé produit au moins 12 écarts dont tous les domaines.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Le durcissement d'un système consiste à :
- A. ajouter des fonctions
- B. ralentir le serveur
- C. réduire la surface d'attaque et sécuriser la configuration
2. Une bonne configuration SSH :
- A. interdit la connexion root et les mots de passe, avec des clés
- B. autorise tout pour la commodité
- C. change seulement le port
3. Dans un conteneur, on évite :
- A. d'utiliser une image minimale
- B. d'exécuter le processus en root
- C. d'épingler les versions
4. 🔁 Révision mission 07 : L'injection consiste à :
- A. chiffrer deux fois
- B. saturer un serveur
- C. mélanger des données non fiables à une instruction interprétée
5. 🔁 Révision mission 07 : La validation d'entrées doit privilégier :
- A. la liste blanche de ce qui est permis
- B. la liste noire des caractères dangereux
- C. l'absence de contrôle
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quels services ou comptes « oubliés » existent dans ton environnement (anciens comptes, ports ouverts, applications inutiles) ?
- Comment saurais-tu, aujourd'hui, si une dépendance de ton projet a une faille connue ?
🎒 À retenir
- Réduire la surface, moindre privilège, configuration sûre, mises à jour.
- Inventaire attendu contre observé (sur ses propres machines).
- SSH par clés, root interdit ; permissions strictes.
- TLS 1.2+, suites AEAD, certificat valide.
- Conteneurs non root, images épinglées ; dépendances inventoriées et mises à jour.
flowchart LR
T(["Sécurité réseau et système"])
T --> R1["1. Réduire la surface, moindre privilège, configuration sûre, mises à…"]
T --> R2["2. Inventaire attendu contre observé sur ses propres machines."]
T --> R3["3. SSH par clés, root interdit ; permissions strictes."]
T --> R4["4. TLS 1.2+, suites AEAD, certificat valide."]
T --> R5["5. Conteneurs non root, images épinglées ; dépendances inventoriées et…"]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Durcisseur de systèmes
← Mission 07 — OWASP Top 10 et validation des entrées · Mission 09 — Journalisation, détection et réponse à incident →
HEF-100 — Sécurité

