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))