Comprendre en détail le fonctionnement de la correspondance Casbin
Cet article explique comment concevoir et mettre en œuvre le RBAC avec la bibliothèque Casbin. Pour les plateformes SaaS avec des hiérarchies de ressources et des rôles qui héritent des permissions, Casbin est une option performante.
Introduction au RBAC
Le RBAC restreint l'accès en fonction des rôles détenus par les utilisateurs. Pour voir comment fonctionne le RBAC hiérarchique, nous examinons le RBAC d'Azure puis implémentons quelque chose de similaire dans Casbin.
RBAC hiérarchique d'Azure

Dans Azure, le rôle Owner s'applique à différents niveaux de portée. Si je suis Owner au niveau de l'abonnement, je suis Owner de tous les groupes de ressources et des ressources situées sous cet abonnement. Si je suis Owner au niveau d'un groupe de ressources, je suis Owner de toutes les ressources de ce groupe.
L'image ci-dessous montre l'accès Owner au niveau de l'abonnement. 
La vérification de l'IAM pour un groupe de ressources situé sous cet abonnement montre un accès Owner hérité. 
C'est ainsi que le RBAC d'Azure est hiérarchique. De nombreux systèmes utilisent des hiérarchies similaires. Dans ce tutoriel, nous implémentons un modèle comparable avec Casbin.
Fonctionnement de Casbin
Comprendre les éléments constitutifs de Casbin (requête, politique, matcher, effet) facilite la conception et le réglage de votre modèle RBAC.
Qu'est-ce que l'ACL ?
L'ACL (Access Control List) associe les utilisateurs aux actions et les actions aux ressources.
Définition du modèle
Un modèle ACL minimal :
[request_definition]
r = sub, act, obj
[policy_definition]
p = sub, act, obj
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act
- request_definition — Définit le format de la requête. Par exemple,
alice, write, data1signifie « Alice peut-elle écrire dans data1 ? » - policy_definition — Définit le format de la politique. Par exemple, une politique
alice, write, data1accorde à Alice la permission d'écrire dans data1. - policy_effect — Comment combiner plusieurs politiques correspondantes (par ex. allow-override).
- matchers — La condition qui doit être remplie :
r.sub == p.sub && r.obj == p.obj && r.act == p.act.
Essayez-le dans l'éditeur Casbin
Ouvrez l'éditeur Casbin et collez le modèle ci-dessus dans l'éditeur Model.
Collez ce qui suit dans l'éditeur Policy :
p, alice, read, data1
p, bob, write, data2
et ce qui suit dans l'éditeur Request :
alice, read, data1
Le résultat sera :
true
Représentation visuelle du modèle ACL, de la politique et de la correspondance des requêtes

Qu'est-ce que le RBAC ?
Le RBAC (Role-Based Access Control) affecte les utilisateurs à des rôles ; les rôles ont des permissions sur les ressources. Une requête vérifie si le rôle de l'utilisateur autorise l'action sur la ressource.
Définition du modèle
Un modèle RBAC simple :
[request_definition]
r = sub, act, obj
[policy_definition]
p = sub, act, obj
[role_definition]
g = _, _
g2 = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = r.sub == p.sub && g(p.act, r.act) && r.obj == p.obj
- role_definition — Définit les relations de graphes (par ex.
gpour rôle-rôle ou utilisateur-rôle). Le matcher utilise ces relations pour résoudre les rôles et les permissions.
Essayez-le dans l'éditeur Casbin
Ouvrez l'éditeur et collez le modèle ci-dessus.
Collez ce qui suit dans l'éditeur Policy :
p, alice, reader, data1
p, bob, owner, data2
g, reader, read
g, owner, read
g, owner, write
et ce qui suit dans l'éditeur Request :
alice, read, data1
alice, write, data1
bob, write, data2
bob, read, data2
bob, write, data1
Le résultat sera :
true
false
true
true
false
Représentation visuelle du modèle RBAC, de la politique et de la correspondance des requêtes

La relation g (rôle-vers-action) est un graphe. Dans la politique, elle est écrite sous forme d'arêtes, par exemple :
g, reader, read
g, owner, read
g, owner, write
p est une politique normale (comparée avec ==). g est une relation de graphe. Vous pouvez en ajouter d'autres avec des suffixes : g2, g3, etc.
RBAC hiérarchique
Dans le RBAC hiérarchique, il existe plusieurs types de ressources avec héritage (par ex. Subscription → ResourceGroup). Un abonnement sub1 peut contenir des groupes de ressources rg1, rg2. De même, il existe des rôles/actions au niveau de l'abonnement et des rôles/actions au niveau du groupe de ressources, avec héritage entre eux. Par exemple, le rôle d'abonnement sub-owner pourrait hériter vers le rôle de groupe de ressources rg-owner : si j'ai sub-owner sur sub1, j'ai effectivement rg-owner sur rg1 et rg2.
Définition du modèle
Un modèle RBAC hiérarchique minimal :
[request_definition]
r = sub, act, obj
[policy_definition]
p = sub, act, obj
[role_definition]
g = _, _
g2 = _, _
[policy_effect]
e = some(where (p.eft == allow))
[matchers]
m = r.sub == p.sub && g(p.act, r.act) && g2(p.obj, r.obj)
Ici, g lie les rôles/actions et g2 lie les ressources (par ex. l'abonnement au groupe de ressources).
Essayez-le dans l'éditeur Casbin
Ouvrez l'éditeur et collez le modèle ci-dessus.
Collez ce qui suit dans l'éditeur Policy :
p, alice, sub-reader, sub1
p, bob, rg-owner, rg2
// subscription role to subscription action mapping
g, sub-reader, sub-read
g, sub-owner, sub-read
g, sub-owner, sub-write
// resourceGroup role to resourceGroup action mapping
g, rg-reader, rg-read
g, rg-owner, rg-read
g, rg-owner, rg-write
// subscription role to resourceGroup role mapping
g, sub-reader, rg-reader
g, sub-owner, rg-owner
// subscription resource to resourceGroup resource mapping
g2, sub1, rg1
g2, sub2, rg2
Et collez ce qui suit dans l'éditeur Request :
alice, rg-read, rg1
Le résultat sera :
true
Représentation visuelle de la correspondance entre le modèle RBAC, la politique et la requête

Les arêtes g (rôle → action, rôle → rôle) peuvent être écrites dans la politique comme suit :
// subscription role to subscription action mapping
g, sub-reader, sub-read
g, sub-owner, sub-read
g, sub-owner, sub-write
// resourceGroup role to resourceGroup action mapping
g, rg-reader, rg-read
g, rg-owner, rg-read
g, rg-owner, rg-write
// subscription role to resourceGroup role mapping
g, sub-reader, rg-reader
g, sub-owner, rg-owner
Les arêtes g2 font correspondre l'abonnement au groupe de ressources :
// subscription resource to resourceGroup resource mapping
g2, sub1, rg1
g2, sub2, rg2
Représentation visuelle de la correspondance du sujet

Représentation visuelle de la correspondance de l'action

Représentation visuelle de la correspondance de l'objet

Casbin évalue la requête par rapport à toutes les politiques. Si au moins une politique correspond, le résultat est true ; sinon false.
Conclusion
Ce tutoriel a montré comment ACL, RBAC et RBAC hiérarchique peuvent être exprimés dans Casbin. Dans un article suivant, nous implémenterons cela dans une application Spring Boot et sécuriserons les API avec Casbin.

Comments are powered by giscus and GitHub Discussions. They load from giscus.app and GitHub only after you click the button below.