Changeset 5935


Ignore:
Timestamp:
02/11/09 17:10:10 (10 years ago)
Author:
pjkersha
Message:

1.3.0 Release

Completed MyProxy? SAML Attribute assertion callout and added console script entry point.

Location:
TI12-security/trunk/python
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg_security/setup.py

    r5788 r5935  
    4242setup( 
    4343    name =                      'ndg_security', 
    44     version =                   '1.2.0', 
     44    version =                   '1.3.0', 
    4545    description =               'NERC DataGrid Security Utilities', 
    4646    long_description =          _longDescription, 
  • TI12-security/trunk/python/ndg_security_client/setup.py

    r5788 r5935  
    4444setup( 
    4545    name =                      'ndg_security_client', 
    46     version =                   '1.2.0', 
     46    version =                   '1.3.0', 
    4747    description =               'NERC DataGrid Security Client side interface', 
    4848    long_description =          _longDescription, 
  • TI12-security/trunk/python/ndg_security_common/setup.py

    r5788 r5935  
    6969setup( 
    7070    name =                      'ndg_security_common', 
    71     version =                   '1.2.0', 
     71    version =                   '1.3.0', 
    7272    description =           'NERC DataGrid Security package containing common ' 
    7373                            'utilities used by both server and client ' 
  • TI12-security/trunk/python/ndg_security_common_utils_openid_dbinterface/ndg/security/common/utils/openid/dbinterface.py

    r5875 r5935  
    342342                accountIds += [res[0]] 
    343343                identifier = DatabaseUserIdentifiers.makeIdentifier(*res[1:3]) 
    344                 identifier = DatabaseUserIdentifiers.makeUniqId(lowserCaseIds,  
     344                identifier = DatabaseUserIdentifiers.makeUniqId(lowerCaseIds,  
    345345                                                                identifier) 
    346346                ids += [identifier] 
     
    498498            raise SystemExit(msg) 
    499499 
    500         if not opt.command: 
    501             msg = "Error, no command set.\n\n" + parser.format_help() 
    502             raise SystemExit(msg) 
    503  
    504500        ids = DatabaseUserIdentifiers(opt.configFilePath) 
    505501 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r5929 r5935  
    3636from ndg.security.common.X509 import X500DN 
    3737from ndg.security.server.wsgi.openid.provider import IdentityMapping 
    38  
    39  
    40 class SamlAssertionMyProxyCertExtAppError(Exception): 
    41     """Base class for SamlAssertionMyProxyCertExtApp class exceptions""" 
    42      
    43      
    44 class SamlAssertionMyProxyCertExtAppConfigError( 
    45                                         SamlAssertionMyProxyCertExtAppError): 
    46     """Configuration fault for SamlAssertionMyProxyCertExtApp instance""" 
    47  
    48  
    49 class SamlAssertionMyProxyCertExtAppRetrieveError( 
    50                                         SamlAssertionMyProxyCertExtAppError): 
     38from ndg.security.common.utils.configfileparsers import (      
     39                                                    CaseSensitiveConfigParser,) 
     40 
     41class CertExtAppError(Exception): 
     42    """Base class for CertExtApp class exceptions""" 
     43     
     44     
     45class CertExtAppConfigError(CertExtAppError): 
     46    """Configuration fault for CertExtApp instance""" 
     47 
     48 
     49class CertExtAppRetrieveError(CertExtAppError): 
    5150    """Error retrieving results from user database or attribute authority""" 
    5251     
    5352 
    54 class SamlAssertionMyProxyCertExtAppSqlError( 
    55                                         SamlAssertionMyProxyCertExtAppError):    
     53class CertExtAppSqlError(CertExtAppError):    
    5654    """Error with SQL query syntax""" 
    5755     
    5856     
    59 class SamlAssertionMyProxyCertExtApp(object): 
     57class CertExtApp(object): 
    6058    """Application to create a X.509 certificate extension containing a SAML 
    6159    assertion for inclusion by MyProxy into an issued certificate 
     
    8583    OPENID_SQLQUERY_OPTNAME = 'openIdSqlQuery' 
    8684    OPENID_IDENTITY_URI_TMPL_OPTNAME = 'identityUriTemplate' 
    87      
     85    ATTRIBUTE_AUTHORITY_URI_OPTNAME = 'attributeAuthorityURI' 
     86    ISSUER_DN_OPTNAME = 'issuerDN' 
     87     
     88    CONFIG_FILE_OPTNAMES = ( 
     89        ATTRIBUTE_AUTHORITY_URI_OPTNAME, 
     90        ISSUER_DN_OPTNAME,                  
     91        CONNECTION_STRING_OPTNAME, 
     92        OPENID_SQLQUERY_OPTNAME, 
     93        OPENID_IDENTITY_URI_TMPL_OPTNAME                    
     94    ) 
    8895    __slots__ = ( 
    89        'attributeAuthorityURI', 
    9096       'userOpenID', 
    91        'issuerDN', 
    92        'attributeDescr', 
    93        CONNECTION_STRING_OPTNAME, 
    94        OPENID_SQLQUERY_OPTNAME, 
    95        OPENID_IDENTITY_URI_TMPL_OPTNAME 
     97       'attributeDescr' 
    9698    ) 
    97     __PRIVATE_ATTR_PREFIX = '_SamlAssertionMyProxyCertExtApp__' 
     99    __slots__ += CONFIG_FILE_OPTNAMES 
     100    __PRIVATE_ATTR_PREFIX = '_CertExtApp__' 
    98101    __slots__ += tuple([__PRIVATE_ATTR_PREFIX + i for i in __slots__]) 
    99102     
     
    108111        # Use property here as a safeguard in case DEFAULT_ATTR_DESCR has been 
    109112        # altered 
    110         self.attributeDescr = SamlAssertionMyProxyCertExtApp.DEFAULT_ATTR_DESCR 
    111  
     113        self.attributeDescr = CertExtApp.DEFAULT_ATTR_DESCR 
     114 
     115    @classmethod 
     116    def fromConfigFile(cls, configFilePath, **kw): 
     117        '''Alternative constructor makes object from config file settings 
     118        @type configFilePath: basestring 
     119        @param configFilePath: configuration file path 
     120        ''' 
     121        certExtApp = cls() 
     122        certExtApp.readConfig(configFilePath, **kw) 
     123         
     124        return certExtApp 
     125         
    112126    def __call__(self, username): 
    113127        """Main method - create SAML assertion by querying the user's OpenID 
     
    126140             
    127141        except (IndexError, TypeError): 
    128             raise SamlAssertionMyProxyCertExtAppRetrieveError("Error accessing " 
    129                     "assertion from Attribute Authority SAML response: %s" % 
    130                     traceback.format_exc()) 
     142            raise CertExtAppRetrieveError("Error accessing assertion from " 
     143                                          "Attribute Authority SAML response: " 
     144                                          "%s" % traceback.format_exc()) 
    131145             
    132146        return assertionStr 
    133147 
     148    def readConfig(self, configFilePath, prefix='', section='DEFAULT'): 
     149        '''Read config file settings 
     150        @type configFilePath: basestring 
     151        @param configFilePath: configuration file path 
     152        @type prefix: basestring 
     153        @param prefix: prefix for option names e.g. "certExtApp." 
     154        @type section: baestring 
     155        @param section: configuration file section from which to extract 
     156        parameters. 
     157        ''' 
     158        cfg = CaseSensitiveConfigParser() 
     159        cfg.read(os.path.expandvars(configFilePath)) 
     160         
     161        for optName in CertExtApp.CONFIG_FILE_OPTNAMES: 
     162            val = cfg.get(section, prefix+optName) 
     163            setattr(self, optName, val) 
     164                     
    134165    def _getAttributeDescr(self): 
    135166        return self.__attributeDescr 
     
    145176                                'tuple sub-elements; got %r instead' %  
    146177                                type(value)) 
    147             if len(i) != SamlAssertionMyProxyCertExtApp.N_ATTR_DESCR_ELEM_ITEMS: 
     178            if len(i) != CertExtApp.N_ATTR_DESCR_ELEM_ITEMS: 
    148179                raise TypeError('Expecting %d element tuple for ' 
    149                     '"attributeDescr" sub-elements; got %d elements instead' %  
    150                     (SamlAssertionMyProxyCertExtApp.N_ATTR_DESCR_ELEM_ITEMS, 
    151                     len(i))) 
     180                                '"attributeDescr" sub-elements; got %d ' 
     181                                'elements instead' %  
     182                                (CertExtApp.N_ATTR_DESCR_ELEM_ITEMS, 
     183                                 len(i))) 
    152184                 
    153185        self.__attributeDescr = value 
     
    209241        if not isinstance(value, basestring): 
    210242            raise TypeError('Expecting string type for "%s" attribute; got %r'% 
    211                     (SamlAssertionMyProxyCertExtApp.CONNECTION_STRING_OPTNAME, 
    212                      type(value))) 
     243                            (CertExtApp.CONNECTION_STRING_OPTNAME, 
     244                             type(value))) 
    213245        self.__connectionString = value 
    214246 
     
    223255        if not isinstance(value, basestring): 
    224256            raise TypeError('Expecting string type for "%s" attribute; got %r'%  
    225                         (SamlAssertionMyProxyCertExtApp.OPENID_SQLQUERY_OPTNAME, 
     257                        (CertExtApp.OPENID_SQLQUERY_OPTNAME, 
    226258                         type(value))) 
    227259        self.__openIdSqlQuery = value 
     
    237269        if not isinstance(value, basestring): 
    238270            raise TypeError('Expecting string type for "%s" attribute; got %r'%  
    239             (SamlAssertionMyProxyCertExtApp.OPENID_IDENTITY_URI_TMPL_OPTNAME, 
    240              type(value))) 
     271                            (CertExtApp.OPENID_IDENTITY_URI_TMPL_OPTNAME, 
     272                             type(value))) 
    241273        self.__identityUriTemplate = value 
    242274 
     
    252284        '''Specific implementation needed with __slots__''' 
    253285        return dict([(attrName, getattr(self, attrName)) \ 
    254                      for attrName in SamlAssertionMyProxyCertExtApp.__slots__]) 
     286                     for attrName in CertExtApp.__slots__]) 
    255287         
    256288    def __setstate__(self, attrDict): 
     
    281313        attributeQuery.subject.nameID = NameID() 
    282314        attributeQuery.subject.nameID.format = \ 
    283                             SamlAssertionMyProxyCertExtApp.ESG_NAME_ID_FORMAT 
     315                            CertExtApp.ESG_NAME_ID_FORMAT 
    284316        attributeQuery.subject.nameID.value = self.userOpenID 
    285317                   
     
    324356            dbEngine = create_engine(self.connectionString) 
    325357        except ImportError, e: 
    326             raise SamlAssertionMyProxyCertExtAppConfigError("Missing database " 
    327                                                             "engine for " 
    328                                                             "SQLAlchemy: %s" %  
    329                                                             e) 
     358            raise CertExtAppConfigError("Missing database engine for " 
     359                                        "SQLAlchemy: %s" % e) 
    330360        connection = dbEngine.connect() 
    331361         
     
    336366 
    337367        except exc.ProgrammingError: 
    338             raise SamlAssertionMyProxyCertExtAppSqlError( 
    339                                                 "Error with SQL Syntax: %s" % 
    340                                                 traceback.format_exc()) 
     368            raise CertExtAppSqlError("Error with SQL Syntax: %s" % 
     369                                     traceback.format_exc()) 
    341370        finally: 
    342371            connection.close() 
     
    346375         
    347376        except Exception: 
    348             raise SamlAssertionMyProxyCertExtAppRetrieveError( 
    349                                                 "Error with result set: %s" % 
    350                                                 traceback.format_exc()) 
     377            raise CertExtAppRetrieveError("Error with result set: %s" % 
     378                                          traceback.format_exc()) 
    351379         
    352380        log.debug('Query succeeded for user %r' % username) 
    353381        return identifier 
     382     
     383     
     384import optparse 
     385import sys 
     386import os 
     387 
     388class CertExtConsoleApp(CertExtApp): 
     389    """Extend CertExtApp with functionality for command line options""" 
     390 
     391    DEBUG_ENVVAR_NAME = 'NDGSEC_MYPROXY_CERT_EXT_APP_DEBUG' 
     392 
     393    @classmethod 
     394    def run(cls): 
     395        """Parse command line arguments and run the query specified""" 
     396 
     397        if cls.DEBUG_ENVVAR_NAME in os.environ: 
     398            import pdb 
     399            pdb.set_trace() 
     400 
     401        parser = optparse.OptionParser() 
     402 
     403        parser.add_option("-f", 
     404                          "--config-file", 
     405                          dest="configFilePath", 
     406                          help="ini style configuration file path containing " 
     407                               "the options: connectionString, " 
     408                               "openIdSqlQuery, identityUriTemplate, " 
     409                               "attributeAuthorityURI and issuerDN") 
     410 
     411        parser.add_option("-u", 
     412                          "--username", 
     413                          dest="username", 
     414                          help="username to generate a SAML assertion for") 
     415 
     416        opt = parser.parse_args()[0] 
     417 
     418        if not opt.configFilePath: 
     419            msg = "Error: no configuration file set.\n\n" + parser.format_help() 
     420            raise SystemExit(msg) 
     421        elif not opt.username: 
     422            msg = "Error: no username set.\n\n" + parser.format_help() 
     423            raise SystemExit(msg) 
     424         
     425        certExtApp = cls.fromConfigFile(opt.configFilePath) 
     426        assertion = certExtApp(opt.username) 
     427        print(assertion) 
     428 
  • TI12-security/trunk/python/ndg_security_server/setup.py

    r5843 r5935  
    2929_entryPoints = """ 
    3030    [console_scripts]  
    31     init-credrepos-db=ndg.security.server.initCredentialRepositoryDb:main 
     31    myproxy-saml-assertion-cert-ext-app=ndg.security.server.myproxy.certificate_extapp.saml_attribute_assertion:CertExtConsoleApp.run 
    3232 
    3333    [paste.app_factory] 
     
    6464setup( 
    6565    name =                      'ndg_security_server', 
    66     version =                   '1.2.0', 
     66    version =                   '1.3.0', 
    6767    description =               'Server side components for running NERC DataGrid ' 
    6868                            'Security Services', 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/test_saml_attribute_assertion.py

    r5929 r5935  
    1515import os 
    1616from string import Template 
     17from cStringIO import StringIO 
    1718 
    1819from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String 
     
    2223from ndg.security.test.unit import BaseTestCase 
    2324from ndg.security.server.myproxy.certificate_extapp.saml_attribute_assertion \ 
    24     import SamlAssertionMyProxyCertExtApp 
     25    import CertExtApp, CertExtConsoleApp 
    2526  
    2627from sqlalchemy.ext.declarative import declarative_base 
    2728 
    2829 
    29 class SamlAssertionMyProxyCertExtAppTestCase(BaseTestCase): 
     30class CertExtAppTestCase(BaseTestCase): 
    3031    THIS_DIR = os.path.dirname(__file__) 
    3132    USERNAME = 'pjk' 
     
    3435    OPENID = Template(OPENID_TMPL).substitute( 
    3536                                        dict(userIdentifier=OPENID_IDENTIFIER)) 
     37    OPENID_SQL_QUERY = ("select openid_identifier from users where username " 
     38                        "= '${username}'")  
    3639     
    3740    DB_FILENAME = 'user.db' 
     
    3942     
    4043    def __init__(self, *arg, **kw): 
    41         super(SamlAssertionMyProxyCertExtAppTestCase, self).__init__(*arg,  
    42                                                                      **kw)             
     44        super(CertExtAppTestCase, self).__init__(*arg, **kw)             
    4345        self.startSiteAAttributeAuthority() 
    44         if not os.path.isfile(os.path.join( 
    45                         SamlAssertionMyProxyCertExtAppTestCase.THIS_DIR, 
    46                         SamlAssertionMyProxyCertExtAppTestCase.DB_FILENAME)): 
     46         
     47        if not os.path.isfile(os.path.join(CertExtAppTestCase.THIS_DIR, 
     48                                           CertExtAppTestCase.DB_FILENAME)): 
    4749            self._createDb() 
    4850         
    4951    def _createDb(self): 
    50         db = create_engine( 
    51                     SamlAssertionMyProxyCertExtAppTestCase.DB_CONNECTION_STR) 
     52        db = create_engine(CertExtAppTestCase.DB_CONNECTION_STR) 
    5253         
    5354        metadata = MetaData() 
     
    6970                self.openid_identifier = openid_identifier 
    7071         
    71         user = User(SamlAssertionMyProxyCertExtAppTestCase.USERNAME,  
    72                     SamlAssertionMyProxyCertExtAppTestCase.OPENID_IDENTIFIER) 
     72        user = User(CertExtAppTestCase.USERNAME,  
     73                    CertExtAppTestCase.OPENID_IDENTIFIER) 
    7374         
    7475        Session = sessionmaker(bind=db) 
     
    7879         
    7980    def test01DbQuery(self): 
    80         myProxyCertExtApp = SamlAssertionMyProxyCertExtApp() 
     81        myProxyCertExtApp = CertExtApp() 
    8182        myProxyCertExtApp.connectionString = \ 
    82                     SamlAssertionMyProxyCertExtAppTestCase.DB_CONNECTION_STR 
     83                    CertExtAppTestCase.DB_CONNECTION_STR 
    8384                     
    84         myProxyCertExtApp.openIdSqlQuery = ( 
    85                             "select openid_identifier from " 
    86                             "users where username = '%s'" % 
    87                             SamlAssertionMyProxyCertExtAppTestCase.USERNAME) 
     85        myProxyCertExtApp.openIdSqlQuery = CertExtAppTestCase.OPENID_SQL_QUERY 
    8886         
    8987        identifier = myProxyCertExtApp.queryOpenId( 
    90                                 SamlAssertionMyProxyCertExtAppTestCase.USERNAME) 
     88                                CertExtAppTestCase.USERNAME) 
    9189        self.assert_(identifier ==  
    92                      SamlAssertionMyProxyCertExtAppTestCase.OPENID_IDENTIFIER) 
     90                     CertExtAppTestCase.OPENID_IDENTIFIER) 
    9391         
    9492    def test02AttributeQuery(self): 
    95         myProxyCertExtApp = SamlAssertionMyProxyCertExtApp() 
     93        myProxyCertExtApp = CertExtApp() 
    9694        myProxyCertExtApp.attributeAuthorityURI = ('http://localhost:%d' 
    9795                                                   '/AttributeAuthority/saml' %  
    98         SamlAssertionMyProxyCertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
     96        CertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
    9997        ) 
    10098        myProxyCertExtApp.issuerDN = "/O=Site A/CN=Authorisation Service" 
    101         myProxyCertExtApp.userOpenID = \ 
    102                                 SamlAssertionMyProxyCertExtAppTestCase.OPENID 
     99        myProxyCertExtApp.userOpenID = CertExtAppTestCase.OPENID 
    103100                                 
    104101        assertion = myProxyCertExtApp.attributeQuery() 
     
    106103         
    107104    def test03End2End(self): 
    108         myProxyCertExtApp = SamlAssertionMyProxyCertExtApp() 
     105        myProxyCertExtApp = CertExtApp() 
    109106         
    110107        myProxyCertExtApp.connectionString = \ 
    111                     SamlAssertionMyProxyCertExtAppTestCase.DB_CONNECTION_STR 
     108                    CertExtAppTestCase.DB_CONNECTION_STR 
    112109                     
    113110        myProxyCertExtApp.openIdSqlQuery = ( 
    114111                            "select openid_identifier from " 
    115112                            "users where username = '%s'" % 
    116                             SamlAssertionMyProxyCertExtAppTestCase.USERNAME) 
     113                            CertExtAppTestCase.USERNAME) 
    117114         
    118115        myProxyCertExtApp.identityUriTemplate = \ 
    119                             SamlAssertionMyProxyCertExtAppTestCase.OPENID_TMPL 
     116                            CertExtAppTestCase.OPENID_TMPL 
    120117                             
    121118        myProxyCertExtApp.attributeAuthorityURI = ('http://localhost:%d' 
    122119                                                   '/AttributeAuthority/saml' %  
    123         SamlAssertionMyProxyCertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
     120        CertExtAppTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
    124121        ) 
    125122        myProxyCertExtApp.issuerDN = "/O=Site A/CN=Authorisation Service" 
    126123         
    127         assertion = myProxyCertExtApp( 
    128                                 SamlAssertionMyProxyCertExtAppTestCase.USERNAME) 
     124        assertion = myProxyCertExtApp(CertExtAppTestCase.USERNAME) 
    129125        self.assert_(assertion) 
    130126        print(assertion) 
     127 
     128    def test04FromConfigFile(self): 
     129        configFilePath = os.path.join(CertExtAppTestCase.THIS_DIR, 'config.ini') 
     130        myProxyCertExtApp = CertExtApp.fromConfigFile(configFilePath) 
     131        assertion = myProxyCertExtApp(CertExtAppTestCase.USERNAME) 
     132        self.assert_(assertion) 
     133        print(assertion) 
     134 
     135    def test05ConsoleApp(self): 
     136        configFilePath = os.path.join(CertExtAppTestCase.THIS_DIR, 'config.ini') 
     137        import sys 
     138        sys.argv = [ 
     139            None,  
     140            "-f", 
     141            configFilePath, 
     142            "-u", 
     143            CertExtAppTestCase.USERNAME 
     144        ] 
     145        try: 
     146            stdOut = sys.stdout 
     147            sys.stdout = StringIO() 
     148             
     149            CertExtConsoleApp.run() 
     150            output = sys.stdout.getvalue() 
     151        finally: 
     152            sys.stdout = stdOut 
    131153         
     154        self.assert_(output)         
     155        print(output) 
     156         
  • TI12-security/trunk/python/ndg_security_test/setup.py

    r5788 r5935  
    2020setup( 
    2121    name =                      'ndg_security_test', 
    22     version =                   '1.2.0', 
     22    version =                   '1.3.0', 
    2323    description =               'NERC DataGrid Security Unit tests', 
    2424    long_description =          'Unit tests client - server side', 
Note: See TracChangeset for help on using the changeset viewer.