Changeset 6805


Ignore:
Timestamp:
14/04/10 15:45:01 (11 years ago)
Author:
pjkersha
Message:

Working <Condition> statement processing. This means that policy rules can now be evaluated. The rule combining algorithm handling needs to be implemented to complete the PDP processing.

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

Legend:

Unmodified
Added
Removed

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/apply.py

    r6804 r6805  
    136136         
    137137        # Marshall inputs 
    138         funcInputs = ['']*len(self.expressions) 
     138        funcInputs = [None]*len(self.expressions) 
    139139 
    140140        for i, expression in enumerate(self.expressions): 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attribute.py

    r6792 r6805  
    3535        "attribute values" 
    3636        return self.__attributeValues 
     37      
     38    @attributeValues.setter 
     39    def attributeValues(self, value): 
     40        "attribute values" 
     41        if not isinstance(value, TypedList): 
     42            raise TypeError('Expecting %r type for "attributeValues" ' 
     43                            'attribute; got %r' % (TypedList, type(value))) 
    3744             
     45        self.__attributeValues = value 
     46                    
    3847    def _get_dataType(self): 
    3948        return self.__dataType 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributedesignator.py

    r6796 r6805  
    1212from ndg.xacml.utils import TypedList 
    1313from ndg.xacml.core.expression import Expression 
    14 from ndg.xacml.core.attributevalue import AttributeValue 
     14from ndg.xacml.core.attributevalue import (AttributeValue,  
     15                                           AttributeValueClassFactory) 
    1516from ndg.xacml.core.context.request import Request 
    1617from ndg.xacml.core.context.exceptions import MissingAttributeError 
    … …  
    2425    MUST_BE_PRESENT_ATTRIB_NAME = 'MustBePresent' 
    2526     
    26     __slots__ = ('__attributeId', '__issuer', '__mustBePresent') 
     27    __slots__ = ( 
     28        '__attributeId',  
     29        '__issuer',  
     30        '__mustBePresent', 
     31        '__attributeValueFactory' 
     32    ) 
    2733     
    2834    def __init__(self): 
    … …  
    3137        self.__issuer = None 
    3238        self.__mustBePresent = False 
     39        self.__attributeValueFactory = AttributeValueClassFactory() 
    3340 
    3441    @property 
    … …  
    7279                            'attribute; got %r' % (bool, type(value))) 
    7380             
    74         self.__mustBePresent = value         
    75                  
     81        self.__mustBePresent = value    
     82              
     83    @property 
     84    def attributeValueFactory(self): 
     85        """Get Attribute Value factory function""" 
     86        return self.__attributeValueFactory 
     87                     
    7688         
    7789class SubjectAttributeDesignator(AttributeDesignator): 
    7890    """XACML Subject Attribute Designator type""" 
    7991    ELEMENT_LOCAL_NAME = 'SubjectAttributeDesignator' 
    80  
     92         
    8193    def evaluate(self, context): 
    8294        """Evaluate the result of the SubjectAttributeDesignator in a condition 
    … …  
    92104                            (Request, type(context))) 
    93105         
    94         attributeValueBag = TypedList(AttributeValue) 
    95         dataType = self.dataType 
     106        dataType = self.dataType 
     107        attributeValueBag = TypedList(self.attributeValueFactory(dataType)) 
    96108        attributeId = self.attributeId 
    97109        issuer = self.issuer 
    … …  
    141153                            (Request, type(context))) 
    142154         
    143         attributeValueBag = TypedList(AttributeValue) 
    144         dataType = self.dataType 
     155        dataType = self.dataType 
     156        attributeValueBag = TypedList(self.attributeValueFactory(dataType)) 
    145157        attributeId = self.attributeId 
    146158        issuer = self.issuer 
    … …  
    190202                            (Request, type(context))) 
    191203         
    192         attributeValueBag = TypedList(AttributeValue) 
    193         dataType = self.dataType 
     204        dataType = self.dataType 
     205        attributeValueBag = TypedList(self.attributeValueFactory(dataType)) 
    194206        attributeId = self.attributeId 
    195207        issuer = self.issuer 
    … …  
    240252                            (Request, type(context))) 
    241253         
    242         attributeValueBag = [] 
    243         dataType = self.dataType 
     254        dataType = self.dataType 
     255        attributeValueBag = TypedList(self.attributeValueFactory(dataType)) 
    244256        attributeId = self.attributeId 
    245257        issuer = self.issuer 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/attributevalue.py

    r6804 r6805  
    5151             
    5252        self.__value = None 
    53             
     53 
     54    def __repr__(self): 
     55        return "%s = %r " % (super(AttributeValue, self).__repr__(), 
     56                             self.__value) 
     57     
    5458    def _get_value(self): 
    5559        return self.__value 
    … …  
    6670     
    6771    def evaluate(self, context): 
    68         """Evaluate the result of the expression in a condition 
     72        """Evaluate the result of the expression in a condition.  In the case of 
     73        an attribute value it's simply itself 
     74         
    6975        @param context: the request context 
    7076        @type context: ndg.xacml.core.context.request.Request 
    71         @return: attribute value(s) resulting from execution of this expression 
    72         in a condition 
    73         @rtype: AttributeValue/NoneType   
     77        @return: this attribute value 
     78        @rtype: AttributeValue   
    7479        """  
    75         return self.__value 
     80        return self 
    7681 
    7782 

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

    r6804 r6805  
    304304                _attributeMatch = self.attributeDesignatorMatchFuncFactory( 
    305305                                                matchFunctionClass(), 
    306                                                 childMatch.attributeValue.value, 
     306                                                childMatch.attributeValue, 
    307307                                                childMatch.attributeDesignator) 
    308308                 
    … …  
    371371         
    372372        _attributeMatch = lambda attribute: ( 
    373             any([matchFunc.evaluate(matchAttributeValue, attrVal.value)  
     373            any([matchFunc.evaluate(matchAttributeValue, attrVal)  
    374374                 for attrVal in attribute.attributeValues]) and 
    375375            attribute.attributeId == attributeId and 
    … …  
    403403          
    404404        result = applyElem.evaluate(self.request) 
    405  
    406  
    407  
     405         
     406        return result 
     407 
     408 
     409 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/__init__.py

    r6804 r6805  
    1616log = logging.getLogger(__name__) 
    1717 
    18 from ndg.xacml.core.attributevalue import AttributeValue 
     18from ndg.xacml.core.attributevalue import (AttributeValue,  
     19                                           AttributeValueClassFactory) 
    1920from ndg.xacml.utils import VettedDict, _isIterable 
    2021from ndg.xacml.utils.factory import callModuleObject 
    … …  
    349350                                  for n in functionSuffixParts if n]) 
    350351         
     352        attributeValueClassFactory = AttributeValueClassFactory() 
     353         
    351354        for identifier in self.__class__.FUNCTION_NAMES:             
    352355            # Extract the function name and the type portion of the function 
    … …  
    356359             
    357360            typeName = typePart[0].upper() + typePart[1:] 
    358             _type = AttributeValue.TYPE_MAP.get(typeName) 
     361            typeURI = AttributeValue.IDENTIFIER_PREFIX + typePart 
     362            _type = attributeValueClassFactory(typeURI) 
    359363            if _type is None: 
    360364                raise TypeError('No AttributeValue.TYPE_MAP entry for %r type' % 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/at_least_one_member_of.py

    r6804 r6805  
    1616class AtLeastOneMemberOfBase(AbstractFunction): 
    1717    """Base class implementation for at least one member of XACML function - 
    18     check an item of a given type is contained in a given bag 
     18    check at least one item in one set is contained in the second set 
    1919     
    2020    urn:oasis:names:tc:xacml:1.0:function:<type>-at-least-one-member-of 
     21     
     22    @cvar TYPE: AttributeValue type for the sets 
     23    @type TYPE: AttributeValue sub-class 
    2124    """ 
    2225    TYPE = None 
    2326     
    24     def evaluate(self, item, bag): 
     27    def evaluate(self, set1, set2): 
    2528        """Check input is contained in the bag 
    2629         
    27         @param item: check to see if this string is contained in the bag 
    28         @type item: type 
    29         @param bag: bag of <type> values 
    30         @type bag: TypedList(<type>) 
     30        @param set1: check to see if at least one item in this set is contained  
     31        in the second set 
     32        @type set1: TypedList(self.__class__.TYPE) 
     33        @param set2: bag of self.__class__.TYPE values 
     34        @type set2: TypedList(self.__class__.TYPE) 
    3135        @return: True if str is in bag, False otherwise 
    3236        @rtype: bool 
    3337        """ 
    34         if not isinstance(item, self.__class__.TYPE): 
    35             raise XacmlContextTypeError('Expecting %r derived type for "item"; ' 
    36                                         'got %r' % (self.__class__.TYPE,  
    37                                                     type(item))) 
     38        if not isinstance(set1, Bag): 
     39            raise XacmlContextTypeError('Expecting %r derived type for "set1"; ' 
     40                                        'got %r' % (Bag, type(set1))) 
    3841             
    39         if not isinstance(bag, Bag): 
    40             raise XacmlContextTypeError('Expecting %r derived type for "bag"; ' 
    41                                         'got %r' % (Bag, type(bag))) 
     42        if set1.elementType != self.__class__.TYPE: 
     43            raise XacmlContextTypeError('Expecting %r type elements for ' 
     44                                        '"set1"; got %r' % 
     45                                        (self.__class__.TYPE, set1.elementType)) 
    4246             
    43         if bag.elementType != self.__class__.TYPE: 
    44             raise XacmlContextTypeError('Expecting %r type elements for "bag"; ' 
    45                                         'got %r' % 
    46                                         (self.__class__.TYPE, bag.elementType)) 
    47         return item in bag 
     47        if not isinstance(set2, Bag): 
     48            raise XacmlContextTypeError('Expecting %r derived type for "set2"; ' 
     49                                        'got %r' % (Bag, type(set2))) 
     50             
     51        if set2.elementType != self.__class__.TYPE: 
     52            raise XacmlContextTypeError('Expecting %r type elements for ' 
     53                                        '"set2"; got %r' % 
     54                                        (self.__class__.TYPE, set2.elementType)) 
     55         
     56        set2Values = [attr.value for attr in set2] 
     57        for i in set1: 
     58            if i.value in set2Values: 
     59                return True 
     60             
     61        return False 
    4862     
    4963 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/bag.py

    r6804 r6805  
    3636        bag = Bag(self.__class__.TYPE) 
    3737        for i in args: 
    38             if not isinstance(i, basestring): 
     38            if not isinstance(i, self.__class__.TYPE): 
    3939                raise TypeError('Expecting %r derived type for bag element; ' 
    4040                                'got %r' % (self.__class__.TYPE, type(i))) 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/functions/v1/regexp_match.py

    r6804 r6805  
    1010__revision__ = '$Id: $' 
    1111import re 
    12 #import sys 
    1312 
     13from ndg.xacml.core.context.exceptions import XacmlContextTypeError 
     14from ndg.xacml.core.attributevalue import AttributeValueClassFactory 
    1415from ndg.xacml.core.functions import (AbstractFunction,  
    1516                                      FunctionClassFactoryInterface) 
    16 from ndg.xacml.core.context.exceptions import XacmlContextTypeError 
    1717 
    1818 
    … …  
    3535        @rtype: bool 
    3636        """ 
    37         if not isinstance(pat, basestring): 
     37        if not isinstance(pat, self.__class__.TYPE): 
    3838            raise TypeError('Expecting %r derived type for "pat"; got %r' % 
    39                             (basestring, type(pat))) 
     39                            (self.__class__.TYPE, type(pat))) 
    4040             
    4141        if not isinstance(input, self.__class__.TYPE): 
    … …  
    4343                            (self.__class__.TYPE, type(input))) 
    4444             
    45         return bool(re.match(pat, input)) 
     45        return bool(re.match(pat.value, input.value)) 
    4646     
     47 
     48attributeValueClassFactory = AttributeValueClassFactory() 
    4749 
    4850class StringRegexMatch(RegexpMatchBase): 
    4951    FUNCTION_NS = 'urn:oasis:names:tc:xacml:1.0:function:string-regexp-match' 
    50     TYPE = basestring 
     52    TYPE = attributeValueClassFactory('http://www.w3.org/2001/XMLSchema#string') 
    5153     
    5254     

  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/ndg1.xml

    r6796 r6805  
    7575            <Resources> 
    7676                <Resource> 
    77                     <ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:regexp-string-match"> 
     77                    <ResourceMatch MatchId="urn:oasis:names:tc:xacml:2.0:function:anyURI-regexp-match"> 
    7878                        <ResourceAttributeDesignator 
    7979                            AttributeId="urn:siteA:security:authz:1.0:attr:resourceURI" 
    80                             DataType="http://www.w3.org/2001/XMLSchema#string"/> 
    81                         <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">^http://localhost/test_accessDeniedToSecuredURI$</AttributeValue> 
     80                            DataType="http://www.w3.org/2001/XMLSchema#anyURI"/> 
     81                        <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#anyURI">^http://localhost/test_accessDeniedToSecuredURI$</AttributeValue> 
    8282                    </ResourceMatch> 
    8383                </Resource> 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_context.py

    r6802 r6805  
    7171                                    'http://www.w3.org/2001/XMLSchema#anyURI' 
    7272 
    73         StringAttributeValue = attributeValueFactory( 
     73        AnyUriAttributeValue = attributeValueFactory( 
    7474                                    'http://www.w3.org/2001/XMLSchema#anyURI') 
    75         openidSubjectAttribute.attributeValues.append(StringAttributeValue()) 
     75        openidSubjectAttribute.attributeValues.append(AnyUriAttributeValue()) 
    7676     
    7777        openidSubjectAttribute.attributeValues[-1].dataType = \ 
    7878                                    'http://www.w3.org/2001/XMLSchema#anyURI' 
     79                                     
     80                                     
    7981        openidSubjectAttribute.attributeValues[-1].value = \ 
    8082                                    'https://my.name.somewhere.ac.uk' 
    … …  
    8284        subject.attributes.append(openidSubjectAttribute) 
    8385 
     86        StringAttributeValue = attributeValueFactory( 
     87                                    'http://www.w3.org/2001/XMLSchema#string') 
     88 
    8489        roleAttribute.attributeId = "urn:ndg:security:authz:1.0:attr" 
    8590        roleAttribute.dataType = 'http://www.w3.org/2001/XMLSchema#string' 
     91         
    8692        roleAttribute.attributeValues.append(StringAttributeValue()) 
    8793        roleAttribute.attributeValues[-1].dataType = \ 
    … …  
    101107                             
    102108        resourceAttribute.dataType = "http://www.w3.org/2001/XMLSchema#anyURI" 
    103         resourceAttribute.attributeValues.append(StringAttributeValue()) 
     109        resourceAttribute.attributeValues.append(AnyUriAttributeValue()) 
    104110        resourceAttribute.attributeValues[-1].value = \ 
    105111                                        'http://www.localhost/test_securedURI' 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/utils/__init__.py

    r6777 r6805  
    4747        self.__elementType = elementType 
    4848        super(TypedList, self).__init__(*arg, **kw) 
    49      
     49 
     50    def __repr__(self): 
     51        return "%r type: %s" % (self.__elementType,  
     52                                super(TypedList, self).__repr__()) 
     53         
    5054    def _getElementType(self): 
    5155        return self.__elementType 
Note: See TracChangeset for help on using the changeset viewer.