Los geht's
Installation
- Go
- Java
- Node.js
- PHP
- Python
- .NET
- C++
- Rust
- Delphi
- Lua
go get github.com/casbin/casbin/v2
Für Maven:
<!-- https://mvnrepository.com/artifact/org.casbin/jcasbin -->
<dependency>
<groupId>org.casbin</groupId>
<artifactId>jcasbin</artifactId>
<version>1.x.y</version>
</dependency>
# NPM
npm install casbin --save
# Yarn
yarn add casbin
Require this package in the composer.json
of your project to download the package:
Komponist benötigt Kasbin/Kasbin
pip install casbin
dotnet add package Casbin.NET
# 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
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
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).
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
- Java
- Node.js
- PHP
- Python
- .NET
- C++
- Delphi
- Rust
- Lua
import "github.com/casbin/casbin/v2"
e, err := casbin.NewEnforcer("path/to/model.conf", "path/to/policy.csv")
import org.casbin.jcasbin.main.Enforcer;
Enforcer e = new Enforcer("path/to/model.conf", "path/to/policy.csv");
import { newEnforcer } from 'casbin';
const e = await newEnforcer('path/to/model.conf', 'path/to/policy.csv');
require_once './vendor/autoload.php';
use Casbin\Enforcer;
$e = new Enforcer("path/to/model.conf", "path/to/policy.csv");
import casbin
e = casbin.Enforcer("path/to/model.conf", "path/to/policy.csv")
using NetCasbin;
var e = new Enforcer("path/to/model.conf", "path/to/policy.csv");
#include <iostream>
#include <casbin/casbin.h>
int main() {
// Enforcer erstellen
casbin::Enforcer e("path/to/model.conf", "path/to/policy.csv");
// Code ..
}
var
casbin: ICasbin;
begin
casbin := TCasbin.Create('path/to/model.conf', 'path/to/policy.csv');
...
end
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())
}
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
- Python
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)
}
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
- Java
- Node.js
- PHP
- Python
- .NET
- C++
- Delphi
- Rust
- Lua
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"}})
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
}
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
}
$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
}
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
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
}
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;
}
if casbin.enforce(['alice,data1,read']) then
// Alice ist super glücklich, da sie Daten lesen kann
sonst
// Alice ist traurig
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
}
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
- Java
- Node.js
- PHP
- Python
- .NET
- Delphi
- Rust
- Lua
roles, err := e.GetRolesForUser("alice")
List<String> roles = e.getRolesForUser("alice");
const roles = await e.getRolesForUser('alice');
$roles = $e->getRolesForUser("alice");
roles = e.get_roles_for_user("alice")
var roles = e.GetRolesForUser("alice");
roles = e.rolesForEntity("alice")
let roles = e.get_roles_for_user("alice");
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.