Trouver des failles ne sert à rien si personne ne les comprend ni ne les corrige. Un bon rapport transforme un constat en décisions.
⏱️ Durée : environ 110 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Auditeur·rice de sécurité
🎬 L'histoire
La direction de HashBox veut un état des lieux avant l'ouverture à de nouveaux clients. Maya demande à Kodi : « Fais-moi un rapport de sécurité. Je veux savoir ce qui est grave, ce qu'il faut corriger d'abord, et combien ça coûte. »
« Un audit, ce n'est pas une liste de failles, dit Sam. C'est une histoire : ce que j'ai regardé, ce que j'ai trouvé, ce que ça signifie pour l'entreprise, et ce qu'on fait. »
Dans cette dernière mission, tu mènes un audit complet : analyse statique automatisée, évaluation de la gravité (CVSS), rapport professionnel et plan de remédiation.
🎯 Ta mission
À la fin, je serai capable de :
- préparer et cadrer un audit (périmètre, règles d'engagement, autorisation)
- écrire un analyseur statique simple de code Python avec le module
ast - calculer un score de gravité CVSS v3.1 pour une vulnérabilité
- rédiger un rapport structuré destiné à des publics techniques et non techniques
- bâtir un plan de remédiation priorisé et vérifier les corrections (retest)
🧩 Défi d'échauffement (5 XP)
Un inspecteur visite un restaurant. Son compte rendu doit être utile à trois lecteurs : le patron (que dois-je faire en premier, quel risque pour mon activité ?), le cuisinier (quel geste précis corriger ?) et l'administration (est-ce conforme ?). Écris les trois éléments minimaux de chaque partie du rapport. Pourquoi une simple liste de 80 défauts est-elle inutilisable ?
💡 Le concept
Les types d'évaluation
| Type | Objectif | Méthode |
|---|---|---|
| Revue de code | trouver des failles dans le code | lecture, analyse statique (SAST) |
| Analyse de dépendances | composants vulnérables | outils de composition logicielle (SCA) |
| Test d'intrusion | exploiter les failles dans un cadre autorisé | tests manuels et outils |
| Évaluation de configuration | écarts de durcissement | audits de conformité |
| Revue d'architecture / modèle de menaces | failles de conception | ateliers, DFD, STRIDE |
| Exercice d'équipe rouge/bleue | tester détection et réponse | simulation d'adversaire |
Cadrer un audit
Avant de commencer :
- Autorisation écrite du propriétaire du système (sans elle, c'est une infraction) ;
- Périmètre : quoi est inclus, quoi est exclu ;
- Règles d'engagement : horaires, techniques permises, données sensibles, que faire si on trouve un incident réel ;
- Contacts et canal sûr pour signaler une faille critique immédiatement ;
- Livrables et calendrier.
L'analyse statique du code (SAST)
Un analyseur statique lit le code sans l'exécuter et repère des motifs dangereux. En Python, le module ast donne accès à l'arbre syntaxique (voir HEF-090) ; on y cherche par exemple :
| Motif | Risque |
|---|---|
eval, exec | exécution de code arbitraire |
pickle.loads, yaml.load sans SafeLoader | désérialisation dangereuse |
subprocess.*(…, shell=True) | injection de commande |
.execute(f"…"), .execute("…" + x), .execute("…" % x) | injection SQL |
hashlib.md5, hashlib.sha1 | hachage faible |
random.* pour des jetons ou secrets | aléa prévisible |
| , |
L'analyse statique produit des faux positifs et des faux négatifs ; elle complète, mais ne remplace pas, la revue humaine et les tests.
Évaluer la gravité : CVSS
Le CVSS (Common Vulnerability Scoring System) v3.1 donne un score de 0 à 10 à partir de métriques de base :
| Métrique | Valeurs |
|---|---|
| AV — vecteur d'attaque | Réseau (N), Adjacent (A), Local (L), Physique (P) |
| AC — complexité | Basse (L), Haute (H) |
| PR — privilèges requis | Aucun (N), Bas (L), Haut (H) |
| UI — interaction utilisateur | Aucune (N), Requise (R) |
| C / I / A — impact sur confidentialité / intégrité / disponibilité | Haut (H), Bas (L), Aucun (N) |
| Score | Gravité |
|---|---|
| 0,0 | aucune |
| 0,1 – 3,9 | basse |
| 4,0 – 6,9 | moyenne |
| 7,0 – 8,9 | haute |
| 9,0 – 10,0 | critique |
Le CVSS mesure la gravité technique, pas le risque pour ton entreprise : une faille 9,8 sur une machine isolée et sans données peut compter moins qu'une faille 6,5 sur ta base clients. On combine donc avec le contexte (exposition, valeur de l'actif, exploitation connue).
Le rapport
| Section | Public | Contenu |
|---|---|---|
| Résumé exécutif | direction | situation globale, risques majeurs en langage clair, décisions demandées |
| Périmètre et méthode | tous | ce qui a été testé, comment, limites |
| Synthèse des constats | direction, responsables | tableau par gravité, tendances |
| Détail des constats | techniciens | description, preuve, impact, gravité, recommandation |
| Plan de remédiation | responsables | priorités, responsables, échéances, effort |
| Annexes | techniciens | détails techniques, données brutes |
Écrire un bon constat
Chaque constat contient :
- un titre précis (« Injection SQL dans la recherche de cours ») ;
- la gravité et le vecteur CVSS ;
- la description et l'emplacement (fichier, ligne, URL) ;
- la preuve reproductible (sans publier de données réelles) ;
- l'impact pour l'entreprise ;
- la recommandation concrète et vérifiable ;
- des références (catégorie OWASP, CWE).
Prioriser la remédiation
Critères : gravité, exploitabilité, exposition, valeur de l'actif, effort de correction. Une règle utile : traiter d'abord ce qui est grave, facile à exploiter et exposé, ainsi que les corrections rapides à fort effet (« quick wins »).
Vérifier : le retest
Un constat n'est clos qu'après un retest : on rejoue l'attaque, et on vérifie qu'elle échoue ; on ajoute le test de régression automatisé.
Divulgation responsable
Si tu trouves une faille chez un tiers : tu ne l'exploites pas au-delà du minimum, tu contactes le propriétaire par le canal de sécurité (security.txt, programme de bug bounty), tu laisses un délai raisonnable pour corriger et tu ne publies pas de détails exploitables avant correction.
🧠 Astuce : mesure la qualité d'un rapport à ce qu'il déclenche : si la direction sait quoi décider et si les développeurs savent quoi corriger, il est réussi.
🔍 Exemple pas à pas
Problème : analyseur statique, score CVSS, et génération d'un rapport.
import ast, math
# ---------- 1. Analyseur statique (SAST) ----------
SOURCE = '''
import hashlib, pickle, random, subprocess, sqlite3, requests
API_KEY = "sk_live_1234567890abcdef"
def jeton():
return "".join(random.choice("abcdef0123456789") for _ in range(16))
def hacher(mdp):
return hashlib.md5(mdp.encode()).hexdigest()
def recherche(bd, terme):
return bd.execute("SELECT * FROM cours WHERE titre LIKE '%" + terme + "%'").fetchall()
def lire(nom):
return subprocess.run("cat " + nom, shell=True)
def charger(octets):
return pickle.loads(octets)
def appeler(url):
return requests.get(url, verify=False)
def calcul(expression):
return eval(expression)
'''
def nom_appel(n):
f = n.func
if isinstance(f, ast.Attribute) and isinstance(f.value, ast.Name):
return f"{f.value.id}.{f.attr}"
if isinstance(f, ast.Name):
return f.id
return ""
def construit_dynamique(n): # concaténation, f-string ou formatage %
return isinstance(n, (ast.JoinedStr, ast.BinOp))
def analyser(source):
arbre = ast.parse(source)
constats = []
sensibles = [f for f in ast.walk(arbre) if isinstance(f, ast.FunctionDef) and any(m in f.name m (, , ))]
():
constats.append({: n.lineno, : titre, : gravite, : owasp, : reco})
n ast.walk(arbre):
(n, ast.Assign) (n.value, ast.Constant) (n.value.value, ):
cible n.targets:
(cible, ast.Name) (m cible..lower() m (, , , , )) (n.value.value) >= :
ajouter(n, , , , )
(n, ast.Call):
nom = nom_appel(n)
nom (, ):
ajouter(n, , , , )
nom (, ):
ajouter(n, , , , )
nom.startswith() (k.arg == (k.value, ast.Constant) k.value.value k n.keywords):
ajouter(n, , , , )
nom (, ):
ajouter(n, , , , )
nom.endswith() n.args construit_dynamique(n.args[]):
ajouter(n, , , , )
(k.arg == (k.value, ast.Constant) k.value.value k n.keywords):
ajouter(n, , , , )
nom.startswith() (f.lineno <= n.lineno <= f.end_lineno f sensibles):
ajouter(n, , , , )
(constats, key= c: c[])
c analyser(SOURCE):
()
AV = {: , : , : , : }
AC = {: , : }
PR = {: , : , : }
UI = {: , : }
CIA = {: , : , : }
():
entier = (x * )
entier / entier % == (math.floor(entier / ) + ) /
():
m = (p.split() p vecteur.split()[:])
iss = - ( - CIA[m[]]) * ( - CIA[m[]]) * ( - CIA[m[]])
impact = * iss
exploitabilite = * AV[m[]] * AC[m[]] * PR[m[]] * UI[m[]]
impact <= :
arrondi_haut((impact + exploitabilite, ))
cvss() ==
cvss() ==
cvss() ==
():
score == score < score < score <
(cvss(), gravite())
Lecture :
- l'analyseur trouve huit problèmes dans un code de 25 lignes : secret en dur, jeton avec
random, MD5, SQL concaténé,shell=True,pickle,verify=False,eval; - chaque constat porte sa gravité, sa catégorie OWASP et une recommandation ;
- le calcul CVSS reproduit les valeurs de référence (9,8 pour une exécution de code distante sans authentification ; 6,5 pour une faille réseau à impact limité) ;
- l'outil est un auxiliaire : il prépare la revue humaine, il ne la remplace pas.
✍️ À toi, avec aide (10 XP)
Calcule et interprète le score CVSS (avec la fonction cvss de l'exemple) pour ces trois vulnérabilités, puis dis laquelle tu corriges en premier dans le contexte de HashBox (application publique, base de données clients) :
- Injection SQL sur la recherche publique, sans authentification :
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N. - XSS stocké dans les commentaires, nécessitant qu'un utilisateur ouvre la page :
AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N. - Mot de passe administrateur par défaut sur une console accessible seulement depuis le réseau interne :
AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H.
💡 Indice 1
Utilise la fonction cvss de l'exemple.
💡 Indice 2
Pense à l'exposition : une faille sur une page publique est atteignable par tous.
💡 Indice 3
Une faille interne n'est pas à ignorer : elle devient grave si un attaquant entre dans le réseau.
✅ Réponse
# (fonctions cvss et gravite de l'exemple)
for i, v in enumerate(["CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N",
"CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:U/C:L/I:L/A:N",
"CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H"], 1):
s = cvss(v)
print(i, s, gravite(s))
Résultats : 1 → 9,1 (critique), 2 → 4,6 (moyenne), 3 → 8,8 (haute).
Ordre dans le contexte de HashBox : 1 d'abord (critique, exposée à tout internet, sans authentification, accès à la base clients) ; ensuite 3 (haute, mais limitée au réseau interne : correction rapide et peu coûteuse : changer le mot de passe) — c'est un « quick win » à faire le jour même ; puis 2 (moyenne : XSS stocké, dont l'impact réel dépend du contenu des sessions et des CSP). Le score CVSS donne la gravité technique ; l'exposition et la valeur de l'actif décident de l'ordre réel.
🚀 À toi, en solo (20 XP)
Générateur de rapport. Écris generer_rapport(constats, contexte) qui produit un rapport Markdown à partir d'une liste de constats {id, titre, vecteur_cvss, description, emplacement, preuve, recommandation, owasp, effort_jours, exposition} :
- résumé exécutif généré automatiquement : nombre de constats par gravité, les 3 risques majeurs en une phrase simple chacun, une recommandation de décision ;
- tableau de synthèse trié par gravité puis score ;
- détail de chaque constat avec le vecteur et le score calculé (fonction
cvss) ; - plan de remédiation priorisé par
score × exposition / effortavec trois horizons (sous 72 h, ce mois-ci, ce trimestre) ; - teste avec 8 constats inventés et vérifie que le rapport contient chaque section et que l'ordre de priorité est cohérent.
✅ Pistes de correction
# (fonctions cvss et gravite de l'exemple)
from collections import Counter
EXPOSITION = {"internet": 1.0, "partenaires": 0.6, "interne": 0.3}
def priorite(c):
return cvss(c["vecteur_cvss"]) * EXPOSITION[c["exposition"]] / max(c["effort_jours"], 0.5)
def horizon(c):
s = cvss(c["vecteur_cvss"]) * EXPOSITION[c["exposition"]]
return "sous 72 h" if s >= 8 else "ce mois-ci" if s >= 4 else "ce trimestre"
def generer_rapport(constats, contexte):
for c in constats:
c["score"], c["gravite"] = cvss(c["vecteur_cvss"]), gravite(cvss(c["vecteur_cvss"]))
ordre = ["critique", "haute", "moyenne", "basse"]
nb = Counter(c[] c constats)
tri = (constats, key= c: (ordre.index(c[]), -c[]))
majeurs = (constats, key=priorite, reverse=)[:]
lignes = [, , ,
+ .join( g ordre) + , ,
]
c majeurs:
lignes.append()
lignes += [, , ,
, , , ]
lignes += [ c tri]
lignes += [, ]
c tri:
lignes += [, , ,
, ,
, , ]
lignes += [, , , , ]
c (constats, key=priorite, reverse=):
lignes.append()
.join(lignes)
CONSTATS = [
(=, titre=, vecteur_cvss=, description=, emplacement=, preuve=, recommandation=, owasp=, effort_jours=, exposition=),
(=, titre=, vecteur_cvss=, description=, emplacement=, preuve=, recommandation=, owasp=, effort_jours=, exposition=),
(=, titre=, vecteur_cvss=, description=, emplacement=, preuve=, recommandation=, owasp=, effort_jours=, exposition=),
(=, titre=, vecteur_cvss=, description=, emplacement=, preuve=, recommandation=, owasp=, effort_jours=, exposition=),
]
rapport = generer_rapport(CONSTATS, {: })
section (, , , ):
section rapport
rapport.index() < rapport.index()
(rapport[:])
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Auditer sans autorisation écrite | Infraction pénale, même avec de bonnes intentions | Périmètre, règles d'engagement et contact signés avant de commencer |
| Livrer une liste brute de failles | Personne ne sait par quoi commencer | Priorisation par gravité, exposition, effort |
| Se fier uniquement au score CVSS | Il ne tient pas compte du contexte | Combiner avec exposition et valeur de l'actif |
| Clore un constat sans retest | On croit corrigé ce qui ne l'est pas | Rejouer l'attaque et ajouter un test automatisé |
🐉 Mini-boss (60 XP)
Audit de sécurité complet de la mini-application HashBox. Prends l'application jouet du boss de la mission 7 (ou écris-en une de 150 lignes) et mène un audit en conditions réelles :
- Cadrage : rédige le périmètre, les règles d'engagement et le plan de test (1 page) ;
- Analyse statique : étends l'analyseur pour couvrir au moins 12 motifs de la mission et exécute-le ;
- Tests dynamiques : écris un jeu d'attaques automatisées (injections, chemin, IDOR, XSS, CSRF, débit) qui s'exécutent contre l'application et enregistrent les réussites ;
- Modèle de menaces : un DFD avec STRIDE, croisé avec les constats ;
- Rapport : généré par ton code (résumé exécutif, synthèse, détail avec CVSS, plan de remédiation priorisé) ;
- Remédiation et retest : corrige les constats critiques et hauts, rejoue toutes les attaques, montre l'avant/après (nombre de constats par gravité) ;
- Retour d'expérience : une page : ce qui a été le plus efficace pour trouver les failles, ce qui t'a échappé, comment l'équipe peut intégrer ces contrôles en continu (intégration continue, pré-commit, revue).
✅ Pistes de correction
Un bon dossier : un document AUDIT.md structuré (cadrage, méthode, limites), un outil audit.py avec les règles statiques et un banc d'attaques dynamiques, un rapport généré (Markdown) avec résumé exécutif compréhensible par une personne non technique, des vecteurs CVSS cohérents (une injection SQL non authentifiée à 9,1 ; une IDOR authentifiée à 6,5), un plan priorisé (par exemple « sous 72 h : injection SQL, secret en dur ; ce mois-ci : XSS, MD5 ; ce trimestre : journalisation »), un tableau avant/après (par exemple 5 critiques/hauts → 0), les tests de régression conservés dans la suite de tests. Le retour d'expérience souligne souvent que l'analyse statique trouve vite les motifs évidents mais que les failles de logique (IDOR, contrôle d'accès) demandent des tests dynamiques et une revue humaine, et propose d'automatiser les attaques en CI.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. Avant un audit ou un test d'intrusion, il faut absolument :
- A. une autorisation écrite et un périmètre défini
- B. un outil à la mode
- C. l'accord de la presse
2. Le score CVSS mesure :
- A. le risque exact pour l'entreprise
- B. la gravité technique d'une vulnérabilité
- C. le coût de correction
3. Un constat d'audit n'est clos qu'après :
- A. un e-mail de confirmation
- B. la fin du trimestre
- C. un retest qui prouve que l'attaque échoue
4. 🔁 Révision mission 09 : Une chaîne de hachés sert à :
- A. détecter la modification ou la suppression de lignes d'un journal
- B. chiffrer les journaux
- C. compresser les journaux
5. 🔁 Révision mission 09 : La phase de confinement vise à :
- A. restaurer les sauvegardes
- B. stopper la propagation de l'incident
- C. rédiger le rapport
✅ Réponses
- A.
- B.
- C.
- A.
- B.
🪞 Je réfléchis (10 XP)
- Qu'est-ce qui te frappe le plus dans l'idée qu'un rapport doit parler à trois publics différents ?
- Quelle habitude de sécurité de ce module vas-tu appliquer dès demain à tes propres projets ou comptes ?
🎒 À retenir
- Cadrer : autorisation écrite, périmètre, règles d'engagement.
- SAST avec
ast: motifs dangereux, faux positifs possibles. - CVSS : gravité technique ; contexte et exposition décident de la priorité.
- Rapport : résumé exécutif, synthèse, détail, plan de remédiation.
- Retest et tests de régression ; divulgation responsable.
flowchart LR
T(["Audit et rapport de sécurité"])
T --> R1["1. Cadrer : autorisation écrite, périmètre, règles d'engagement."]
T --> R2["2. SAST avec ast : motifs dangereux, faux positifs possibles."]
T --> R3["3. CVSS : gravité technique ; contexte et exposition décident de la…"]
T --> R4["4. Rapport : résumé exécutif, synthèse, détail, plan de remédiation."]
T --> R5["5. Retest et tests de régression ; divulgation responsable."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 120 XP · 🏅 Badge Auditeur·rice de sécurité
← Mission 09 — Journalisation, détection et réponse à incident
🎉 Félicitations
Tu as terminé HEF-100 — Sécurité. Tu sais modéliser les menaces, authentifier et autoriser correctement, utiliser la cryptographie sans l'inventer, protéger les secrets, te défendre contre les attaques web et les injections, durcir un système, détecter et répondre à un incident, puis auditer et rapporter.
→ Prochain module : HEF-110 — Tests et qualité
HEF-100 — Sécurité

