Le contrôle d'accès, appelé Access Control en anglais, est un mécanisme fondamental de la cybersécurité permettant de limiter l'accès aux ressources informatiques selon des règles et des autorisations définies.
Il vise à garantir que seules les personnes, les applications et les systèmes autorisés peuvent consulter, modifier, supprimer ou utiliser une ressource protégée.
Les ressources concernées peuvent être des fichiers, des dossiers, des bases de données, des applications Web, des services réseau, des équipements ou des infrastructures cloud.
Le contrôle d'accès intervient dans la protection de la confidentialité, de l'intégrité et de la disponibilité des systèmes d'information. Il constitue ainsi un élément essentiel de la CIA Triad.
Dans ce tutoriel, nous allons étudier les principes fondamentaux du contrôle d'accès, les principaux modèles DAC, MAC, RBAC et ABAC, ainsi que les mécanismes de sécurité utilisés dans les systèmes informatiques. Nous verrons également comment développer des exemples pratiques en Python.
1. À propos du contrôle d'accès en cybersécurité
Définition du contrôle d'accès
Le contrôle d'accès informatique désigne l'ensemble des règles, mécanismes et procédures permettant de déterminer si une entité peut effectuer une opération sur une ressource.
Une décision de contrôle d'accès repose généralement sur plusieurs éléments :
- Sujet : utilisateur, application, processus ou système demandant un accès.
- Objet : ressource à laquelle l'accès est demandé.
- Action : opération souhaitée, comme lire, écrire, modifier ou supprimer.
- Politique de sécurité : ensemble des règles définissant les accès autorisés.
- Décision : autorisation ou refus de l'opération.
Exemple simple de contrôle d'accès
Dans une plateforme pédagogique, un étudiant peut consulter ses propres résultats, tandis qu'un enseignant peut consulter les résultats des étudiants dont il assure le suivi.
Un étudiant ne doit pas pouvoir accéder aux résultats d'un autre étudiant simplement en modifiant l'identifiant présent dans une adresse Web.
Le système doit donc vérifier les autorisations associées à chaque demande d'accès.
Différence entre identification, authentification et autorisation
Trois notions interviennent fréquemment dans le fonctionnement d'un système de contrôle d'accès :
- Identification : déclaration de l'identité d'un utilisateur.
- Authentification : vérification de cette identité.
- Autorisation : détermination des opérations que l'utilisateur peut effectuer.
Par exemple, lorsqu'un utilisateur saisit son identifiant, il s'identifie. Lorsqu'il fournit un mot de passe valide, il s'authentifie. Lorsque le système vérifie s'il peut consulter un document, il applique une règle d'autorisation.
Une authentification réussie ne signifie donc pas que toutes les ressources deviennent accessibles.
Contrôle d'accès logique et physique
Le contrôle d'accès logique concerne les ressources numériques : applications, fichiers, réseaux et bases de données.
Le contrôle d'accès physique concerne les locaux et les équipements : salles informatiques, centres de données, bureaux et bâtiments.
Ces deux formes de contrôle sont complémentaires dans une politique de sécurité globale.
Objectifs du contrôle d'accès
- Empêcher les accès non autorisés.
- Protéger les informations confidentielles.
- Limiter les modifications et suppressions non autorisées.
- Réduire les conséquences d'une compromission de compte.
- Appliquer les responsabilités associées aux différents rôles.
- Faciliter la traçabilité et les audits de sécurité.
2. Les principes fondamentaux du contrôle d'accès
Principe du moindre privilège
Le principe du moindre privilège, ou Least Privilege, consiste à attribuer uniquement les permissions nécessaires à l'accomplissement d'une tâche.
Par exemple, un utilisateur chargé de consulter des rapports ne doit pas disposer de permissions permettant de supprimer les bases de données.
Ce principe contribue à limiter les conséquences d'une erreur ou d'une compromission.
Principe du besoin d'en connaître
Le besoin d'en connaître, ou Need-to-Know, consiste à autoriser l'accès à une information uniquement lorsque cet accès est nécessaire à la mission de l'utilisateur.
Un enseignant peut avoir besoin de consulter les résultats de ses étudiants sans avoir besoin d'accéder aux dossiers personnels de tous les étudiants d'un établissement.
Principe du refus par défaut
Le refus par défaut, ou Default Deny, signifie qu'une opération est refusée lorsqu'aucune règle explicite ne l'autorise.
Ce principe évite qu'une absence de configuration soit interprétée comme une permission générale.
Séparation des responsabilités
La séparation des tâches, ou Separation of Duties, consiste à répartir certaines opérations sensibles entre plusieurs personnes ou rôles.
Par exemple, une personne peut préparer une opération financière tandis qu'une autre doit la valider.
Cette organisation réduit les risques d'erreurs et d'abus de privilèges.
Réévaluation des permissions
Les permissions doivent être régulièrement examinées afin de vérifier qu'elles correspondent toujours aux besoins réels.
Lorsqu'un utilisateur change de fonction ou quitte une organisation, ses droits doivent être adaptés ou révoqués.
Traçabilité et responsabilité
La journalisation permet d'enregistrer certains événements associés aux accès : utilisateur, ressource, action, date et décision.
Ces informations facilitent les investigations, les audits et la détection des comportements inhabituels.
Les journaux doivent eux-mêmes être protégés contre les accès et les modifications non autorisés.
Contrôle continu des accès
Dans les architectures modernes, notamment Zero Trust, l'accès ne doit pas être considéré comme définitivement fiable après une seule authentification.
Les décisions peuvent dépendre de l'identité, des permissions, du contexte et de l'état de sécurité des équipements.
3. Les principaux modèles de contrôle d'accès
DAC : Discretionary Access Control
Le DAC, ou contrôle d'accès discrétionnaire, est un modèle dans lequel le propriétaire d'une ressource peut disposer du pouvoir d'attribuer certaines permissions à d'autres utilisateurs.
Ce modèle est couramment associé aux mécanismes de partage de fichiers et aux listes de permissions.
Exemple : le propriétaire d'un document autorise un collègue à le consulter.
Avantage : flexibilité dans la gestion des autorisations.
Limite : les propriétaires peuvent accorder des accès trop larges ou inappropriés.
MAC : Mandatory Access Control
Le MAC, ou contrôle d'accès obligatoire, repose sur une politique centrale imposant des règles d'accès aux ressources.
Les utilisateurs ne peuvent pas librement modifier ces règles simplement parce qu'ils possèdent une ressource.
Le modèle peut s'appuyer sur des niveaux de classification et des habilitations.
Exemple : l'accès à certains documents est déterminé par leur niveau de classification et les habilitations du demandeur.
Avantage : application centralisée de politiques strictes.
Limite : administration parfois complexe et flexibilité réduite.
RBAC : Role-Based Access Control
Le RBAC, ou contrôle d'accès basé sur les rôles, consiste à associer des permissions à des rôles plutôt qu'à chaque utilisateur individuellement.
Les utilisateurs obtiennent ensuite des permissions en fonction des rôles qui leur sont attribués.
Exemple : dans une plateforme pédagogique, les rôles peuvent être administrateur, enseignant et étudiant.
Un administrateur peut gérer les comptes, un enseignant peut publier des ressources pédagogiques et un étudiant peut consulter les cours auxquels il est inscrit.
Avantage : administration simplifiée des permissions.
Limite : la multiplication des rôles peut compliquer la gestion.
ABAC : Attribute-Based Access Control
Le ABAC, ou contrôle d'accès basé sur les attributs, détermine les autorisations en fonction de plusieurs caractéristiques.
Les attributs peuvent concerner :
- L'identité ou la fonction de l'utilisateur.
- La catégorie de la ressource.
- L'opération demandée.
- L'heure ou le contexte de la demande.
- Le niveau de sécurité de l'équipement.
Exemple : un enseignant peut consulter les notes d'un groupe uniquement s'il est responsable de ce groupe et si son compte est actif.
Avantage : politiques d'accès fines et contextuelles.
Limite : conception et maintenance des règles plus complexes.
ACL : Access Control List
Une ACL, ou liste de contrôle d'accès, associe à une ressource des règles précisant quelles identités ou catégories d'identités peuvent effectuer certaines opérations.
Une ACL est un mécanisme de représentation et d'application des permissions ; elle n'est pas nécessairement un modèle indépendant de DAC, MAC, RBAC ou ABAC.
Tableau comparatif des modèles
| Modèle | Principe | Exemple d'utilisation |
|---|---|---|
| DAC | Permissions gérées selon les droits du propriétaire | Partage de documents |
| MAC | Politique centrale obligatoire | Systèmes à classification stricte |
| RBAC | Permissions associées aux rôles | Applications d'entreprise |
| ABAC | Permissions évaluées selon des attributs | Applications contextuelles |
| ACL | Liste de permissions attachée à une ressource | Fichiers et équipements réseau |
4. Les mécanismes et technologies de contrôle d'accès
Contrôle d'accès aux fichiers
Les systèmes d'exploitation disposent de mécanismes permettant de limiter la lecture, l'écriture et l'exécution des fichiers.
Les permissions dépendent du système utilisé et peuvent être définies au niveau des utilisateurs, des groupes ou de règles plus détaillées.
Contrôle d'accès aux bases de données
Les systèmes de gestion de bases de données permettent de définir des permissions sur les bases, les tables et certaines opérations.
Un compte applicatif destiné à lire des données ne devrait pas disposer de droits de suppression ou d'administration s'ils ne sont pas nécessaires.
Contrôle d'accès dans les applications Web
Les applications Web doivent vérifier les permissions côté serveur avant chaque opération sensible.
Le fait de masquer un bouton ou un menu dans l'interface ne suffit pas à empêcher un accès non autorisé.
Les identifiants de ressources fournis par l'utilisateur ne doivent jamais être considérés comme une preuve d'autorisation.
Contrôle d'accès réseau
Les pare-feu et certaines listes de contrôle d'accès réseau permettent de filtrer les communications selon des règles portant notamment sur les adresses, les ports et les protocoles.
Ces mécanismes contribuent à réduire la surface d'exposition des systèmes.
IAM : Identity and Access Management
L'IAM, ou gestion des identités et des accès, regroupe les processus et technologies permettant de gérer les identités, les rôles et les permissions.
Il intervient notamment dans la création des comptes, l'attribution des droits, leur révision et leur révocation.
Authentification multifacteur
L'MFA combine plusieurs facteurs d'authentification afin de réduire les risques liés à la compromission d'un seul facteur.
La MFA renforce l'authentification, mais ne remplace pas les contrôles d'autorisation.
OAuth 2.0 et OpenID Connect
OAuth 2.0 est un cadre de délégation d'autorisation permettant notamment à une application d'obtenir un accès limité à certaines ressources.
OpenID Connect ajoute une couche d'authentification fondée sur OAuth 2.0.
Ces technologies doivent être configurées et utilisées conformément à leurs objectifs respectifs.
Contrôle d'accès dans le cloud
Les plateformes cloud proposent des mécanismes IAM permettant de définir des permissions sur les machines virtuelles, les espaces de stockage, les bases de données et les autres ressources.
Le moindre privilège, la protection des clés API et la surveillance des permissions sont essentiels pour limiter les risques.
Contrôle d'accès dans WordPress
WordPress utilise un système de rôles et capacités pour contrôler certaines opérations.
Les rôles courants comprennent notamment administrateur, éditeur, auteur, contributeur et abonné, avec des capacités variables.
Dans une extension WordPress, les actions sensibles doivent vérifier les capacités appropriées côté serveur. La protection contre les requêtes CSRF, notamment au moyen de nonces, constitue une mesure complémentaire, mais un nonce ne remplace pas une vérification d'autorisation.
5. Les vulnérabilités et les bonnes pratiques de sécurité
Broken Access Control
Le Broken Access Control désigne une catégorie de vulnérabilités dans lesquelles les restrictions d'accès ne sont pas correctement appliquées.
Un utilisateur peut alors effectuer une opération ou consulter une ressource sans disposer de l'autorisation nécessaire.
IDOR : Insecure Direct Object Reference
Une vulnérabilité IDOR apparaît lorsqu'une application expose une référence à une ressource sans vérifier correctement les droits du demandeur.
Par exemple, une application qui permet de consulter un dossier simplement en modifiant son identifiant, sans vérifier son propriétaire, peut présenter une vulnérabilité de contrôle d'accès.
La protection consiste à vérifier les permissions pour chaque ressource demandée.
Élévation de privilèges
L'élévation de privilèges correspond à l'obtention de permissions supérieures à celles normalement accordées.
Elle peut résulter d'une vulnérabilité, d'une mauvaise configuration ou d'une gestion incorrecte des rôles.
Permissions excessives
Des permissions trop larges augmentent les conséquences potentielles d'une erreur ou d'une compromission.
Il est recommandé de limiter les droits aux opérations nécessaires et de réviser régulièrement les autorisations.
Absence de vérification côté serveur
Une application ne doit pas se contenter de cacher certaines fonctionnalités dans l'interface utilisateur.
Chaque demande sensible doit être contrôlée côté serveur, indépendamment de la manière dont elle a été déclenchée.
Défaut de révocation des accès
Les comptes et permissions qui ne sont plus nécessaires peuvent devenir une source de risque.
Les procédures de départ, de changement de fonction et de désactivation de comptes doivent prévoir la révocation des accès appropriés.
Bonnes pratiques recommandées
- Appliquer le refus par défaut.
- Respecter le principe du moindre privilège.
- Vérifier les autorisations côté serveur pour chaque opération sensible.
- Contrôler les permissions sur chaque ressource demandée.
- Éviter les comptes administrateurs inutiles.
- Réviser régulièrement les rôles et les permissions.
- Révoquer rapidement les accès devenus inutiles.
- Utiliser la MFA pour les comptes sensibles.
- Protéger les journaux et surveiller les accès inhabituels.
- Tester les contrôles d'accès dans un environnement autorisé.
6. Pratique du contrôle d'accès avec Python
Le langage Python permet de simuler plusieurs mécanismes de contrôle d'accès et de comprendre leur fonctionnement.
Les exemples suivants utilisent uniquement la bibliothèque standard de Python 3. Ils sont destinés à l'apprentissage et utilisent des utilisateurs et des ressources fictifs.
Exemple 1 : autoriser ou refuser l'accès à une ressource
Ce premier programme vérifie si un utilisateur appartient à une liste d'utilisateurs autorisés. Il illustre le fonctionnement élémentaire d'une décision de contrôle d'accès.
1 2 3 4 5 6 | utilisateur = 'alice' autorises = ['alice', 'bob'] if utilisateur in autorises: print('Accès autorisé') else: print('Accès refusé') |
Output :
1 | Accès autorisé |
Exemple 2 : appliquer le refus par défaut
Le principe du refus par défaut consiste à interdire une opération lorsqu'aucune permission explicite ne l'autorise.
Le programme suivant vérifie si une opération figure dans la liste des permissions accordées.
1 2 3 4 5 6 | permissions = ['lecture'] action = 'suppression' if action in permissions: print('Opération autorisée') else: print('Opération refusée') |
Output :
1 | Opération refusée |
Exemple 3 : implémenter un contrôle d'accès RBAC
Le modèle RBAC associe des permissions à des rôles. Dans cet exemple, le rôle administrateur dispose de plusieurs permissions, tandis que le rôle étudiant possède uniquement une permission de lecture.
1 2 3 4 5 6 7 8 9 10 11 | roles = { 'administrateur': ['lecture', 'ecriture', 'suppression'], 'enseignant': ['lecture', 'ecriture'], 'etudiant': ['lecture'] } role = 'etudiant' action = 'suppression' if action in roles.get(role, []): print('Accès autorisé') else: print('Accès refusé') |
Output :
1 | Accès refusé |
Exemple 4 : implémenter une liste de contrôle d'accès ACL
Une ACL permet de définir les permissions associées à une ressource. Le programme suivant vérifie si un utilisateur peut lire ou modifier un document.
1 2 3 4 5 6 7 8 9 10 | acl = { 'alice': ['lecture', 'ecriture'], 'bob': ['lecture'] } utilisateur = 'bob' action = 'ecriture' if action in acl.get(utilisateur, []): print('Permission accordée') else: print('Permission refusée') |
Output :
1 | Permission refusée |
Exemple 5 : simuler un contrôle d'accès DAC
Dans un modèle DAC, le propriétaire d'une ressource peut être autorisé à accorder certaines permissions.
Le programme suivant simule une règle simple selon laquelle le propriétaire d'un document peut accorder un accès en lecture à un autre utilisateur.
1 2 3 4 5 6 7 8 | proprietaire = 'alice' demandeur = 'alice' beneficiaire = 'bob' permissions = {'alice': ['lecture', 'ecriture']} if demandeur == proprietaire: permissions[beneficiaire] = ['lecture'] print('Permission accordée à', beneficiaire) print('Permissions de bob :', permissions['bob']) |
Output :
1 2 | Permission accordée à bob Permissions de bob : ['lecture'] |
Exemple 6 : simuler un contrôle d'accès MAC
Le modèle MAC peut utiliser des niveaux de classification et d'habilitation. Le programme suivant illustre une règle simplifiée d'autorisation de lecture selon ces niveaux.
Il ne constitue pas une implémentation complète d'un modèle MAC, car les politiques réelles peuvent imposer des règles supplémentaires, notamment sur les écritures et les catégories de sécurité.
1 2 3 4 5 6 7 8 9 10 11 | niveaux = { 'public': 1, 'interne': 2, 'confidentiel': 3 } habilitation = 'interne' classification = 'confidentiel' if niveaux[habilitation] >= niveaux[classification]: print('Lecture autorisée') else: print('Lecture refusée') |
Output :
1 | Lecture refusée |
Exemple 7 : implémenter un contrôle d'accès ABAC
Le modèle ABAC utilise plusieurs attributs pour prendre une décision. Le programme suivant vérifie le rôle, l'état du compte et l'heure de la demande.
Les conditions présentées constituent une politique fictive destinée à illustrer les décisions contextuelles.
1 2 3 4 5 6 7 8 9 10 11 | utilisateur = { 'role': 'enseignant', 'compte_actif': True } heure = 10 if (utilisateur['role'] == 'enseignant' and utilisateur['compte_actif'] and 8 <= heure < 18): print('Accès autorisé') else: print('Accès refusé') |
Output :
1 | Accès autorisé |
Exemple 8 : protéger l'accès à un dossier individuel
Dans une application pédagogique, un étudiant ne doit pas pouvoir consulter le dossier d'un autre étudiant sans autorisation.
Le programme suivant vérifie que l'utilisateur est bien le propriétaire du dossier demandé. Il illustre une protection élémentaire contre les erreurs d'autorisation de type IDOR.
1 2 3 4 5 6 7 8 9 10 | dossiers = { 'dossier_101': 'etudiant_101', 'dossier_102': 'etudiant_102' } utilisateur = 'etudiant_101' dossier = 'dossier_102' if dossiers.get(dossier) == utilisateur: print('Consultation autorisée') else: print('Consultation refusée') |
Output :
1 | Consultation refusée |
Exemple 9 : enregistrer les décisions d'accès
La journalisation permet de conserver une trace des demandes et des décisions d'accès.
Le programme suivant simule une demande d'accès et affiche un événement de journal contenant l'utilisateur, l'action et la décision.
Dans une application réelle, les journaux doivent être protégés et ne doivent pas contenir de secrets inutiles.
1 2 3 4 5 6 7 8 9 10 | utilisateur = 'bob' action = 'suppression' permissions = ['lecture'] decision = 'autorisé' if action in permissions else 'refusé' journal = { 'utilisateur': utilisateur, 'action': action, 'decision': decision } print(journal) |
Output :
1 | {'utilisateur': 'bob', 'action': 'suppression', 'decision': 'refusé'} |
Exemple 10 : créer un mini système de contrôle d'accès
Ce dernier programme combine plusieurs principes : gestion des rôles, attribution de permissions et refus par défaut.
Une fonction reçoit le rôle de l'utilisateur et l'action demandée. Elle retourne une décision d'autorisation.
Ce modèle est volontairement simplifié. Dans une application réelle, le rôle doit provenir d'une identité authentifiée et les permissions doivent également être vérifiées pour la ressource concernée.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | permissions = { 'administrateur': ['lecture', 'ecriture', 'suppression'], 'enseignant': ['lecture', 'ecriture'], 'etudiant': ['lecture'] } def verifier_acces(role, action): return action in permissions.get(role, []) tests = [ ('administrateur', 'suppression'), ('enseignant', 'ecriture'), ('etudiant', 'suppression'), ('inconnu', 'lecture') ] for role, action in tests: resultat = 'Autorisé' if verifier_acces(role, action) else 'Refusé' print(role, '-', action, ':', resultat) |
Output :
1 2 3 4 | administrateur - suppression : Autorisé enseignant - ecriture : Autorisé etudiant - suppression : Refusé inconnu - lecture : Refusé |
Prolongements pédagogiques
Ces exemples peuvent être prolongés par le développement d'une application Python intégrant une authentification, une gestion des rôles, des permissions et une journalisation des accès.
La bibliothèque sqlite3 peut être utilisée pour enregistrer les utilisateurs, les rôles et les autorisations. Les frameworks Flask et Django permettent de construire des applications Web dans lesquelles les permissions sont vérifiées côté serveur.
Un projet pédagogique intéressant consiste à développer une plateforme de gestion de documents dans laquelle chaque utilisateur possède un rôle et ne peut accéder qu'aux ressources autorisées.
7. À retenir
Le contrôle d'accès est un mécanisme essentiel de cybersécurité permettant de limiter l'utilisation des ressources aux entités disposant des permissions nécessaires.
Il repose sur plusieurs notions fondamentales : identification, authentification, autorisation et application des politiques de sécurité.
Le moindre privilège consiste à accorder uniquement les permissions nécessaires à l'accomplissement d'une tâche.
Le refus par défaut signifie qu'une opération est interdite lorsqu'aucune règle explicite ne l'autorise.
Les principaux modèles de contrôle d'accès sont le DAC, le MAC, le RBAC et l'ABAC.
Le RBAC attribue les permissions selon les rôles, tandis que l'ABAC évalue plusieurs attributs associés à l'utilisateur, à la ressource et au contexte.
Les ACL permettent de représenter des règles d'accès associées à des ressources.
Les vulnérabilités de type Broken Access Control peuvent permettre à des utilisateurs d'accéder à des ressources ou à des opérations sans autorisation.
Les applications Web doivent vérifier les permissions côté serveur et contrôler l'accès à chaque ressource demandée.
Le langage Python permet de simuler et de développer des mécanismes de contrôle d'accès fondés sur les utilisateurs, les rôles, les attributs et les permissions.
Enfin, un contrôle d'accès efficace nécessite une politique de sécurité claire, une gestion rigoureuse des identités, une révision régulière des permissions et une surveillance des opérations sensibles.
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/



