Changeset 6750 for TI12-security/trunk


Ignore:
Timestamp:
18/03/10 13:57:03 (10 years ago)
Author:
pjkersha
Message:

Parsing functionality near complete for rule1.xml

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

Legend:

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

    r6747 r6750  
    88 
    99class AttributeDesignator(Expression): 
     10    '''XACML Attribute Designator type 
    1011    ''' 
    11     classdocs 
    12     ''' 
     12    ATTRIBUTE_ID_ATTRIB_NAME = 'AttributeId' 
     13    ISSUER_ATTRIB_NAME = 'Issuer' 
     14    MUST_BE_PRESENT_ATTRIB_NAME = 'MustBePresent' 
     15     
     16    __slots__ = ('__attributeId', '__issuer', '__mustBePresent') 
     17     
     18    def __init__(self): 
     19        super(AttributeDesignator, self).__init__() 
     20        self.__attributeId = None 
     21        self.__issuer = None 
     22        self.__mustBePresent = False 
    1323 
     24    @property 
     25    def attributeId(self): 
     26        """Get Attribute Id""" 
     27        return self.__attributeId 
    1428 
    15     def __init__(self): 
    16         ''' 
    17         Constructor 
    18         ''' 
     29    @attributeId.setter 
     30    def attributeId(self, value): 
     31        """Set Attribute Id""" 
     32        if not isinstance(value, basestring): 
     33            raise TypeError('Expecting %r type for "attributeId" ' 
     34                            'attribute; got %r' % (basestring, type(value))) 
     35             
     36        self.__attributeId = value   
     37         
     38    @property 
     39    def issuer(self): 
     40        """Get Issuer""" 
     41        return self.__issuer 
     42 
     43    @issuer.setter 
     44    def issuer(self, value): 
     45        """Set Issuer""" 
     46        if not isinstance(value, basestring): 
     47            raise TypeError('Expecting %r type for "issuer" ' 
     48                            'attribute; got %r' % (basestring, type(value))) 
     49             
     50        self.__issuer = value    
     51 
     52    @property 
     53    def mustBePresent(self): 
     54        """Get Must Be Present flag""" 
     55        return self.__mustBePresent 
     56 
     57    @mustBePresent.setter 
     58    def mustBePresent(self, value): 
     59        """Set Must Be Present flag""" 
     60        if not isinstance(value, bool): 
     61            raise TypeError('Expecting %r type for "mustBePresent" ' 
     62                            'attribute; got %r' % (bool, type(value))) 
     63             
     64        self.__mustBePresent = value         
     65         
     66         
     67class SubjectAttributeDesignator(AttributeDesignator): 
     68    """XACML Subject Attribute Designator type""" 
     69    ELEMENT_LOCAL_NAME = 'SubjectAttributeDesignator' 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/expression.py

    r6747 r6750  
    1111    ELEMENT_LOCAL_NAME = None 
    1212    DATA_TYPE_ATTRIB_NAME = 'DataType' 
    13     ATTRIB_NAMES = (DATA_TYPE_ATTRIB_NAME,) 
    1413     
    1514    __slots__ = ('__dataType', ) 
     
    3029    dataType = property(_get_dataType, _set_dataType, None,  
    3130                        "expression value data type")   
    32  
    33          
     31           
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/match.py

    r6747 r6750  
    1313from ndg.xacml.core.attributedesignator import AttributeDesignator 
    1414from ndg.xacml.core.attributeselector import AttributeSelector 
    15 from ndg.xacml.core.attribute import AttributeValue 
     15from ndg.xacml.core.attributevalue import AttributeValue 
    1616 
    1717 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/attributedesignatorreader.py

    r6747 r6750  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
    12 from ndg.xacml.core.attributedesignator import AttributeDesignator 
     12from ndg.xacml.utils import str2Bool 
     13from ndg.xacml.core.attributedesignator import SubjectAttributeDesignator 
    1314from ndg.xacml.parsers import XMLParseError 
    1415from ndg.xacml.parsers.etree import QName 
    15 from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
     16from ndg.xacml.parsers.etree.expressionreader import ExpressionReader 
    1617 
    1718 
    18 class AttributeDesignatorReader(ETreeAbstractReader): 
    19     '''ElementTree based XACML Attribute Designator type parser 
     19class AttributeDesignatorReaderBase(ExpressionReader): 
     20    '''ElementTree based XACML Attribute Designator base class type parser 
    2021    ''' 
    21      
    22     def __call__(self, obj): 
     22    def _parseExtension(self, elem, attributeDesignator): 
    2323        """Parse AttributeDesignator object""" 
    24         elem = super(AttributeDesignatorReader, self)._parse(obj) 
     24        cls = self.__class__.TYPE 
    2525         
    26         cls = AttributeDesignator 
    27         attributeDesignator = cls() 
    28          
    29         localName = QName.getLocalPart(elem.tag) 
    30         if localName != cls.ELEMENT_LOCAL_NAME: 
    31             raise XMLParseError("No \"%s\" element found" %  
    32                                 cls.ELEMENT_LOCAL_NAME) 
    33          
    34         dataType = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
    35         if dataType is None: 
    36             raise XMLParseError('No "%s" attribute found in "%s" element' % 
    37                                 (cls.DATA_TYPE_ATTRIB_NAME,  
    38                                  cls.ELEMENT_LOCAL_NAME)) 
     26        # Unpack additional *required* attributes from top-level element 
     27        attributeValues = [] 
     28        for attributeName in (cls.ATTRIBUTE_ID_ATTRIB_NAME,): 
     29            attributeValue = elem.attrib.get(attributeName) 
     30            if attributeValue is None: 
     31                raise XMLParseError('No "%s" attribute found in "%s" element' % 
     32                                    (attributeName, cls.ELEMENT_LOCAL_NAME)) 
    3933                 
    40         attributeDesignator.dataType = dataType 
    41      
     34            attributeValues.append(attributeValue) 
     35              
     36        attributeDesignator.attributeId, = attributeValues 
     37               
     38        # Optional attributes 
     39        issuer = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
     40        if issuer is not None: 
     41            attributeDesignator.issuer = issuer 
     42              
     43        mustBePresent = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
     44        if mustBePresent is not None: 
     45            attributeDesignator.mustBePresent = str2Bool(mustBePresent) 
     46    
    4247        return attributeDesignator 
    4348 
    44          
     49 
     50class SubjectAttributeDesignatorReader(AttributeDesignatorReaderBase):  
     51    '''ElementTree based XACML Subject Attribute Designator type parser 
     52    ''' 
     53    TYPE = SubjectAttributeDesignator 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/attributevaluereader.py

    r6748 r6750  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
    12 from abc import abstractmethod 
    13  
    14 from ndg.xacml.core.attribute import Expression, AttributeValue 
     12from ndg.xacml.core.attributevalue import Expression, AttributeValue 
    1513from ndg.xacml.parsers import XMLParseError 
    16 from ndg.xacml.parsers.etree import QName 
    17 from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    18  
    19  
    20 class ExpressionReader(ETreeAbstractReader): 
    21     '''ElementTree based XACML Expression type parser 
    22     ''' 
    23     TYPE = Expression 
    24      
    25     def __call__(self, obj): 
    26         """Parse AttributeValue object""" 
    27         elem = super(ExpressionReader, self)._parse(obj) 
    28          
    29         cls = self.__class__.TYPE 
    30         expression = cls() 
    31          
    32         localName = QName.getLocalPart(elem.tag) 
    33         if localName != cls.ELEMENT_LOCAL_NAME: 
    34             raise XMLParseError("No \"%s\" element found" %  
    35                                 cls.ELEMENT_LOCAL_NAME) 
    36          
    37         dataType = elem.attrib.get(cls.DATA_TYPE_ATTRIB_NAME) 
    38         if dataType is None: 
    39             raise XMLParseError('No "%s" attribute found in "%s" element' % 
    40                                 (cls.DATA_TYPE_ATTRIB_NAME,  
    41                                  cls.ELEMENT_LOCAL_NAME)) 
    42                  
    43         expression.dataType = dataType 
    44          
    45         self._parseExtension(elem, expression) 
    46          
    47         return expression 
    48          
    49     @abstractmethod 
    50     def _parseExtension(self, elem, expression): 
    51         """Derived classes should implement this method to read any remaining 
    52         attributes and elements specific to their type""" 
    53         raise NotImplementedError() 
    54            
    55 # Set up new class as an abstract base itself              
    56 ETreeAbstractReader.register(ExpressionReader) 
     14from ndg.xacml.parsers.etree.expressionreader import ExpressionReader 
    5715 
    5816 
    5917class AttributeValueReader(ExpressionReader): 
    60     '''ElementTree based XACML AttributeValue type parser 
     18    '''ElementTree based XACML Expression type parser 
    6119    ''' 
    6220    TYPE = AttributeValue 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/expressionreader.py

    r6748 r6750  
    1 ''' 
    2 Created on 18 Mar 2010 
     1"""NDG XACML ElementTree based reader for Expression type 
    32 
    4 @author: pjkersha 
    5 ''' 
     3NERC DataGrid Project 
     4""" 
     5__author__ = "P J Kershaw" 
     6__date__ = "18/03/10" 
     7__copyright__ = "(C) 2010 Science and Technology Facilities Council" 
     8__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     9__license__ = "BSD - see LICENSE file in top-level directory" 
     10__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     11__revision__ = "$Id: $" 
     12from abc import abstractmethod 
     13 
     14from ndg.xacml.core.expression import Expression 
     15from ndg.xacml.parsers import XMLParseError 
     16from ndg.xacml.parsers.etree import QName 
     17from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
     18 
     19 
     20class ExpressionReader(ETreeAbstractReader): 
     21    '''ElementTree based XACML Expression type parser 
     22    ''' 
     23    TYPE = Expression 
     24     
     25    def __call__(self, obj): 
     26        """Parse AttributeValue object""" 
     27        elem = super(ExpressionReader, self)._parse(obj) 
     28         
     29        cls = self.__class__.TYPE 
     30        expression = cls() 
     31         
     32        localName = QName.getLocalPart(elem.tag) 
     33        if localName != cls.ELEMENT_LOCAL_NAME: 
     34            raise XMLParseError("No \"%s\" element found" %  
     35                                cls.ELEMENT_LOCAL_NAME) 
     36             
     37        # Unpack *required* attributes from top-level element 
     38        attributeValues = [] 
     39        for attributeName in (cls.DATA_TYPE_ATTRIB_NAME,): 
     40            attributeValue = elem.attrib.get(attributeName) 
     41            if attributeValue is None: 
     42                raise XMLParseError('No "%s" attribute found in "%s" element' % 
     43                                    (attributeName, cls.ELEMENT_LOCAL_NAME)) 
     44                 
     45            attributeValues.append(attributeValue) 
     46              
     47        expression.dataType, = attributeValues 
     48                    
     49        self._parseExtension(elem, expression) 
     50         
     51        return expression 
     52         
     53    @abstractmethod 
     54    def _parseExtension(self, elem, expression): 
     55        """Derived classes should implement this method to read any remaining 
     56        attributes and elements specific to their type""" 
     57        raise NotImplementedError() 
     58           
     59# Set up new class as an abstract base itself              
     60ETreeAbstractReader.register(ExpressionReader) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/matchreader.py

    r6747 r6750  
    1212__revision__ = "$Id: $" 
    1313from ndg.xacml.core.match import SubjectMatch 
    14 from ndg.xacml.core.attributedesignator import AttributeDesignator 
    1514from ndg.xacml.core.attributeselector import AttributeSelector 
    1615from ndg.xacml.parsers import XMLParseError 
    1716from ndg.xacml.parsers.etree import QName 
    1817from ndg.xacml.parsers.etree.reader import ETreeAbstractReader 
    19 from ndg.xacml.parsers.etree.attributereader import AttributeValueReader 
     18from ndg.xacml.parsers.etree.attributevaluereader import AttributeValueReader 
     19from ndg.xacml.parsers.etree.attributedesignatorreader import ( 
     20    SubjectAttributeDesignatorReader) 
     21from ndg.xacml.parsers.etree.attributeselectorreader import \ 
     22    AttributeSelectorReader 
    2023 
    2124 
     
    2427    action and environment match types 
    2528    ''' 
    26     MATCH_TYPE = None 
     29    ATTRIBUTE_DESIGNATOR_READER_TYPE = None 
    2730     
    2831    def __init__(self): 
    29         if None in (self.__class__.MATCH_TYPE,): 
    30             raise NotImplementedError('Extend this class setting the "' 
    31                                       '"MATCH_TYPE" class variable') 
     32        if self.__class__.ATTRIBUTE_DESIGNATOR_READER_TYPE is None: 
     33            raise NotImplementedError('Extend this class setting the ' 
     34                                      '"ATTRIBUTE_DESIGNATOR_READER_TYPE" ' 
     35                                      'class variable') 
    3236             
    3337        super(MatchReaderBase, self).__init__() 
     
    3741        elem = super(MatchReaderBase, self)._parse(obj) 
    3842         
    39         match = self.__class__.MATCH_TYPE() 
    40         cls = self.__class__.MATCH_TYPE 
     43        cls = self.__class__.TYPE 
     44        match = cls() 
    4145         
    4246        localName = QName.getLocalPart(elem.tag) 
     
    5761                    
    5862        match.matchId, = attributeValues 
    59              
     63          
     64        # Assign specific attribute designator type from derived class 
     65        attributeDesignatorReaderType = \ 
     66                                self.__class__.ATTRIBUTE_DESIGNATOR_READER_TYPE  
     67        attributeDesignatorType = attributeDesignatorReaderType.TYPE 
     68 
    6069        # Parse match elements 
    6170        for childElem in elem: 
     
    6574                match.attributeValue = AttributeValueReader.parse(childElem) 
    6675                 
    67             elif localName == cls.ATTRIBUTE_DESIGNATOR_ELEMENT_LOCAL_NAME: 
     76            elif localName == attributeDesignatorType.ELEMENT_LOCAL_NAME: 
    6877                if match.attributeSelector is not None: 
    6978                    raise XMLParseError("XACML %r child element may only be " 
    7079                                        "either a %r or %r element NOT both" % 
    7180                            (cls.ELEMENT_LOCAL_NAME, 
    72                              cls.ATTRIBUTE_DESIGNATOR_ELEMENT_LOCAL_NAME, 
     81                             attributeDesignatorType.ELEMENT_LOCAL_NAME, 
    7382                             AttributeSelector.ELEMENT_LOCAL_NAME)) 
    7483                     
    75                 match.attributeDesignator = AttributeDesignatorReader.parse( 
     84                match.attributeDesignator = attributeDesignatorReaderType.parse( 
    7685                                                                    childElem) 
    7786                         
     
    8190                                        "either a %r or %r element NOT both" % 
    8291                            (cls.ELEMENT_LOCAL_NAME, 
    83                              cls.ATTRIBUTE_DESIGNATOR_ELEMENT_LOCAL_NAME, 
     92                             attributeDesignatorType.ELEMENT_LOCAL_NAME, 
    8493                             AttributeSelector.ELEMENT_LOCAL_NAME)) 
    8594 
     
    96105 
    97106class SubjectMatchReader(MatchReaderBase): 
    98     MATCH_TYPE = SubjectMatch 
     107    """ElementTree based parser for XACML SubjectMatch""" 
     108    TYPE = SubjectMatch 
     109    ATTRIBUTE_DESIGNATOR_READER_TYPE = SubjectAttributeDesignatorReader 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/policyreader.py

    r6746 r6750  
    2323class PolicyReader(ETreeAbstractReader): 
    2424    """Parse a Policy Document using ElementTree 
    25     """ 
     25    @cvar TYPE: XACML type to instantiate from parsed object 
     26    @type string: type""" 
     27    TYPE = Policy 
     28     
    2629    def __call__(self, obj): 
    2730        """Parse policy object""" 
    2831        elem = super(PolicyReader, self)._parse(obj) 
    2932         
    30         policy = Policy() 
    31         cls = Policy 
     33        # XACML type to instantiate 
     34        cls = PolicyReader.TYPE 
     35        policy = cls() 
    3236         
    3337        localName = QName.getLocalPart(elem.tag) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/reader.py

    r6746 r6750  
    2424 
    2525class ETreeAbstractReader(AbstractReader): 
    26     """Base class for ElementTree implementation of XACML reader""" 
    27       
     26    """Base class for ElementTree implementation of XACML reader 
     27     
     28    @cvar TYPE: XACML type to instantiate from parsed object 
     29    @type string: type""" 
     30    TYPE = None 
     31     
    2832    def __init__(self): 
     33        if self.__class__.TYPE is None: 
     34            raise NotImplementedError('No "TYPE" class variable set to specify ' 
     35                                      'the XACML type to instantiate') 
     36             
    2937        self.__namespace_map_backup = ElementTree._namespace_map.copy() 
    3038        ElementTree._namespace_map[''] = PolicyComponent.XACML_2_0_XMLNS 
     
    5361AbstractReader.register(ETreeAbstractReader) 
    5462 
    55  
    56 class VariableDefinitionReader(object): 
    57     def __call__(self, obj): 
    58         pass 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/rulereader.py

    r6747 r6750  
    2222class RuleReader(ETreeAbstractReader): 
    2323    '''ElementTree based XACML Rule parser 
     24     
     25    @cvar TYPE: XACML type to instantiate from parsed object 
     26    @type string: type 
    2427    ''' 
     28    TYPE = Rule 
     29     
    2530    def __call__(self, obj): 
    2631        """Parse rule object""" 
    2732        elem = super(RuleReader, self)._parse(obj) 
    2833         
    29         rule = Rule() 
    30         cls = Rule 
     34        cls = RuleReader.TYPE 
     35        rule = cls() 
    3136         
    3237        localName = QName.getLocalPart(elem.tag) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/subjectreader.py

    r6747 r6750  
    1919class SubjectReader(ETreeAbstractReader): 
    2020    '''ElementTree based XACML Rule parser 
     21    @cvar TYPE: XACML type to instantiate from parsed object 
     22    @type string: type 
    2123    ''' 
     24    TYPE = Subject 
     25 
    2226    def __call__(self, obj): 
    2327        """Parse subject object""" 
    2428        elem = super(SubjectReader, self)._parse(obj) 
    2529         
    26         subject = Subject() 
    27         cls = Subject 
     30        cls = SubjectReader.TYPE 
     31        subject = cls() 
    2832         
    2933        localName = QName.getLocalPart(elem.tag) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/targetreader.py

    r6747 r6750  
    2121 
    2222class TargetReader(ETreeAbstractReader): 
    23     """ElementTree based parser for XACML Target elements""" 
     23    """ElementTree based parser for XACML Target elements 
     24     
     25    @cvar TYPE: XACML type to instantiate from parsed object 
     26    @type string: type""" 
     27    TYPE = Target 
    2428     
    2529    def __call__(self, obj): 
    2630        elem = super(TargetReader, self)._parse(obj) 
    2731         
    28         target = Target() 
    29         cls = Target 
     32        cls = TargetReader.TYPE 
     33        target = cls() 
    3034         
    3135        localName = QName.getLocalPart(elem.tag) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_xacml.py

    r6744 r6750  
    2121    XACML_FILEPATH = path.join(THIS_DIR, XACML_FILENAME) 
    2222     
    23     def test01ETreeParsePolicy(self): 
     23    def test01ETreeParseRule1Policy(self): 
    2424        policy = PolicyReader.parse(XACMLTestCase.XACML_FILEPATH) 
    2525        self.assert_(policy) 
     26         
     27        self.assert_( 
     28            policy.policyId == "urn:oasis:names:tc:example:SimplePolicy1") 
     29         
     30        self.assert_(policy.ruleCombiningAlgId == \ 
     31        "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides") 
     32         
     33        self.assert_( 
     34            "Med Example Corp access control policy" in policy.description) 
     35         
     36        self.assert_(len(policy.target.subjects) == 0) 
     37         
     38        self.assert_(policy.rules[0].id == \ 
     39                     "urn:oasis:names:tc:xacml:2.0:example:SimpleRule1") 
     40         
     41        self.assert_(policy.rules[0].effect == 'Permit') 
     42         
     43        self.assert_( 
     44            'Any subject with an e-mail name in the med.example.com domain' in \ 
     45            policy.rules[0].description) 
     46         
     47        self.assert_(len(policy.rules[0].subjects) == 1) 
     48        self.assert_(len(policy.rules[0].actions) == 0) 
     49        self.assert_(len(policy.rules[0].resources) == 0) 
     50        self.assert_(len(policy.rules[0].environments) == 0) 
     51         
     52        self.assert_(len(policy.rules[0].subjects[0].subjectMatches) == 1) 
     53         
     54        self.assert_(policy.rules[0].subjects[0].subjectMatches[0].id == \ 
     55                     "urn:oasis:names:tc:xacml:1.0:function:rfc822Name-match") 
     56         
     57        self.assert_(policy.rules[0].subjects[0].subjectMatches[0 
     58            ].attributeValue.dataType == \ 
     59            "urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name") 
     60         
     61        self.assert_(policy.rules[0].subjects[0].subjectMatches[0 
     62            ].attributeDesignator.dataType == \ 
     63            "urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name") 
     64         
     65        # Attribute ID 
     66        self.assert_(policy.rules[0].subjects[0].subjectMatches[0 
     67            ].attributeDesignator.attributeId == \ 
     68            "urn:oasis:names:tc:xacml:1.0:subject:subject-id") 
     69         
    2670 
    2771 
Note: See TracChangeset for help on using the changeset viewer.