Patched code sample

import dataclasses
from typing import Dict, List, Optional, Literal

# NOTE: This code is a hypothetical representation of a fix for the described
# vulnerability (CVE-2026-45831), as the CVE itself is not real.
# The logic demonstrates how to correctly scope permissions to a specific tenant,
# database, and collection, which is the core of the required fix.

@dataclasses.dataclass
class Permission:
    """Represents a single permission for a user."""
    scope: Literal["TENANT", "DATABASE", "COLLECTION"]
    resource_id: str  # e.g., "tenant_A", "tenant_A/db_1", or "tenant_A/db_1/coll_X"
    action: str       # e.g., "chroma:get_collection"

@dataclasses.dataclass
class Resource:
    """Represents the resource being accessed."""
    tenant: str
    database: str
    collection_name: Optional[str] = None

class SimpleRBACAuthorizationProvider:
    """A simple RBAC provider that correctly checks resource scopes."""

    def __init__(self):
        # Example: User 'jane' has permission to get a specific collection in 'tenant_A'
        # but has no permissions in 'tenant_B'.
        self.user_permissions: Dict[str, List[Permission]] = {
            "jane": [
                Permission(
                    scope="COLLECTION",
                    resource_id="tenant_A/default_database/sensitive_docs",
                    action="chroma:get_collection"
                )
            ]
        }

    def authorize(self, user_id: str, action: str, resource: Resource) -> bool:
        """
        Authorizes a user action against a specific resource, checking scopes.

        THE FIX: This implementation does not just check if the user has the
        'action' permission. It explicitly verifies that the permission applies
        to the specific tenant, database, and/or collection being accessed.
        """
        permissions = self.user_permissions.get(user_id)
        if not permissions:
            return False

        for perm in permissions:
            # 1. Action must match
            if perm.action != action:
                continue

            # 2. Scope and resource must match (THE CRITICAL FIX)
            # A vulnerable implementation would skip this block and just return True
            # if the action matched, allowing cross-tenant access.

            resource_identifier = f"{resource.tenant}/{resource.database}"
            if resource.collection_name:
                resource_identifier += f"/{resource.collection_name}"

            # Check if the permission directly applies to the collection
            if perm.scope == "COLLECTION" and perm.resource_id == resource_identifier:
                return True

            # Check if a database-level permission applies
            if perm.scope == "DATABASE" and perm.resource_id == f"{resource.tenant}/{resource.database}":
                return True

            # Check if a tenant-level permission applies
            if perm.scope == "TENANT" and perm.resource_id == resource.tenant:
                return True

        # If no matching permission is found after checking all scopes, deny access.
        return False