Chapitre 5: Authentification

Méthodes et techniques sécurisées

Chapitre 5/5 Durée estimée: 3h

Introduction à l'authentification

L'authentification est le processus fondamental qui permet de vérifier l'identité d'une entité (utilisateur, système, application) avant de lui accorder l'accès à des ressources protégées. Dans un environnement numérique où les cyberattaques évoluent constamment en sophistication, l'authentification constitue la première ligne de défense des systèmes d'information et représente un pilier essentiel de toute architecture de sécurité.

Distinction clé : Authentification vs Autorisation

Deux concepts souvent confondus mais fondamentalement différents :

Authentification : Processus de vérification de l'identité d'une entité ("Qui êtes-vous?")
Autorisation : Processus de vérification des droits d'accès d'une entité authentifiée ("Que pouvez-vous faire?")

Ces deux processus sont généralement séquentiels : l'authentification précède l'autorisation, et ensemble ils forment le contrôle d'accès.

5.1. Principes fondamentaux de l'authentification

L'authentification repose sur plusieurs principes fondamentaux qui déterminent sa robustesse et son efficacité dans la protection des systèmes d'information :

Les facteurs d'authentification

Le modèle classique distingue trois catégories principales de facteurs d'authentification, chacune exploitant une caractéristique différente de l'utilisateur ou de son environnement :

Ce que l'on sait

(knowledge factor)

Information mémorisée par l'utilisateur et normalement connue uniquement de lui.

Exemples :

Mots de passe
Codes PIN
Phrases secrètes
Réponses à des questions de sécurité
Motifs de déverrouillage

Avantage : Facile à implémenter
Inconvénient : Vulnérable aux attaques par force brute, par dictionnaire, et au phishing

Ce que l'on possède

(possession factor)

Objet physique ou virtuel détenu uniquement par l'utilisateur légitime.

Exemples :

Cartes à puce (smartcards)
Tokens physiques (RSA SecurID, YubiKey)
Tokens logiciels (Google Authenticator)
Téléphones mobiles (SMS, applications)
Certificats numériques

Avantage : Plus difficile à compromettre qu'un mot de passe
Inconvénient : Peut être perdu, volé ou cloné

Ce que l'on est

(inherence factor)

Caractéristiques physiques ou comportementales intrinsèques à l'utilisateur.

Exemples :

Empreintes digitales
Reconnaissance faciale
Scan d'iris ou de rétine
Reconnaissance vocale
ADN

Avantage : Difficile à falsifier, ne peut être oublié
Inconvénient : Questions de confidentialité, taux d'erreur variables

Avec l'évolution des technologies et des menaces, le modèle classique à trois facteurs s'est enrichi pour inclure deux catégories supplémentaires qui offrent des couches additionnelles de sécurité :

Où l'on est

(location factor)

Informations sur la localisation physique ou logique de l'utilisateur.

Exemples :

Géolocalisation GPS
Adresse IP et sa géolocalisation
Réseau Wi-Fi connecté
Proximité de balises (Bluetooth, NFC)

Ce facteur est particulièrement utile pour détecter les tentatives d'accès anormales, comme une connexion depuis un pays où l'utilisateur ne se trouve habituellement pas.

Ce que l'on fait

(behavior factor)

Schémas comportementaux uniques qui peuvent être analysés pour identifier un utilisateur.

Exemples :

Dynamique de frappe au clavier
Modèles de navigation
Habitudes d'utilisation des applications
Schémas temporels d'activité
Façon de tenir et d'utiliser un smartphone

Cette approche, souvent appelée "authentification comportementale" ou "biométrie comportementale", permet une vérification continue et non intrusive de l'identité pendant toute la session.

La combinaison judicieuse de ces différents facteurs permet de construire des systèmes d'authentification robustes adaptés aux besoins spécifiques de sécurité de chaque contexte.

Authentification à facteurs multiples (MFA)

