- À propos de l'authentification
- Identification, authentification et autorisation
- Les principaux facteurs et méthodes d'authentification
- Fonctionnement d'un système d'authentification
- Protocoles et technologies d'authentification
- Menaces et attaques contre l'authentification
- Implémentation de l'authentification avec Python
- Bonnes pratiques et sécurisation de l'authentification
- À retenir
En cybersécurité, l'authentification constitue l'un des mécanismes fondamentaux de protection des systèmes informatiques. Elle permet de vérifier qu'un utilisateur, un appareil, une application ou un service possède bien l'identité qu'il revendique avant de lui accorder l'accès à certaines ressources.
1. À propos de l'authentification
L'authentification, appelée Authentication en anglais, est le processus permettant de vérifier l'identité déclarée d'une entité à l'aide de preuves appropriées.
Cette entité peut être une personne, un ordinateur, un serveur, une application ou un objet connecté. Les preuves utilisées peuvent notamment être un mot de passe, une clé cryptographique, un authentificateur matériel ou une caractéristique biométrique.
Pourquoi l'authentification est-elle indispensable ?
Sans mécanisme d'authentification approprié, un système ne peut pas établir avec suffisamment de confiance qu'une demande d'accès provient de l'entité autorisée.
L'authentification contribue notamment à :
- Protéger les comptes utilisateurs contre les accès non autorisés.
- Limiter l'usurpation d'identité dans les applications et les réseaux.
- Contrôler l'accès aux services sensibles.
- Protéger les informations confidentielles contre certaines divulgations.
- Renforcer la traçabilité des opérations effectuées.
- Établir la confiance entre certains systèmes communicants.
Exemple d'authentification
Lorsqu'un utilisateur accède à son espace personnel sur une plateforme pédagogique, il peut saisir un identifiant et un mot de passe. Le serveur vérifie alors les informations fournies avant d'établir une session authentifiée.
Dans une application correctement conçue, le serveur ne doit pas conserver les mots de passe en clair : il utilise notamment un mécanisme sécurisé de hachage des mots de passe.
Authentification humaine et authentification machine
L'authentification ne concerne pas uniquement les personnes. Un serveur peut également vérifier l'identité d'un autre serveur ou d'une application à l'aide de certificats numériques, de clés cryptographiques ou d'autres mécanismes adaptés.
| Entité | Exemple de méthode | Contexte |
|---|---|---|
| Utilisateur | Mot de passe et MFA | Connexion à une application Web |
| Administrateur | Clé SSH | Administration d'un serveur |
| Serveur Web | Certificat TLS | Authentification du serveur HTTPS |
| Application | Identité de service ou clé cryptographique | Communication entre services |
| Équipement | Certificat ou mécanisme matériel | Accès à une infrastructure |
2. Identification, authentification et autorisation
Les notions d'identification, d'authentification et d'autorisation sont étroitement liées, mais elles correspondent à des fonctions différentes.
Identification
L'identification consiste à déclarer une identité. Par exemple, un utilisateur saisit son nom de compte ou son adresse électronique.
Cette étape répond à la question : Qui prétendez-vous être ?
Authentification
L'authentification consiste à vérifier les preuves associées à l'identité revendiquée.
Elle répond à la question : Pouvez-vous prouver cette identité ?
Autorisation
L'autorisation consiste à déterminer les opérations qu'une entité authentifiée est autorisée à effectuer.
Elle répond à la question : Qu'avez-vous le droit de faire ?
Traçabilité
La traçabilité consiste à enregistrer les événements et les actions importantes afin de faciliter les audits, les investigations et la détection d'anomalies.
Exemple dans une application pédagogique
Supposons qu'un enseignant se connecte à une plateforme de gestion des notes.
- Il indique son identifiant : c'est l'identification.
- Il fournit une preuve valide de son identité : c'est l'authentification.
- L'application vérifie qu'il peut consulter ou modifier les notes de ses propres classes : c'est l'autorisation.
- L'application enregistre les modifications importantes : c'est la traçabilité.
Une authentification réussie ne signifie donc pas qu'un utilisateur possède automatiquement toutes les permissions du système.
Le modèle AAA
Dans les infrastructures réseau, on utilise souvent le modèle AAA, pour Authentication, Authorization and Accounting.
| Composante | Rôle |
|---|---|
| Authentication | Vérifier l'identité. |
| Authorization | Déterminer les permissions. |
| Accounting | Enregistrer ou comptabiliser les activités et l'utilisation des ressources. |
3. Les principaux facteurs et méthodes d'authentification
Les méthodes d'authentification reposent sur différentes catégories de preuves appelées facteurs d'authentification.
Facteur de connaissance
Ce facteur correspond à quelque chose que l'utilisateur connaît.
- Mot de passe.
- Code PIN.
- Secret mémorisé.
Les mots de passe doivent être suffisamment robustes et protégés contre les tentatives automatisées.
Facteur de possession
Ce facteur correspond à quelque chose que l'utilisateur possède.
- Clé de sécurité matérielle.
- Authentificateur logiciel installé sur un appareil.
- Carte à puce.
- Dispositif cryptographique.
Facteur biométrique
Ce facteur correspond à une caractéristique physique ou comportementale de l'utilisateur.
- Empreinte digitale.
- Reconnaissance faciale.
- Reconnaissance de l'iris.
Les données biométriques sont particulièrement sensibles. Leur utilisation nécessite des mesures de protection adaptées, notamment en matière de confidentialité et de stockage.
Authentification à facteur unique
L'authentification à facteur unique utilise un seul facteur, par exemple un mot de passe.
Authentification multifacteur
L'authentification multifacteur, ou MFA, combine au moins deux facteurs appartenant à des catégories différentes.
Par exemple, un utilisateur peut fournir un mot de passe et utiliser une clé de sécurité matérielle.
Deux mots de passe différents ne constituent pas nécessairement une authentification multifacteur puisqu'ils appartiennent à la même catégorie de connaissance.
Authentification à deux facteurs
L'authentification à deux facteurs, ou 2FA, est une forme de MFA utilisant exactement deux facteurs distincts.
Codes à usage unique
Un OTP, pour One-Time Password, est un code destiné à être utilisé une seule fois ou dans une fenêtre de validité limitée.
Les systèmes TOTP produisent des codes temporaires à partir d'un secret partagé et du temps. Ils peuvent renforcer l'authentification, mais ne garantissent pas à eux seuls une protection contre tous les scénarios de phishing.
Passkeys et FIDO2
Les passkeys utilisent des mécanismes cryptographiques à clé publique, notamment ceux définis par FIDO2 et WebAuthn.
Elles permettent de réduire la dépendance aux mots de passe et offrent une résistance importante au phishing grâce à leur liaison à l'origine du service.
Authentification adaptative
L'authentification adaptative ajuste les vérifications demandées selon le contexte, par exemple le niveau de risque d'une connexion ou la sensibilité de l'opération.
4. Fonctionnement d'un système d'authentification
Un système d'authentification doit vérifier les preuves fournies sans exposer les secrets des utilisateurs et sans accorder de permissions injustifiées.
Étape 1 : création du compte
Lors de l'inscription, l'utilisateur choisit généralement un identifiant et fournit les informations nécessaires à la création du compte.
Étape 2 : enregistrement sécurisé des informations
Lorsqu'un mot de passe est utilisé, il doit être stocké sous forme d'un hachage adapté aux mots de passe, avec un sel aléatoire.
Des algorithmes comme Argon2id, scrypt ou bcrypt peuvent être utilisés selon les exigences du système.
Étape 3 : demande de connexion
L'utilisateur présente son identité et les preuves d'authentification requises.
Étape 4 : vérification des preuves
Le serveur vérifie les preuves reçues en utilisant les mécanismes appropriés. Pour un mot de passe, il vérifie le secret fourni à l'aide de l'algorithme de hachage configuré.
Étape 5 : vérification complémentaire
Si une MFA est activée, une preuve supplémentaire peut être exigée.
Étape 6 : établissement de la session
Après une authentification réussie, l'application peut créer une session authentifiée associée à l'utilisateur.
Les identifiants de session doivent être difficiles à deviner, protégés pendant leur transmission et correctement invalidés lors de la déconnexion ou de leur expiration.
Étape 7 : vérification des autorisations
À chaque opération sensible, le serveur doit vérifier que l'utilisateur possède les permissions nécessaires.
Étape 8 : journalisation
Les événements importants, notamment les connexions réussies ou échouées, peuvent être enregistrés dans des journaux de sécurité.
Ces journaux ne doivent pas contenir de mots de passe ou de secrets d'authentification.
Exemple d'une connexion Web
- L'utilisateur ouvre une page de connexion HTTPS.
- Il saisit son identifiant et son mot de passe.
- Le serveur recherche le compte correspondant.
- Le serveur vérifie le mot de passe à partir du hachage enregistré.
- Une vérification MFA peut être demandée.
- Une session sécurisée est établie.
- Les autorisations sont vérifiées pour chaque ressource protégée.
5. Protocoles et technologies d'authentification
Plusieurs protocoles et technologies permettent de mettre en œuvre l'authentification dans les applications Web, les réseaux et les infrastructures informatiques.
HTTP Basic Authentication
HTTP Basic Authentication est un mécanisme simple dans lequel les identifiants sont transmis sous une forme encodée en Base64. Cet encodage ne constitue pas un chiffrement.
Il doit donc être utilisé uniquement à travers un canal sécurisé, notamment HTTPS, lorsque son emploi est approprié.
LDAP
LDAP, pour Lightweight Directory Access Protocol, permet d'accéder à des services d'annuaire.
Il est notamment utilisé dans certains environnements professionnels pour rechercher des utilisateurs et participer à des mécanismes d'authentification centralisée.
Kerberos
Kerberos est un protocole d'authentification réseau reposant notamment sur des tickets et des mécanismes cryptographiques.
Il est largement utilisé dans des environnements d'entreprise, notamment avec Active Directory.
RADIUS
RADIUS est un protocole utilisé notamment pour centraliser l'authentification, l'autorisation et la comptabilisation des accès réseau.
OAuth 2.0
OAuth 2.0 est principalement un cadre de délégation d'autorisation. Il permet à une application d'obtenir un accès limité à certaines ressources sans recevoir directement le mot de passe de l'utilisateur.
OAuth 2.0 n'est pas, à lui seul, un protocole complet d'authentification des utilisateurs.
OpenID Connect
OpenID Connect, ou OIDC, ajoute une couche d'identité à OAuth 2.0 et permet notamment à une application de vérifier l'identité d'un utilisateur auprès d'un fournisseur d'identité.
SAML
SAML, pour Security Assertion Markup Language, permet notamment de transmettre des assertions d'authentification entre un fournisseur d'identité et un service.
Single Sign-On
Le Single Sign-On, ou SSO, permet à un utilisateur de bénéficier d'une authentification centralisée pour accéder à plusieurs services compatibles.
Certificats numériques
Les certificats numériques permettent notamment d'associer une identité à une clé publique. Ils sont utilisés dans des mécanismes tels que TLS et mTLS.
| Technologie | Usage principal |
|---|---|
| LDAP | Accès aux annuaires et services associés. |
| Kerberos | Authentification réseau par tickets. |
| RADIUS | Contrôle d'accès réseau et fonctions AAA. |
| OAuth 2.0 | Délégation d'autorisation. |
| OpenID Connect | Authentification fédérée et identité. |
| SAML | Fédération d'identité et assertions. |
| WebAuthn | Authentification à clé publique résistante au phishing. |
| mTLS | Authentification mutuelle par certificats TLS. |
6. Menaces et attaques contre l'authentification
Les mécanismes d'authentification constituent des cibles importantes pour les cybercriminels, car une compromission peut permettre d'accéder à des ressources protégées.
Attaque par force brute
Une attaque par force brute consiste à essayer de nombreuses combinaisons de secrets afin de découvrir des identifiants valides.
Password Spraying
Le Password Spraying consiste à tester un nombre limité de mots de passe courants sur plusieurs comptes.
Credential Stuffing
Le Credential Stuffing consiste à réutiliser des couples identifiant/mot de passe compromis provenant d'autres services.
Phishing
Le phishing cherche à tromper l'utilisateur pour obtenir ses informations d'authentification ou l'amener à valider une opération frauduleuse.
Vol de session
Le vol de session consiste à obtenir ou utiliser sans autorisation un identifiant de session permettant de se faire passer pour un utilisateur authentifié.
Attaque par rejeu
Une attaque par rejeu consiste à réutiliser des informations ou messages précédemment valides afin de contourner certaines protections.
MFA Fatigue
La MFA Fatigue consiste à multiplier les sollicitations d'authentification afin de pousser un utilisateur à approuver une demande frauduleuse.
Défauts de gestion des sessions
Des sessions trop longues, des jetons insuffisamment protégés ou une invalidation incorrecte peuvent augmenter les risques d'accès non autorisés.
Conséquences possibles
- Accès non autorisé à un compte.
- Usurpation d'identité.
- Consultation ou modification de données sensibles.
- Élévation de privilèges.
- Compromission de services connectés.
- Fraude ou interruption de certaines activités.
7. Implémentation de l'authentification avec Python
Python permet d'illustrer les principes de l'authentification, du stockage sécurisé des mots de passe et de la vérification des autorisations. Les exemples suivants sont pédagogiques et ne remplacent pas les mécanismes de sécurité fournis par un framework professionnel.
Exemple 1 : authentification simple avec identifiant et mot de passe
Le programme suivant illustre une vérification élémentaire d'identifiant et de mot de passe. Les valeurs sont volontairement définies dans le code pour faciliter la compréhension. Cette méthode ne doit pas être utilisée dans une application réelle, car elle conserve un mot de passe en clair.
1 2 3 4 5 6 7 8 | identifiant_attendu = "admin" mot_de_passe_attendu = "Exemple123!" identifiant_saisi = "admin" mot_de_passe_saisi = "Exemple123!" if identifiant_saisi == identifiant_attendu and mot_de_passe_saisi == mot_de_passe_attendu: print("Authentification réussie") else: print("Authentification refusée") |
Output :
1 | Authentification réussie |
Exemple 2 : hachage d'un mot de passe avec scrypt
Le programme suivant utilise scrypt, disponible dans le module standard hashlib, pour dériver un hachage de mot de passe avec un sel aléatoire. Il vérifie ensuite un mot de passe candidat avec hmac.compare_digest(), qui permet une comparaison adaptée aux secrets.
Le programme illustre une technique de stockage plus sûre que la conservation d'un mot de passe en clair. Dans une application réelle, le sel, les paramètres de dérivation et le hachage doivent être enregistrés ensemble dans un format approprié.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | import hashlib import hmac import secrets mot_de_passe = "MonSecret2026!" sel = secrets.token_bytes(16) hachage = hashlib.scrypt( mot_de_passe.encode("utf-8"), salt=sel, n=2**14, r=8, p=1, dklen=32 ) candidat = "MonSecret2026!" hachage_candidat = hashlib.scrypt( candidat.encode("utf-8"), salt=sel, n=2**14, r=8, p=1, dklen=32 ) if hmac.compare_digest(hachage, hachage_candidat): print("Mot de passe valide") else: print("Mot de passe incorrect") |
Output :
1 | Mot de passe valide |
Exemple 3 : limitation pédagogique des tentatives de connexion
Le programme suivant simule une politique de limitation des tentatives d'authentification. Après trois échecs consécutifs, les nouvelles tentatives sont refusées dans cette simulation. Dans une application réelle, la limitation doit être appliquée côté serveur, avec une politique adaptée pour éviter les abus et les blocages injustifiés.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | mot_de_passe_attendu = "Secret2026!" tentatives = ["incorrect1", "incorrect2", "incorrect3", "Secret2026!"] nombre_echecs = 0 limite = 3 for tentative in tentatives: if nombre_echecs >= limite: print("Tentative refusée : limite atteinte") continue if tentative == mot_de_passe_attendu: print("Connexion autorisée") nombre_echecs = 0 else: nombre_echecs += 1 print("Échec numéro", nombre_echecs) |
Output :
1 2 3 4 | Échec numéro 1 Échec numéro 2 Échec numéro 3 Tentative refusée : limite atteinte |
Exemple 4 : simulation d'une authentification à deux facteurs
Le programme suivant illustre le principe de deux vérifications successives : un mot de passe et un code complémentaire. Les valeurs sont fixes uniquement pour la démonstration. Il ne s'agit pas d'une véritable implémentation TOTP ou MFA sécurisée.
1 2 3 4 5 6 7 8 9 10 11 12 13 | mot_de_passe_attendu = "Secret2026!" code_attendu = "482913" mot_de_passe_saisi = "Secret2026!" code_saisi = "482913" if mot_de_passe_saisi == mot_de_passe_attendu: print("Premier contrôle réussi") if code_saisi == code_attendu: print("Deuxième contrôle réussi") print("Authentification acceptée") else: print("Code complémentaire incorrect") else: print("Mot de passe incorrect") |
Output :
1 2 3 | Premier contrôle réussi Deuxième contrôle réussi Authentification acceptée |
Exemple 5 : distinguer authentification et autorisation
Le programme suivant vérifie d'abord si un utilisateur est authentifié, puis examine son rôle avant d'autoriser une opération administrative. Il montre qu'une identité vérifiée ne donne pas automatiquement accès à toutes les fonctionnalités.
1 2 3 4 5 6 7 8 9 10 11 12 13 | utilisateur = { "nom": "alice", "authentifie": True, "role": "enseignant" } if utilisateur["authentifie"]: print("Utilisateur authentifié :", utilisateur["nom"]) if utilisateur["role"] == "administrateur": print("Accès au panneau administratif autorisé") else: print("Accès au panneau administratif refusé") else: print("Authentification nécessaire") |
Output :
1 2 | Utilisateur authentifié : alice Accès au panneau administratif refusé |
Exemple 6 : générer un jeton de session aléatoire
Le programme suivant utilise le module secrets pour générer un jeton aléatoire destiné à illustrer un identifiant de session difficile à deviner. Pour éviter d'afficher une valeur aléatoire différente à chaque exécution, le programme présente uniquement sa longueur.
Dans une application réelle, un jeton doit également être associé à une session côté serveur, disposer d'une durée de validité adaptée et être transmis et stocké de manière sécurisée.
1 2 3 4 | import secrets jeton = secrets.token_urlsafe(32) print("Jeton généré :", len(jeton) >= 40) print("Longueur du jeton :", len(jeton)) |
Output :
1 2 | Jeton généré : True Longueur du jeton : 43 |
Exemple 7 : analyser des échecs d'authentification
Le programme suivant analyse des événements fictifs de connexion et signale les utilisateurs ayant atteint un seuil d'échecs. Cette technique constitue une introduction à la surveillance des journaux d'authentification.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | evenements = [ ("alice", "echec"), ("bob", "succes"), ("alice", "echec"), ("alice", "echec"), ("charles", "echec"), ("alice", "echec") ] echecs = {} seuil = 3 for utilisateur, resultat in evenements: if resultat == "echec": echecs[utilisateur] = echecs.get(utilisateur, 0) + 1 for utilisateur, nombre in echecs.items(): if nombre >= seuil: print("Alerte :", utilisateur, "-", nombre, "échecs") |
Output :
1 | Alerte : alice - 4 échecs |
Authentification avec Django
Le framework Django possède un système d'authentification intégré comprenant notamment la gestion des utilisateurs, des mots de passe, des sessions, des groupes et des permissions.
Pour une application Django, il est préférable d'utiliser les mécanismes intégrés du framework plutôt que de créer soi-même un système complet d'authentification.
Le programme suivant montre comment vérifier les identifiants d'un utilisateur avec la fonction authenticate(). Il suppose qu'un projet Django est correctement configuré et qu'un utilisateur nommé alice possède le mot de passe de démonstration indiqué.
1 2 3 4 5 6 7 8 9 | from django.contrib.auth import authenticate utilisateur = authenticate( username="alice", password="MotDePasseExemple!" ) if utilisateur is not None: print("Authentification réussie") else: print("Identifiants invalides") |
Output :
1 | Authentification réussie |
Cette sortie correspond au cas où les identifiants sont valides et où le backend d'authentification accepte la connexion. Dans une application Web Django, l'établissement effectif de la session nécessite également l'utilisation appropriée de login().
8. Bonnes pratiques et sécurisation de l'authentification
La sécurité d'un système d'authentification dépend de plusieurs mécanismes complémentaires. Une vérification correcte du mot de passe ne suffit pas à elle seule pour garantir la protection des comptes.
Ne jamais stocker les mots de passe en clair
Les mots de passe doivent être protégés par des algorithmes spécialisés tels que Argon2id, scrypt ou bcrypt, avec des paramètres appropriés.
Les algorithmes de hachage rapides comme SHA-256 ne doivent pas être utilisés seuls pour stocker les mots de passe.
Utiliser une authentification multifacteur
L'authentification multifacteur réduit les risques associés à la compromission d'un seul facteur.
Les mécanismes résistants au phishing, comme les passkeys et certaines clés de sécurité FIDO2, doivent être privilégiés lorsque cela est possible.
Protéger les communications
Les informations d'authentification doivent être transmises à travers des canaux sécurisés, notamment HTTPS pour les applications Web.
Limiter les tentatives automatisées
Les systèmes doivent mettre en place des protections adaptées contre les tentatives répétées, notamment des limitations de débit, des délais progressifs ou des mécanismes de détection des abus.
Éviter les messages trop révélateurs
Les messages d'erreur ne doivent pas permettre trop facilement de déterminer si un identifiant existe ou si seul le mot de passe est incorrect.
Protéger les sessions
Les identifiants de session doivent être générés de manière sécurisée et protégés contre le vol ou la réutilisation non autorisée.
Pour les applications Web, les cookies de session doivent notamment utiliser les attributs Secure, HttpOnly et une politique SameSite adaptée.
Prévoir une expiration des sessions
Les sessions doivent avoir des durées de validité appropriées. Les opérations particulièrement sensibles peuvent nécessiter une nouvelle vérification de l'identité.
Sécuriser la récupération des comptes
La procédure de réinitialisation des mots de passe doit utiliser des mécanismes sécurisés et ne doit pas permettre à un attaquant de contourner l'authentification principale.
Appliquer le moindre privilège
L'authentification doit être complétée par une autorisation rigoureuse. Chaque utilisateur doit disposer uniquement des permissions nécessaires à ses fonctions.
Journaliser les événements sensibles
Les connexions réussies, les échecs, les changements de facteurs d'authentification et les opérations administratives sensibles doivent être surveillés selon les besoins de sécurité.
Protéger les comptes administrateurs
Les comptes disposant de privilèges élevés doivent bénéficier de protections renforcées, notamment une MFA adaptée, une surveillance spécifique et une séparation des usages administratifs et ordinaires.
Réaliser des audits de sécurité
Les applications doivent être régulièrement examinées afin de détecter les erreurs de configuration, les défauts de gestion des sessions et les faiblesses de contrôle d'accès.
Défense en profondeur
Une stratégie de défense en profondeur combine l'authentification forte, les contrôles d'accès, le chiffrement, la surveillance, les mises à jour et les procédures de réponse à incident.
9. À retenir
L'authentification est le processus permettant de vérifier l'identité revendiquée d'un utilisateur, d'une application ou d'un système.
Elle doit être distinguée de l'identification, qui consiste à déclarer une identité, et de l'autorisation, qui détermine les actions permises après vérification de cette identité.
Les principaux facteurs d'authentification reposent sur la connaissance, la possession et les caractéristiques biométriques.
L'authentification multifacteur combine plusieurs catégories de facteurs afin de renforcer la sécurité des accès.
Les passkeys et les mécanismes FIDO2/WebAuthn constituent des solutions modernes offrant une résistance importante au phishing.
Les mots de passe ne doivent jamais être stockés en clair. Leur protection nécessite des algorithmes spécialisés comme Argon2id, scrypt ou bcrypt.
Les technologies Kerberos, LDAP, RADIUS, OpenID Connect, SAML et WebAuthn interviennent dans différents environnements d'authentification et de gestion des identités.
Les principales menaces comprennent la force brute, le Credential Stuffing, le phishing, le vol de session et certaines attaques contre les mécanismes MFA.
Python permet d'illustrer les principes de vérification des identifiants, de hachage des mots de passe, de limitation des tentatives et de surveillance des événements de connexion.
Enfin, une authentification fiable doit être associée à un contrôle d'accès rigoureux, une gestion sécurisée des sessions et une stratégie globale de défense en profondeur.
Auteur : Younes Derfoufi
Lieu de travail : CRMEF OUJDA
Site Web : www.tresfacile.net
Chaine YouTube : https://www.youtube.com/user/InformatiquesFacile
Me contacter : https://www.tresfacile.net/me-contacter/
