Changeset 6777


Ignore:
Timestamp:
26/03/10 14:09:05 (11 years ago)
Author:
pjkersha
Message:

Added matching functions component.

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml
Files:
8 added
10 edited

Legend:

Unmodified
Added
Removed

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

    r6776 r6777  
    2020from ndg.xacml.core.context.response import Response 
    2121from ndg.xacml.core.context.result import Result, Decision 
     22from ndg.xacml.core.functions import FunctionMap 
    2223from ndg.xacml.parsers import AbstractReader 
    2324                             
    … …  
    3940        if policy is not None: 
    4041            self.policy = policy 
     42             
     43        self.matchFunc = FunctionMap.withLoadedMap() 
     44 
    4145         
    4246    @classmethod 
    43     def fromPolicy(cls, source, reader): 
     47    def fromPolicySource(cls, source, readerFactory): 
    4448        """Create a new PDP instance with a given policy 
    4549        @param source: source for policy 
    4650        @type source: type (dependent on the reader set, it could be for example 
    4751        a file path string, file object, XML element instance) 
    48         @param reader: the reader instance to use to read this policy 
    49         @type reader: ndg.xacml.parsers.AbstractReader derived type 
    50         """ 
    51         if not isinstance(reader, AbstractReader): 
    52             raise TypeError('Expecting %r derived type for "reader" input; got ' 
    53                             '%r instead' % (AbstractReader, type(reader))) 
    54              
     52        @param readerFactory: reader factory returns the reader to use to read  
     53        this policy 
     54        @type readerFactory: ndg.xacml.parsers.AbstractReader derived type 
     55        """            
    5556        pdp = cls() 
    56         pdp.policy = reader.parse(source) 
     57        pdp.policy = Policy.fromSource(source, readerFactory) 
    5758        return pdp 
    5859     
    … …  
    7980        @rtype: ndg.xacml.core.context.response.Response 
    8081        """ 
    81         response = Response 
     82        response = Response() 
    8283        result = Result() 
    8384        response.results.append(result) 
    … …  
    9697             
    9798            if not self.matchTarget(self.policy.target, request): 
    98                 log.debug('No match for policy target setting Decision=%r', 
     99                log.debug('No match for policy target setting Decision=%s', 
    99100                          Decision.NOT_APPLICABLE_STR) 
    100101                 
    … …  
    111112        except: 
    112113            log.error('Exception raised evaluating request context, returning ' 
    113                       'Decision=%r:%s',  
     114                      'Decision=%s:%s',  
    114115                      Decision.INDETERMINATE_STR,  
    115116                      traceback.format_exc()) 
    … …  
    147148        return False 
    148149     
    149     @classmethod 
    150     def matchTargetChild(cls, targetChild, requestChild): 
     150    def matchTargetChild(self, targetChild, requestChild): 
    151151        """Match a child (Subject, Resource, Action or Environment) from the  
    152152        request context with a given target's child 
    … …  
    169169         
    170170        for childMatch in targetChild.matches: 
    171             attributeValue = childMatch.attributeValue 
     171            # Get the match function from the Match ID 
     172            matchFunc = self.matchFunc.get(childMatch.matchId) 
     173            if matchFunc is NotImplemented: 
     174                raise NotImplementedError('No match function implemented for ' 
     175                                          'MatchId="%s"' % childMatch.matchId) 
     176                 
     177            if matchFunc is None: 
     178                raise Exception('Match function namespace %r is not recognised'  
     179                                % childMatch.matchId) 
     180                 
     181            matchAttributeValue = childMatch.attributeValue.value 
    172182             
    173183            # Create a match function based on the presence or absence of an 
    … …  
    178188                 
    179189                _attributeMatch = lambda requestChildAttribute: ( 
    180                     requestChildAttribute.attributeValue == attributeValue and 
     190                    matchFunc(matchAttributeValue,  
     191                              requestChildAttribute.attributeValue.value) and 
    181192                    requestChildAttribute.attributeId == attributeId and 
    182193                    requestChildAttribute.dataType == dataType  
    … …  
    192203            else: 
    193204                _attributeMatch = lambda requestChildAttribute: ( 
    194                     requestChildAttribute.attributeValue == attributeValue 
     205                    matchFunc(matchAttributeValue,  
     206                              requestChildAttribute.attributeValue.value) 
    195207                ) 
    196208                 

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

    r6776 r6777  
    1515from ndg.xacml.utils import TypedList 
    1616from ndg.xacml.core.context import XacmlContextBase 
    17 from ndg.xacml.core.subject import Subject 
    18 from ndg.xacml.core.resource import Resource 
    19 from ndg.xacml.core.action import Action 
    20 from ndg.xacml.core.environment import Environment 
     17from ndg.xacml.core.context.subject import Subject 
     18from ndg.xacml.core.context.resource import Resource 
     19from ndg.xacml.core.context.action import Action 
     20from ndg.xacml.core.context.environment import Environment 
    2121 
    2222 
    … …  
    2424    """XACML Request class""" 
    2525    __slots__ = ('__subjects', '__resources', '__action', '__environment') 
     26    ELEMENT_LOCAL_NAME = 'Request' 
    2627     
    2728    def __init__(self): 
     29        super(Request, self).__init__() 
     30         
    2831        self.__subjects = TypedList(Subject) 
    2932        self.__resources = TypedList(Resource) 
    … …  
    5255            raise TypeError('Expecting %r type for request "action" ' 
    5356                            'attribute; got %r' % (Action, type(value))) 
     57             
     58        self.__action = value 
    5459                                     
    5560    @property 
    … …  
    6368        if not isinstance(value, Environment): 
    6469            raise TypeError('Expecting %r type for request "environment" ' 
    65                             'attribute; got %r' % (Environment, type(value)))     
     70                            'attribute; got %r' % (Environment, type(value))) 
     71              
     72        self.__environment = value    

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

    r6776 r6777  
    2525     
    2626    def __init__(self): 
     27        super(Response, self).__init__() 
    2728        self.__results = TypedList(Result) 
    2829         

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

    r6771 r6777  
    292292     
    293293    def __init__(self): 
     294        super(Result, self).__init__() 
    294295        self.__decision = None 
    295296        self.__status = None 
    … …  
    322323            raise TypeError('Expecting %r type for result "decision" ' 
    323324                            'attribute; got %r' % (Decision, type(value))) 
    324                                      
     325        self.__decision = value 
     326         
    325327    @property 
    326328    def status(self): 
    … …  
    334336            raise TypeError('Expecting %r type for result "status" ' 
    335337                            'attribute; got %r' % (Status, type(value))) 
     338             
     339        self.__status = value 
    336340                                     
    337341    @property 
    338     def obligation(self): 
     342    def obligations(self): 
    339343        """Result obligation""" 
    340         return self.__obligation 
    341      
    342     @obligation.setter 
    343     def obligation(self, value): 
     344        return self.__obligations 
     345     
     346    @obligations.setter 
     347    def obligations(self, value): 
    344348        """Result obligation""" 
    345349        if not isinstance(value, Obligation): 
    346             raise TypeError('Expecting %r type for result "obligation" ' 
     350            raise TypeError('Expecting %r type for result "obligations" ' 
    347351                            'attribute; got %r' % (Obligation, type(value))) 
     352             
     353        self.__obligations = value 

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

    r6771 r6777  
    1111__revision__ = "$Id: $" 
    1212from ndg.xacml.utils import TypedList 
     13from ndg.xacml.parsers import AbstractReaderFactory, AbstractReader 
    1314from ndg.xacml.core import XacmlCoreBase 
    1415from ndg.xacml.core.policydefaults import PolicyDefaults 
    … …  
    7172        self.__obligations = TypedList(Obligation) 
    7273 
     74    @classmethod 
     75    def fromSource(cls, source, readerFactory): 
     76        """Create a new policy from the input source parsing it using a  
     77        reader from the required reader factory e.g. ETreeReaderFactory to use 
     78        ElementTree based parsing 
     79         
     80        @param source: source from which to read the policy - file path, 
     81        file object, XML node or other dependent on the reader factory selected 
     82        @type source: string, file, XML node type 
     83        @param readerFactory: factory class returns reader class used to parse  
     84        the policy 
     85        @type readerFactory: ndg.xacml.parsers.AbstractReaderFactory 
     86        @return: new policy instance 
     87        @rtype: ndg.xacml.core.policy.Policy 
     88        """ 
     89        if not issubclass(readerFactory, AbstractReaderFactory): 
     90            raise TypeError('Expecting %r derived class for reader factory ' 
     91                            'method; got %r' % (AbstractReaderFactory,  
     92                                                readerFactory)) 
     93             
     94        reader = readerFactory.getReader(cls) 
     95        if not issubclass(reader, AbstractReader): 
     96            raise TypeError('Expecting %r derived class for reader class; ' 
     97                            'got %r' % (AbstractReader, reader)) 
     98             
     99        return reader.parse(source) 
     100         
    73101    def _getPolicyId(self): 
    74102        return self.__policyId 

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

    r6770 r6777  
    1515 
    1616from ndg.xacml import XACMLError 
    17   
     17from ndg.xacml.core import XacmlCoreBase 
     18 
    1819     
    1920class XMLParseError(XACMLError): 
    … …  
    2122 
    2223 
    23 class AbstractReader: 
    24     """Abstract base class for ElementTree implementation of XACML reader""" 
     24class AbstractReader(object): 
     25    """Abstract base class for XACML reader""" 
    2526    __metaclass__ = ABCMeta 
    2627     
    … …  
    5152        reader = cls() 
    5253        return reader(obj) 
     54     
     55     
     56class AbstractReaderFactory(object): 
     57    """Abstract base class XACML reader factory""" 
     58    __metaclass__ = ABCMeta 
     59     
     60    @classmethod 
     61    @abstractmethod 
     62    def getReader(cls, xacmlType): 
     63        """Get the reader class for the given XACML input type 
     64        @param xacmlType: XACML type to retrieve a reader for 
     65        @type xacmlType: ndg.xaml.core.XacmlCoreBase derived 
     66        @return: reader class 
     67        @rtype: ndg.xacml.parsers.AbstractReader derived type 
     68        """ 
     69        if not issubclass(xacmlType, XacmlCoreBase): 
     70            raise TypeError('Expecting %r derived class for getReader method; ' 
     71                            'got %r' % (XacmlCoreBase, xacmlType)) 

  • TI12-security/trunk/NDG_XACML/ndg/xacml/parsers/etree/factory.py

    r6752 r6777  
    1313log = logging.getLogger(__name__) 
    1414 
     15from ndg.xacml.parsers import AbstractReaderFactory 
    1516from ndg.xacml.utils.factory import importModuleObject 
    1617 
    … …  
    2627 
    2728 
    28 class ReaderFactory(object): 
     29class ReaderFactory(AbstractReaderFactory): 
    2930    """Parser factory for ElementTree based parsers for XACML types""" 
    3031     

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

    r6766 r6777  
    1616            <Resource> 
    1717                <!-- Pattern match all request URIs beginning with / --> 
    18                 <ResourceMatch MatchId="urn:oasis:names:tc:xacml:1.0:function:regexp-string-match"> 
     18                <ResourceMatch MatchId="urn:oasis:names:tc:xacml:2.0:function:anyURI-regexp-match"> 
    1919                    <ResourceAttributeDesignator 
    2020                        AttributeId="urn:siteA:security:authz:1.0:attr:resourceURI" 
    21                         DataType="http://www.w3.org/2001/XMLSchema#string"/> 
    22                     <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string"> 
     21                        DataType="http://www.w3.org/2001/XMLSchema#anyURI"/> 
     22                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#anyURI"> 
    2323                        ^/.*$ 
    2424                    </AttributeValue> 
    … …  
    2929     
    3030    <!-- Deny everything by default --> 
     31    <!-- 
    3132    <Rule RuleId="urn:ndg:security1.0:authz:test:DenyAllRule" Effect="Deny"/> 
    32      
     33    --> 
    3334    <!--  
    3435        Following rules punch holes through the deny everything rule above 

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

    r6776 r6777  
    317317                             
    318318        resourceAttribute.dataType = "http://www.w3.org/2001/XMLSchema#anyURI" 
    319         resourceAttribute.attributeValue = \ 
     319        resourceAttribute.attributeValue = AttributeValue() 
     320        resourceAttribute.attributeValue.value = \ 
    320321                            'file://example/med/record/patient/BartSimpson' 
    321322 
    … …  
    324325        request.action = Action() 
    325326        actionAttribute = Attribute() 
    326         request.action.append(actionAttribute) 
    327          
    328         requestAttribute.attributeId = \ 
     327        request.action.attributes.append(actionAttribute) 
     328         
     329        actionAttribute.attributeId = \ 
    329330                                "urn:oasis:names:tc:xacml:1.0:action:action-id" 
    330         requestAttribute.dataType = "http://www.w3.org/2001/XMLSchema#string" 
    331         requestAttribute.attributeValue = 'read' 
     331        actionAttribute.dataType = "http://www.w3.org/2001/XMLSchema#string" 
     332        actionAttribute.attributeValue = AttributeValue() 
     333        actionAttribute.attributeValue.value = 'read' 
    332334         
    333335        return request 
    … …  
    344346         
    345347    def test03AbstractCtxHandler(self): 
    346         self.assertRaises(AbstractContextHandler(), NotImplementedError) 
     348        self.assertRaises(TypeError, AbstractContextHandler) 
    347349         
    348350    def test04CreateCtxHandler(self): 
    … …  
    350352         
    351353    def test04PDPInterface(self): 
    352         self.assertRaises(PDPInterface(), NotImplementedError) 
     354        self.assertRaises(TypeError, PDPInterface) 
    353355         
    354356    def test05CreatePDP(self): 
    … …  
    357359         
    358360    def _createPDPfromPolicy(self): 
    359         pdp = PDP.fromPolicy(XACML_NDGTEST1_FILEPATH) 
     361        pdp = PDP.fromPolicySource(XACML_NDGTEST1_FILEPATH, ReaderFactory) 
    360362        return pdp 
    361363         
    … …  
    366368    def test07EvaluatePDP(self): 
    367369        request = self._createRequestCtx() 
     370        pdp = self._createPDPfromPolicy() 
    368371        response = pdp.evaluate(request) 
    369372        self.assert_(response) 
    370373         
    371          
     374from ndg.xacml.core.functions import FunctionMap 
     375from ndg.xacml.core.functions.v2.anyuri_regexp_match import AnyURIRegexpMatch 
     376 
     377 
     378class FunctionTestCase(unittest.TestCase): 
     379    """Test XACML match functions implementation""" 
     380     
     381    def test01(self):    
     382        funcMap = FunctionMap() 
     383        funcMap.load() 
     384        anyUriMatchNs = \ 
     385            'urn:oasis:names:tc:xacml:2.0:function:anyURI-regexp-match' 
     386             
     387        self.assert_(isinstance(funcMap.get(anyUriMatchNs), AnyURIRegexpMatch)) 
    372388 
    373389         

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

    r6730 r6777  
    1 """Utilities package for NDG Security 
     1"""Utilities package for NDG XACML 
    22 
    33NERC DataGrid Project 
    … …  
    7777        return super(TypedList, self).append(item) 
    7878 
     79 
    7980class RestrictedKeyNamesDict(dict): 
    8081    """Utility class for holding a constrained list of key names 
    … …  
    104105         
    105106        dict.update(self, d, **kw) 
     107         
     108 
     109_isIterable = lambda obj: getattr(obj, '__iter__', False) 
     110 
     111   
     112class VettedDict(dict): 
     113    """Enforce custom checking on keys and items before addition to the  
     114    dictionary""" 
     115     
     116    def __init__(self, *args): 
     117        """Initialise setting the allowed type or types for keys and items 
     118         
     119        @param args: two arguments: the first is a callable which filters for  
     120        permissable keys in this dict, the second sets the type or list of 
     121        types permissable for items in this dict 
     122        @type args: tuple 
     123        """ 
     124        super(VettedDict, self).__init__() 
     125         
     126        if len(args) != 2: 
     127            raise TypeError('__init__() takes 2 arguments, KeyFilter and ' 
     128                            'valueFilter (%d given)' % len(args)) 
     129         
     130        # Validation of inputs 
     131        for arg, argName in zip(args, ('KeyFilter', 'valueFilter')): 
     132            if not callable(arg): 
     133                raise TypeError('Expecting callable for %r input; got %r' %  
     134                                (argName, type(arg))) 
     135 
     136        self.__KeyFilter, self.__valueFilter = args 
     137         
     138    def _verifyKeyValPair(self, key, val): 
     139        """Check given key value pair and return False if they should be  
     140        filtered out.  Filter functions may also raise an exception if they 
     141        wish to abort completely 
     142        """ 
     143        if not self.__KeyFilter(key): 
     144            return False 
     145         
     146        elif not self.__valueFilter(val): 
     147            return False 
     148         
     149        else: 
     150            return True 
     151                   
     152    def __setitem__(self, key, val): 
     153        """Override base class implementation to enforce type checking"""        
     154        if self._verifyKeyValPair(key, val): 
     155            dict.__setitem__(self, key, val) 
     156 
     157    def update(self, d, **kw):  
     158        """Override base class implementation to enforce type checking"""        
     159        for dictArg in (d, kw): 
     160            for key, val in dictArg.items(): 
     161                if not self._verifyKeyValPair(key, val): 
     162                    del dictArg[key] 
     163         
     164        dict.update(self, d, **kw)         
     165     
Note: See TracChangeset for help on using the changeset viewer.