Los geht's

Installation

Go

go get github.com/casbin/casbin/v2

Java

Für Maven:

<!-- https://mvnrepository.com/artifact/org.casbin/jcasbin -->
<dependency>
    <groupId>org.casbin</groupId>
    <artifactId>jcasbin</artifactId>
    <version>1.x.y</version>
</dependency>

Node.js

# NPM
npm install casbin --save

# Yarn
yarn add casbin

PHP

Require this package in the composer.json of your project to download the package:

Komponist benötigt Kasbin/Kasbin

Python

pip install casbin

.NET

dotnet add package Casbin.NET

C++

# Download source
git clone https://github.com/casbin/casbin-cpp.git

# Generate project files
cd casbin-cpp && mkdir build && cd build && cmake .. -DCMAKE_BUILD_TYPE=Release

# Build and install casbin
cmake --build . --config Release --target casbin install -j 10

Rust

cargo install cargo-edit
cargo add casbin

// If you use async-std as async executor
cargo add async-std

// If you use tokio as async executor, make sure you activate its `macros` feature
cargo add tokio

Delphi

Casbin4D kommt in einem Paket (derzeit für Delphi 10.3 Rio) und Sie können es in der IDE installieren. Es gibt jedoch keine visuellen Komponenten, was bedeutet, dass Sie die Units unabhängig von den Paketen verwenden können. Importieren Sie einfach die Einheiten in Ihrem Projekt (vorausgesetzt Sie haben nichts dagegen).

Lua

luarocks casbin installieren  

If you receive an error message: "Your user does not have write permissions in /usr/local/lib/luarocks/rocks", you may want to run the command as a privileged user or use your local tree with --local. To fix the error, you can add --local behind your command like this:

luarocks install casbin --local

Neuer Casbin-Vollstrecker

Casbin uses configuration files to define the access control model.

There are two configuration files: model.conf and policy.csv. model.conf stores the access model, while policy.csv stores the specific user permission configuration. The usage of Casbin is very straightforward. We only need to create one main structure: enforcer. Beim Bau dieser Struktur werden model.conf und policy.csv geladen.

In other words, to create a Casbin enforcer, you need to provide a Model and an Adapter.

Casbin provides a FileAdapter that you can use. See Adapter for more information.

• Example of using the Model file and the default FileAdapter:

Go

import "github.com/casbin/casbin/v2"

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

Java

import org.casbin.jcasbin.main.Enforcer;

Enforcer e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

Node.js

import { newEnforcer } from 'casbin';

const e = await newEnforcer('path/to/model.conf', 'path/to/policy.csv');

PHP

require_once './vendor/autoload.php';

use Casbin\Enforcer;

$e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

Python

import casbin

e = casbin.Enforcer("path/to/model.conf", "path/to/policy.csv")

.NET

using NetCasbin; 

var e = new Enforcer("path/to/model.conf", "path/to/policy.csv");

C++

#include <iostream>
#include <casbin/casbin.h>

int main() {
    // Enforcer erstellen
    casbin::Enforcer e("path/to/model.conf", "path/to/policy.csv");

    // Code ..
}

Delphi

var
  casbin: ICasbin;
begin
  casbin := TCasbin.Create('path/to/model.conf', 'path/to/policy.csv');
  ...
end

Rust

benutze Casbin::prelude::*;

// Wenn Sie async_td als async executor verwenden
#[cfg(feature = "runtime-async-std")]
#[async_std::main]
async fn main() -> Result<()> {
    let mut e = Enforcer::new("path/to/model). onf", "path/to/policy.csv"). warten?;
    Ok())
}

// Wenn Sie tokio als async executor verwenden
#[cfg(feature = "runtime-tokio")]
#[tokio::main]
async fn main() -> Result<()> {
    let mut e = Enforcer::new("path/to/model). onf", "path/to/policy.csv").await?;
    Ok())
}

Lua

local Enforcer = require("casbin")
local e = Enforcer:new("path/to/model.conf", "path/to/policy.csv") -- Der Casbin Enforcer

• Den Modelltext mit einem anderen Adapter verwenden:

Go

import (
    "log"

    "github.com/casbin/v2"
    "github.com/casbin/casbin/v2/model"
    xormadapter "github.com/casbin/xorm-adapter/v2"
    _ "github.com/go-sql-driver/mysql"
)

// Xorm-Adapter mit MySQL-Datenbank initialisieren.
a, err := xormadapter.NewAdapter("mysql", "mysql_username:mysql_password@tcp(127.0.0.1:3306)/")
if err != nil {
    log.Fatalf("error: adapter: %s", err)
}

m, err := model.NewModelFromString(`
[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
`)
if err != nil {
    log.Fatalf("error: model: %s", err)
}

e, err := casbin.NewEnforcer(m, a)
if err != nil {
    log.Fatalf("error: enforcer: %s", err)
}

Python

import casbin
import casbin_sqlalchemy_adapter


# SQLAlchemy Casbin Adapter mit SQLLite DB
adapter = casbin_sqlalchemy_adapter. dapter('sqlite:///test.db')

# Erstelle eine Konfigurationsmodellrichtlinie
mit open("rbac_example_model.conf", "w") wie f:
    f. rite("""
    [request_definition]
    r = sub, obj, handeln

    [policy_definition]
    p = sub, obj, act

    [policy_effect]
    e = some(where (p. ft == allow))

    [matchers]
    m = r. ub == p.sub && r.obj == p.obj && r.act == p. ct
    """)

