Changeset 6805


Ignore:
Timestamp:
14/04/10 15:45:01 (9 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.