On ne peut pas défendre ce qu'on ne voit pas. Et quand ça arrive, on a besoin d'un plan, pas d'improvisation.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Veilleur et répondant
🎬 L'histoire
Un matin, un formateur de HashBox signale que son compte a envoyé des messages étranges pendant la nuit. L'équipe cherche : quand la connexion a-t-elle eu lieu ? Depuis où ? Qu'a fait ce compte ? Les journaux existent, mais ils ne contiennent pas l'adresse IP, ils sont écrasés après 24 heures, et personne ne sait qui est responsable de la réponse.
« Une enquête d'incident repose sur trois choses, dit Sam : des traces fiables, des outils pour les lire, et un plan connu à l'avance. Il manque les trois. »
Tu apprends à journaliser pour la sécurité, à détecter des comportements suspects et à mener une réponse à incident structurée.
🎯 Ta mission
À la fin, je serai capable de :
- définir quoi journaliser pour la sécurité (et quoi ne pas journaliser)
- analyser des journaux pour détecter force brute, bourrage d'identifiants et voyage impossible
- protéger l'intégrité des journaux avec une chaîne de hachés
- décrire les phases de la réponse à incident (préparation, détection, confinement, éradication, récupération, retour d'expérience)
- mesurer MTTD et MTTR et rédiger un post-mortem sans blâme
🧩 Défi d'échauffement (5 XP)
Un cambriolage a eu lieu dans un magasin. Pour reconstituer ce qui s'est passé, quels éléments voudrais-tu avoir (caméras, journal des alarmes, badge des employés, caisse) ? Que se passe-t-il si les enregistrements sont effacés après 24 h ou si le cambrioleur peut les modifier ? Écris les propriétés indispensables d'un bon enregistrement.
💡 Le concept
Que journaliser pour la sécurité ?
| Catégorie | Exemples d'événements |
|---|---|
| Authentification | succès, échecs, verrouillage, changement de mot de passe, MFA |
| Autorisation | accès refusés, changements de droits |
| Données sensibles | lectures, exports, suppressions |
| Administration | actions privilégiées, changements de configuration |
| Application | erreurs inattendues, validation d'entrée échouée |
| Système | démarrage/arrêt de services, nouvelles clés, nouveaux comptes |
Pour chaque événement : qui (identifiant, pas le mot de passe), quoi, quand (horodatage UTC précis), d'où (IP, agent), sur quelle ressource, résultat, identifiant de corrélation (suivre une requête à travers les services).
À ne jamais journaliser : mots de passe, jetons, clés, numéros de carte complets, données personnelles inutiles (mission 5).
Des journaux utiles
- structurés (JSON) pour être analysés par des machines ;
- centralisés (hors de la machine compromise) ;
- horodatés de façon synchronisée (NTP) ;
- conservés assez longtemps (30 à 365 jours selon les règles) ;
- protégés : écriture seule, intégrité vérifiable ;
- surveillés : des alertes, pas seulement du stockage.
Détection : quelques motifs classiques
| Motif | Signal | Exemple de règle |
|---|---|---|
| Force brute | beaucoup d'échecs sur un compte depuis une source | ≥ 5 échecs en 60 s |
| Bourrage d'identifiants (credential stuffing) / pulvérisation | un mot de passe essayé sur beaucoup de comptes | une IP, ≥ 10 comptes différents en 10 min |
| Connexion après échecs | succès juste après une rafale d'échecs | compromission probable |
| Voyage impossible | deux connexions éloignées géographiquement en peu de temps | Lyon puis Sydney 20 min plus tard |
| Heures inhabituelles | activité hors des horaires normaux du compte | 3 h du matin |
| Élévation de privilèges | un compte reçoit des droits administrateur | événement role_change |
Intégrité des journaux : la chaîne de hachés
Pour détecter la modification ou la suppression de lignes, on chaîne les enregistrements : chaque ligne inclut le haché de la précédente. Modifier une ligne casse toutes les suivantes.
import hashlib, json
def ajouter(chaine, evenement):
precedent = chaine[-1]["hash"] if chaine else "0" * 64
corps = json.dumps(evenement, sort_keys=True)
h = hashlib.sha256((precedent + corps).encode()).hexdigest()
chaine.append({"evenement": evenement, "precedent": precedent, "hash": h})
def verifier(chaine):
precedent = "0" * 64
for i, ligne in enumerate(chaine):
attendu = hashlib.sha256((precedent + json.dumps(ligne["evenement"], sort_keys=True)).encode()).hexdigest()
if ligne["precedent"] != precedent or ligne["hash"] != attendu:
return i
precedent = ligne["hash"]
return None
(Pour être résistant à un attaquant qui contrôle la machine, on envoie aussi régulièrement le dernier haché à un système externe.)
Réponse à incident (modèle NIST)
flowchart LR
A["1. Préparation"] --> B["2. Détection et analyse"]
B --> C["3. Confinement"]
C --> D["4. Éradication"]
D --> E["5. Récupération"]
E --> F["6. Retour d'expérience"]
F -.-> A
Description du schéma : six étapes en cycle : préparation, détection et analyse, confinement, éradication, récupération, puis retour d'expérience qui améliore la préparation.
| Phase | Objectif | Exemples d'actions |
|---|---|---|
| Préparation | être prêt avant | plan, rôles, contacts, journaux, sauvegardes testées, exercices |
| Détection et analyse | savoir qu'il y a un incident et son ampleur | alertes, triage, chronologie |
| Confinement | stopper la propagation | isoler la machine, révoquer des sessions et des clés, bloquer une IP |
| Éradication | supprimer la cause | corriger la faille, supprimer les accès de l'attaquant |
| Récupération | revenir en service sûr | restaurer, surveiller de près |
| Retour d'expérience | apprendre | post-mortem sans blâme, actions correctives |
Règles d'or : conserver les preuves (copies, hachés) avant de nettoyer ; communiquer (interne, clients, autorités selon les obligations légales, par exemple notification d'une violation de données personnelles sous 72 h en Europe) ; documenter chaque action avec l'heure.
Mesures
| Indicateur | Sens |
|---|---|
| MTTD (mean time to detect) | délai moyen entre le début d'un incident et sa détection |
| MTTR (mean time to respond/recover) | délai moyen de réponse ou de rétablissement |
| Taux de faux positifs | alertes inutiles (fatigue) |
Le post-mortem sans blâme
Un bon post-mortem décrit la chronologie, les causes (techniques et organisationnelles), ce qui a bien marché, ce qui a manqué, et des actions avec responsables et dates. Il cherche à comprendre le système, pas à désigner un coupable.
🧠 Astuce : écris ton plan de réponse avant d'en avoir besoin, avec les numéros de téléphone, et exerce-le une fois par an.
🔍 Exemple pas à pas
Problème : analyser un journal d'authentification pour détecter force brute, pulvérisation et voyage impossible, et protéger le journal contre la falsification.
import hashlib, json, math, re
from collections import defaultdict
from datetime import datetime, timedelta
JOURNAL = '''
2025-03-10T02:14:01Z LOGIN_FAIL user=ada ip=203.0.113.9 geo=FR
2025-03-10T02:14:05Z LOGIN_FAIL user=ada ip=203.0.113.9 geo=FR
2025-03-10T02:14:09Z LOGIN_FAIL user=ada ip=203.0.113.9 geo=FR
2025-03-10T02:14:13Z LOGIN_FAIL user=ada ip=203.0.113.9 geo=FR
2025-03-10T02:14:17Z LOGIN_FAIL user=ada ip=203.0.113.9 geo=FR
2025-03-10T02:14:21Z LOGIN_OK user=ada ip=203.0.113.9 geo=FR
2025-03-10T09:00:00Z LOGIN_OK user=bob ip=198.51.100.4 geo=FR
2025-03-10T09:10:00Z LOGIN_OK user=bob ip=192.0.2.77 geo=AU
2025-03-10T03:00:00Z LOGIN_FAIL user=zoe ip=192.0.2.200 geo=RU
2025-03-10T03:00:03Z LOGIN_FAIL user=eve ip=192.0.2.200 geo=RU
2025-03-10T03:00:06Z LOGIN_FAIL user=sam ip=192.0.2.200 geo=RU
2025-03-10T03:00:09Z LOGIN_FAIL user=cleo ip=192.0.2.200 geo=RU
2025-03-10T03:00:12Z LOGIN_FAIL user=dan ip=192.0.2.200 geo=RU
2025-03-10T03:00:15Z LOGIN_FAIL user=max ip=192.0.2.200 geo=RU
'''
MOTIF = re.compile(r"(\S+) (LOGIN_OK|LOGIN_FAIL)\s+user=(\w+) ip=(\S+) geo=(\w+)")
CENTRES = {"FR": (46.2, 2.2), "AU": (-25.3, 133.8), "RU": (61.5, 105.3)}
def lire(texte):
evts = []
for m in MOTIF.finditer(texte):
evts.append({"t": datetime.strptime(m.group(1), "%Y-%m-%dT%H:%M:%SZ"), "type": m.group(2), "user": m.group(3), "ip": m.group(4), "geo": m.group(5)})
return (evts, key= e: e[])
():
(la1, lo1), (la2, lo2) = ( x: ((math.radians, x)), (a, b))
h = math.sin((la2 - la1) / ) ** + math.cos(la1) * math.cos(la2) * math.sin((lo2 - lo1) / ) **
* * math.asin(math.sqrt(h))
():
alertes = []
echecs = defaultdict()
e evts:
e[] == :
echecs[(e[], e[])].append(e[])
e[] == :
recents = [t t echecs[(e[], e[])] e[] - t <= timedelta(seconds=)]
(recents) >= :
alertes.append((, ))
par_ip = defaultdict()
e evts:
e[] == :
par_ip[e[]][e[]] = e[]
ip, comptes par_ip.items():
temps = (comptes.values())
(comptes) >= temps[-] - temps[] <= timedelta(minutes=):
alertes.append((, ))
derniere = {}
e evts:
e[] == :
e[] derniere:
avant = derniere[e[]]
km, heures = distance_km(CENTRES[avant[]], CENTRES[e[]]), (e[] - avant[]).total_seconds() /
heures > km / heures > :
alertes.append((, ))
derniere[e[]] = e
alertes
niveau, message detecter(lire(JOURNAL)):
()
():
precedent = chaine[-][] chaine *
h = hashlib.sha256((precedent + json.dumps(evenement, sort_keys=)).encode()).hexdigest()
chaine.append({: evenement, : precedent, : h})
():
precedent = *
i, ligne (chaine):
attendu = hashlib.sha256((precedent + json.dumps(ligne[], sort_keys=)).encode()).hexdigest()
ligne[] != precedent ligne[] != attendu:
i
precedent = ligne[]
chaine = []
i ():
ajouter(chaine, {: i, : , : })
verifier(chaine)
chaine[][][] =
verifier(chaine) ==
chaine[]
verifier(chaine)
()
Lecture : trois alertes sont produites automatiquement : la compromission probable du compte de ada (connexion réussie après 5 échecs en moins d'une minute), la pulvérisation depuis 192.0.2.200 (6 comptes en 15 secondes), et le voyage impossible de bob (France puis Australie en 10 minutes). La chaîne de hachés détecte une ligne modifiée ou supprimée.
✍️ À toi, avec aide (10 XP)
Calcule les indicateurs de réponse d'une équipe à partir de 5 incidents fictifs :
| Incident | Début réel | Détecté à | Confiné à | Rétabli à |
|---|---|---|---|---|
| 1 | 08:00 | 08:30 | 09:00 | 12:00 |
| 2 | 22:00 | 06:00 (lendemain) | 06:30 | 10:00 |
| 3 | 14:00 | 14:05 | 14:20 | 15:00 |
| 4 | 03:00 | 15:00 | 15:30 | 18:00 |
| 5 | 10:00 | 10:10 | 10:40 | 11:30 |
Calcule le MTTD (début → détection), le MTTC (détection → confinement), le MTTR (détection → rétablissement), et ressors la cause principale du mauvais résultat global.
💡 Indice 1
Utilise datetime ou convertis les heures en minutes depuis minuit en gérant le lendemain.
💡 Indice 2
L'incident 2 et l'incident 4 ont un très long délai de détection (de nuit).
💡 Indice 3
Moyenne et médiane peuvent diverger fortement : donne les deux.
✅ Réponse
from datetime import datetime
import statistics
def t(h, jour=0):
hh, mm = map(int, h.split(":"))
return jour * 1440 + hh * 60 + mm
INCIDENTS = [
(t("08:00"), t("08:30"), t("09:00"), t("12:00")),
(t("22:00"), t("06:00", 1), t("06:30", 1), t("10:00", 1)),
(t("14:00"), t("14:05"), t("14:20"), t("15:00")),
(t("03:00"), t("15:00"), t("15:30"), t("18:00")),
(t("10:00"), t("10:10"), t("10:40"), t("11:30")),
]
mttd = [d - s for s, d, c, r in INCIDENTS]
mttc = [c - d for s, d, c, r in INCIDENTS]
mttr = [r - d for s, d, c, r in INCIDENTS]
for nom, v in (("MTTD", mttd), ("MTTC", mttc), ("MTTR", mttr)):
()
🚀 À toi, en solo (20 XP)
Moteur de règles de détection. Écris un petit moteur dans lequel chaque règle est une fonction qui reçoit la liste des événements (dictionnaires) et renvoie des alertes. Implémente au moins 6 règles :
- force brute suivie d'un succès ;
- pulvérisation de mots de passe (une IP, plusieurs comptes) ;
- voyage impossible ;
- connexion à une heure inhabituelle pour ce compte (apprise sur l'historique : plage où le compte se connecte 95 % du temps) ;
- élévation de privilèges (événement
ROLE_CHANGEvers admin sans ticket associé) ; - export massif (nombre de lignes exportées > moyenne + 3 écarts-types du compte).
Génère un jeu de 2 000 événements normaux (graine fixée) dans lequel tu injectes 5 scénarios d'attaque, puis mesure rappel (attaques trouvées) et précision (alertes réellement justifiées).
✅ Pistes de correction
import random, statistics
from collections import defaultdict
from datetime import datetime, timedelta
def generer(graine=1):
rng = random.Random(graine)
debut = datetime(2025, 3, 1, 8, 0, 0)
evts = []
for i in range(2000):
user = f"u{rng.randint(1, 40)}"
t = debut + timedelta(days=rng.randint(0, 9), hours=rng.randint(0, 9), minutes=rng.randint(0, 59)) # horaires de bureau 8h-17h
evts.append({"t": t, "type": rng.choices(["LOGIN_OK", "LOGIN_FAIL", "EXPORT"], [80, 5, 15])[0], "user": user,
"ip": f"10.0.{rng.randint(0, 5)}.{rng.randint(1, 50)}", : , : rng.randint(, )})
evts, debut
():
attaques = ()
t0 = debut + timedelta(days=, hours=)
k ():
evts.append({: t0 + timedelta(seconds= * k), : , : , : , : , : })
evts.append({: t0 + timedelta(seconds=), : , : , : , : , : })
attaques.add()
k ():
evts.append({: t0 + timedelta(minutes=, seconds= * k), : , : , : , : , : })
attaques.add()
evts.append({: debut + timedelta(days=, hours=-), : , : , : , : , : })
attaques.add()
evts.append({: debut + timedelta(days=, hours=), : , : , : , : , : , : , : })
attaques.add()
evts.append({: debut + timedelta(days=, hours=), : , : , : , : , : })
attaques.add()
(evts, key= e: e[]), attaques
():
res, echecs = [], defaultdict()
e evts:
k = (e[], e[])
e[] == :
echecs[k].append(e[])
e[] == ( t echecs[k] e[] - t <= timedelta(seconds=)) >= :
res.append((, e[]))
res
():
par_ip = defaultdict()
e evts:
e[] == :
par_ip[e[]][e[]] = e[]
[(, ip) ip, c par_ip.items() (c) >= (c.values()) - (c.values()) <= timedelta(minutes=)]
():
heures = defaultdict()
e evts:
e[] == :
heures[e[]].append(e[].hour)
res = []
user, hs heures.items():
(hs) < :
h (hs):
hs.count(h) == (h < h > ):
res.append((, user))
res
():
[(, e[]) e evts e[] == e.get() == e.get()]
():
par_user = defaultdict()
e evts:
e[] == :
par_user[e[]].append(e[])
res = []
user, valeurs par_user.items():
(valeurs) < :
pic = (valeurs)
reste = (valeurs)
reste.remove(pic)
m, s = statistics.mean(reste), statistics.pstdev(reste)
pic > m + * s:
res.append((, user))
res
evts, debut = generer()
evts, attaques = injecter(evts, debut)
alertes = ()
regle (regle_force_brute, regle_pulverisation, regle_heure, regle_elevation, regle_export):
alertes |= (regle(evts))
trouvees = {nom nom, _ alertes}
rappel = (trouvees & attaques) / (attaques)
precision = ([a a alertes a[] attaques]) / (alertes)
()
rappel ==
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Journaux sans IP ni identifiant | Impossible d'enquêter | Qui, quoi, quand, d'où, résultat |
| Journaliser des secrets | Les journaux deviennent un trésor pour l'attaquant | Masquer avant d'écrire |
| Alertes trop nombreuses | La fatigue d'alerte les fait ignorer | Régler seuils, mesurer faux positifs |
| Nettoyer avant de collecter les preuves | Enquête et obligations légales compromises | Copier, hacher, puis éradiquer |
🐉 Mini-boss (40 XP)
Exercice de réponse à incident : « le compte du formateur ». Simule un incident de bout en bout :
- génère un journal de 3 jours avec activité normale et un scénario d'attaque en 5 étapes (hameçonnage → connexion depuis une IP étrangère → élévation de privilèges → export massif → suppression de journaux) ;
- écris l'analyseur qui reconstruit la chronologie de l'incident (événements corrélés par compte et IP) ;
- utilise la chaîne de hachés pour montrer que des lignes ont été supprimées ;
- écris le plan de réponse exécutable : confinement (révoquer les sessions, bloquer l'IP, désactiver le compte), éradication (réinitialiser les secrets), récupération, avec un journal horodaté des actions ;
- calcule MTTD/MTTR de ta simulation ;
- rédige un post-mortem sans blâme d'une page : chronologie, causes, ce qui a marché, ce qui a manqué, 5 actions avec responsable et échéance.
✅ Pistes de correction
Un bon travail : une classe Incident qui accumule (horodatage, acteur, action); la chronologie est obtenue en filtrant les événements du compte et de l'IP suspectés et en les triant; la détection de suppression utilise verifier() qui renvoie l'indice de la première rupture dans la chaîne; le plan de réponse est une liste d'actions Action(nom, fonction, preuve) exécutées dans l'ordre (conserver les preuves → confiner → éradiquer → récupérer) avec journalisation; le post-mortem sépare faits et interprétations, cite des causes organisationnelles (aucune alerte de nuit, MFA absent sur les comptes de formateurs) et propose des actions mesurables (MFA obligatoire sous 30 jours, journaux envoyés vers un stockage externe en écriture seule, exercice semestriel).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Un journal de sécurité utile contient :
- A. uniquement les erreurs du programme
- B. qui, quoi, quand, d'où et le résultat
- C. les mots de passe des utilisateurs
2. Une chaîne de hachés sert à :
- A. chiffrer les journaux
- B. compresser les journaux
- C. détecter la modification ou la suppression de lignes d'un journal
3. La phase de confinement vise à :
- A. stopper la propagation de l'incident
- B. restaurer les sauvegardes
- C. rédiger le rapport
4. 🔁 Révision mission 08 : Le durcissement d'un système consiste à :
- A. ajouter des fonctions
- B. réduire la surface d'attaque et sécuriser la configuration
- C. ralentir le serveur
5. 🔁 Révision mission 08 : Dans un conteneur, on évite :
- A. d'utiliser une image minimale
- B. d'épingler les versions
- C. d'exécuter le processus en root
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Si ton compte principal était compromis cette nuit, comment le saurais-tu, et qui préviendrais-tu ?
- Pourquoi un post-mortem « sans blâme » produit-il de meilleures améliorations qu'une recherche de coupable ?
🎒 À retenir
- Journaliser qui, quoi, quand, d'où, résultat — sans secrets.
- Détecter : force brute, pulvérisation, voyage impossible, exfiltration.
- Chaîne de hachés pour l'intégrité des journaux.
- Réponse : préparation, détection, confinement, éradication, récupération, retour d'expérience.
- MTTD, MTTR, post-mortem sans blâme.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Veilleur et répondant
← Mission 08 — Sécurité réseau et système · Mission 10 — Audit et rapport de sécurité →
HEF-100 — Sécurité

