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) > 0and 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 "*:*"."""ifnot isinstance(grant, str):
raise ValueError("invalid grant %s" % (grant,))
if grant == "*":
return ("*", "*", False)
parts = grant.split(":")
ok = lambda s: s == "*"or _segment(s) # noqa: E731if (len(parts) == 2or (len(parts) == 3and 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) == 2or (allow_own and len(parts) == 3and 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:
ifnot 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 notin 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 isNone:
visit(parent)
stack.pop()
state[name] = 2for role in policy.roles:
if role.name notin 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:
continueif name notin 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))