Ignore:
Timestamp:
16/04/10 10:36:08 (10 years ago)
Author:
pjkersha
Message:

Working XACML implementation with permit-overrides rule combining algorithm.

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml/core
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py

    r6822 r6823  
    1717from ndg.xacml.core.rule import Rule 
    1818from ndg.xacml.core.obligation import Obligation 
    19 from ndg.xacml.core.rule_combining_alg import (RuleCombiningAlgInterface, 
    20                                                RuleCombiningAlgClassFactory) 
     19from ndg.xacml.core.rule_combining_alg import (RuleCombiningAlgClassFactory, 
     20                                               RuleCombiningAlgInterface) 
     21from ndg.xacml.core.exceptions import (UnsupportedStdFunctionError, 
     22                                       UnsupportedFunctionError) 
    2123 
    2224 
     
    4345    OBLIGATIONS_LOCAL_NAME = "Obligations" 
    4446     
    45     # Plan to support permit overrides in a future release 
    46     RULE_COMBINING_ALG_IDS = ( 
    47     "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides", 
    48     "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides", 
    49     ) 
    5047    __slots__ = ( 
    5148        '__policyId', 
     
    6158    ) 
    6259     
    63     def __init__(self): 
     60    def __init__(self, ruleCombiningAlgFactory=None): 
     61        """Customise rule combining behaviour by passing in a custom combining 
     62        algorithm factory.  This is invoked when the combining algorithm Id 
     63        property is set in order to create the corresponding combining algorithm 
     64        object 
     65        """ 
    6466        super(Policy, self).__init__() 
    6567        self.__policyId = None 
     
    7678        self.__obligations = TypedList(Obligation) 
    7779         
    78         self.__ruleCombiningAlgFactory = RuleCombiningAlgClassFactory() 
     80        self.__ruleCombiningAlgFactory = None 
     81        if ruleCombiningAlgFactory is None: 
     82            self.ruleCombiningAlgFactory = RuleCombiningAlgClassFactory() 
     83        else: 
     84            self.ruleCombiningAlgFactory = ruleCombiningAlgFactory 
    7985 
    8086        self.__ruleCombiningAlg = None 
     
    94100                                       _setRuleCombiningAlgFactory,  
    95101                                       doc="Rule Combining Algorithm Factory") 
    96     def _getRuleCombiningAlg(self): 
     102     
     103    @property 
     104    def ruleCombiningAlg(self): 
     105        "Rule Combining algorithm" 
    97106        return self.__ruleCombiningAlg 
    98  
    99     def _setRuleCombiningAlg(self, value): 
    100         if (value not in (NotImplemented, None) and  
    101             not issubclass(value, RuleCombiningAlgInterface)): 
    102             raise TypeError('Expecting %r derived type or None or ' 
    103                             'NotImplemented for "ruleCombiningAlg" attibute; ' 
    104                             'got %r' % (RuleCombiningAlgInterface, type(value))) 
    105              
    106         self.__ruleCombiningAlg = value 
    107  
    108     ruleCombiningAlg = property(_getRuleCombiningAlg, _setRuleCombiningAlg,  
    109                                 doc="Rule Combining algorithm") 
    110107     
    111108    @classmethod 
     
    168165                            'attribute; got %r' % type(value)) 
    169166             
    170         if value not in Policy.RULE_COMBINING_ALG_IDS: 
    171             raise AttributeError('%r rule combining algorithm is invalid.  ' 
    172                                  'Only these algorithms are currently ' 
    173                                  'supported %r' %  
    174                                  (value, Policy.RULE_COMBINING_ALG_IDS)) 
    175167        self.__ruleCombiningAlgId = value 
    176          
     168        self._setRuleCombiningAlgFromId() 
     169         
     170    def _setRuleCombiningAlgFromId(self): 
     171        """Set the rule combining algorithm implementation from the Id set 
     172        """ 
    177173        # Look-up rule combining algorithm 
    178         self.__ruleCombiningAlg = self.__ruleCombiningAlgFactory( 
     174        ruleCombiningAlgClass = self.__ruleCombiningAlgFactory( 
    179175                                                    self.__ruleCombiningAlgId) 
     176        if not issubclass(ruleCombiningAlgClass, RuleCombiningAlgInterface): 
     177            raise TypeError('Expecting %r derived type for rule combining ' 
     178                            'algorithm class; got %r' % 
     179                            (RuleCombiningAlgInterface, ruleCombiningAlgClass)) 
     180             
     181        self.__ruleCombiningAlg = ruleCombiningAlgClass() 
     182        if self.__ruleCombiningAlg is NotImplemented: 
     183            raise UnsupportedStdFunctionError('The rule combining algorithm %r ' 
     184                                              'is not currently implemented' %  
     185                                              self.__ruleCombiningAlgId) 
     186             
     187        elif self.__ruleCombiningAlg is None: 
     188            raise UnsupportedFunctionError('%r is not recognised as a valid ' 
     189                                           'XACML rule combining algorithm' %  
     190                                           self.__ruleCombiningAlgId)  
    180191 
    181192    ruleCombiningAlgId = property(_getRuleCombiningAlgId,  
    182193                                  _setRuleCombiningAlgId, None,  
    183194                                  doc="Rule Combining Algorithm Id") 
    184  
    185195 
    186196    @property 
     
    241251                              None,  
    242252                              "Policy PolicyDefaults element")    
    243     def parse(self): 
    244         """Parse the policy file set in policyFilePath attribute 
    245         """ 
    246         elem = ElementTree.parse(self.policyFilePath) 
    247         root = elem.getroot() 
    248          
    249         self.xmlns = QName.getNs(root.tag) 
    250         if not self.isValidXmlns: 
    251             raise InvalidPolicyXmlNsError("Namespace %r is recognised; valid " 
    252                                           "namespaces are: %r" % 
    253                                           (self.xmlns, Policy.XMLNS)) 
    254              
    255         for elem in root: 
    256             localName = QName.getLocalPart(elem.tag) 
    257             if localName == Policy.DESCRIPTION_LOCALNAME: 
    258                 self.description = elem.text.strip() 
    259                  
    260             elif localName == Policy.TARGET_LOCALNAME: 
    261                 self.targets.append(Target.Parse(elem)) 
    262                  
    263             else: 
    264                 raise PolicyParseError("Invalid policy attribute: %s" %  
    265                                         localName) 
    266                  
    267     @classmethod 
    268     def Parse(cls, policyFilePath): 
    269         policy = cls(policyFilePath=policyFilePath) 
    270         policy.parse() 
    271         return policy 
    272  
    273  
     253 
     254 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/rule_combining_alg.py

    r6822 r6823  
    5050 
    5151 
    52 class PermitOverridesRuleCombingAlg(RuleCombiningAlgInterface): 
     52class PermitOverridesRuleCombiningAlg(RuleCombiningAlgInterface): 
    5353    """Implementation of permit overrides XACML rule combining algorithm""" 
    5454     
     
    7070        atLeastOneDeny = False 
    7171         
    72         for rule in rules:    
     72        for rule in rules: 
    7373            decision = rule.evaluate(context) 
    7474            if decision == Decision.DENY: 
     
    105105    """Class Factory mapping Rule Combining Algorithm identifiers to their 
    106106    class implementations""" 
     107     
     108    # All algorithms are not implemented by default(!) 
    107109    DEFAULT_MAP = {}.fromkeys(ALGORITHMS, NotImplemented) 
     110     
     111    # Permit overrides is the only one currently implemented 
    108112    DEFAULT_MAP[ 
    109113        'urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides' 
    110         ] = PermitOverridesRuleCombingAlg 
     114        ] = PermitOverridesRuleCombiningAlg 
    111115     
    112116    def __init__(self, map=DEFAULT_MAP): 
     
    116120    def __call__(self, identifier): 
    117121        """Return the class for a given Rule Combining Algorithm identifier 
     122        @param identifier: XACML rule combining algorithm urn 
     123        @type identifier: basestring 
     124        @return: rule combining class corresponding to the given input 
     125        identifier 
     126        @rtype: RuleCombiningAlgInterface derived type or NoneType if no match  
     127        is found or NotImplementedType if the identifier corresponds to a valid  
     128        XACML rule combining algorithm but is not supported in this  
     129        implementation 
    118130        """ 
    119         self.__map.get(identifier) 
     131        return self.__map.get(identifier) 
Note: See TracChangeset for help on using the changeset viewer.