RBAC vs ABAC vs ACL vs ReBAC : Choisir un modèle de contrôle d'accès
Les modèles de contrôle d'accès diffèrent sur un point : la base de la décision d'autorisation.
RBAC vs ABAC en bref : RBAC accorde des permissions aux rôles et assigne des rôles aux utilisateurs ; il répond donc facilement à « que peuvent faire les éditeurs ? » mais ne peut pas dire « uniquement leurs propres documents » sans créer un rôle par document. ABAC évalue des conditions sur les attributs de l'utilisateur, de la ressource et de l'environnement ; il gère naturellement les règles de propriété, de département et de temps, mais est plus difficile à auditer. La plupart des applications utilisent RBAC pour les fonctionnalités et ajoutent des conditions ABAC pour les enregistrements ; le dernier exemple de cette page fait les deux dans un seul modèle Casbin.
| Modèle | Décide sur | Exemple de règle |
|---|---|---|
| ACL (liste de contrôle d'accès) | L'utilisateur | alice peut modifier design.md |
| RBAC (basé sur les rôles) | Les rôles de l'utilisateur | les éditeurs peuvent modifier les documents |
| ABAC (basé sur les attributs) | Attributs de l'utilisateur, de la ressource et du contexte | les propriétaires peuvent modifier leurs documents ; les personnes du même département peuvent les lire |
| ReBAC (basé sur les relations) | Relations entre l'utilisateur et la ressource | toute personne étant lecteur du dossier peut lire les documents qu'il contient |
| PBAC (basé sur les politiques) | Expressions de règles stockées comme politique | quelle que soit la condition contenue dans la ligne de politique |
Ce ne sont pas des produits concurrents : ce sont des manières d'écrire des règles, et les systèmes réels les mélangent. Dans Casbin, chacune correspond à quelques lignes de configuration du modèle, et vous pouvez changer ou les combiner sans modifier le code de votre application. Cette page exprime le même petit exemple dans chaque modèle afin que les différences soient concrètes.
L'exemple : une application de documents avec un seul document, design.md, possédé par alice. alice devrait pouvoir le modifier, bob devrait pouvoir le lire, et personne d'autre ne devrait y avoir accès.
ACL
Une liste de contrôle d'accès indique, pour chaque utilisateur, ce qu'il peut faire avec chaque objet.
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act
p, alice, design.md, read
p, alice, design.md, edit
p, bob, design.md, read
- Points forts : petits systèmes et partage par objet (« partager ce fichier avec bob »). Chaque décision est facile à expliquer.
- Points faibles : passage à l'échelle. Avec u utilisateurs et o objets, la liste tend vers u × o lignes, et lorsqu'une personne change de poste, vous devez trouver et modifier toutes ses lignes.
RBAC
Le contrôle d'accès basé sur les rôles place des rôles entre les utilisateurs et les permissions. Les permissions sont accordées aux rôles, et les utilisateurs se voient assigner des rôles.
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub, p.sub) && r.obj == p.obj && r.act == p.act
p, editor, design.md, read
p, editor, design.md, edit
p, viewer, design.md, read
g, alice, editor
g, bob, viewer
g, carol, viewer
Donner l'accès en lecture à carol a pris une seule ligne g ; elle hérite de tout ce que viewer peut faire. Les rôles peuvent également hériter d'autres rôles (g, editor, viewer), et le RBAC avec domaines permet d'assigner à un utilisateur différents rôles dans différents locataires.
- Points forts : permissions suivant les fonctions professionnelles. Il est facile à auditer (« que peut faire un éditeur ? », « qui est admin ? »), et l'intégration ou la sortie d'un collaborateur se résume à un changement de rôle.
- Points faibles : règles concernant des enregistrements spécifiques. « Les auteurs peuvent modifier leurs propres articles » ne peut pas s'écrire uniquement avec des rôles ; essayer mène à un rôle par enregistrement, phénomène connu sous le nom d'explosion des rôles.
RBAC vs ACL : une ACL est du RBAC sans les rôles. Commencez avec RBAC sauf si vous n'avez réellement qu'une poignée d'utilisateurs, car ajouter des rôles plus tard signifie réécrire chaque règle.
Tutoriels : Go, Node.js, NestJS, Python, Java, Rust, gRPC.
ABAC
Le contrôle d'accès basé sur les attributs évalue des conditions sur les attributs de l'utilisateur (département, niveau d'habilitation), de la ressource (propriétaire, statut, sensibilité) et de l'environnement (heure, adresse IP). Dans Casbin, vous passez des objets à Enforce() et lisez leurs champs dans le matcher.
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = r.sub.Name == r.obj.Owner || (r.act == 'read' && r.sub.Department == r.obj.Department)
Il n'y a pas de fichier de politique : alice peut modifier design.md parce qu'elle en est propriétaire, et bob peut le lire parce qu'il travaille dans le même département. Un nouveau document dans le département design est lisible par bob sans aucun changement des règles.
- Points forts : règles dépendant de l'enregistrement ou du contexte : propriété, département, statut du document, heures ouvrables, région. Une seule règle remplace de nombreuses concessions de rôles.
- Points faibles : audit. « Qui peut lire ce document ? » n'a pas de réponse directe ; vous devez évaluer les conditions contre chaque utilisateur. Les conditions nécessitent également d'avoir les attributs sous la main, ce qui implique de charger l'enregistrement avant le contrôle.
Avec le motif eval(), les conditions passent du modèle aux lignes de politique, afin de pouvoir être ajoutées et supprimées à l'exécution comme toute autre règle.
Tutoriels : Go, Node.js with Express, Python with Flask.
ReBAC
Le contrôle d'accès basé sur les relations dérive les permissions des relations : alice est le propriétaire de design.md, bob en est un lecteur, et les propriétaires peuvent modifier tandis que les lecteurs peuvent lire. C'est le modèle derrière Google Zanzibar et ses descendants open source.
[request_definition]
r = sub, obj, act
[policy_definition]
p = relation, obj_type, act
[role_definition]
g = _, _, _
g2 = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub, r.obj, p.relation) && g2(r.obj, p.obj_type) && r.act == p.act
p, owner, doc, read
p, owner, doc, edit
p, viewer, doc, read
g, alice, design.md, owner
g, bob, design.md, viewer
g, bob, roadmap.md, owner
g2, design.md, doc
g2, roadmap.md, doc
bob peut modifier roadmap.md, dont il est propriétaire, mais seulement lire design.md. Les règles p décrivent ce que chaque relation autorise une fois pour un type entier d'objet, et les lignes g enregistrent qui a quelle relation avec quel objet.
- Points forts : partage et collaboration (documents, dossiers, projets, organisations), surtout lorsque les permissions sont héritées via une hiérarchie telle que organisation → dossier → document.
- Points faibles : petits systèmes ou systèmes plats, où c'est plus de mécanisme que nécessaire. Les relations doivent être écrites chaque fois que des objets sont créés ou partagés.
Voir ReBAC pour le modèle complet, et Casbin vs. OpenFGA si vous envisagez un service dédié de style Zanzibar.
PBAC
Le contrôle d'accès basé sur les politiques est moins un modèle séparé qu'une manière d'écrire les autres : les règles elles-mêmes sont des expressions stockées comme politique et évaluées à l'exécution. Dans Casbin, c'est le motif eval() utilisé dans les tutoriels ABAC et sur la page PBAC. Sa valeur est opérationnelle : les équipes de sécurité ou de conformité peuvent modifier les règles sans déploiement de code.
Côte à côte
| ACL | RBAC | ABAC | ReBAC | |
|---|---|---|---|---|
| Règles écrites sous forme | user–object–action | role–object–action, plus user–role | conditions sur les attributs | relation–type–action, plus user–relation–object |
| Nombre de règles croît avec | users × objects | roles × permissions | nombre de conditions distinctes | nombre d'objets partagés |
| « Que peut faire alice ? » | Facile | Facile | Difficile | Moyen |
| « Qui peut lire ce document ? » | Facile | Facile | Difficile | Facile |
| Règles par enregistrement (propriété) | Une ligne par enregistrement | Non exprimable sans explosion des rôles | Naturel | Naturel |
| Contexte (heure, IP, statut) | Non | Non | Oui | Seulement avec des conditions supplémentaires |
| Utilisation typique | Petits outils, partage de fichiers | Panneaux d'administration, outils internes, la plupart des applications métier | Plateformes de données, données réglementées, règles de propriété | Applications collaboratives, hiérarchies multi-niveaux |
Comment choisir
- Commencez par le RBAC. Si les autorisations peuvent être décrites par fonction ("admins", "editors", "billing"), le RBAC est le modèle le plus simple qui évolue bien et le plus facile à auditer.
- Ajoutez des conditions ABAC pour la propriété et le contexte. Lorsque vous avez besoin de "seulement les leurs" ou "seulement pendant les heures ouvrables", ajoutez des conditions plutôt que davantage de rôles.
- Choisissez le ReBAC lorsque le partage est au cœur du produit. Si les utilisateurs partagent des objets entre eux et que l'accès s'hérite via des dossiers, des projets ou des organisations, modélisez directement les relations.
- Utilisez les domaines pour le multi-tenant. Si le même utilisateur a des rôles différents dans différentes organisations, utilisez le RBAC avec domaines quel que soit le reste de votre choix.
- Envisagez les modèles obligatoires uniquement si requis. Les modèles BLP, Biba et LBAC conviennent aux environnements avec des niveaux de classification, tels que le gouvernement ou la défense.
Combinaison de RBAC et ABAC
La plupart des applications finissent ici : les rôles déterminent quelles fonctionnalités un utilisateur peut atteindre, et les attributs restreignent cela aux enregistrements qu'il peut toucher. Dans ce modèle, les admins peuvent modifier n'importe quel document, tandis que les auteurs ne peuvent modifier que les documents dont ils sont propriétaires :
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[role_definition]
g = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = g(r.sub.Name, p.sub) && r.obj.Type == p.obj && r.act == p.act && (p.sub == 'admin' || r.sub.Name == r.obj.Owner)
p, admin, doc, edit
p, author, doc, edit
g, erin, admin
g, alice, author
g, bob, author
Pour design.md (type doc, propriétaire alice), alice peut modifier car elle est auteur et propriétaire, erin peut modifier car elle est admin, et bob ne peut pas : il est auteur, mais pas le propriétaire.
FAQ
L'ABAC est-il plus sécurisé que le RBAC ? Aucun n'est intrinsèquement plus sécurisé. L'ABAC permet d'exprimer des règles plus fines, mais ses décisions sont plus difficiles à auditer ; le RBAC est plus grossier mais facile à vérifier. La sécurité vient de règles correspondant à vos intentions et de la capacité à vérifier qu'elles le font.
Puis-je commencer par le RBAC et passer à l'ABAC plus tard ? Oui. Dans Casbin, le modèle est un fichier de configuration et l'application appelle la même méthode Enforce(), vous pouvez donc ajouter des conditions au matcher, ou combiner les deux comme indiqué ci-dessus, sans réécrire vos appels d'autorisation.
Où se situe le PBAC ? Le PBAC décrit comment les règles sont gérées (comme des données de politique évaluées à l'exécution) plus que sur quoi elles sont basées. Les politiques Casbin sont des données dans tous les modèles, donc chacun des modèles ci-dessus peut être géré de cette manière.
Quelles bibliothèques et plateformes supportent à la fois le RBAC et l'ABAC ? Casbin supporte les deux, ainsi que leur combinaison, dans un seul modèle pour Go, Java, Node.js, Python, .NET, Rust et d'autres langages. Les moteurs de politique tels que OPA et Cedar peuvent exprimer les deux également, tandis que les services de type Zanzibar tels que OpenFGA sont construits autour du ReBAC. Casbin vs. Alternatives les compare.
Casbin supporte-t-il tout cela ? Oui, ainsi que d'autres comme RBAC96, OrBAC, UCON, LBAC, le modèle d'intégrité Biba, et les politiques de priorité et de rejet prioritaire. Voir Modèles supportés, et essayez-en n'importe lequel dans l'éditeur en ligne. Les super administrateurs sont gérés avec une condition supplémentaire dans le matcher plutôt qu'un modèle séparé.
Comments are powered by giscus and GitHub Discussions. They load from giscus.app and GitHub only after you click the button below.