Changeset 2899


Ignore:
Timestamp:
19/09/07 15:38:41 (12 years ago)
Author:
pjkersha
Message:

ndg.security.server/setup.py: add .cfg and .conf files for inclusion is egg - this will include openssl and logging config files

ndg.security.server/ndg/security/server/log/init.py: log directory to hold log files for testing

ndg.security.server/ndg/security/server/conf/attAuthorityLog.cfg,
ndg.security.server/ndg/security/server/conf/sessionMgrLog.cfg:

  • config files to configure logging for Attribute Authority and Session Manager respectively

ndg.security.server/ndg/security/server/conf/sessionMgr.tac,
ndg.security.server/ndg/security/server/conf/attAuthority.tac:

  • added call to read in logging config files

ndg.security.server/ndg/security/server/conf/openssl.conf: default OpenSSL config for use by Session Manager when formulating cert requests for MyProxy? delegation calls. File from Globus installation can be used instead if prefered.

ndg.security.test/ndg/security/test/AttAuthority/siteAMapConfig.xml: fix formatting

ndg.security.test/ndg/security/test/AttAuthority/siteAAttAuthorityProperties.xml: expt with SSL setting

ndg.security.server/ndg/security/server/Log.py,
ndg.security.test/ndg/security/test/Log/LogTest.py:

  • experimented with logging. These modules are no longer needed because new logging config file do the same job

ndg.security.client/ndg/security/client/ndgSessionClient.py: got rid of debug statement

ndg.security.test/ndg/security/test/AttAuthority/siteAUserRoles.py: added role for help with testing

Makefile: set PYTHON macro to default 'python' + added force target

