Changeset 2929


Ignore:
Timestamp:
05/10/07 12:02:32 (12 years ago)
Author:
pjkersha
Message:

MAjor change to enable login transactions to operate over https.

ndgDiscovery.config: added sslServer param for https virtual host to serve secured login

ows_server/models/ndgSecurity.py:

  • access config params via g.securityCfg set in ndgMiddleware
  • improved error reporting

ows_server/config/ndgMiddleware.py: added global settings ...

  • sslServer - virtual host for running login transactions over https
  • securityCfg - security configuration parameters

ows_server/controllers/login.py:

  • urlsplit instead of urlparse
  • use ndg.security.common.m2CryptoSSLUtility.HTTPSConnection to check peer cert prior to redirect back to login requestor in LoginController?.doRedirect
  • replace 'setup' with 'before'. Latter is pylons/paste convenience method enabling settings to be made prior to each action
  • removed 'securitySetup' - this is done in ndgMiddleware at start-up
  • Nb. in doRedirect - currently set to always return params over http GET even if requestor and logi service are in the same domain - this is for testing only

ows_server/controllers/logout.py:

  • replace 'setup' with 'before'.
  • removed 'securitySetup' - this is done in ndgMiddleware at start-up

ows_server/lib/security_util.py:

  • Added SecurityConfig? class - a container for security config items held by 'g' global variable.

ows_server/lib/base.py: on setting of security params from LoginService? redirect back to http from https

ows_server/templates/ndgPage.kid: removed Session Manager address from the display - not needed for the user to see.

ows_server/templates/wayf.kid: ensure return URL is switched to https from http so that GET query args are hidden.

