Changeset 5397


Ignore:
Timestamp:
17/06/09 17:08:43 (10 years ago)
Author:
pjkersha
Message:

ndg.security.common.authz.msi: added additional logging for PDP and PIP.
ndg.security.common.authz.xacml: added SetFunction? and ConditionSetFunction? implementations to enable support got at-least-one-member of rules.

Location:
TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/msi.py

    r5357 r5397  
    325325        attributeResponse = PIPAttributeResponse() 
    326326        attributeResponse[Subject.ROLES_NS] = attributeCertificate.roles 
    327           
     327         
     328        log.debug("PIP.attributeQuery response: %r", attributeResponse) 
     329         
    328330        return attributeResponse 
    329331     
     
    596598            # must match one of the attributes restricting access to the 
    597599            # resource. 
     600            log.debug("PDP.evaluate: Matching subject attributes %r against " 
     601                      "resource attributes %r ...",  
     602                      matchingTarget.attributes, 
     603                      request.subject[Subject.ROLES_NS]) 
     604             
    598605            status.append(PDP._match(matchingTarget.attributes,  
    599606                                     request.subject[Subject.ROLES_NS])) 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/xacml/__init__.py

    r5395 r5397  
    409409          "urn:oasis:names:tc:xacml:1.0:status:processing-error" 
    410410    STATUS_SYNTAX_ERROR = \ 
    411           "urn:oasis:names:tc:xacml:1.0:status:syntax-error"   
    412       
    413 class EvaluationResult(XacmlBase): 
    414     def __init__(self,  
    415                  attributeValue=None,  
    416                  status=None,  
    417                  indeterminate=False): 
    418         self.status = status 
    419         self.attributeValue = attributeValue 
    420         self.indeterminate = indeterminate 
    421        
     411          "urn:oasis:names:tc:xacml:1.0:status:syntax-error"        
    422412 
    423413class Effect(XacmlBase): 
     
    521511        @return a decision effect, as defined in <code>Result</code> 
    522512        ''' 
    523         return self.effectAttr 
     513        return self.effect 
    524514     
    525515    def getId(self): 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/xacml/attr.py

    r5396 r5397  
    4646import logging 
    4747log = logging.getLogger(__name__) 
    48 import sys 
    4948 
    5049from ndg.security.common.utils import getLocalName 
    51 from ndg.security.common.authz.xacml.cond.eval import Evaluatable 
     50from ndg.security.common.authz.xacml.cond.eval import Evaluatable, \ 
     51    EvaluationResult 
    5252 
    5353class AttributeDesignator(object): 
    5454    elemNames = [n+'AttributeDesignator' for n in ('Action', 'Environment', 
    55                                                   'Resource', 'Subject')] 
     55                                                   'Resource', 'Subject')] 
    5656    targetCodes = range(4) 
    5757    targetLUT = dict(zip(elemNames, targetCodes)) 
     
    6262    SUBJECT_TARGET) = targetCodes 
    6363     
    64     def __init__(self, target, type, id, mustBePresent=False, issuer=None): 
     64    def __init__(self,  
     65                 target,  
     66                 type,  
     67                 attributeId,  
     68                 mustBePresent=False,  
     69                 issuer=None): 
    6570        if target not in AttributeDesignator.targetCodes: 
    6671            raise AttributeError("Target code must be one of %r; input code " 
     
    6974        self.target = target 
    7075        self.type = type 
    71         self.id = id 
     76        self.id = attributeId 
    7277        self.mustBePresent = mustBePresent 
    7378        self.issuer = issuer 
     
    100105        issuer = elem.attrib.get('issuer') 
    101106        return cls(target, type, id, mustBePresent=mustBePresent,issuer=issuer) 
     107 
    102108 
    103109class AttributeValue(Evaluatable): 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/xacml/cond/__init__.py

    r5395 r5397  
    4949from ndg.security.common.authz.xacml.exceptions import \ 
    5050    UnknownIdentifierException, ParsingException 
    51 from ndg.security.common.authz.xacml.cond.eval import Evaluatable 
     51from ndg.security.common.authz.xacml.cond.eval import Evaluatable, \ 
     52    EvaluationResult 
    5253from ndg.security.common.authz.xacml.attr import AnyURIAttribute, \ 
    5354    Base64BinaryAttribute, BooleanAttribute, DateAttribute, DateTimeAttribute,\ 
     
    556557 
    557558class SetFunction(FunctionBase): 
    558     def __init__(self, *arg, **kw): 
    559         raise NotImplementedError() 
     559    '''Represents all of the Set functions, though the actual implementations 
     560    are in two sub-classes specific to the condition and general set 
     561    functions.''' 
     562 
     563    # Base name for the type-intersection functions. To get the standard 
     564    # identifier for a given type, use FunctionBase.FUNCTION_NS 
     565    # + the datatype's base name (e.g., string) + 
     566    # NAME_BASE_INTERSECTION. 
     567    NAME_BASE_INTERSECTION = "-intersection" 
     568 
     569    # Base name for the type-at-least-one-member-of functions. To get the 
     570    # standard identifier for a given type, use 
     571    # FunctionBase.FUNCTION_NS + the datatype's base name (e.g., string) + 
     572    # NAME_BASE_AT_LEAST_ONE_MEMBER_OF. 
     573    NAME_BASE_AT_LEAST_ONE_MEMBER_OF = "-at-least-one-member-of" 
     574 
     575    # Base name for the type-union funtions. To get the standard 
     576    # identifier for a given type, use FunctionBase.FUNCTION_NS 
     577    # + the datatype's base name (e.g., string) + NAME_BASE_UNION. 
     578    NAME_BASE_UNION = "-union" 
     579 
     580    # Base name for the type-subset funtions. To get the standard 
     581    # identifier for a given type, use FunctionBase.FUNCTION_NS 
     582    # + the datatype's base name (e.g., string) + NAME_BASE_SUBSET. 
     583    NAME_BASE_SUBSET = "-subset" 
     584 
     585    # Base name for the type-set-equals funtions. To get the standard 
     586    # identifier for a given type, use FunctionBase.FUNCTION_NS 
     587    # + the datatype's base name (e.g., string) + NAME_BASE_SET_EQUALS. 
     588    NAME_BASE_SET_EQUALS = "-set-equals" 
     589 
     590     
     591    # A complete list of all the XACML datatypes supported by the Set 
     592    # functions 
     593    baseTypes = ( 
     594        StringAttribute.identifier, 
     595        BooleanAttribute.identifier, 
     596        IntegerAttribute.identifier, 
     597        DoubleAttribute.identifier, 
     598        DateAttribute.identifier, 
     599        DateTimeAttribute.identifier, 
     600        TimeAttribute.identifier, 
     601        AnyURIAttribute.identifier, 
     602        HexBinaryAttribute.identifier, 
     603        Base64BinaryAttribute.identifier, 
     604        DayTimeDurationAttribute.identifier, 
     605        YearMonthDurationAttribute.identifier, 
     606        X500NameAttribute.identifier, 
     607        RFC822NameAttribute.identifier) 
     608     
     609    # A complete list of all the XACML datatypes supported by the Set 
     610    # functions, using the "simple" form of the names (eg, string 
     611    # instead of http:#www.w3.org/2001/XMLSchema#string) 
     612    simpleTypes = ( 
     613        "string",  
     614        "boolean",  
     615        "integer",  
     616        "double",  
     617        "date",  
     618        "dateTime", 
     619        "time",  
     620        "anyURI",  
     621        "hexBinary",  
     622        "base64Binary",  
     623        "dayTimeDuration", 
     624        "yearMonthDuration",  
     625        "x500Name",  
     626        "rfc822Name") 
     627 
     628    # Define as lambda to avoid reference to classes that aren't defined yet 
     629    _getSupportedIdentifiers = lambda: \ 
     630        ConditionSetFunction.supportedIdentifiers +\ 
     631        GeneralSetFunction.supportedIdentifiers 
     632         
     633    # All the function identifiers supported by this class. 
     634    supportedIdentifiers = property(fget=_getSupportedIdentifiers) 
     635 
     636     
     637    def __init__(self,  
     638                 functionName,  
     639                 functionId,  
     640                 argumentType,  
     641                 returnType, 
     642                 returnsBag): 
     643        '''Constuctor used by the general and condition subclasses only. 
     644        If you need to create a new SetFunction instance you 
     645        should either use one of the getInstance methods or 
     646        construct one of the sub-classes directly. 
     647         
     648        @param functionName the identitifer for the function 
     649        @param functionId an optional, internal numeric identifier 
     650        @param argumentType the datatype this function accepts 
     651        @param returnType the datatype this function returns 
     652        @param returnsBag whether this function returns bags 
     653        ''' 
     654        super(SetFunction, self).__init__(functionName,  
     655                                          functionId,  
     656                                          argumentType,  
     657                                          True,  
     658                                          2,  
     659                                          returnType, 
     660                                          returnsBag) 
     661     
     662         
     663    @classmethod 
     664    def getIntersectionInstance(cls, functionName, argumentType): 
     665        '''Creates a new instance of the intersection set function. 
     666        This should be used to create support for any new attribute types 
     667        and then the new SetFunction object should be added 
     668        to the factory (all set functions for the base types are already 
     669        installed in the factory). 
     670         
     671        @param functionName the name of the function 
     672        @param argumentType the attribute type this function will work with 
     673         
     674        @return a new SetFunction for the given type 
     675        ''' 
     676        return GeneralSetFunction(functionName, argumentType, 
     677                                  cls.NAME_BASE_INTERSECTION) 
     678     
     679    @classmethod 
     680    def getAtLeastOneInstance(cls, functionName, argumentType): 
     681        '''Creates a new instance of the at-least-one-member-of set function. 
     682        This should be used to create support for any new attribute types 
     683        and then the new SetFunction object should be added 
     684        to the factory (all set functions for the base types are already 
     685        installed in the factory). 
     686         
     687        @param functionName the name of the function 
     688        @param argumentType the attribute type this function will work with 
     689         
     690        @return a new SetFunction for the given type 
     691        ''' 
     692        return ConditionSetFunction(functionName, argumentType, 
     693                                    cls.NAME_BASE_AT_LEAST_ONE_MEMBER_OF) 
     694     
     695    @classmethod 
     696    def getUnionInstance(cls, functionName, argumentType): 
     697        '''Creates a new instance of the union set function. 
     698        This should be used to create support for any new attribute types 
     699        and then the new SetFunction object should be added 
     700        to the factory (all set functions for the base types are already 
     701        installed in the factory). 
     702         
     703        @param functionName the name of the function 
     704        @param argumentType the attribute type this function will work with 
     705         
     706        @return a new SetFunction for the given type 
     707        ''' 
     708        return GeneralSetFunction(functionName, argumentType, 
     709                                  cls.NAME_BASE_UNION) 
     710     
     711    def getSubsetInstance(cls, functionName, argumentType): 
     712        '''Creates a new instance of the subset set function. 
     713        This should be used to create support for any new attribute types 
     714        and then the new SetFunction object should be added 
     715        to the factory (all set functions for the base types are already 
     716        installed in the factory). 
     717         
     718        @param functionName the name of the function 
     719        @param argumentType the attribute type this function will work with 
     720         
     721        @return a new SetFunction for the given type 
     722        ''' 
     723        return ConditionSetFunction(functionName, argumentType, 
     724                                    cls.NAME_BASE_SUBSET) 
     725     
     726    def getSetEqualsInstance(cls, functionName, argumentType): 
     727        '''Creates a new instance of the equals set function. 
     728        This should be used to create support for any new attribute types 
     729        and then the new SetFunction object should be added 
     730        to the factory (all set functions for the base types are already 
     731        installed in the factory). 
     732         
     733        @param functionName the name of the function 
     734        @param argumentType the attribute type this function will work with 
     735         
     736        @return a new SetFunction for the given type 
     737        ''' 
     738        return ConditionSetFunction(functionName, argumentType, 
     739                                    cls.NAME_BASE_SET_EQUALS) 
     740 
     741         
     742class ConditionSetFunction(SetFunction): 
     743    '''Specific SetFunction class that supports all of the 
     744    condition set functions: type-at-least-one-member-of, type-subset, and 
     745    type-set-equals.''' 
     746     
     747    # Private identifiers for the supported functions 
     748    (ID_BASE_AT_LEAST_ONE_MEMBER_OF, 
     749     ID_BASE_SUBSET, 
     750     ID_BASE_SET_EQUALS) = range(3) 
     751 
     752    # Mapping of function name to its associated id and parameter type 
     753    idMap = {} 
     754    typeMap = {} 
     755    for baseType, simpleType in zip(SetFunction.baseTypes,  
     756                                    SetFunction.simpleTypes): 
     757        baseName = SetFunction.FUNCTION_NS + simpleType 
     758 
     759        idMap[baseName + SetFunction.NAME_BASE_AT_LEAST_ONE_MEMBER_OF] = \ 
     760                  ID_BASE_AT_LEAST_ONE_MEMBER_OF 
     761        idMap[baseName + SetFunction.NAME_BASE_SUBSET] = ID_BASE_SUBSET 
     762        idMap[baseName + SetFunction.NAME_BASE_SET_EQUALS] = ID_BASE_SET_EQUALS 
     763 
     764        typeMap[baseName+SetFunction.NAME_BASE_AT_LEAST_ONE_MEMBER_OF]=baseType 
     765        typeMap[baseName + SetFunction.NAME_BASE_SUBSET] = baseType 
     766        typeMap[baseName + SetFunction.NAME_BASE_SET_EQUALS] = baseType 
     767         
     768    del baseName 
     769     
     770    # the actual supported ids 
     771    supportedIdentifiers = tuple(idMap.keys()) 
     772 
     773    idMap.update({ 
     774        SetFunction.NAME_BASE_AT_LEAST_ONE_MEMBER_OF: 
     775                                            ID_BASE_AT_LEAST_ONE_MEMBER_OF, 
     776        SetFunction.NAME_BASE_SUBSET: ID_BASE_SUBSET, 
     777        SetFunction.NAME_BASE_SET_EQUALS: ID_BASE_SET_EQUALS} 
     778    ) 
     779     
     780     
     781    def __init__(self, functionName, dataType=None): 
     782        '''Constructor that is used to create one of the condition standard 
     783        set functions. The name supplied must be one of the standard XACML 
     784        functions supported by this class, including the full namespace, 
     785        otherwise an exception is thrown. Look in SetFunction 
     786        for details about the supported names. 
     787         
     788        @param functionName the name of the function to create 
     789         
     790        @throws IllegalArgumentException if the function is unknown 
     791        ''' 
     792        if dataType is None: 
     793            dataType = ConditionSetFunction.typeMap[functionName] 
     794             
     795        super(ConditionSetFunction, self).__init__(functionName,  
     796                                ConditionSetFunction.idMap[functionName],  
     797                                dataType, 
     798                                BooleanAttribute.identifier,  
     799                                False) 
     800 
     801     
     802    def evaluate(self, inputs, context): 
     803        '''Evaluates the function, using the specified parameters. 
     804         
     805        @param inputs a list of Evaluatable objects representing the arguments  
     806        passed to the function 
     807        @param context an EvaluationCtx so that the Evaluatable objects can be  
     808        evaluated 
     809        @return an EvaluationResult representing the function's result 
     810        ''' 
     811 
     812        # Evaluate the arguments 
     813        argValues = AttributeValue[len(inputs)] 
     814        evalResult = self.evalArgs(inputs, context, argValues) 
     815        if evalResult is not None: 
     816            return evalResult 
     817 
     818        # Setup the two bags we'll be using 
     819        bags = argValues[:1] 
     820 
     821        result = None 
     822         
     823        if self.functionId == \ 
     824            ConditionSetFunction.ID_BASE_AT_LEAST_ONE_MEMBER_OF: 
     825             
     826            #-at-least-one-member-of takes two bags of the same type and 
     827            # returns a boolean 
     828     
     829            # true if at least one element in the first argument is in the 
     830            # second argument (using the-is-in semantics) 
     831 
     832            result = BooleanAttribute.getFalseInstance() 
     833            for it in bags[0]:  
     834                if it in bags[1]:  
     835                    result = BooleanAttribute.getTrueInstance() 
     836                    break 
     837                 
     838        elif self.functionId == ConditionSetFunction.ID_BASE_SUBSET: 
     839            #-set-equals takes two bags of the same type and returns 
     840            # a boolean 
     841             
     842            # returns true if the first argument is a subset of the second 
     843            # argument (ie, all the elements in the first bag appear in 
     844            # the second bag) ... ignore all duplicate values in both 
     845            # input bags 
     846 
     847            subset = bags[1].containsAll(bags[0]) 
     848            result = BooleanAttribute.getInstance(subset) 
     849 
     850        elif self.functionId == ConditionSetFunction.ID_BASE_SET_EQUALS: 
     851            #-set-equals takes two bags of the same type and returns 
     852            # a boolean 
     853 
     854            # returns true if the two inputs contain the same elements 
     855            # discounting any duplicates in either input ... this is the same 
     856            # as applying the and function on the subset function with 
     857            # the two inputs, and then the two inputs reversed (ie, are the 
     858            # two inputs subsets of each other) 
     859 
     860            equals = bags[1].containsAll(bags[0] and \ 
     861                              bags[0].containsAll(bags[1])) 
     862            result = BooleanAttribute.getInstance(equals) 
     863         
     864        return EvaluationResult(result)  
     865     
    560866        
     867class GeneralSetFunction(SetFunction): 
     868    supportedIdentifiers = () 
     869    def __init__(self, *arg, **kw): 
     870        raise NotImplementedError() 
     871 
    561872class ConditionBagFunction(BagFunction): 
    562     def __init__(self, *arg, **kw): 
    563         raise NotImplementedError() 
    564          
    565 class ConditionSetFunction(FunctionBase): 
    566873    def __init__(self, *arg, **kw): 
    567874        raise NotImplementedError() 
     
    8051112    def __init__(self, *arg, **kw): 
    8061113        raise NotImplementedError() 
    807  
    808 class GeneralSetFunction(SetFunction): 
    809      
    810     def __init__(self, *arg, **kw): 
    811         raise NotImplementedError() 
    8121114     
    8131115class MapFunction(Function):         
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/xacml/cond/eval.py

    r5395 r5397  
    4646log = logging.getLogger(__name__) 
    4747 
     48      
     49class EvaluationResult(object): 
     50    def __init__(self,  
     51                 attributeValue=None,  
     52                 status=None,  
     53                 indeterminate=False): 
     54        self.status = status 
     55        self.attributeValue = attributeValue 
     56        self.indeterminate = indeterminate 
     57         
     58         
    4859class Evaluatable(object): 
    4960    '''Generic interface that is implemented by all objects that can appear in 
Note: See TracChangeset for help on using the changeset viewer.