Apache Casbin

Noticias: ¿aún te preocupa cómo escribir la política correcta de Apache Casbin? ¡Apache Casbin online editor viene a ayudarte! Pruébalo en: https://casbin.apache.org/editor/

Apache Casbin es una biblioteca de control de acceso de código abierto, potente y eficiente, para proyectos Golang. Proporciona soporte para aplicar la autorización basada en diversos modelos de control de acceso.

Todos los lenguajes soportados por Apache Casbin:

Tabla de contenidos

• Modelos compatibles
• ¿Cómo funciona?
• Características
• Instalación
• Documentación
• Editor en línea
• Tutoriales
• Primeros pasos
• Gestión de políticas
• Persistencia de políticas
• Consistencia de políticas entre múltiples nodos
• Gestor de roles
• Benchmarks
• Ejemplos
• Middlewares
• Nuestros adoptantes

Modelos compatibles

1. ACL (Lista de Control de Acceso)
2. ACL con superusuario
3. ACL sin usuarios: especialmente útil para sistemas que no tienen autenticación ni inicios de sesión de usuarios.
4. ACL sin recursos: algunos escenarios pueden apuntar a un tipo de recursos en lugar de un recurso individual utilizando permisos como write-article, read-log. No controla el acceso a un artículo o registro específico.
5. RBAC (Control de Acceso Basado en Roles)
6. RBAC con roles de recursos: tanto los usuarios como los recursos pueden tener roles (o grupos) al mismo tiempo.
7. RBAC con dominios/inquilinos: los usuarios pueden tener diferentes conjuntos de roles para diferentes dominios/inquilinos.
8. ABAC (Control de Acceso Basado en Atributos): azúcar sintáctico como resource.Owner se puede utilizar para obtener el atributo de un recurso.
9. RESTful: soporta rutas como /res/*, /res/:id y métodos HTTP como GET, POST, , .

¿Cómo funciona?

En Casbin, un modelo de control de acceso se abstrae en un archivo CONF basado en el metamodelo PERM (Policy, Effect, Request, Matchers). Por lo tanto, cambiar o actualizar el mecanismo de autorización de un proyecto es tan simple como modificar una configuración. Puedes personalizar tu propio modelo de control de acceso combinando los modelos disponibles. Por ejemplo, puedes obtener roles RBAC y atributos ABAC juntos dentro de un mismo modelo y compartir un mismo conjunto de reglas de política.

El modelo más básico y sencillo de Casbin es ACL. El CONF del modelo ACL es:

# Request definition
[request_definition]
r = sub, obj, act

# Policy definition
[policy_definition]
p = sub, obj, act

# Policy effect
[policy_effect]
e = some(where (p.eft == allow))

# Matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

Un ejemplo de política para el modelo ACL es:

p, alice, data1, read
p, bob, data2, write

Esto significa:

• alice puede leer data1
• bob puede escribir data2

También soportamos el modo multilínea añadiendo '\' al final:

# Matchers
[matchers]
m = r.sub == p.sub && r.obj == p.obj \
  && r.act == p.act

Además, si estás usando ABAC, puedes probar el operador in como se muestra a continuación en la edición golang de Casbin (jCasbin y Node-Casbin aún no son compatibles):

# Matchers
[matchers]
m = r.obj == p.obj && r.act == p.act || r.obj in ('data2', 'data3')

Pero DEBES asegurarte de que la longitud del array sea MAYOR que 1; de lo contrario, provocará un panic.

Para más operadores, puedes echar un vistazo a govaluate

Características

Qué hace Apache Casbin:

1. aplicar la política en la forma clásica {subject, object, action} o en una forma personalizada según la definas; se admiten tanto autorizaciones de permitir como de denegar.
2. manejar el almacenamiento del modelo de control de acceso y su política.
3. gestionar las asignaciones rol-usuario y rol-rol (también conocidas como jerarquía de roles en RBAC).
4. soportar superusuarios integrados como root o administrator. Un superusuario puede hacer cualquier cosa sin permisos explícitos.
5. múltiples operadores integrados para soportar la coincidencia de reglas. Por ejemplo, keyMatch puede mapear una clave de recurso /foo/bar al patrón /foo*.

Qué no hace Apache Casbin:

1. autenticación (es decir, verificar username y password cuando un usuario inicia sesión)
2. gestionar la lista de usuarios o roles. Creo que es más conveniente que el propio proyecto gestione estas entidades. Los usuarios suelen tener sus contraseñas, y Apache Casbin no está diseñado como un contenedor de contraseñas. Sin embargo, Apache Casbin almacena la asignación usuario-rol para el escenario RBAC.

Instalación

go get github.com/casbin/casbin/v3

Documentación

https://casbin.apache.org/docs/overview

Editor en línea

También puedes usar el editor en línea (https://casbin.apache.org/editor/) para escribir tu modelo y política de Casbin en tu navegador web. Proporciona funcionalidades como syntax highlighting y code completion, igual que un IDE para un lenguaje de programación.

Tutoriales

https://casbin.apache.org/docs/tutorials

Primeros pasos

1. Crea un enforcer de Casbin con un archivo de modelo y un archivo de política:

   root@kitploit:~

   e, _ := casbin.NewEnforcer("path/to/model.conf", "path/to/policy.csv")
   

Nota: también puedes inicializar un enforcer con la política en la base de datos en lugar de un archivo; consulta la sección Persistencia de políticas para más detalles.

2. Añade un hook de enforcement en tu código justo antes de que ocurra el acceso:

   root@kitploit:~

   sub := "alice" // the user that wants to access a resource.
   obj := "data1" // the resource that is going to be accessed.
   act := "read" // the operation that the user performs on the resource.
   
   if res, _ := e.Enforce(sub, obj, act); res {
       // permit alice to read data1
   } else {
       // deny the request, show an error
   }
   

3. Además del archivo de política estático, Apache Casbin también proporciona una API para la gestión de permisos en tiempo de ejecución. Por ejemplo, puedes obtener todos los roles asignados a un usuario como se muestra a continuación:

   root@kitploit:~

   roles, _ := e.GetImplicitRolesForUser(sub)
   

Consulta API de gestión de políticas para más usos.

Gestión de políticas

Apache Casbin proporciona dos conjuntos de API para gestionar permisos:

• Management API: la API primitiva que proporciona soporte completo para la gestión de políticas de Apache Casbin.
• RBAC API: una API más amigable para RBAC. Esta API es un subconjunto de Management API. Los usuarios de RBAC pueden usar esta API para simplificar el código.

También proporcionamos una interfaz de usuario basada en web para la gestión de modelos y políticas:

Persistencia de políticas

https://casbin.apache.org/docs/adapters

Consistencia de políticas entre múltiples nodos

https://casbin.apache.org/docs/watchers

Gestor de roles

https://casbin.apache.org/docs/role-managers

Benchmarks

https://casbin.apache.org/docs/benchmark

Ejemplos

Middlewares

Middlewares de autorización para frameworks web: https://casbin.apache.org/docs/middlewares

Nuestros adoptantes

https://casbin.apache.org/docs/adopters

Cómo contribuir

Por favor, lee la guía de contribución.

Contribuyentes

Este proyecto existe gracias a todas las personas que contribuyen.

Historial de estrellas

Licencia

Este proyecto está licenciado bajo la licencia Apache 2.0.

Contacto

Si tienes algún problema o solicitud de funcionalidad, por favor contáctanos. Los PR son bienvenidos.

• https://github.com/apache/casbin/issues
• https://discord.gg/S5UjpzGZjN