Location:
TI05-delivery/ows_framework/trunk/ows_server
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • TI05-delivery/ows_framework/trunk/ows_server/ndgDiscovery.config

    r2878 r2929  
    112112 
    113113[NDG_SECURITY] 
    114 # Debug e.g. open(<somefile>, 'w') 
     114# Server address for secure connections 
     115sslServer: https://localhost 
     116 
     117# Redirect SOAP output to a file e.g. open(<somefile>, 'w') 
    115118#tracefile: None 
    116119tracefile: sys.stderr 
     
    120123sessionMgrURI: https://glue.badc.rl.ac.uk:50000/SessionManager 
    121124#attAuthorityURI: http://localhost:5000/AttributeAuthority 
    122 attAuthorityURI: http://glue.badc.rl.ac.uk/services/ndg/security/AttributeAuthority 
     125attAuthorityURI: http://aa.ceda.rl.ac.uk 
    123126 
    124127# WS-Security signature handler 
     
    154157# Certificate submitted in order to gain access 
    155158acIssuer: /CN=AttributeAuthority/O=NDG/OU=BADC 
     159#acIssuer: /CN=Junk/O=NDG/OU=Gabriel 
    156160 
    157161# verification of X.509 cert back to CA 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/config/ndgMiddleware.py

    r2858 r2929  
    22from paste.deploy import CONFIG 
    33from ows_server.models.Utilities import myConfig 
     4from ows_server.lib.security_util import SecurityConfig 
     5 
    46class ndgMiddleware: 
    57     
     
    4042         
    4143        self.globals.server=cf.get('DEFAULT','server','') 
     44 
     45        # Security Related 
    4246        self.globals.wayfuri='%s/wayf'%self.globals.server 
    43         self.globals.getCredentials='%s/getCredentials'%self.globals.server 
    44          
     47 
     48        # Use secure connection 
     49        self.globals.sslServer=cf.get('NDG_SECURITY','sslServer','') 
     50        self.globals.getCredentials='%s/getCredentials'%self.globals.sslServer        
    4551        self.globals.logout='%s/logout'%self.globals.server 
     52        self.globals.securityCfg = SecurityConfig(cf) 
    4653         
    4754        self.config=cf 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/login.py

    r2881 r2929  
    11import sys,cgi 
    2 from urlparse import urlparse 
     2from urlparse import urlsplit 
    33import base64 
    44 
     
    1313from ndg.security.common.SessionMgr import SessionMgrClient, SessionExpired, \ 
    1414    AttributeRequestDenied 
     15from ndg.security.common.m2CryptoSSLUtility import HTTPSConnection, \ 
     16    HostCheck, InvalidCertSignature 
    1517 
    1618 
    1719class LoginController(BaseController): 
    1820    ''' Provides the pylons controller for local login ''' 
     21 
     22    def __call__(self, environ, start_response): 
     23        """Update c.requestURL and c.b64encRequestURL using g.server setting 
     24        to avoid exposing the absolute URL hidden behind the proxy""" 
     25                 
     26        # Insert any code to be run per request here. The Routes match 
     27        # is under environ['pylons.routes_dict'] should you want to check 
     28        # the action or route vars here 
     29 
     30        log.debug("LoginController.__call__ calling BaseController.__call__ ...") 
     31        response = super(LoginController, self).__call__(environ, start_response) 
     32 
     33         
     34        # Construct URL picking up setting of server name from config to  
     35        # avoid exposing absolute URL hidden behind mod_proxy see #857             
     36        c.requestURL = g.server + urllib.quote(environ.get('PATH_INFO', '')) 
     37 
     38        query = '&'.join(["%s=%s" % item for item in request.params.items()]) 
     39        if query: 
     40            c.requestURL += '?' + query 
     41 
     42        # Base 64 encode to enable passing around in 'r' argument of query 
     43        # string for use with login/logout 
     44        c.b64encRequestURL = urlsafe_b64encode(c.requestURL) 
     45         
     46        return response 
    1947     
    20     def __setup(self): 
    21         """Get 'r' return to URL argument from current URL query string""" 
    22         #where are we going back to? 
    23 #        self.inputs=dict(parse_querystring(request.environ)) 
    24 #        if 'r' in self.inputs: 
    25 #            c.returnTo=self.inputs['r'] 
    26 #        elif 'HTTP_REFERER' in request.environ: 
    27 #            #Added by Dom, 06/07/07 
    28 #            #http redirect  based on parse_querystring wasn't working so added this condition 
    29 #            #NOTE:  Not been able to test whether this has broken discovery/browse due to missing templates. 
    30 #            c.returnTo=request.environ['HTTP_REFERER'] 
    31         # Try request.params - above method skips 'r' when passed in a hidden 
    32         # field in a HTTP POST 
    33         c.returnTo=request.params.get('r','') 
    34              
    35  
    36     def __securitySetup(self): 
    37         '''PKI settings for Attribute Authority and Session Manager''' 
    38          
    39         self.ndgCfg = request.environ['ndgConfig'] 
    40  
    41         tracefileExpr = self.ndgCfg.get('NDG_SECURITY', 'tracefile') 
    42         if tracefileExpr: 
    43             self.tracefile = eval(tracefileExpr) 
    44          
    45         # ... for SSL connections to security web services 
    46         try: 
    47             self.sslCACertFilePathList = \ 
    48             self.ndgCfg.get('NDG_SECURITY', 'sslCACertFilePathList').split() 
    49                  
    50         except AttributeError: 
    51             raise OwsError, 'No "sslCACertFilePathList" security setting' 
    52  
    53         self.sslPeerCertCN = self.ndgCfg.get('NDG_SECURITY', 'sslPeerCertCN') 
    54  
    55         # ...and for WS-Security digital signature 
    56         self.wssCertFilePath = self.ndgCfg.get('NDG_SECURITY',  
    57                                                'wssCertFilePath') 
    58         self.wssPriKeyFilePath = self.ndgCfg.get('NDG_SECURITY',  
    59                                                  'wssKeyFilePath') 
    60         self.wssPriKeyPwd = self.ndgCfg.get('NDG_SECURITY', 'wssKeyPwd') 
    61  
    62         try: 
    63             self.wssCACertFilePathList = \ 
    64             self.ndgCfg.get('NDG_SECURITY', 'wssCACertFilePathList').split() 
    65                  
    66         except AttributeError: 
    67             raise OwsError, 'No "wssCACertFilePathList" security setting' 
     48     
     49    def __before__(self, action):  
     50        """For each action, get 'r' return to URL argument from current URL  
     51        query string.  c.returnTo is used in some of the .kid files""" 
     52        c.returnTo = request.params.get('r', '') 
    6853 
    6954     
    7055    def index(self): 
    7156        ''' Ok, you really want to login here ''' 
     57        log.debug("LoginController.index ...")    
     58 
    7259        if 'ndgSec' in session:  
     60            # Session is set in this domain - copy its content 
     61            # and return it across http GET to caller 
    7362            return self.__doRedirect() 
    74         self.__setup() 
    75         return render_response('login') 
     63        else: 
     64            return render_response('login') 
    7665 
    7766 
     
    7968        """Authenticate user and cache user credentials in 
    8069        Session Manager following user login""" 
    81          
    82         try: 
    83             self.__setup() 
    84             self.__securitySetup() 
    85      
    86             smURI = self.ndgCfg.get('NDG_SECURITY', 'sessionMgrURI') 
    87      
    88             # May be better as a 'g' global set-up at start-up? 
    89             # 
    90             # tracefile could be removed for production use 
    91             smClnt = SessionMgrClient(uri=smURI, 
    92                                 sslCACertFilePathList=self.sslCACertFilePathList, 
    93                                 sslPeerCertCN=self.sslPeerCertCN, 
    94                                 signingCertFilePath=self.wssCertFilePath, 
    95                                 signingPriKeyFilePath=self.wssPriKeyFilePath, 
    96                                 signingPriKeyPwd=self.wssPriKeyPwd, 
    97                                 caCertFilePathList=self.wssCACertFilePathList, 
    98                                 tracefile=self.tracefile) 
     70        log.debug("LoginController.getCredentials ...")    
     71 
     72        try:     
     73            smClnt = SessionMgrClient(uri=g.securityCfg.smURI, 
     74                    sslCACertFilePathList=g.securityCfg.sslCACertFilePathList, 
     75                    sslPeerCertCN=g.securityCfg.sslPeerCertCN, 
     76                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     77                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     78                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     79                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     80                    tracefile=g.securityCfg.tracefile) 
    9981                                 
    10082            username = request.params['username'] 
     
    10789        # Connect to Session Manager 
    10890        log.debug('Calling Session Manager "%s" connect for user "%s" ...' % \ 
    109                   (smURI, username)) 
     91                  (g.securityCfg.smURI, username)) 
    11092        try: 
    11193            sessID = smClnt.connect(username, passphrase=passphrase)[-1] 
     
    11496    "Error logging in.  Please check your username/pass-phrase and try again." 
    11597            log.error("Session Manager connect returned: %s" % e) 
    116             return Response(render('login'),code=401) 
     98            return Response(render('login'), code=401) 
    11799         
    118100        # Cache user attributes in Session Manager 
    119101        log.debug("Calling Session Manager getAttCert for user ") 
    120102        try: 
    121             # Set the Attribute Authority address for the Session Manager to 
    122             # send its attribute request to 
    123             aaURI = self.ndgCfg.get('NDG_SECURITY', 'attAuthorityURI') 
    124  
    125103            # Make request for attribute certificate 
    126             attCert = smClnt.getAttCert(sessID=sessID, attAuthorityURI=aaURI) 
     104            attCert = smClnt.getAttCert(sessID=sessID,  
     105                                        attAuthorityURI=g.securityCfg.aaURI) 
    127106        except SessionExpired, e: 
    128107            log.info("Session expired getting Attribute Certificate: %s" % e) 
    129108            c.xml = "Session has expired, please re-login" 
    130             return Response(render('login'),code=401) 
     109            return Response(render('login'), code=401) 
    131110             
    132111        except AttributeRequestDenied, e: 
     
    134113            c.xml = "No authorisation roles are available for your " + \ 
    135114                    "account.  Please check with your site administrator." 
    136             return Response(render('login'),code=401) 
     115            return Response(render('login'), code=401) 
    137116             
    138117        except Exception, e: 
     
    140119            c.xml = "An internal error occured.  Please report this to " + \ 
    141120                    "your site administrator." 
    142             return Response(render('login'),code=400) 
    143  
    144         log.debug('Completing login') 
     121            return Response(render('login'), code=400) 
     122 
     123        log.debug('Completing login...') 
     124         
    145125        # Make session 
    146126        # 
     
    149129         
    150130        # Make a security cookie here ... 
    151         setSecuritySession(h=smURI,u=username,roles=attCert.roles,sid=sessID) 
     131        setSecuritySession(h=g.securityCfg.smURI, 
     132                           u=username, 
     133                           roles=attCert.roles, 
     134                           sid=sessID) 
    152135        session['panelView']='History' 
    153136        session.save() 
    154137 
     138        log.info("user %s logged in with roles %s" % (session['ndgSec']['u'], 
     139                                                  session['ndgSec']['roles'])) 
    155140        return self.__doRedirect() 
    156141             
     
    158143    def wayf(self): 
    159144        ''' NDG equivalent to Shibboleth WAYF ''' 
    160          
    161         self.__setup() 
    162         self.__securitySetup() 
    163          
    164         aaURI = self.ndgCfg.get('NDG_SECURITY', 'attAuthorityURI') 
     145        log.debug("LoginController.wayf ...")    
    165146 
    166147        # May be better as a 'g' global set-up at start-up? 
    167148        # 
    168149        # tracefile could be removed for production use 
    169         aaClnt = AttAuthorityClient(uri=aaURI, 
    170                                 signingCertFilePath=self.wssCertFilePath, 
    171                                 signingPriKeyFilePath=self.wssPriKeyFilePath, 
    172                                 signingPriKeyPwd=self.wssPriKeyPwd, 
    173                                 caCertFilePathList=self.wssCACertFilePathList, 
    174                                 tracefile=self.tracefile) 
     150        aaClnt = AttAuthorityClient(uri=g.securityCfg.aaURI, 
     151                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     152                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     153                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     154                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     155                    tracefile=g.securityCfg.tracefile) 
    175156 
    176157        # Get list of login uris for trusted sites including THIS one 
     
    190171        if 'panelView' in session: del session['panelView'] 
    191172        session.save() 
     173         
    192174        return render_response('wayf') 
    193175         
    194176    def __doRedirect(self): 
    195          
    196         # Need to pass security creds back to requestor so that they can make 
    197         # a cookie.  If the requestor is in the same domain as the login then 
    198         # this is not necessary. 
     177        """Pass security creds back to requestor so that they can make 
     178        a cookie.  If the requestor is in the same domain as the login then 
     179        this is not necessary.""" 
     180         
    199181        # and now go back to whence we had come 
    200         log.debug('Login redirect to [%s]'%c.returnTo) 
    201182        if c.returnTo!='': 
    202183            # is there a keyword on redirect_to that can make this https? See: 
     
    208189            # Decode return to address 
    209190            cc = base64.urlsafe_b64decode(c.returnTo) 
    210  
    211             returnToHostname = urlparse(cc)[1] 
    212  
    213             if thisHostname not in returnToHostname: 
     191            log.debug('Login redirect to [%s]' % cc) 
     192 
     193            returnToHostname = urlsplit(cc)[1] 
     194 
     195#            if thisHostname not in returnToHostname: 
     196            if True: 
     197                # Returning to a different domain - copy the security session 
     198                # details into the URL query string 
    214199                if '?' in cc: 
    215200                    cc+='&%s' % LoginServiceQuery() 
    216201                else: 
    217202                    cc+='?%s' % LoginServiceQuery() 
    218  
     203             
     204            # Check return-to address by examining peer cert 
     205            log.debug("Checking return-to URL for valid SSL peer cert. ...") 
     206            hostCheck=HostCheck(caCertFilePathList=g.securityCfg.sslCACertFilePathList)             
     207            cxn = HTTPSConnection(returnToHostname,  
     208                                  None,  
     209                                  postConnectionCheck=hostCheck) 
     210            try: 
     211                try: 
     212                    cxn.connect() 
     213                except InvalidCertSignature, e: 
     214                    log.error("Login: requestor SSL cert.: %s" % e) 
     215                    c.xml = "There is a problem with the SSL certificate of"+\ 
     216                            " the site requesting your login details. " + \ 
     217                            " Please report this to your site administrator." 
     218                    return Response(render('login'), code=400) 
     219            finally:     
     220                cxn.close() 
     221 
     222            log.debug("SSL peer cert. is OK - redirecting to [%s] ..." % cc) 
    219223            h.redirect_to(cc) 
    220224        else: 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/controllers/logout.py

    r2880 r2929  
    1414    ''' Provides the pylons controller for logging out and killing the cookies ''' 
    1515     
    16     def __setup(self): 
    17         #where are we going back to? 
    18         self.inputs=dict(parse_querystring(request.environ)) 
    19         if 'r' in self.inputs: 
    20             c.returnTo=self.inputs['r'] 
    21         else: 
    22             c.returnTo='' 
    23  
    24         self.__securitySetup() 
    25          
    26          
    27     def __securitySetup(self): 
    28         '''PKI settings for 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 OwsError, '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 OwsError, 'No "wssCACertFilePathList" security setting' 
     16    def __before__(self): 
     17        """Get return to URL""" 
     18        c.returnTo = request.params.get('r', '') 
    5919 
    6020     
    6121    def index(self): 
    6222        ''' Ok, you really want to logout here ''' 
    63         self.__setup() 
    6423 
    6524        if 'ndgSec' not in session: 
     
    6827            return self.__redirect() 
    6928         
    70         # Look into the session and go kill the wallet 
    71         smURI = self.ndgCfg.get('NDG_SECURITY', 'sessionMgrURI') 
    72  
    73         # May be better as a 'g' global set-up at start-up? 
    74         # 
    75         # tracefile could be removed for production use 
    7629        try: 
    77             smClnt = SessionMgrClient(uri=smURI, 
    78                             sslCACertFilePathList=self.sslCACertFilePathList, 
    79                             sslPeerCertCN=self.sslPeerCertCN, 
    80                             signingCertFilePath=self.wssCertFilePath, 
    81                             signingPriKeyFilePath=self.wssPriKeyFilePath, 
    82                             signingPriKeyPwd=self.wssPriKeyPwd, 
    83                             caCertFilePathList=self.wssCACertFilePathList, 
    84                             tracefile=self.tracefile)        
     30            smClnt = SessionMgrClient(uri=g.securityCfg.smURI, 
     31                    sslCACertFilePathList=g.securityCfg.sslCACertFilePathList, 
     32                    sslPeerCertCN=g.securityCfg.sslPeerCertCN, 
     33                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     34                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     35                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     36                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     37                    tracefile=g.securityCfg.tracefile)        
    8538        except Exception, e: 
    8639            log.error("logout - creating Session Manager client: %s" % e) 
     
    8942        # Disconnect from Session Manager 
    9043        log.info('Calling Session Manager "%s" disconnect for logout...' % \ 
    91                  smURI) 
     44                 g.securityCfg.smURI) 
    9245        try: 
    9346            smClnt.disconnect(sessID=session['ndgSec']['sid']) 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/base.py

    r2905 r2929  
    11import urllib 
     2from urlparse import urlsplit, urlunsplit 
    23from base64 import urlsafe_b64encode 
    34from pylons import Response, c, g, cache, request, session 
     
    2324 
    2425import logging 
    25 logger = logging.getLogger('ows_server.lib.base') 
     26logger = logging.getLogger(__name__) 
    2627 
    2728# Configure 
     
    3637        # is under environ['pylons.routes_dict'] should you want to check 
    3738        # the action or route vars here 
     39 
     40        logger.debug("BaseController.__call__ ...") 
    3841         
    3942        # construct URL picking up setting of server name from config to  
     
    4649            c.requestURL += '?' + query 
    4750 
     51        logger.debug("BaseController.__call__ URL = [%s]" % c.requestURL) 
     52 
    4853        # Base 64 encode to enable passing around in 'r' argument of query 
    4954        # string for use with login/logout 
     
    5156 
    5257        if 'h' in request.params: 
     58            # 'h' corresponds to the setting of a session manager host i.e. 
     59            # the request has come from a completed login from the login  
     60            # service 
     61            logger.debug("Setting security session from URL query args ...") 
     62             
     63            # Copy the query arguments into security session keys 
    5364            setSecuritySession() 
    5465             
     
    5768            session.save() 
    5869             
    59             # TODO Make the redirect tidier ... 
     70            # Re-construct the URL removing the security related arguments 
    6071            qs = LoginServiceQuery.stripFromURI() 
    6172 
    62             cc=construct_url(environ,querystring=qs) 
     73            logger.debug('Switching from https to http...') 
     74            cc = g.server + urllib.quote(environ.get('PATH_INFO','')) 
     75            if qs: 
     76                cc += "?" + qs 
     77                 
     78            logger.debug('URL transport switched to http: "%s"' % cc) 
    6379            h.redirect_to(cc) 
    64          
     80 
     81                 
    6582        #organise the information needed by pagetabs ...  
    6683        # TODO avoid this for the server controllers ... 
     
    101118                r.headers['content-type'] = 'text/xml' 
    102119                return r 
    103              
    104   
     120 
     121 
    105122    def _fixOwsAction(self, environ): 
    106123        # Override the Routes action from the request query parameter 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/lib/security_util.py

    r2858 r2929  
    99""" 
    1010__revision__ = '$Id:$' 
     11 
     12import logging 
     13log = logging.getLogger(__name__) 
    1114 
    1215from pylons import session, request 
     
    5154        session[SecuritySession.key].update(subKeys)             
    5255        session.save() 
     56        log.debug("Set security session: %s" % session[SecuritySession.key]) 
    5357 
    5458    @classmethod 
     
    5862            del session[SecuritySession.key] 
    5963            session.save() 
     64        log.debug("Deleted security key to session object: %s" % session) 
    6065             
    6166setSecuritySession = SecuritySession 
     
    128133 
    129134        return keys 
     135     
     136import sys 
     137 
     138class SecurityConfigError(Exception): 
     139    """Handle errors from parsing security config items""" 
     140        
     141class SecurityConfig(object): 
     142    """Get Security related parameters from the Pylons NDG config file""" 
     143 
     144    def __init__(self, cfg=None): 
     145        '''Get PKI settings for Attribute Authority and Session Manager from 
     146        the configuration file 
     147         
     148        @type param: pylons config file object 
     149        @param cfg: reference to NDG configuration file.  If omitted defaults 
     150        to request.environ['ndgConfig']''' 
     151         
     152        if cfg is None: 
     153            cfg = request.environ['ndgConfig'] 
     154 
     155        tracefileExpr = cfg.get('NDG_SECURITY', 'tracefile') 
     156        if tracefileExpr: 
     157            self.tracefile = eval(tracefileExpr) 
     158 
     159        self.smURI = cfg.get('NDG_SECURITY', 'sessionMgrURI')         
     160        self.aaURI = cfg.get('NDG_SECURITY', 'attAuthorityURI') 
     161         
     162        # ... for SSL connections to security web services 
     163        try: 
     164            self.sslCACertFilePathList = \ 
     165            cfg.get('NDG_SECURITY', 'sslCACertFilePathList').split() 
     166                 
     167        except AttributeError: 
     168            raise SecurityConfigError, \ 
     169                        'No "sslCACertFilePathList" security setting' 
     170 
     171        self.sslPeerCertCN = cfg.get('NDG_SECURITY', 'sslPeerCertCN') 
     172 
     173        # ...and for WS-Security digital signature 
     174        self.wssCertFilePath = cfg.get('NDG_SECURITY', 'wssCertFilePath') 
     175        self.wssPriKeyFilePath = cfg.get('NDG_SECURITY', 'wssKeyFilePath') 
     176        self.wssPriKeyPwd = cfg.get('NDG_SECURITY', 'wssKeyPwd') 
     177 
     178        try: 
     179            self.wssCACertFilePathList = \ 
     180                cfg.get('NDG_SECURITY', 'wssCACertFilePathList').split() 
     181                 
     182        except AttributeError: 
     183            raise SecurityConfigError, \ 
     184                                'No "wssCACertFilePathList" security setting' 
     185         
     186    def __repr__(self): 
     187        return '\n'.join(["%s=%s" % (k,v) for k,v in self.__dict__.items() \ 
     188                if k[:2] != "__"]) 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/models/ndgSecurity.py

    r2878 r2929  
    4747        self.securityElement = securityElement 
    4848        self.securityTokens = securityTokens 
    49          
    50          
    51         # we need access to the config file to get the various PKI certificates. 
    52         # note that this is already a config parser instance 
    53         try: 
    54             self.ndgCfg = request.environ['ndgConfig'] 
    55             self.tracefile = eval(self.ndgCfg.get('NDG_SECURITY', 
    56                                                   'tracefile', 
    57                                                   None)) 
    58         except: 
    59             raise OwsError('NDG Security not enabled') 
    60          
    61         # ... for SSL connections to security web services 
    62         try:     
    63             
    64             m='sslCACertFilePathList' 
    65             self.sslCACertFilePathList = \ 
    66             self.ndgCfg.get('NDG_SECURITY',m).split() 
    67              
    68             m='sslPeerCertCN' 
    69             self.sslPeerCertCN = self.ndgCfg.get('NDG_SECURITY',m) 
    70                  
    71             # ...and for WS-Security digital signature 
    72             m='wssCertFilePath' 
    73             self.wssCertFilePath = self.ndgCfg.get('NDG_SECURITY',m)  
    74             m='wssKeyFilePath' 
    75             self.wssPriKeyFilePath = self.ndgCfg.get('NDG_SECURITY',m) 
    76             m='wssKeyPwd' 
    77             self.wssPriKeyPwd = self.ndgCfg.get('NDG_SECURITY',m)     
    78             m='wssCACertFilePathList' 
    79             self.wssCACertFilePathList=self.ndgCfg.get('NDG_SECURITY',m).split() 
    80              
    81             # Attribute Certificate verification of X.509 cert chain back to CA 
    82             m='acCACertFilePathList' 
    83             self.acCACertFilePathList = self.ndgCfg.get('NDG_SECURITY',m).split() 
    84            
    85             m='acIssuer' 
    86             self.acIssuer = self.ndgCfg.get('NDG_SECURITY',m) 
    87              
    88         except AttributeError: 
    89             raise OwsError, 'NDG Security Error: No %s'%m 
    90          
    91          
     49 
    9250 
    9351    def __call__(self, **kw): 
     
    10159         
    10260        @type: ElementTree Element 
    103         @keyword securityElement: MOES security constraint containing role and 
     61        @param securityElement: MOES security constraint containing role and 
    10462        Attribute Authority URI. In xml, could look like: 
    10563        <moles:effect>allow</moles:effect> 
     
    11169         
    11270        @type: pylons.session 
    113         @keyword securityTokens: dict-like session object containing security  
     71        @param securityTokens: dict-like session object containing security  
    11472        tokens.  Resets equivalent object attribute.""" 
    11573           
     
    157115                     'in data "%s" - defaulting to config file setting' % \ 
    158116                     self.securityElement) 
    159             self.reqAAURI=request.environ['ndgConfig'].get('NDG_SECURITY',  
    160                                                            'attAuthorityURI') 
     117            self.reqAAURI = g.securityCfg.aaURI 
    161118     
    162119        # Create Session Manager client 
    163120        self.smClnt = SessionMgrClient(uri=self.securityTokens['h'], 
    164                             sslCACertFilePathList=self.sslCACertFilePathList, 
    165                             sslPeerCertCN=self.sslPeerCertCN, 
    166                             signingCertFilePath=self.wssCertFilePath, 
    167                             signingPriKeyFilePath=self.wssPriKeyFilePath, 
    168                             signingPriKeyPwd=self.wssPriKeyPwd, 
    169                             caCertFilePathList=self.wssCACertFilePathList, 
    170                             tracefile=self.tracefile)        
     121                    sslCACertFilePathList=g.securityCfg.sslCACertFilePathList, 
     122                    sslPeerCertCN=g.securityCfg.sslPeerCertCN, 
     123                    signingCertFilePath=g.securityCfg.wssCertFilePath, 
     124                    signingPriKeyFilePath=g.securityCfg.wssPriKeyFilePath, 
     125                    signingPriKeyPwd=g.securityCfg.wssPriKeyPwd, 
     126                    caCertFilePathList=g.securityCfg.wssCACertFilePathList, 
     127                    tracefile=g.securityCfg.tracefile)        
    171128         
    172129        return self.__checkAttCert() 
     
    185142                                         reqRole=self.reqRole) 
    186143        except AttributeRequestDenied, e: 
    187             log.info("Gatekeeper - access denied: %s" % e) 
     144            log.info(\ 
     145                "Gatekeeper - request for attribute certificate denied: %s"%e) 
    188146            return False, str(e) 
    189147         
     
    191149            # Clear the security details from the session object 
    192150            SecuritySession.delete() 
    193             log.info("Gatekeeper - access denied: %s" % e) 
     151            log.info("Gatekeeper - no session found: %s" % e) 
    194152            return False, self.__class__.NotLoggedInMsg 
    195153 
     
    197155            # Clear the security details from the session object 
    198156            SecuritySession.delete() 
    199             log.info("Gatekeeper - access denied: %s" % e) 
     157            log.info("Gatekeeper - session expired: %s" % e) 
    200158            return False, self.__class__.SessionExpiredMsg 
    201159 
     
    203161            # Clear the security details from the session object 
    204162            SecuritySession.delete() 
    205             log.info("Gatekeeper - access denied: %s" % e) 
     163            log.info("Gatekeeper - session cert. time error: %s" % e) 
    206164            return False, self.__class__.InvalidSessionMsg 
    207165             
    208166        except InvalidSession, e: 
    209167            SecuritySession.delete() 
    210             log.info("Gatekeeper - access denied: %s" % e) 
     168            log.info("Gatekeeper - invalid user session: %s" % e) 
    211169            return False, self.__class__.InvalidSessionMsg 
    212170 
     
    222180        if attCert.issuer != self.acIssuer: 
    223181            log.info('Gatekeeper - access denied: Attribute Certificate ' + \ 
    224                 'issuer DN, "%s"' % attCert.issuer + \ 
     182                'issuer DN, "%s" ' % attCert.issuer + \ 
    225183                'must match this data provider\'s Attribute Authority ' + \ 
    226184                'DN: "%s"' % self.acIssuer) 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/ndgPage.kid

    r2882 r2929  
    142142                        <!--! now we choose one of the next two (logged in or not) --> 
    143143                        <div py:if="'ndgSec' in session"><table><tbody><tr><td> User [${session['ndgSec']['u']}] logged in 
    144                         at [${session['ndgSec']['h']}] with roles [${len(session['ndgSec']['roles'])==1 and session['ndgSec']['roles'][0] or ', '.join(session['ndgSec']['roles'])}]</td><td> 
     144                        with roles [${len(session['ndgSec']['roles'])==1 and session['ndgSec']['roles'][0] or ', '.join(session['ndgSec']['roles'])}]</td><td> 
    145145                        &nbsp;<span py:replace="logOut()"/></td></tr></tbody></table></div> 
    146146                        <div py:if="'ndgSec' not in session">Further services maybe available if you can 
  • TI05-delivery/ows_framework/trunk/ows_server/ows_server/templates/wayf.kid

    r2882 r2929  
    77        <h4> Where are you from? </h4> 
    88        <?python 
    9         # Decode the return URL so that it can be displayed to the user. 
    10         # The URL has previously been encoded from ndgPage.kid 
    11         from base64 import urlsafe_b64decode 
    12         b64decReturnTo = urlsafe_b64decode(c.returnTo) 
     9                # Decode the return URL so that it can be displayed to the user. 
     10                # The URL has previously been encoded from ndgPage.kid 
     11                from base64 import urlsafe_b64decode, urlsafe_b64encode  
     12                b64decReturnTo = urlsafe_b64decode(c.returnTo) 
     13                 
     14                # Ensure login can return to an address over https to  
     15                # preserve confidentiality of credentials 
     16                if g.server in b64decReturnTo: 
     17                        b64decReturnTo = b64decReturnTo.replace(g.server, g.sslServer) 
     18                        c.returnTo = urlsafe_b64encode(b64decReturnTo)         
    1319        ?> 
    1420        <p> You can login in at  
Note: See TracChangeset for help on using the changeset viewer.