Translate

Syntaxe pour les modèles

  • Un modèle CONF doit avoir au moins quatre sections : [request_definition], [policy_definition], [policy_effect], [matchers].

  • Si un modèle utilise RBAC, il devrait également ajouter la section [role_definition].

  • Un modèle CONF peut contenir des commentaires. Les commentaires commencent par #, et # commentera le reste de la ligne.

Définition de la requête

[request_definition] est la définition de la requête d'accès. Elle définit les arguments dans e.Enforce(...) fonction.

[request_definition]
r = sub, obj, act

sub, obj, act représente le triple classique : accès à l'entité (Sujet), ressource accédée (Objet) et la méthode d'accès (Action). Cependant, vous pouvez personnaliser votre propre formulaire de requête, comme sub, agir si vous n'avez pas besoin de spécifier une ressource particulière, ou sub, sub2, obj, act si vous avez deux entités d'accès.

Définition de la politique

[policy_definition] est la définition de la politique. Elle définit le sens de la politique. Par exemple, nous avons le modèle suivant :

[policy_definition]
p = sub, obj, act
p2 = sub, act

Et nous avons la politique suivante (si dans un fichier de politiques)

p, alice, data1, lire
p2, bob, write-all-objects

Chaque ligne dans une politique est appelée règle de police. Chaque règle de politique commence par un type de politique, par exemple p, p2. Il est utilisé pour correspondre à la définition de la politique s'il y a plusieurs définitions. La politique ci-dessus montre le caractère contraignant suivant. La reliure peut être utilisée dans le matcher.

(alice, data1, read) -> (p.sub, p.obj, p.act)
(bob, write-all-objects) -> (p2.sub, p2.act)
tip

Les éléments d'une règle de politique sont toujours considérés commestring. Si vous avez des questions à ce sujet, veuillez consulter la discussion sur: https://github.com/casbin/casbin/issues/113

Effet de la politique

[policy_effect] est la définition de l'effet de politique. Il définit si la requête d'accès doit être approuvée si plusieurs règles de politique correspondent à la requête. Par exemple, une règle autorise et l'autre refuse.

[policy_effect]
e = quelque part (p.eft == allow))

L'effet de la politique ci-dessus signifie s'il y a une règle de politique correspondante de autoriser, l'effet final est autoriser (aka allow-override). p.eft est l'effet d'une politique, il peut être autoriser ou refuser. C'est optionnel et la valeur par défaut est autoriser. Donc, comme nous ne l'avons pas spécifié ci-dessus, il utilise la valeur par défaut.

Un autre exemple d'effet de politique est :

[policy_effect]
e = !some(where (p.eft == refy))

Cela signifie que s'il n'y a pas de règles de politique correspondantes derefus, l'effet final est autoriser (aka refus de remplacement). certains signifient : s'il existe une règle de politique correspondante. n'importe quel signifie : toutes les règles de politique correspondantes (non utilisées ici). L'effet de la politique peut même être lié aux expressions logiques:

[policy_effect]
e = some(where (p.eft == allow)) && !some(where (p.eft == refy))

Cela signifie qu'au moins une règle de politique correspondante deautorise, et qu'il n'y a pas de règle de politique correspondante derefus. Donc, de cette façon, les autorisations d’autorisation et de refus sont soutenues et les dérogations de refus.

note

Bien que nous ayons conçu la syntaxe de l'effet de politique comme ci-dessus, les implémentations actuelles n'utilisent que des effets de politique codés en dur, car nous avons trouvé qu'il n'y avait pas grand besoin de ce genre de flexibilité. Donc, pour l'instant, vous devez utiliser l'un des effets de la politique intégrée au lieu de personnaliser le vôtre.

Les effets de politique intégrée pris en charge sont :

Effet de la politiqueSensExemple
quelque part (p.eft == allow))autoriser-substituerACL, RBAC, etc.
!some(où (p.eft == refy))refus de surchargerRefuser la substitution
some(where (p.eft == allow)) && !some(where (p.eft == refy))autoriser/refuserAllumer et refuser
priorité(p.eft) || refuserprioritéPriorité
SujetPriority(p.eft)base de priorité sur le rôleSujet-Priorité

Matchs

[matchers] est la définition des correspondants à la politique. Les correspondants sont des expressions. Il définit comment les règles de politique sont évaluées par rapport à la demande.

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

Le résultat ci-dessus est le plus simple, cela signifie que le sujet, l'objet et l'action dans une requête doivent correspondre à ceux d'une règle de police.

Vous pouvez utiliser l'arithmétique comme +, -, *, / et les opérateurs logiques comme &&, ||, ! dans les matchers.

Type de sections multiples

Si vous avez besoin de plusieurs définitions de politique ou de plusieurs correspondants, vous pouvez utiliser comme p2, m2. En fait, toutes les quatre sections ci-dessus peuvent utiliser plusieurs types et la syntaxe est r+ numéro, comme r2, e2. Par défaut, ces quatre sections doivent correspondre à une seule. Comme votre r2 n'utilisera que le matcher m2 pour correspondre aux politiques p2.

Vous pouvez passer dans EnforceContext en tant que premier paramètre de la méthode enforce pour spécifier les types, le EnforceContext est comme ceci

