acl.py

   1 #!/usr/bin/env python3
   2
   3 from abc import ABC, abstractmethod
   4 import enum
   5 import fnmatch
   6 import logging
   7 import re
   8 from typing import Any, Callable, List, Optional, Set
   9
  10 # This module is commonly used by others in here and should avoid
  11 # taking any unnecessary dependencies back on them.
  12
  13 logger = logging.getLogger(__name__)
  14
  15
  16 class Order(enum.Enum):
  17     """A helper to express the order of evaluation for allows/denies
  18     in an Access Control List.
  19     """
  20     UNDEFINED = 0
  21     ALLOW_DENY = 1
  22     DENY_ALLOW = 2
  23
  24
  25 class SimpleACL(ABC):
  26     """A simple Access Control List interface."""
  27
  28     def __init__(
  29         self,
  30         *,
  31         order_to_check_allow_deny: Order,
  32         default_answer: bool
  33     ):
  34         if order_to_check_allow_deny not in (
  35                 Order.ALLOW_DENY, Order.DENY_ALLOW
  36         ):
  37             raise Exception(
  38                 'order_to_check_allow_deny must be Order.ALLOW_DENY or ' +
  39                 'Order.DENY_ALLOW')
  40         self.order_to_check_allow_deny = order_to_check_allow_deny
  41         self.default_answer = default_answer
  42
  43     def __call__(self, x: Any) -> bool:
  44         """Returns True if x is allowed, False otherwise."""
  45         logger.debug(f'SimpleACL checking {x}')
  46         if self.order_to_check_allow_deny == Order.ALLOW_DENY:
  47             logger.debug('Checking allowed first...')
  48             if self.check_allowed(x):
  49                 logger.debug(f'{x} was allowed explicitly.')
  50                 return True
  51             logger.debug('Checking denied next...')
  52             if self.check_denied(x):
  53                 logger.debug(f'{x} was denied explicitly.')
  54                 return False
  55         elif self.order_to_check_allow_deny == Order.DENY_ALLOW:
  56             logger.debug('Checking denied first...')
  57             if self.check_denied(x):
  58                 logger.debug(f'{x} was denied explicitly.')
  59                 return False
  60             if self.check_allowed(x):
  61                 logger.debug(f'{x} was allowed explicitly.')
  62                 return True
  63
  64         logger.debug(
  65             f'{x} was not explicitly allowed or denied; ' +
  66             f'using default answer ({self.default_answer})'
  67         )
  68         return self.default_answer
  69
  70     @abstractmethod
  71     def check_allowed(self, x: Any) -> bool:
  72         """Return True if x is explicitly allowed, False otherwise."""
  73         pass
  74
  75     @abstractmethod
  76     def check_denied(self, x: Any) -> bool:
  77         """Return True if x is explicitly denied, False otherwise."""
  78         pass
  79
  80
  81 class SetBasedACL(SimpleACL):
  82     """An ACL that allows or denies based on membership in a set."""
  83     def __init__(self,
  84                  *,
  85                  allow_set: Optional[Set[Any]] = None,
  86                  deny_set: Optional[Set[Any]] = None,
  87                  order_to_check_allow_deny: Order,
  88                  default_answer: bool) -> None:
  89         super().__init__(
  90             order_to_check_allow_deny=order_to_check_allow_deny,
  91             default_answer=default_answer
  92         )
  93         self.allow_set = allow_set
  94         self.deny_set = deny_set
  95
  96     def check_allowed(self, x: Any) -> bool:
  97         if self.allow_set is None:
  98             return False
  99         return x in self.allow_set
 100
 101     def check_denied(self, x: Any) -> bool:
 102         if self.deny_set is None:
 103             return False
 104         return x in self.deny_set
 105
 106
 107 class AllowListACL(SetBasedACL):
 108     """Convenience subclass for a list that only allows known items.
 109     i.e. a 'whitelist'
 110     """
 111     def __init__(self,
 112                  *,
 113                  allow_set: Optional[Set[Any]]) -> None:
 114         super().__init__(
 115             allow_set = allow_set,
 116             order_to_check_allow_deny = Order.ALLOW_DENY,
 117             default_answer = False)
 118
 119
 120 class DenyListACL(SetBasedACL):
 121     """Convenience subclass for a list that only disallows known items.
 122     i.e. a 'blacklist'
 123     """
 124     def __init__(self,
 125                  *,
 126                  deny_set: Optional[Set[Any]]) -> None:
 127         super().__init__(
 128             deny_set = deny_set,
 129             order_to_check_allow_deny = Order.ALLOW_DENY,
 130             default_answer = True)
 131
 132
 133 class PredicateListBasedACL(SimpleACL):
 134     """An ACL that allows or denies by applying predicates."""
 135     def __init__(self,
 136                  *,
 137                  allow_predicate_list: List[Callable[[Any], bool]] = None,
 138                  deny_predicate_list: List[Callable[[Any], bool]] = None,
 139                  order_to_check_allow_deny: Order,
 140                  default_answer: bool) -> None:
 141         super().__init__(
 142             order_to_check_allow_deny=order_to_check_allow_deny,
 143             default_answer=default_answer
 144         )
 145         self.allow_predicate_list = allow_predicate_list
 146         self.deny_predicate_list = deny_predicate_list
 147
 148     def check_allowed(self, x: Any) -> bool:
 149         if self.allow_predicate_list is None:
 150             return False
 151         return any(predicate(x) for predicate in self.allow_predicate_list)
 152
 153     def check_denied(self, x: Any) -> bool:
 154         if self.deny_predicate_list is None:
 155             return False
 156         return any(predicate(x) for predicate in self.deny_predicate_list)
 157
 158
 159 class StringWildcardBasedACL(PredicateListBasedACL):
 160     """An ACL that allows or denies based on string glob (*, ?) patterns."""
 161     def __init__(self,
 162                  *,
 163                  allowed_patterns: Optional[List[str]] = None,
 164                  denied_patterns: Optional[List[str]] = None,
 165                  order_to_check_allow_deny: Order,
 166                  default_answer: bool) -> None:
 167         allow_predicates = []
 168         if allowed_patterns is not None:
 169             for pattern in allowed_patterns:
 170                 allow_predicates.append(
 171                     lambda x, pattern=pattern: fnmatch.fnmatch(x, pattern)
 172                 )
 173         deny_predicates = None
 174         if denied_patterns is not None:
 175             deny_predicates = []
 176             for pattern in denied_patterns:
 177                 deny_predicates.append(
 178                     lambda x, pattern=pattern: fnmatch.fnmatch(x, pattern)
 179                 )
 180
 181         super().__init__(
 182             allow_predicate_list=allow_predicates,
 183             deny_predicate_list=deny_predicates,
 184             order_to_check_allow_deny=order_to_check_allow_deny,
 185             default_answer=default_answer,
 186         )
 187
 188
 189 class StringREBasedACL(PredicateListBasedACL):
 190     """An ACL that allows or denies by applying regexps."""
 191     def __init__(self,
 192                  *,
 193                  allowed_regexs: Optional[List[re.Pattern]] = None,
 194                  denied_regexs: Optional[List[re.Pattern]] = None,
 195                  order_to_check_allow_deny: Order,
 196                  default_answer: bool) -> None:
 197         allow_predicates = None
 198         if allowed_regexs is not None:
 199             allow_predicates = []
 200             for pattern in allowed_regexs:
 201                 allow_predicates.append(
 202                     lambda x, pattern=pattern: pattern.match(x) is not None
 203                 )
 204         deny_predicates = None
 205         if denied_regexs is not None:
 206             deny_predicates = []
 207             for pattern in denied_regexs:
 208                 deny_predicates.append(
 209                     lambda x, pattern=pattern: pattern.match(x) is not None
 210                 )
 211         super().__init__(
 212             allow_predicate_list=allow_predicates,
 213             deny_predicate_list=deny_predicates,
 214             order_to_check_allow_deny=order_to_check_allow_deny,
 215             default_answer=default_answer,
 216         )
 217
 218
 219 class AnyCompoundACL(SimpleACL):
 220     """An ACL that allows if any of its subacls allow."""
 221     def __init__(self,
 222                  *,
 223                  subacls: Optional[List[SimpleACL]] = None,
 224                  order_to_check_allow_deny: Order,
 225                  default_answer: bool) -> None:
 226         super().__init__(
 227             order_to_check_allow_deny = order_to_check_allow_deny,
 228             default_answer = default_answer
 229         )
 230         self.subacls = subacls
 231
 232     def check_allowed(self, x: Any) -> bool:
 233         if self.subacls is None:
 234             return False
 235         return any(acl(x) for acl in self.subacls)
 236
 237     def check_denied(self, x: Any) -> bool:
 238         if self.subacls is None:
 239             return False
 240         return any(not acl(x) for acl in self.subacls)
 241
 242
 243 class AllCompoundACL(SimpleACL):
 244     """An ACL that allows if all of its subacls allow."""
 245     def __init__(self,
 246                  *,
 247                  subacls: Optional[List[SimpleACL]] = None,
 248                  order_to_check_allow_deny: Order,
 249                  default_answer: bool) -> None:
 250         super().__init__(
 251             order_to_check_allow_deny = order_to_check_allow_deny,
 252             default_answer = default_answer
 253         )
 254         self.subacls = subacls
 255
 256     def check_allowed(self, x: Any) -> bool:
 257         if self.subacls is None:
 258             return False
 259         return all(acl(x) for acl in self.subacls)
 260
 261     def check_denied(self, x: Any) -> bool:
 262         if self.subacls is None:
 263             return False
 264         return any(not acl(x) for acl in self.subacls)