En cybersécurité, l'Account Lockout, ou verrouillage de compte, est un mécanisme de sécurité qui bloque temporairement ou durablement les nouvelles tentatives d'authentification sur un compte après un nombre déterminé d'échecs. Il est principalement utilisé pour limiter les attaques par force brute, les tentatives répétées de deviner un mot de passe et certaines attaques automatisées contre les systèmes d'authentification.
1. À propos de l'Account Lockout en cybersécurité
L'Account Lockout est une mesure de protection qui consiste à verrouiller un compte utilisateur lorsqu'un nombre excessif de tentatives d'authentification incorrectes est détecté.
Ce mécanisme est utilisé dans de nombreux environnements informatiques : Windows, Linux, Active Directory, applications Web, plateformes Cloud et systèmes de gestion des identités.
Pourquoi verrouiller un compte ?
Lorsqu'un utilisateur saisit un mot de passe incorrect, le système peut autoriser une nouvelle tentative.
Cependant, si un attaquant peut essayer un nombre illimité de mots de passe, il peut automatiser ses tentatives jusqu'à découvrir éventuellement le mot de passe correct.
Le verrouillage de compte permet de limiter ce type d'activité en imposant une restriction après plusieurs échecs.
Exemple simple
Supposons qu'un site Web applique la politique suivante :
- Nombre maximal d'échecs : 5 tentatives.
- Durée de verrouillage : 15 minutes.
- Période d'observation : 10 minutes.
Si cinq tentatives incorrectes sont enregistrées sur un compte pendant une période de dix minutes, le système verrouille le compte pendant quinze minutes.
À l'expiration de cette durée, le compte peut de nouveau accepter les tentatives d'authentification, sous réserve des autres règles de sécurité.
Objectifs de l'Account Lockout
- Limiter les attaques par force brute.
- Réduire les tentatives automatisées contre les comptes.
- Ralentir certaines attaques par dictionnaire.
- Détecter les comportements d'authentification anormaux.
- Protéger les comptes sensibles.
- Déclencher des alertes de sécurité.
- Renforcer les politiques d'authentification.
Account Lockout et Account Hijacking
L'Account Hijacking désigne la prise de contrôle frauduleuse d'un compte utilisateur.
L'Account Lockout est une mesure de protection qui peut contribuer à réduire certains risques de compromission.
Le verrouillage ne protège cependant pas contre toutes les techniques de prise de contrôle, notamment le vol d'une session déjà authentifiée.
Account Lockout et Rate Limiting
Le Rate Limiting limite le nombre de requêtes ou d'opérations autorisées pendant une période donnée.
L'Account Lockout agit plus précisément sur l'état d'un compte après des échecs d'authentification.
Les deux mécanismes peuvent être combinés pour protéger un système de connexion.
Account Lockout et CAPTCHA
Un CAPTCHA cherche à distinguer certaines interactions humaines des interactions automatisées.
Il peut constituer une protection complémentaire, mais ne remplace pas les mécanismes de limitation des tentatives et d'authentification forte.
2. Fonctionnement et principaux types de verrouillage de compte
Le fonctionnement de l'Account Lockout repose généralement sur le suivi des échecs d'authentification et l'application de règles de sécurité.
Étape 1 : tentative d'authentification
Un utilisateur saisit ses identifiants pour accéder à un service.
Étape 2 : vérification des identifiants
Le système vérifie les informations d'authentification à l'aide du mécanisme prévu.
Étape 3 : enregistrement d'un échec
Si l'authentification échoue, le système peut incrémenter un compteur d'échecs associé au compte.
Étape 4 : comparaison avec le seuil
Le nombre d'échecs est comparé au seuil de verrouillage.
Lorsque le seuil est atteint, une règle de protection peut être déclenchée.
Étape 5 : verrouillage du compte
Le système refuse les nouvelles tentatives d'authentification concernées pendant la durée prévue.
Étape 6 : déverrouillage
Le compte peut être déverrouillé automatiquement après expiration du délai ou à la suite d'une intervention autorisée.
Verrouillage temporaire
Le Temporary Account Lockout consiste à verrouiller un compte pendant une durée limitée.
Par exemple, un compte peut être verrouillé pendant quinze minutes après cinq échecs.
Ce type de verrouillage permet de ralentir les attaques tout en réduisant la nécessité d'une intervention administrative.
Verrouillage jusqu'à intervention administrative
Le Administrative Lockout nécessite une intervention autorisée pour rétablir l'accès.
Cette méthode peut convenir à certains environnements sensibles, mais elle augmente les contraintes d'administration et les risques d'indisponibilité.
Verrouillage progressif
Un mécanisme de Progressive Lockout augmente progressivement les restrictions après des échecs répétés.
Par exemple, un système peut imposer une attente de plus en plus longue avant de permettre une nouvelle tentative.
Temporisation des tentatives
Le Login Throttling consiste à ralentir les tentatives d'authentification plutôt qu'à verrouiller immédiatement le compte.
Cette approche peut contribuer à réduire les risques d'abus du mécanisme de verrouillage.
Verrouillage basé sur le risque
Un système d'authentification peut adapter ses décisions en fonction de signaux de risque, comme un appareil inconnu, des échecs répétés ou une activité inhabituelle.
Selon la politique, il peut demander une authentification supplémentaire, ralentir les tentatives ou bloquer temporairement l'accès.
Les paramètres importants
| Paramètre | Description | Exemple |
|---|---|---|
| Lockout Threshold | Nombre d'échecs déclenchant le verrouillage. | 5 tentatives |
| Lockout Duration | Durée du verrouillage. | 15 minutes |
| Observation Window | Période pendant laquelle les échecs sont comptabilisés. | 10 minutes |
| Counter Reset | Règle de remise à zéro du compteur. | Après une période sans échec |
| Unlock Policy | Conditions de déverrouillage. | Automatique ou administratif |
Les valeurs présentées sont des exemples pédagogiques et non des paramètres universellement recommandés.
3. Avantages, risques et limites de l'Account Lockout
Le verrouillage de compte présente des avantages importants, mais une configuration inadaptée peut également créer des problèmes de disponibilité et d'expérience utilisateur.
Protection contre les attaques par force brute
Une attaque par force brute consiste à essayer de nombreuses combinaisons afin de découvrir un mot de passe.
Le verrouillage de compte limite le nombre de tentatives possibles pendant une période donnée.
Réduction des attaques par dictionnaire
Une attaque par dictionnaire consiste à tester des mots de passe issus de listes de valeurs courantes ou probables.
Le verrouillage peut ralentir ce type d'attaque.
Détection d'activités suspectes
Les échecs répétés peuvent être enregistrés dans des journaux et déclencher des alertes.
Ces événements peuvent aider les équipes de sécurité à identifier certaines tentatives d'accès abusives.
Risque de déni de service
Un attaquant peut volontairement provoquer des échecs d'authentification afin de verrouiller le compte d'un utilisateur légitime.
Ce scénario constitue une forme de déni de service applicatif visant la disponibilité des comptes.
Verrouillage des comptes administrateurs
Une politique trop stricte peut empêcher un administrateur d'accéder à un système critique.
Il est donc important de prévoir des procédures de récupération et d'accès d'urgence adaptées.
Faux positifs
Un utilisateur peut saisir plusieurs fois un mot de passe incorrect sans intention malveillante.
Le système doit tenir compte de cette possibilité pour éviter des restrictions disproportionnées.
Attaques distribuées
Une attaque peut provenir de nombreuses adresses IP ou viser plusieurs comptes.
Un mécanisme de verrouillage limité à une seule adresse IP ne suffit donc pas à protéger tous les scénarios.
Password Spraying
Le Password Spraying consiste à essayer un petit nombre de mots de passe sur de nombreux comptes.
Cette technique peut rester difficile à détecter si les contrôles examinent uniquement les échecs associés à chaque compte.
Credential Stuffing
Le Credential Stuffing consiste à tenter d'utiliser des identifiants précédemment compromis.
Si les identifiants sont corrects dès la première tentative, le verrouillage de compte ne constitue pas une protection suffisante.
Vol de sessions
Un attaquant possédant un jeton de session valide peut parfois accéder à un compte sans effectuer de nouvelles tentatives de mot de passe.
Le verrouillage ne remplace donc pas la protection des sessions.
Tableau des avantages et limites
| Aspect | Avantage | Limite |
|---|---|---|
| Force brute | Réduit les tentatives répétées. | Ne bloque pas tous les scénarios. |
| Disponibilité | Protège contre certains abus. | Peut verrouiller des comptes légitimes. |
| Surveillance | Fournit des événements exploitables. | Nécessite une analyse contextuelle. |
| Administration | Renforce le contrôle des accès. | Peut augmenter les demandes de support. |
| Automatisation | Permet une réaction automatique. | Peut être exploité pour provoquer des blocages. |
4. Implémentation de l'Account Lockout avec Python
Python permet de simuler les mécanismes de verrouillage automatique des comptes, de suivre les tentatives échouées et de gérer les durées de blocage.
Les exemples suivants sont pédagogiques. Ils utilisent des données fictives et ne constituent pas, à eux seuls, un système d'authentification prêt pour la production.
Exemple 1 : compter les tentatives échouées
Le programme suivant utilise une variable pour compter les échecs de connexion. Chaque tentative incorrecte augmente le compteur d'une unité.
1 2 3 4 5 6 | tentatives = ["echec", "echec", "succes", "echec"] compteur = 0 for resultat in tentatives: if resultat == "echec": compteur += 1 print("Nombre d'échecs :", compteur) |
Output :
1 | Nombre d'échecs : 3 |
Dans cet exemple, le programme compte tous les échecs de la liste. Il ne remet pas automatiquement le compteur à zéro après une authentification réussie.
Exemple 2 : verrouiller un compte après cinq échecs
Le programme suivant compare le nombre de tentatives incorrectes avec un seuil fixé à cinq. Lorsque ce seuil est atteint, le compte est considéré comme verrouillé.
1 2 3 4 5 6 | nombre_echecs = 5 seuil = 5 if nombre_echecs >= seuil: print("Compte verrouillé") else: print("Compte non verrouillé") |
Output :
1 | Compte verrouillé |
Exemple 3 : gérer plusieurs comptes utilisateurs
Le programme suivant utilise un dictionnaire contenant le nombre d'échecs associés à plusieurs utilisateurs. Il affiche les comptes ayant atteint le seuil de verrouillage.
1 2 3 4 5 6 7 8 9 10 | comptes = { "alice": 2, "bob": 5, "charlie": 7, "admin": 1 } seuil = 5 for utilisateur, echecs in comptes.items(): if echecs >= seuil: print("Compte verrouillé :", utilisateur) |
Output :
1 2 | Compte verrouillé : bob Compte verrouillé : charlie |
Exemple 4 : remettre le compteur à zéro après une réussite
Le programme suivant simule une politique dans laquelle une authentification réussie remet à zéro le compteur des échecs précédents. Cette remise à zéro ne s'applique que si le compte n'est pas déjà verrouillé.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | tentatives = ["echec", "echec", "succes", "echec"] compteur = 0 seuil = 5 verrouille = False for resultat in tentatives: if verrouille: break if resultat == "echec": compteur += 1 if compteur >= seuil: verrouille = True else: compteur = 0 print("Compteur final :", compteur) print("Compte verrouillé :", verrouille) |
Output :
1 2 | Compteur final : 1 Compte verrouillé : False |
Exemple 5 : simuler un verrouillage temporaire
Le programme suivant utilise le module time pour représenter un compte verrouillé pendant quinze minutes. Il compare l'heure actuelle à l'heure d'expiration du verrouillage.
1 2 3 4 5 6 7 | import time maintenant = time.time() expiration = maintenant + 900 if maintenant < expiration: print("Compte temporairement verrouillé") else: print("Compte déverrouillé") |
Output :
1 | Compte temporairement verrouillé |
Dans cet exemple, 900 secondes correspondent à quinze minutes. Le programme illustre uniquement la comparaison temporelle.
Exemple 6 : déverrouiller automatiquement un compte
Le programme suivant simule un verrouillage déjà expiré. Il compare l'heure d'expiration à l'heure actuelle et affiche le nouvel état du compte.
1 2 3 4 5 6 7 8 | import time maintenant = time.time() expiration = maintenant - 60 verrouille = maintenant < expiration if verrouille: print("Compte encore verrouillé") else: print("Compte automatiquement déverrouillé") |
Output :
1 | Compte automatiquement déverrouillé |
Exemple 7 : appliquer une période d'observation
Le programme suivant utilise des horodatages fictifs exprimés en secondes. Il compte uniquement les échecs survenus pendant les dix dernières minutes.
1 2 3 4 5 6 7 8 | maintenant = 2000 echecs = [1000, 1450, 1600, 1800, 1950] fenetre = 600 recents = [] for instant in echecs: if maintenant - fenetre <= instant <= maintenant: recents.append(instant) print("Échecs récents :", len(recents)) |
Output :
1 | Échecs récents : 4 |
Les événements survenus avant le début de la fenêtre d'observation ne sont pas comptabilisés.
Exemple 8 : appliquer un verrouillage progressif
Le programme suivant augmente la durée du verrouillage selon le nombre de déclenchements déjà observés. Les durées sont purement pédagogiques.
1 2 3 4 | nombre_verrouillages = 3 duree_initiale = 60 duree = duree_initiale * (2 ** (nombre_verrouillages - 1)) print("Durée de verrouillage :", duree, "secondes") |
Output :
1 | Durée de verrouillage : 240 secondes |
Un système réel doit limiter les durées maximales afin d'éviter des blocages excessifs.
Exemple 9 : analyser un journal fictif de connexions
Le programme suivant analyse plusieurs événements d'authentification. Il compte les échecs pour chaque compte et signale ceux qui atteignent le seuil fixé.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | journal = [ ("alice", "echec"), ("bob", "echec"), ("alice", "echec"), ("alice", "echec"), ("bob", "succes") ] compteurs = {} for utilisateur, resultat in journal: if resultat == "echec": compteurs[utilisateur] = compteurs.get(utilisateur, 0) + 1 seuil = 3 for utilisateur, nombre in compteurs.items(): if nombre >= seuil: print("Compte à examiner :", utilisateur) |
Output :
1 | Compte à examiner : alice |
Cette simulation ne prend pas en compte les horodatages et ne remet pas le compteur à zéro après une connexion réussie.
Exemple 10 : enregistrer les verrouillages dans un fichier
Le programme suivant utilise le module logging pour enregistrer un événement de verrouillage dans un fichier local nommé account_lockout.log.
1 2 3 4 5 6 7 8 9 | import logging logging.basicConfig( filename="account_lockout.log", level=logging.WARNING, format="%(asctime)s - %(levelname)s - %(message)s" ) utilisateur = "alice" logging.warning("Compte verrouillé : %s", utilisateur) print("Événement enregistré dans account_lockout.log") |
Output :
1 | Événement enregistré dans account_lockout.log |
Dans une application professionnelle, les journaux doivent être protégés contre les modifications non autorisées.
Exemple 11 : simuler une fonction de verrouillage automatique
Le programme suivant définit une fonction qui traite les résultats d'authentification. Il incrémente le compteur après chaque échec et verrouille le compte lorsque le seuil est atteint.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | def verifier_tentatives(tentatives, seuil=3): compteur = 0 verrouille = False for resultat in tentatives: if verrouille: break if resultat == "echec": compteur += 1 if compteur >= seuil: verrouille = True elif resultat == "succes": compteur = 0 return verrouille tentatives = ["echec", "echec", "echec", "succes"] if verifier_tentatives(tentatives): print("Compte verrouillé") else: print("Compte accessible") |
Output :
1 | Compte verrouillé |
La quatrième tentative n'est pas traitée, car le verrouillage est déclenché dès le troisième échec.
Exemple 12 : simuler un mécanisme complet de verrouillage temporaire
Le programme suivant définit une classe pédagogique permettant de compter les échecs, de verrouiller un compte et de vérifier si le délai de blocage est expiré. Pour rendre la simulation reproductible, les instants sont fournis explicitement.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | class Compte: def __init__(self, seuil=3, duree=300): self.echecs = 0 self.seuil = seuil self.duree = duree self.verrouille_jusqua = 0 def tentative(self, succes, instant): if instant < self.verrouille_jusqua: return "REFUS : compte verrouillé" if succes: self.echecs = 0 return "ACCES AUTORISE" self.echecs += 1 if self.echecs >= self.seuil: self.verrouille_jusqua = instant + self.duree self.echecs = 0 return "COMPTE VERROUILLE" return "ECHEC : tentative incorrecte" compte = Compte(seuil=3, duree=300) print(compte.tentative(False, 1000)) print(compte.tentative(False, 1010)) print(compte.tentative(False, 1020)) print(compte.tentative(True, 1030)) print(compte.tentative(True, 1320)) |
Output :
1 2 3 4 5 | ECHEC : tentative incorrecte ECHEC : tentative incorrecte COMPTE VERROUILLE REFUS : compte verrouillé ACCES AUTORISE |
Ce programme illustre les mécanismes fondamentaux de l'Account Lockout. Il ne comporte pas de stockage persistant, de gestion de sessions, de concurrence entre requêtes ni de véritable vérification cryptographique des mots de passe.
5. Configuration et bonnes pratiques de sécurité
Une politique d'Account Lockout doit trouver un équilibre entre la protection des comptes et leur disponibilité pour les utilisateurs légitimes.
Définir un seuil adapté
Le nombre maximal d'échecs doit être déterminé selon la sensibilité des comptes, les risques identifiés et les besoins de l'organisation.
Un seuil trop faible peut provoquer des verrouillages fréquents, tandis qu'un seuil trop élevé peut laisser davantage de possibilités aux attaques automatisées.
Choisir une durée raisonnable
Le Lockout Duration doit être proportionné au niveau de risque.
Les durées très longues peuvent augmenter les risques de déni de service contre les comptes.
Utiliser une fenêtre d'observation
La Observation Window permet de comptabiliser les échecs sur une période définie.
Elle évite qu'un nombre limité d'erreurs réparties sur une très longue période provoque nécessairement un verrouillage.
Privilégier les temporisations progressives lorsque cela est pertinent
Le ralentissement progressif des tentatives peut constituer une alternative ou un complément au verrouillage strict.
Activer l'authentification multifacteur
La MFA renforce la protection des comptes lorsque les mots de passe sont compromis.
Les méthodes résistantes au phishing, notamment celles fondées sur FIDO2 et WebAuthn, sont particulièrement utiles pour les comptes sensibles.
Utiliser des mots de passe uniques
Chaque compte doit disposer d'un mot de passe suffisamment robuste et distinct de ceux utilisés sur d'autres services.
Combiner Account Lockout et Rate Limiting
Le Rate Limiting permet de limiter les tentatives selon plusieurs dimensions, comme le compte, l'adresse IP ou le service.
Il contribue à réduire les attaques automatisées sans dépendre uniquement du verrouillage d'un compte.
Éviter l'énumération des comptes
Les messages d'erreur ne doivent pas révéler inutilement si un compte existe ou s'il est soumis à un état particulier.
Des réponses génériques peuvent réduire les risques de divulgation d'informations.
Surveiller les événements de verrouillage
Les échecs répétés et les verrouillages doivent être enregistrés et analysés afin de détecter les activités suspectes.
Prévoir une procédure de récupération
Les utilisateurs légitimes doivent disposer d'un moyen sécurisé de retrouver l'accès à leur compte.
Les procédures de récupération doivent être protégées contre les abus et l'ingénierie sociale.
Protéger les comptes administrateurs
Les comptes disposant de privilèges élevés nécessitent des protections renforcées, notamment une authentification forte et des procédures d'accès d'urgence.
Account Lockout dans Windows et Active Directory
Les environnements Windows et Active Directory peuvent appliquer des stratégies de verrouillage des comptes.
Les paramètres concernés comprennent notamment :
- Account lockout threshold : seuil de verrouillage.
- Account lockout duration : durée du verrouillage.
- Reset account lockout counter after : période de réinitialisation du compteur.
Ces paramètres doivent être définis selon les politiques de sécurité et les caractéristiques de l'environnement.
Account Lockout sous Linux
Sous Linux, des mécanismes d'authentification comme PAM peuvent être utilisés pour appliquer des politiques de restriction après des échecs répétés.
Le module pam_faillock, lorsqu'il est disponible et configuré, permet notamment de suivre les échecs et d'appliquer certaines règles de verrouillage.
Account Lockout dans les applications Web
Les applications développées avec Django, Flask, Laravel ou d'autres frameworks peuvent intégrer des mécanismes de limitation des tentatives.
Les compteurs et les décisions de verrouillage doivent être gérés côté serveur, avec un stockage fiable et des opérations adaptées aux accès concurrents.
Account Lockout dans WordPress
Pour un site WordPress, la protection contre les tentatives de connexion répétées peut être mise en place à plusieurs niveaux :
- Le pare-feu applicatif Web.
- Les mécanismes de protection de l'hébergement.
- Les services de sécurité comme Cloudflare.
- Les extensions de sécurité fiables.
- Les mécanismes d'authentification multifacteur.
Il est important de vérifier que les protections couvrent les différents points d'authentification utilisés par le site.
Prévenir les attaques par déni de service
Une politique de verrouillage doit être conçue pour éviter qu'un attaquant puisse bloquer facilement un grand nombre de comptes légitimes.
Les temporisations, les vérifications supplémentaires et les analyses de risque peuvent contribuer à réduire ce problème.
Défense en profondeur
L'Account Lockout doit être associé à une stratégie de défense en profondeur comprenant l'authentification forte, la limitation des tentatives, la surveillance des événements et la protection des sessions.
6. À retenir
L'Account Lockout est un mécanisme de sécurité permettant de verrouiller automatiquement un compte après plusieurs tentatives d'authentification échouées.
Il contribue à limiter certaines attaques par force brute, les attaques par dictionnaire et les tentatives automatisées de connexion.
Le fonctionnement repose sur un compteur d'échecs, un seuil de verrouillage, une durée de blocage et, souvent, une fenêtre d'observation.
Le verrouillage peut être temporaire, administratif ou associé à des temporisations progressives.
Une configuration trop stricte peut provoquer des faux positifs et permettre certaines attaques par déni de service.
Le mécanisme ne suffit pas à empêcher le Credential Stuffing, le Password Spraying ou le vol de sessions dans tous les scénarios.
Python permet de simuler le comptage des échecs, les seuils, les fenêtres d'observation, les verrouillages temporaires et les procédures de déverrouillage.
Les systèmes Windows, Active Directory, Linux et les applications Web disposent de mécanismes permettant de mettre en œuvre ces politiques.
L'Account Lockout doit être combiné avec le Rate Limiting, la MFA, les mots de passe uniques et la surveillance des événements.
Enfin, une politique efficace doit protéger les comptes tout en préservant leur disponibilité pour les utilisateurs légitimes.
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/
