Commencer
Installationâ
- Go
- Java
- Node.js
- PHP
- Python
- .NET
- C++
- Rust
- Delphi
- Lua
allez obtenir github.com/casbin/casbin/v2
Pour 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:
compositeur ont besoin de casbin/casbin
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 est disponible dans un paquet (actuellement pour Delphi 10.3 Rio) et vous pouvez l'installer dans l'IDE. Cependant, il n'y a pas de composants visuels ce qui signifie que vous pouvez utiliser les unités indépendamment des paquets. Il vous suffit d'importer les unités de votre projet (en supposant que le nombre de ces unités ne vous dérange pas).
luarocks installer casbin
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
Un nouveau responsable de Casbinâ
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. Lors de la construction de cette structure, model.conf
et policy.csv
seront chargés.
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() {
// Créer un moteur
casbin::Enforcer e("path/to/model.conf", "path/to/policy.csv");
// votre code ..
}
var
casbin: ICasbin;
begin
casbin := TCasbin.Create('path/to/model.conf', 'path/to/policy.csv');
...
end
use casbin::prelude::*;
// If you use async_td as async executor
#[cfg(feature = "runtime-async-std")]
#[async_std::main]
async fn main() -> Result<()> {
let mut e = Enforcer::new("path/to/model.conf", "path/to/policy.csv").await?;
Ok(())
}
// If you use tokio as async executor
#[cfg(feature = "runtime-tokio")]
#[tokio::main]
async fn main() -> Result<()> {
let mut e = Enforcer::new("path/to/model.conf", "path/to/policy.csv").await?;
Ok(())
}
local Enforcer = require("casbin")
local e = Enforcer:new("path/to/model.conf", "path/to/policy.csv") -- The Casbin Enforcer
- Utiliser le texte du modĂšle avec un autre adaptateur:
- Go
- Python
import (
"log"
"github.com/casbin/casbin/v2"
"github.com/casbin/casbin/casbin/v2/model"
xormadapter "github.com/casbin/xorm-adapter/v2"
_ "github.com/go-sql-driver/mysql"
)
// Initialise un adaptateur Xorm avec une base de données MySQL.
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
# Utiliser l'adaptateur SQLAlchemy Casbin avec SQLLite DB
adaptateur = casbin_sqlalchemy_adapter. dapter('sqlite:///test.db')
# Créez une charte de modÚle de configuration
avec open("rbac_example_model.conf", "w") comme f:
f. rite("""
[request_definition]
r = sub, obj, act
[policy_definition]
p = sub, obj, act
[policy_effect]
e = quelque part (oĂč (p. ft == allow))
[matchers]
m = r. ub == p.sub && r.obj == p.obj && r.act == p. ct
""")
# Créer un enforcer à partir de l'adaptateur et de la politique de configuration
e = casbin.Enforcer('rbac_example_model.conf', adaptateur)
VĂ©rifier les autorisationsâ
Ajoutez un crochet d'application Ă votre code juste avant que l'accĂšs ne se produise :
- Go
- Java
- Node.js
- PHP
- Python
- .NET
- C++
- Delphi
- Rust
- Lua
sub := "alice" // l'utilisateur qui veut accéder à une ressource.
obj := "data1" // la ressource qui va ĂȘtre accĂ©dĂ©e.
act := "read" // l'opération que l'utilisateur effectue sur la ressource.
ok, erreur := e. nforce(sub, obj, act)
si erreur! nil {
// handle err
}
if ok == true {
// autorise alice à lire les données 1
} else {
// refuse la requĂȘte, affiche une erreur
}
// Vous pouvez utiliser BatchEnforce() pour imposer certaines requĂȘtes en lots.
// Cette méthode retourne une tranche de booléen, et l'index de cette tranche correspond à l'index de ligne du tableau en deux dimensions.
// par exemple les résultats[0] sont le résultat de {"alice", "data1", "read"}
résultats, erreur:= e.BatchEnforce([][]interface{}{{"alice", "data1", "read"}, {"bob", "data2", "write"}, {"jack", "data3", "read"}})
String sub = "alice"; // l'utilisateur qui veut accéder à une ressource.
String obj = "data1"; // la ressource qui va ĂȘtre accĂ©dĂ©e.
String act = "read"; // l'opération que l'utilisateur effectue sur la ressource.
if (e. nforce(sub, obj, act) == true) {
// autorise alice à lire les données1
} else {
// refuse la requĂȘte, afficher une erreur
}
const sub = 'alice'; // l'utilisateur qui veut accéder à une ressource.
const obj = 'data1'; // la ressource qui va ĂȘtre accĂ©dĂ©e.
const act = 'read'; // l'opération que l'utilisateur effectue sur la ressource.
if (attendez e. nforce(sub, obj, act)) === true) {
// autorise alice à lire les données1
} else {
// refuse la requĂȘte, afficher une erreur
}
$sub = "alice"; // l'utilisateur qui veut accéder à une ressource.
$obj = "data1"; // la ressource qui va ĂȘtre accĂ©dĂ©e.
$act = "read"; // l'opération que l'utilisateur effectue sur la ressource.
if ($e->enforce($sub, $obj, $act) === true) {
// autorise alice à lire les données 1
} else {
// refuse la requĂȘte, afficher une erreur
}
sub = "alice" # l'utilisateur qui veut accéder à une ressource.
obj = "data1" # la ressource qui va ĂȘtre accĂ©dĂ©e.
act = "read" # l'opération que l'utilisateur effectue sur la ressource.
if e.enforce(sub, obj, act):
# permet alice de lire les données1
passe
else:
# refuse la requĂȘte, affiche une erreur
passe
var sub = "alice"; # l'utilisateur qui veut accéder à une ressource.
var obj = "data1"; # la ressource qui va ĂȘtre accĂ©dĂ©e.
var act = "read"; # l'opération que l'utilisateur effectue sur la ressource.
if (attendre e. nforceAsync(sub, obj, act))
{
// autorise alice à lire les données 1
}
else
{
// refuse la requĂȘte, afficher une erreur
}
casbin::Enforcer e("../assets/model.conf", "../assets/policy.csv");
if (e. nforce({"alice", "/alice_data/bonjour", "GET"})) {
std::cout << "Forcer OK" << std::endl;
} else {
std::cout << "Force NOT Good" << std::endl;
}
if (e. nforce({"alice", "/alice_data/bonjour", "POST"})) {
std::cout << "Forcer OK" << std::endl;
} else {
std::cout << "Force NOT Good" << std::endl;
}
if casbin.enforce(['alice,data1,read']) then
// Alice est super heureuse car elle peut lire les données1
else
// Alice est triste
let sub = "alice"; // l'utilisateur qui veut accéder à une ressource.
let obj = "data1"; // la ressource qui va ĂȘtre accĂ©dĂ©e.
let act = "read"; // l'opération que l'utilisateur effectue sur la ressource.
if e.enforce(sub, obj, act)).await? {
// autorise alice à lire les données1
} else {
// erreur survient
}
if e:enforce("alice", "data1", "read") then
-- allow alice to read data1
else
-- deny the request, show an error
end
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:
- 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")
Voir Management API et RBAC API pour plus d'utilisation.
Veuillez vous référer aux cas de test pour plus d'usage.