Ignore:
Timestamp:
19/03/08 16:45:01 (12 years ago)
Author:
pjkersha
Message:
  • Added sso Pylons project to security stack consisting of LoginService? extracted from the NDG Browse stack
  • Fixes to Attribute Authority, Credential Wallet and Session Manager to enable explicit setting of exclusive namespace settings for WS-Security via config files.
Location:
TI12-security/trunk/python/ndg.security.server/ndg/security/server
Files:
85 added
13 deleted
12 edited
3 moved

Legend:

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

    r3135 r3652  
    105105                    'keyFile':             '', 
    106106                    'keyPwd':              '', 
     107                    'wssRefInclNS':        [], 
     108                    'wssSignedInfoInclNS': [], 
    107109                    'caCertFileList':      [], 
    108110                    'clntCertFile':        '', 
     
    638640                    # Make sure to leave password element contents unchanged 
    639641                    if isinstance(AttAuthority.__validKeys[elem.tag], list): 
    640                         self.__prop[elem.tag] = \ 
    641                             [os.path.expandvars(subElem.text.strip()) \ 
    642                              for subElem in elem] 
     642                        if len(elem) == 0 and elem.text is not None: 
     643                            # Treat as a list of space separated elements 
     644                            self.__prop[elem.tag] = elem.text.split() 
     645                        else: 
     646                            # Parse from a list of sub-elements 
     647                            self.__prop[elem.tag] = \ 
     648                                [os.path.expandvars(subElem.text.strip()) \ 
     649                                 for subElem in elem] 
    643650                             
    644651                    elif 'eyPwd' not in elem.tag and elem.text:  
     
    654661                "Error parsing tag \"%s\" in properties file \"%s\": %s" % \ 
    655662                (elem.tag, self.__propFilePath, e) 
    656   
     663 
    657664        if invalidKeys != []: 
    658665            raise AttAuthorityError, "The following properties file " + \ 
     
    668675        self.__prop['portNum'] = int(self.__prop['portNum']) 
    669676        self.__prop['attCertFileLogCnt']=int(self.__prop['attCertFileLogCnt']) 
    670          
     677 
    671678        # Check directory path 
    672679        try: 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/LoginService/loginservice/config/environment.py

    r2918 r3652  
    11import os 
    22 
    3 import pylons.config 
     3from pylons import config 
    44import webhelpers 
    55 
     6import loginservice.lib.helpers 
     7import loginservice.lib.app_globals as app_globals 
    68from loginservice.config.routing import make_map 
    79 
    810def load_environment(global_conf={}, app_conf={}): 
    911    map = make_map(global_conf, app_conf) 
     12     
     13    # ~Advice from deprecation warning... 
     14    config['routes.map'] = map 
     15     
    1016    # Setup our paths 
    11     root_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) 
    12     paths = {'root_path': root_path, 
    13              'controllers': os.path.join(root_path, 'controllers'), 
    14              'templates': [os.path.join(root_path, path) for path in \ 
    15                            ('components', 'templates')], 
    16              'static_files': os.path.join(root_path, 'public') 
    17              } 
     17    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) 
     18    paths = dict(root=root, 
     19                 controllers=os.path.join(root, 'controllers'), 
     20                 static_files=os.path.join(root, 'public'), 
     21                 templates=[os.path.join(root, path) for path in \ 
     22                           ('components', 'templates')]) 
     23#    paths = {'root_path': root_path, 
     24#             'controllers': os.path.join(root_path, 'controllers'), 
     25#             'templates': [os.path.join(root_path, path) for path in \ 
     26#                           ('components', 'templates')], 
     27#             'static_files': os.path.join(root_path, 'public') 
     28#             } 
     29 
     30    # Initialize config with the basic options 
     31    config.init_app(global_conf, app_conf, package='loginservice', 
     32                    template_engine='myghty', paths=paths) 
     33 
     34    config['routes.map'] = make_map() 
     35    config['pylons.g'] = app_globals.Globals() 
     36    config['pylons.h'] = loginservice.lib.helpers 
     37 
     38    # Customize templating options via this variable 
     39    tmpl_options = config['buffet.template_options'] 
     40 
     41    # CONFIGURATION OPTIONS HERE (note: all config options will override 
     42    # any Pylons config options) 
    1843     
    19     # The following template options are passed to your template engines 
    20     tmpl_options = {} 
    2144    tmpl_options['myghty.log_errors'] = True 
    2245    tmpl_options['myghty.escapes'] = dict(l=webhelpers.auto_link, s=webhelpers.simple_format) 
    2346     
    24     # Add your own template options config options here, note that all config options will override 
    25     # any Pylons config options 
    26      
    2747    # Return our loaded config object 
    28     return pylons.config.Config(tmpl_options, map, paths) 
     48    #return config.Config(tmpl_options, map, paths) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/LoginService/loginservice/config/middleware.py

    r2918 r3652  
    66from paste.deploy.converters import asbool 
    77 
     8from pylons import config 
    89from pylons.error import error_template 
    910from pylons.middleware import ErrorHandler, ErrorDocuments, StaticJavascripts, error_mapper 
    10 import pylons.wsgiapp 
     11from pylons.wsgiapp import PylonsApp 
    1112 
    1213from loginservice.config.environment import load_environment 
    13 import loginservice.lib.helpers 
    14 import loginservice.lib.app_globals as app_globals 
    1514from loginservice.config.ndgMiddleware import ndgMiddleware 
     15 
    1616 
    1717def make_app(global_conf, full_stack=True, **app_conf): 
     
    2323     
    2424    """ 
    25     # Setup the Paste CONFIG object, adding app_conf/global_conf for legacy code 
    26     conf = global_conf.copy() 
    27     conf.update(app_conf) 
    28     conf.update(dict(app_conf=app_conf, global_conf=global_conf)) 
    29     CONFIG.push_process_config(conf) 
    30  
     25  
    3126    # Load our Pylons configuration defaults 
    32     config = load_environment(global_conf, app_conf) 
    33     config.init_app(global_conf, app_conf, package='loginservice', 
    34                     template_engine='kid') 
     27    load_environment(global_conf, app_conf) 
    3528         
    3629    # Load our default Pylons WSGI app and make g available 
    37     app = pylons.wsgiapp.PylonsApp(config, helpers=loginservice.lib.helpers, 
    38                                    g=app_globals.Globals) 
     30    app = PylonsApp() 
    3931    g = app.globals 
    4032    app = ConfigMiddleware(app, conf) 
     
    4436    # handling middleware underneath 
    4537 
    46     app = ndgMiddleware(app, g) 
     38    app = ndgMiddleware(app,g) 
    4739    g=app.globals 
     40     
     41    # Configure logging 
     42    #logging.basicConfig(format='%(thread)s %(name)s %(levelname)s %(message)s') 
    4843     
    4944    # If errror handling and exception catching will be handled by middleware 
     
    5550     
    5651        # Error Handling 
    57         app = ErrorHandler(app, global_conf, error_template=error_template, **config.errorware) 
     52        app = ErrorHandler(app, global_conf, error_template=error_template, **config['pylons.errorware']) 
    5853     
    5954        # Display error documents for 401, 403, 404 status codes (if debug is disabled also 
    6055        # intercepts 500) 
    61         app = ErrorDocuments(app, global_conf, mapper=error_mapper, **app_conf) 
     56        #app = ErrorDocuments(app, global_conf, mapper=error_mapper, **app_conf) 
    6257     
    6358    # Establish the Registry for this application 
    6459    app = RegistryManager(app) 
    6560     
    66     static_app = StaticURLParser(config.paths['static_files']) 
     61    # Allow static files from outside the egg too ... g.htdocs defined in ndgDiscovery.config 
     62    if g.htdocs: 
     63        static_paths = [g.htdocs,config['pylons.paths']['static_files']] 
     64    else: static_paths= [config['pylons.paths']['static_files']] 
     65    static_app = [StaticURLParser(path) for path in static_paths] 
    6766    javascripts_app = StaticJavascripts() 
    68     app = Cascade([static_app, javascripts_app, app]) 
     67    app = Cascade(static_app +[javascripts_app, app]) 
    6968    return app 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/LoginService/loginservice/controllers/login.py

    r2926 r3652  
    11import sys,cgi 
    2 from urlparse import urlparse 
     2from urlparse import urlsplit, urlunsplit 
    33import base64 
    44 
    5 from loginservice.lib.base import * 
    6 from loginservice.lib.security_util import setSecuritySession, \ 
    7                                             LoginServiceQuery 
    8  
     5from ows_server.lib.base import * 
     6from ows_server.lib.security_util import setSecuritySession, SecuritySession,\ 
     7                                         LoginServiceQuery 
     8from ows_common.exception_report import OwsError 
    99from paste.request import parse_querystring 
    1010import logging 
     
    1414from ndg.security.common.SessionMgr import SessionMgrClient, SessionExpired, \ 
    1515    AttributeRequestDenied 
    16  
    17 class LoginControllerError(Exception): 
    18     """Handle exceptions from LoginController""" 
    19      
     16from ndg.security.common.m2CryptoSSLUtility import HTTPSConnection, \ 
     17    HostCheck, InvalidCertSignature, InvalidCertDN 
     18 
     19 
    2020class LoginController(BaseController): 
    2121    ''' Provides the pylons controller for local login ''' 
    2222     
    23     def __setup(self): 
    24         """Get 'r' return to URL argument from current URL query string""" 
    25         c.returnTo=request.params.get('r','') 
    26  
    27     def __securitySetup(self): 
    28         '''PKI settings for Attribute Authority and Session Manager''' 
    29          
    30         self.ndgCfg = request.environ['ndgConfig'] 
    31  
    32         tracefileExpr = self.ndgCfg.get('NDG_SECURITY', 'tracefile') 
    33         if tracefileExpr: 
    34             self.tracefile = eval(tracefileExpr) 
    35          
    36         # ... for SSL connections to security web services 
    37         try: 
    38             self.sslCACertFilePathList = \ 
    39             self.ndgCfg.get('NDG_SECURITY', 'sslCACertFilePathList').split() 
    40                  
    41         except AttributeError: 
    42             raise LoginControllerError, 'No "sslCACertFilePathList" security setting' 
    43  
    44         self.sslPeerCertCN = self.ndgCfg.get('NDG_SECURITY', 'sslPeerCertCN') 
    45  
    46         # ...and for WS-Security digital signature 
    47         self.wssCertFilePath = self.ndgCfg.get('NDG_SECURITY',  
    48                                                'wssCertFilePath') 
    49         self.wssPriKeyFilePath = self.ndgCfg.get('NDG_SECURITY',  
    50                                                  'wssKeyFilePath') 
    51         self.wssPriKeyPwd = self.ndgCfg.get('NDG_SECURITY', 'wssKeyPwd') 
    52  
    53         try: 
    54             self.wssCACertFilePathList = \ 
    55             self.ndgCfg.get('NDG_SECURITY', 'wssCACertFilePathList').split() 
    56                  
    57         except AttributeError: 
    58             raise LoginControllerError, 'No "wssCACertFilePathList" security setting' 
    59  
     23    def __before__(self, action):  
     24        """For each action, get 'r' return to URL argument from current URL  
     25        query string.  c.returnTo is used in some of the .kid files""" 
     26        c.returnTo = request.params.get('r', '') 
     27         
     28        # Check return to address - getCredentials should NOT be returned to 
     29        # with its query args intact 
     30        b64decReturnTo = base64.urlsafe_b64decode(c.returnTo) 
     31        scheme, netloc, pathInfo, query, frag = urlsplit(b64decReturnTo) 
     32        if 'getCredentials' in pathInfo: 
     33            # Swap to discovery and remove sensitive creds query args 
     34            # 
     35            # TODO: re-write to be more robust and modular.  Nb.  
     36            # BaseController.__call__ should filter out 'getCredentials' 
     37            # calls from c.requestURL so this code should never need to be  
     38            # executed. 
     39            filteredReturnTo = urlunsplit((scheme,netloc,'/discovery','','')) 
     40            c.returnTo = base64.urlsafe_b64encode(filteredReturnTo) 
     41         
     42        # Check return to address - getCredentials should NOT be returned to 
     43        # with its query args intact 
     44        log.debug("LoginController.__before__: Decoded c.returnTo = %s" % \ 
     45                                      base64.urlsafe_b64decode(c.returnTo)) 
     46     
    6047     
    6148    def index(self): 
    62         '''Present login''' 
    63         if 'ndgSec' in session:  
     49        ''' Ok, you really want to login here ''' 
     50        log.debug("LoginController.index ...")    
     51 
     52        if 'ndgSec' not in session:  
     53            log.debug('No security session details found - offering login...') 
     54            return render('login') 
     55         
     56        # Session is set in this domain - check it  
     57        try:     
     58            smClnt = SessionMgrClient(uri=session['ndgSec']['h'], 
     59                    sslCACertFilePathList=g.securityCfg.sslCACertFilePathList, 
     60                    sslPeerCertCN=g.securityCfg.sslPeerCertCN, 
     61                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     62                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     63                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     64                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     65                    tracefile=g.securityCfg.tracefile) 
     66                                 
     67        except Exception, e: 
     68            c.xml='Error establishing security context.  Please report ' + \ 
     69                  'the error to your site administrator' 
     70            log.error("Initialising SessionMgrClient for " + \ 
     71                      "getSessionStatus call: %s" % e) 
     72            SecuritySession.delete() 
     73            response.status_code = 400 
     74            return render('content') 
     75         
     76        # Check session status 
     77        log.debug('Calling Session Manager "%s" getSessionStatus ' % \ 
     78                  session['ndgSec']['h'] + 'for user "%s" with sid="%s" ...'%\ 
     79                  (session['ndgSec']['u'], session['ndgSec']['sid'])) 
     80        try: 
     81            bSessOK = smClnt.getSessionStatus(sessID=session['ndgSec']['sid']) 
     82        except Exception, e: 
     83            c.xml = "Error checking your session details.  Please re-login" 
     84            log.error("Session Manager getSessionStatus returned: %s" % e) 
     85            SecuritySession.delete() 
     86            response.status_code = 400 
     87            return render('login') 
     88    
     89        if bSessOK: 
     90            log.debug("Session found - redirect back to site requesting " + \ 
     91                      "credentials ...") 
     92            # ... Return across http GET passing security parameters... 
    6493            return self.__doRedirect() 
    65         self.__setup() 
    66         return render_response('login') 
     94        else: 
     95            log.debug("Session wasn't found - removing security details " + \ 
     96                      "from cookie and re-displaying login...") 
     97            SecuritySession.delete() 
     98            return render('login') 
    6799 
    68100 
    69101    def getCredentials(self): 
    70102        """Authenticate user and cache user credentials in 
    71         Session Manager following user login form submit""" 
    72          
    73         try: 
    74             self.__setup() 
    75             self.__securitySetup() 
    76      
    77             smURI = self.ndgCfg.get('NDG_SECURITY', 'sessionMgrURI') 
    78      
    79             # May be better as a 'g' global set-up at start-up? 
    80             # 
    81             # tracefile could be removed for production use 
    82             smClnt = SessionMgrClient(uri=smURI, 
    83                                 sslCACertFilePathList=self.sslCACertFilePathList, 
    84                                 sslPeerCertCN=self.sslPeerCertCN, 
    85                                 signingCertFilePath=self.wssCertFilePath, 
    86                                 signingPriKeyFilePath=self.wssPriKeyFilePath, 
    87                                 signingPriKeyPwd=self.wssPriKeyPwd, 
    88                                 caCertFilePathList=self.wssCACertFilePathList, 
    89                                 tracefile=self.tracefile) 
     103        Session Manager following user login""" 
     104        log.debug("LoginController.getCredentials ...")    
     105 
     106        try:     
     107            smClnt = SessionMgrClient(uri=g.securityCfg.smURI, 
     108                    sslCACertFilePathList=g.securityCfg.sslCACertFilePathList, 
     109                    sslPeerCertCN=g.securityCfg.sslPeerCertCN, 
     110                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     111                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     112                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     113                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     114                    tracefile=g.securityCfg.tracefile) 
    90115                                 
    91116            username = request.params['username'] 
    92117            passphrase = request.params['passphrase']                      
    93118                                 
    94         except Exception,e: 
    95             c.xml='Error establishing security context [%s]'%cgi.escape(str(e)) 
    96             return Response(render('content'),code=400) 
     119        except Exception, e: 
     120            c.xml='Error establishing security context.  Please report ' + \ 
     121                  'the error to your site administrator' 
     122            log.error("Login: initialising SessionMgrClient: %s" % e) 
     123            response.status_code = 400 
     124            return render('content') 
    97125         
    98126        # Connect to Session Manager 
    99127        log.debug('Calling Session Manager "%s" connect for user "%s" ...' % \ 
    100                   (smURI, username)) 
     128                  (g.securityCfg.smURI, username)) 
    101129        try: 
    102130            sessID = smClnt.connect(username, passphrase=passphrase)[-1] 
    103131        except Exception, e: 
    104             c.xml = \ 
    105     "Error logging in.  Please check your username/pass-phrase and try again." 
     132            c.xml = "Error logging in.  Please check your username/" + \ 
     133                    "pass-phrase and try again." 
    106134            log.error("Session Manager connect returned: %s" % e) 
    107             return Response(render('login'),code=401) 
     135            response.status_code = 401 
     136            return render('login') 
    108137         
    109138        # Cache user attributes in Session Manager 
    110139        log.debug("Calling Session Manager getAttCert for user ") 
    111140        try: 
    112             # Set the Attribute Authority address for the Session Manager to 
    113             # send its attribute request to 
    114             aaURI = self.ndgCfg.get('NDG_SECURITY', 'attAuthorityURI') 
    115  
    116141            # Make request for attribute certificate 
    117             attCert = smClnt.getAttCert(sessID=sessID, attAuthorityURI=aaURI) 
     142            attCert = smClnt.getAttCert(sessID=sessID,  
     143                                        attAuthorityURI=g.securityCfg.aaURI) 
    118144        except SessionExpired, e: 
    119145            log.info("Session expired getting Attribute Certificate: %s" % e) 
    120146            c.xml = "Session has expired, please re-login" 
    121             return Response(render('login'),code=401) 
     147            response.status_code = 401 
     148            return render('login') 
    122149             
    123150        except AttributeRequestDenied, e: 
     
    125152            c.xml = "No authorisation roles are available for your " + \ 
    126153                    "account.  Please check with your site administrator." 
    127             return Response(render('login'),code=401) 
     154            response.status_code = 401 
     155            return render('login') 
    128156             
    129157        except Exception, e: 
     
    131159            c.xml = "An internal error occured.  Please report this to " + \ 
    132160                    "your site administrator." 
    133             return Response(render('login'),code=400) 
    134  
    135         log.debug('Completing login') 
    136         # Make session 
    137         # 
    138         # Security credentials - proxyCert, userCert, ProxyPriKey and sessID 
    139         # could be held in the session but how secure is 
    140          
    141         # Make a security cookie here ... 
    142         setSecuritySession(h=smURI,u=username,roles=attCert.roles,sid=sessID) 
    143         session['panelView']='History' 
     161            response.status_code = 400 
     162            return render('login') 
     163 
     164        log.debug('Completing login...') 
     165         
     166        # Make security session details 
     167        setSecuritySession(h=g.securityCfg.smURI, 
     168                           u=username, 
     169                           org=attCert.issuerName, 
     170                           roles=attCert.roles, 
     171                           sid=sessID) 
    144172        session.save() 
    145173 
     
    151179    def wayf(self): 
    152180        ''' NDG equivalent to Shibboleth WAYF ''' 
    153          
    154         self.__setup() 
    155         self.__securitySetup() 
    156          
    157         aaURI = self.ndgCfg.get('NDG_SECURITY', 'attAuthorityURI') 
     181        log.debug("LoginController.wayf ...")    
    158182 
    159183        # May be better as a 'g' global set-up at start-up? 
    160184        # 
    161185        # tracefile could be removed for production use 
    162         aaClnt = AttAuthorityClient(uri=aaURI, 
    163                                 signingCertFilePath=self.wssCertFilePath, 
    164                                 signingPriKeyFilePath=self.wssPriKeyFilePath, 
    165                                 signingPriKeyPwd=self.wssPriKeyPwd, 
    166                                 caCertFilePathList=self.wssCACertFilePathList, 
    167                                 tracefile=self.tracefile) 
     186        aaClnt = AttAuthorityClient(uri=g.securityCfg.aaURI, 
     187                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     188                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     189                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     190                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     191                    tracefile=g.securityCfg.tracefile) 
    168192 
    169193        # Get list of login uris for trusted sites including THIS one 
    170194        log.debug("Calling Attribute Authority getTrustedHostInfo and " + \ 
    171195                  "getHostInfo for wayf") 
    172         trustedHosts = aaClnt.getTrustedHostInfo() 
    173         thisHost = aaClnt.getHostInfo() 
    174          
    175         try: 
    176             trustedHosts[thisHost.keys()[0]] = thisHost.values()[0] 
    177         except TypeError: 
    178             raise LoginControllerError, \ 
    179                         "thisHost returned from Attribute Authority is empty"  
    180              
    181         c.providers=dict([(k,v['loginURI']) for k,v in trustedHosts.items()]) 
    182          
    183         if 'panelView' in session: del session['panelView'] 
     196 
     197        hosts = aaClnt.getAllHostsInfo()     
     198        c.providers=dict([(k, v['loginURI']) for k, v in hosts.items()]) 
     199         
    184200        session.save() 
    185         return render_response('wayf') 
     201         
     202        return render('wayf') 
     203         
    186204         
    187205    def __doRedirect(self): 
    188          
    189         # Need to pass security creds back to requestor so that they can make 
    190         # a cookie.  If the requestor is in the same domain as the login then 
    191         # this is not necessary. 
     206        """Pass security creds back to requestor so that they can make 
     207        a cookie.  If the requestor is in the same domain as the login then 
     208        this is not necessary.""" 
     209         
    192210        # and now go back to whence we had come 
    193211        if c.returnTo!='': 
     
    202220            log.debug('Login redirect to [%s]' % cc) 
    203221 
    204             returnToHostname = urlparse(cc)[1] 
    205  
    206             if thisHostname not in returnToHostname: 
     222            returnToHostname = urlsplit(cc)[1] 
     223#            returnToHostname = 'localhost' 
     224#            if thisHostname not in returnToHostname: 
     225            if True: 
    207226                # Returning to a different domain - copy the security session 
    208227                # details into the URL query string 
     
    211230                else: 
    212231                    cc+='?%s' % LoginServiceQuery() 
    213  
     232             
     233            # Check return-to address by examining peer cert 
     234            log.debug("Checking return-to URL for valid SSL peer cert. ...") 
     235             
     236            # Look-up list of Cert DNs for trusted requestors 
     237            aaClnt = AttAuthorityClient(uri=g.securityCfg.aaURI, 
     238                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     239                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     240                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     241                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     242                    tracefile=g.securityCfg.tracefile) 
     243             
     244            HostInfo = aaClnt.getAllHostsInfo() 
     245            requestServerDN = [val['loginRequestServerDN'] \ 
     246                               for val in HostInfo.values()] 
     247            log.debug("Expecting DN for SSL peer one of: %s"%requestServerDN) 
     248            hostCheck=HostCheck(acceptedDNs=requestServerDN, 
     249                    caCertFilePathList=g.securityCfg.sslCACertFilePathList)             
     250            testConnection = HTTPSConnection(returnToHostname,  
     251                                             None,  
     252                                             postConnectionCheck=hostCheck) 
     253 
     254            log.debug('Testing connection to "%s"' % returnToHostname) 
     255            try: 
     256                try: 
     257                    testConnection.connect() 
     258                except (InvalidCertSignature, InvalidCertDN), e: 
     259                    log.error("Login: requestor SSL certificate: %s" % e) 
     260                    c.xml = """Request to redirect back to %s with your  
     261credentials refused: there is a problem with the SSL certificate of this site. 
     262  Please report this to your site administrator.""" % returnToHostname 
     263                    response.status_code = 400 
     264                    return render('login') 
     265            finally:     
     266                testConnection.close() 
     267 
     268            log.debug("SSL peer cert. is OK - redirecting to [%s] ..." % cc) 
    214269            h.redirect_to(cc) 
    215270        else: 
    216271            c.xml='<p> Logged in </p>' 
    217             return render_response('content') 
     272            return render('content') 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/LoginService/loginservice/lib/app_globals.py

    r2918 r3652  
     1"""The application's Globals object""" 
     2from pylons import config 
     3 
    14class Globals(object): 
     5    """Globals acts as a container for objects available throughout the 
     6    life of the application 
     7    """ 
    28 
    3     def __init__(self, global_conf, app_conf, **extra): 
    4         """ 
    5         Globals acts as a container for objects available throughout 
    6         the life of the application. 
    7  
    8         One instance of Globals is created by Pylons during 
    9         application initialization and is available during requests 
    10         via the 'g' variable. 
    11          
    12         ``global_conf`` 
    13             The same variable used throughout ``config/middleware.py`` 
    14             namely, the variables from the ``[DEFAULT]`` section of the 
    15             configuration file. 
    16              
    17         ``app_conf`` 
    18             The same ``kw`` dictionary used throughout 
    19             ``config/middleware.py`` namely, the variables from the 
    20             section in the config file for your application. 
    21              
    22         ``extra`` 
    23             The configuration returned from ``load_config`` in  
    24             ``config/middleware.py`` which may be of use in the setup of 
    25             your global variables. 
    26              
     9    def __init__(self): 
     10        """One instance of Globals is created during application 
     11        initialization and is available during requests via the 'g' 
     12        variable 
    2713        """ 
    2814        pass 
    29          
    30     def __del__(self): 
    31         """ 
    32         Put any cleanup code to be run when the application finally exits  
    33         here. 
    34         """ 
    35         pass 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/LoginService/loginservice/lib/helpers.py

    r2918 r3652  
    55""" 
    66from webhelpers import * 
    7 from pylons.helpers import log 
     7from pylons.controllers.util import log 
    88from pylons.i18n import get_lang, set_lang 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/__init__.py

    r3153 r3652  
    354354        'keyPwd':                 None, 
    355355        'clntCertFile':           None, 
     356        'wssRefInclNS':           [], 
     357        'wssSignedInfoInclNS':    [], 
    356358        'sessMgrEncrKey':         None,  
    357359        'sessMgrURI':             None, 
     
    658660                    # trailing white space 
    659661                    if isinstance(self.__validElem[elem.tag], list): 
    660                         self.__prop[elem.tag] = [filtElemTxt(subElem) \ 
    661                                                  for subElem in elem] 
     662                        if len(elem) == 0 and elem.text is not None: 
     663                            # Treat as a list of space separated elements 
     664                            self.__prop[elem.tag] = elem.text.split() 
     665                        else: 
     666                            # Parse from a list of sub-elements 
     667                            self.__prop[elem.tag] = [filtElemTxt(subElem) \ 
     668                                                     for subElem in elem] 
    662669                         
    663670                    elif elem.text is not None and elem.tag != 'keyPwd':                         
     
    932939            # and session ID 
    933940            # 
    934             # Nb. Client pub/pri key info to allow message level  
    935             # encryption for responses from Attribute Authority WS 
     941            wssSignatureHandlerKw = { 
     942            'refC14nKw': {'unsuppressedPrefixes': self.__prop['wssRefInclNS']}, 
     943            'signedInfoC14nKw':{'unsuppressedPrefixes': 
     944                                self.__prop['wssSignedInfoInclNS']}} 
     945 
    936946            try:    
    937947                userSess = UserSession(credRepos=self.__credRepos,  
    938948                             caCertFilePathList=self.__prop['caCertFileList'], 
     949                             wssSignatureHandlerKw=wssSignatureHandlerKw, 
    939950                             *creds)       
    940951            except Exception, e: 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/attAuthority.tac

    r3135 r3652  
    247247    # Initialise WS-Security signature handler passing Attribute Authority 
    248248    # public and private keys 
     249     
     250    # Inclusive namespaces for Exclusive C14N 
     251    refC14nKw = {'unsuppressedPrefixes': srv.aa['wssRefInclNS']} 
     252    signedInfoC14nKw = {'unsuppressedPrefixes': 
     253                        srv.aa['wssSignedInfoInclNS']} 
     254     
    249255    WSSecurityHandler.signatureHandler = SignatureHandler(\ 
    250                                 verifyingCertFilePath=srv.aa['clntCertFile'], 
    251                                 signingCertFilePath=srv.aa['certFile'], 
    252                                 signingPriKeyFilePath=srv.aa['keyFile'], 
    253                                 signingPriKeyPwd=srv.aa['keyPwd'], 
    254                                 caCertFilePathList=srv.aa.get('caCertFileList')) 
     256                                        verifyingCertFilePath=srv.aa['clntCertFile'], 
     257                                        signingCertFilePath=srv.aa['certFile'], 
     258                                        signingPriKeyFilePath=srv.aa['keyFile'], 
     259                                        signingPriKeyPwd=srv.aa['keyPwd'], 
     260                                        caCertFilePathList=srv.aa.get('caCertFileList'), 
     261                                        refC14nKw=refC14nKw, 
     262                                        signedInfoC14nKw=signedInfoC14nKw) 
    255263 
    256264# Add Service to Attribute Authority branch 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/attAuthorityProperties.xml

    r3199 r3652  
    1919    <sslCACertDir>$NDGSEC_DIR/conf/certs/ca</sslCACertDir> 
    2020    <!-- 
    21     PKI settings for signature of outbound SOAP messages 
     21    WS-Security settings for signature of outbound SOAP messages 
    2222    --> 
    2323    <useSignatureHandler>Yes</useSignatureHandler> <!-- leave blank for no signature --> 
     
    2525    <keyFile>$NDGSEC_DIR/conf/certs/aa-key.pem</keyFile> 
    2626    <keyPwd></keyPwd> 
     27        <!--  
     28        Inclusive namespace prefixes for reference and SignedInfo sections of 
     29        WS-Security digital signature 
     30        --> 
     31        <wssRefInclNS></wssRefInclNS> 
     32        <wssSignedInfoInclNS></wssSignedInfoInclNS> 
    2733    <!--  
    2834    CA Certificates used to verify X.509 certs used in peer SOAP messages, 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/sessionMgr.tac

    r3145 r3652  
    216216        # Initialise WS-Security signature handler passing Session Manager 
    217217        # public and private keys 
     218     
     219    # Inclusive namespaces for Exclusive C14N 
     220        refC14nKw = {'unsuppressedPrefixes': srv.sm['wssRefInclNS']} 
     221        signedInfoC14nKw = {'unsuppressedPrefixes': 
     222                                            srv.sm['wssSignedInfoInclNS']} 
     223 
    218224        WSSecurityHandler.signatureHandler = SignatureHandler(\ 
    219225                                                        verifyingCertFilePath=srv.sm['clntCertFile'], 
     
    221227                            signingPriKeyFilePath=srv.sm['keyFile'], 
    222228                            signingPriKeyPwd=srv.sm['keyPwd'], 
    223                             caCertFilePathList=srv.sm.get('caCertFileList')) 
     229                            caCertFilePathList=srv.sm.get('caCertFileList'), 
     230                                        refC14nKw=refC14nKw, 
     231                                        signedInfoC14nKw=signedInfoC14nKw) 
    224232 
    225233# Add Service to Session Manager branch 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/sessionMgrProperties.xml

    r3199 r3652  
    2626    <!-- Password protecting private key file - leave blank if none set --> 
    2727    <keyPwd></keyPwd> 
     28        <wssRefInclNS></wssRefInclNS> 
     29        <wssSignedInfoInclNS></wssSignedInfoInclNS> 
    2830    <!--  
    2931    CA Certificates used to verify X.509 certs used in peer SOAP messages, 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/simpleCAProperties.xml

    r2148 r3652  
    99    <keyFile></keyFile> 
    1010    <keyPwd></keyPwd> 
     11        <wssRefInclNS></wssRefInclNS> 
     12        <wssSignedInfoInclNS></wssSignedInfoInclNS> 
    1113    <!--  
    1214    Set the certificate used to verify the signature of messages from the  
Note: See TracChangeset for help on using the changeset viewer.