EnforceContext{"r2","p2","e2","m2"}
type EnforceContext struct {
    RType string
    PType string
    EType string
    MType string
}
const enforceContext = new EnforceContext('r2', 'p2', 'e2', 'm2');
classe EnforceContext {
  constructor(rType, pType, eType, mType) {
    ceci. Type = pType;
    this.eType = eType;
    ceci. Type = mType;
    this.rType = rType;
  }
 } }
EnforceContext enforceContext = new EnforceContext("2");
classe publique EnforceContext {
    pType de chaîne privée ;
    eType de chaîne privée ;
    chaîne privée mType;
    rType de chaîne privée ;
    public EnforceContext(String suffix) {
      ceci. Type = "p" + suffixe;
      cette.eType = "e" + suffixe;
      ceci. Type = "m" + suffixe;
      cette.rType = "r" + suffixe;
    }
}

Exemple d'utilisation, voir modèle et politique, la requête est la suivante

// Passez dans un suffixe en tant que paramètre à NewEnforceContext,comme 2 ou 3 et il créera r2,p2,etc..
enforceContext := NewEnforceContext("2")
// Vous pouvez également spécifier un certain type individuellement
enforceContext. Type = "e"
// Ne pas passer dans EnforceContext,le défaut est r,p,e,m
e. nforce("alice", "data2", "read") // true
// passe dans EnforceContext
e. nforce(enforceContext, struct{ Age int }{Age: 70}, "/data1", "read") //false
e. nforce(enforceContext, struct{ Age int }{Age: 30}, "/data1", "read") //true
// Passez dans un suffixe en tant que paramètre à NewEnforceContext,comme 2 ou 3 et il créera r2,p2,etc..
const enforceContext = new NewEnforceContext('2');
// Vous pouvez également spécifier un certain type individuellement
enforceContext. Type = "e"
// Ne pas passer dans EnforceContext,le défaut est r,p,e,m
e. nforce("alice", "data2", "read") // true
// passe dans EnforceContext
e. nforce(enforceContext, {Age: 70}, "/data1", "read") //false
e. nforce(enforceContext, {Age: 30}, "/data1", "read") //true
```java // Passe dans un suffixe comme paramètre à NewEnforceContext, de sorte que 2 ou 3 et il va créer r2, p2, etc. EnforceContext enforceContext = new EnforceContext("2"); // Vous pouvez également spécifier un certain type individuellement enforceContext. eteType("e"); // Ne passe pas dans EnforceContext, la valeur par défaut est r, p, e, m e. nforce("alice", "data2", "read"); // true // Pass in EnforceContext // TestEvalRule est situé sur https://github. om/casbin/jcasbin/blob/master/src/test/java/org/casbin/jcasbin/main/AbacAPIUnitTest.java#L56 e.enforce(enforceContext, new AbacAPIUnitTest.TestEvalRule("alice", 70), "/data1", "read"); // false e.enforce(enforceContext, new AbacAPIUnitTest.TestEvalRule("alice", 30), "/data1", "read"); // true ```

Special Grammer

Vous pouvez également utiliser dans, le seul opérateur avec un nom de texte. Cet opérateur vérifie le tableau à droite pour voir s'il contient une valeur égale à la valeur à gauche. L'égalité est déterminée par l'utilisation de l'opérateur == et cette bibliothèque ne vérifie pas les types entre les valeurs. Toutes les deux valeurs, lorsqu'elles sont converties en interface{}, et peuvent toujours être vérifiées si l'égalité avec == agit comme prévu. Notez que vous pouvez utiliser un paramètre pour le tableau, mais ce doit être une []interface{}.

Reportez-vous également à rbac_model_matcher_using_in_op, keyget2_model et keyget_model

Exemple:

[request_definition]
r = sub, obj
...
[matchers]
m = r.sub.Name in (r.obj.Admins)

e.Enforce(Sub{Name: "alice"}, Obj{Name: "un livre", Admins: []interface{}{"alice", "bob"}})

Évaluateur d'expressions

L'évaluation de la correspondance à Casbin est implémentée par des évaluateurs d'expressions dans chaque langue. Casbin intègre ses pouvoirs pour fournir le langage PERM unifié. En plus de toute la syntaxe de modèle fournie ici, ces évaluateurs d'expressions peuvent fournir des fonctionnalités supplémentaires, qui peuvent ne pas être supportées par un autre langage ou une implémentation. Utilisez-la à vos propres risques.

L'expression utilisée par chaque implémentation de Casbin est :

ImplémentationLangueÉvaluateur d'expressions
CasbinGolanghttps://github.com/Knetic/govaluate
jCasbinJavahttps://github.com/killme2008/aviator
Node-CasbinNode.jshttps://github.com/donmccurdy/expression-eval
PHP-CasbinPHPhttps://github.com/symfony/expression-language
PyCasbinPythonhttps://github.com/danthedeckie/simpleeval
Casbin.NETN° Chttps://github.com/davideicardi/DynamicExpresso
Casbin4DDelphihttps://github.com/casbin4d/Casbin4D/tree/master/SourceCode/Common/Troisième%20Party/TExpressionParser
casbin-rsRouillehttps://github.com/jonathandturner/rhai
casbin-cppC++https://github.com/ArashPartow/exprtk
note

Si vous rencontrez un problème de performance à propos de Casbin, c'est probablement dû à la faible efficacité de l'évaluateur d'expression. Vous pouvez tous les deux envoyer un problème à Casbin ou à l’évaluateur d’expression directement pour obtenir des conseils pour accélérer. Voir la section Benchmarks pour plus de détails.

← Modèles pris en chargeEffet →