Commencer

Installation

Go

allez obtenir github.com/casbin/casbin/v2

Java

Pour 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:

compositeur ont besoin de casbin/casbin

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 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).

Lua

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

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() {
    // Créer un moteur
    casbin::Enforcer e("path/to/model.conf", "path/to/policy.csv");

    // votre code ..
}

Delphi

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

Rust

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(())
}

Lua

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

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)
}

Python

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

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"}})

Java

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
}

Node.js

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
}

PHP

$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
}

Python

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

.NET

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
}

C++

    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;
}

Delphi

if casbin.enforce(['alice,data1,read']) then
  // Alice est super heureuse car elle peut lire les données1
else
  // Alice est triste

Rust

  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
}

Lua

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

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")

Voir Management API et RBAC API pour plus d'utilisation.

Veuillez vous référer aux cas de test pour plus d'usage.