Translate

Syntax für Modelle

  • Ein Modell CONF sollte mindestens vier Bereiche haben: [request_definition], [policy_definition], [policy_effect], [matchers].

  • Wenn ein Modell RBAC verwendet, sollte es auch den [role_definition] Bereich hinzufügen.

  • Ein Modell CONF kann Kommentare enthalten. Die Kommentare beginnen mit #, und # wird den Rest der Zeile kommentieren.

Anforderungsdefinition

[request_definition] ist die Definition für die Zugriffsanfrage. Sie definiert die Argumente in e.Enforce(...) Funktion.

[request_definition]
r = sub, obj, handeln

sub, obj, act repräsentiert das klassische Dreieck: Zugriff auf Entität (Betreff), auf Ressource (Objekt) und Zugriffsmethode (Aktion). Sie können jedoch Ihr eigenes Anfrageformular anpassen, wie zum Beispiel sub, handeln wenn Sie keine bestimmte Ressource angeben müssen, oder sub, sub2, obj, handeln Sie , wenn Sie irgendwie zwei Zugriffseinheiten haben.

Richtlinien-Definition

[policy_definition] ist die Definition der Richtlinie. Sie definiert die Bedeutung der Richtlinie. Zum Beispiel haben wir folgendes Modell:

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

Und wir haben folgende Richtlinien (falls in einer Richtlinien-Datei)

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

Jede Zeile in einer Politik wird als politische Regel bezeichnet. Jede Richtlinien-Regel beginnt mit einem Richtlinientyp, z. B. p, p2. Es wird verwendet, um der Richtlinien-Definition zu entsprechen, wenn es mehrere Definitionen gibt. Die obige Richtlinie zeigt die folgende Verbindung. Die Bindung kann im Matcher verwendet werden.

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

Die Elemente in einer Regelregel werden immer alsStringbetrachtet. Wenn Sie dazu Fragen haben, lesen Sie bitte die Diskussion unter: https://github.com/casbin/casbin/issues/113

Richtlinien-Effekt

[policy_effect] ist die Definition für den Policy-Effekt. Es legt fest, ob die Zugriffsanfrage genehmigt werden soll, wenn mehrere Richtlinien-Regeln mit der Anfrage übereinstimmen. Zum Beispiel erlaubt eine Regel und die andere verweigert.

[policy_effect]
e = irgendwe(wo (p.eft == erlaubt))

Der obige Richtlinien-Effekt bedeutet, wenn es eine übereinstimmende Richtlinien-Regel von allowgibt, der endgültige Effekt ist allow (aka allow-override). p.eft ist der Effekt für eine Richtlinie, es kann erlauben oder verweigern. Es ist optional und der Standardwert erlaubt. Da wir es nicht oben angegeben haben, verwendet es den Standardwert.

Ein weiteres Beispiel für die politische Wirkung ist:

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

Es bedeutet, wenn es keine übereinstimmenden Regeln fürleugnengibt, der endgültige Effekt ist allow (aka deny-override). einige bedeutet: wenn es eine übereinstimmende Regel gibt. irgendein bedeutet: alle übereinstimmenden Richtlinien-Regeln (nicht hier verwendet). Der politische Effekt kann sogar mit logischen Ausdrücken verbunden werden:

[policy_effect]
e = irgendwe(wo (p.eft == allow)) && !some(where (p.eft == deny))

Es bedeutet mindestens eine übereinstimmende Richtlinien-Regel vonallow, und es gibt keine übereinstimmende Richtlinien-Regel vondeny. Auf diese Weise werden sowohl die Genehmigungen als auch die Verweigerung von Genehmigungen unterstützt, und das Leugnen überschreibt.

note

, obwohl wir die Syntax des Policy-Effekts wie oben beschrieben gestaltet haben, die aktuellen Implementierungen nur mit hartkodiertem Policy-Effekt, da wir für diese Art von Flexibilität keine große Notwendigkeit gefunden haben. Daher müssen Sie vorerst einen der integrierten Policy-Effekte verwenden, anstatt Ihren eigenen zu personalisieren.

Die unterstützten Richtlinien-Effekte sind:

Richtlinien-EffektBedeutungBeispiel
irgend (wo (p.eft == erlaubt))zulassenACL, RBAC, etc.
!some(where (p.eft == deny))verweigeren-überschreibenVerweigerung überschreiben
irgendwo (p.eft == allow)) && !some(where (p.eft == deny))zulassen und ablehnenZulassen und verweigern
priority(p.eft) || verweigernprioritätPriorität
themtpriority(p.eft)prioritäre Basis für RolleBetreff-Priorität

Matcher

[matchers] ist die Definition für Policy-Matcher. Die Matcher sind Ausdrücke. Sie legt fest, wie die Richtlinien-Regeln mit der Anforderung bewertet werden.

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

Der obige Matcher ist der einfachste, es bedeutet, dass Subjekt, Objekt und Aktion in einer Anfrage die in einer Regel der Richtlinie entsprechen sollten.

Sie können die Arithmetik wie +, -, *, / und logische Operatoren wie &&, |, |, verwenden! in Übereinstimmungen.

Typ mehrerer Abschnitte

Wenn Sie mehrere Richtlinien-Definitionen oder mehrere Übereinstimmungen benötigen, können Sie wie p2, m2 verwenden. Tatsächlich können alle oben genannten vier Abschnitte mehrere Typen verwenden und die Syntax ist r+number, wie r2, e2. Standardmäßig sollten diese vier Abschnitte einem entsprechen. So wie Ihr r2 verwendet nur einen Matcher m2 , um Richtlinien p2 abzugleichen.

