Changeset 7698


Ignore:
Timestamp:
04/11/10 13:55:40 (9 years ago)
Author:
pjkersha
Message:

Integrated SAML ESGF Group/Role? attribute value type into SAML Attribute Authority client unit tests.

Location:
TI12-security/trunk/NDGSecurity/python
Files:
1 deleted
26 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDGSecurity/python/Tests/esg_integration/test_attributeserviceclient.cfg

    r7681 r7698  
    1616subject = https://esg.prototype.ucar.edu/myopenid/testUser 
    1717 
    18 attributeQuery.deserialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.fromXML 
     18attributeQuery.deserialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.fromXML 
    1919attributeQuery.subjectIdFormat = urn:esg:openid 
    2020attributeQuery.clockSkewTolerance = 1. 
     
    3535subject = https://esg.prototype.ucar.edu/myopenid/testUser 
    3636 
    37 attributeQuery.deserialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.fromXML 
     37attributeQuery.deserialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.fromXML 
    3838attributeQuery.subjectIdFormat = urn:esg:openid 
    3939attributeQuery.clockSkewTolerance = 1. 
     
    5454subject = https://ceda.ac.uk/openid/Philip.Kershaw 
    5555 
    56 attributeQuery.deserialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.fromXML 
     56attributeQuery.deserialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.fromXML 
    5757attributeQuery.subjectIdFormat = urn:esg:openid 
    5858attributeQuery.clockSkewTolerance = 1. 
  • TI12-security/trunk/NDGSecurity/python/Tests/esg_integration/test_attributeserviceclient.py

    r7681 r7698  
    2222                                        AttributeQuerySslSOAPBinding) 
    2323 
    24 from ndg.security.common.saml_utils.esg.xml.etree import EsgResponseElementTree 
     24from ndg.security.common.saml_utils.esgf.xml.etree import ESGFResponseElementTree 
    2525from ndg.security.common.utils.etree import prettyPrint 
    2626from ndg.security.common.utils.configfileparsers import ( 
     
    5454        response = binding.send(uri=uri) 
    5555         
    56         # EsgResponseElementTree has an extension to support ESG Group/Role  
     56        # ESGFResponseElementTree has an extension to support ESG Group/Role  
    5757        # Attribute Value  
    58         samlResponseElem = EsgResponseElementTree.toXML(response) 
     58        samlResponseElem = ESGFResponseElementTree.toXML(response) 
    5959         
    6060        print("SAML Response ...") 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/esgf/__init__.py

    r7076 r7698  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id$' 
    11 from ndg.saml.saml2.core import XSStringAttributeValue, AttributeValue, Attribute 
     11from ndg.saml.saml2.core import (XSStringAttributeValue, AttributeValue,  
     12                                 Attribute) 
    1213from ndg.saml.common.xml import QName, SAMLConstants 
    1314 
     
    1516 
    1617 
    17 class  _MetaEsgSamlNamespaces(type): 
     18class  _MetaESGFSamlNamespaces(type): 
    1819    """Meta class enables read-only constants""" 
    1920    @property 
     
    4647 
    4748  
    48 class EsgSamlNamespaces(object): 
     49class ESGFSamlNamespaces(object): 
    4950    """Earth System Grid specific constants for use with SAML assertions""" 
    50     __metaclass__ = _MetaEsgSamlNamespaces 
     51    __metaclass__ = _MetaESGFSamlNamespaces 
    5152     
    5253     
    53 class XSGroupRoleAttributeValue(AttributeValue):  
     54class ESGFGroupRoleAttributeValue(AttributeValue):  
    5455    '''ESG Specific Group/Role attribute value.  ESG attribute permissions are 
    5556    organised into group/role pairs 
     
    6162    GROUP_ATTRIB_NAME = "group" 
    6263    ROLE_ATTRIB_NAME = "role" 
     64    DEFAULT_ROLE_NAME = "default" 
    6365     
    6466    # QName of the XSI type 
     
    125127      
    126128    def _setGroup(self, group):  
     129        if not isinstance(group, basestring): 
     130            raise TypeError('Expecting a string type for "group" attribute; ' 
     131                            'got %r' % type(group)) 
    127132        self.__group = group 
    128133      
    129     group = property(fget=_getGroup, fset=_setGroup) 
     134    group = property(fget=_getGroup, fset=_setGroup, doc="Group value") 
    130135      
    131136    def _getRole(self): 
     
    133138      
    134139    def _setRole(self, role): 
     140        if not isinstance(role, basestring): 
     141            raise TypeError('Expecting a string type for "role" attribute; ' 
     142                            'got %r' % type(role))            
    135143        self.__role = role 
    136144      
    137     role = property(fget=_getRole, fset=_setRole) 
     145    role = property(fget=_getRole, fset=_setRole, doc="Role value") 
    138146 
     147    def _setValue(self, value): 
     148        if not isinstance(value, (tuple, list)) and len(value) != 2: 
     149            raise TypeError('Expecting a two element tuple or list for group/' 
     150                            'role value; got %r' % type(value)) 
     151             
     152        self.group, self.role = value 
     153         
     154    def _getValue(self): 
     155        return self.group, self.role 
     156     
     157    value = property(_getValue, _setValue,  
     158                     doc="group/role attribute value tuple") 
     159     
    139160    def getOrderedChildren(self): 
    140161        # no children 
     
    142163 
    143164 
    144 class EsgDefaultQueryAttributes(object):     
     165class ESGFDefaultQueryAttributes(object):     
    145166    XSSTRING_NS = "%s#%s" % ( 
    146167        SAMLConstants.XSD_NS, 
     
    150171    ATTRIBUTES = TypedList(Attribute) 
    151172    N_ATTRIBUTES = 3 
    152     ATTRIBUTES += [Attribute(),]*N_ATTRIBUTES 
     173    i = 0 
     174    for i in range(N_ATTRIBUTES):  
     175        ATTRIBUTES.append(Attribute()) 
     176    del i 
    153177     
    154     ATTRIBUTES[0].name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME  
    155     ATTRIBUTES[0].friendlyName = EsgSamlNamespaces.FIRSTNAME_FRIENDLYNAME 
     178    ATTRIBUTES[0].name = ESGFSamlNamespaces.FIRSTNAME_ATTRNAME  
     179    ATTRIBUTES[0].friendlyName = ESGFSamlNamespaces.FIRSTNAME_FRIENDLYNAME 
    156180    ATTRIBUTES[0].nameFormat = XSSTRING_NS 
    157181 
    158     ATTRIBUTES[1].name = EsgSamlNamespaces.LASTNAME_ATTRNAME  
    159     ATTRIBUTES[1].friendlyName = EsgSamlNamespaces.LASTNAME_FRIENDLYNAME 
     182    ATTRIBUTES[1].name = ESGFSamlNamespaces.LASTNAME_ATTRNAME  
     183    ATTRIBUTES[1].friendlyName = ESGFSamlNamespaces.LASTNAME_FRIENDLYNAME 
    160184    ATTRIBUTES[1].nameFormat = XSSTRING_NS 
    161185     
    162     ATTRIBUTES[2].name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    163     ATTRIBUTES[2].friendlyName = EsgSamlNamespaces.EMAILADDRESS_FRIENDLYNAME 
     186    ATTRIBUTES[2].name = ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME 
     187    ATTRIBUTES[2].friendlyName = ESGFSamlNamespaces.EMAILADDRESS_FRIENDLYNAME 
    164188    ATTRIBUTES[2].nameFormat =  XSSTRING_NS 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/esgf/xml/etree.py

    r7287 r7698  
    1919                                QName) 
    2020 
    21 from ndg.security.common.saml_utils.esg import XSGroupRoleAttributeValue 
     21from ndg.security.common.saml_utils.esgf import ESGFGroupRoleAttributeValue 
    2222 
    2323 
    24 class XSGroupRoleAttributeValueElementTree(AttributeValueElementTreeBase, 
    25                                            XSGroupRoleAttributeValue): 
     24class ESGFGroupRoleAttributeValueElementTree(AttributeValueElementTreeBase, 
     25                                             ESGFGroupRoleAttributeValue): 
    2626    """ElementTree XML representation of Earth System Grid custom Group/Role  
    2727    Attribute Value"""  
     
    3232        Attribute Value 
    3333         
    34         @type assertion: saml.saml2.core.XSGroupRoleAttributeValue 
    35         @param assertion: XSGroupRoleAttributeValue to be represented as an  
    36         ElementTree Element 
     34        @type attributeValue: ndg.security.common.saml_utils.esgf.ESGFGroupRoleAttributeValue 
     35        @param attributeValue: Group/Role Attribute Value to be represented as  
     36        an ElementTree Element 
    3737        @rtype: ElementTree.Element 
    3838        @return: ElementTree Element 
     
    4040        elem = AttributeValueElementTreeBase.toXML(attributeValue) 
    4141         
    42         if not isinstance(attributeValue, XSGroupRoleAttributeValue): 
     42        if not isinstance(attributeValue, ESGFGroupRoleAttributeValue): 
    4343            raise TypeError("Expecting %r type; got: %r" %  
    44                             (XSGroupRoleAttributeValue, type(attributeValue))) 
     44                            (ESGFGroupRoleAttributeValue, type(attributeValue))) 
    4545             
    4646        ElementTree._namespace_map[attributeValue.namespaceURI 
     
    6262    def fromXML(cls, elem): 
    6363        """Parse ElementTree ESG Group/Role attribute element into a SAML  
    64         XSGroupRoleAttributeValue object 
     64        ESGFGroupRoleAttributeValue object 
    6565         
    6666        @type elem: ElementTree.Element 
    6767        @param elem: Attribute value as ElementTree XML element 
    68         @rtype: saml.saml2.core.XSGroupRoleAttributeValue 
     68        @rtype: saml.saml2.core.ESGFGroupRoleAttributeValue 
    6969        @return: SAML ESG Group/Role Attribute value 
    7070        """ 
     
    9595 
    9696                                       
    97         attributeValue = XSGroupRoleAttributeValue() 
     97        attributeValue = ESGFGroupRoleAttributeValue() 
    9898        groupName = childElem.attrib.get(cls.GROUP_ATTRIB_NAME) 
    9999        if groupName is None: 
     
    105105        roleName = childElem.attrib.get(cls.ROLE_ATTRIB_NAME) 
    106106        if roleName is None: 
    107             raise XMLTypeParseError('No "%s" attribute found in Group/Role ' 
    108                                     'attribute element' %  
    109                                     cls.GROUP_ATTRIB_NAME) 
     107            roleName = cls.DEFAULT_ROLE_NAME 
     108             
    110109        attributeValue.role = roleName 
    111110 
     
    115114    def factoryMatchFunc(cls, elem): 
    116115        """Match function used by AttributeValueElementTreeFactory to 
    117         determine whether the given attribute is XSGroupRole type 
     116        determine whether the given attribute is ESGFGroupRoleAttributeValue 
     117        type 
    118118         
    119119        @type elem: ElementTree.Element 
    120120        @param elem: Attribute value as ElementTree XML element 
    121         @rtype: saml.saml2.core.XSGroupRoleAttributeValue or None 
    122         @return: SAML ESG Group/Role Attribute Value class if elem is an 
     121        @rtype: ndg.security.common.saml_utils.etree.ESGFGroupRoleAttributeValue 
     122        or None 
     123        @return: SAML ESGF Group/Role Attribute Value class if elem is an 
    123124        Group/role type element or None if if doesn't match this type  
    124125        """ 
     
    140141 
    141142 
    142 class EsgResponseElementTree(ResponseElementTree): 
     143class ESGFResponseElementTree(ResponseElementTree): 
    143144    """Extend ResponseElementTree type for Attribute Query Response to include  
    144145    ESG custom Group/Role Attribute support""" 
     
    146147    @classmethod 
    147148    def toXML(cls, response, **kw): 
    148         # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    149         # Attribute Value factory to render the XML output 
     149        """Extend base method adding mapping for ESG Group/Role Attribute Value  
     150        to enable ElementTree Attribute Value factory to render the XML output 
     151         
     152        @type response: ndg.security.common.saml_utils.etree.ESGFGroupRoleAttributeValue 
     153        @param response: ESGF Group/Role attribute value  
     154        @rtype: ElementTree.Element 
     155        @return: ESGF Group/Role attribute value as ElementTree.Element 
     156        """ 
    150157        toXMLTypeMap = kw.get('customToXMLTypeMap', {}) 
    151         toXMLTypeMap[XSGroupRoleAttributeValue 
    152                      ] = XSGroupRoleAttributeValueElementTree 
     158        toXMLTypeMap[ESGFGroupRoleAttributeValue 
     159                     ] = ESGFGroupRoleAttributeValueElementTree 
    153160         
    154161        kw['customToXMLTypeMap'] = toXMLTypeMap 
     
    160167    @classmethod 
    161168    def fromXML(cls, elem, **kw): 
     169        """Extend base method adding mapping for ESG Group/Role Attribute Value 
     170          
     171        @type elem: ElementTree.Element 
     172        @param elem: ESGF Group/Role attribute value as ElementTree.Element 
     173        @rtype: ndg.security.common.saml_utils.etree.ESGFGroupRoleAttributeValue 
     174        @return: ESGF Group/Role attribute value  
     175        """ 
    162176        toSAMLTypeMap = kw.get('customToSAMLTypeMap', []) 
    163177        toSAMLTypeMap.append( 
    164                         XSGroupRoleAttributeValueElementTree.factoryMatchFunc) 
     178                        ESGFGroupRoleAttributeValueElementTree.factoryMatchFunc) 
    165179        kw['customToSAMLTypeMap'] = toSAMLTypeMap 
    166180         
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/utils/factory.py

    r7076 r7698  
    3838            except ValueError: 
    3939                raise ValueError('Invalid module name %r set for import: %s' % 
    40                                  (moduleName, traceback.format_exc())) 
    41                  
    42             objectName = [objectName] 
     40                                 (moduleName, traceback.format_exc()))         
    4341    else: 
    4442        _moduleName = moduleName 
    45         if isinstance(objectName, basestring): 
    46             objectName = [objectName] 
     43         
     44    if isinstance(objectName, basestring): 
     45        objectName = [objectName] 
    4746     
    4847    log.debug("Importing %r ..." % objectName)  
     
    5352        for component in components[1:]: 
    5453            module = getattr(module, component) 
    55     except AttributeError, e: 
     54    except AttributeError: 
    5655        raise AttributeError("Error importing %r: %s" % 
    5756                             (objectName, traceback.format_exc())) 
     
    7170 
    7271def callModuleObject(moduleName, objectName=None, moduleFilePath=None,  
    73                      objectType=None, objectArgs=(), objectProperties={}): 
     72                     objectType=None, objectArgs=None, objectProperties=None): 
    7473    ''' 
    7574    Create and return an instance of the specified class or invoke callable 
     
    9089    @return: object - instance of the class specified  
    9190    ''' 
    92  
    9391     
    9492    # ensure that properties is a dict - NB, it may be passed in as a null 
     
    9795        objectProperties = {} 
    9896 
     97    if not objectArgs: 
     98        objectArgs = () 
     99         
    99100    # variable to store original state of the system path 
    100101    sysPathBak = None 
     
    131132 
    132133    # Instantiate class 
    133     log.debug('Instantiating object "%s"' % importedObject.__name__) 
     134    log.debug('Instantiating object "%s"', importedObject.__name__) 
    134135    try: 
    135136        if objectArgs: 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r7507 r7698  
    3636                                 StatusCode, StatusMessage) 
    3737 
    38 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     38from ndg.security.common.saml_utils.esgf import ESGFSamlNamespaces 
    3939from ndg.security.common.X509 import X500DN 
    4040from ndg.security.common.utils import TypedList 
     
    461461        utcNow = datetime.utcnow() 
    462462        if (attributeQuery.subject.nameID.format !=  
    463             EsgSamlNamespaces.NAMEID_FORMAT): 
     463            ESGFSamlNamespaces.NAMEID_FORMAT): 
    464464            log.error('SAML Attribute Query subject format is %r; expecting ' 
    465465                      '%r' % (attributeQuery.subject.nameID.format, 
    466                                 EsgSamlNamespaces.NAMEID_FORMAT)) 
     466                                ESGFSamlNamespaces.NAMEID_FORMAT)) 
    467467            samlResponse.status.statusCode.value = StatusCode.REQUESTER_URI 
    468468            samlResponse.status.statusMessage.value = \ 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r7155 r7698  
    4141from ndg.saml.saml2.binding.soap.client.attributequery import \ 
    4242                                                AttributeQuerySslSOAPBinding 
    43 from ndg.security.common.saml_utils.esg import (EsgSamlNamespaces, 
    44                                                 EsgDefaultQueryAttributes) 
     43from ndg.security.common.saml_utils.esgf import (ESGFSamlNamespaces, 
     44                                                ESGFDefaultQueryAttributes) 
    4545from ndg.security.common.utils.etree import prettyPrint 
    4646from ndg.security.common.X509 import X500DN 
     
    104104    assertion for inclusion by MyProxy into an issued certificate 
    105105    """ 
    106     DEFAULT_QUERY_ATTRIBUTES = EsgDefaultQueryAttributes.ATTRIBUTES 
     106    DEFAULT_QUERY_ATTRIBUTES = ESGFDefaultQueryAttributes.ATTRIBUTES 
    107107    N_DEFAULT_QUERY_ATTRIBUTES = len(DEFAULT_QUERY_ATTRIBUTES) 
    108     ESG_NAME_ID_FORMAT = EsgSamlNamespaces.NAMEID_FORMAT 
     108    ESG_NAME_ID_FORMAT = ESGFSamlNamespaces.NAMEID_FORMAT 
    109109     
    110110    CONNECTION_STRING_OPTNAME = 'connectionString' 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/xacml/ctx_handler/saml_ctx_handler.py

    r7413 r7698  
    3232 
    3333from ndg.security.server.xacml.pip.saml_pip import PIP 
     34from ndg.security.common.utils.factory import importModuleObject 
    3435 
    3536 
     
    7980        '__issuerProxy',  
    8081        '__assertionLifetime', 
     82        '__xacmlExtFunc' 
    8183    ) 
    8284     
     
    9294        self.__assertionLifetime = 0. 
    9395        self.__policyFilePath = None 
    94      
     96        self.__xacmlExtFunc = None 
     97 
     98    def _getXacmlExtFunc(self): 
     99        """Get XACML extensions function""" 
     100        return self.__xacmlExtFunc 
     101 
     102    def _setXacmlExtFunc(self, value): 
     103        """Set XACML extensions function""" 
     104        if isinstance(value, basestring): 
     105            self.__xacmlExtFunc = importModuleObject(value) 
     106             
     107        elif callable(value): 
     108            self.__xacmlExtFunc = value 
     109             
     110        else: 
     111            raise TypeError('Expecting module object import path string or ' 
     112                            'callable; got %r' % type(value)) 
     113             
     114    xacmlExtFunc = property(_getXacmlExtFunc, _setXacmlExtFunc,  
     115                            doc="Function or other callable which will be " 
     116                                "called to set any XACML specific " 
     117                                "extensions such as new custom attribute value " 
     118                                "types.  The function should accept no input " 
     119                                "arguments and any return value is ignored")    
     120     
     121    def load(self): 
     122        """Load Policy file, mapping file and extensions function.  In each case 
     123        load only if they're set 
     124        """ 
     125        if self.policyFilePath: 
     126            self.pdp = PDP.fromPolicySource(self.policyFilePath,  
     127                                            XacmlPolicyReaderFactory) 
     128         
     129        if self.pip.mappingFilePath: 
     130            self.pip.readMappingFile() 
     131             
     132        if self.xacmlExtFunc: 
     133            self.xacmlExtFunc() 
     134         
    95135    @classmethod 
    96136    def fromConfig(cls, cfg, **kw): 
     
    105145         
    106146        # Post initialisation steps - load policy and PIP mapping file 
    107         if obj.policyFilePath: 
    108             obj.pdp = PDP.fromPolicySource(obj.policyFilePath,  
    109                                            XacmlPolicyReaderFactory) 
    110          
    111         if obj.pip.mappingFilePath: 
    112             obj.pip.readMappingFile() 
    113              
     147        obj.load() 
     148            
    114149        return obj 
    115150 
     
    159194         
    160195        def _setAttr(__optName): 
    161             # Check for PIP attribute related items 
     196            """Convenience function to check for PIP attribute related items 
     197            """ 
    162198            if __optName.startswith(pipPrefix): 
    163199                if self.pip is None:     
     
    211247         
    212248        # Post initialisation steps - load policy and PIP mapping file 
    213         if obj.policyFilePath: 
    214             obj.pdp = PDP.fromPolicySource(obj.policyFilePath,  
    215                                            XacmlPolicyReaderFactory) 
    216          
    217         if obj.pip.mappingFilePath: 
    218             obj.pip.readMappingFile() 
     249        obj.load() 
    219250                        
    220251        return obj 
     
    492523 
    493524        return response 
     525 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/xacml/esgf_ext.py

    r7693 r7698  
    1313log = logging.getLogger(__name__) 
    1414 
     15from ndg.xacml.core.functions import functionMap 
    1516from ndg.xacml.core.functions.v1.bag import BagBase 
    1617from ndg.xacml.core.functions.v1.at_least_one_member_of import \ 
    1718    AtLeastOneMemberOfBase  
    18 from ndg.xacml.core.attributevalue import AttributeValueClassFactory 
     19from ndg.xacml.core.attributevalue import (AttributeValue, 
     20                                           AttributeValueClassFactory) 
    1921from ndg.xacml.parsers import XMLParseError 
    2022from ndg.xacml.parsers.etree.attributevaluereader import ( 
     
    6870        return self.__group 
    6971     
    70     @property.setter 
     72    @group.setter 
    7173    def group(self, value): 
    7274        """@param value: new group value to set 
     
    8688        return self.__role 
    8789     
    88     @property.setter 
     90    @role.setter 
    8991    def role(self, value): 
    9092        """@param value: new role value to set 
     
    155157            if localName == attributeValue.__class__.ROLE_ELEMENT_LOCAL_NAME: 
    156158                attributeValue.role = subElem.text 
     159                 
    157160            elif localName == attributeValue.__class__.GROUP_ELEMENT_LOCAL_NAME: 
    158161                attributeValue.group = subElem.text 
     162                 
    159163            else: 
    160164                raise XMLParseError('%r ESG Group/Role sub-element not ' 
    161165                                    'recognised' % localName)  
     166 
     167 
     168def addEsgfXacmlSupport(): 
     169    """Add custom Earth System Grid types to XACML Classes.  This includes 
     170    the Group/Role Attribute type, and associated ElementTree based parser, 
     171    and XACML bag and at least one member functions 
     172    """ 
     173     
     174    # Add Group/Role type 
     175    AttributeValueClassFactory.addClass(ESGFGroupRoleAttributeValue.IDENTIFIER,  
     176                                        ESGFGroupRoleAttributeValue) 
     177     
     178    # Add new parser for this type 
     179    DataTypeReaderClassFactory.addReader(ESGFGroupRoleAttributeValue.IDENTIFIER, 
     180                                         ETreeESGFGroupRoleDataTypeReader) 
     181     
     182    # Add extra matching and bag functions 
     183    functionMap[ESGFGroupRoleBag.FUNCTION_NS] = ESGFGroupRoleBag 
     184    functionMap[ESGFGroupRoleAtLeastOneMemberOf.FUNCTION_NS 
     185                ] = ESGFGroupRoleAtLeastOneMemberOf 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/xacml/pip/saml_pip.py

    r7359 r7698  
    4545    __slots__ = ('__session', ) 
    4646     
    47     def __init__(self, _id, data_dir=None): 
     47    def __init__(self, _id, data_dir=None, timeout=None): 
    4848        """ 
    4949        @param _id: unique identifier for session to be created, or one to reload 
     
    5555        If set to None, sessions are cached in memory only. 
    5656        @type data_dir: None type / basestring 
     57        @param timeout: time in seconds for individual caches' lifetimes.  Set  
     58        to None to set no expiry. 
     59        @type timeout: float/int/long or None type 
    5760        """                 
    5861        # Expecting URIs for Ids, make them safe for storage by encoding first 
     
    6467        self.__session = beaker.session.Session({}, id=encodedId,  
    6568                                                data_dir=data_dir, 
     69                                                timeout=timeout, 
    6670                                                use_cookies=False) 
    6771        if 'wallet' not in self.__session: 
     
    153157        '__cacheSessions', 
    154158        '__sessionCacheDataDir', 
     159        '__sessionCacheTimeout', 
    155160        '__sessionCache' 
    156161    ) 
    157162     
    158     def __init__(self, sessionCacheDataDir=None): 
     163    def __init__(self, sessionCacheDataDir=None, sessionCacheTimeout=None): 
    159164        '''Initialise settings for connection to an Attribute Authority 
    160165         
     
    164169        If set to None, sessions are cached in memory only. 
    165170        @type sessionCacheDataDir: None type / basestring 
     171        @param sessionCacheTimeout: time in seconds for individual caches'  
     172        lifetimes.  Set to None to set no expiry. 
     173        @type sessionCacheTimeout: float/int/long/string or None type 
    166174        ''' 
     175        self.sessionCacheDataDir = sessionCacheDataDir 
     176        self.sessionCacheTimeout = sessionCacheTimeout 
     177         
    167178        self.__subjectAttributeId = None 
    168179        self.__mappingFilePath = None 
     
    175186         
    176187        self.__cacheSessions = True 
    177         self.__sessionCacheDataDir = sessionCacheDataDir 
    178188        self.__sessionCache = None 
     189 
     190    def _getSessionCacheTimeout(self): 
     191        return self.__sessionCacheTimeout 
     192 
     193    def _setSessionCacheTimeout(self, value): 
     194        if value is None: 
     195            self.__sessionCacheTimeout = value 
     196          
     197        elif isinstance(value, basestring): 
     198            self.__sessionCacheTimeout = float(value) 
     199              
     200        elif isinstance(value, (int, float, long)): 
     201            self.__sessionCacheTimeout = value 
     202             
     203        else: 
     204            raise TypeError('Expecting None, float, int, long or string type; ' 
     205                            'got %r' % type(value)) 
     206 
     207    sessionCacheTimeout = property(_getSessionCacheTimeout,  
     208                                   _setSessionCacheTimeout,  
     209                                   doc='Set individual session caches to ' 
     210                                       'timeout after this period (seconds).  ' 
     211                                       'Set to None to have no timeout') 
    179212 
    180213    def _getCacheSessions(self): 
     
    423456        if self.cacheSessions: 
    424457            sessionCache = SessionCache(subjectId, 
    425                                         data_dir=self.__sessionCacheDataDir) 
     458                                        data_dir=self.__sessionCacheDataDir, 
     459                                        timeout=self.__sessionCacheTimeout) 
    426460            assertions = sessionCache.retrieve(attributeAuthorityURI) 
    427461        else: 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/site-a.ini

    r7164 r7698  
    6060 
    6161# Specialisation to incorporate ESG Group/Role type 
    62 saml.soapbinding.serialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.toXML 
     62saml.soapbinding.serialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.toXML 
    6363 
    6464saml.soapbinding.mountPath = /AttributeAuthority 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/sitea_attributeinterface.py

    r7077 r7698  
    1515 
    1616from ndg.saml.common.xml import SAMLConstants 
    17 from ndg.saml.saml2.core import (Assertion, Attribute, AttributeStatement, Issuer, 
    18                              SAMLVersion, Subject, NameID, Conditions, 
    19                              XSStringAttributeValue) 
     17from ndg.saml.saml2.core import (Assertion, Attribute, AttributeStatement,  
     18                                 Issuer, SAMLVersion, Subject, NameID,  
     19                                 Conditions, XSStringAttributeValue) 
    2020 
     21from ndg.security.common.saml_utils.esgf import (ESGFSamlNamespaces, 
     22                                                 ESGFGroupRoleAttributeValue) 
    2123from ndg.security.common.X509 import X500DN 
    2224from ndg.security.server.attributeauthority import (AttributeInterface,  
     
    3436 
    3537    SAML_ATTRIBUTE_NAMES = ATTRIBUTE_NAMES + ( 
    36         'urn:esg:email:address', 
    37         'urn:esg:first:name',  
    38         'urn:esg:last:name' 
     38        ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME, 
     39        ESGFSamlNamespaces.FIRSTNAME_ATTRNAME,  
     40        ESGFSamlNamespaces.LASTNAME_ATTRNAME, 
     41        'urn:esg:sitea:grouprole' 
    3942    ) 
    4043     
     
    4346        ('p.kershaw@somewhere.ac.uk',), 
    4447        ('Philip',), 
    45         ('Kershaw',) 
     48        ('Kershaw',), 
     49        (('siteagroup', 'default'),) 
    4650    ) 
    4751     
     
    4953        "EmailAddress", 
    5054        "FirstName", 
    51         "LastName" 
     55        "LastName", 
     56        "groupRole" 
    5257    ) 
    53     SAML_ATTRIBUTE_FORMATS = (SAMLConstants.XSD_NS+"#"+\ 
    54                               XSStringAttributeValue.TYPE_LOCAL_NAME,) * \ 
    55                               len(SAML_ATTRIBUTE_NAMES) 
     58    SAML_ATTRIBUTE_FORMATS = ( 
     59        SAMLConstants.XSD_NS+"#"+XSStringAttributeValue.TYPE_LOCAL_NAME,) * ( 
     60        len(SAML_ATTRIBUTE_NAMES)-1) + \ 
     61        (ESGFGroupRoleAttributeValue.TYPE_LOCAL_NAME, ) 
     62     
    5663    SAML_ATTRIBUTES = [] 
    5764     
     65    name, val, vals, format, friendlyName = (None, None, None, None, None) 
    5866    for name, vals, format, friendlyName in zip(SAML_ATTRIBUTE_NAMES, 
    59                                                SAML_ATTRIBUTE_VALUES, 
    60                                                SAML_ATTRIBUTE_FORMATS, 
    61                                                SAML_ATTRIBUTE_FRIENDLY_NAMES): 
     67                                                SAML_ATTRIBUTE_VALUES, 
     68                                                SAML_ATTRIBUTE_FORMATS, 
     69                                                SAML_ATTRIBUTE_FRIENDLY_NAMES): 
    6270        SAML_ATTRIBUTES.append(Attribute()) 
    6371        SAML_ATTRIBUTES[-1].name = name 
     
    6573        SAML_ATTRIBUTES[-1].friendlyName = friendlyName 
    6674        for val in vals: 
    67             SAML_ATTRIBUTES[-1].attributeValues.append(XSStringAttributeValue()) 
    68             SAML_ATTRIBUTES[-1].attributeValues[-1].value = val 
     75            if isinstance(val, tuple): 
     76                SAML_ATTRIBUTES[-1].attributeValues.append( 
     77                                                ESGFGroupRoleAttributeValue()) 
     78                SAML_ATTRIBUTES[-1].attributeValues[-1].value = val 
     79            else: 
     80                SAML_ATTRIBUTES[-1].attributeValues.append( 
     81                                                XSStringAttributeValue()) 
     82                SAML_ATTRIBUTES[-1].attributeValues[-1].value = val 
    6983 
    7084    del name, val, vals, format, friendlyName 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/integration/full_system/securityservices.ini

    r7517 r7698  
    377377 
    378378# Specialisation to incorporate ESG Group/Role type 
    379 saml.soapbinding.serialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.toXML 
     379saml.soapbinding.serialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.toXML 
    380380 
    381381saml.soapbinding.mountPath = /AttributeAuthority 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/attributeauthority/test_attributeauthority.py

    r7077 r7698  
    3737                                 StatusCode) 
    3838from ndg.saml.xml import XMLConstants 
    39 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     39from ndg.security.common.saml_utils.esgf import ESGFSamlNamespaces 
    4040 
    4141THIS_DIR = path.dirname(__file__) 
     
    139139        # Define queries for SAML attribute names 
    140140        attributeInterface.samlAttribute2SqlQuery_firstName = '"%s" "%s"' % ( 
    141             EsgSamlNamespaces.FIRSTNAME_ATTRNAME,                                                                
     141            ESGFSamlNamespaces.FIRSTNAME_ATTRNAME,                                                                
    142142            SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY) 
    143143             
    144144        setattr(attributeInterface,  
    145145                'samlAttribute2SqlQuery.lastName', 
    146                 "%s %s" % (EsgSamlNamespaces.LASTNAME_ATTRNAME, 
     146                "%s %s" % (ESGFSamlNamespaces.LASTNAME_ATTRNAME, 
    147147                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY)) 
    148148         
    149149        attributeInterface.samlAttribute2SqlQuery[ 
    150             EsgSamlNamespaces.EMAILADDRESS_ATTRNAME] = ( 
     150            ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME] = ( 
    151151                SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY) 
    152152         
     
    170170                 
    171171            'samlAttribute2SqlQuery.firstname': '"%s" "%s"' % ( 
    172                 EsgSamlNamespaces.FIRSTNAME_ATTRNAME, 
     172                ESGFSamlNamespaces.FIRSTNAME_ATTRNAME, 
    173173                SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY), 
    174174             
    175175            'samlAttribute2SqlQuery.blah': '"%s" "%s"' % ( 
    176                 EsgSamlNamespaces.LASTNAME_ATTRNAME, 
     176                ESGFSamlNamespaces.LASTNAME_ATTRNAME, 
    177177                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY), 
    178178         
    179179            'samlAttribute2SqlQuery.3': '%s "%s"' % ( 
    180             EsgSamlNamespaces.EMAILADDRESS_ATTRNAME, 
     180            ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME, 
    181181            SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY), 
    182182         
     
    195195        self.assert_( 
    196196            attributeInterface.samlAttribute2SqlQuery[ 
    197                 EsgSamlNamespaces.FIRSTNAME_ATTRNAME] == \ 
     197                ESGFSamlNamespaces.FIRSTNAME_ATTRNAME] == \ 
    198198            SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY) 
    199199         
     
    219219        self.assert_( 
    220220            attributeInterface.samlAttribute2SqlQuery[ 
    221                 EsgSamlNamespaces.EMAILADDRESS_ATTRNAME] == \ 
     221                ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME] == \ 
    222222            SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY) 
    223223 
     
    239239        attributeQuery.subject = Subject()   
    240240        attributeQuery.subject.nameID = NameID() 
    241         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     241        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    242242        attributeQuery.subject.nameID.value = \ 
    243243                                SQLAlchemyAttributeInterfaceTestCase.OPENID_URI 
    244244         
    245245        fnAttribute = Attribute() 
    246         fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
     246        fnAttribute.name = ESGFSamlNamespaces.FIRSTNAME_ATTRNAME 
    247247        fnAttribute.nameFormat = XSStringAttributeValue.DEFAULT_FORMAT 
    248248        fnAttribute.friendlyName = "FirstName" 
     
    251251     
    252252        lnAttribute = Attribute() 
    253         lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
     253        lnAttribute.name = ESGFSamlNamespaces.LASTNAME_ATTRNAME 
    254254        lnAttribute.nameFormat = XSStringAttributeValue.DEFAULT_FORMAT 
    255255        lnAttribute.friendlyName = "LastName" 
     
    258258     
    259259        emailAddressAttribute = Attribute() 
    260         emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
     260        emailAddressAttribute.name = ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME 
    261261        emailAddressAttribute.nameFormat = XSStringAttributeValue.DEFAULT_FORMAT 
    262262        emailAddressAttribute.friendlyName = "EmailAddress" 
     
    295295        # Define queries for SAML attribute names 
    296296        samlAttribute2SqlQuery = { 
    297             EsgSamlNamespaces.FIRSTNAME_ATTRNAME:  
     297            ESGFSamlNamespaces.FIRSTNAME_ATTRNAME:  
    298298                SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY, 
    299299             
    300             EsgSamlNamespaces.LASTNAME_ATTRNAME:  
     300            ESGFSamlNamespaces.LASTNAME_ATTRNAME:  
    301301                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY, 
    302302         
    303             EsgSamlNamespaces.EMAILADDRESS_ATTRNAME:  
     303            ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME:  
    304304                SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY, 
    305305         
     
    357357        attributeQuery.subject = Subject()   
    358358        attributeQuery.subject.nameID = NameID() 
    359         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     359        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    360360        attributeQuery.subject.nameID.value = \ 
    361361                                SQLAlchemyAttributeInterfaceTestCase.OPENID_URI 
    362362     
    363363        emailAddressAttribute = Attribute() 
    364         emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
     364        emailAddressAttribute.name = ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME 
    365365        emailAddressAttribute.nameFormat = "InvalidFormat" 
    366366        emailAddressAttribute.friendlyName = "EmailAddress" 
     
    399399        # Define queries for SAML attribute names 
    400400        samlAttribute2SqlQuery = { 
    401             EsgSamlNamespaces.FIRSTNAME_ATTRNAME:  
     401            ESGFSamlNamespaces.FIRSTNAME_ATTRNAME:  
    402402                SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY, 
    403403             
    404             EsgSamlNamespaces.LASTNAME_ATTRNAME:  
     404            ESGFSamlNamespaces.LASTNAME_ATTRNAME:  
    405405                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY, 
    406406         
    407             EsgSamlNamespaces.EMAILADDRESS_ATTRNAME:  
     407            ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME:  
    408408                SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY, 
    409409         
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_samlattributeauthorityclient.cfg

    r7164 r7698  
    3434saml.deserialise = ndg.saml.xml.etree:ResponseElementTree.fromXML 
    3535 
    36 [test05AttributeQuerySOAPBindingInterface] 
     36[test05AttributeQueryWithESGFAttributeType] 
     37uri = http://localhost:5000/AttributeAuthority/ 
     38subject = https://openid.localhost/philip.kershaw 
     39prefix = saml. 
     40saml.serialise = ndg.saml.xml.etree:AttributeQueryElementTree.toXML 
     41saml.deserialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.fromXML 
     42 
     43[test06AttributeQuerySOAPBindingInterface] 
    3744uri = http://localhost:5000/AttributeAuthority/ 
    3845subject = https://openid.localhost/philip.kershaw 
    3946 
    40 [test06AttributeQueryFromConfig] 
     47[test07AttributeQueryFromConfig] 
    4148uri = http://localhost:5000/AttributeAuthority/ 
    4249subject = https://openid.localhost/philip.kershaw 
     
    4855attributeQuery.queryAttributes.roles = urn:siteA:security:authz:1.0:attr, , http://www.w3.org/2001/XMLSchema#string 
    4956 
    50 [test07AttributeQuerySslSOAPBindingInterface] 
     57[test08AttributeQuerySslSOAPBindingInterface] 
    5158uri = https://localhost:5443/AttributeAuthority/ 
    5259subject = https://openid.localhost/philip.kershaw 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_samlattributeauthorityclient.py

    r7155 r7698  
    2828                                        AttributeQuerySOAPBinding,  
    2929                                        AttributeQuerySslSOAPBinding) 
    30 from ndg.security.common.saml_utils.esg import (EsgSamlNamespaces, 
    31                                                 EsgDefaultQueryAttributes) 
     30from ndg.security.common.saml_utils.esgf import (ESGFSamlNamespaces, 
     31                                                 ESGFDefaultQueryAttributes, 
     32                                                 ESGFGroupRoleAttributeValue) 
     33from ndg.security.common.saml_utils.esgf.xml.etree import ( 
     34                                        ESGFGroupRoleAttributeValueElementTree, 
     35                                        ESGFResponseElementTree) 
     36from ndg.security.common.utils.etree import prettyPrint 
    3237from ndg.security.test.unit.attributeauthorityclient import \ 
    3338                                        AttributeAuthorityClientBaseTestCase 
    34 from ndg.security.common.utils.etree import prettyPrint 
    35  
     39    
    3640    
    3741class AttributeAuthoritySAMLInterfaceTestCase( 
     
    6468        attributeQuery.subject = Subject() 
    6569        attributeQuery.subject.nameID = NameID() 
    66         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     70        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    6771        attributeQuery.subject.nameID.value = _cfg['subject'] 
    6872        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
    6973                                        XSStringAttributeValue.TYPE_LOCAL_NAME 
    7074        fnAttribute = Attribute() 
    71         fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
     75        fnAttribute.name = ESGFSamlNamespaces.FIRSTNAME_ATTRNAME 
    7276        fnAttribute.nameFormat = xsStringNs 
    7377        fnAttribute.friendlyName = "FirstName" 
     
    7680     
    7781        lnAttribute = Attribute() 
    78         lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
     82        lnAttribute.name = ESGFSamlNamespaces.LASTNAME_ATTRNAME 
    7983        lnAttribute.nameFormat = xsStringNs 
    8084        lnAttribute.friendlyName = "LastName" 
     
    8387     
    8488        emailAddressAttribute = Attribute() 
    85         emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
     89        emailAddressAttribute.name = ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME 
    8690        emailAddressAttribute.nameFormat = xsStringNs 
    8791        emailAddressAttribute.friendlyName = "emailAddress" 
     
    132136        attributeQuery.subject = Subject()   
    133137        attributeQuery.subject.nameID = NameID() 
    134         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     138        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    135139        attributeQuery.subject.nameID.value = _cfg['subject'] 
    136140        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
     
    172176        attributeQuery.subject = Subject()   
    173177        attributeQuery.subject.nameID = NameID() 
    174         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     178        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    175179        attributeQuery.subject.nameID.value = _cfg['subject'] 
    176180        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
     
    212216        attributeQuery.subject = Subject()   
    213217        attributeQuery.subject.nameID = NameID() 
    214         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     218        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    215219        attributeQuery.subject.nameID.value = _cfg['subject'] 
    216220        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
     
    238242        self.assert_(response.status.statusCode.value==\ 
    239243                     StatusCode.INVALID_ATTR_NAME_VALUE_URI) 
    240          
    241     def test05AttributeQuerySOAPBindingInterface(self): 
    242         _cfg = self.cfg['test05AttributeQuerySOAPBindingInterface'] 
     244              
     245    def test05AttributeQueryWithESGFAttributeType(self): 
     246        # Test interface with custom ESGF Group/Role attribute type 
     247        thisSection = 'test05AttributeQueryWithESGFAttributeType' 
     248        _cfg = self.cfg[thisSection] 
     249         
     250        attributeQuery = AttributeQuery() 
     251        attributeQuery.version = SAMLVersion(SAMLVersion.VERSION_20) 
     252        attributeQuery.id = str(uuid4()) 
     253        attributeQuery.issueInstant = datetime.utcnow() 
     254         
     255        attributeQuery.issuer = Issuer() 
     256        attributeQuery.issuer.format = Issuer.X509_SUBJECT 
     257        attributeQuery.issuer.value = "/CN=Authorisation Service/O=Site A"     
     258                         
     259        attributeQuery.subject = Subject()   
     260        attributeQuery.subject.nameID = NameID() 
     261        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
     262        attributeQuery.subject.nameID.value = _cfg['subject'] 
     263         
     264        groupRoleAttribute = Attribute() 
     265        groupRoleAttribute.name = 'urn:esg:sitea:grouprole' 
     266        groupRoleAttribute.nameFormat = \ 
     267            ESGFGroupRoleAttributeValue.TYPE_LOCAL_NAME 
     268         
     269        attributeQuery.attributes.append(groupRoleAttribute)  
     270 
     271        binding = SOAPBinding.fromConfig( 
     272                     AttributeAuthoritySAMLInterfaceTestCase.CONFIG_FILEPATH,  
     273                     prefix='saml.', 
     274                     section=thisSection) 
     275         
     276        response = binding.send(attributeQuery, _cfg['uri']) 
     277         
     278        samlResponseElem = ResponseElementTree.toXML(response) 
     279         
     280        print("SAML Response ...") 
     281        print(ElementTree.tostring(samlResponseElem)) 
     282        print("Pretty print SAML Response ...") 
     283        print(prettyPrint(samlResponseElem)) 
     284         
     285        self.assert_(response.assertions[0].attributeStatements[0].attributes[0 
     286            ].attributeValues[0].value == ('siteagroup', 'default')) 
     287         
     288        self.assert_(response.status.statusCode.value == StatusCode.SUCCESS_URI) 
     289        
     290    def test06AttributeQuerySOAPBindingInterface(self): 
     291        _cfg = self.cfg['test06AttributeQuerySOAPBindingInterface'] 
    243292         
    244293        binding = AttributeQuerySOAPBinding() 
    245294         
    246295        binding.subjectID = AttributeAuthoritySAMLInterfaceTestCase.OPENID_URI 
    247         binding.subjectIdFormat = EsgSamlNamespaces.NAMEID_FORMAT 
     296        binding.subjectIdFormat = ESGFSamlNamespaces.NAMEID_FORMAT 
    248297        binding.issuerName = \ 
    249298            str(AttributeAuthoritySAMLInterfaceTestCase.VALID_REQUESTOR_IDS[0]) 
    250299        binding.issuerFormat = Issuer.X509_SUBJECT 
    251300         
    252         binding.queryAttributes = EsgDefaultQueryAttributes.ATTRIBUTES 
     301        binding.queryAttributes = ESGFDefaultQueryAttributes.ATTRIBUTES 
    253302         
    254303        response = binding.send(uri=_cfg['uri']) 
     
    262311        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI) 
    263312 
    264     def test06AttributeQueryFromConfig(self): 
    265         thisSection = 'test06AttributeQueryFromConfig' 
     313    def test07AttributeQueryFromConfig(self): 
     314        thisSection = 'test07AttributeQueryFromConfig' 
    266315        _cfg = self.cfg[thisSection] 
    267316         
     
    280329        self.assert_(response.status.statusCode.value==StatusCode.SUCCESS_URI) 
    281330         
    282     def test07AttributeQuerySslSOAPBindingInterface(self): 
    283         thisSection = 'test07AttributeQuerySslSOAPBindingInterface' 
     331    def test08AttributeQuerySslSOAPBindingInterface(self): 
     332        thisSection = 'test08AttributeQuerySslSOAPBindingInterface' 
    284333        _cfg = self.cfg[thisSection] 
    285334         
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/authz/xacml/saml_ctx_handler.cfg

    r7339 r7698  
    2121saml_ctx_handler.issuerFormat = urn:oasis:names:tc:SAML:1.1:nameid-format:x509SubjectName 
    2222saml_ctx_handler.assertionLifetime = 86400 
     23 
     24# Add Earth System Grid custom types and functions to XACML 
     25saml_ctx_handler.xacmlExtFunc = ndg.security.server.xacml.esgf_ext:addEsgfXacmlSupport 
    2326 
    2427# 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/authz/xacml/saml_pip.cfg

    r7358 r7698  
    2323saml_pip.sessionCacheDataDir = %(here)s/query-results-cache 
    2424 
     25# Timeout cache in 30mins 
     26saml_pip.sessionCacheTimeout = 1800 
     27 
    2528# The attribute ID of the subject value to extract from the XACML request 
    2629# context and pass in the SAML attribute query 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/authz/xacml/test_saml_ctx_handler.py

    r7339 r7698  
    5656        self.assert_(handler.issuerFormat) 
    5757        self.assert_(handler.assertionLifetime) 
     58        self.assert_(handler.xacmlExtFunc) 
     59         
    5860         
    5961if __name__ == "__main__": 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/authz/xacml/test_saml_pip.py

    r7517 r7698  
    5959         
    6060        setattr(pip, 'sessionCacheDataDir', 'My data dir') 
     61        self.assert_(pip.sessionCacheDataDir == 'My data dir') 
     62        self.assert_(pip.sessionCacheTimeout is None) 
     63         
     64        try: 
     65            pip.sessionCacheTimeout = {} 
     66            self.fail("pip.sessionCacheTimeout accepts only float/int/long/" 
     67                      "string or None type value") 
     68        except TypeError: 
     69            pass 
     70         
     71        pip.sessionCacheTimeout = 86400L 
     72        self.assert_(pip.sessionCacheTimeout == 86400L) 
    6173 
    6274    def test02ReadMappingFile(self): 
     
    6981        print(pip.attribute2AttributeAuthorityMap) 
    7082         
    71     def _createXacmlRequestCtx(self): 
     83    @classmethod 
     84    def _createXacmlRequestCtx(cls): 
     85        """Helper to create a XACML request context""" 
    7286        ctx = Request() 
    7387         
     
    7589        openidAttr = Attribute() 
    7690        ctx.subjects[-1].attributes.append(openidAttr) 
    77         openidAttr.attributeId = self.__class__.OPENID_ATTR_ID 
     91        openidAttr.attributeId = cls.OPENID_ATTR_ID 
    7892        openidAttr.dataType = 'http://www.w3.org/2001/XMLSchema#anyURI' 
    7993         
    80         anyUriAttrValue = self.__class__.attributeValueClassFactory( 
    81                                                             openidAttr.dataType) 
     94        anyUriAttrValue = cls.attributeValueClassFactory(openidAttr.dataType) 
    8295         
    83         openidAttrVal = anyUriAttrValue(self.__class__.OPENID_URI) 
     96        openidAttrVal = anyUriAttrValue(cls.OPENID_URI) 
    8497        openidAttr.attributeValues.append(openidAttrVal)  
    8598         
    8699        return ctx 
    87100     
    88     def _createPIP(self):    
     101    @classmethod 
     102    def _createPIP(cls):    
    89103        """Create PIP from test attribute settings"""               
    90104        pip = PIP() 
    91         pip.mappingFilePath = self.__class__.MAPPING_FILEPATH 
     105        pip.mappingFilePath = cls.MAPPING_FILEPATH 
    92106        pip.readMappingFile() 
    93         pip.subjectAttributeId = self.__class__.OPENID_ATTR_ID 
     107        pip.subjectAttributeId = cls.OPENID_ATTR_ID 
    94108         
    95109        pip.attributeQueryBinding.issuerName = \ 
    96             'O=NDG, OU=Security, CN=localhost' 
     110                                            'O=NDG, OU=Security, CN=localhost' 
    97111        pip.attributeQueryBinding.issuerFormat = SamlIssuer.X509_SUBJECT 
    98         pip.attributeQueryBinding.sslCertFilePath = \ 
    99             self.__class__.CLNT_CERT_FILEPATH 
    100         pip.attributeQueryBinding.sslPriKeyFilePath = \ 
    101             self.__class__.CLNT_PRIKEY_FILEPATH 
     112        pip.attributeQueryBinding.sslCertFilePath = cls.CLNT_CERT_FILEPATH 
     113        pip.attributeQueryBinding.sslPriKeyFilePath = cls.CLNT_PRIKEY_FILEPATH 
    102114             
    103         pip.attributeQueryBinding.sslCACertDir = self.__class__.CACERT_DIR 
     115        pip.attributeQueryBinding.sslCACertDir = cls.CACERT_DIR 
    104116         
    105117        return pip 
    106118 
    107     def _createSubjectAttributeDesignator(self): 
     119    @classmethod 
     120    def _createSubjectAttributeDesignator(cls): 
    108121        '''Make attribute designator - in practice this would be passed back  
    109122        from the PDP via the context handler 
    110123        ''' 
    111124        designator = SubjectAttributeDesignator() 
    112         designator.attributeId = self.__class__.NDGS_ATTR_ID 
     125        designator.attributeId = cls.NDGS_ATTR_ID 
    113126        designator.dataType = 'http://www.w3.org/2001/XMLSchema#string' 
    114127         
    115         stringAttrValue = self.__class__.attributeValueClassFactory( 
     128        stringAttrValue = cls.attributeValueClassFactory( 
    116129                                    'http://www.w3.org/2001/XMLSchema#string') 
    117130         
    118131        return designator 
    119132     
    120     def _initQuery(self): 
     133    @classmethod 
     134    def _initQuery(cls): 
    121135        '''Convenience method to set-up the parameters needed for a query''' 
    122         pip = self._createPIP() 
    123         designator = self._createSubjectAttributeDesignator() 
    124         ctx = self._createXacmlRequestCtx() 
     136        pip = cls._createPIP() 
     137        designator = cls._createSubjectAttributeDesignator() 
     138        ctx = cls._createXacmlRequestCtx() 
    125139        return pip, designator, ctx 
    126140     
     
    129143                    port=self.__class__.SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM) 
    130144         
    131         pip, designator, ctx = self._initQuery() 
     145        pip, designator, ctx = self.__class__._initQuery() 
    132146         
    133147        # Avoid caching to avoid impacting other tests in this class 
     
    144158        pip = PIP.fromConfig(self.__class__.CONFIG_FILEPATH) 
    145159        self.assert_(pip.mappingFilePath) 
     160        self.assert_(pip.sessionCacheTimeout == 1800) 
    146161         
    147162# TODO: fix test - left out for now because can't get threading to correctly  
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/test_saml_attribute_assertion.py

    r7517 r7698  
    1919import unittest 
    2020 
    21 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     21from ndg.security.common.saml_utils.esgf import ESGFSamlNamespaces 
    2222from ndg.security.test.unit import BaseTestCase 
    2323from ndg.security.server.myproxy.certificate_extapp.saml_attribute_assertion \ 
     
    5353                                        "/CN=Authorisation Service/O=Site A" 
    5454        myProxyCertExtApp.attributeQuery.subjectIdFormat = \ 
    55                                         EsgSamlNamespaces.NAMEID_FORMAT                                 
     55                                        ESGFSamlNamespaces.NAMEID_FORMAT                                 
    5656        myProxyCertExtApp.attributeQuery.subjectID = \ 
    5757                                        CertExtAppTestCase.OPENID_URI 
     
    8686 
    8787        myProxyCertExtApp.attributeQuery.subjectIdFormat = \ 
    88                                         EsgSamlNamespaces.NAMEID_FORMAT                                         
     88                                        ESGFSamlNamespaces.NAMEID_FORMAT                                         
    8989        myProxyCertExtApp.attributeQuery.sslCACertDir = \ 
    9090                                                CertExtAppTestCase.CACERT_DIR 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/attributeauthority/test.ini

    r7077 r7698  
    4646 
    4747# Specialisation to incorporate ESG Group/Role type 
    48 saml.soapbinding.serialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.toXML 
     48saml.soapbinding.serialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.toXML 
    4949 
    5050saml.soapbinding.pathMatchList = /AttributeAuthority 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/attribute-interface.ini

    r7153 r7698  
    2828 
    2929# Specialisation to incorporate ESG Group/Role type 
    30 saml.serialise = ndg.security.common.saml_utils.esg.xml.etree:EsgResponseElementTree.toXML 
     30saml.serialise = ndg.security.common.saml_utils.esgf.xml.etree:ESGFResponseElementTree.toXML 
    3131 
    3232#______________________________________________________________________________ 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/policy.xml

    r7444 r7698  
    9696        </Condition> 
    9797    </Rule> 
     98    <Rule RuleId="Rule with ESGF Custom types" Effect="Permit"> 
     99        <Target> 
     100            <Resources> 
     101                <Resource> 
     102                    <ResourceMatch MatchId="urn:oasis:names:tc:xacml:2.0:function:anyURI-regexp-match"> 
     103                        <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#anyURI">^http://localhost/test_esgf$</AttributeValue> 
     104                        <ResourceAttributeDesignator 
     105                            AttributeId="urn:siteA:security:authz:1.0:attr:resourceURI" 
     106                            DataType="http://www.w3.org/2001/XMLSchema#anyURI"/> 
     107                    </ResourceMatch> 
     108                </Resource> 
     109            </Resources> 
     110        </Target> 
     111        <Condition> 
     112            <Apply FunctionId="urn:esg:security:xacml:2.0:function:grouprole-at-least-one-member-of"> 
     113                <SubjectAttributeDesignator  
     114                    AttributeId="urn:ndg:security:authz:1.0:attr"  
     115                    DataType="grouprole"/> 
     116                <Apply FunctionId="urn:esg:security:xacml:2.0:function:grouprole-bag"> 
     117                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">forbidden</AttributeValue> 
     118                    <AttributeValue DataType="http://www.w3.org/2001/XMLSchema#string">keepout</AttributeValue> 
     119                </Apply> 
     120            </Apply> 
     121        </Condition> 
     122    </Rule> 
    98123</Policy> 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/test_soapattributeinterface.py

    r7077 r7698  
    2222 
    2323from ndg.security.common.soap.etree import SOAPEnvelope 
    24 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     24from ndg.security.common.saml_utils.esgf import ESGFSamlNamespaces 
    2525from ndg.security.test.unit.wsgi.saml import SoapSamlInterfaceMiddlewareTestCase 
    2626 
     
    4444        attributeQuery.subject = Subject()   
    4545        attributeQuery.subject.nameID = NameID() 
    46         attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     46        attributeQuery.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    4747        attributeQuery.subject.nameID.value = subject 
    4848                                     
     
    5050        # special case handling for 'FirstName' attribute 
    5151        fnAttribute = Attribute() 
    52         fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
     52        fnAttribute.name = ESGFSamlNamespaces.FIRSTNAME_ATTRNAME 
    5353        fnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    5454        fnAttribute.friendlyName = "FirstName" 
     
    5858        # special case handling for 'LastName' attribute 
    5959        lnAttribute = Attribute() 
    60         lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
     60        lnAttribute.name = ESGFSamlNamespaces.LASTNAME_ATTRNAME 
    6161        lnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    6262        lnAttribute.friendlyName = "LastName" 
     
    6666        # special case handling for 'LastName' attribute 
    6767        emailAddressAttribute = Attribute() 
    68         emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
     68        emailAddressAttribute.name = ESGFSamlNamespaces.EMAILADDRESS_ATTRNAME 
    6969        emailAddressAttribute.nameFormat = XMLConstants.XSD_NS+"#"+\ 
    7070                                    XSStringAttributeValue.TYPE_LOCAL_NAME 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/test_soapauthzdecisioninterface.py

    r7153 r7698  
    2222 
    2323from ndg.security.common.soap.etree import SOAPEnvelope 
    24 from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
     24from ndg.security.common.saml_utils.esgf import ESGFSamlNamespaces 
    2525from ndg.security.test.unit.wsgi.saml import SoapSamlInterfaceMiddlewareTestCase 
    2626 
     
    115115        query.subject = Subject()   
    116116        query.subject.nameID = NameID() 
    117         query.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
     117        query.subject.nameID.format = ESGFSamlNamespaces.NAMEID_FORMAT 
    118118        query.subject.nameID.value = subject 
    119119                                  
Note: See TracChangeset for help on using the changeset viewer.