Changeset 6771 for TI12-security/trunk


Ignore:
Timestamp:
25/03/10 08:27:00 (10 years ago)
Author:
pjkersha
Message:

Added request subject, resource, action and environment types

Location:
TI12-security/trunk/NDG_XACML/ndg/xacml
Files:
4 added
6 edited

Legend:

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

    r6770 r6771  
    1515class XacmlContextBase(object): 
    1616    """Base class for XACML Request and Response types""" 
     17    ELEMENT_LOCAL_NAME = None 
    1718    __slots__ = () 
     19     
     20    def __init__(self): 
     21        if self.__class__.ELEMENT_LOCAL_NAME is None: 
     22            raise NotImplementedError('Set "ELEMENT_LOCAL_NAME" in a derived ' 
     23                                      'type') 
    1824     
    1925     
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/handler.py

    r6770 r6771  
    3939        
    4040        
    41 class AbstractContextHandler: 
     41class AbstractContextHandler(object): 
    4242    """Context Handler Abstract Base class""" 
    4343    __metaclass__ = ABCMeta 
     44    __slots__ = ('__pdp',) 
    4445     
     46    def __init__(self): 
     47        self.__pdp = None 
     48         
    4549    @classmethod 
    4650    def __subclasshook__(cls, C): 
     
    5458             
    5559        return NotImplemented 
    56  
    57  
    58  
    59 # Set up new class as an abstract base itself              
    60 PEPInterface.register(AbstractContextHandler) 
     60     
     61    def _getPDP(self): 
     62        return self.__pdp 
     63     
     64    def _setPDP(self, value): 
     65        if not isinstance(value, PDPInterface): 
     66            raise TypeError('Expecting %r derived type for "pdp" attribute; ' 
     67                            'got %r' % (PDPInterface, type(pdp)) 
     68         
     69        self.__pdp = value 
     70         
     71    pdp = property(_getPDP, _setPDP, doc="Interface to PDP") 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/context/result.py

    r6770 r6771  
    288288     
    289289    ELEMENT_LOCAL_NAME  = 'Result' 
     290    OBLIGATIONS_ELEMENT_LOCAL_NAME = 'Obligations' 
    290291    REOSURCE_ID_ATTRIB_NAME = 'ResourceId' 
    291292     
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/pdp.py

    r6745 r6771  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = "$Id: $" 
     12from abc import ABCMeta, abstractmethod 
     13from ndg.xacml.core.context.request import Request 
    1214 
     15 
     16class PDPInterface: 
     17    __metaclass__ = ABCmeta 
     18     
     19    @classmethod 
     20    def __subclasshook__(cls, C): 
     21        """Derived class must implement __call__""" 
     22        if cls is PDPInterface: 
     23            if any("evaluate" in B.__dict__ for B in C.__mro__): 
     24                return True 
     25             
     26        return NotImplemented 
     27 
     28    @abstractmethod 
     29    def evaluate(self, request): 
     30        '''evaluate the input request and return an access control decision 
     31        in the returned response 
     32         
     33        @param request: XACML context request 
     34        @type request: ndg.xacml.core.context.request.Request 
     35        @return: XACML context response 
     36        @rtype: ndg.xacml.core.context.response.Response 
     37        ''' 
     38        if not isinstance(request, Request): 
     39            raise TypeError('Expecting %r type for input request; got %r ' 
     40                            'instead' % (Request, type(request)) 
     41                             
     42 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/core/policy.py

    r6770 r6771  
    4242    # Plan to support permit overrides in a future release 
    4343    RULE_COMBINING_ALG_IDS = ( 
    44 #    "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides", 
     44    "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:permit-overrides", 
    4545    "urn:oasis:names:tc:xacml:1.0:rule-combining-algorithm:deny-overrides", 
    4646    ) 
  • TI12-security/trunk/NDG_XACML/ndg/xacml/test/test_xacml.py

    r6770 r6771  
    2020from ndg.xacml.parsers.etree.factory import ReaderFactory 
    2121 
     22from ndg.xacml.core.attribute import Attribute 
    2223from ndg.xacml.core.context.request import Request 
    23 from ndg.xacml.core.subject import Subject 
    24 from ndg.xacml.core.resource import Resource 
    25 from ndg.xacml.core.action import Action 
     24from ndg.xacml.core.context.response import Response 
     25from ndg.xacml.core.context.result import Result, Decision 
     26from ndg.xacml.core.context.subject import Subject 
     27from ndg.xacml.core.context.resource import Resource 
     28from ndg.xacml.core.context.action import Action 
    2629 
    2730THIS_DIR = path.dirname(__file__) 
     
    4245    def test01ETreeParseRule1Policy(self): 
    4346        PolicyReader = ReaderFactory.getReader(Policy) 
    44         policy = PolicyReader.parse(XACMLTestCase.XACML_TEST1_FILEPATH) 
     47        policy = PolicyReader.parse(XACMLPolicyTestCase.XACML_TEST1_FILEPATH) 
    4548        self.assert_(policy) 
    4649         
     
    9194    def test02ETreeParseRule2Policy(self): 
    9295        PolicyReader = ReaderFactory.getReader(Policy) 
    93         policy = PolicyReader.parse(XACMLTestCase.XACML_TEST2_FILEPATH) 
     96        policy = PolicyReader.parse(XACMLPolicyTestCase.XACML_TEST2_FILEPATH) 
    9497        self.assert_(policy) 
    9598         
     
    244247         
    245248        try: 
    246             policy = PolicyReader.parse(XACMLTestCase.XACML_TEST3_FILEPATH) 
     249            policy = PolicyReader.parse(XACMLPolicyTestCase.XACML_TEST3_FILEPATH) 
    247250            self.assert_(policy) 
    248251        except NotImplementedError, e: 
     
    251254    def test04ETreeParseRule4Policy(self): 
    252255        PolicyReader = ReaderFactory.getReader(Policy) 
    253         policy = PolicyReader.parse(XACMLTestCase.XACML_TEST4_FILEPATH) 
     256        policy = PolicyReader.parse(XACMLPolicyTestCase.XACML_TEST4_FILEPATH) 
    254257        self.assert_(policy) 
    255258                     
     
    258261        # resources for NDG 
    259262        PolicyReader = ReaderFactory.getReader(Policy) 
    260         policy = PolicyReader.parse(XACMLTestCase.XACML_NDGTEST1_FILEPATH) 
     263        policy = PolicyReader.parse(XACMLPolicyTestCase.XACML_NDGTEST1_FILEPATH) 
    261264        self.assert_(policy) 
    262  
     265         
     266         
     267class MyPDP(PDPInterface): 
     268     
     269    def __init__(self): 
     270        self.policy = None 
     271         
     272    @classmethod 
     273    def fromPolicy(cls, source): 
     274        pdp = cls() 
     275        self.policy = ReaderFactory.getReader(Policy).parse(source) 
     276         
     277    def evaluate(self, request): 
     278        response = Response 
     279        result = Result() 
     280        response.results.append(result) 
     281        result.decision = Decision.INDETERMINATE 
     282         
     283        # Check policy target for match 
     284        if not self.matchTarget(self.policy.target, request): 
     285            result.decision = Decision.NOT_APPLICABLE 
     286            return response 
     287         
     288        # Check rules 
     289        for rule in self.policy.rules: 
     290            if not self.matchTarget(rule.target, request): 
     291                continue 
     292             
     293        return response 
     294     
     295    def matchTarget(self, target, request): 
     296        if target is None: 
     297            return False 
     298         
     299        for targetSubject in target.subjects: 
     300            for requestSubject in request.subjects: 
     301                if subject. 
     302                 
     303class TestContextHandler(AbstractContextHandler): 
     304    """Test implementation of Context Handler""" 
     305     
     306    def __init__(self): 
     307        super(TestContextHandler, self).__init__() 
     308        self.pip = None         
     309         
     310    def handlePEPRequest(self, myRequest): 
     311         
     312        # Convert myRequest to XACML context request 
     313        request = myRequest 
     314         
     315        if self.pdp is None: 
     316            raise TypeError('No "pdp" attribute set') 
     317         
     318        response = self.pdp.evaluate(request) 
     319         
     320        # Convert XACML context response to domain specific request 
     321        myResponse = response 
     322         
     323        return myResponse 
     324     
    263325 
    264326class XACMLContextTestCase(unittest.TestCase): 
    265327    """Test PDP, PAP, PIP and Context handler""" 
    266328     
    267     def test01(self): 
     329    def test01CreateRequest(self): 
    268330        request = Request() 
    269331         
    270332        subject = Subject() 
    271         subject. 
     333        subjectAttribute = Attribute() 
     334        subject.attributes.append(subjectAttribute) 
     335        subjectAttribute.attributeId = \ 
     336                            "urn:oasis:names:tc:xacml:1.0:subject:subject-id" 
     337        subjectAttribute.dataType = \ 
     338                            "urn:oasis:names:tc:xacml:1.0:data-type:rfc822Name" 
     339        subjectAttribute.attributeValue = 'bs@simpsons.com' 
     340         
    272341        request.subjects.append(subject) 
    273  
    274         request.resources.append(Resource()) 
     342         
     343        resource = Resource() 
     344        resourceAttribute = Attribute() 
     345        resource.attributes.append(resourceAttribute) 
     346         
     347        resourceAttribute.attributeId = \ 
     348                            "urn:oasis:names:tc:xacml:1.0:resource:resource-id" 
     349                             
     350        resourceAttribute.dataType = "http://www.w3.org/2001/XMLSchema#anyURI" 
     351        resourceAttribute.attributeValue = \ 
     352                            'file://example/med/record/patient/BartSimpson' 
     353 
     354        request.resources.append(resource) 
     355         
    275356        request.action = Action() 
     357        actionAttribute = Attribute() 
     358        request.action.append(actionAttribute) 
     359         
     360        requestAttribute.attributeId = \ 
     361                                "urn:oasis:names:tc:xacml:1.0:action:action-id" 
     362        requestAttribute.dataType = "http://www.w3.org/2001/XMLSchema#string" 
     363        requestAttribute.attributeValue = 'read' 
     364         
     365    def test02CreateResponse(self): 
     366        response = Response() 
     367        result = Result() 
     368        response.results.append(result) 
     369        result.decision = Decision.value = Decision.NOT_APPLICABLE 
     370         
     371    def test03CreateContextHandler(self): 
     372 
    276373         
    277374 
Note: See TracChangeset for help on using the changeset viewer.