开始使用

安装

go get github.com/casbin/casbin/v2

<dependency>
  <groupId>org.casbin</groupId>
  <artifactId>jcasbin</artifactId>
  <version>1.6.0</version>
</dependency>

# NPM
npm install casbin --save

# Yarn
yarn add casbin

composer.json 中需要这个软件包。这将下载软件包：

composer require casbin/casbin

pip install casbin

dotnet add package Casbin.NET

cargo install cargo-edit
cargo add casbin

// 如果你使用异步标准作为异步执行者
cargo add async-std

// 如果你使用tokio作为异步执行者
cargo add tokio // 请确保您激活了其`macros`特性

luarocks install casbin  

如果报出错误：您的用户没有写入/usr/local/lib/luarocks/rocks 的权限，您可能需要以 root 用户身份运行或使用本地树，加上 --local 参数。 您可以将 --local 参数添加到您的命令后面，就像这样修改：

luarocks install casbin  --local

新建一个Casbin enforcer

Casbin使用配置文件来设置访问控制模式。

它有两个配置文件，model.conf和policy.csv。 其中，model.conf存储了访问模型，policy.csv存储了特定的用户权限配置。 Casbin的使用非常精炼。 基本上，我们只需要一个主要结构：enforcer。 当构建这个结构时，model.conf和policy.csv将被加载。

换句话说，要新建一个Casbin执行器，你必须提供一个Model和一个Adapter。

Casbin有一个FileAdapter，请看Adapter查看更多Adapter。

• 使用Model文件和默认 FileAdapter:

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

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

use casbin::prelude::*;

// 如果你使用 async_td 作为异步执行器
#[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(())
}

// 如果你使用 tokio 作为异步执行器
#[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

• 与其他Adapter一起使用Model text

import (
    "log"

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

// 使用 MySQL 数据库初始化一个 Xorm 适配器
a, err := xormadapter.NewAdapter("mysql", "mysql_username:mysql_password@tcp(127.0.0.1:3306)/casbin")
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)
}

检查权限

在访问发生之前，在你的代码中添加一个执行钩。

sub := "alice" // 想要访问资源的用户。
obj: = "data1" // 将被访问的资源。
act := "read" // 用户对资源执行的操作。

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

if err != nil {
    // 处理err
}

if ok == true {
    // 允许alice读取data1
} else {
    // 拒绝请求，抛出异常
}

// 您可以使用BatchEnforce()来批量执行一些请求
// 这个方法返回布尔切片，此切片的索引对应于二维数组的行索引。
// 例如 results[0] 是 {"alice", "data1", "read"} 的结果
results, err := e.BatchEnforce([[] []interface{}{"alice", "data1", "read"}, {"bob", datata2", "write"}, {"jack", "data3", "read"}})

String sub = "alice"; // 想要访问资源的用户
String obj = "data1"; // 将要被访问的资源
String act = "read"; // 用户对资源进行的操作

if (e.enforce(sub, obj, act) == true) {
    // 允许alice读取data1
} else {
    // 拒绝请求，抛出异常
}

const sub = 'alice'; // 想要访问资源的用户
const obj = 'data1'; // 将要被访问的资源
const act = 'read'; // 用户对资源进行的操作

if ((await e.enforce(sub, obj, act)) === true) {
    // 允许alice读取data1
} else {
    // 拒绝请求，抛出异常
}

$sub = "alice"; // 想要访问资源的用户
$obj = "data1"; // 将要被访问的资源
$act = "read"; // 用户对资源进行的操作

if ($e->enforce($sub, $obj, $act) === true) {
    // 允许alice读取data1
} else {
    // 拒绝请求，抛出异常
}

sub = "alice"  # 想要访问资源的用户
obj = "data1"  # 将要被访问的资源
act = "read"  # 用户对资源进行的操作

if e.enforce(sub, obj, act):
    # 允许alice读取data1
    pass
else:
    # 拒绝请求，抛出异常
    pass

var sub = "alice";  # 想要访问资源的用户
var obj = "data1";  # 将要被访问的资源
var act = "read";  # 用户对资源进行的操作

if (await e.EnforceAsync(sub, obj, act)) 
{
    // 允许alice读取data1
}
else
{
    // 拒绝请求，抛出异常
}

if casbin.enforce(['alice,data1,read']) then
  // Alice很开兴它能够读取data1了
else
  // Alice很伤心

  let sub = "alice"; // 想要访问资源的用户
  let obj = "data1"; // 将会被访问的资源
  let act = "read"; // 用户对资源的操作

  if e.enforce((sub, obj, act)).await? {
      // 允许alice读取data1
  } else {
      // 发生错误
  }

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

Casbin还提供了在运行时进行权限管理的API。例如，你可以获得分配给一个用户的所有角色，如下所示：

roles := e.GetRolesForUser("alice")

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

更多使用方法见Management API和RBAC API。

更多用法请参考测试案例。