Functional Weave
Code in TypeScript

auth.rbac@1.0.0

impl/python/resolve_roles.py

3,942 bytes · the Python implementation · view raw

from typing import Dict, List, Sequence, Tuple

from .auth_rbac_types import RbacPolicy, ResolvedRoles, RoleDef


def _segment(text: str) -> bool:
    # Compared by character range: lower-case ASCII letters, digits, _ and -.
    return len(text) > 0 and all("a" <= ch <= "z" or "0" <= ch <= "9" or ch in "_-" for ch in text)


def parse_grant(grant: str) -> Tuple[str, str, bool]:
    """A grant as (resource, action, own); "*" alone is "*:*"."""
    if not isinstance(grant, str):
        raise ValueError("invalid grant %s" % (grant,))
    if grant == "*":
        return ("*", "*", False)
    parts = grant.split(":")
    ok = lambda s: s == "*" or _segment(s)  # noqa: E731
    if (len(parts) == 2 or (len(parts) == 3 and parts[2] == "own")) and ok(parts[0]) and ok(parts[1]):
        return (parts[0], parts[1], len(parts) == 3)
    raise ValueError("invalid grant %s" % grant)


def parse_permission(permission: str, allow_own: bool) -> Tuple[str, str, bool]:
    """A concrete permission as (resource, action, own): no wildcards, :own only where asked."""
    if isinstance(permission, str):
        parts = permission.split(":")
        shape = len(parts) == 2 or (allow_own and len(parts) == 3 and parts[2] == "own")
        if shape and _segment(parts[0]) and _segment(parts[1]):
            return (parts[0], parts[1], len(parts) == 3)
    raise ValueError("invalid permission %s" % (permission,))


def check_policy(policy: RbacPolicy) -> Dict[str, RoleDef]:
    """The policy checked whole (names, inherited roles, grants, cycles found
    depth-first in policy order, permissions); the roles by name."""
    by_name: Dict[str, RoleDef] = {}
    for role in policy.roles:
        if not isinstance(role.name, str) or role.name == "":
            raise ValueError("role name must be a non-empty string")
        if role.name in by_name:
            raise ValueError("duplicate role %s" % role.name)
        by_name[role.name] = role
    for role in policy.roles:
        for parent in role.inherits:
            if parent not in by_name:
                raise ValueError("unknown role %s" % parent)
        for grant in role.permissions:
            parse_grant(grant)
    state: Dict[str, int] = {}
    stack: List[str] = []

    def visit(name: str) -> None:
        state[name] = 1
        stack.append(name)
        for parent in by_name[name].inherits:
            seen = state.get(parent)
            if seen == 1:
                path = stack[stack.index(parent):] + [parent]
                raise ValueError("role inheritance cycle: %s" % " -> ".join(path))
            if seen is None:
                visit(parent)
        stack.pop()
        state[name] = 2

    for role in policy.roles:
        if role.name not in state:
            visit(role.name)
    for permission in policy.permissions:
        parse_permission(permission, False)
    return by_name


def expand_roles(by_name: Dict[str, RoleDef], roles: Sequence[str]) -> List[str]:
    """The roles given plus every role they inherit, deduplicated and sorted."""
    seen = set()
    queue = list(roles)
    while queue:
        name = queue.pop(0)
        if name in seen:
            continue
        if name not in by_name:
            raise ValueError("unknown role %s" % (name,))
        seen.add(name)
        queue.extend(by_name[name].inherits)
    return sorted(seen)


def grants_of(by_name: Dict[str, RoleDef], roles: Sequence[str]) -> List[str]:
    """Every grant of these (already expanded) roles, deduplicated and sorted."""
    grants = set()
    for name in roles:
        grants.update(by_name[name].permissions)
    return sorted(grants)


def resolve_roles(policy: RbacPolicy, roles: Sequence[str]) -> ResolvedRoles:
    """What a user holding these roles effectively is and may do."""
    by_name = check_policy(policy)
    every = expand_roles(by_name, roles)
    return ResolvedRoles(roles=every, permissions=grants_of(by_name, every))