Changeset 6067


Ignore:
Timestamp:
30/11/09 16:30:24 (10 years ago)
Author:
pjkersha
Message:

Re-issue 1.3.3 release:

  • uses SQLAlchemy test user database for authz_lite integration tests
  • important fix for ndg.security.common.saml_utils.bindings.AttributeQuerySOAPBinding: set 'nameFormat' attribute not 'format' for attributes in AttributeQuery?.
Location:
TI12-security/trunk/python
Files:
11 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/saml_utils/bindings.py

    r6064 r6067  
    333333                (attribute.name,  
    334334                 attribute.friendlyName,  
    335                  attribute.format) = pat.split(value) 
     335                 attribute.nameFormat) = pat.split(value) 
    336336                  
    337337                self.queryAttributes.append(attribute) 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r6062 r6067  
    22692269            attribute.name = requestedAttribute.name 
    22702270             
    2271             # TODO: check name format requested - only XSString is currently 
     2271            # Check name format requested - only XSString is currently 
    22722272            # supported 
    22732273            if (requestedAttribute.nameFormat !=  
     
    23642364        queryTmpl = self.samlAttribute2SqlQuery.get(attributeName) 
    23652365        if queryTmpl is None: 
    2366             raise AttributeInterfaceConfigError('No SQL query set for attribute ' 
    2367                                                 '%r' % attributeName) 
     2366            raise AttributeInterfaceConfigError('No SQL query set for ' 
     2367                                                'attribute %r' % attributeName) 
    23682368         
    23692369        try: 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/sqlalchemy_authn.py

    r6064 r6067  
    203203            connection.close() 
    204204             
    205         nEntries = int([r[0] for r in result][0]) 
    206         if nEntries != 1: 
    207             raise AuthNInterfaceInvalidCredentials("Invalid password for user " 
    208                                                    "%r" % username) 
    209          
     205        try: 
     206            nEntries = int([r[0] for r in result][0]) 
     207             
     208        except (ValueError, TypeError), e: 
     209            raise AuthNInterfaceRetrieveError("Expecting integer count result " 
     210                                              "from login SQL query: %s" % 
     211                                              traceback.format_exc()) 
     212        if nEntries < 1: 
     213            raise AuthNInterfaceInvalidCredentials("Logon query %r: invalid " 
     214                                                   "password for user %r" %  
     215                                                   (query, username)) 
     216        elif nEntries > 1: 
     217            raise AuthNInterfaceInvalidCredentials("Logon: multiple entries " 
     218                                                   "returned for query %r" %  
     219                                                   query) 
     220             
    210221        log.debug('Logon succeeded for user %r' % username) 
    211222 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/csv.py

    r6064 r6067  
    3636        "attributeMap", 
    3737    ) 
    38     __slots__ += tuple(["__%s" % n for n in ATTR_NAMES]) 
     38    __slots__ = tuple(["__%s" % n for n in ATTR_NAMES]) 
    3939    del n 
    4040     
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/genshi/layout/ndg2.css

    r5984 r6067  
    8989#contentsRight  {border-left: 1px solid #3c78b5; margin-left:250px;} 
    9090 
    91 .error {display:block;text-align:center;padding:10px;} 
     91/* 
     92.error {display:block;text-align:left;padding:10px;} 
     93*/ 
     94.error {text-align:left;padding:10px;} 
    9295 
    9396/* The following is the css associated with pretty printing xml */ 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/genshi/templates/login.html

    r5984 r6067  
    3434            <div py:replace="loginForm()"/> 
    3535            </div> 
     36            <p>${c.xml}</p> 
    3637        <div py:replace="footer()"/> 
    3738    </body> 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/siteAUserRoles.py

    r6064 r6067  
    2525                                                    AttributeReleaseDenied,  
    2626                                                    UserIdNotKnown) 
     27from ndg.security.test.unit import BaseTestCase 
    2728 
    2829 
    2930class TestUserRoles(AttributeInterface): 
    3031    """Test User Roles class dynamic import for Attribute Authority""" 
    31     ATTRIBUTE_NAMES = ( 
    32         "urn:siteA:security:authz:1.0:attr", 
    33     ) 
    34      
    35     ATTRIBUTE_VALUES = ( 
    36         'urn:siteA:security:authz:1.0:attr:postdoc', 
    37         'urn:siteA:security:authz:1.0:attr:staff',  
    38         'urn:siteA:security:authz:1.0:attr:undergrad',  
    39         'urn:siteA:security:authz:1.0:attr:coapec', 
    40         'urn:siteA:security:authz:1.0:attr:rapid' 
    41     ) 
     32    ATTRIBUTE_NAMES = BaseTestCase.ATTRIBUTE_NAMES 
     33    ATTRIBUTE_VALUES = BaseTestCase.ATTRIBUTE_VALUES 
    4234 
    4335    SAML_ATTRIBUTE_NAMES = ATTRIBUTE_NAMES + ( 
     
    5547     
    5648    SAML_ATTRIBUTE_FRIENDLY_NAMES = ('',)*len(ATTRIBUTE_NAMES) + ( 
    57         "emailAddress", 
     49        "EmailAddress", 
    5850        "FirstName", 
    5951        "LastName" 
    6052    ) 
    6153    SAML_ATTRIBUTE_FORMATS = (SAMLConstants.XSD_NS+"#"+\ 
    62                             XSStringAttributeValue.TYPE_LOCAL_NAME,) * \ 
    63                             len(SAML_ATTRIBUTE_NAMES) 
     54                              XSStringAttributeValue.TYPE_LOCAL_NAME,) * \ 
     55                              len(SAML_ATTRIBUTE_NAMES) 
    6456    SAML_ATTRIBUTES = [] 
    6557     
     
    8274     
    8375    VALID_USER_IDS = ("https://openid.localhost/philip.kershaw", 
    84                       "https://localhost:7443/openid/PhilipKershaw") 
    85     VALID_REQUESTOR_IDS = ( 
    86         X500DN.fromString("/O=Site A/CN=Authorisation Service"),  
    87         X500DN.fromString("/O=Site B/CN=Authorisation Service"), 
    88         X500DN.fromString('/CN=test/O=NDG/OU=BADC') 
    89     ) 
     76                      BaseTestCase.OPENID_URI) 
     77    VALID_REQUESTOR_IDS = BaseTestCase.VALID_REQUESTOR_IDS 
    9078     
    9179    ISSUER_NAME = "/O=Site A/CN=Attribute Authority" 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r6063 r6067  
    2828attributeQueryInterfaceEnvironKeyName = ndg.security.server.attributeauthority.attributeQueryInterface 
    2929 
     30dbConnectionString = sqlite:///%(testConfigDir)s/user.db 
    3031 
    3132[server:main] 
     
    245246 
    246247# Basic Authentication interface to demonstrate capabilities 
    247 openid.provider.authNInterface=ndg.security.server.wsgi.openid.provider.authninterface.basic.BasicAuthNInterface 
     248#openid.provider.authNInterface=ndg.security.server.wsgi.openid.provider.authninterface.basic.BasicAuthNInterface 
     249openid.provider.authNInterface=ndg.security.server.wsgi.openid.provider.authninterface.sqlalchemy_authn.SQLAlchemyAuthnInterface 
     250openid.provider.authN.connectionString=%(dbConnectionString)s 
     251openid.provider.authN.logonSqlQuery=select count(*) from users where username = '${username}' and md5password = '${password}' 
     252openid.provider.authN.username2UserIdentifierSqlQuery=select openid_identifier from users where username = '${username}' 
     253openid.provider.authN.isMD5EncodedPwd=True 
    248254 
    249255# user login details format is: 
     
    261267 
    262268# Attribute Exchange interface 
    263 openid.provider.axResponse.class=ndg.security.server.wsgi.openid.provider.axinterface.csv.CSVFileAXInterface 
    264 openid.provider.axResponse.csvFilePath=%(here)s/openidprovider/attributeexchange.csv 
     269#openid.provider.axResponse.class=ndg.security.server.wsgi.openid.provider.axinterface.csv.CSVFileAXInterface 
     270#openid.provider.axResponse.csvFilePath=%(here)s/openidprovider/attributeexchange.csv 
     271openid.provider.axResponse.class=ndg.security.server.wsgi.openid.provider.axinterface.sqlalchemy_ax.SQLAlchemyAXInterface 
     272openid.provider.axResponse.connectionString=%(dbConnectionString)s 
     273openid.provider.axResponse.sqlQuery = select firstname, lastname, emailaddress from users where username = '${username}' 
    265274openid.provider.axResponse.attributeNames=http://openid.net/schema/namePerson/first 
    266275    http://openid.net/schema/namePerson/last 
     
    311320# Settings for custom AttributeInterface derived class to get user roles for given  
    312321# user ID 
    313 attributeAuthority.attributeInterface.modFilePath: %(testConfigDir)s/attributeauthority/sitea 
    314 attributeAuthority.attributeInterface.modName: siteAUserRoles 
    315 attributeAuthority.attributeInterface.className: TestUserRoles 
     322#attributeAuthority.attributeInterface.modFilePath: %(testConfigDir)s/attributeauthority/sitea 
     323#attributeAuthority.attributeInterface.modName: siteAUserRoles 
     324#attributeAuthority.attributeInterface.className: TestUserRoles 
     325 
     326# SQLAlchemy Attribute Interface 
     327attributeAuthority.attributeInterface.connectionString: %(dbConnectionString)s 
     328attributeAuthority.attributeInterface.modName: ndg.security.server.attributeauthority 
     329attributeAuthority.attributeInterface.className: SQLAlchemyAttributeInterface 
     330attributeAuthority.attributeInterface.issuerName = /O=Site A/CN=Attribute Authority 
     331attributeAuthority.attributeInterface.samlSubjectSqlQuery = select count(*) from users where openid = '${userId}' 
     332attributeAuthority.attributeInterface.samlAttribute2SqlQuery.1 = "urn:esg:first:name" "select firstname from users where openid = '${userId}'" 
     333attributeAuthority.attributeInterface.samlAttribute2SqlQuery.lastName = "urn:esg:last:name" "select lastname from users where openid = '${userId}'" 
     334attributeAuthority.attributeInterface.samlAttribute2SqlQuery.emailAddress = "urn:esg:email:address" "select emailaddress from users where openid = '${userId}'" 
     335attributeAuthority.attributeInterface.samlAttribute2SqlQuery.4 = "urn:siteA:security:authz:1.0:attr" "select attributename from attributes where openid = '${userId}'" 
     336attributeAuthority.attributeInterface.samlValidRequestorDNs = /O=Site A/CN=Authorisation Service,/O=Site A/CN=Attribute Authority, 
     337                                                           /O=Site B/CN=Authorisation Service,  
     338                                                           /CN=test/O=NDG/OU=BADC 
    316339 
    317340# Config for XML signature of Attribute Certificate 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservicesapp.py

    r6063 r6067  
    2929    else: 
    3030        port = 7443 
    31          
     31             
     32    # Initialise test user database 
     33    from ndg.security.test.unit import BaseTestCase 
     34    BaseTestCase.initDb() 
     35     
    3236    cfgFileName = INI_FILEPATH 
    3337    cfgFilePath = os.path.join(dirname(abspath(__file__)), cfgFileName)   
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/__init__.py

    r6052 r6067  
    1414import socket 
    1515logging.basicConfig() 
     16log = logging.getLogger(__name__) 
    1617 
    1718import os 
     
    2930mkDataDirPath = lambda file:join(TEST_CONFIG_DIR, file) 
    3031 
     32from ndg.security.common.X509 import X500DN 
    3133from ndg.security.test.unit.wsgi import PasteDeployAppServer 
    3234 
     
    101103    MD5_PASSWORD = md5(PASSWORD).hexdigest() 
    102104     
    103     OPENID_URI_STEM = 'https://openid.localhost/' 
     105    OPENID_URI_STEM = 'https://localhost:7443/openid/' 
    104106    OPENID_IDENTIFIER = 'philip.kershaw' 
    105107    OPENID_URI = OPENID_URI_STEM + OPENID_IDENTIFIER 
     
    122124    N_ATTRIBUTE_VALUES = len(ATTRIBUTE_VALUES) 
    123125     
    124     VALID_REQUESTOR_IDS = ("/O=Site A/CN=Authorisation Service",  
    125                            "/O=Site B/CN=Authorisation Service") 
     126    VALID_REQUESTOR_IDS = ( 
     127        X500DN.fromString("/O=Site A/CN=Authorisation Service"),  
     128        X500DN.fromString("/O=Site B/CN=Authorisation Service"), 
     129        X500DN.fromString('/CN=test/O=NDG/OU=BADC') 
     130    ) 
    126131     
    127132    SSL_PEM_FILENAME = 'localhost.pem' 
     
    202207                service.terminateThread() 
    203208  
    204     def initDb(self): 
     209    @classmethod 
     210    def initDb(cls): 
    205211        """Wrapper to _createDb - Create database only if it doesn't already  
    206212        exist""" 
    207         if not os.path.isfile(BaseTestCase.DB_FILEPATH): 
    208             self._createDb() 
    209              
    210     def _createDb(self): 
     213        if not os.path.isfile(cls.DB_FILEPATH): 
     214            cls._createDb() 
     215         
     216    @classmethod   
     217    def _createDb(cls): 
    211218        """Create a test SQLite database with SQLAlchemy for use with unit  
    212219        tests 
    213220        """ 
     221        log.debug("Creating database for %r ..." % cls.__name__) 
     222         
    214223        if not sqlAlchemyInstalled: 
    215224            raise NotImplementedError("SQLAlchemy must be installed in order " 
    216225                                      "for this method to be implemented") 
    217226             
    218         db = create_engine(BaseTestCase.DB_CONNECTION_STR) 
     227        db = create_engine(cls.DB_CONNECTION_STR) 
    219228         
    220229        metadata = MetaData() 
     
    231240        attributesTable = Table('attributes', metadata, 
    232241                                Column('id', Integer, primary_key=True), 
    233                                 Column('username', String), 
     242                                Column('openid', String), 
    234243                                Column('attributename', String)) 
    235244        metadata.create_all(db) 
     
    261270         
    262271            id = Column(Integer, primary_key=True) 
    263             username = Column('username', String(40)) 
     272            openid = Column('openid', String(128)) 
    264273            attributename = Column('attributename', String(40)) 
    265274         
    266             def __init__(self, username, attributename): 
    267                 self.username = username 
     275            def __init__(self, openid, attributename): 
     276                self.openid = openid 
    268277                self.attributename = attributename 
    269                  
     278 
    270279        Session = sessionmaker(bind=db) 
    271280        session = Session() 
    272281         
    273         attributes = [Attribute(BaseTestCase.USERNAME, attrVal) 
    274                       for attrVal in BaseTestCase.ATTRIBUTE_VALUES] 
     282        attributes = [Attribute(cls.OPENID_URI, attrVal) 
     283                      for attrVal in cls.ATTRIBUTE_VALUES] 
    275284        session.add_all(attributes) 
    276              
    277         user = User(BaseTestCase.USERNAME,  
    278                     BaseTestCase.MD5_PASSWORD, 
    279                     BaseTestCase.OPENID_URI, 
    280                     BaseTestCase.OPENID_IDENTIFIER, 
    281                     BaseTestCase.FIRSTNAME, 
    282                     BaseTestCase.LASTNAME, 
    283                     BaseTestCase.EMAILADDRESS) 
     285            
     286        user = User(cls.USERNAME,  
     287                    cls.MD5_PASSWORD, 
     288                    cls.OPENID_URI, 
     289                    cls.OPENID_IDENTIFIER, 
     290                    cls.FIRSTNAME, 
     291                    cls.LASTNAME, 
     292                    cls.EMAILADDRESS) 
    284293         
    285294        session.add(user) 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/openid/provider/axinterface/test_axinterface.py

    r6062 r6067  
    2121 
    2222 
    23 class SQLAlchemyAXInterfaceTestCase(BaseTestCase): 
    24     DB_FILEPATH = path.join(path.dirname(__file__), BaseTestCase.DB_FILENAME) 
    25      
     23class SQLAlchemyAXInterfaceTestCase(BaseTestCase):     
    2624    def __init__(self, *arg, **kw): 
    2725        super(SQLAlchemyAXInterfaceTestCase, self).__init__(*arg, **kw) 
    28          
    2926        self.initDb() 
    3027             
Note: See TracChangeset for help on using the changeset viewer.