Sécuriser un service | Med Learning

Leçon 1

La politique d'utilisation des mots de passe

Tableau: Ce que recommande le résumé

Règle du résumé	Détail
mots de passe complexes	combiner majuscules, minuscules, chiffres et caractères spéciaux ; ne pas contenir le nom ou l'identifiant
longueur minimale	8 caractères au minimum ; 14 est la meilleure norme
phrases de passe	au moins 15 caractères pour les comptes administrateurs : plus faciles à retenir, plus difficiles à deviner
historique	interdire la réutilisation des 5 derniers mots de passe
âge minimal	garder un mot de passe 3 à 7 jours avant de pouvoir le changer (pour empêcher de revenir tout de suite à l'ancien)
âge maximal	changement obligatoire tous les 90 jours (mots de passe) ou 180 jours (phrases de passe)
rappels	e-mail avant l'expiration

Recommandation actuelle	Pourquoi
longueur : au moins 15 caractères si le mot de passe est le seul facteur, au moins 8 s'il est combiné à un second facteur	la longueur est ce qui rend un mot de passe difficile à casser
accepter des mots de passe longs (au moins 64 caractères), les espaces et tous les caractères Unicode	pour permettre les phrases de passe
pas de règles de composition imposées (« une majuscule, un chiffre, un caractère spécial »)	elles produisent des mots de passe prévisibles
pas de changement périodique obligatoire ; changement seulement en cas de soupçon de compromission	le changement forcé affaiblit les mots de passe
refuser les mots de passe courants ou déjà fuités (liste noire)	`123456`, `azerty`, `motdepasse` sont essayés en premier

Mot de passe testé (identifiant `sara.alaoui`)	Résultat
`Sara2005`	refusé : trop court
`motdepasse123`	refusé : dans la liste noire
`sara.alaoui-2026!`	refusé : contient l'identifiant
`Maroc-12345678`	refusé : suite `1234`
`girafe tajine orage violon`	accepté

Vidéo · À regarder

How NOT to Store Passwords! - Computerphile

Computerphile · YouTube

Regarde de 5:28 à 7:131 min 45 s

Ouvrir sur YouTube à 5:28

Leçon 2

La gestion des rôles d'utilisateurs

Les trois principes du RBAC
attribution de rôle	un utilisateur ne peut exercer une permission que s'il s'est vu attribuer un rôle
autorisation du rôle	le rôle actif de l'utilisateur doit lui avoir été autorisé
autorisation de la permission	l'utilisateur ne peut exercer une permission que si elle est accordée à son rôle actif

Avantages du RBAC

Leçon 3

Les chiffrements symétrique et asymétrique

Je veux…	J'utilise…	Qui peut défaire l'opération ?	Propriété obtenue
envoyer un message secret à Karim	la clé publique de Karim pour chiffrer	seulement Karim, avec sa clé privée	confidentialité
signer un document pour prouver que c'est moi	ma clé privée pour signer	tout le monde peut vérifier avec ma clé publique

Leçon 4

La notion de clé privée et de clé publique

	Cryptographie à clé secrète (symétrique)	Cryptographie à clé publique (asymétrique)
nombre de clés	une clé secrète, la même pour chiffrer et déchiffrer	deux clés : une publique, une privée
partage	l'expéditeur et le destinataire doivent partager la même clé	aucun partage de secret : on publie la clé publique
ce qui est secret	la clé unique

Travaux pratiques

TP fil rouge · Rôles et connexion

Exercices

Exercice 7.1

Choisis la bonne réponse

1Selon le NIST (2025), un mot de passe utilisé comme seul facteur doit faire au moins…
2Les recommandations actuelles sur le changement périodique obligatoire :
3Dans le RBAC, les permissions sont attribuées…
4Pour envoyer un message confidentiel à Karim, je chiffre avec…
5Pour signer un document, j'utilise…
6Le chiffrement des données dans une connexion HTTPS établie est…
7Le code HTTP renvoyé à un utilisateur connecté mais non autorisé est…
8La version de TLS la plus récente est…

0/8 répondues

Exercice 7.2

Accepté ou refusé ?

Exercice 7.3

La matrice des rôles

L'essentiel du chapitre

À retenir

Politique de mots de passe du résumé : complexité, 8 à 14 caractères, phrases de passe, historique, âge minimal et maximal (90 jours).
Recommandations actuelles (NIST 2025) : longueur (15 seul, 8 avec MFA), jusqu'à 64 caractères et plus, pas de composition imposée, pas de changement périodique, liste noire, limitation des tentatives, gestionnaires, MFA.
RBAC : utilisateurs → rôles → permissions ; trois principes ; tables roles, permissions, role_permission, utilisateur_role ; contrôle côté serveur à chaque requête (403).
Asymétrique : chiffrer avec la clé publique du destinataire (confidentialité) ; signer avec sa clé privée (authenticité, intégrité, non-répudiation).
Hybride : asymétrique (ou Diffie-Hellman) pour la clé de session, AES pour les données ; TLS 1.2/1.3 (SSL obsolète), certificat signé par une autorité de certification.
Clé secrète (symétrique) ≠ clé privée (moitié secrète d'une paire) ; la clé privée ne quitte jamais son propriétaire.

Appel (Sara = stagiaire, M. Idrissi = formateur, Admin = admin)	Résultat
`peut($pdo, Sara, 'notes.saisir')`	`false`
`peut($pdo, Idrissi, 'notes.saisir')`	`true`
`peut($pdo, Idrissi, 'stagiaires.gerer')`	`false`
`peut($pdo, Admin, 'utilisateurs.gerer')`	`true`

Outil	Usage
GnuPG (GPG)	outil en ligne de commande, libre, qui chiffre et signe fichiers et e-mails, avec un système complet de gestion des clés et l'accès aux annuaires de clés publiques
AES Crypt	chiffrement de fichiers en AES, intégré à l'explorateur Windows ou en ligne de commande sous Linux
Encrypto	glisser un fichier, choisir un mot de passe, envoyer : gratuit pour Windows et Mac
7-Zip	archive `.7z` ou `.zip` chiffrée en AES-256 avec un mot de passe
OpenSSL	la boîte à outils cryptographique utilisée par la plupart des serveurs (et par PHP)

verifier_mdp.php

php

<?php
function verifierMotDePasse(string $mdp, string $email, array $interdits): array
{
    $erreurs = [];
    $longueur = mb_strlen($mdp);
    if ($longueur < 12) {
        $erreurs[] = 'Au moins 12 caractères (une phrase de passe est idéale).';
    }
    if ($longueur > 128) {
        $erreurs[] = 'Au plus 128 caractères.';
    }
    if (in_array(mb_strtolower($mdp), $interdits, true)) {
        $erreurs[] = 'Ce mot de passe est trop courant ou a déjà fuité.';
    }
    $identifiant = mb_strtolower(strstr($email, '@', true) ?: $email);
    if ($identifiant !== '' && str_contains(mb_strtolower($mdp), $identifiant)) {
        $erreurs[] = 'Le mot de passe ne doit pas contenir ton identifiant.';
    }
    if (preg_match('/(.)\1{3,}/u', $mdp) || preg_match('/(0123|1234|2345|3456|4567|5678|6789|abcd|azer|qwer)/i', $mdp)) {
        $erreurs[] = 'Évite les suites et les répétitions (1234, aaaa, azerty).';
    }
    return $erreurs;   // tableau vide : mot de passe accepté
}

// en production, la liste noire contient des milliers de mots de passe fuités, chargés depuis un fichier
$interdits = ['123456789012', 'motdepasse123', 'azertyuiop12', 'password1234'];

limitation des tentatives (5 échecs en 15 minutes)

php

<?php
// CREATE TABLE tentatives_connexion (id INT AUTO_INCREMENT PRIMARY KEY,
//   email VARCHAR(100) NOT NULL, ip VARCHAR(45) NOT NULL, moment INT NOT NULL);

function tropDeTentatives(PDO $pdo, string $email, string $ip, int $max = 5, int $fenetre = 900): bool
{
    $stmt = $pdo->prepare('SELECT COUNT(*) FROM tentatives_connexion WHERE (email = ? OR ip = ?) AND moment > ?');
    $stmt->execute([$email, $ip, time() - $fenetre]);
    return (int) $stmt->fetchColumn() >= $max;
}

function noterEchec(PDO $pdo, string $email, string $ip): void
{
    $pdo->prepare('INSERT INTO tentatives_connexion (email, ip, moment) VALUES (?, ?, ?)')
        ->execute([$email, $ip, time()]);
}

// dans connexion.php, AVANT de vérifier le mot de passe :
$ip = $_SERVER['REMOTE_ADDR'];
if (tropDeTentatives($pdo, $email, $ip)) {
    http_response_code(429);                     // 429 Too Many Requests
    exit('Trop de tentatives. Réessaie dans 15 minutes.');
}
// … si password_verify échoue : noterEchec($pdo, $email, $ip);

Le RBAC : des utilisateurs, des rôles, des permissions

txt

  utilisateurs          rôles                 permissions
  Sara        ──────►  stagiaire   ──────►  voir ses notes
  M. Idrissi  ──────►  formateur   ──────►  saisir des notes
  Admin       ──────►  admin       ──┬───►  saisir des notes
                                     ├───►  gérer les stagiaires
                                     └───►  gérer les utilisateurs

rbac.sql

sql

CREATE TABLE roles (
  id INT AUTO_INCREMENT PRIMARY KEY,
  nom VARCHAR(30) NOT NULL UNIQUE
);
CREATE TABLE permissions (
  id INT AUTO_INCREMENT PRIMARY KEY,
  code VARCHAR(50) NOT NULL UNIQUE          -- 'notes.saisir', 'stagiaires.gerer'…
);
CREATE TABLE role_permission (              -- association plusieurs-à-plusieurs (M106)
  role_id INT NOT NULL,
  permission_id INT NOT NULL,
  PRIMARY KEY (role_id, permission_id),
  FOREIGN KEY (role_id) REFERENCES roles(id),
  FOREIGN KEY (permission_id) REFERENCES permissions(id)
);
CREATE TABLE utilisateur_role (
  utilisateur_id INT NOT NULL,
  role_id INT NOT NULL,
  PRIMARY KEY (utilisateur_id, role_id),
  FOREIGN KEY (utilisateur_id) REFERENCES utilisateurs(id),
  FOREIGN KEY (role_id) REFERENCES roles(id)
);

INSERT INTO roles (id, nom) VALUES (1, 'stagiaire'), (2, 'formateur'), (3, 'admin');
INSERT INTO permissions (id, code) VALUES
  (1, 'notes.voir_les_siennes'), (2, 'notes.saisir'), (3, 'stagiaires.gerer'), (4, 'utilisateurs.gerer');
INSERT INTO role_permission VALUES (1, 1), (2, 2), (3, 2), (3, 3), (3, 4);

autorisation.php

php

<?php
function peut(PDO $pdo, int $utilisateurId, string $permission): bool
{
    $stmt = $pdo->prepare(
        'SELECT 1 FROM utilisateur_role ur
         JOIN role_permission rp ON rp.role_id = ur.role_id
         JOIN permissions p ON p.id = rp.permission_id
         WHERE ur.utilisateur_id = ? AND p.code = ?
         LIMIT 1'
    );
    $stmt->execute([$utilisateurId, $permission]);
    return (bool) $stmt->fetchColumn();
}

function exiger(PDO $pdo, string $permission): void
{
    $id = $_SESSION['utilisateur_id'] ?? null;
    if ($id === null) {
        header('Location: connexion.php');
        exit;
    }
    if (!peut($pdo, $id, $permission)) {
        http_response_code(403);                 // 403 Forbidden : connecté, mais pas autorisé
        exit('Accès refusé.');
    }
}

// en haut de saisir_notes.php :
exiger($pdo, 'notes.saisir');

Générer une paire de clés RSA

bash

openssl genpkey -algorithm RSA -pkeyopt rsa_keygen_bits:3072 -out cle_privee.pem   # la clé privée : à protéger
openssl pkey -in cle_privee.pem -pubout -out cle_publique.pem                      # la clé publique : à diffuser

Chiffrer pour le propriétaire de la clé publique, puis déchiffrer

bash

echo "Note finale M108 : 17,5" > message.txt
openssl pkeyutl -encrypt -pubin -inkey cle_publique.pem -pkeyopt rsa_padding_mode:oaep \
        -in message.txt -out message.chiffre             # 384 octets illisibles
openssl pkeyutl -decrypt -inkey cle_privee.pem -pkeyopt rsa_padding_mode:oaep -in message.chiffre
# Note finale M108 : 17,5

Signer avec la clé privée, vérifier avec la clé publique

bash

openssl dgst -sha256 -sign cle_privee.pem -out message.sig message.txt
openssl dgst -sha256 -verify cle_publique.pem -signature message.sig message.txt
# Verified OK
echo "Note finale M108 : 19,5" > message.txt             # quelqu'un modifie la note…
openssl dgst -sha256 -verify cle_publique.pem -signature message.sig message.txt
# Verification failure                                    …la signature ne correspond plus

efficacité opérationnelle	moins de tâches manuelles : on ajoute, modifie ou retire des rôles plutôt que des droits individuels
conformité	on démontre facilement qui a accès à quoi (loi 09-08, RGPD, normes du secteur bancaire et de la santé)
sécurité	moins de droits inutiles, donc moins de dégâts si un compte est compromis