Changeset 6822 for TI12-security


Ignore:
Timestamp:
15/04/10 16:39:27 (10 years ago)
Author:
pjkersha
Message:

Added rule combining algorithm module with class factory and implementation for permit overrides algorithm.

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml/core
Files:
1 added
4 edited

Legend:

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

    r6806 r6822  
    1 """NDG Security Condition type definition 
     1"""NDG XACML Condition type definition 
    22 
    33NERC DataGrid Project 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/pdp.py

    r6807 r6822  
    2222from ndg.xacml.core.context.result import Result, Decision 
    2323from ndg.xacml.core.context.result import StatusCode 
    24         
     24 
    2525 
    2626class PDPError(XacmlContextError): 
     
    144144             
    145145            # Check rules 
    146             ruleDecisions = [False]*len(self.policy.rules) 
    147             for i, rule in enumerate(self.policy.rules): 
    148                 ruleDecisions[i] = rule.evaluate(request) 
     146#            ruleDecisions = [False]*len(self.policy.rules) 
     147#            for i, rule in enumerate(self.policy.rules): 
     148#                ruleDecisions[i] = rule.evaluate(request) 
    149149                 
    150             # TODO: Apply the rule combining algorithm here combining the  
     150            # Apply the rule combining algorithm here combining the  
    151151            # effects from the rules evaluated into an overall decision 
    152                       
     152            result.decision = self.policy.ruleCombiningAlg.evaluate( 
     153                                                            self.policy.rules, 
     154                                                            request) 
    153155        except PDPError, e: 
    154156            log.error('Exception raised evaluating request context, returning ' 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py

    r6777 r6822  
    1717from ndg.xacml.core.rule import Rule 
    1818from ndg.xacml.core.obligation import Obligation 
     19from ndg.xacml.core.rule_combining_alg import (RuleCombiningAlgInterface, 
     20                                               RuleCombiningAlgClassFactory) 
    1921 
    2022 
     
    5456        '__target', 
    5557        '__attr', 
    56         '__obligations' 
     58        '__obligations', 
     59        '__ruleCombiningAlgFactory', 
     60        '__ruleCombiningAlg' 
    5761    ) 
    5862     
     
    7175         
    7276        self.__obligations = TypedList(Obligation) 
    73  
     77         
     78        self.__ruleCombiningAlgFactory = RuleCombiningAlgClassFactory() 
     79 
     80        self.__ruleCombiningAlg = None 
     81 
     82    def _getRuleCombiningAlgFactory(self): 
     83        return self.__ruleCombiningAlgFactory 
     84 
     85    def _setRuleCombiningAlgFactory(self, value): 
     86        if not isinstance(value, RuleCombiningAlgClassFactory): 
     87            raise TypeError('Expecting %r derived type for ' 
     88                            '"ruleCombiningAlgFactory" attibute; got %r' %  
     89                            (RuleCombiningAlgClassFactory, type(value))) 
     90             
     91        self.__ruleCombiningAlgFactory = value 
     92 
     93    ruleCombiningAlgFactory = property(_getRuleCombiningAlgFactory,  
     94                                       _setRuleCombiningAlgFactory,  
     95                                       doc="Rule Combining Algorithm Factory") 
     96    def _getRuleCombiningAlg(self): 
     97        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") 
     110     
    74111    @classmethod 
    75112    def fromSource(cls, source, readerFactory): 
     
    137174                                 (value, Policy.RULE_COMBINING_ALG_IDS)) 
    138175        self.__ruleCombiningAlgId = value 
     176         
     177        # Look-up rule combining algorithm 
     178        self.__ruleCombiningAlg = self.__ruleCombiningAlgFactory( 
     179                                                    self.__ruleCombiningAlgId) 
    139180 
    140181    ruleCombiningAlgId = property(_getRuleCombiningAlgId,  
     
    229270        policy.parse() 
    230271        return policy 
     272 
     273 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/rule.py

    r6807 r6822  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12import traceback 
    1213import logging 
    1314log = logging.getLogger(__name__) 
     
    209210        @type context: ndg.xacml.core.request.Request 
    210211        @return: result of the evaluation - the decision for this rule 
    211         @rtype:  
     212        @rtype: ndg.xacml.core.context.result.Decision 
    212213        """ 
    213         log.debug('Evaluating rule %r ...', self.id) 
    214          
    215         # Default to indeterminate 
    216         decision = Decision() 
    217          
    218         # Check for a rule target 
    219         if self.target is not None: 
    220             targetMatch = self.target.match(context) 
    221             if targetMatch: 
    222                 log.debug('Match to request context for target in rule ' 
    223                           '%r', self.id) 
    224         else: 
    225             log.debug('No target set in rule %r', self.id) 
    226             targetMatch = True 
    227    
    228         if not targetMatch: 
    229             decision = Decision.NOT_APPLICABLE 
     214         
     215        # Place exception block to enable rule combining algorithm which calls 
     216        # this method to correctly handle Indeterminate results 
     217        try: 
     218            log.debug('Evaluating rule %r ...', self.id) 
     219             
     220            # Default to indeterminate 
     221            decision = Decision() 
     222             
     223            # Check for a rule target 
     224            if self.target is not None: 
     225                targetMatch = self.target.match(context) 
     226                if targetMatch: 
     227                    log.debug('Match to request context for target in rule ' 
     228                              '%r', self.id) 
     229            else: 
     230                log.debug('No target set in rule %r', self.id) 
     231                targetMatch = True 
     232       
     233            if not targetMatch: 
     234                decision = Decision.NOT_APPLICABLE 
     235                return decision 
     236             
     237            # Apply the condition if present 
     238            if self.condition is not None: 
     239                conditionStatus = self.condition.evaluate(context) 
     240            else: 
     241                # No condition set to True - 7.8 in spec.: 
     242                # 
     243                # The condition value SHALL be "True" if the <Condition> element 
     244                # is absent 
     245                conditionStatus = True 
     246                 
     247            if conditionStatus: 
     248                decision = Decision(decision=self.effect.value) 
     249                 
    230250            return decision 
    231251         
    232         # Apply the condition if present 
    233         if self.condition is not None: 
    234             conditionStatus = self.condition.evaluate(context) 
    235         else: 
    236             # No condition set to True - 7.8 in spec.: 
    237             # 
    238             # The condition value SHALL be "True" if the <Condition> element is  
    239             # absent 
    240             conditionStatus = True 
    241              
    242         if conditionStatus: 
    243             decision = Decision(decision=self.effect.value) 
    244              
    245         return decision 
    246  
     252        except Exception: 
     253            log.error('Error occured evaluating rule %r, returning ' 
     254                      'Indeterminate result to caller: %s', 
     255                      self.id, 
     256                      traceback.format_exc()) 
Note: See TracChangeset for help on using the changeset viewer.