# Erzwingen aus Adapter und Konfigurationsrichtlinie
e = casbin.Enforcer('rbac_example_model.conf', Adapter)

Berechtigungen überprüfen

Fügen Sie einen Strafverfolgungshaken direkt vor dem Zugriff in Ihren Code ein:

Go

sub := "alice" // der Benutzer, der auf eine Ressource zugreifen möchte.
obj := "data1" // die Ressource, auf die zugegriffen werden soll.
act := "read" // die Operation, die der Benutzer auf der Ressource ausführt.

ok, err := e. nforce(sub, obj, act)

wenn fehler! nil {
    // err
}

if ok == true {
    // Erlaube dem Alice das Lesen von data1
} else {
    // Anfrage verweigern zeigen einen Fehler
}

// Sie könnten BatchEnforce() verwenden, um einige Anfragen in Batches zu erzwingen.
// Diese Methode gibt ein bool Slice zurück und der Slice-Index entspricht dem Datensatzindex des zweidimensionalen Arrays.
// z.B. Ergebnis[0] ist das Ergebnis von {"alice", "data1", "read"}
results, err := e.BatchEnforce([][][]interface{}{{"alice", "data1", "read"}, {"bob", "data2", "write"}, {"jack", "data3", "read"}})

Java

String sub = "alice"; // der Benutzer, der auf eine Ressource zugreifen möchte.
String obj = "data1"; // die Ressource, auf die zugegriffen werden soll.
String act = "read"; // die Operation, die der Benutzer auf der Ressource ausführt.

wenn (e. nforce(unter, obj, act) == true) {
    // Erlaubt dem Alice Daten 1
} else {
    // Anfrage ablehnen zeige einen Fehler
}

Node.js

const sub = 'alice'; // der Benutzer, der auf eine Ressource zugreifen möchte.
const obj = 'data1'; // die Ressource, auf die zugegriffen werden soll.
const act = 'read'; // die Operation, die der Benutzer auf der Ressource ausführt.

if (warten e. nforce(unter, obj, act)) === true) {
    // Erlaubt dem Alice Daten 1
} else {
    // Anfrage ablehnen zeige einen Fehler
}

PHP

$sub = "alice"; // der Benutzer, der auf eine Ressource zugreifen möchte.
$obj = "data1"; // die Ressource, auf die zugegriffen wird.
$act = "lesen"; // die Operation, die der Benutzer auf der Ressource ausführt.

if ($e->enforce($sub, $obj, $act) === true) {
    // Erlaube dem Alice Daten 1
} sonst {
    // Anfrage ablehnen zeige einen Fehler
}

Python

sub = "alice" # der Benutzer, der auf eine Ressource zugreifen möchte.
obj = "data1" # die Ressource, auf die zugegriffen wird.
act = "read" # die Operation, die der Benutzer auf der Ressource ausführt.

if e.enforce(sub, obj, act):
    # Erlaube dem Alice Daten 1
    weitergeben
else:
    # die Anfrage verweigern, zeige einen Fehler
    Weitergabe an

.NET

var sub = "alice"; # der Benutzer, der auf eine Ressource zugreifen möchte.
var obj = "data1"; # die Ressource, auf die zugegriffen wird.
var act = "read"; # die Operation, die der Benutzer auf der Ressource ausführt.

wenn (warten e. nforceAsync(Unter, obj, act)) 
{
    // Erlaubt dem Alice Daten 1
}
else
{
    // Anfrage ablehnen zeige einen Fehler
}

C++

    casbin::Enforcer e("../assets/model.conf", "../assets/policy.csv");

    if (e. nforce({"alice", "/alice_data/hello", "GET"})) {
        std::cout << "Erzwinge OK" << std::endl;
    } else {
        std::cout << "Erzwinge NICHT Good" << std::endl;
    }

    if (e. nforce({"alice", "/alice_data/hello", "POST"})) {
        std::cout << "Erzwinge OK" << std::endl;
    } else {
        std::cout << "Erzwinge NICHT Good" << std::endl;
}

Delphi

if casbin.enforce(['alice,data1,read']) then
  // Alice ist super glücklich, da sie Daten lesen kann
sonst
  // Alice ist traurig

Rust

  let sub = "alice"; // der Benutzer, der auf eine Ressource zugreifen möchte.
  let obj = "data1"; // die Ressource, auf die zugegriffen werden soll.
  let act = "read"; // die Operation, die der Benutzer auf der Ressource ausführt.

  if e.enforce(sub, obj, act)).warten Sie? {
      // Erlaube dem Alice Daten 1
  } sonst {
      // Fehler auftreten
}

Lua

if e:enforce("alice", "data1", "read") then
   -- allow alice to read data1
else
   -- deny the request, show an error
end

Casbin stellt auch die API für das Berechtigungsmanagement zur Laufzeit zur Verfügung. Zum Beispiel können Sie alle Rollen einem Benutzer zuweisen wie unten:

Go

roles, err := e.GetRolesForUser("alice")

Java

List<String> roles = e.getRolesForUser("alice");

Node.js

const roles = await e.getRolesForUser('alice');

PHP

$roles = $e->getRolesForUser("alice");

Python

roles = e.get_roles_for_user("alice")

.NET

var roles = e.GetRolesForUser("alice");

Delphi

roles = e.rolesForEntity("alice")

Rust

let roles = e.get_roles_for_user("alice");

Lua

local roles = e:GetRolesForUser("alice")

Siehe Management API und RBAC API für mehr Nutzung.

Bitte beachten Sie die Testfälle für mehr Verwendung.