Apache Casbin

Nouvelle : vous vous demandez toujours comment écrire la bonne politique Apache Casbin ? Apache Casbin online editor est là pour vous aider ! Essayez-le sur : https://casbin.apache.org/editor/

Apache Casbin est une bibliothèque de contrôle d'accès open-source puissante et efficace pour les projets Golang. Elle permet d'appliquer une autorisation basée sur différents modèles de contrôle d'accès.

Toutes les langues prises en charge par Apache Casbin :

Table des matières

• Modèles pris en charge
• Comment cela fonctionne-t-il ?
• Fonctionnalités
• Installation
• Documentation
• Éditeur en ligne
• Tutoriels
• Pour commencer
• Gestion des politiques
• Persistance des politiques
• Cohérence des politiques entre plusieurs nœuds
• Gestionnaire de rôles
• Benchmarks
• Exemples
• Middlewares
• Nos utilisateurs

Modèles pris en charge

1. ACL (Liste de contrôle d'accès)
2. ACL avec superutilisateur
3. ACL sans utilisateurs : particulièrement utile pour les systèmes qui n'ont pas d'authentification ou de connexion utilisateur.
4. ACL sans ressources : certains scénarios peuvent cibler un type de ressources plutôt qu'une ressource individuelle en utilisant des permissions comme write-article, read-log. Cela ne contrôle pas l'accès à un article ou un journal spécifique.
5. RBAC (Contrôle d'accès basé sur les rôles)
6. RBAC avec rôles de ressources : les utilisateurs et les ressources peuvent avoir des rôles (ou groupes) en même temps.
7. RBAC avec domaines/locataires : les utilisateurs peuvent avoir différents ensembles de rôles pour différents domaines/locataires.
8. ABAC (Contrôle d'accès basé sur les attributs) : du sucre syntaxique comme resource.Owner peut être utilisé pour obtenir l'attribut d'une ressource.
9. RESTful : prend en charge des chemins comme /res/*, /res/:id et des méthodes HTTP comme GET, POST, , .

Comment cela fonctionne-t-il ?

Dans Casbin, un modèle de contrôle d'accès est abstrait dans un fichier CONF basé sur le métamodèle PERM (Policy, Effect, Request, Matchers). Ainsi, changer ou mettre à niveau le mécanisme d'autorisation d'un projet est aussi simple que de modifier une configuration. Vous pouvez personnaliser votre propre modèle de contrôle d'accès en combinant les modèles disponibles. Par exemple, vous pouvez réunir les rôles RBAC et les attributs ABAC dans un même modèle et partager un ensemble de règles de politique.

Le modèle le plus basique et le plus simple de Casbin est l'ACL. Le fichier CONF du modèle ACL est :

# Request definition
[request_definition]
r = sub, obj, act

# Policy definition
[policy_definition]
p = sub, obj, act

# Policy effect
[policy_effect]
e = some(where (p.eft == allow))

# Matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

Un exemple de politique pour le modèle ACL ressemble à :

p, alice, data1, read
p, bob, data2, write

Cela signifie :

• alice peut lire data1
• bob peut écrire data2

Nous prenons également en charge le mode multiligne en ajoutant '\' à la fin :

# Matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj \
  && r.act == p.act

De plus, si vous utilisez ABAC, vous pouvez essayer l'opérateur in comme suit dans l'édition Casbin golang (jCasbin et Node-Casbin ne sont pas encore pris en charge) :

# Matchers
[matchers]
m = r.obj == p.obj && r.act == p.act || r.obj in ('data2', 'data3')

Mais vous DEVEZ vous assurer que la longueur du tableau est SUPÉRIEURE à 1, sinon cela provoquera un panic.

Pour plus d'opérateurs, vous pouvez jeter un œil à govaluate

Fonctionnalités

Ce que fait Apache Casbin :

1. applique la politique sous la forme classique {subject, object, action} ou sous une forme personnalisée comme vous l'avez définie, les autorisations d'accord et de refus étant toutes deux prises en charge.
2. gère le stockage du modèle de contrôle d'accès et de sa politique.
3. gère les correspondances rôle-utilisateur et rôle-rôle (aussi appelé hiérarchie des rôles dans RBAC).
4. prend en charge un superutilisateur intégré comme root ou administrator. Un superutilisateur peut tout faire sans permissions explicites.
5. plusieurs opérateurs intégrés pour prendre en charge la correspondance des règles. Par exemple, keyMatch peut mapper une clé de ressource /foo/bar vers le motif /foo*.

Ce que Apache Casbin ne fait PAS :

1. l'authentification (c'est-à-dire vérifier username et password lorsqu'un utilisateur se connecte)
2. gérer la liste des utilisateurs ou des rôles. Je pense qu'il est plus pratique que le projet lui-même gère ces entités. Les utilisateurs ont généralement leurs mots de passe, et Apache Casbin n'est pas conçu comme un conteneur de mots de passe. Cependant, Apache Casbin stocke la correspondance utilisateur-rôle pour le scénario RBAC.

Installation

go get github.com/casbin/casbin/v3

Documentation

https://casbin.apache.org/docs/overview

Éditeur en ligne

Vous pouvez également utiliser l'éditeur en ligne (https://casbin.apache.org/editor/) pour écrire votre modèle et votre politique Casbin dans votre navigateur web. Il fournit des fonctionnalités telles que syntax highlighting et code completion, tout comme un IDE pour un langage de programmation.

Tutoriels

https://casbin.apache.org/docs/tutorials

Pour commencer

1. Créez un enforcer Casbin avec un fichier de modèle et un fichier de politique :

   root@kitploit:~

   e, _ := casbin.NewEnforcer("path/to/model.conf", "path/to/policy.csv")
   

Remarque : vous pouvez également initialiser un enforcer avec une politique en base de données au lieu d'un fichier, voir la section Persistance des politiques pour plus de détails.

2. Ajoutez un hook d'application dans votre code juste avant que l'accès ne se produise :

   root@kitploit:~

   sub := "alice" // the user that wants to access a resource.
   obj := "data1" // the resource that is going to be accessed.
   act := "read" // the operation that the user performs on the resource.
   
   if res, _ := e.Enforce(sub, obj, act); res {
       // permit alice to read data1
   } else {
       // deny the request, show an error
   }
   

3. Outre le fichier de politique statique, Apache Casbin fournit également une API pour la gestion des permissions à l'exécution. Par exemple, vous pouvez obtenir tous les rôles assignés à un utilisateur comme ci-dessous :

   root@kitploit:~

   roles, _ := e.GetImplicitRolesForUser(sub)
   

Voir API de gestion des politiques pour plus d'utilisations.

Gestion des politiques

Apache Casbin fournit deux ensembles d'API pour gérer les permissions :

• Management API : l'API primitive qui fournit un support complet pour la gestion des politiques Apache Casbin.
• RBAC API : une API plus conviviale pour RBAC. Cette API est un sous-ensemble de Management API. Les utilisateurs de RBAC peuvent utiliser cette API pour simplifier le code.

Nous fournissons également une interface web pour la gestion des modèles et la gestion des politiques :

Persistance des politiques

https://casbin.apache.org/docs/adapters

Cohérence des politiques entre plusieurs nœuds

https://casbin.apache.org/docs/watchers

Gestionnaire de rôles

https://casbin.apache.org/docs/role-managers

Benchmarks

https://casbin.apache.org/docs/benchmark

Exemples

Middlewares

Middlewares d'autorisation pour les frameworks web : https://casbin.apache.org/docs/middlewares

Nos utilisateurs

https://casbin.apache.org/docs/adopters

Comment contribuer

Merci de lire le guide de contribution.

Contributeurs

Ce projet existe grâce à toutes les personnes qui contribuent.

Historique des étoiles

Licence

Ce projet est distribué sous la licence Apache 2.0.

Contact

Si vous avez des problèmes ou des demandes de fonctionnalités, n'hésitez pas à nous contacter. Les PR sont les bienvenues.

• https://github.com/apache/casbin/issues
• https://discord.gg/S5UjpzGZjN