Changeset 5543


Ignore:
Timestamp:
31/07/09 17:10:15 (10 years ago)
Author:
pjkersha
Message:

Fixes for testing OpenID Relying Party running in the application code stack instead of the separate services stack.

Location:
TI12-security/trunk/python
Files:
7 edited

Legend:

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

    r5454 r5543  
    103103class AuthNRedirectInitiatorMiddleware(AuthNRedirectMiddleware): 
    104104    '''Middleware to initiate a redirect to another URI if a user is not  
    105     authenticated i.e. in AuthKit terms, no user is set in the REMOTE_USER key  
    106     of environ 
     105    authenticated i.e. security cookie is not set 
    107106     
    108107    AuthKit.authenticate.middleware must be in place upstream of this  
     
    249248        return self._app(environ, start_response) 
    250249 
    251   
     250 
     251class SessionHandlerMiddlewareConfigError(Exception): 
     252    """Configuration errors from SessionHandlerMiddleware""" 
     253     
    252254     
    253255class SessionHandlerMiddleware(NDGSecurityMiddlewareBase): 
     
    286288        dictionary 
    287289        ''' 
    288         super(SessionHandlerMiddleware, self).__init__(app,  
     290        super(SessionHandlerMiddleware, self).__init__(app, 
    289291                                                       global_conf, 
    290292                                                       prefix=prefix,  
     
    304306        log.debug("SessionHandlerMiddleware.__call__ ...") 
    305307         
    306         session = environ[self.sessionKey] 
     308        session = environ.get(self.sessionKey) 
     309        if session is None: 
     310            raise SessionHandlerMiddlewareConfigError('No beaker session key ' 
     311                                                      '"%s" found in environ' % 
     312                                                      self.sessionKey) 
    307313         
    308314        if self.signoutPath and self.pathInfo == self.signoutPath: 
     
    338344                 
    339345                session['username'] = environ['REMOTE_USER'] 
     346                session.save() 
    340347                 
    341348            remoteUserData = environ.get('REMOTE_USER_DATA', '')     
     
    358365                        sessionId = axData['ax'].get('value.sessionId.1') 
    359366                        session['sessionId'] = sessionId 
    360      
     367                        session.save() 
     368                         
    361369                        log.debug("SessionHandlerMiddleware: updated session " 
    362370                                  "with sessionManagerURI=%s and " 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/authz.py

    r5454 r5543  
    177177        targetMatch = len(matchingTargets) > 0 
    178178        if not targetMatch: 
    179             log.info("PEPFilter: granting access - no matching URI path " 
    180                      "target was found in the policy for URI path [%s]",  
     179            log.info("PEPFilter.__call__: granting access - no matching URI " 
     180                     "path target was found in the policy for URI path [%s]",  
    181181                     resourceURI) 
    182182            return self._app(environ, start_response) 
    183183 
    184         log.info("PEPFilter found matching target(s):\n\n %s\n" 
     184        log.info("PEPFilter.__call__: found matching target(s):\n\n %s\n" 
    185185                 "\nfrom policy file [%s] for URI Path=[%s]\n", 
    186186                 '\n'.join(["RegEx=%s" % t for t in matchingTargets]),  
     
    189189         
    190190        if not self.isAuthenticated: 
    191             log.info("PEPFilter: user is not authenticated - setting HTTP " 
    192                      "401 response ...") 
     191            log.info("PEPFilter.__call__: user is not authenticated - setting " 
     192                     "HTTP 401 response ...") 
    193193             
    194194            # Set a 401 response for an authentication handler to capture 
    195195            return self._setErrorResponse(code=401) 
    196196         
    197         log.debug("PEPFilter: creating request to call PDP to check user " 
    198                   "authorisation ...") 
     197        log.debug("PEPFilter.__call__: creating request to call PDP to check " 
     198                  "user authorisation ...") 
    199199         
    200200        # Make a request object to pass to the PDP 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/relyingparty/__init__.py

    r5499 r5543  
    5454        'signinInterfaceMiddlewareClass': None, 
    5555        'baseURL': '', 
    56         'sessionKey': 'beaker.session.ndg.security' 
     56#        'sessionKey': 'beaker.session.ndg.security' 
    5757    } 
    5858    propertyDefaults.update(sslPropertyDefaults) 
     
    100100                            "AuthKit settings") 
    101101                 
    102             moduleName, className = \ 
    103                 app_conf[prefix+'signinInterfaceMiddlewareClass'].rsplit('.',1) 
    104              
    105102            signinInterfacePrefix = prefix+'signinInterface.' 
    106103            classProperties = {'prefix': signinInterfacePrefix} 
    107104            classProperties.update(app_conf) 
    108             app = instantiateClass(moduleName,  
    109                                    className,   
    110                                    objectType=SigninInterface,  
    111                                    classArgs=(app, global_conf), 
    112                                    classProperties=classProperties)             
     105            app = instantiateClass( 
     106                           app_conf[prefix+'signinInterfaceMiddlewareClass'],  
     107                           None,   
     108                           objectType=SigninInterface,  
     109                           classArgs=(app, global_conf), 
     110                           classProperties=classProperties)             
    113111             
    114112            # Delete sign in interface middleware settings 
     
    122120        self.signoutPath = app_conf.get('authkit.cookie.signoutpath') 
    123121 
    124         authKitApp = authkit.authenticate.middleware(app, app_conf) 
    125         _app = authKitApp 
     122        app = authkit.authenticate.middleware(app, app_conf) 
     123        _app = app 
    126124        while True: 
    127125            if isinstance(_app,authkit.authenticate.open_id.AuthOpenIDHandler): 
    128                 self._authKitVerifyPath = _app.path_verify 
    129                 self._authKitProcessPath = _app.path_process 
     126                authOpenIDHandler = _app 
     127                self._authKitVerifyPath = authOpenIDHandler.path_verify 
     128                self._authKitProcessPath = authOpenIDHandler.path_process 
    130129                break 
    131130             
     
    140139                                                "WSGI stack") 
    141140         
     141        # Put this check in here after sessiionKey has been set by the  
     142        # super class __init__ above 
     143        self.sessionKey = authOpenIDHandler.session_middleware 
     144             
     145         
    142146        # Check for return to argument in query key value pairs 
    143147        self._return2URIKey = AuthNRedirectMiddleware.return2URIArgName + '=' 
    144148     
    145         super(OpenIDRelyingPartyMiddleware, self).__init__(authKitApp,  
     149        super(OpenIDRelyingPartyMiddleware, self).__init__(app,  
    146150                                                           global_conf,  
    147151                                                           prefix=prefix,  
    148152                                                           **app_conf) 
    149  
    150          
     153         
     154#    @classmethod 
     155#    def filter_app_factory(cls, app, app_conf, **local_conf): 
     156#        """Override to enforce correct ordering of beaker session middleware 
     157#        in WSGI stack""" 
     158#        app = cls(app, app_conf, **local_conf) 
     159#        app = SessionMiddleware(app, environ_key=app.sessionKey, **app_conf) 
     160#        return app 
     161     
    151162    @NDGSecurityMiddlewareBase.initCall      
    152163    def __call__(self, environ, start_response): 
     
    165176        @return: response 
    166177        ''' 
    167         session = environ[self.sessionKey] 
     178        session = environ.get(self.sessionKey) 
     179        if session is None: 
     180            raise OpenIDRelyingPartyConfigError('No beaker session key "%s" ' 
     181                                                'found in environ' %  
     182                                                self.sessionKey) 
    168183         
    169184        # Check for return to address in URI query args set by  
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/soap.py

    r5516 r5543  
    2020 
    2121from ZSI.ServiceContainer import ServiceSOAPBinding 
    22 from ndg.security.common.utils.classfactory import instantiateClass 
     22from ndg.security.common.utils.classfactory import instantiateClass, \ 
     23    importClass 
    2324from ndg.security.common.wssecurity.utils import DomletteReader, \ 
    2425    DomletteElementProxy 
     
    6869    """ZSI middleware configuration error""" 
    6970      
    70 class ZSIMiddleware(object): 
     71class ZSIMiddleware(SOAPMiddleware): 
    7172    '''Middleware configurable to a given ZSI SOAP binding'''   
    7273     
     
    101102            # __call__  may reference any filters in environ keyed by these 
    102103            # keywords 
    103             self.referencedFilterKeys = \ 
    104                                 self.app_conf.pop('referencedFilters').split() 
     104            self.referencedFilterKeys = self.app_conf.pop( 
     105                                                'referencedFilters').split() 
    105106                                 
    106107            # Remove equivalent keyword if present 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidrelyingparty_withapp/securedapp.ini

    r5541 r5543  
    2424baseURI = %(scheme)s://%(hostname)s:%(portNum)s 
    2525openIDProviderIDBase = /openid 
    26 openIDProviderIDSelectURI = %(baseURI)s%(openIDProviderIDBase)s 
     26openIDProviderIDSelectURI = http://localhost:7443%(openIDProviderIDBase)s 
    2727testConfigDir = %(here)s/../../config 
     28beakerSessionKeyName = beaker.session.ndg.security 
    2829 
    2930[server:main] 
     
    3334 
    3435[pipeline:main] 
    35 pipeline = SessionMiddlewareFilter 
     36pipeline = BeakerSessionFilter 
    3637                   OpenIDRelyingPartyFilter  
     38                   SessionHandlerFilter 
    3739                   AuthorizationFilter  
    3840                   AuthZTestApp 
     
    4042[app:AuthZTestApp] 
    4143paste.app_factory = ndg.security.test.integration.openidrelyingparty_withapp.securedapp:AuthZTestApp.app_factory 
    42  
    43 [filter:AuthenticationFilter] 
    44 paste.filter_app_factory = ndg.security.server.wsgi.authn:AuthenticationMiddleware 
    45 prefix = authN. 
    46  
    47 # Set redirect for OpenID Relying Party in the Security Services app instance 
    48 authN.redirectURI = http://localhost:7443/verify 
    49  
    50 # Beaker Session set-up 
    51 beaker.session.key = ndg.security.session 
    52 beaker.session.secret = rBIvKXLa+REYB8pM/8pdPoorVpKQuaOW 
    53 beaker.cache.data_dir = %(here)s/authn/beaker/cache 
    54 beaker.session.data_dir = %(here)s/authn/beaker/sessions 
    55  
    56 # AuthKit Set-up 
    57 authkit.setup.method=cookie 
    58  
    59 # This cookie name and secret MUST agree with the name used by the security web 
    60 # services app 
    61 authkit.cookie.name=ndg.security.auth 
    62 authkit.cookie.secret=9wvZObs9anUEhSIAnJNoY2iJq59FfYZr 
    63 authkit.cookie.signoutpath = /logout 
    64  
    65 # Disable inclusion of client IP address from cookie signature due to  
    66 # suspected problem with AuthKit setting it when a HTTP Proxy is in place 
    67 authkit.cookie.includeip = False 
    6844 
    6945[filter:AuthorizationFilter] 
     
    11086pip.wssecurity.addTimestamp=True 
    11187 
    112 #______________________________________________________________________________ 
    113 # Beaker Session Middleware (used by OpenID Provider Filter) 
    114 [filter:SessionMiddlewareFilter] 
    115 paste.filter_app_factory=beaker.middleware:SessionMiddleware 
    116 beaker.session.key = openid 
    117 beaker.session.secret = qKEdQdCr33NE087dRUWX3qUv5r7AsuQU 
    118 # These options enable cookie only type sessions with the cookie content  
    119 # encrypted 
    120 #beaker.session.type = cookie 
    121 #beaker.session.validate_key = 0123456789abcdef 
    122 #beaker.session.encrypt_key = fedcba9876543210 
     88[filter:BeakerSessionFilter] 
     89paste.filter_app_factory = beaker.middleware:SessionMiddleware 
    12390 
    124 # If you'd like to fine-tune the individual locations of the cache data dirs 
    125 # for the Cache data, or the Session saves, un-comment the desired settings 
    126 # here: 
    127 beaker.cache.data_dir = %(here)s/openidprovider/beaker/cache 
    128 beaker.session.data_dir = %(here)s/openidprovider/beaker/sessions 
    129 beaker.session.cookie_expires = True 
     91# Cookie name 
     92beaker.session.key = ndg.security.session 
    13093 
     94# WSGI environ key name 
     95environ_key = %(beakerSessionKeyName)s 
     96beaker.session.secret = rBIvKXLa+REYB8pM/8pdPoorVpKQuaOW 
     97beaker.cache.data_dir = %(here)s/authn/beaker/cache 
     98beaker.session.data_dir = %(here)s/authn/beaker/sessions 
     99 
     100[filter:SessionHandlerFilter] 
     101paste.filter_app_factory = ndg.security.server.wsgi.authn:SessionHandlerMiddleware.filter_app_factory 
     102sessionKey = %(beakerSessionKeyName)s 
     103signoutPath = /logout 
    131104 
    132105[filter:OpenIDRelyingPartyFilter] 
     
    134107        ndg.security.server.wsgi.openid.relyingparty:OpenIDRelyingPartyMiddleware.filter_app_factory 
    135108 
    136 openid.relyingparty.sessionKey = beaker.session 
    137109openid.relyingparty.baseURL = %(authkit.openid.baseurl)s 
    138110openid.relyingparty.certFilePath = %(testConfigDir)s/pki/localhost.crt 
     
    141113openid.relyingparty.caCertDirPath = %(testConfigDir)s/ca 
    142114openid.relyingparty.providerWhitelistFilePath = 
    143 #openid.relyingparty.signinInterfaceMiddlewareClass = ndg.security.test.integration.openid.openidrelyingparty.signin_interface.CombinedSigninAndLoginInterface 
    144 #openid.relyingparty.signinInterface.templatePackage = ndg.security.test.integration.openid.openidrelyingparty.templates 
    145115openid.relyingparty.signinInterfaceMiddlewareClass = ndg.security.server.wsgi.openid.relyingparty.signin_interface.buffet.BuffetSigninTemplate 
    146116openid.relyingparty.signinInterface.templatePackage = ndg.security.server.wsgi.openid.relyingparty.signin_interface.buffet.templates 
     
    164134# This cookie name and secret MUST agree with the name used by the  
    165135# Authentication Filter used to secure a given app 
    166 authkit.cookie.name=ndg.security.auth 
     136authkit.cookie.name=ndg.security.authkit 
    167137authkit.cookie.secret=9wvZObs9anUEhSIAnJNoY2iJq59FfYZr 
    168138authkit.cookie.signoutpath = /logout 
     
    177147authkit.openid.session.key = authkit_openid 
    178148authkit.openid.session.secret = random string 
     149authkit.openid.session.middleware = %(beakerSessionKeyName)s 
    179150 
    180151authkit.openid.baseurl = %(baseURI)s 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidrelyingparty_withapp/securedapp.py

    r5541 r5543  
    5353 
    5454    def __init__(self, app, globalConfig, **localConfig): 
     55        self.beakerSessionKeyName = globalConfig['beakerSessionKeyName'] 
    5556        self.app = app 
    5657             
     
    7172             
    7273    def default(self, environ, start_response): 
    73         if 'REMOTE_USER' in environ: 
     74        if 'username' in environ.get(self.beakerSessionKeyName, {}): 
    7475            response = """<html> 
    7576    <head/> 
     
    8384       '\n'.join(['<li><a href="%s">%s</a></li>' % (link, name)  
    8485                 for link,name in self.method.items() if name != 'default']), 
    85        environ['REMOTE_USER']) 
     86       environ[self.beakerSessionKeyName]['username']) 
    8687         
    8788            start_response('200 OK',  
     
    107108 
    108109    def test_401(self, environ, start_response): 
    109         if 'REMOTE_USER' in environ: 
    110             response = """<html> 
     110        response = """<html> 
    111111    <head/> 
    112112    <body> 
     
    119119                 for link,name in self.method.items() if name != 'default']) 
    120120 
    121             start_response('200 OK',  
    122                            [('Content-type', 'text/html'), 
    123                             ('Content-length', str(len(response)))]) 
    124         else: 
    125             response = "Trigger OpenID Relying Party..." 
    126             start_response('401 Unauthorized',  
    127                            [('Content-type', 'text/plain'), 
    128                             ('Content-length', str(len(response)))]) 
     121        start_response('200 OK',  
     122                       [('Content-type', 'text/html'), 
     123                        ('Content-length', str(len(response)))]) 
    129124        return response 
    130125 
     
    133128        HTTP status code from this URI""" 
    134129         
    135         if 'REMOTE_USER' in environ: 
    136             response = """<html> 
     130        response = """<html> 
    137131    <head/> 
    138132    <body> 
     
    144138""" % ('\n'.join(['<li><a href="%s">%s</a></li>' % (link, name)  
    145139                 for link,name in self.method.items() if name != 'default']), 
    146        environ['REMOTE_USER']) 
    147  
    148             start_response('200 OK',  
    149                            [('Content-type', 'text/html'), 
    150                             ('Content-length', str(len(response)))]) 
    151         else: 
    152             response = ("Authorization middleware is triggered becuase this " 
    153                         "page returns a 403 Forbidden status.") 
    154             start_response('403 Forbidden',  
    155                            [('Content-type', 'text/plain'), 
    156                             ('Content-length', str(len(response)))]) 
     140       environ[self.beakerSessionKeyName]['username']) 
     141 
     142        start_response('200 OK',  
     143                       [('Content-type', 'text/html'), 
     144                        ('Content-length', str(len(response)))]) 
    157145        return response 
    158146 
     
    160148        """To be secured, the Authorization middleware must have this URI in 
    161149        its policy""" 
    162         if 'REMOTE_USER' in environ: 
    163             response = """<html> 
     150        response = """<html> 
    164151    <head/> 
    165152    <body> 
     
    172159       '\n'.join(['<li><a href="%s">%s</a></li>' % (link, name)  
    173160                 for link,name in self.method.items() if name != 'default']), 
    174        environ['REMOTE_USER']) 
    175  
    176  
    177             start_response('200 OK',  
    178                            [('Content-type', 'text/html'), 
    179                             ('Content-length', str(len(response)))]) 
    180         else: 
    181             response = ("Authorization middleware must have this URI in its " 
    182                         "policy in order to secure it!") 
    183             start_response('200 OK',  
    184                            [('Content-type', 'text/plain'), 
    185                             ('Content-length', str(len(response)))]) 
     161       environ[self.beakerSessionKeyName]['username']) 
     162 
     163 
     164        start_response('200 OK',  
     165                       [('Content-type', 'text/html'), 
     166                        ('Content-length', str(len(response)))]) 
    186167        return response 
    187168 
     
    192173        in the policy.  See ndg.security.test.config.attributeauthority.sitea 
    193174        for user role settings retrieved from the attribute authority""" 
    194         if 'REMOTE_USER' in environ: 
    195             response = """<html> 
     175        response = """<html> 
    196176    <head/> 
    197177    <body> 
     
    204184       '\n'.join(['<li><a href="%s">%s</a></li>' % (link, name)  
    205185                 for link,name in self.method.items() if name != 'default']), 
    206        environ['REMOTE_USER']) 
    207  
    208  
    209             start_response('200 OK',  
    210                            [('Content-type', 'text/html'), 
    211                             ('Content-length', str(len(response)))]) 
    212         else: 
    213             response = ("Authorization middleware must have this URI in its " 
    214                         "policy in order to secure it!") 
    215             start_response('200 OK',  
    216                            [('Content-type', 'text/plain'), 
    217                             ('Content-length', str(len(response)))]) 
     186       environ[self.beakerSessionKeyName]['username']) 
     187 
     188 
     189        start_response('200 OK',  
     190                       [('Content-type', 'text/html'), 
     191                        ('Content-length', str(len(response)))]) 
    218192        return response 
    219193    
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidrelyingparty_withapp/securityservices.ini

    r5541 r5543  
    8686           wsseSignatureFilter  
    8787                   SessionMiddlewareFilter 
    88                    OpenIDRelyingPartyFilter 
    8988                   OpenIDProviderApp 
    9089 
     
    108107beaker.session.cookie_expires = True 
    109108 
    110 [filter:OpenIDRelyingPartyFilter] 
    111 paste.filter_app_factory =  
    112         ndg.security.server.wsgi.openid.relyingparty:OpenIDRelyingPartyMiddleware.filter_app_factory 
    113  
    114 openid.relyingparty.sessionKey = beaker.session 
    115 openid.relyingparty.baseURL = %(authkit.openid.baseurl)s 
    116 openid.relyingparty.certFilePath = %(testConfigDir)s/pki/localhost.crt 
    117 openid.relyingparty.priKeyFilePath = %(testConfigDir)s/pki/localhost.key 
    118 openid.relyingparty.priKeyPwd =  
    119 openid.relyingparty.caCertDirPath = %(testConfigDir)s/ca 
    120 openid.relyingparty.providerWhitelistFilePath = 
    121 #openid.relyingparty.signinInterfaceMiddlewareClass = ndg.security.test.integration.openid.openidrelyingparty.signin_interface.CombinedSigninAndLoginInterface 
    122 #openid.relyingparty.signinInterface.templatePackage = ndg.security.test.integration.openid.openidrelyingparty.templates 
    123 openid.relyingparty.signinInterfaceMiddlewareClass = ndg.security.server.wsgi.openid.relyingparty.signin_interface.buffet.BuffetSigninTemplate 
    124 openid.relyingparty.signinInterface.templatePackage = ndg.security.server.wsgi.openid.relyingparty.signin_interface.buffet.templates 
    125 openid.relyingparty.signinInterface.staticContentRootDir = %(here)s/openidrelyingparty/public 
    126 openid.relyingparty.signinInterface.baseURL = %(openid.relyingparty.baseURL)s 
    127 openid.relyingparty.signinInterface.initialOpenID = %(openIDProviderIDSelectURI)s 
    128 openid.relyingparty.signinInterface.leftLogo = %(openid.relyingparty.signinInterface.baseURL)s/layout/NERC_Logo.gif 
    129 openid.relyingparty.signinInterface.leftAlt = Natural Environment Research Council 
    130 openid.relyingparty.signinInterface.ndgLink = http://ndg.nerc.ac.uk/ 
    131 openid.relyingparty.signinInterface.ndgImage = %(openid.relyingparty.signinInterface.baseURL)s/layout/ndg_logo_circle.gif 
    132 openid.relyingparty.signinInterface.disclaimer = This site is for test purposes only and is under active development. 
    133 openid.relyingparty.signinInterface.stfcLink = http://www.stfc.ac.uk/ 
    134 openid.relyingparty.signinInterface.stfcImage = %(openid.relyingparty.signinInterface.baseURL)s/layout/stfc-circle-sm.gif 
    135 openid.relyingparty.signinInterface.helpIcon = %(openid.relyingparty.signinInterface.baseURL)s/layout/icons/help.png 
    136  
    137 cache_dir = %(here)s/data 
    138  
    139 # AuthKit Set-up 
    140 authkit.setup.method=openid, cookie 
    141  
    142 # This cookie name and secret MUST agree with the name used by the  
    143 # Authentication Filter used to secure a given app 
    144 authkit.cookie.name=ndg.security.auth 
    145 authkit.cookie.secret=9wvZObs9anUEhSIAnJNoY2iJq59FfYZr 
    146 authkit.cookie.signoutpath = /logout 
    147  
    148 # Disable inclusion of client IP address from cookie signature due to  
    149 # suspected problem with AuthKit setting it when a HTTP Proxy is in place 
    150 authkit.cookie.includeip = False 
    151  
    152 authkit.openid.path.signedin=/ 
    153 authkit.openid.store.type=file 
    154 authkit.openid.store.config=%(here)s/openidrelyingparty/store 
    155 authkit.openid.session.key = authkit_openid 
    156 authkit.openid.session.secret = random string 
    157  
    158 authkit.openid.baseurl = %(baseURI)s 
    159  
    160 # Template for signin 
    161 #authkit.openid.template.obj =  
    162  
    163 # Handler for parsing OpenID and creating a session from it 
    164 #authkit.openid.urltouser =  
    165109 
    166110#______________________________________________________________________________ 
Note: See TracChangeset for help on using the changeset viewer.