Changeset 6825 for TI12-security


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

Moved PDP evaluate content into Policy.evaluate

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

Legend:

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

    r6822 r6825  
    1 """NDG Security Policy Decision Point type definition 
     1"""NDG XACML Policy Decision Point type definition 
    22 
    33NERC DataGrid Project 
     
    1313log = logging.getLogger(__name__) 
    1414 
    15 import traceback 
    16  
    17 from ndg.xacml.core.context.exceptions import XacmlContextError 
    1815from ndg.xacml.core.context.pdpinterface import PDPInterface 
    1916from ndg.xacml.core.policy import Policy 
    20 from ndg.xacml.core.context.request import Request 
    21 from ndg.xacml.core.context.response import Response 
    22 from ndg.xacml.core.context.result import Result, Decision 
    23 from ndg.xacml.core.context.result import StatusCode 
    2417 
    2518 
    26 class PDPError(XacmlContextError): 
    27     """Base class for PDP class exceptions""" 
    28       
    29      
    30 class UnsupportedElementError(PDPError): 
    31     """Element type is not supported in this implementation""" 
    32     def __init__(self, *arg, **kw): 
    33         super(UnsupportedElementError, self).__init__(*arg, **kw) 
    34         self.response.results[0 
    35                             ].status.statusCode.value = StatusCode.SYNTAX_ERROR 
    36  
    37  
    38 class UnsupportedStdElementError(UnsupportedElementError): 
    39     """Element type is part of the XACML spec. but is not supported in this  
    40     implementation"""   
    41      
    42      
    4319class PDP(PDPInterface): 
    4420    """A XACML Policy Decision Point implementation.  It supports the use of a  
    4521    single policy but not policy sets 
    4622    """ 
    47     __slots__ = ('__policy', '__request') 
     23    __slots__ = ('__policy', ) 
    4824     
    4925    def __init__(self, policy=None): 
     
    8561                            '%r instead' % (Policy, type(value))) 
    8662        self.__policy = value 
    87  
    88     @property 
    89     def request(self): 
    90         """request context""" 
    91         return self.__request 
    92      
    93     @request.setter 
    94     def request(self, value): 
    95         '''request context''' 
    96         if not isinstance(value, Request): 
    97             raise TypeError('Expecting %r derived type for "request" ' 
    98                             'input; got %r instead' % (Request,  
    99                                                        type(value))) 
    100         self.__request = value 
    10163                                         
    10264    def evaluate(self, request): 
    10365        """Make an access control decision for the given request based on the 
    104         policy set 
     66        single policy provided 
    10567         
    10668        @param request: XACML request context 
     
    10971        @rtype: ndg.xacml.core.context.response.Response 
    11072        """ 
    111         response = Response() 
    112         result = Result.createInitialised(decision=Decision.NOT_APPLICABLE) 
    113         response.results.append(result) 
     73        response = self.policy.evaluate(request) 
    11474         
    115         try: 
    116             self.request = request 
    117              
    118         except AttributeError, e: 
    119             log.error(str(e)) 
    120             result.decision = Decision.INDETERMINATE 
    121             return response 
    122              
    123         # Exception block around all rule processing in order to set 
    124         # INDETERMINATE response from any exceptions raised 
    125         try: 
    126             log.debug('Checking policy %r target for match with request...', 
    127                       self.policy.policyId) 
    128              
    129             target = self.policy.target 
    130              
    131             # If no target is set, ALL requests are counted as matches 
    132             if target is not None: 
    133                 if not target.match(request): 
    134                     # The target didn't match so the whole policy does not apply 
    135                     # to this request 
    136                     log.debug('No match for policy target setting %r decision', 
    137                               Decision.NOT_APPLICABLE_STR) 
    138                      
    139                     result.decision = Decision.NOT_APPLICABLE 
    140                     return response 
    141              
    142             log.debug('Request matches the Policy %r target',  
    143                       self.policy.policyId) 
    144              
    145             # Check rules 
    146 #            ruleDecisions = [False]*len(self.policy.rules) 
    147 #            for i, rule in enumerate(self.policy.rules): 
    148 #                ruleDecisions[i] = rule.evaluate(request) 
    149                  
    150             # Apply the rule combining algorithm here combining the  
    151             # effects from the rules evaluated into an overall decision 
    152             result.decision = self.policy.ruleCombiningAlg.evaluate( 
    153                                                             self.policy.rules, 
    154                                                             request) 
    155         except PDPError, e: 
    156             log.error('Exception raised evaluating request context, returning ' 
    157                       '%r decision:%s',  
    158                       e.response.results[0].decision,  
    159                       traceback.format_exc()) 
    160              
    161             result = e.response.results[0] 
    162              
    163         except Exception: 
    164             # Catch all so that nothing is handled from within the scope of this 
    165             # method 
    166             log.error('No PDPError type exception raised evaluating request ' 
    167                       'context, returning %r decision:%s',  
    168                       Decision.INDETERMINATE_STR,  
    169                       traceback.format_exc())  
    170                         
    171             result.decision = Decision.INDETERMINATE 
    172             result.status.statusCode.value = StatusCode.PROCESSING_ERROR 
    173              
    17475        return response 
    17576 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py

    r6823 r6825  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12import traceback 
     13import logging 
     14log = logging.getLogger(__name__) 
     15 
    1216from ndg.xacml.utils import TypedList 
    1317from ndg.xacml.parsers import AbstractReaderFactory, AbstractReader 
     
    2125from ndg.xacml.core.exceptions import (UnsupportedStdFunctionError, 
    2226                                       UnsupportedFunctionError) 
     27 
     28# Evaluation of a request context 
     29from ndg.xacml.core.context.response import Response 
     30from ndg.xacml.core.context.result import Result, Decision, StatusCode 
     31from ndg.xacml.core.context.exceptions import XacmlContextError 
    2332 
    2433 
     
    252261                              "Policy PolicyDefaults element")    
    253262 
    254  
     263    def evaluate(self, request): 
     264        """Make an access control decision for the given request based on this 
     265        policy 
     266         
     267        @param request: XACML request context 
     268        @type request: ndg.xacml.core.context.request.Request 
     269        @return: XACML response instance 
     270        @rtype: ndg.xacml.core.context.response.Response 
     271        """ 
     272        response = Response() 
     273        result = Result.createInitialised(decision=Decision.NOT_APPLICABLE) 
     274        response.results.append(result) 
     275             
     276        # Exception block around all rule processing in order to set 
     277        # INDETERMINATE response from any exceptions raised 
     278        try: 
     279            log.debug('Checking policy %r target for match with request...', 
     280                      self.policyId) 
     281             
     282            target = self.target 
     283             
     284            # If no target is set, ALL requests are counted as matches 
     285            if target is not None: 
     286                if not target.match(request): 
     287                    # The target didn't match so the whole policy does not apply 
     288                    # to this request 
     289                    log.debug('No match for policy target setting %r decision', 
     290                              Decision.NOT_APPLICABLE_STR) 
     291                     
     292                    result.decision = Decision.NOT_APPLICABLE 
     293                    return response 
     294             
     295            log.debug('Request matches the Policy %r target', self.policyId) 
     296             
     297            # Apply the rule combining algorithm here combining the  
     298            # effects from the rules evaluated into an overall decision 
     299            result.decision = self.ruleCombiningAlg.evaluate(self.rules, 
     300                                                             request) 
     301        except XacmlContextError, e: 
     302            log.error('Exception raised evaluating request context, returning ' 
     303                      '%r decision:%s',  
     304                      e.response.results[0].decision,  
     305                      traceback.format_exc()) 
     306             
     307            result = e.response.results[0] 
     308             
     309        except Exception: 
     310            # Catch all so that nothing is handled from within the scope of this 
     311            # method 
     312            log.error('No PDPError type exception raised evaluating request ' 
     313                      'context, returning %r decision:%s',  
     314                      Decision.INDETERMINATE_STR,  
     315                      traceback.format_exc())  
     316                        
     317            result.decision = Decision.INDETERMINATE 
     318            result.status.statusCode.value = StatusCode.PROCESSING_ERROR 
     319             
     320        return response 
     321 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/rule.py

    r6822 r6825  
    232232       
    233233            if not targetMatch: 
     234                log.debug('No match to request context for target in rule ' 
     235                          '%r returning NotApplicable status', self.id) 
    234236                decision = Decision.NOT_APPLICABLE 
    235237                return decision 
     
    243245                # The condition value SHALL be "True" if the <Condition> element 
    244246                # is absent 
     247                log.debug('No condition set for rule %r: setting condition ' 
     248                          'status True', self.id) 
    245249                conditionStatus = True 
    246250                 
     
    251255         
    252256        except Exception: 
    253             log.error('Error occured evaluating rule %r, returning ' 
     257            log.error('Error occurred evaluating rule %r, returning ' 
    254258                      'Indeterminate result to caller: %s', 
    255259                      self.id, 
    256260                      traceback.format_exc()) 
     261            return Decision.INDETERMINATE 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/target.py

    r6807 r6825  
    141141        @return: True if request context matches something in the target 
    142142        @rtype: bool 
    143         @raise UnsupportedElementError: AttributeSelector processing is not  
    144         currently supported.  If an AttributeSelector is found in the policy, 
    145         this exception will be raised. 
    146143        @raise UnsupportedStdFunctionError: policy references a function type  
    147144        which is in the XACML spec. but is not supported by this implementation 
Note: See TracChangeset for help on using the changeset viewer.