Introduction

Welcome to RBAC Algorithm - a powerful, enterprise-grade Role-Based Access Control library designed for modern applications.

System Architecture

🎨 Enhanced architecture diagram with colorful icons, modern design, and 96% code-verified accuracy. Shows all 5 layers: Application, Protocol, Implementation, Data Models, and Storage Backends. Open in diagrams.net to edit.

What is RBAC Algorithm?

RBAC Algorithm provides a comprehensive, language-agnostic solution for implementing fine-grained access control in your applications. Built on industry-standard protocols, it supports:

• 🎯 Traditional RBAC - Users, Roles, and Permissions
• 🔐 ABAC - Attribute-Based Access Control with dynamic conditions
• 📊 Role Hierarchies - Inheritance with automatic permission propagation
• 🏢 Multi-Tenancy - Domain isolation for SaaS applications
• � Permissions Matrix - Visual role×permission management
• 🌐 Language Agnostic - Protocol-based with adapters for multiple languages

Why RBAC Algorithm?

Simple Yet Powerful

# Check if a user can perform an action
result = rbac.check_permission(
    user_id="user_123",
    action="write",
    resource_id="document_456"
)

if result.allowed:
    # Proceed with operation
    pass

Enterprise-Ready

• Performance - Fast in-memory storage with optimized algorithms
• Scalable - From startups to enterprises
• Auditable - Complete authorization trails
• Secure - Industry best practices baked in

Developer Experience First

• Clear, intuitive API
• Comprehensive documentation
• Interactive examples
• Multi-language support

Quick Example

from rbac import RBAC

# Initialize
rbac = RBAC()

# Create permissions
read_perm = rbac.create_permission(
    permission_id="perm_doc_read",
    action="read",
    resource_type="document"
)

# Create role
editor = rbac.create_role(
    role_id="role_editor",
    name="Editor"
)

# Assign permission to role
rbac.assign_permission_to_role("role_editor", "perm_doc_read")

# Assign role to user
rbac.assign_role_to_user("user_123", "role_editor")

# Check permission
result = rbac.check_permission(
    user_id="user_123",
    action="read",
    resource_id="document_456"
)

print(result.allowed)  # True

Next Steps

Get Started

Learn Concepts

Try Playground

Key Features

Role-Based Access Control

Assign permissions to roles, then assign roles to users. Simple, proven, and effective.

Attribute-Based Access Control

Go beyond simple role assignments with dynamic conditions:

# Only allow editing own documents during business hours
permission = rbac.create_permission(
    permission_id="perm_edit_own",
    action="edit",
    resource_type="document",
    conditions=[
        {"field": "resource.owner_id", "operator": "==", "value": "{{user.id}}"},
        {"field": "time.hour", "operator": ">", "value": 8},
        {"field": "time.hour", "operator": "<", "value": 18}
    ]
)

Role Hierarchies

Build organizational structures with automatic permission inheritance:

# Admin inherits all Editor permissions
rbac.create_role(
    role_id="role_admin",
    name="Administrator",
    parent_id="role_editor"  # Inherits from Editor
)

Multi-Tenancy

Perfect for SaaS applications with domain isolation:

# Different permissions for different tenants
result = rbac.check_permission(
    user_id="user_123",
    action="read",
    resource_id="document_456",
    domain="tenant_a"
)

Permissions Matrix

Visualize and manage role-permission assignments interactively:

from rbac import PermissionsMatrixManager, MatrixMode

# Create matrix manager
matrix_mgr = PermissionsMatrixManager(rbac._storage)

# View current permissions as a table
matrix = matrix_mgr.create_matrix(mode=MatrixMode.READONLY)
matrix_mgr.print_matrix(matrix)

# Output:
# Feature                |   Viewer   |   Editor   |   Admin
# ----------------------------------------------------------------
# document - read        |     Y      |     Y      |     Y
# document - write       |     N      |     Y      |     Y
# document - delete      |     N      |     N      |     Y

# Make changes interactively
editable = matrix_mgr.create_matrix(mode=MatrixMode.EDITABLE)
matrix_mgr.toggle_permission(editable, "role_viewer", "perm_write")
matrix_mgr.apply_changes(editable)  # Persist to storage

Features:

• Read-only and editable modes
• Change tracking before applying
• Bulk permission operations
• Export to JSON for auditing
• Pretty-printed tables

Community & Support

• 📖 Documentation
• 💬 GitHub Discussions
• 🐛 Issue Tracker