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

Requiert ce package dans le composer.json de votre projet. Ceci va télécharger le paquet:

compositeur ont besoin de casbin/casbin

Python

pip install casbin

.NET

dotnet add package Casbin.NET

C++

# télécharger la source
git clone https://github.com/casbin/casbin-cpp. il

# générer des fichiers de projet
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
cargo add tokio // make sure you activate its `macros` feature

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  

Si erreur de rapport : votre utilisateur n'a pas les permissions d'écriture dans /usr/local/lib/luarocks/rocks -- vous pouvez utiliser votre arborescence locale avec --local. vous pouvez ajouter --local derrière votre commande pour corriger :

luarocks installe casbin --local

Un nouveau responsable de Casbin

Casbin utilise des fichiers de configuration pour définir le modèle de contrôle d'accès.

Il a deux fichiers de configuration, model.conf et policy.csv. Parmi eux, model.conf stocke notre modèle d'accès, et policy.csv stocke notre configuration spécifique de permission d'utilisateur. L'utilisation de Casbin est très raffinée. Fondamentalement, nous avons juste besoin d'une structure principale : enforcecer. Lors de la construction de cette structure, model.conf et policy.csv seront chargés.

En un autre mot, pour un nouvel agent de sécurité Casbin, vous devez fournir un modèle et un adaptateur.

Casbin has a FileAdapter, see Adapter for more information.

• Utiliser le fichier modèle et la valeur par défaut 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. :3306)/casbin")
if err != nil {
    log.Fatalf("error: adapter: %s", err)
}

m, err := model. ewModelFromString(`
[request_definition]
r = sub, obj, act

[policy_definition]
p = sub, obj, act

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

[matchers]
m = r.sub == p.sub && r.obj == p. bj && r.act == p.act
`)
if err != nil {
    log. atalf("erreur: modèle : %s", err)
}

e, err := casbin. ewEnforcer(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.