L'authentification à facteurs multiples (Multi-Factor Authentication) implique l'utilisation d'au moins deux facteurs d'authentification distincts. Elle renforce considérablement la sécurité car même si un facteur est compromis, l'attaquant doit encore compromettre les autres facteurs.

Exemple d'authentification à deux facteurs

L'utilisateur saisit son nom d'utilisateur et son mot de passe (ce qu'il sait)
Un code à usage unique (OTP) est envoyé à son téléphone mobile (ce qu'il possède)
L'utilisateur saisit ce code pour compléter l'authentification

Cette combinaison est bien plus difficile à contourner qu'un simple mot de passe, car un attaquant devrait à la fois connaître le mot de passe et avoir accès au téléphone de l'utilisateur.

Principe du moindre privilège

Ce principe stipule qu'un utilisateur, un système ou une application ne devrait avoir accès qu'aux ressources strictement nécessaires à l'accomplissement de ses tâches. Il est fondamental pour limiter l'impact potentiel d'une compromission.

5.2. Authentification par mot de passe

Malgré ses limites bien connues, l'authentification par mot de passe reste la méthode la plus répandue. Voici les bonnes pratiques pour la renforcer :

Stockage sécurisé des mots de passe

Les mots de passe ne doivent jamais être stockés en clair dans une base de données. On utilise à la place :

Hachage : Transformation irréversible du mot de passe
Salage : Ajout d'une chaîne aléatoire unique à chaque mot de passe avant le hachage
Fonctions de dérivation de clé adaptées : Comme Argon2, bcrypt ou PBKDF2

$$storedValue = KDF(password, salt, iterations, memorySize)$$

Où KDF est une fonction de dérivation de clé, avec des paramètres ajustables pour la force de calcul et la mémoire requises.

Politiques de mots de passe

Les recommandations modernes du NIST (SP 800-63B) suggèrent :

Longueur minimale de 8 caractères (idéalement 12+)
Vérification contre des listes de mots de passe compromis
Permettre tous les caractères imprimables, y compris les espaces
Éviter les exigences de complexité arbitraires (qui peuvent réduire l'entropie)
Ne pas imposer de changements périodiques sans raison

Attaques sur les mots de passe

Type d'attaque	Description	Contremesures
Force brute	Essai méthodique de toutes les combinaisons possibles	Mots de passe longs, limitation des tentatives, délais croissants
Dictionnaire	Essai de mots communs et variations	Éviter les mots communs, phrases de passe
Rainbow tables	Tables précalculées de hashes	Salage unique pour chaque mot de passe
Phishing	Manipulation de l'utilisateur pour révéler son mot de passe	Formation des utilisateurs, authentification multifacteur
Keylogging	Capture des frappes au clavier	Authentification multifacteur, vérification de l'intégrité du système

5.3. Authentification par certificats et infrastructures à clés publiques (PKI)

Principes de la PKI

Une infrastructure à clés publiques (PKI) fournit un cadre pour gérer les certificats numériques et les paires de clés publiques/privées. Elle permet la création, la distribution, la gestion, le stockage, la révocation et l'utilisation de certificats numériques.

Composants d'une PKI

Autorité de Certification (CA) : Entité de confiance qui émet les certificats numériques
Autorité d'Enregistrement (RA) : Vérifie l'identité des demandeurs avant l'émission des certificats
Répertoire de certificats : Stocke et publie les certificats et les listes de révocation
Liste de Révocation de Certificats (CRL) : Liste des certificats révoqués
Protocole OCSP (Online Certificate Status Protocol) : Vérifie le statut d'un certificat en temps réel

Structure d'un certificat X.509

Le format X.509 est le standard pour les certificats numériques. Un certificat contient typiquement :

Version du certificat
Numéro de série
Algorithme de signature
Émetteur (CA)
Période de validité
Sujet (entité identifiée)
Informations de clé publique
Extensions (usages, contraintes, etc.)
Signature de la CA

Utilisation de certificats pour l'authentification

Les certificats clients peuvent être utilisés pour authentifier les utilisateurs auprès des services. Ce processus implique généralement :

Le serveur demande un certificat client
Le client présente son certificat
Le serveur vérifie que le certificat est signé par une CA de confiance
Le serveur vérifie que le certificat n'est pas révoqué
Le serveur envoie un défi au client pour prouver qu'il possède la clé privée correspondante
Le client signe le défi avec sa clé privée
Le serveur vérifie la signature avec la clé publique du certificat

5.4. Protocoles et mécanismes d'authentification

SAML (Security Assertion Markup Language)

SAML est un standard basé sur XML qui permet l'échange d'informations d'authentification et d'autorisation entre domaines de sécurité, notamment pour le Single Sign-On (SSO) entre domaines.

OAuth 2.0

OAuth 2.0 est un framework d'autorisation qui permet à une application d'accéder à des ressources pour le compte d'un utilisateur sans nécessiter que l'utilisateur partage ses identifiants avec l'application.

Les principaux flux OAuth 2.0 sont :

Authorization Code Flow
Implicit Flow
Resource Owner Password Credentials Flow
Client Credentials Flow

OpenID Connect

OpenID Connect est une couche d'identité simple construite sur OAuth 2.0. Elle permet aux clients de vérifier l'identité d'un utilisateur et d'obtenir des informations de profil de base.

FIDO (Fast IDentity Online)

FIDO est un ensemble de standards ouverts pour l'authentification sans mot de passe, visant à réduire la dépendance aux mots de passe. Il comprend plusieurs spécifications :

FIDO U2F (Universal 2nd Factor) : Pour l'authentification à deux facteurs
FIDO UAF (Universal Authentication Framework) : Pour l'authentification sans mot de passe
FIDO2 : Comprend les spécifications WebAuthn du W3C et le protocole CTAP (Client to Authenticator Protocol)

Kerberos

Kerberos est un protocole d'authentification réseau qui utilise la cryptographie à clé symétrique pour fournir une authentification forte sur des réseaux non sécurisés. Il est basé sur le concept de tickets et inclut un serveur d'authentification tiers de confiance (KDC - Key Distribution Center).

Exemple simplifié de flux Kerberos

L'utilisateur s'authentifie auprès du service d'authentification (AS) et reçoit un Ticket-Granting Ticket (TGT)
L'utilisateur utilise le TGT pour demander un ticket de service au Ticket-Granting Service (TGS)
L'utilisateur présente le ticket de service au serveur de ressources
Le serveur de ressources valide le ticket et accorde l'accès

Ce processus permet une authentification unique (SSO) dans un environnement d'entreprise sans transmettre de mots de passe en clair sur le réseau.

5.5. Authentification biométrique

L'authentification biométrique utilise des caractéristiques physiques ou comportementales uniques pour identifier les individus.

Types de biométrie

Empreintes digitales : L'une des méthodes les plus courantes, basée sur les motifs uniques des empreintes
Reconnaissance faciale : Analyse des traits du visage
Iris/rétine : Analyse des motifs complexes de l'iris ou des vaisseaux sanguins de la rétine
Reconnaissance vocale : Analyse des caractéristiques de la voix
Dynamique de frappe : Analyse de la façon dont un utilisateur tape sur un clavier
Géométrie de la main : Mesure de la forme et taille de la main

Métriques d'évaluation des systèmes biométriques

Taux de fausse acceptation (FAR) : Probabilité qu'un imposteur soit accepté
Taux de faux rejet (FRR) : Probabilité qu'un utilisateur légitime soit rejeté
Taux d'égale erreur (EER) : Point où FAR = FRR, utilisé pour comparer différents systèmes
Taux d'échec à l'inscription (FTE) : Pourcentage d'utilisateurs qui ne peuvent pas s'inscrire dans le système

Défis et limitations

Les caractéristiques biométriques ne peuvent pas être facilement modifiées en cas de compromission
Risques de faux positifs et faux négatifs
Préoccupations en matière de vie privée et de protection des données
Possibilité d'attaques par présentation (utilisation de répliques)
Coût des capteurs et des infrastructures

Bonnes pratiques

Utiliser la biométrie dans le cadre d'une authentification multifacteur
Stocker des modèles biométriques, pas des images brutes
Implémenter des mécanismes de détection de vivacité (liveness detection)
Chiffrer les données biométriques à chaque étape
Respecter les réglementations sur la protection des données

5.6. Considérations de sécurité et meilleures pratiques

Défense en profondeur

Une approche de défense en profondeur implique l'utilisation de plusieurs couches de sécurité pour protéger les systèmes. Dans le contexte de l'authentification, cela pourrait inclure :

Authentification multifacteur
Segmentation réseau
Contrôles d'accès basés sur les rôles (RBAC)
Journalisation et surveillance des événements d'authentification
Gestion des sessions

Gestion des sessions

Une fois l'authentification réussie, la gestion sécurisée des sessions est cruciale :

Utiliser des identifiants de session aléatoires et imprévisibles
Régénérer les identifiants de session après l'authentification
Définir des délais d'expiration appropriés
Implémenter des mécanismes de déconnexion efficaces
Utiliser des cookies sécurisés (HttpOnly, Secure, SameSite)

Réponse aux incidents d'authentification

Un plan de réponse aux incidents devrait inclure des procédures pour :

Détection des tentatives d'authentification suspectes
Verrouillage automatique des comptes après plusieurs échecs
Notification des utilisateurs en cas d'activité inhabituelle
Réinitialisation sécurisée des informations d'authentification
Analyse post-incident pour améliorer les mécanismes de défense

Authentification dans les architectures Zero Trust

Le modèle Zero Trust part du principe que les menaces existent à la fois à l'intérieur et à l'extérieur du réseau traditionnel. Dans ce modèle :

L'authentification est requise pour chaque accès à une ressource
Le principe de moindre privilège est strictement appliqué
L'authentification continue ou adaptative peut être utilisée
L'autorisation est basée sur plusieurs facteurs (identité, appareil, contexte)

Implications réglementaires et conformité

Les mécanismes d'authentification doivent souvent se conformer à diverses réglementations et normes :

RGPD (Règlement Général sur la Protection des Données)
PCI DSS (Payment Card Industry Data Security Standard)
HIPAA (Health Insurance Portability and Accountability Act)
SOC 2 (Service Organization Control 2)
ISO/IEC 27001

Ces réglementations peuvent imposer des exigences spécifiques en matière d'authentification, comme l'utilisation de l'authentification multifacteur pour certains types d'accès ou la documentation des processus d'authentification.

Chapitre précédent: Cryptographie quantique Exercices sur l'authentification

Exercices associés

Mettez en pratique les concepts de ce chapitre avec les exercices dédiés.

Accéder aux exercices

Exemple de code (Python)


import os
import hashlib
import hmac
import base64
import time
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import padding

# Exemple de stockage de mot de passe sécurisé avec Argon2
def hash_password_argon2(password):
    try:
        from argon2 import PasswordHasher
        ph = PasswordHasher()
        return ph.hash(password)
    except ImportError:
        print("Argon2 non disponible, utilisation de PBKDF2 comme alternative")
        return hash_password_pbkdf2(password)

# Alternative avec PBKDF2
def hash_password_pbkdf2(password):
    salt = os.urandom(16)
    iterations = 100000
    dk = hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, iterations)
    return base64.b64encode(salt + dk).decode('utf-8')

# Vérification du mot de passe avec PBKDF2
def verify_password_pbkdf2(stored_password, provided_password):
    decoded = base64.b64decode(stored_password.encode('utf-8'))
    salt = decoded[:16]
    stored_dk = decoded[16:]
    computed_dk = hashlib.pbkdf2_hmac('sha256', provided_password.encode('utf-8'), salt, 100000)
    return hmac.compare_digest(stored_dk, computed_dk)

# Génération d'un OTP basé sur le temps (TOTP)
def generate_totp(secret, time_step=30, digits=6):
    # Convertir le secret en bytes s'il ne l'est pas déjà
    if isinstance(secret, str):
        secret = base64.b32decode(secret)
    
    # Calculer le compteur basé sur le temps
    counter = int(time.time() // time_step)
    counter_bytes = counter.to_bytes(8, byteorder='big')
    
    # Calculer le HMAC-SHA1
    h = hmac.new(secret, counter_bytes, hashlib.sha1).digest()
    
    # Extraction dynamique d'un nombre à partir du HMAC
    offset = h[-1] & 0x0F
    code = ((h[offset] & 0x7F) << 24 |
            (h[offset + 1] & 0xFF) << 16 |
            (h[offset + 2] & 0xFF) << 8 |
            (h[offset + 3] & 0xFF))
    
    # Réduire au nombre de chiffres souhaité
    code = code % (10 ** digits)
    
    # Formater avec des zéros en tête si nécessaire
    return '{0:0{1}d}'.format(code, digits)

# Exemple d'utilisation de certificats X.509 pour l'authentification
def verify_certificate_signature(cert_pem, ca_cert_pem):
    # Charger le certificat et le certificat de l'autorité de certification
    cert = x509.load_pem_x509_certificate(cert_pem, default_backend())
    ca_cert = x509.load_pem_x509_certificate(ca_cert_pem, default_backend())
    
    # Vérifier la signature du certificat
    try:
        ca_public_key = ca_cert.public_key()
        ca_public_key.verify(
            cert.signature,
            cert.tbs_certificate_bytes,
            padding.PKCS1v15(),
            cert.signature_hash_algorithm
        )
        return True
    except Exception as e:
        print(f"Erreur de vérification: {e}")
        return False

# Démonstration
if __name__ == "__main__":
    # Exemple de stockage de mot de passe
    password = "MotDePasse_Complexe!123"
    hashed_password = hash_password_pbkdf2(password)
    print(f"Mot de passe haché: {hashed_password}")
    
    # Vérification du mot de passe
    is_valid = verify_password_pbkdf2(hashed_password, password)
    print(f"Mot de passe valide: {is_valid}")
    
    # Exemple de génération TOTP
    # Dans un vrai système, ce secret serait partagé avec l'app d'authentification de l'utilisateur
    totp_secret = base64.b32encode(os.urandom(10))
    print(f"Secret TOTP: {totp_secret.decode('utf-8')}")
    totp_code = generate_totp(totp_secret)
    print(f"Code TOTP actuel: {totp_code}")

Chapitre 5: Authentification

Introduction à l'authentification

Distinction clé : Authentification vs Autorisation

5.1. Principes fondamentaux de l'authentification

Les facteurs d'authentification

Ce que l'on sait

Ce que l'on possède

Ce que l'on est

Où l'on est

Ce que l'on fait

Authentification à facteurs multiples (MFA)

Exemple d'authentification à deux facteurs

Principe du moindre privilège

5.2. Authentification par mot de passe

Stockage sécurisé des mots de passe

Politiques de mots de passe

Attaques sur les mots de passe

5.3. Authentification par certificats et infrastructures à clés publiques (PKI)

Principes de la PKI

Composants d'une PKI

Structure d'un certificat X.509

Utilisation de certificats pour l'authentification

5.4. Protocoles et mécanismes d'authentification

SAML (Security Assertion Markup Language)

OAuth 2.0

OpenID Connect

FIDO (Fast IDentity Online)

Kerberos

Exemple simplifié de flux Kerberos

5.5. Authentification biométrique

Types de biométrie

Métriques d'évaluation des systèmes biométriques

Défis et limitations

Bonnes pratiques

5.6. Considérations de sécurité et meilleures pratiques

Défense en profondeur

Gestion des sessions

Réponse aux incidents d'authentification

Authentification dans les architectures Zero Trust

Implications réglementaires et conformité

Dans ce chapitre

Exercices associés

Exemple de code (Python)