Sie können EnforceContext als ersten Parameter von enforce Methode durchführen, um die Typen anzugeben, der Vollstreckungskontext ist wie folgt

EnforceContext{"r2","p2","e2","m2"}
EnforceContext struct {
    RType string
    PType String
    EType String
    MType String
}
const enforceContext = new EnforceContext('r2', 'p2', 'e2', 'm2');
Klasse EnforceContext {
  constructor(rType, pType, eType, mType) {
    dies. Typ = pType;
    this.eType = eType;
    dies. Typ = mType;
    this.rType = rType;
  }
}
EnforceContext enforceContext = new EnforceContext("2");
public class EnforceContext {
    private String pType;
    private String eType;
    private String mType;
    private String rType;
    public EnforceContext(String suffix) {
      dies. Typ = "p" + Suffix;
      this.eType = "e" + Suffix;
      . Typ = "m" + Suffix;
      this.rType = "r" + Suffix;
    }
}

Beispiel Verwendung, siehe Modell und Richtlinie, die Anfrage ist wie folgt

// Pass in einem Suffix als Parameter an NewEnforceContext,wie 2 oder 3 und es wird r2,p2,etc..
enforceContext := NewEnforceContext("2")
// Sie können auch einen bestimmten Typ individuell
enforceContext angeben. Typ = "e"
// Nicht in EnforceContext,die Standardeinstellung ist r,p,e,m
e. nforce("alice", "data2", "read") // true
// durchlaufen in EnforceContext
e. nforce(enforceContext, struct{ Age int }{Age: 70}, "/data1", "read") //false
e. nforce(enforceContext, struct{ Age int }{Age: 30}, "/data1", "read") //true
// Pass in einem Suffix als Parameter an NewEnforceContext,wie 2 oder 3 und es wird r2,p2,etc..
const enforceContext = new NewEnforceContext('2');
// Sie können auch einen bestimmten Typ individuell
enforceContext angeben. Typ = "e"
// Nicht in EnforceContext,die Standardeinstellung ist r,p,e,m
e. nforce("alice", "data2", "read") // true
// durchlaufen in EnforceContext
e. nforce(enforceContext, {Age: 70}, "/data1", "read") //false
e. nforce(enforceContext, {Age: 30}, "/data1", "read") //true
```java // In einem Suffix als Parameter an NewEnforceContext übergeben uch as 2 oder 3 und es wird r2, p2, etc.. EnforceContext enforceContext = new EnforceContext("2"); // Sie können auch einen bestimmten Typ individuell enforceContext angeben. eteType("e"); // EnforceContext nicht übergeben, Standard ist r, p, e, m e. nforce("alice", "data2", "read"); // true // EnforceContext übergeben // TestEvalRule befindet sich in 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 true e.enforce(enforceContext, new AbacAPIUnitTestEval.TestEvalRule("alice", 30), "/data1", "read"); // true true true true ```

Special Grammer

Sie können auch inverwenden, der einzige Operator mit einem Textnamen. Dieser Operator prüft das Array auf der rechten Seite, um zu sehen, ob es einen Wert enthält, der gleich dem linken Wert ist. Die Gleichberechtigung wird durch den Operator == bestimmt und diese Bibliothek prüft nicht die Typen zwischen den Werten. Alle zwei Werte, wenn sie an die Schnittstelle gewirkt werden {}, und immer noch auf die Gleichberechtigung mit == überprüft werden können, werden wie erwartet funktionieren. Beachten Sie, dass Sie einen Parameter für das Array verwenden können, aber es muss eine []Schnittstelle sein{} sein.

Verweisen Sie auch auf rbac_model_matcher_using_in_op, keyget2_model und keyget_model

Beispiel:

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

e.Enforce(Unter{Name: "alice"}, Obj{Name: "a book", Admins: []interface{}{"alice", "bob"}})

Ausdruck-Auswerter

Die Matcher-Auswertung in Casbin wird von Auswertern in jeder Sprache implementiert. Casbin integriert ihre Kompetenzen zur Bereitstellung der einheitlichen PERM-Sprache. Abgesehen von all der hier zur Verfügung gestellten Modellsyntax können diese Auswerter zusätzliche Funktionalität bieten, die möglicherweise nicht von einer anderen Sprache oder Implementierung unterstützt wird. Die Nutzung erfolgt auf eigene Gefahr.

Die Auswerter für jede Casbin-Implementierung sind:

ImplementierungSpracheAusdruck-Auswerter
CasbinGolanghttps://github.com/Knetic/govaluate
jCasbinJaltahttps://github.com/killme2008/aviator
Node-CasbinNode.jshttps://de.github.com/donmccurdy/expression-eval
PHP-CasbinPHPhttps://github.com/symfony/expression-language
PyCasbinPythonhttps://github.com/danthedeckie/simpleeval
Casbin.NETC#https://github.com/davideicardi/DynamicExpresso
Casbin4DJenniferhttps://github.com/casbin4d/Casbin4D/tree/master/SourceCode/Common/Third%20Party/TExpressionParser
casbin-rsRosthttps://de.github.com/jonathandturner/rhai
casbin-cppC++https://github.com/ArashPartow/exprtk
note

Wenn Sie Performance-Probleme mit Kasbin haben, wird dies wahrscheinlich durch die geringe Effizienz des Ausdrucks Auswertungs-Auswerter verursacht. Sie können sowohl Probleme an Kasbin oder den Ausdruck-Auswerter direkt senden um Ratschläge zu beschleunigen. Siehe Benchmarks Abschnitt für Details.

← Unterstützte ModelleEffektor →