Changeset 5982


Ignore:
Timestamp:
09/11/09 14:28:29 (10 years ago)
Author:
pjkersha
Message:
  • SQLAlchemyAttributeInterface complete and tested.
  • Moved ESG specific SAML types out of saml egg and into ndg.security.common.saml.esg
Location:
TI12-security/trunk/python
Files:
5 added
11 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security_saml/saml/saml2/core.py

    r5738 r5982  
    10931093 
    10941094    value = property(fget=_getValue, fset=_setValue, doc="string value")   
    1095      
    1096  
    1097 # TODO: Move this class out of the SAML package back into ndg.security.common 
    1098 class XSGroupRoleAttributeValue(AttributeValue):  
    1099     '''ESG Specific Group/Role attribute value.  ESG attribute permissions are 
    1100     organised into group/role pairs 
    1101     ''' 
    1102     DEFAULT_NS = "http://www.earthsystemgrid.org" 
    1103     DEFAULT_PREFIX = "esg" 
    1104     TYPE_LOCAL_NAME = "groupRole" 
    1105      
    1106     GROUP_ATTRIB_NAME = "group" 
    1107     ROLE_ATTRIB_NAME = "role" 
    1108      
    1109     # QName of the XSI type 
    1110     TYPE_NAME = QName(DEFAULT_NS,  
    1111                       TYPE_LOCAL_NAME,  
    1112                       DEFAULT_PREFIX) 
    1113       
    1114     def __init__(self,  
    1115                  namespaceURI=DEFAULT_NS,  
    1116                  elementLocalName=TYPE_LOCAL_NAME,  
    1117                  namespacePrefix=DEFAULT_PREFIX): 
    1118         '''@param namespaceURI: the namespace the element is in 
    1119         @param elementLocalName: the local name of the XML element this Object  
    1120         represents 
    1121         @param namespacePrefix: the prefix for the given namespace''' 
    1122         self.__namespaceURI = namespaceURI 
    1123         self.__elementLocalName = elementLocalName 
    1124         self.__namespacePrefix = namespacePrefix 
    1125         self.__group = None 
    1126         self.__role = None         
    1127  
    1128     def _getNamespaceURI(self): 
    1129         return self.__namespaceURI 
    1130  
    1131     def _setNamespaceURI(self, value): 
    1132         if not isinstance(value, basestring): 
    1133             raise TypeError("Expecting %r type for namespaceURI got %r" % 
    1134                             (basestring, value.__class__)) 
    1135         self.__namespaceURI = value 
    1136  
    1137     def _getElementLocalName(self): 
    1138         return self.__elementLocalName 
    1139  
    1140     def _setElementLocalName(self, value): 
    1141         if not isinstance(value, basestring): 
    1142             raise TypeError("Expecting %r type for elementLocalName got %r" % 
    1143                             (basestring, value.__class__)) 
    1144         self.__elementLocalName = value 
    1145  
    1146     def _getNamespacePrefix(self): 
    1147         return self.__namespacePrefix 
    1148  
    1149     def _setNamespacePrefix(self, value): 
    1150         if not isinstance(value, basestring): 
    1151             raise TypeError("Expecting %r type for namespacePrefix got %r" % 
    1152                             (basestring, value.__class__)) 
    1153         self.__namespacePrefix = value 
    1154  
    1155     namespaceURI = property(fget=_getNamespaceURI,  
    1156                             fset=_setNamespaceURI,  
    1157                             doc="the namespace the element is in") 
    1158  
    1159     elementLocalName = property(fget=_getElementLocalName,  
    1160                                 fset=_setElementLocalName,  
    1161                                 doc="the local name of the XML element this " 
    1162                                     "Object represents") 
    1163  
    1164     namespacePrefix = property(fget=_getNamespacePrefix,  
    1165                                fset=_setNamespacePrefix,  
    1166                                doc="the prefix for the given namespace") 
    1167  
    1168     def _getGroup(self): 
    1169         return self.__group 
    1170       
    1171     def _setGroup(self, group):  
    1172         self.__group = group 
    1173       
    1174     group = property(fget=_getGroup, fset=_setGroup) 
    1175       
    1176     def _getRole(self): 
    1177         return self.__role 
    1178       
    1179     def _setRole(self, role): 
    1180         self.__role = role 
    1181       
    1182     role = property(fget=_getRole, fset=_setRole) 
    1183  
    1184     def getOrderedChildren(self): 
    1185         # no children 
    1186         return None 
    11871095 
    11881096 
  • TI12-security/trunk/python/ndg_security_saml/saml/test/test_saml.py

    r5738 r5982  
    2121from xml.etree import ElementTree 
    2222 
    23 from saml.saml2.core import SAMLVersion, Attribute, AttributeStatement, \ 
    24     Assertion, AttributeQuery, Response, Issuer, Subject, NameID, StatusCode, \ 
    25     StatusMessage, Status, Conditions, XSStringAttributeValue, \ 
    26     XSGroupRoleAttributeValue 
     23from saml.saml2.core import (SAMLVersion, Attribute, AttributeStatement,  
     24                             Assertion, AttributeQuery, Response, Issuer,  
     25                             Subject, NameID, StatusCode,  
     26                             StatusMessage, Status, Conditions,  
     27                             XSStringAttributeValue) 
     28 
    2729from saml.common.xml import SAMLConstants 
    28 from saml.xml.etree import prettyPrint, AssertionElementTree, \ 
    29     XSGroupRoleAttributeValueElementTree, AttributeQueryElementTree, \ 
    30     ResponseElementTree 
     30from saml.xml.etree import (prettyPrint, AssertionElementTree,  
     31                            AttributeQueryElementTree, ResponseElementTree) 
    3132 
    3233 
     
    4445        self.emailAddress = None 
    4546         
    46         # ESG Group/Role attribute type 
    47         self.__groupRoleList = [] 
    4847        self.__miscAttrList = [] 
    49  
    50     def addGroupRole(self, group, role): 
    51         """Add an ESG Group/Role attribute 
    52         @type group: basestring 
    53         @param group: group name 
    54         @type role: basestring 
    55         @param role: role name 
    56         """ 
    57         self.__groupRoleList.append((group, role)) 
    5848     
    5949    def addAttribute(self, name, value): 
     
    158148            attributes.append(emailAddressAttribute) 
    159149         
    160         if len(self.__groupRoleList) > 0: 
    161             # custom group/role attribute to be added to attr statement 
    162             groupRoleAttribute = Attribute() 
    163             groupRoleAttribute.name = "GroupRole" 
    164             groupRoleAttribute.nameFormat = \ 
    165                                     XSGroupRoleAttributeValue.TYPE_LOCAL_NAME 
    166  
    167             for group, role in self.__groupRoleList: 
    168                 groupRole = XSGroupRoleAttributeValue() 
    169                 groupRole.group = group 
    170                 groupRole.role = role 
    171  
    172                 groupRoleAttribute.attributeValues.append(groupRole) 
    173              
    174             attributes.append(groupRoleAttribute) 
    175          
    176150        for name, value in self.__miscAttrList: 
    177151            attribute = Attribute() 
     
    211185            samlUtil.addAttribute("urn:badc:security:authz:1.0:attr", role) 
    212186         
    213         # ESG Group/Role type list 
    214         esgGroupRoleList = ( 
    215             ("ESG-NCAR", "admin"), 
    216             ("ESG-PCMDI", "testUser"), 
    217         ) 
    218         for group, role in esgGroupRoleList: 
    219             samlUtil.addGroupRole(group, role) 
    220          
    221187        # Make an assertion object 
    222188        assertion = samlUtil.buildAssertion() 
     
    227193          
    228194        assertion = self._createAssertionHelper() 
    229          
    230         # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    231         # Attribute Value factory to render the XML output 
    232         toXMLTypeMap = { 
    233             XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    234         } 
     195 
    235196         
    236197        # Create ElementTree Assertion Element 
    237         assertionElem = AssertionElementTree.toXML(assertion, 
    238                                             customToXMLTypeMap=toXMLTypeMap) 
     198        assertionElem = AssertionElementTree.toXML(assertion) 
    239199         
    240200        self.assert_(iselement(assertionElem)) 
     
    251211        assertion = self._createAssertionHelper() 
    252212         
    253         # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    254         # Attribute Value factory to render the XML output 
    255         toXMLTypeMap = { 
    256             XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    257         } 
    258          
    259213        # Create ElementTree Assertion Element 
    260         assertionElem = AssertionElementTree.toXML(assertion, 
    261                                             customToXMLTypeMap=toXMLTypeMap) 
     214        assertionElem = AssertionElementTree.toXML(assertion) 
    262215         
    263216        self.assert_(iselement(assertionElem)) 
     
    277230        elem2 = tree.getroot() 
    278231         
    279         toSAMLTypeMap = [XSGroupRoleAttributeValueElementTree.factoryMatchFunc] 
    280          
    281         assertion2 = AssertionElementTree.fromXML(elem2, 
    282                                             customToSAMLTypeMap=toSAMLTypeMap) 
     232        assertion2 = AssertionElementTree.fromXML(elem2) 
    283233        self.assert_(assertion2) 
    284         xsGroupRoleAttrFound = False 
    285         for attr in assertion2.attributeStatements[0].attributes: 
    286             for attrValue in attr.attributeValues: 
    287                 if isinstance(attrValue, XSGroupRoleAttributeValue): 
    288                     self.assert_(attrValue.group) 
    289                     self.assert_(attrValue.role) 
    290                     xsGroupRoleAttrFound = True 
    291          
    292         self.assert_(xsGroupRoleAttrFound) 
    293234         
    294235    def test03CreateAttributeQuery(self): 
     
    384325        response.assertions.append(assertion) 
    385326         
    386         # Add mapping for ESG Group/Role Attribute Value to enable ElementTree 
    387         # Attribute Value factory to render the XML output 
    388         toXMLTypeMap = { 
    389             XSGroupRoleAttributeValue: XSGroupRoleAttributeValueElementTree            
    390         } 
    391          
    392327        # Create ElementTree Assertion Element 
    393         responseElem = ResponseElementTree.toXML(response, 
    394                                             customToXMLTypeMap=toXMLTypeMap) 
     328        responseElem = ResponseElementTree.toXML(response) 
    395329         
    396330        self.assert_(iselement(responseElem)) 
  • TI12-security/trunk/python/ndg_security_saml/saml/xml/etree.py

    r5738 r5982  
    737737 
    738738 
    739 class XSGroupRoleAttributeValueElementTree(AttributeValueElementTreeBase, 
    740                                            XSGroupRoleAttributeValue): 
    741     """ElementTree XML representation of Earth System Grid custom Group/Role  
    742     Attribute Value"""  
    743  
    744     @classmethod 
    745     def toXML(cls, attributeValue): 
    746         """Create an XML representation of the input SAML ESG Group/Role type 
    747         Attribute Value 
    748          
    749         @type assertion: saml.saml2.core.XSGroupRoleAttributeValue 
    750         @param assertion: XSGroupRoleAttributeValue to be represented as an  
    751         ElementTree Element 
    752         @rtype: ElementTree.Element 
    753         @return: ElementTree Element 
    754         """ 
    755         elem = AttributeValueElementTreeBase.toXML(attributeValue) 
    756          
    757         if not isinstance(attributeValue, XSGroupRoleAttributeValue): 
    758             raise TypeError("Expecting %r type; got: %r" %  
    759                             (XSGroupRoleAttributeValue, type(attributeValue))) 
    760              
    761         ElementTree._namespace_map[attributeValue.namespaceURI 
    762                                    ] = attributeValue.namespacePrefix 
    763                                     
    764         tag = str(QName.fromGeneric(cls.TYPE_NAME))     
    765         groupRoleElem = ElementTree.Element(tag) 
    766         ElementTree._namespace_map[cls.DEFAULT_ELEMENT_NAME.namespaceURI 
    767                                    ] = cls.DEFAULT_ELEMENT_NAME.prefix  
    768          
    769         groupRoleElem.set(cls.GROUP_ATTRIB_NAME, attributeValue.group) 
    770         groupRoleElem.set(cls.ROLE_ATTRIB_NAME, attributeValue.role) 
    771  
    772         elem.append(groupRoleElem) 
    773          
    774         return elem 
    775  
    776     @classmethod 
    777     def fromXML(cls, elem): 
    778         """Parse ElementTree ESG Group/Role attribute element into a SAML  
    779         XSGroupRoleAttributeValue object 
    780          
    781         @type elem: ElementTree.Element 
    782         @param elem: Attribute value as ElementTree XML element 
    783         @rtype: saml.saml2.core.XSGroupRoleAttributeValue 
    784         @return: SAML ESG Group/Role Attribute value 
    785         """ 
    786          
    787         # Update namespace map for the Group/Role type referenced.   
    788         ElementTree._namespace_map[cls.DEFAULT_NS] = cls.DEFAULT_PREFIX 
    789          
    790         if not ElementTree.iselement(elem): 
    791             raise TypeError("Expecting %r input type for parsing; got %r" % 
    792                             (ElementTree.Element, elem)) 
    793  
    794         localName = QName.getLocalPart(elem.tag) 
    795         if localName != cls.DEFAULT_ELEMENT_LOCAL_NAME: 
    796             raise XMLTypeParseError("No \"%s\" element found" % 
    797                                     cls.DEFAULT_ELEMENT_LOCAL_NAME) 
    798                                     
    799         # Check for group/role child element 
    800         if len(elem) == 0: 
    801             raise XMLTypeParseError('Expecting "%s" child element to "%s" ' 
    802                                     'element' % (cls.TYPE_LOCAL_NAME, 
    803                                                cls.DEFAULT_ELEMENT_LOCAL_NAME)) 
    804          
    805         childElem = elem[0] 
    806         childLocalName = QName.getLocalPart(childElem.tag) 
    807         if childLocalName != cls.TYPE_LOCAL_NAME: 
    808             raise XMLTypeParseError("No \"%s\" element found" % 
    809                                     cls.TYPE_LOCAL_NAME) 
    810  
    811                                        
    812         attributeValue = XSGroupRoleAttributeValue() 
    813         groupName = childElem.attrib.get(cls.GROUP_ATTRIB_NAME) 
    814         if groupName is None: 
    815             raise XMLTypeParseError('No "%s" attribute found in Group/Role ' 
    816                                     'attribute element' %  
    817                                     cls.GROUP_ATTRIB_NAME) 
    818         attributeValue.group = groupName 
    819          
    820         roleName = childElem.attrib.get(cls.ROLE_ATTRIB_NAME) 
    821         if roleName is None: 
    822             raise XMLTypeParseError('No "%s" attribute found in Group/Role ' 
    823                                     'attribute element' %  
    824                                     cls.GROUP_ATTRIB_NAME) 
    825         attributeValue.role = roleName 
    826  
    827         return attributeValue 
    828      
    829     @classmethod 
    830     def factoryMatchFunc(cls, elem): 
    831         """Match function used by AttributeValueElementTreeFactory to 
    832         determine whether the given attribute is XSGroupRole type 
    833          
    834         @type elem: ElementTree.Element 
    835         @param elem: Attribute value as ElementTree XML element 
    836         @rtype: saml.saml2.core.XSGroupRoleAttributeValue or None 
    837         @return: SAML ESG Group/Role Attribute Value class if elem is an 
    838         Group/role type element or None if if doesn't match this type  
    839         """ 
    840          
    841         # Group/role element is a child of the AttributeValue element 
    842         if len(elem) == 0: 
    843             return None 
    844          
    845         childLocalName = QName.getLocalPart(elem[0].tag) 
    846         if childLocalName != cls.TYPE_LOCAL_NAME: 
    847             raise XMLTypeParseError('No "%s" child element found in ' 
    848                                     'AttributeValue' % cls.TYPE_LOCAL_NAME) 
    849                 
    850         if cls.GROUP_ATTRIB_NAME in elem[0].attrib and \ 
    851            cls.ROLE_ATTRIB_NAME in elem[0].attrib: 
    852             return cls 
    853  
    854         return None 
    855  
    856  
    857739class AttributeValueElementTreeFactory(object): 
    858740    """Class factory for AttributeValue ElementTree classes.  These classes are 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r5977 r5982  
    2929 
    3030from saml.utils import SAMLDateTime 
    31 from saml.saml2.core import (Response, Assertion, Attribute, AttributeValue,  
    32     AttributeStatement, SAMLVersion, Subject, NameID, Issuer, AttributeQuery,  
    33     XSStringAttributeValue, XSGroupRoleAttributeValue, Conditions, Status,  
    34     StatusCode, StatusMessage) 
    35      
    36 from saml.common.xml import SAMLConstants 
    37 from saml.xml.etree import (AssertionElementTree, AttributeQueryElementTree,  
    38     ResponseElementTree, XSGroupRoleAttributeValueElementTree) 
     31from saml.saml2.core import (Response, Assertion, Attribute, AttributeStatement, 
     32                             SAMLVersion, Subject, NameID, Issuer,  
     33                             AttributeQuery, XSStringAttributeValue, Conditions, 
     34                             Status, StatusCode, StatusMessage) 
    3935 
    4036from ndg.security.common.utils import TypedList 
     
    11111107            return samlResponse 
    11121108         
    1113         elif attributeQuery.subject.nameID.format != "urn:esg:openid": 
     1109        elif attributeQuery.subject.nameID.format != EsgSamlNamespaces.NAMEID_FORMAT: 
    11141110            log.error('SAML Attribute Query subject format is %r; expecting ' 
    11151111                      '%r' % (attributeQuery.subject.nameID.format, 
    1116                                 "urn:esg:openid")) 
     1112                                EsgSamlNamespaces.NAMEID_FORMAT)) 
    11171113            samlResponse.status.statusCode.value = StatusCode.REQUESTER_URI 
    11181114            samlResponse.status.statusMessage.value = \ 
     
    19091905    SAML_ASSERTION_LIFETIME_OPTNAME = 'samlAssertionLifetime' 
    19101906    SAML_ATTRIBUTE2SQLQUERY_OPTNAME = 'samlAttribute2SqlQuery' 
     1907    SAML_ATTRIBUTE2SQLQUERY_OPTNAME_LEN = len(SAML_ATTRIBUTE2SQLQUERY_OPTNAME) 
    19111908     
    19121909    SAML_ATTRIBUTE2SQLQUERY_ATTRNAME_DELIMITERS = ('.', '_') 
    1913     SAML_ATTRIBUTE2SQLQUERY_ATTRNAME_RE = re.compile('%s[%s]' %                                                    
    1914         (SAML_ATTRIBUTE2SQLQUERY_OPTNAME, 
    1915          ''.join(SAML_ATTRIBUTE2SQLQUERY_ATTRNAME_DELIMITERS)) 
    1916     ) 
    19171910     
    19181911    __slots__ = ( 
     
    19611954        option name and values parsed from an ini file. 
    19621955        """ 
    1963         if name in SQLAlchemyAttributeInterface.__slots__: 
     1956        cls = SQLAlchemyAttributeInterface 
     1957         
     1958        if name in cls.__slots__: 
    19641959            object.__setattr__(self, name, value) 
     1960             
     1961        elif (name[cls.SAML_ATTRIBUTE2SQLQUERY_OPTNAME_LEN] in  
     1962              cls.SAML_ATTRIBUTE2SQLQUERY_ATTRNAME_DELIMITERS): 
     1963            # A special 'samlAttribute2SqlQuery[._]+' attribute name has been  
     1964            # found.  The first item is the attribute name and the second, the 
     1965            # corresponding SQL query to get the values corresponding to that 
     1966            # name.             
     1967            samlAttributeName, samlAttributeSqlQuery = value.split(None, 1) 
     1968             
     1969            # Items may be quoted with " quotes 
     1970            self.__samlAttribute2SqlQuery[samlAttributeName.strip('"') 
     1971                                          ] = samlAttributeSqlQuery.strip('"') 
    19651972        else: 
    1966             r = SQLAlchemyAttributeInterface.SAML_ATTRIBUTE2SQLQUERY_ATTRNAME_RE 
    1967             attributeNameSplit = r.split(name) 
    1968             if len(attributeNameSplit) == 2: 
    1969                 # A special 'samlAttribute2SqlQuery*' attribute name has been  
    1970                 # found ...             
    1971                 samlAttributeName = attributeNameSplit[1] 
    1972                 self.__samlAttribute2SqlQuery[samlAttributeName] = value 
     1973            raise AttributeError("'SQLAlchemyAttributeInterface' has no " 
     1974                                 "attribute %r" % name) 
     1975 
     1976    def setProperties(self, prefix='', **properties): 
     1977        for name, val in properties.items(): 
     1978            if prefix: 
     1979                if name.startswith(prefix): 
     1980                    name = name.replace(prefix, '', 1) 
     1981                    setattr(self, name, val) 
    19731982            else: 
    1974                 raise AttributeError("'SQLAlchemyAttributeInterface' has no " 
    1975                                      "attribute %r" % name) 
    1976  
    1977     def setProperties(self, **properties): 
    1978         for name, val in properties.items(): 
    1979             setattr(self, name, val) 
     1983                setattr(self, name, val) 
    19801984             
    19811985    def _getSamlAssertionLifetime(self): 
     
    21962200        assertion.conditions.notBefore = assertion.issueInstant 
    21972201        assertion.conditions.notOnOrAfter = (assertion.conditions.notBefore +  
    2198                                 timedelta(seconds=self.samlAssertionLifetime)) 
     2202                                             self.samlAssertionLifetime) 
    21992203 
    22002204        assertion.subject = Subject() 
     
    22242228                attribute.friendlyName = requestedAttribute.friendlyName 
    22252229 
    2226             attribute.attributeValues.append(XSStringAttributeValue()) 
    22272230            for val in attributeVals: 
     2231                attribute.attributeValues.append(XSStringAttributeValue()) 
    22282232                attribute.attributeValues[-1].value = val 
    22292233 
     
    22682272            result = connection.execute(query) 
    22692273 
    2270         except exc.ProgrammingError: 
    2271             raise AttributeInterfaceRetrieveError("Error with SQL Syntax: %s" % 
    2272                                                   traceback.format_exc()) 
     2274        except (exc.ProgrammingError, exc.OperationalError): 
     2275            raise AttributeInterfaceRetrieveError('SQL error: %s' % 
     2276                                                  traceback.format_exc())  
    22732277        finally: 
    22742278            connection.close() 
     
    23212325            connection = dbEngine.connect() 
    23222326            result = connection.execute(query) 
    2323  
    2324         except exc.ProgrammingError: 
    2325             raise AttributeInterfaceRetrieveError("Error with SQL Syntax: " 
    2326                                                   "%s" % 
     2327             
     2328        except (exc.ProgrammingError, exc.OperationalError): 
     2329            raise AttributeInterfaceRetrieveError('SQL error: %s' % 
    23272330                                                  traceback.format_exc()) 
    23282331        finally: 
     
    23302333 
    23312334        try: 
    2332             attributeValues = [entry for entry in result][0] 
     2335            attributeValues = [entry[0] for entry in result] 
    23332336             
    23342337        except (IndexError, TypeError): 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r5953 r5982  
    3434    
    3535from ndg.security.common.saml.bindings import SOAPBinding as SamlSoapBinding 
     36from ndg.security.common.saml.esg import EsgSamlNamespaces 
    3637from ndg.security.common.X509 import X500DN 
    3738from ndg.security.server.wsgi.openid.provider import IdentityMapping 
     
    7475    N_ATTR_DESCR_ELEM_ITEMS = 3 
    7576    DEFAULT_ATTR_DESCR = ( 
    76         ("urn:esg:first:name", "FirstName", XSSTRING_NS), 
    77         ("urn:esg:last:name", "LastName", XSSTRING_NS), 
    78         ("urn:esg:email:address", "emailAddress", XSSTRING_NS), 
     77        (EsgSamlNamespaces.FIRSTNAME_ATTRNAME, "FirstName", XSSTRING_NS), 
     78        (EsgSamlNamespaces.LASTNAME_ATTRNAME, "LastName", XSSTRING_NS), 
     79        (EsgSamlNamespaces.EMAILADDRESS_ATTRNAME, "emailAddress", XSSTRING_NS), 
    7980    ) 
    80     ESG_NAME_ID_FORMAT = "urn:esg:openid" 
     81    ESG_NAME_ID_FORMAT = EsgSamlNamespaces.NAMEID_FORMAT 
    8182     
    8283    CONNECTION_STRING_OPTNAME = 'connectionString' 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/siteAUserRoles.py

    r5924 r5982  
    1515 
    1616 
    17 from ndg.security.server.attributeauthority import AttributeInterface, \ 
    18     InvalidRequestorId, AttributeNotKnownError, AttributeReleaseDenied, \ 
    19     UserIdNotKnown 
     17from ndg.security.server.attributeauthority import (AttributeInterface,  
     18                                                    InvalidRequestorId,  
     19                                                    AttributeNotKnownError,  
     20                                                    AttributeReleaseDenied,  
     21                                                    UserIdNotKnown) 
    2022from saml.common.xml import SAMLConstants 
    21 from saml.saml2.core import Response, Assertion, Attribute, AttributeValue, \ 
    22     AttributeStatement, SAMLVersion, Subject, NameID, Issuer, AttributeQuery, \ 
    23     XSStringAttributeValue, XSGroupRoleAttributeValue, Conditions, Status, \ 
    24     StatusCode 
     23from saml.saml2.core import (Assertion, Attribute, AttributeStatement,  
     24                             SAMLVersion, Subject, NameID,  
     25                             XSStringAttributeValue, Conditions) 
    2526 
    2627 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/__init__.py

    r5977 r5982  
    7575        'urn:siteA:security:authz:1.0:attr:rapid' 
    7676    ) 
     77    N_ATTRIBUTE_VALUES = len(ATTRIBUTE_VALUES) 
    7778     
    7879    def __init__(self, *arg, **kw): 
     
    192193        session = Session() 
    193194         
    194         for attrName in BaseTestCase.ATTRIBUTE_VALUES: 
    195             session.add(Attribute(BaseTestCase.USERNAME, attrName)) 
     195        attributes = [Attribute(BaseTestCase.USERNAME, attrVal) 
     196                      for attrVal in BaseTestCase.ATTRIBUTE_VALUES] 
     197        session.add_all(attributes) 
    196198             
    197199        user = User(BaseTestCase.USERNAME,  
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthority/test_attributeauthority.py

    r5977 r5982  
    248248                             Status, StatusMessage, StatusCode) 
    249249from saml.xml import XMLConstants 
     250from ndg.security.common.saml.esg import EsgSamlNamespaces 
    250251 
    251252 
     
    263264                              BaseTestCase.OPENID_URI_STEM) 
    264265         
    265     SAML_EMAILADDRESS_SQLQUERY = ("select emailaddress from users where '%s' || " 
    266                                   "openid_identifier = '${userId}'" % 
     266    SAML_EMAILADDRESS_SQLQUERY = ("select emailaddress from users where '%s' ||" 
     267                                  " openid_identifier = '${userId}'" % 
    267268                                  BaseTestCase.OPENID_URI_STEM) 
    268269         
    269     SAML_ATTRIBUTES_SQLQUERY = ("select attributename from attributes where " 
    270                                 "'%s' || openid_identifier = '${userId}'" % 
    271                                 BaseTestCase.OPENID_URI_STEM) 
     270    SAML_ATTRIBUTES_SQLQUERY = ("select attributename from attributes, users " 
     271                                "where '%s' || users.openid_identifier = " 
     272                                "'${userId}' and attributes.username = " 
     273                                "users.username" % BaseTestCase.OPENID_URI_STEM) 
     274#         
     275#    SAML_ATTRIBUTES_SQLQUERY = ("select attributename from attributes " 
     276#                                "where username = 'pjk'") 
    272277                                 
    273278    def __init__(self, *arg, **kw): 
     
    275280        self.skipTests = False 
    276281        try: 
    277             self._createDb() 
     282            import sqlalchemy 
    278283 
    279284        except NotImplementedError: 
     
    283288            self.skipTests = True 
    284289         
     290        if 'NDGSEC_AA_UNITTEST_DIR' not in os.environ: 
     291            os.environ['NDGSEC_AA_UNITTEST_DIR' 
     292                       ] = os.path.abspath(os.path.dirname(__file__)) 
     293             
     294        if not os.path.exists(mkPath('user.db')): 
     295            self._createDb() 
     296         
    285297    def test01TrySamlAttribute2SqlQuery__setattr__(self): 
    286298        if self.skipTests: 
     
    290302         
    291303        # Define queries for SAML attribute names 
    292         attributeInterface.samlAttribute2SqlQuery_firstName = \ 
    293             SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY 
    294              
    295         setattr(attributeInterface, 'samlAttribute2SqlQuery.lastName', 
    296             SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY) 
    297          
    298         attributeInterface.samlAttribute2SqlQuery['emailAddress'] = ( 
    299             SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY) 
    300          
    301         attributeInterface.samlAttribute2SqlQuery_attributes = ( 
     304        attributeInterface.samlAttribute2SqlQuery_firstName = '"%s" "%s"' % ( 
     305            EsgSamlNamespaces.FIRSTNAME_ATTRNAME,                                                                
     306            SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY) 
     307             
     308        setattr(attributeInterface,  
     309                'samlAttribute2SqlQuery.lastName', 
     310                "%s %s" % (EsgSamlNamespaces.LASTNAME_ATTRNAME, 
     311                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY)) 
     312         
     313        attributeInterface.samlAttribute2SqlQuery[ 
     314            EsgSamlNamespaces.EMAILADDRESS_ATTRNAME] = ( 
     315                SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY) 
     316         
     317        attributeInterface.samlAttribute2SqlQuery[ 
     318            SQLAlchemyAttributeInterfaceTestCase.ATTRIBUTE_NAMES[0]] = ( 
    302319            SQLAlchemyAttributeInterfaceTestCase.SAML_ATTRIBUTES_SQLQUERY) 
    303320         
     
    307324            return 
    308325         
     326        # samlAttribute2SqlQuery* suffixes have no particular requirement 
     327        # only that they are unique and start with an underscore or period. 
    309328        properties = { 
    310329            'connectionString':  
     
    314333                SQLAlchemyAttributeInterfaceTestCase.SAML_SUBJECT_SQLQUERY, 
    315334                 
    316             'samlAttribute2SqlQuery.urn:esg:first:name': 
    317                 SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY, 
    318              
    319             'samlAttribute2SqlQuery.urn:esg:last:name': 
    320                 SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY, 
    321          
    322             'samlAttribute2SqlQuery.urn:esg:first:email:address': 
    323                 SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY, 
    324          
    325             'samlAttribute2SqlQuery_attributes': 
    326                 SQLAlchemyAttributeInterfaceTestCase.SAML_ATTRIBUTES_SQLQUERY, 
     335            'samlAttribute2SqlQuery.firstname': '"%s" "%s"' % ( 
     336                EsgSamlNamespaces.FIRSTNAME_ATTRNAME, 
     337                SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY), 
     338             
     339            'samlAttribute2SqlQuery.blah': '"%s" "%s"' % ( 
     340                EsgSamlNamespaces.LASTNAME_ATTRNAME, 
     341                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY), 
     342         
     343            'samlAttribute2SqlQuery.3': '%s "%s"' % ( 
     344            EsgSamlNamespaces.EMAILADDRESS_ATTRNAME, 
     345            SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY), 
     346         
     347            'samlAttribute2SqlQuery_0': '%s %s' % ( 
     348                SQLAlchemyAttributeInterfaceTestCase.ATTRIBUTE_NAMES[0], 
     349                SQLAlchemyAttributeInterfaceTestCase.SAML_ATTRIBUTES_SQLQUERY), 
    327350             
    328351            'samlValidRequestorDNs': ('/O=STFC/OU=CEDA/CN=AuthorisationService', 
     
    334357        attributeInterface.setProperties(**properties) 
    335358         
    336         self.assert_(attributeInterface.samlAttribute2SqlQuery['firstName'] == \ 
     359        self.assert_( 
     360            attributeInterface.samlAttribute2SqlQuery[ 
     361                EsgSamlNamespaces.FIRSTNAME_ATTRNAME] == \ 
    337362            SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY) 
    338363         
     
    343368        attributeInterface2 = SQLAlchemyAttributeInterface(**properties) 
    344369        self.assert_(attributeInterface2.samlAssertionLifetime.days == 1) 
    345          
    346     def test03SamlAttributeQuery(self): 
     370 
     371    def test03FromConfigFile(self): 
     372        if self.skipTests: 
     373            return 
     374        cfgParser = CaseSensitiveConfigParser() 
     375        cfgFilePath = mkPath('test_sqlalchemyattributeinterface.cfg') 
     376        cfgParser.read(cfgFilePath) 
     377         
     378        cfg = dict(cfgParser.items('DEFAULT')) 
     379        attributeInterface = SQLAlchemyAttributeInterface() 
     380        attributeInterface.setProperties(prefix='attributeInterface.', **cfg) 
     381         
     382        self.assert_( 
     383            attributeInterface.samlAttribute2SqlQuery[ 
     384                EsgSamlNamespaces.EMAILADDRESS_ATTRNAME] == \ 
     385            SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY) 
     386 
     387    def test04SamlAttributeQuery(self): 
    347388        if self.skipTests: 
    348389            return 
     
    361402        attributeQuery.subject = Subject()   
    362403        attributeQuery.subject.nameID = NameID() 
    363         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     404        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    364405        attributeQuery.subject.nameID.value = \ 
    365406                                    "https://openid.localhost/philip.kershaw" 
    366407         
    367408        fnAttribute = Attribute() 
    368         fnAttribute.name = "urn:esg:first:name" 
     409        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
    369410        fnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    370411        fnAttribute.friendlyName = "FirstName" 
     
    373414     
    374415        lnAttribute = Attribute() 
    375         lnAttribute.name = "urn:esg:last:name" 
     416        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
    376417        lnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    377418        lnAttribute.friendlyName = "LastName" 
     
    380421     
    381422        emailAddressAttribute = Attribute() 
    382         emailAddressAttribute.name = "urn:esg:email:address" 
     423        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    383424        emailAddressAttribute.nameFormat = XMLConstants.XSD_NS+"#"+\ 
    384425                                    XSStringAttributeValue.TYPE_LOCAL_NAME 
     
    397438         
    398439        # Add the response - the interface will populate with an assertion as 
    399         # appropraite 
     440        # appropriate 
    400441        samlResponse = Response() 
    401442         
     
    419460        # Define queries for SAML attribute names 
    420461        samlAttribute2SqlQuery = { 
    421             'firstName':  
     462            EsgSamlNamespaces.FIRSTNAME_ATTRNAME:  
    422463                SQLAlchemyAttributeInterfaceTestCase.SAML_FIRSTNAME_SQLQUERY, 
    423464             
    424             'lastName':  
     465            EsgSamlNamespaces.LASTNAME_ATTRNAME:  
    425466                SQLAlchemyAttributeInterfaceTestCase.SAML_LASTNAME_SQLQUERY, 
    426467         
    427             'emailAddress':  
     468            EsgSamlNamespaces.EMAILADDRESS_ATTRNAME:  
    428469                SQLAlchemyAttributeInterfaceTestCase.SAML_EMAILADDRESS_SQLQUERY, 
    429470         
    430             'attributes':  
    431                 SQLAlchemyAttributeInterfaceTestCase.SAML_ATTRIBUTES_SQLQUERY,                                
     471            SQLAlchemyAttributeInterfaceTestCase.ATTRIBUTE_NAMES[0]:  
     472                SQLAlchemyAttributeInterfaceTestCase.SAML_ATTRIBUTES_SQLQUERY                     
    432473        } 
    433474         
     
    455496        self.assert_(samlResponse.assertions[0].subject.nameID.value == \ 
    456497                     attributeQuery.subject.nameID.value) 
     498        self.assert_( 
     499            samlResponse.assertions[0].attributeStatements[0].attributes[1 
     500                ].attributeValues[0].value == 'Kershaw') 
     501         
     502        self.assert_( 
     503            len(samlResponse.assertions[0].attributeStatements[0].attributes[3 
     504                ].attributeValues) == \ 
     505                    SQLAlchemyAttributeInterfaceTestCase.N_ATTRIBUTE_VALUES) 
    457506 
    458507         
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_attributeauthorityclient.py

    r5924 r5982  
    4343    
    4444from ndg.security.common.saml.bindings import SOAPBinding as SamlSoapBinding 
     45from ndg.security.common.saml.esg import EsgSamlNamespaces 
    4546 
    4647 
     
    322323        attributeQuery.subject = Subject()   
    323324        attributeQuery.subject.nameID = NameID() 
    324         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     325        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    325326        attributeQuery.subject.nameID.value = _cfg['subject'] 
    326327        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
    327328                                        XSStringAttributeValue.TYPE_LOCAL_NAME 
    328329        fnAttribute = Attribute() 
    329         fnAttribute.name = "urn:esg:first:name" 
     330        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
    330331        fnAttribute.nameFormat = xsStringNs 
    331332        fnAttribute.friendlyName = "FirstName" 
     
    334335     
    335336        lnAttribute = Attribute() 
    336         lnAttribute.name = "urn:esg:last:name" 
     337        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
    337338        lnAttribute.nameFormat = xsStringNs 
    338339        lnAttribute.friendlyName = "LastName" 
     
    341342     
    342343        emailAddressAttribute = Attribute() 
    343         emailAddressAttribute.name = "urn:esg:email:address" 
     344        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    344345        emailAddressAttribute.nameFormat = xsStringNs 
    345346        emailAddressAttribute.friendlyName = "emailAddress" 
     
    388389        attributeQuery.subject = Subject()   
    389390        attributeQuery.subject.nameID = NameID() 
    390         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     391        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    391392        attributeQuery.subject.nameID.value = _cfg['subject'] 
    392393        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
     
    426427        attributeQuery.subject = Subject()   
    427428        attributeQuery.subject.nameID = NameID() 
    428         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     429        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    429430        attributeQuery.subject.nameID.value = _cfg['subject'] 
    430431        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
     
    463464        attributeQuery.subject = Subject()   
    464465        attributeQuery.subject.nameID = NameID() 
    465         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     466        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    466467        attributeQuery.subject.nameID.value = _cfg['subject'] 
    467468        xsStringNs = SAMLConstants.XSD_NS+"#"+\ 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/saml/test_samlinterface.py

    r5977 r5982  
    2121from xml.etree import ElementTree 
    2222 
    23 from ndg.security.common.soap.etree import SOAPEnvelope 
    24 from ndg.security.common.utils.etree import QName, prettyPrint 
    25  
    2623from saml.saml2.core import (Response, Assertion, Attribute,  
    2724                             AttributeStatement, SAMLVersion, Subject, NameID, 
    2825                             Issuer, AttributeQuery, XSStringAttributeValue,  
    29                              XSGroupRoleAttributeValue, Conditions, Status,  
    30                              StatusCode) 
     26                             Conditions, Status, StatusCode) 
    3127from saml.xml import XMLConstants 
    32 from saml.xml.etree import (AttributeQueryElementTree, ResponseElementTree,  
    33                             XSGroupRoleAttributeValueElementTree) 
    34  
     28from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
     29 
     30from ndg.security.common.soap.etree import SOAPEnvelope 
     31from ndg.security.common.utils.etree import QName, prettyPrint 
     32from ndg.security.common.saml.esg import (EsgSamlNamespaces,  
     33                                          XSGroupRoleAttributeValue) 
     34from ndg.security.common.saml.esg.xml.etree import ( 
     35                                        XSGroupRoleAttributeValueElementTree) 
    3536 
    3637class SamlSoapBindingApp(object): 
     
    8283         
    8384        for attribute in attributeQuery.attributes: 
    84             if attribute.name == "urn:esg:first:name": 
     85            if attribute.name == EsgSamlNamespaces.FIRSTNAME_ATTRNAME: 
    8586                # special case handling for 'FirstName' attribute 
    8687                fnAttribute = Attribute() 
     
    9596                assertion.attributeStatements[0].attributes.append(fnAttribute) 
    9697             
    97             elif attribute.name == "urn:esg:last:name": 
     98            elif attribute.name == EsgSamlNamespaces.LASTNAME_ATTRNAME: 
    9899                lnAttribute = Attribute() 
    99100                lnAttribute.name = attribute.name 
     
    107108                assertion.attributeStatements[0].attributes.append(lnAttribute) 
    108109                
    109             elif attribute.name == "urn:esg:email:address": 
     110            elif attribute.name == EsgSamlNamespaces.EMAILADDRESS_ATTRNAME: 
    110111                emailAddressAttribute = Attribute() 
    111112                emailAddressAttribute.name = attribute.name 
     
    178179        attributeQuery.subject = Subject()   
    179180        attributeQuery.subject.nameID = NameID() 
    180         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     181        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    181182        attributeQuery.subject.nameID.value = \ 
    182183                                    "https://openid.localhost/philip.kershaw" 
     
    184185        # special case handling for 'FirstName' attribute 
    185186        fnAttribute = Attribute() 
    186         fnAttribute.name = "urn:esg:first:name" 
     187        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
    187188        fnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    188189        fnAttribute.friendlyName = "FirstName" 
     
    192193        # special case handling for 'LastName' attribute 
    193194        lnAttribute = Attribute() 
    194         lnAttribute.name = "urn:esg:last:name" 
     195        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
    195196        lnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    196197        lnAttribute.friendlyName = "LastName" 
     
    200201        # special case handling for 'LastName' attribute 
    201202        emailAddressAttribute = Attribute() 
    202         emailAddressAttribute.name = "urn:esg:email:address" 
     203        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    203204        emailAddressAttribute.nameFormat = XMLConstants.XSD_NS+"#"+\ 
    204205                                    XSStringAttributeValue.TYPE_LOCAL_NAME 
     
    270271        attributeQuery.subject = Subject()   
    271272        attributeQuery.subject.nameID = NameID() 
    272         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     273        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    273274        attributeQuery.subject.nameID.value = \ 
    274275                            "https://esg.prototype.ucar.edu/myopenid/testUser" 
     
    276277        # special case handling for 'FirstName' attribute 
    277278        fnAttribute = Attribute() 
    278         fnAttribute.name = "urn:esg:first:name" 
     279        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
    279280        fnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    280281        fnAttribute.friendlyName = "FirstName" 
     
    284285        # special case handling for 'LastName' attribute 
    285286        lnAttribute = Attribute() 
    286         lnAttribute.name = "urn:esg:last:name" 
     287        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
    287288        lnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    288289        lnAttribute.friendlyName = "LastName" 
     
    292293        # special case handling for 'LastName' attribute 
    293294        emailAddressAttribute = Attribute() 
    294         emailAddressAttribute.name = "urn:esg:email:address" 
     295        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    295296        emailAddressAttribute.nameFormat = XMLConstants.XSD_NS+"#"+\ 
    296297                                    XSStringAttributeValue.TYPE_LOCAL_NAME 
     
    338339            <saml:Issuer Format="urn:esg:issuer">ESG-NCAR</saml:Issuer> 
    339340            <saml:Subject> 
    340                <saml:NameID Format="urn:esg:openid">https://esg.prototype.ucar.edu/myopenid/testUser</saml:NameID> 
     341               <saml:NameID Format=EsgSamlNamespaces.NAMEID_FORMAT>https://esg.prototype.ucar.edu/myopenid/testUser</saml:NameID> 
    341342            </saml:Subject> 
    342343            <saml:Conditions NotBefore="2009-08-17T12:28:37.347Z" NotOnOrAfter="2009-08-18T12:28:37.347Z" /> 
     
    348349                  <saml:AttributeValue xsi:type="xs:string" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">User</saml:AttributeValue> 
    349350               </saml:Attribute> 
    350                <saml:Attribute FriendlyName="EmailAddress" Name="urn:esg:email:address" NameFormat="http://www.w3.org/2001/XMLSchema#string"> 
     351               <saml:Attribute FriendlyName="EmailAddress" Name="urn:esg:first:email:address" NameFormat="http://www.w3.org/2001/XMLSchema#string"> 
    351352                  <saml:AttributeValue xsi:type="xs:string" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">ejn@ucar.edu</saml:AttributeValue> 
    352353               </saml:Attribute> 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/test_soapattributeinterface.py

    r5924 r5982  
    1010__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1111__revision__ = '$Id$' 
    12 import logging 
    13  
    1412import unittest 
    1513import os 
     
    2119 
    2220from cStringIO import StringIO 
    23 from xml.etree import ElementTree 
     21 
     22from saml.saml2.core import (Attribute, SAMLVersion, Subject, NameID, Issuer,  
     23                             AttributeQuery, XSStringAttributeValue,  
     24                             StatusCode) 
     25from saml.xml import XMLConstants 
     26from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    2427 
    2528from ndg.security.common.soap.etree import SOAPEnvelope 
    2629from ndg.security.common.utils.etree import prettyPrint 
    27  
    28 from saml.saml2.core import Response, Assertion, Attribute, AttributeValue, \ 
    29     AttributeStatement, SAMLVersion, Subject, NameID, Issuer, AttributeQuery, \ 
    30     XSStringAttributeValue, XSGroupRoleAttributeValue, Conditions, Status, \ 
    31     StatusCode 
    32 from saml.xml import XMLConstants 
    33 from saml.xml.etree import AssertionElementTree, AttributeQueryElementTree, \ 
    34     ResponseElementTree, XSGroupRoleAttributeValueElementTree 
     30from ndg.security.common.saml.esg import EsgSamlNamespaces 
    3531   
    3632     
     
    7167        attributeQuery.subject = Subject()   
    7268        attributeQuery.subject.nameID = NameID() 
    73         attributeQuery.subject.nameID.format = "urn:esg:openid" 
     69        attributeQuery.subject.nameID.format = EsgSamlNamespaces.NAMEID_FORMAT 
    7470        attributeQuery.subject.nameID.value = subject 
    7571                                     
     
    7773        # special case handling for 'FirstName' attribute 
    7874        fnAttribute = Attribute() 
    79         fnAttribute.name = "urn:esg:first:name" 
     75        fnAttribute.name = EsgSamlNamespaces.FIRSTNAME_ATTRNAME 
    8076        fnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    8177        fnAttribute.friendlyName = "FirstName" 
     
    8581        # special case handling for 'LastName' attribute 
    8682        lnAttribute = Attribute() 
    87         lnAttribute.name = "urn:esg:last:name" 
     83        lnAttribute.name = EsgSamlNamespaces.LASTNAME_ATTRNAME 
    8884        lnAttribute.nameFormat = "http://www.w3.org/2001/XMLSchema#string" 
    8985        lnAttribute.friendlyName = "LastName" 
     
    9389        # special case handling for 'LastName' attribute 
    9490        emailAddressAttribute = Attribute() 
    95         emailAddressAttribute.name = "urn:esg:email:address" 
     91        emailAddressAttribute.name = EsgSamlNamespaces.EMAILADDRESS_ATTRNAME 
    9692        emailAddressAttribute.nameFormat = XMLConstants.XSD_NS+"#"+\ 
    9793                                    XSStringAttributeValue.TYPE_LOCAL_NAME 
Note: See TracChangeset for help on using the changeset viewer.