Design a multi-tenant authorization model: RBAC/ABAC, policy evaluation, tenant…
- User
Design a multi-tenant authorization model: RBAC/ABAC, policy evaluation, tenant isolation, audit, and threat modeling.
Assistant
The user wants a design for a multi-tenant authorization model. The request covers several key areas:
- Core Model: RBAC (Role-Based Access Control) vs. ABAC (Attribute-Based Access Control).
- Policy Evaluation: How are permissions actually determined?
- Tenant Isolation: How do we ensure data and logic separation?
- Audit: Logging and monitoring.
- Threat Modeling: Security risks and mitigations.
Deconstruction & Strategy:
-
Scenario: I need to establish a context. A SaaS platform is the standard use case for multi-tenancy. I'll assume a generic B2B SaaS application (e.g., a project management tool or an analytics platform).
-
1. Core Model (RBAC vs. ABAC):
- RBAC is simpler but rigid. Good for broad strokes (Admin, Editor, Viewer).
- ABAC is flexible but complex. Good for granular rules (User X can edit Project Y only if User X is in Department Z and Project Y is "Active").
- Hybrid approach: Usually the best bet. Use RBAC for base permissions within a tenant and ABAC for cross-tenant or context-aware constraints. Let's propose a "ReBAC" (Relationship-Based) or hybrid RBAC/ABAC model.
-
2. Policy Evaluation (The "Engine"):
- Need a Policy Decision Point (PDP) and Policy Enforcement Point (PEP).
- Language: Rego (OPA) or Cedar (AWS) are industry standards. I'll stick to a generic logic description but mention these tools.
- Input context: Subject (User), Action, Resource, Environment (Tenant ID is crucial here).
-
3. Tenant Isolation (The "Blast Radius" Constraint):
- Logical Isolation: The Tenant ID must be a mandatory predicate in every database query. This is the most common failure point.
- Physical Isolation: Separate DBs or schemas (more secure, higher cost/maintenance). I'll assume shared DB for efficiency but emphasize logical isolation mechanisms.
-
4. Audit (The "Who, What, Where, When"):
- Logs must be immutable.
- Logs must be tenant-scoped ( Tenant A shouldn't see Tenant B's audit logs unless Tenant A is the Super Admin/Platform Owner).
- What to log? Denials are just as important as Allowances.
-
5. Threat Modeling (STRIDE/DREAD):
- Spoofing: Impersonating a user from another tenant.
- Tampering: Modifying policy files.
- Information Disclosure: Leaking data across tenants (the biggest fear).
- Elevation of Privilege: Tenant User becoming Platform Admin.
Drafting the Content - Section by Section:
-
Introduction: Define the scope. Multi-tenancy means shared infrastructure, isolated data/logic.
-
Section 1: The Authorization Architecture (Hybrid RBAC + ABAC)
- RBAC: Assign roles per tenant (Tenant A Admin, Tenant B Viewer).
- ABAC: Attributes like
department,clearance_level,region. - Hierarchy: Platform Admin > Tenant Admin > Tenant User.
-
Section 2: Policy Evaluation Strategy
- Use OPA (Open Policy Agent) as the conceptual engine.
- The "Golden Rule": The Tenant ID is part of the resource ID. You cannot query a resource without proving you belong to the same tenant (unless you are a Platform Admin).
- Flow: Request -> PEP (Gateway) -> Context Enrichment (Get claims) -> PDP (OPA) -> Decision.
-
Section 3: Tenant Isolation (Data & Logic)
- Row-Level Security (RLS): The database must enforce this. Middleware isn't enough.
- Middleware/Context Propagation: The
tenant_idmust be injected into the request context immediately after authentication.
-
Section 4: Audit & Accountability
- Structure: Who (User + Tenant), What (Action), On (Resource), Result (Allow/Deny).
- Storage: Centralized for the platform, segmented views for tenants.
-
Section 5: Threat Modeling (The "Bad Day" Scenarios)
- Broken Object Level Authorization (BOLA): The #1 API threat. Prevention: Automatic tenant ID injection.
- Confused Deputy: A client attacking a server to make it misuse its authority.
- Policy Bypass: Bugs in the policy code (Rego/SQL).
Refining the Design:
- Correction: Pure RBAC often fails in multi-tenancy because you need to define "Admin" scoped to a tenant. I need to emphasize "Scoping".
- Enhancement: Mentioning "Global Policies" vs. "Tenant-Defined Policies". Large enterprise tenants often want to define their own authorization rules (e.g., "No one can access data after 5 PM"). The system needs to support policy composition.
Final Structure:
- High-Level Architecture Diagram (Textual): Identity -> Policy Engine -> Data.
- Model Selection: Why Hybrid?
- Policy Evaluation: OPA/Cedar integration.
- Isolation Strategy: RLS + Middleware.
- Audit: Contextual logging.
- Threat Modeling: BOLA, Privilege Escalation.
Self-Correction during drafting: Make sure to distinguish between Authentication (AuthN) and Authorization (AuthZ). The prompt is about AuthZ, but AuthN provides the claims (tenant_id) needed for AuthZ. I will assume the JWT contains the
tenant_id.Let's write it out. Focus on clarity, architectural patterns, and security first principles. Designing a multi-tenant authorization system requires balancing centralized management with strict isolation. Below is a comprehensive design model covering the architecture, policy evaluation, isolation strategies, auditing, and threat modeling.
1. The Authorization Model: Hybrid RBAC + ABAC
A pure Role-Based Access Control (RBAC) model often fails in complex SaaS environments due to "Role Explosion" (e.g., needing
Admin-TenantA-USvsAdmin-TenantB-EU). A hybrid approach is superior.Architecture Layers
- Global Platform Layer (RBAC): Defines coarse-grained permissions for platform operations.
- Subjects: Platform Admins, Support Staff, Billing Systems.
- Permissions:
platform.tenant.create,platform.billing.view,audit.global.read.
- Tenant Layer (Hierarchical RBAC + ABAC): Defines permissions inside a tenant context.
- Roles:
TenantAdmin,Editor,Viewer. - Attributes (ABAC): Used for fine-grained control within the tenant.
- User Attributes:
Department=Sales,Region=EU,Clearance=Secret. - Resource Attributes:
Classification=Confidential,OwnerID=123. - Context Attributes:
Time=09:00-17:00,IP_Range=Corporate.
- User Attributes:
- Roles:
The Policy Definition (e.g., using Rego/OPA or Cedar)
Instead of hardcoding logic, policies should be declarative.
- Example Policy Logic:
ALLOW IF: User.Role == "Editor" AND Resource.TenantID == User.TenantID AND Resource.Classification <= User.ClearanceLevel
2. Policy Evaluation Pipeline (The "Ask")
The evaluation engine must be stateless and high-performance.
- Context Injection: The API Gateway injects the
TenantIDinto the request context based on the request origin (URL subdomain or header) before passing it to the Policy Decision Point (PDP). - Policy Decision Point (PDP):
- Input: User Identity (JWT), Resource ID, Action, Tenant Context.
- Lookup: Fetches User Groups/Roles and Resource Attributes.
- Evaluation: Compiles the data against the policy rules.
- Enforcement (PEP): The application or API Gateway blocks or allows the request.
Critical Optimization: Caching evaluated policies. Since policies rarely change per request, cache the "Allow/Deny" decision for (User+Tenant+Resource) for a short TTL (e.g., 5 mins).
3. Tenant Isolation Strategies
Isolation is the most critical security property. You must assume that a malicious tenant will try to access another tenant's data.
A. Logical Isolation (The "Tenant ID" Constraint)
Every data entity (Database row, Blob storage object, Cache key) must possess a
TenantID.- Database: Use Row-Level Security (RLS) if available (e.g., Postgres RLS, Firebase Rules).
- Mechanism: The DB connection is established using a session variable
SET app.current_tenant = 'tenant_123'. The database engine physically rejects any query that does not containWHERE tenant_id = 'tenant_123'.
- Mechanism: The DB connection is established using a session variable
- Application Logic: Middleware ensures that every ORM query automatically scopes to the current context.
B. Policy Isolation (Namespace Segmentation)
Policies for Tenant A must never apply to Tenant B.
- Namespace: Policy rules should be namespaced.
tenant_123.policy.allowtenant_456.policy.allow
- Custom Roles: Allow Tenant A to define a role "SuperEditor" that Tenant B does not have, without affecting the global schema.
C. "Escalation" Prevention
- A
TenantAdmincan assign roles within their tenant. - Constraint: They cannot assign the
PlatformAdminrole or modify theTenantIDattribute of their organization.
4. Auditing and Compliance
In multi-tenant systems, audits are legal requirements. Logs must be Attributable, Immutable, and Filterable.
Audit Log Schema
Do not simply log "Access Granted." Log the full context:
- Who:
UserID,ActorRole(Human vs. Service Account). - Context:
TenantID,SourceIP,UserAgent. - What:
ResourceType,ResourceID,Action(Read/Write/Delete). - Decision:
Effect(Allow/Deny),Reason(e.g., "Missing Role X"). - Changes: For Write operations, log the
Diff(Before vs. After).
Access Patterns
- Tenant Admin View: Can only see audit logs where
TenantID == Self. - Platform Admin View: Can see cross-tenant activity (e.g., Support staff accessing Tenant data).
5. Threat Modeling (STRIDE)
Here is how we address specific threats in this model:
Spoofing (Identity Theft)
- Threat: User A (Tenant 1) steals User B (Tenant 2) token.
- Mitigation: Bind the
TenantIDto the JWT signature claims. Even if the token is valid, if theJWT.TenantIDdoes not match theRequest.TargetTenantID, reject immediately.
Tampering (Data Integrity)
- Threat: User modifies a request to change the
ResourceIDto one belonging to another tenant (Insecure Direct Object Reference - IDOR). - Mitigation: The PDP must resolve the
ResourceIDto retrieve its attributes (includingOwnerTenantID) before making a decision. Never trust the client to say "I own this resource."
Information Disclosure
- Threat: "Leakage" via search or list APIs (e.g., searching for users returns results from all tenants).
- Mitigation: Enforce "Scope Hygiene". All
SELECT *queries must have a mandatory predicatetenant_id = ?.
Elevation of Privilege
- Threat: A user creates an API Key with
PlatformAdminrights. - Mitigation: Privilege Brackets.
- A user can only grant permissions they currently hold.
- API Key generation logic validates that the requested scopes are a subset of the user's current scopes.
Denial of Service (Policy Engine)
- Threat: Tenant sends complex queries to overload the Rego/Cedar evaluation engine.
- Mitigation: Rate limiting per tenant (not just per IP). Limit the complexity/size of custom policies defined by tenants.
Summary Architecture Diagram
[User] -> [API Gateway] | +-- 1. Extract TenantID (Subdomain/Header) +-- 2. Verify JWT (AuthN) | [Policy Enforcement Point (PEP)] | +-- 3. Construct Request Context: { User: "alice", Roles: ["Admin"], Tenant: "T1" } { Resource: "Doc_99", Action: "Write" } | [Policy Decision Point (PDP)] | (OPA / Cedar / Casbin) +-- 4. Fetch Data: "Who owns Doc_99?" -> "Tenant T1" +-- 5. Evaluate: Does T1.Admin allow Write on T1.Doc_99? -> TRUE | [Database (RLS Enabled)] +-- 6. Query: UPDATE Docs WHERE id=99 AND tenant_id='T1'
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.