Location:
TI12-security/trunk/python/ndg.security.server/ndg/security/server
Files:
5 added
3 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/Log.py

    r2893 r2899  
    1313__revision__ = '$Id$' 
    1414 
     15import os 
    1516import logging 
    1617from logging.handlers import RotatingFileHandler, SysLogHandler 
     
    3637    backUpCnt = 10 
    3738     
    38     def __init__(self, name=name, sysLogHandlerKw={}): 
     39    def __init__(self, name=None, sysLogHandlerKw={}): 
    3940        """NDG Logging class 
    4041         
     
    9091# Make NDG Security Logger the default 
    9192logging.setLoggerClass(Log) 
     93 
     94log = Log() 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/attAuthority.tac

    r2884 r2899  
    1515""" 
    1616import os, base64 
     17from logging.config import fileConfig 
     18try: 
     19        _logConfig = os.path.join(os.environ["NDGSEC_DIR"], 
     20                                                          'conf', 
     21                                                          'attAuthorityLog.cfg') 
     22except KeyError: 
     23        from warnings import warn 
     24        warn(\ 
     25        '"NDGSEC_DIR" environment variable must be set to enable logging config', 
     26        RuntimeWarning) 
     27         
     28fileConfig(_logConfig) 
     29import logging 
     30log = logging.getLogger(__name__) 
    1731 
    1832from ZSI.twisted.WSresource import WSResource 
     
    184198 
    185199if srv.aa['useSSL']: 
    186         # Use SSL connection 
    187 #       from twisted.internet import ssl 
    188 #        
    189 #       # Nb. ssl.DefaultOpenSSLContextFactory requires pyOpenSSL 
    190 #       ctxFactory = ssl.DefaultOpenSSLContextFactory(srv.aa['sslKeyFile'],  
    191 #                                                                                                 srv.aa['sslCertFile']) 
    192 #       port = internet.SSLServer(srv.aa['portNum'], siteFactory, ctxFactory) 
    193  
    194         # Using M2Crypto ... 
    195     os.putenv("OPENSSL_ALLOW_PROXY_CERTS", "1") 
    196  
    197     import twisted.protocols.policies as policies 
    198     from M2Crypto import SSL 
    199     from M2Crypto.SSL import TwistedProtocolWrapper 
    200     from M2Crypto.SSL.TwistedProtocolWrapper import TLSProtocolWrapper 
    201  
    202     siteFactory.startTLS = True 
    203     siteFactory.sslChecker = SSL.Checker.Checker() 
    204  
     200        log.info("Running over https ...") 
     201 
     202        os.putenv("OPENSSL_ALLOW_PROXY_CERTS", "1") 
     203 
     204        import twisted.protocols.policies as policies 
     205 
     206        # Using M2Crypto 
     207        from M2Crypto import SSL 
     208        from M2Crypto.SSL import TwistedProtocolWrapper 
     209        from M2Crypto.SSL.TwistedProtocolWrapper import TLSProtocolWrapper 
     210 
     211        siteFactory.startTLS = True 
     212        siteFactory.sslChecker = SSL.Checker.Checker() 
     213         
    205214        # TODO: Python ssl client seems to require SSL vers 2 is this a security 
    206215        # risk? 
    207     ctx = SSL.Context(protocol='sslv23') 
    208     ctx.set_cipher_list("NULL-MD5:ALL:!ADH:!EXP:@STRENGTH") 
    209     ctx.load_cert(srv.aa['sslCertFile'],  
    210                           srv.aa['sslKeyFile'], 
    211                           callback=lambda *args, **kw: srv.aa['sslKeyPwd']) 
    212                            
    213     ctx.set_allow_unknown_ca(False) 
    214  
    215     # TODO: resolve check - verify_peer setting fails with 
    216     # BIOError: 'no certificate returned' error 18 
    217 #    ctx.set_verify(SSL.verify_peer, 10) 
    218     ctx.set_verify(SSL.verify_client_once, 1) 
    219  
    220     ctx.load_verify_locations(cafile=os.path.basename(srv.aa['caCertFile']),  
    221                                                   capath=os.path.dirname(srv.aa['caCertFile'])) 
    222  
    223     class ContextFactory: 
    224         def getContext(self): 
    225             return ctx 
    226  
    227     factory = policies.WrappingFactory(siteFactory) 
    228     factory.protocol.TLS = True 
    229     factory.protocol = lambda factory, wrappedProtocol: \ 
    230         TLSProtocolWrapper(factory, 
    231                            wrappedProtocol, 
    232                            startPassThrough=0, 
    233                            client=0, 
    234                            contextFactory=ContextFactory(), 
    235                            postConnectionCheck=None) 
    236  
    237     siteFactory = factory 
    238      
    239     port = internet.TCPServer(srv.aa['portNum'], siteFactory) 
    240     port.CERTFILE = srv.aa['sslCertFile'] 
    241     port.KEYFILE = srv.aa['sslKeyFile'] 
    242     root.__class__.server = port 
     216        ctx = SSL.Context(protocol='sslv23') 
     217        ctx.set_cipher_list("NULL-MD5:ALL:!ADH:!EXP:@STRENGTH") 
     218        ctx.load_cert(srv.aa['sslCertFile'],  
     219                                  srv.aa['sslKeyFile'], 
     220                                  callback=lambda *args, **kw: srv.aa['sslKeyPwd']) 
     221                                   
     222        ctx.set_allow_unknown_ca(False) 
     223         
     224        # TODO: resolve check - verify_peer setting fails with 
     225        # BIOError: 'no certificate returned' error 18 
     226        #    ctx.set_verify(SSL.verify_peer, 10) 
     227        ctx.set_verify(SSL.verify_client_once, 1) 
     228         
     229        ctx.load_verify_locations(cafile=os.path.basename(srv.aa['caCertFile']),  
     230                                                  capath=os.path.dirname(srv.aa['caCertFile'])) 
     231         
     232        class ContextFactory: 
     233            def getContext(self): 
     234                return ctx 
     235         
     236        factory = policies.WrappingFactory(siteFactory) 
     237        factory.protocol.TLS = True 
     238        factory.protocol = lambda factory, wrappedProtocol: \ 
     239            TLSProtocolWrapper(factory, 
     240                               wrappedProtocol, 
     241                               startPassThrough=0, 
     242                               client=0, 
     243                               contextFactory=ContextFactory(), 
     244                               postConnectionCheck=None) 
     245         
     246        siteFactory = factory 
     247         
     248        port = internet.TCPServer(srv.aa['portNum'], siteFactory) 
     249        port.CERTFILE = srv.aa['sslCertFile'] 
     250        port.KEYFILE = srv.aa['sslKeyFile'] 
     251        root.__class__.server = port 
    243252else:    
    244253        # Non-SSL 
     254        log.info("Running over http ...")        
    245255        port = internet.TCPServer(srv.aa['portNum'], siteFactory) 
    246256 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/sessionMgr.tac

    r2884 r2899  
    1515""" 
    1616import os, base64 
     17 
     18from logging.config import fileConfig 
     19try: 
     20        _logConfig = os.path.join(os.environ["NDGSEC_DIR"], 
     21                                                          'conf', 
     22                                                          'sessionMgrLog.cfg') 
     23except KeyError: 
     24        from warnings import warn 
     25        warn(\ 
     26        '"NDGSEC_DIR" environment variable must be set to enable logging config', 
     27        RuntimeWarning) 
     28         
     29fileConfig(_logConfig) 
     30import logging 
     31log = logging.getLogger(__name__) 
    1732 
    1833from ZSI.twisted.WSresource import WSResource 
     
    208223if srv.sm['useSSL']: 
    209224        # Use SSL connection 
    210 #       from twisted.internet import ssl 
    211 #        
    212 #       # Nb. ssl.DefaultOpenSSLContextFactory requires pyOpenSSL 
    213 #       ctxFactory = ssl.DefaultOpenSSLContextFactory(srv.sm['sslKeyFile'],  
    214 #                                                                                                 srv.sm['sslCertFile']) 
    215 #       port = internet.SSLServer(srv.sm['portNum'], siteFactory, ctxFactory) 
    216  
    217     # Using M2Crypto ... 
    218     import os 
    219     os.putenv("OPENSSL_ALLOW_PROXY_CERTS", "1") 
    220  
    221     import twisted.protocols.policies as policies 
    222     from M2Crypto import SSL 
    223     from M2Crypto.SSL import TwistedProtocolWrapper 
    224     from M2Crypto.SSL.TwistedProtocolWrapper import TLSProtocolWrapper 
    225          
    226     siteFactory.startTLS = True 
    227     siteFactory.sslChecker = SSL.Checker.Checker() 
     225        log.info("Running over https ...")       
     226 
     227        # Using M2Crypto ... 
     228        import os 
     229        os.putenv("OPENSSL_ALLOW_PROXY_CERTS", "1") 
     230 
     231        import twisted.protocols.policies as policies 
     232        from M2Crypto import SSL 
     233        from M2Crypto.SSL import TwistedProtocolWrapper 
     234        from M2Crypto.SSL.TwistedProtocolWrapper import TLSProtocolWrapper 
     235         
     236        siteFactory.startTLS = True 
     237        siteFactory.sslChecker = SSL.Checker.Checker() 
    228238 
    229239        # TODO: Python ssl client seems to require SSL vers 2 is this a security 
    230240        # risk? 
    231     ctx = SSL.Context(protocol='sslv23') 
    232     ctx.set_cipher_list("NULL-MD5:ALL:!ADH:!EXP:@STRENGTH") 
    233     ctx.load_cert(srv.sm['sslCertFile'],  
     241        ctx = SSL.Context(protocol='sslv23') 
     242        ctx.set_cipher_list("NULL-MD5:ALL:!ADH:!EXP:@STRENGTH") 
     243        ctx.load_cert(srv.sm['sslCertFile'],  
    234244                          srv.sm['sslKeyFile'], 
    235245                          callback=lambda *args, **kw: srv.aa['sslKeyPwd']) 
    236246                           
    237     ctx.set_allow_unknown_ca(False) 
     247        ctx.set_allow_unknown_ca(False) 
    238248 
    239249    # TODO: resolve check - verify_peer setting fails with 
    240250    # BIOError: 'no certificate returned' error 18 
    241251#    ctx.set_verify(SSL.verify_peer, 10) 
    242     ctx.set_verify(SSL.verify_client_once, 1) 
    243  
    244     ctx.load_verify_locations(cafile=os.path.basename(srv.sm['caCertFile']),  
     252        ctx.set_verify(SSL.verify_client_once, 1) 
     253 
     254        ctx.load_verify_locations(cafile=os.path.basename(srv.sm['caCertFile']),  
    245255                                                  capath=os.path.dirname(srv.sm['caCertFile'])) 
    246256 
    247     class ContextFactory: 
    248         def getContext(self): 
    249             return ctx 
    250  
    251     factory = policies.WrappingFactory(siteFactory) 
    252     factory.protocol.TLS = True 
    253     factory.protocol = lambda factory, wrappedProtocol: \ 
    254         TLSProtocolWrapper(factory, 
    255                            wrappedProtocol, 
    256                            startPassThrough=0, 
    257                            client=0, 
    258                            contextFactory=ContextFactory(), 
    259                            postConnectionCheck=None) 
    260  
    261     siteFactory = factory 
    262      
    263     port = internet.TCPServer(srv.sm['portNum'], siteFactory) 
    264     port.CERTFILE = srv.sm['sslCertFile'] 
    265     port.KEYFILE = srv.sm['sslKeyFile'] 
    266     root.__class__.server = port 
     257        class ContextFactory: 
     258            def getContext(self): 
     259                return ctx 
     260         
     261        factory = policies.WrappingFactory(siteFactory) 
     262        factory.protocol.TLS = True 
     263        factory.protocol = lambda factory, wrappedProtocol: \ 
     264            TLSProtocolWrapper(factory, 
     265                               wrappedProtocol, 
     266                               startPassThrough=0, 
     267                               client=0, 
     268                               contextFactory=ContextFactory(), 
     269                               postConnectionCheck=None) 
     270         
     271        siteFactory = factory 
     272         
     273        port = internet.TCPServer(srv.sm['portNum'], siteFactory) 
     274        port.CERTFILE = srv.sm['sslCertFile'] 
     275        port.KEYFILE = srv.sm['sslKeyFile'] 
     276        root.__class__.server = port 
    267277else:    
    268278        # Non-SSL 
     279        log.info("Running over http ...") 
    269280        port = internet.TCPServer(srv.sm['portNum'], siteFactory) 
    270281 
Note: See TracChangeset for help on using the changeset viewer.