Ignore:
Timestamp:
29/03/10 17:07:31 (10 years ago)
Author:
pjkersha
Message:
  • Started work on processing for <Condition> statement of <Rule>.
  • Fixed ndg1.xml for correct Condition statement for setting a - user must have at least one of these roles - condition.
Location:
TI12-security/trunk/NDG_XACML/ndg/xacml
Files:
1 added
11 edited

Legend:

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

    r6774 r6783  
    1414     
    1515class XacmlCoreBase(object): 
    16     """Base class for Policy and Policy subelements""" 
    17     XACML_2_0_XMLNS = "urn:oasis:names:tc:xacml:2.0:policy:schema:os" 
     16    """Base class for all XACML types""" 
     17    XACML_1_0_NS_PREFIX = "urn:oasis:names:tc:xacml:1.0" 
     18    XACML_2_0_NS_PREFIX = "urn:oasis:names:tc:xacml:2.0" 
    1819 
    1920    __slots__ = ('__xmlns', '__reader', '__writer', '__elem') 
     
    2223     
    2324    def __init__(self): 
    24         self.__xmlns = XacmlCoreBase.XACML_2_0_XMLNS 
     25        self.__xmlns = None 
    2526        self.__reader = None 
    2627        self.__writer = None 
     
    3233         
    3334    def _getXmlns(self): 
     35        """XML Namespace for this XACML type""" 
    3436        return self.__xmlns 
    3537 
    3638    def _setXmlns(self, value): 
     39        """XML Namespace for this XACML type""" 
    3740        if not isinstance(value, basestring): 
    3841            raise TypeError('Expecting string type for "xmlns" ' 
     
    8790        self.__elem = value 
    8891             
     92 
     93class XacmlPolicyBase(XacmlCoreBase): 
     94    """Base class for policy types""" 
     95    XACML_2_0_POLICY_NS = XACML_2_0_NS_PREFIX + ":policy:schema:os" 
     96    def __init__(self): 
     97        super(XacmlPolicyBase, self).__init__() 
     98        self.xmlns = XacmlPolicyBase.XACML_2_0_POLICY_NS 
    8999             
    90 class TargetChildBase(XacmlCoreBase): 
     100         
     101class TargetChildBase(XacmlPolicyBase): 
    91102    """Base type for XACML Policy Subject, Resource, Action and Environment  
    92103    types""" 
     
    96107     
    97108    def __init__(self): 
     109        super(TargetChildBase, self).__init__() 
     110         
    98111        # Derived types can specify the type for matches via the MATCH_TYPE 
    99112        # class variable 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/__init__.py

    r6776 r6783  
    1212__revision__ = "$Id: $" 
    1313from ndg.xacml.utils import TypedList 
     14from ndg.xacml.core import XacmlContextBase 
    1415from ndg.xacml.core.attribute import Attribute 
    1516 
    1617 
    17 class XacmlContextBase(object): 
     18class XacmlContextBase(XacmlCoreBase): 
    1819    """Base class for XACML Request and Response types""" 
    1920    ELEMENT_LOCAL_NAME = None 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/pdp.py

    r6782 r6783  
    1616 
    1717from ndg.xacml.core.context.pdpinterface import PDPInterface 
     18from ndg.xacml.core.rule import Effect 
    1819from ndg.xacml.core.policy import Policy 
     20from ndg.xacml.core.apply import Apply 
     21from ndg.xacml.core.attributevalue import AttributeValue 
     22from ndg.xacml.core.variablereference import VariableReference 
     23from ndg.xacml.core.attributedesignator import AttributeDesignator 
     24from ndg.xacml.core.attributeselector import AttributeSelector 
    1925from ndg.xacml.core.context.request import Request 
    2026from ndg.xacml.core.context.response import Response 
    2127from ndg.xacml.core.context.result import Result, Decision 
     28from ndg.xacml.core.context.result import StatusCode 
    2229from ndg.xacml.core.functions import FunctionMap 
    23 from ndg.xacml.parsers import AbstractReader 
    2430                             
    25          
     31 
     32class PDPError(Exception): 
     33    """Base class for PDP class exceptions""" 
     34    def __init__(self, *arg, **kw): 
     35        super(PDPError, self).__init__(*arg, **kw) 
     36        self.__response = Response() 
     37        self.__response.results.append(Result.createInitialised()) 
     38         
     39        if len(arg) > 0: 
     40            self.__response.results[0].status.statusMessage = arg[0] 
     41         
     42    @property 
     43    def response(self): 
     44        """Context response object associated with this exception 
     45        """ 
     46        return self.__response 
     47     
     48    @response.setter 
     49    def response(self, value): 
     50        if not isinstance(value, Response): 
     51            raise TypeError('Expecting %r type for "response" attribute; got ' 
     52                            '%r instead' % (Response, type(Response))) 
     53        self.__response = value 
     54 
     55  
     56class UnsupportedFunctionError(PDPError): 
     57    """Encountered a function type that is not supported in this implementation 
     58    """ 
     59    def __init__(self, *arg, **kw): 
     60        super(UnsupportedFunctionError, self).__init__(*arg, **kw) 
     61        self.response.results[0].status.statusCode = StatusCode.PROCESSING_ERROR 
     62 
     63 
     64class UnsupportedStdFunctionError(UnsupportedFunctionError):  
     65    """Encountered a function type that is not supported even though it is part 
     66    of the XACML spec.""" 
     67  
     68     
     69class UnsupportedElementError(PDPError): 
     70    """Element type is not supported in this implementation""" 
     71    def __init__(self, *arg, **kw): 
     72        super(UnsupportedElementError, self).__init__(*arg, **kw) 
     73        self.response.results[0].status.statusCode = StatusCode.SYNTAX_ERROR 
     74 
     75 
     76class UnsupportedStdElementError(UnsupportedElementError): 
     77    """Element type is part of the XACML spec but is not suppored in this  
     78    implementation"""   
     79     
     80     
    2681class PDP(PDPInterface): 
    2782    """A XACML Policy Decision Point implementation.  It supports the use of a  
     
    4196            self.policy = policy 
    4297             
    43         self.matchFunc = FunctionMap.withLoadedMap() 
     98        self.functionMap = FunctionMap.withLoadedMap() 
    4499 
    45100         
     
    97152             
    98153            if not self.matchTarget(self.policy.target, request): 
    99                 log.debug('No match for policy target setting Decision=%s', 
     154                log.debug('No match for policy target setting %r decision', 
    100155                          Decision.NOT_APPLICABLE_STR) 
    101156                 
     
    106161             
    107162            # Check rules 
    108             for rule in self.policy.rules: 
     163            ruleEffects = [Effect()]*len(self.policy.rules) 
     164            for rule, effect in zip(self.policy.rules, ruleEffects): 
    109165                log.debug('Checking policy rule %r for match...', rule.id) 
    110166                if not self.matchTarget(rule.target, request): 
    111167                    log.debug('No match to request context for target in rule ' 
    112168                              '%r', rule.id) 
     169                    effect.value = Effect.PERMIT_STR 
    113170                    continue    
    114171                 
    115172                # Apply the condition 
    116                 self.appyCondition(rule.condition)       
    117         except: 
     173                effect = self.applyCondition(rule.condition)  
     174                      
     175        except PDPError, e: 
    118176            log.error('Exception raised evaluating request context, returning ' 
    119                       'Decision=%s:%s',  
     177                      '%r decision:%s',  
    120178                      Decision.INDETERMINATE_STR,  
    121179                      traceback.format_exc()) 
     180             
    122181            result.decision = Decision.INDETERMINATE 
     182            result.status.statusCode = e.response.results[0].status.statusCode 
     183             
     184        except Exception: 
     185            # Catch all so that nothing is handled from within the scope of this 
     186            # method 
     187            log.error('No PDPError type exception raised evaluating request ' 
     188                      'context, returning %r decision:%s',  
     189                      Decision.INDETERMINATE_STR,  
     190                      traceback.format_exc())  
     191                        
     192            result.decision = Decision.INDETERMINATE 
     193            result.status.statusCode = StatusCode.PROCESSING_ERROR 
    123194             
    124195        return response 
     
    167238                continue 
    168239             
    169             # Iterate over each for example, subject in the list of subjects or 
    170             # for example, resource in the list of resources and so on 
     240            # Iterate over each for example, subject in the list of subjects: 
     241            # <Target> 
     242            #     <Subjects> 
     243            #          <Subject> 
     244            #              ... 
     245            #          </Subject> 
     246            #          <Subject> 
     247            #              ... 
     248            #          </Subject> 
     249            #     ... 
     250            # or for example, resource in the list of resources and so on 
    171251            for targetSubElem in targetElem: 
    172252                 
     
    187267     
    188268    def matchTargetChild(self, targetChild, requestChild): 
    189         """Match a child (Subject, Resource, Action or Environment) from the  
    190         request context with a given target's child 
     269        """Match a request child element (a <Subject>, <Resource>, <Action> or  
     270        <Environment>) with the corresponding target's <Subject>, <Resource>,  
     271        <Action> or <Environment>. 
    191272         
    192273        @param targetChild: Target Subject, Resource, Action or Environment 
     
    198279        @return: True if request context matches something in the target 
    199280        @rtype: bool 
    200         @raise NotImplementedError: AttributeSelector processing is not  
     281        @raise UnsupportedElementError: AttributeSelector processing is not  
    201282        currently supported.  If an AttributeSelector is found in the policy, 
    202283        this exception will be raised. 
    203         """ 
    204         matchStatus = True 
     284        @raise UnsupportedStdFunctionError: policy references a function type  
     285        which is in the XACML spec. but is not supported by this implementation 
     286        @raise UnsupportedFunctionError: policy references a function type which 
     287        is not supported by this implementation 
     288        """ 
    205289         
    206290        if targetChild is None: 
     
    208292            return True 
    209293         
     294         
     295        matchStatusValues = [True]*len(targetChild.matches) 
    210296         
    211297        # Section 7.6 
     
    214300        # request context if the value of all its <SubjectMatch>,  
    215301        # <ResourceMatch>, <ActionMatch> or <EnvironmentMatch> elements,  
    216         # respectively, are “True”. 
    217         for childMatch in targetChild.matches: 
     302        # respectively, are "True". 
     303        # 
     304        # e.g. for <SubjectMatch>es in <Subject> ... 
     305        for childMatch, matchStatus in zip(targetChild.matches,  
     306                                           matchStatusValues): 
     307             
    218308            # Get the match function from the Match ID 
    219             matchFunc = self.matchFunc.get(childMatch.matchId) 
     309            matchFunc = self.functionMap.get(childMatch.matchId) 
    220310            if matchFunc is NotImplemented: 
    221                 raise NotImplementedError('No match function implemented for ' 
    222                                           'MatchId="%s"' % childMatch.matchId) 
    223                  
    224             if matchFunc is None: 
    225                 raise Exception('Match function namespace %r is not recognised'  
    226                                 % childMatch.matchId) 
     311                raise UnsupportedStdFunctionError('No match function ' 
     312                                                  'implemented for MatchId="%s"' 
     313                                                  % childMatch.matchId) 
     314            elif matchFunc is None: 
     315                raise UnsupportedFunctionError('Match function namespace %r is ' 
     316                                               'not recognised' %  
     317                                               childMatch.matchId) 
    227318                 
    228319            matchAttributeValue = childMatch.attributeValue.value 
     
    234325                dataType = childMatch.attributeDesignator.dataType 
    235326                 
    236                 # Issuer is an optional match - see core spec 7.2.4 
     327                # Issuer is an optional match - see core spec. 7.2.4 
    237328                issuer = childMatch.attributeDesignator.issuer 
    238329                if issuer is not None: 
     
    258349                # it's XML representation and an abstraction of the XML parser 
    259350                # for executing XPath searches into that representation 
    260                 raise NotImplementedError('This PDP implementation does not ' 
    261                                           'support <AttributeSelector> ' 
    262                                           'elements') 
     351                raise UnsupportedElementError('This PDP implementation does ' 
     352                                              'not support <AttributeSelector> ' 
     353                                              'elements') 
    263354            else: 
    264355                _attributeMatch = lambda requestChildAttribute: ( 
     
    266357                                    requestChildAttribute.attributeValue.value) 
    267358                ) 
    268                  
    269             for attribute in requestChild.attributes: 
    270                 if _attributeMatch(attribute) == True: 
     359         
     360            # Iterate through each attribute in the request in turn matching it 
     361            # against the target using the generated _attributeMatch function 
     362            # 
     363            # Any Match element NOT matching will result in an overall status of 
     364            # no match. 
     365            # 
     366            # Continue iterating through the whole list even if a False status 
     367            # is found.  The other attributes need to be checked in case an  
     368            # error occurs.  In this case the top-level PDP exception handling  
     369            # block will catch it and set an overall decision of INDETERMINATE 
     370            attrMatchStatusValues = [False]*len(requestChild.attributes) 
     371             
     372            for attribute, attrMatchStatus in zip(requestChild.attributes,  
     373                                                  attrMatchStatusValues): 
     374                attrMatchStatus = _attributeMatch(attribute) 
     375                if attrMatchStatus == True: 
    271376                    if log.getEffectiveLevel() <= logging.DEBUG: 
    272377                        log.debug('Request attribute %r set to %r matches ' 
     
    275380                                  attribute.attributeValue.value) 
    276381                         
    277                     # Default status is True - any *Match element NOT matching 
    278                     # will result in an overall status of no match 
    279                 else:         
    280                     # Don't return here but set the status to False.  The other 
    281                     # attributes need to be checked in case an error occurs. 
    282                     # In this case the top-level PDP exception handling block 
    283                     # will catch it and set an overall decision of INDETERMINATE 
    284                     matchStatus = False 
    285                      
    286         return matchStatus 
    287  
    288     def applyCondition(self, condition): 
    289         """Apply a rule condition""" 
    290          
     382            matchStatus = all(attrMatchStatusValues) 
     383         
     384        # Any match => overall match       
     385        return any(matchStatusValues) 
     386 
     387    def evaluateCondition(self, condition): 
     388        """Evaluate a rule condition""" 
     389         
     390        # Spec:  
     391        # 
     392        # "The condition value SHALL be "True" if the <Condition> element is  
     393        # absent"  
     394        if condition is None: 
     395            return True 
     396         
     397        applyElem = condition.expression 
     398        if not isinstance(applyElem, Apply): 
     399            raise UnsupportedElementError('%r type <Condition> sub-element ' 
     400                                          'processing is not supported in this ' 
     401                                          'implementation' % applyElem) 
     402          
     403        result = self.evaluateApplyStatement(applyElem) 
     404                 
     405    def evaluateApplyStatement(self, applyElem): 
     406        """Evaluate a given Condition <Apply> statement""" 
     407         
     408        # Get function for this <Apply> statement          
     409        func = self.functionMap.get(applyElem.functionId) 
     410        if func is NotImplemented: 
     411            raise UnsupportedStdFunctionError('No match function ' 
     412                                              'implemented for MatchId="%s"' 
     413                                              % applyElem.functionId) 
     414        elif func is None: 
     415            raise UnsupportedFunctionError('<Apply> function namespace %r is ' 
     416                                           'not recognised' %  
     417                                           applyElem.functionId) 
     418             
     419        inputMarshallerMap = { 
     420            Apply: self.evaluateApplyStatement, 
     421            AttributeValue: self.evaluateAttributeValueStatement, 
     422            AttributeDesignator: self.evaluateAttributeDesignator, 
     423            AttributeSelector: NotImplemented, 
     424            VariableReference: NotImplemented 
     425        }    
     426         
     427        # Marshall inputs 
     428        funcInputs = ()*len(applyElem.expressions) 
     429        for i, expression in enumerate(applyElem.expressions): 
     430            marshaller = inputMarshallerMap.get(expression.__class__) 
     431            if marshaller is NotImplemented: 
     432                raise UnsupportedStdElementError('%r type <Apply> sub-element ' 
     433                                                 'processing is not supported ' 
     434                                                 'in this implementation' %  
     435                                                 expression) 
     436            elif marshaller is None: 
     437                raise UnsupportedElementError('%r type <Apply> sub-element ' 
     438                                              'processing is not supported in ' 
     439                                              'this implementation' %  
     440                                              expression) 
     441             
     442            funcInputs[i] = marshaller(self, expression) 
     443             
     444        # Execute function on the retrieved inputs 
     445        result = func(*funcInputs) 
     446         
     447        # Pass the result back to the parent <Apply> element 
     448        return result 
     449             
     450    def evaluateAttributeValueStatement(self, attributeValue): 
     451        return  
     452     
     453    def evaluateAttributeDesignator(self): 
     454        pass 
     455 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/result.py

    r6777 r6783  
    1313log = logging.getLogger(__name__) 
    1414 
     15from ndg.xacml.core import XacmlBase 
    1516from ndg.xacml.core.context import XacmlContextBase 
    1617from ndg.xacml.core.obligation import Obligation 
     
    2324    ELEMENT_LOCAL_NAME = "StatusCode" 
    2425 
    25  
     26    IDENTIFIER_PREFIX = XacmlContextBase.XACML_1_0_NS_PREFIX + ':status' 
     27     
     28    OK = IDENTIFIER_PREFIX + ":ok" 
     29    MISSING_ATTRIBUTE = IDENTIFIER_PREFIX + ":missing-attribute" 
     30    PROCESSING_ERROR = IDENTIFIER_PREFIX + ":processing-error" 
     31    SYNTAX_ERROR = IDENTIFIER_PREFIX + ":syntax-error" 
     32     
     33    CODES = (OK, MISSING_ATTRIBUTE, PROCESSING_ERROR, SYNTAX_ERROR) 
     34     
    2635    __slots__ = ('__value', '__childStatusCode',) 
    2736     
     
    8291        self.__statusDetail = None 
    8392     
     93    @classmethod 
     94    def createInitialised(cls, code=StatusCode.OK, message='', detail=''): 
     95        """Create with an empty StatusCode object set 
     96        """ 
     97        status = cls() 
     98        status.statusCode = StatusCode() 
     99        status.statusCode.value = code 
     100        status.statusCode.statusMessage = message 
     101        status.statusCode.statusDetail = detail 
     102         
     103        return status 
     104         
    84105    def _getStatusCode(self): 
    85106        ''' 
     
    298319        self.__obligations = None 
    299320         
     321    @classmethod 
     322    def createInitialised(cls,  
     323                          decision=Decision.NOT_APPLICABLE, 
     324                          resourceId='',  
     325                          obligations=None 
     326                          **kw): 
     327        """Create a result object populated with all it's child elements 
     328        rather than set to None as is the default from __init__ 
     329        @return: new result object with all its child attributes created 
     330        @rtype: ndg.xacml.core.context.result.Result 
     331        """ 
     332        result = cls() 
     333        result.decision = Decision() 
     334        result.decision.value = decision 
     335        result.status = Status.createInitialised(**kw) 
     336         
     337        if obligations is not None: 
     338            result.obligations = obligations 
     339             
     340        return result 
     341         
    300342    @property 
    301343    def resourceId(self): 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/rule.py

    r6770 r6783  
    1414from ndg.xacml.core.target import Target 
    1515from ndg.xacml.core.condition import Condition 
     16 
     17 
     18class Effect(object): 
     19    """Rule Effect""" 
     20    DENY_STR = 'Deny' 
     21    PERMIT_STR = 'Permit' 
     22    TYPES = (DENY_STR, PERMIT_STR) 
     23    __slots__ = ('__value',) 
     24     
     25    def __init__(self): 
     26        self.__value = Effect.DENY_STR 
     27 
     28    def __getstate__(self): 
     29        '''Enable pickling''' 
     30        _dict = {} 
     31        for attrName in Effect.__slots__: 
     32            # Ugly hack to allow for derived classes setting private member 
     33            # variables 
     34            if attrName.startswith('__'): 
     35                attrName = "_Effect" + attrName 
     36                 
     37            _dict[attrName] = getattr(self, attrName) 
     38             
     39        return _dict 
     40   
     41    def __setstate__(self, attrDict): 
     42        '''Enable pickling''' 
     43        for attrName, val in attrDict.items(): 
     44            setattr(self, attrName, val) 
     45             
     46    def _setValue(self, value): 
     47        if isinstance(value, Effect): 
     48            # Cast to string 
     49            value = str(value) 
     50             
     51        elif not isinstance(value, basestring): 
     52            raise TypeError('Expecting string or Effect instance for ' 
     53                            '"value" attribute; got %r instead' % type(value)) 
     54             
     55        if value not in self.__class__.TYPES: 
     56            raise AttributeError('Permissable effect types are %r; got ' 
     57                                 '%r instead' % (Effect.TYPES, value)) 
     58        self.__value = value 
     59         
     60    def _getValue(self): 
     61        return self.__value 
     62     
     63    value = property(fget=_getValue, fset=_setValue, doc="Effect value") 
     64     
     65    def __str__(self): 
     66        return self.__value 
     67 
     68    def __eq__(self, effect): 
     69        if isinstance(effect, Effect): 
     70            # Cast to string 
     71            value = effect.value 
     72             
     73        elif isinstance(effect, basestring): 
     74            value = effect 
     75             
     76        else: 
     77            raise TypeError('Expecting string or Effect instance for ' 
     78                            'input effect value; got %r instead' % type(value)) 
     79             
     80        if value not in self.__class__.TYPES: 
     81            raise AttributeError('Permissable effect types are %r; got ' 
     82                                 '%r instead' % (Effect.TYPES, value)) 
     83             
     84        return self.__value == value         
     85 
     86 
     87class PermitEffect(Effect): 
     88    """Permit authorisation Effect""" 
     89    __slots__ = () 
     90 
     91    def __init__(self): 
     92        super(PermitEffect, self).__init__(Effect.PERMIT_STR) 
     93         
     94    def _setValue(self):   
     95        raise AttributeError("can't set attribute") 
     96 
     97 
     98class DenyEffect(Effect): 
     99    """Deny authorisation Effect""" 
     100    __slots__ = () 
     101     
     102    def __init__(self): 
     103        super(DenyEffect, self).__init__(Effect.DENY_STR) 
     104         
     105    def _setValue(self, value):   
     106        raise AttributeError("can't set attribute") 
     107 
     108# Add instances of each for convenience 
     109Effect.PERMIT = PermitEffect() 
     110Effect.DENY = DenyEffect() 
    16111 
    17112 
     
    79174 
    80175    def _set_effect(self, value): 
    81         if not isinstance(value, basestring): 
     176        if not isinstance(value, Effect): 
    82177            raise TypeError('Expecting %r type for "effect" ' 
    83178                            'attribute; got %r' % (basestring, type(value))) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/variabledefinition.py

    r6745 r6783  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12from ndg.xacml.core import XacmlPolicyBase 
    1213 
    13 class VariableDefinition(object): 
    14     ''' 
    15     classdocs 
     14 
     15class VariableDefinition(XacmlPolicyBase): 
     16    '''XACML Variable Definition Type 
    1617    ''' 
    1718    ELEMENT_LOCAL_NAME = "VariableDefinition" 
     
    2021     
    2122    def __init__(self): 
    22         ''' 
    23         Constructor 
    24         ''' 
     23        '''This class not needed yet''' 
     24        raise NotImplementedError() 
    2525         
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/applyreader.py

    r6774 r6783  
    1515from ndg.xacml.core.apply import Apply 
    1616from ndg.xacml.core.attributevalue import AttributeValue 
     17from ndg.xacml.core.variablereference import VariableReference 
    1718from ndg.xacml.core.attributeselector import AttributeSelector 
    1819from ndg.xacml.core.attributedesignator import (SubjectAttributeDesignator, 
     
    114115                                          'implemented', localName) 
    115116             
    116             elif (localName ==  
    117                   self.__class__.VARIABLE_REFERENCE_ELEMENT_LOCAL_NAME):                                 
     117            elif (localName == VariableReference.ELEMENT_LOCAL_NAME):                                 
    118118                raise NotImplementedError('%r Apply sub-element not ' 
    119119                                          'implemented', localName) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/reader.py

    r6770 r6783  
    1515from xml.etree import ElementTree 
    1616 
    17 from ndg.xacml.core import XacmlCoreBase 
     17from ndg.xacml.core import XacmlPolicyBase 
    1818from ndg.xacml.parsers import AbstractReader 
    1919 
     
    3232             
    3333        self.__namespace_map_backup = ElementTree._namespace_map.copy() 
    34         ElementTree._namespace_map[''] = XacmlCoreBase.XACML_2_0_XMLNS 
     34        ElementTree._namespace_map[''] = XacmlPolicyBase.XACML_2_0_POLICY_NS 
    3535         
    3636    def __del__(self): 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/ndg1.xml

    r6782 r6783  
    6161            something more specific 
    6262        --> 
    63         <Condition FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-equal"> 
     63        <Condition> 
    6464            <!--  
    6565                The user must have at least one of the roles set - in this 
     
    7373                    Issuer="https://localhost:7443/AttributeAuthority"/> 
    7474                <Apply FunctionId="urn:oasis:names:tc:xacml:1.0:function:string-bag"> 
    75                     <!--  
    76                         A custom attribute type is used for NDG Security because 
    77                         the PDP needs to ask the PIP to retrieve user attributes 
    78                         from the applicable issuing attribute authority 
    79                     --> 
    8075                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"> 
    81                         urn:siteA:security:authz:1.0:attr:staff 
     76                        staff 
     77                    </AttributeValue> 
     78                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"> 
     79                        admin 
     80                    </AttributeValue> 
     81                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"> 
     82                        postdoc 
    8283                    </AttributeValue> 
    8384                </Apply> 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/rule2.xml

    r6754 r6783  
    88    PolicyId="urn:oasis:names:tc:xacml:2.0:example:policyid:2"  
    99    RuleCombiningAlgId="urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides"> 
    10 <!-- 
     10 
    1111    <PolicyDefaults> 
    1212        <XPathVersion>http://www.w3.org/TR/1999/Rec-xpath-19991116</XPathVersion> 
    1313    </PolicyDefaults> 
    14 --> 
     14 
    1515    <Target/> 
    16 <!-- 
     16<!-- VariableDefinition is not currently implemented 29/03/10 
    1717    <VariableDefinition VariableId="17590035"> 
    1818        <Apply FunctionId="urn:oasis:names:tc:xacml:2.0:function:date-less-or-equal"> 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_context.py

    r6782 r6783  
    106106        result = Result() 
    107107        response.results.append(result) 
    108         result.decision = Decision.value = Decision.NOT_APPLICABLE 
     108        result.decision = Decision() 
     109        result.decision.value = Decision.NOT_APPLICABLE 
    109110         
    110111    def test03AbstractCtxHandler(self): 
Note: See TracChangeset for help on using the changeset viewer.