Qui es-tu ? Peux-tu le prouver ? Et as-tu le droit de faire ça ? Trois questions, trois mécanismes.
⏱️ Durée : environ 100 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Gardien des accès
🎬 L'histoire
Un utilisateur de HashBox se plaint : « Quelqu'un a lu mes résultats ! » L'enquête montre que l'application vérifie bien le mot de passe… mais qu'ensuite, pour afficher un profil, elle fait confiance à l'identifiant dans l'URL : /profil?id=42. En changeant 42 en 43, on voit le profil de quelqu'un d'autre.
« Tu as résolu l'authentification, dit Sam, mais oublié l'autorisation. Savoir qui est là ne dit pas ce qu'il peut faire. »
Tu apprends à distinguer identification, authentification et autorisation, à stocker des mots de passe correctement, à implémenter le second facteur et les contrôles d'accès (RBAC/ABAC).
🎯 Ta mission
À la fin, je serai capable de :
- distinguer identification, authentification et autorisation
- stocker et vérifier un mot de passe avec un hachage lent et salé
- implémenter un mot de passe à usage unique temporel (TOTP) et des jetons de session
- implémenter RBAC et ABAC et repérer les contrôles d'accès manquants (IDOR)
- expliquer le flux OAuth 2.0 / OpenID Connect et ses pièges
🧩 Défi d'échauffement (5 XP)
À l'entrée d'un immeuble de bureaux : (1) tu dis ton nom à l'accueil, (2) on vérifie ta pièce d'identité, (3) on te remet un badge qui ouvre seulement certains étages. Quelle étape est l'identification, laquelle l'authentification, laquelle l'autorisation ? Que se passe-t-il si (2) est bien faite mais que le badge ouvre tous les étages ? Et si on vérifie les badges seulement au rez-de-chaussée ?
💡 Le concept
Trois notions à ne pas confondre
| Notion | Question | Exemple |
|---|---|---|
| Identification | qui prétends-tu être ? | saisir un identifiant |
| Authentification | peux-tu le prouver ? | mot de passe, code à usage unique, clé de sécurité |
| Autorisation | as-tu le droit de faire cette action sur cette ressource ? | « cet utilisateur peut lire ce cours » |
Une erreur classique : bien authentifier, mal autoriser (mission 7 : le contrôle d'accès défaillant est la première catégorie de l'OWASP Top 10).
Les facteurs d'authentification
| Facteur | Principe | Exemples |
|---|---|---|
| Connaissance | ce que je sais | mot de passe, code PIN |
| Possession | ce que j'ai | téléphone (TOTP), clé de sécurité (FIDO2/WebAuthn), carte |
| Inhérence | ce que je suis | empreinte, visage |
L'authentification multifacteur (MFA) combine au moins deux facteurs de familles différentes. Les clés FIDO2/WebAuthn résistent à l'hameçonnage (elles lient la preuve au site légitime).
Stocker les mots de passe
Jamais en clair, jamais chiffrés de façon réversible, jamais avec un hachage rapide seul (md5, sha256). On utilise une fonction de dérivation de clé lente : argon2id, scrypt, bcrypt ou PBKDF2, avec :
- un sel (salt) aléatoire unique par utilisateur ;
- un coût ajustable (temps, mémoire) ;
- une comparaison en temps constant.
import hashlib, hmac, os
def hacher(mot_de_passe, sel=None):
sel = sel or os.urandom(16)
h = hashlib.scrypt(mot_de_passe.encode(), salt=sel, n=2**14, r=8, p=1, dklen=32)
return sel, h
def verifier(mot_de_passe, sel, h):
_, candidat = hacher(mot_de_passe, sel)
return hmac.compare_digest(candidat, h)
sel, h = hacher("correct-cheval-pile-agrafe")
print(verifier("correct-cheval-pile-agrafe", sel, h), verifier("autre", sel, h)) # True False
Le second facteur : TOTP
Le TOTP (Time-based One-Time Password, RFC 6238) génère un code à 6 chiffres qui change toutes les 30 secondes, à partir d'un secret partagé et de l'heure.
import hashlib, hmac, struct
def totp(secret, instant, pas=30, chiffres=6):
compteur = struct.pack(">Q", int(instant) // pas)
h = hmac.new(secret, compteur, hashlib.sha1).digest()
decalage = h[-1] & 0x0F
code = (struct.unpack(">I", h[decalage:decalage + 4])[0] & 0x7FFFFFFF) % (10 ** chiffres)
return str(code).zfill(chiffres)
# Vecteur de test de la RFC 6238 (secret ASCII de 20 octets, instant 59 s, 8 chiffres)
print(totp(b"12345678901234567890", 59, chiffres=8)) # 94287082
Sessions et jetons
Après l'authentification, le serveur remet une preuve de session que le client représente à chaque requête : cookie de session (identifiant aléatoire stocké côté serveur) ou jeton signé (JWT). Règles :
- identifiant aléatoire (
secrets.token_urlsafe(32)), jamais prévisible ; - expiration et révocation possibles ;
- cookie
HttpOnly,Secure,SameSite(mission 6) ; - régénérer l'identifiant après la connexion (contre la fixation de session) ;
- un JWT n'est pas chiffré (juste signé) : n'y mets rien de secret, vérifie toujours la signature et l'algorithme attendu.
Autorisation : RBAC et ABAC
| Modèle | Principe | Exemple |
|---|---|---|
| RBAC (Role-Based) | les droits sont attachés à des rôles ; les utilisateurs ont des rôles | formateur peut créer un cours |
| ABAC (Attribute-Based) | une politique évalue des attributs (utilisateur, ressource, contexte) | un formateur modifie ses cours, pendant les heures ouvrées |
| ACL | liste d'autorisations par ressource | ce dossier est lisible par Ada et Bob |
Règles de base : refuser par défaut ; vérifier l'autorisation côté serveur, à chaque requête, sur chaque objet ; ne jamais se fier à un identifiant ou à un rôle fourni par le client.
PERMISSIONS = {
"apprenant": {"cours:lire"},
"formateur": {"cours:lire", "cours:creer", "cours:modifier_les_siens"},
"admin": {"cours:lire", "cours:creer", "cours:modifier", "membre:supprimer"},
}
def autorise(utilisateur, action, ressource=None):
droits = set().union(*(PERMISSIONS.get(r, set()) for r in utilisateur["roles"]))
if action in droits:
return True
if action == "cours:modifier" and "cours:modifier_les_siens" in droits: # contrôle d'attribut (ABAC)
return ressource is not None and ressource["auteur"] == utilisateur["id"]
return False
OAuth 2.0 et OpenID Connect
OAuth 2.0 est un protocole d'autorisation déléguée : une application obtient un jeton d'accès limité pour agir au nom de l'utilisateur, sans connaître son mot de passe. OpenID Connect (OIDC) ajoute une couche d'authentification (un jeton d'identité).
sequenceDiagram
participant U as Utilisateur
participant A as Application
participant S as Serveur d'autorisation
U->>A: « Se connecter avec ... »
A->>S: redirection (client_id, portée, état, PKCE)
S->>U: demande de connexion et de consentement
U->>S: identifiants + accord
S->>A: code d'autorisation (via redirection)
A->>S: code + secret/PKCE
S->>A: jeton d'accès (+ jeton d'identité OIDC)
A->>S: API avec jeton d'accès
Description du schéma : l'application redirige l'utilisateur vers le serveur d'autorisation, qui l'authentifie et recueille son consentement, puis renvoie un code. L'application échange ce code contre des jetons et appelle ensuite les API avec le jeton d'accès.
Pièges classiques : ne pas vérifier le paramètre state (CSRF), accepter n'importe quelle URI de redirection, ne pas utiliser PKCE pour les applications publiques, confondre jeton d'accès et preuve d'identité, stocker les jetons en clair.
🧠 Astuce : l'authentification se fait une fois par session ; l'autorisation se fait à chaque requête.
🔍 Exemple pas à pas
Problème : un petit système de connexion avec hachage, TOTP, session et contrôle d'accès, puis la correction d'un défaut d'autorisation (IDOR).
import hashlib, hmac, os, secrets, struct, time
# ---------- mots de passe ----------
def hacher(mot_de_passe, sel=None):
sel = sel or os.urandom(16)
return sel, hashlib.scrypt(mot_de_passe.encode(), salt=sel, n=2**14, r=8, p=1, dklen=32)
def verifier_mdp(mot_de_passe, sel, h):
return hmac.compare_digest(hacher(mot_de_passe, sel)[1], h)
# ---------- TOTP ----------
def totp(secret, instant, pas=30, chiffres=6):
compteur = struct.pack(">Q", int(instant) // pas)
h = hmac.new(secret, compteur, hashlib.sha1).digest()
decalage = h[-1] & 0x0F
code = (struct.unpack(">I", h[decalage:decalage + 4])[0] & 0x7FFFFFFF) % (10 ** chiffres)
return str(code).zfill(chiffres)
assert totp(b"12345678901234567890", 59, chiffres=8) == "94287082" # vecteur de la RFC 6238
assert totp(b"12345678901234567890", 1111111109, chiffres=) ==
():
(hmac.compare_digest(totp(secret, instant + d * ), code) d (-tolerance, tolerance + ))
UTILISATEURS = {}
SESSIONS = {}
():
sel, h = hacher(mot_de_passe)
UTILISATEURS[nom] = {: (UTILISATEURS) + , : nom, : sel, : h,
: os.urandom(), : roles, : }
():
maintenant = maintenant time.time()
u = UTILISATEURS.get(nom)
sel = u[] u *
attendu = u[] u *
ok_mdp = verifier_mdp(mot_de_passe, sel, attendu) u
ok_mdp u[] >= :
u: u[] +=
verifier_totp(u[], code, maintenant):
u[] +=
u[] =
jeton = secrets.token_urlsafe()
SESSIONS[jeton] = {: u[], : maintenant + }
jeton
PERMISSIONS = {: {}, : {}}
():
s = SESSIONS.get(jeton)
s s[] < (maintenant maintenant time.time()):
(u u UTILISATEURS.values() u[] == s[])
():
u = utilisateur_de(jeton, maintenant)
u :
,
droits = ().union(*(PERMISSIONS[r] r u[]))
droits ( droits id_demande == u[]):
,
,
inscrire(, , [])
inscrire(, , [])
inscrire(, , [])
maintenant =
code_ada = totp(UTILISATEURS[][], maintenant)
jeton = connecter(, , code_ada, maintenant)
jeton
connecter(, , code_ada, maintenant)
connecter(, , , maintenant)
connecter(, , , maintenant)
(lire_profil(jeton, , maintenant))
(lire_profil(jeton, , maintenant))
(lire_profil(, , maintenant))
Lecture :
- le mot de passe est haché avec
scrypt+ sel ; la comparaison est en temps constant ; - le second facteur TOTP est vérifié avec une tolérance d'un pas (dérive d'horloge) ;
- un échec renvoie toujours
None, sans dire si c'est le nom, le mot de passe ou le code (pas d'énumération de comptes) ; - après 5 échecs, le compte refuse de nouvelles tentatives (limitation) ;
lire_profilvérifie l'autorisation sur l'objet demandé : changerid=1enid=2n'ouvre rien (c'est la correction du défaut IDOR de l'histoire).
✍️ À toi, avec aide (10 XP)
Implémente un contrôle d'accès ABAC pour les cours de HashBox :
- un formateur peut modifier un cours qu'il a créé ;
- un formateur peut lire tous les cours ;
- un apprenant peut lire un cours publié s'il y est inscrit ;
- un admin peut tout faire, sauf supprimer son propre compte.
Écris autorise(utilisateur, action, ressource) avec ces règles, refus par défaut, puis 12 tests (cas autorisés et refusés).
💡 Indice 1
Représente un utilisateur par {id, roles, cours_inscrits} et un cours par {id, auteur, publie}.
💡 Indice 2
Commence par return False en fin de fonction : le refus est la valeur par défaut.
💡 Indice 3
Teste explicitement les cas limites : cours non publié, formateur qui modifie le cours d'un autre, admin qui se supprime.
✅ Réponse
def autorise(u, action, r=None):
roles = set(u["roles"])
if "admin" in roles:
if action == "membre:supprimer" and r is not None and r["id"] == u["id"]:
return False # règle d'exception
return True
if action == "cours:lire":
if "formateur" in roles:
return True
if "apprenant" in roles and r is not None:
return r["publie"] and r["id"] in u["cours_inscrits"]
if action == "cours:modifier" and "formateur" in roles r :
r[] == u[]
ada = {: , : [], : {}}
sam = {: , : [], : ()}
root = {: , : [], : ()}
c_publie = {: , : , : }
c_brouillon = {: , : , : }
c_autre = {: , : , : }
autorise(ada, , c_publie)
autorise(ada, , c_brouillon)
autorise(ada, , c_autre)
autorise(ada, , c_publie)
autorise(sam, , c_brouillon)
autorise(sam, , c_publie)
autorise(sam, , c_autre)
autorise(root, , c_autre)
autorise(root, , {: })
autorise(root, , {: })
autorise(ada, , c_publie)
autorise({: , : [], : ()}, , c_publie)
()
🚀 À toi, en solo (20 XP)
Sessions robustes. Écris un gestionnaire de sessions GestionnaireSessions avec :
creer(id_utilisateur, maintenant): jeton aléatoire de 256 bits ;- expiration absolue (8 h) et par inactivité (30 min) ;
valider(jeton, maintenant)qui renvoie l'utilisateur ouNoneet prolonge l'inactivité ;regenerer(jeton, maintenant): nouveau jeton, ancien invalidé (à appeler après connexion pour empêcher la fixation de session) ;revoquer_toutes(id_utilisateur)(après changement de mot de passe) ;- stockage du haché du jeton (SHA-256) et non du jeton lui-même (si la table fuit, les jetons restent inutilisables).
Écris 12 tests, dont l'expiration, la régénération et la révocation.
✅ Pistes de correction
import hashlib, secrets
class GestionnaireSessions:
ABSOLUE, INACTIVITE = 8 * 3600, 30 * 60
def __init__(self):
self._sessions = {} # haché du jeton -> données
@staticmethod
def _h(jeton):
return hashlib.sha256(jeton.encode()).hexdigest()
def creer(self, id_utilisateur, maintenant):
jeton = secrets.token_urlsafe(32)
self._sessions[self._h(jeton)] = {"id": id_utilisateur, "cree": maintenant, "vu": maintenant}
return jeton
def valider(self, jeton, maintenant):
cle = self._h(jeton)
s = self._sessions.get(cle)
if s is None:
return None
if maintenant - s["cree"] > self.ABSOLUE or maintenant - s["vu"] > .INACTIVITE:
._sessions[cle]
s[] = maintenant
s[]
():
id_u = .valider(jeton, maintenant)
id_u :
._sessions[._h(jeton)]
.creer(id_u, maintenant)
():
cle [c c, s ._sessions.items() s[] == id_utilisateur]:
._sessions[cle]
g = GestionnaireSessions()
t0 =
j = g.creer(, t0)
(j) >= g.valider(j, t0 + ) ==
g.valider(, t0)
g.valider(j, t0 + + * ) ==
g.valider(j, t0 + + * + * )
j2 = g.creer(, t0)
k (, ):
g.valider(j2, t0 + k * * )
g.valider(j2, t0 + * * )
j3 = g.creer(, t0)
nouveau = g.regenerer(j3, t0 + )
nouveau != j3 g.valider(j3, t0 + ) g.valider(nouveau, t0 + ) ==
a, b = g.creer(, t0), g.creer(, t0)
g.revoquer_toutes()
g.valider(a, t0 + ) g.valider(b, t0 + )
((k) == k g._sessions)
()
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| Authentifier sans autoriser l'objet | IDOR : id=42 → id=43 | Vérifier le droit sur chaque ressource, côté serveur |
| Hachage rapide pour les mots de passe | Casse en quelques heures sur GPU | scrypt/argon2id/bcrypt avec sel et coût |
| Messages d'échec différents | Énumération des comptes (« cet utilisateur n'existe pas ») | Même message et même temps pour tous les échecs |
| Faire confiance au rôle envoyé par le client | Élévation de privilèges triviale | Les rôles viennent du serveur (session) |
🐉 Mini-boss (40 XP)
Module d'identité de HashBox. Assemble un module complet testé :
- inscription avec politique de mot de passe (longueur ≥ 12, refus d'une liste de mots de passe courants, vérification de non-contenu du nom d'utilisateur) ;
- connexion avec hachage
scrypt, limitation des tentatives (verrouillage temporaire croissant) et message d'échec unique ; - MFA TOTP avec codes de secours à usage unique (hachés) ;
- sessions robustes (mission précédente) et déconnexion partout ;
- autorisation par rôle (RBAC) et par attribut (ABAC) avec refus par défaut ;
- journal d'audit (qui, quoi, quand, résultat) sans jamais écrire de mot de passe ni de jeton ;
- 30 tests, dont : énumération de comptes impossible (temps et message), IDOR bloqué, rejeu d'un code de secours refusé, fixation de session neutralisée.
✅ Pistes de correction
Un bon module : un fichier identite.py avec des classes Comptes, Sessions, Politique; verrouillage calculé par min(2 ** (echecs - 3), 900) secondes après 3 échecs; les codes de secours sont 8 codes de 10 caractères générés avec secrets, stockés sous forme de hachés SHA-256 et supprimés à l'usage; le journal d'audit enregistre des événements structurés ({"evt": "connexion", "utilisateur": id, "ok": False, "ip": "..."}) en ôtant tout champ sensible; la fonction autorise garde la forme « refus par défaut ». Les tests mesurent aussi le temps de réponse pour un utilisateur inconnu et un utilisateur connu avec mauvais mot de passe (même ordre de grandeur) grâce au calcul d'un hachage factice.
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. L'authentification vérifie :
- A. ce que tu as le droit de faire
- B. que tu es bien qui tu prétends
- C. la vitesse de ta connexion
2. Pour stocker un mot de passe, on utilise :
- A. un chiffrement réversible
- B. un hachage rapide seul
- C. une fonction de dérivation lente avec un sel
3. Un défaut IDOR est :
- A. un contrôle d'accès manquant sur l'objet demandé
- B. une faille de chiffrement
- C. un mauvais mot de passe
4. 🔁 Révision mission 02 : STRIDE est :
- A. un algorithme de chiffrement
- B. une méthode de classification des menaces en six catégories
- C. un protocole réseau
5. 🔁 Révision mission 02 : Les menaces se concentrent particulièrement :
- A. au centre des bases de données
- B. dans les commentaires du code
- C. aux frontières de confiance
✅ Réponses
- B.
- C.
- A.
- B.
- C.
🪞 Je réfléchis (10 XP)
- Combien de tes comptes importants utilisent un second facteur ? Lesquels devraient en avoir un d'urgence ?
- Quel contrôle d'accès t'a déjà surpris (un document partagé trop largement, un accès resté après un changement de poste) ?
🎒 À retenir
- Identification, authentification, autorisation : trois choses distinctes.
- Mots de passe : scrypt/argon2id/bcrypt + sel, comparaison en temps constant.
- MFA : TOTP, clés FIDO2.
- Autorisation côté serveur, sur chaque objet, refus par défaut.
- OAuth 2.0 / OIDC : délégation et identité, avec
stateet PKCE.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Gardien des accès
← Mission 02 — La modélisation des menaces · Mission 04 — Cryptographie appliquée →
HEF-100 — Sécurité

