Changeset 5154


Ignore:
Timestamp:
31/03/09 16:07:34 (10 years ago)
Author:
pjkersha
Message:

Major refactoring of PEP and PDP middleware:

  • moved code out of ndg.security.server.wsgi.pdp into ndg.security.server.wsgi.pep - the PDP doesn't need to be and should not be a WSGI
  • Modified PEPMiddleware to be called by via authkit.authenticate.multi.MultiHandler?.
  • New wrapper class AuthorizationMiddleware? wraps the MultiHandler?
  • TODO: delete ndg.security.server.wsgi.pdp and rename ndg.security.server.wsgi.pep package ndg.security.server.wsgi.authz
Location:
TI12-security/trunk/python
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/paster_templates/default_deployment/sessionmanager/userx509certauthn.py

    r4840 r5154  
    1313import logging 
    1414log = logging.getLogger(__name__) 
     15 
     16from M2Crypto import RSA 
    1517 
    1618from ndg.security.server.sessionmanager import SessionManager, \ 
     
    4345        ''' 
    4446         
     47        # Check password by executing a trial load of the private key 
     48        try: 
     49            RSA.load_key_string(self.userPriKey,  
     50                                callback=lambda *ar, **kw: passphrase) 
     51        except RSA.RSAError, e: 
     52            raise AuthNServiceInvalidCredentials(e) 
     53         
    4554        return self.userX509Cert, self.userPriKey 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/authn.py

    r5148 r5154  
    171171 
    172172    def __init__(self, app, global_conf, prefix='', **app_conf): 
    173         if 'beaker.session.key' in app_conf: 
    174             app_conf[prefix+'sessionKey'] = app_conf['beaker.session.key'] 
    175              
    176173        super(SessionHandlerMiddleware, self).__init__(app,  
    177                                                       global_conf, 
    178                                                       prefix=prefix,  
    179                                                       **app_conf) 
     174                                                       global_conf, 
     175                                                       prefix=prefix,  
     176                                                       **app_conf) 
    180177         
    181178    @NDGSecurityMiddlewareBase.initCall 
     
    195192                log.error('No referer set for redirect following logout') 
    196193                _start_response = start_response 
     194                 
     195            # Clear user details from beaker session 
     196            session.pop('username', None) 
     197            session.pop('sessionManagerURI', None) 
     198            session.save() 
    197199        else: 
    198200            if 'username' not in session and 'REMOTE_USER' in environ: 
    199201                session['username'] = environ['REMOTE_USER'] 
    200202                 
    201             if 'REMOTE_USER_DATA' in environ: 
     203            if environ.get('REMOTE_USER_DATA', ''): 
    202204                # eval is safe here because AuthKit cookie is signed and  
    203205                # AuthKit middleware checks for tampering 
     
    221223from authkit.authenticate.multi import MultiHandler 
    222224 
    223          
    224225class AuthenticationMiddlewareConfigError(NDGSecurityMiddlewareConfigError): 
    225226    '''Authentication Middleware Configuration error''' 
     
    245246         
    246247        # Set logout URI parameter from AuthKit settings if not otherwise set 
    247         logoutPrefix = prefix + SessionHandlerMiddleware.prefix 
    248         signoutPathParamName = logoutPrefix + 'signoutPath' 
     248        sessionHandlerPrefix = prefix + SessionHandlerMiddleware.prefix 
     249        signoutPathParamName = sessionHandlerPrefix + 'signoutPath' 
    249250        if signoutPathParamName not in app_conf: 
    250251            try:                    
     
    258259        app = SessionHandlerMiddleware(app,  
    259260                                       global_conf,  
    260                                        prefix=logoutPrefix, 
     261                                       prefix=sessionHandlerPrefix, 
    261262                                       **app_conf) 
    262263         
    263264        # Remove session handler middleware specific parameters 
    264265        for k in app_conf.keys(): 
    265             if k.startswith(logoutPrefix): 
     266            if k.startswith(sessionHandlerPrefix): 
    266267                del app_conf[k] 
    267268         
     269        app = authkit.authenticate.middleware(app, app_conf)         
    268270        app = SessionMiddleware(app, **app_conf) 
    269271         
    270         app = authkit.authenticate.middleware(app, app_conf) 
    271272        MultiHandler.__init__(self, app) 
    272273 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/relyingparty/__init__.py

    r5091 r5154  
    2323 
    2424from ndg.security.server.wsgi import NDGSecurityMiddlewareBase 
    25 from ndg.security.server.wsgi.authn import AuthNRedirectMiddleware 
     25from ndg.security.server.wsgi.authn import AuthenticationRedirectMiddleware 
    2626from ndg.security.common.utils.classfactory import instantiateClass 
    2727 
     
    108108         
    109109        # Check for return to argument in query key value pairs 
    110         self._return2URIKey = AuthNRedirectMiddleware.return2URIArgName + '=' 
     110        self._return2URIKey = AuthenticationRedirectMiddleware.return2URIArgName + '=' 
    111111     
    112112        super(OpenIDRelyingPartyMiddleware, self).__init__(authKitApp,  
     
    135135            params = {} 
    136136         
    137         quotedReferrer=params.get(AuthNRedirectMiddleware.return2URIArgName,'') 
     137        quotedReferrer = params.get( 
     138                        AuthenticationRedirectMiddleware.return2URIArgName, '') 
    138139        referrer = urllib.unquote(quotedReferrer) 
    139140        referrerPathInfo = urlsplit(referrer)[2] 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/pdp.py

    r5148 r5154  
    5858    __call__ = accessPermitted 
    5959     
    60          
    61 class PDPMiddlewareConfigError(NDGSecurityMiddlewareConfigError): 
    62     '''Policy Decision Point Middleware Configuration error''' 
    6360 
    64 class PDPMiddleware(NDGSecurityMiddlewareBase): 
    65     triggerStatus = '403' 
    66     id = 'forbidden' 
    6761     
    68     _isAuthenticated = lambda self: 'REMOTE_USER' in self.environ 
    69     isAuthenticated = property(fget=_isAuthenticated, 
    70                                doc='boolean for is user logged in') 
    71  
    72     def __init__(self, app, global_conf, **app_conf): 
    73         super(PDPMiddleware, self).__init__(app, global_conf, **app_conf) 
    74         self.pdp = PDP() 
    75          
    76     @NDGSecurityMiddlewareBase.initCall 
    77     def __call__(self, environ, start_response): 
    78         if self.isAuthenticated: 
    79             if self.isAuthorized(): 
    80                 # Return next layer in stack 
    81                 return self._app(environ, start_response) 
    82             else: 
    83                 return self.accessDeniedResponse() 
    84         else: 
    85             response = "Not authenticated" 
    86             start_response(PDPMiddleware.getStatusMessage(401),  
    87                            [('Content-type', 'text/plain') , 
    88                             ('Content-length', str(len(response)))]) 
    89             return response             
    90              
    91     def isAuthorized(self): 
    92         '''Check constraints on the requested URI and return boolean - access 
    93         allowed/denied''' 
    94         environ = self.environ 
    95          
    96         # TODO: Refactor here perhaps calling resource constraint look-up or do  
    97         # inside PDP call?       
    98         resource = self.environ.get('ndg.security.server.wsgi.pep.resource') or \ 
    99             Resource() 
    100         subject = Subject() 
    101         subject.userID = self.environ.get('REMOTE_USER') 
    102         subject.attributes += ['someAttribute'] 
    103         status = self.pdp(subject, resource, None, None) 
    104         return status 
    105      
    106     def accessDeniedResponse(self): 
    107         '''Break out of the WSGI stack and set a error message for the user 
    108         403 status is still set to enable programmatic handling of this  
    109         response''' 
    110         response = "Access Denied" 
    111         start_response(PDPMiddleware.getStatusMessage(403),  
    112                        [('Content-type', 'text/plain') , 
    113                         ('Content-length', str(len(response)))]) 
    114         return response             
    115     
    116     @classmethod 
    117     def checker(cls, environ, status, headers): 
    118         """Set the trigger for calling this middleware.  In this case, it's a 
    119         HTTP 403 Forbidden response detected in the middleware chain 
    120         """ 
    121         log.debug("PDPMiddleware.checker received status %r, headers " 
    122                   "%r", status, headers) 
    123          
    124         if status.startswith(cls.triggerStatus): 
    125             log.debug("PDPMiddleware.checker returning True") 
    126             return True 
    127         else: 
    128             log.debug("PDPMiddleware.checker returning False") 
    129             return False 
    130  
    131 from authkit.authenticate.multi import MultiHandler 
    132  
    133 class PDPHandlerMiddleware(MultiHandler, NDGSecurityMiddlewareBase): 
    134     '''Handler to call Policy Decision Point middleware and intercept 
    135     authorisation requests.  Add THIS class to any middleware chain and NOT 
    136     PDPMiddleware which it wraps. 
    137     ''' 
    138     def __init__(self, app, global_conf, **app_conf): 
    139         MultiHandler.__init__(self, app) 
    140  
    141         self.add_method(PDPMiddleware.id,  
    142                         PDPMiddleware.filter_app_factory,  
    143                         global_conf, 
    144                         **app_conf) 
    145          
    146         self.add_checker(PDPMiddleware.id, PDPMiddleware.checker) 
    147      
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/pep/__init__.py

    r5148 r5154  
    2222# TODO: move this class to separate resource constraint module 
    2323class Resource(object): 
    24     def __init__(self, uri, attributes): 
     24    def __init__(self, uri, attributes=[]): 
    2525        self.uri = uri 
    2626        self.attributes = attributes 
     27         
     28    def __eq__(self, uri): 
     29        return self.uri == uri 
     30     
     31from ndg.security.common.authz.pdp import PDPInterface 
     32 
     33from ndg.security.server.wsgi import NDGSecurityMiddlewareBase, \ 
     34    NDGSecurityMiddlewareConfigError 
     35 
     36class Subject(object): 
     37    def __init__(self): 
     38        self.sessionManagerURI = None 
     39        self.sessionManagerEnvironKey = None 
     40        self.userID = None 
     41         
     42        # TODO: may need to refactor out as attributes can be derived from the 
     43        # user's wallet held be the Session Manager 
     44        self.attributes = [] 
     45 
     46class Action(object): 
     47    pass 
     48 
     49class Environment(object): 
     50    pass 
     51         
     52class PDP(PDPInterface): 
     53    def __init__(self, *arg, **kw): 
     54        pass 
     55 
     56    def accessPermitted(self, subject, resource, action, environ, **kw): 
     57        '''Make access control decision''' 
     58        if action is None: 
     59            action = Action() 
     60             
     61        if environ is None: 
     62            environ = Environment() 
     63             
     64        #super(PDP, self).accessPermitted(subject, resource, action, environ) 
     65        for attr in resource.attributes: 
     66            if attr in subject.attributes: 
     67                return True 
     68             
     69        return False 
     70 
     71    __call__ = accessPermitted 
     72 
     73         
     74class PDPMiddlewareConfigError(NDGSecurityMiddlewareConfigError): 
     75    '''Policy Decision Point Middleware Configuration error''' 
    2776 
    2877class PEPMiddleware(NDGSecurityPathFilter): 
    29     """WSGI Middleware to enforce a security policy for a given request URL 
     78    triggerStatus = '403' 
     79    id = 'forbidden' 
    3080     
    31     B{This class must be run under Apache mod_wsgi} 
     81    propertyDefaults = { 
     82        'sessionKey': 'beaker.session' 
     83    } 
    3284 
    33     - This class uses SSL_SERVER_S_DN environment variable if available.  To 
    34     set, set Apache SSL with StdEnvVars option for the SSLOptions directive. 
    35     """   
    36     sslServerDNKeyName = 'SSL_SERVER_S_DN' 
    37       
    38     def __init__(self, app, app_conf, prefix='', **local_conf): 
    39         log.debug("Initialising PEPMiddleware ...") 
     85    _isAuthenticated = lambda self: \ 
     86                            'username' in self.environ.get(self.sessionKey, ()) 
     87    isAuthenticated = property(fget=_isAuthenticated, 
     88                               doc='boolean to indicate is user logged in') 
     89 
     90    def __init__(self, app, global_conf, **app_conf): 
     91        super(PEPMiddleware, self).__init__(app, global_conf, **app_conf) 
     92        self.pdp = PDP() 
    4093         
    41         super(PEPMiddleware, self).__init__(app, app_conf, prefix=prefix,  
    42                                             **local_conf) 
    43         self.charset = '; charset=utf-8' 
     94    @NDGSecurityPathFilter.initCall 
     95    def __call__(self, environ, start_response): 
     96        if self.isAuthenticated: 
     97            if self.isAuthorized(): 
     98                # Return next layer in stack 
     99                return self._app(environ, start_response) 
     100            else: 
     101                return self.accessDeniedResponse() 
     102        else: 
     103            response = "Not authenticated" 
     104            start_response(PEPMiddleware.getStatusMessage(401),  
     105                           [('Content-type', 'text/plain') , 
     106                            ('Content-length', str(len(response)))]) 
     107            return response             
     108             
     109    def isAuthorized(self): 
     110        '''Check constraints on the requested URI and return boolean - access 
     111        allowed/denied''' 
     112        environ = self.environ 
     113         
     114        # TODO: Refactor here perhaps calling resource constraint look-up or do  
     115        # inside PDP call?       
     116        resource = self.environ.get('ndg.security.server.wsgi.pep.resource') or \ 
     117            Resource(self.pathInfo) 
     118        subject = Subject() 
     119        subject.userID = self.environ.get('REMOTE_USER') 
     120        subject.attributes += ['someAttribute'] 
     121        status = self.pdp(subject, resource, None, None) 
     122        return status 
     123     
     124    def accessDeniedResponse(self): 
     125        '''Break out of the WSGI stack and set a error message for the user 
     126        403 status is still set to enable programmatic handling of this  
     127        response''' 
     128        response = "Access Denied" 
     129        start_response(PEPMiddleware.getStatusMessage(403),  
     130                       [('Content-type', 'text/plain') , 
     131                        ('Content-length', str(len(response)))]) 
     132        return response             
     133    
     134    @classmethod 
     135    def checker(cls, environ, status, headers): 
     136        """Set the trigger for calling this middleware.  In this case, it's a 
     137        HTTP 403 Forbidden response detected in the middleware chain 
     138        """ 
     139        log.debug("PEPMiddleware.checker received status %r, headers " 
     140                  "%r", status, headers) 
     141         
     142        if status.startswith(cls.triggerStatus) or environ['PATH_INFO']=='/test_securedURI': 
     143            environ['ndg.security.server.wsgi.pep.resource'] = Resource(environ['PATH_INFO'], attributes=['someAttribute']) 
     144            log.debug("PEPMiddleware.checker returning True") 
     145            return True 
     146        else: 
     147            log.debug("PEPMiddleware.checker returning False") 
     148            return False 
    44149 
    45     @NDGSecurityPathFilter.initCall          
    46     def __call__(self, environ, start_response): 
    47         log.debug("PEPMiddleware.__call__ ...") 
     150from authkit.authenticate.multi import MultiHandler 
     151 
     152class AuthorizationMiddleware(NDGSecurityMiddlewareBase): 
     153    '''Handler to call Policy Decision Point middleware and intercept 
     154    authorisation requests.  Add THIS class to any middleware chain and NOT 
     155    PEPMiddleware which it wraps. 
     156    ''' 
     157    resourceKeyName = 'ndg.security.server.wsgi.pep.resource' 
     158     
     159    def __init__(self, app, global_conf, prefix='', **app_conf): 
     160                         
     161        app = MultiHandler(app) 
     162                            
     163        app.add_method(PEPMiddleware.id,  
     164                       PEPMiddleware.filter_app_factory,  
     165                       global_conf, 
     166                       **app_conf) 
    48167         
    49         # Is this requested URL secured? 
    50         if self.pathMatch: 
    51             environ['ndg.security.server.wsgi.pep.resource'] = Resource( 
    52                                                                 self.pathInfo, 
    53                                                                 ['someAttribute']) 
    54             def _start_response(status, header, exc_info=None): 
    55                 '''alter start_response to return unauthorised status 
     168        app.add_checker(PEPMiddleware.id, PEPMiddleware.checker) 
    56169                 
    57                 @type status: str 
    58                 @param status: HTTP status code and status message 
    59                 @type header: list 
    60                 @param header: list of field, value tuple HTTP header content 
    61                 @type exc_info: Exception 
    62                 @param exc_info: exception info 
    63                 ''' 
    64                 log.debug('[%s] is a secured URI: setting 403 status...' %  
    65                           self.pathInfo) 
    66                                          
    67                 _status = self.getStatusMessage(403) 
    68                             
    69                 return start_response(_status, header, exc_info) 
    70              
    71         else: 
    72             _start_response = start_response 
    73              
    74         return self._setResponse(environ, _start_response) 
    75      
    76  
    77     def _redirectFromHTTPS2HTTP(self, start_response): 
    78         sslServerDN = self.environ.get(PEPMiddleware.sslServerDNKeyName) 
    79  
    80         if sslServerDN is not None: 
    81             if self.serverName: 
    82                 serverName = self.serverName 
    83             else: 
    84                 dn = X500DN.Parse(sslServerDN) 
    85                 serverName = dn['CN'] 
    86             url = 'http://' + serverName + self.mountPath + self.pathInfo 
    87             return self._redirect(start_response, url) 
    88  
     170         
     171        super(AuthorizationMiddleware, self).__init__(app,  
     172                                                      global_conf,  
     173                                                      prefix=prefix,  
     174                                                      **app_conf) 
     175         
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/config/sessionmanager/userx509certauthn.py

    r4840 r5154  
    1313import logging 
    1414log = logging.getLogger(__name__) 
     15 
     16from M2Crypto import RSA 
    1517 
    1618from ndg.security.server.sessionmanager import SessionManager, \ 
     
    4345        ''' 
    4446         
     47        # Check password by executing a trial load of the private key 
     48        try: 
     49            RSA.load_key_string(self.userPriKey,  
     50                                callback=lambda *ar, **kw: passphrase) 
     51        except RSA.RSAError, e: 
     52            raise AuthNServiceInvalidCredentials(e) 
     53         
    4554        return self.userX509Cert, self.userPriKey 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securedapp.ini

    r5148 r5154  
    1212 
    1313[pipeline:main] 
    14 #pipeline = SessionMiddlewareFilter 
    15 #                  AuthenticationFilter 
    16 #                  PDPMiddlewareFilter 
    17 #                  PEPMiddlewareFilter 
     14#pipeline = AuthenticationFilter 
     15##                 PDPMiddlewareFilter 
     16#                  AuthorizationFilter 
    1817#                  AuthZTestApp 
    1918pipeline = AuthenticationFilter 
    20                    PDPMiddlewareFilter 
    21                    PEPMiddlewareFilter 
     19                   AuthorizationFilter 
    2220                   AuthZTestApp 
    2321 
    2422[app:AuthZTestApp] 
    2523paste.app_factory = ndg.security.test.integration.authz.securedapp:AuthZTestMiddleware.app_factory 
    26  
    27 #______________________________________________________________________________ 
    28 # Beaker Session Middleware (used by Authentication Filter) 
    29 [filter:SessionMiddlewareFilter] 
    30 paste.filter_app_factory=beaker.middleware:SessionMiddleware 
    31 #beaker.session.key = sso 
    32 beaker.session.secret = somesecret 
    33 beaker.cache.data_dir = %(here)s/authn/beaker/cache 
    34 beaker.session.data_dir = %(here)s/authn/beaker/sessions 
    35 # These options enable cookie only type sessions with the cookie content  
    36 # encrypted 
    37 #beaker.session.type = cookie 
    38 #beaker.session.validate_key = 0123456789abcdef 
    39 #beaker.session.encrypt_key = fedcba9876543210 
    4024 
    4125[filter:AuthenticationFilter] 
     
    5438# AuthKit Set-up 
    5539authkit.setup.method=cookie 
     40 
     41# This cookie name and secret MUST agree with the name used by the security web 
     42# services app 
    5643authkit.cookie.name=ndg.security.auth 
    5744authkit.cookie.secret=9wvZObs9anUEhSIAnJNoY2iJq59FfYZr 
    5845authkit.cookie.signoutpath = /logout 
    5946 
    60 [filter:PEPMiddlewareFilter] 
    61 paste.filter_app_factory=ndg.security.server.wsgi.pep:PEPMiddleware.filter_app_factory 
    62 prefix = pep. 
    63 pep.pathMatchList = /test_securedURI 
     47[filter:AuthorizationFilter] 
     48paste.filter_app_factory=ndg.security.server.wsgi.pep:AuthorizationMiddleware.filter_app_factory 
     49prefix = authz. 
     50#authz.pep.pathMatchList = /test_securedURI 
    6451 
    65 [filter:PDPMiddlewareFilter] 
    66 #paste.filter_app_factory=ndg.security.server.wsgi.pdp:PDPMiddleware.filter_app_factory 
    67 #prefix = pdp. 
    68 #paste.filter_app_factory = ndg.security.server.wsgi.pdp:PDPMiddlewareAppFactory 
    69 paste.filter_app_factory = ndg.security.server.wsgi.pdp:PDPHandlerMiddleware.filter_app_factory 
     52#[filter:PDPMiddlewareFilter] 
     53##paste.filter_app_factory=ndg.security.server.wsgi.pdp:PDPMiddleware.filter_app_factory 
     54##prefix = pdp. 
     55##paste.filter_app_factory = ndg.security.server.wsgi.pdp:PDPMiddlewareAppFactory 
     56#paste.filter_app_factory = ndg.security.server.wsgi.pdp:PDPHandlerMiddleware.filter_app_factory 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securedapp.py

    r5091 r5154  
    1 class TestAuthNMiddleware(object): 
    2     '''Test Application for the Authentication handler to protect''' 
    3     response = "Test Authentication redirect application" 
    4         
    5     def __init__(self, app_conf, **local_conf): 
    6         pass 
    7      
    8     def __call__(self, environ, start_response): 
    9          
    10         if environ['PATH_INFO'] == '/test_401WithNotLoggedIn': 
    11             status = "401 Unauthorized" 
    12              
    13         else: 
    14             status = "404 Not found" 
    15                  
    16 #        start_response(status, 
    17 #                       [('Content-length',  
    18 #                         str(len(TestAuthNMiddleware.response))), 
    19 #                        ('Content-type', 'text/plain')]) 
    20 #        return [TestAuthNMiddleware.response] 
    21         return self._setResponse(environ, start_response) 
    22      
    23     def _setResponse(self, environ, start_response): 
    24         if 'REMOTE_USER' in environ: 
    25             response = """<html> 
    26     <head/> 
    27     <body> 
    28         <p>Authenticated!</p> 
    29         <p><a href="/logout">logout</a></p> 
    30     </body> 
    31 </html>""" 
    32             start_response('200 OK',  
    33                            [('Content-type', 'text/html'), 
    34                             ('Content-length', str(len(response)))]) 
    35         else: 
    36             response = "Trigger OpenID Relying Party..." 
    37             start_response('401 Unauthorized',  
    38                            [('Content-type', 'text/plain'), 
    39                             ('Content-length', str(len(response)))]) 
    40         return [response] 
     1#!/usr/bin/env python 
     2"""NDG Security test harness for authorisation middleware used to secure an 
     3application 
     4 
     5NERC DataGrid Project 
     6""" 
     7__author__ = "P J Kershaw" 
     8__date__ = "20/11/08" 
     9__copyright__ = "(C) 2009 Science and Technology Facilities Council" 
     10__contact__ = "Philip.Kershaw@stfc.ac.uk" 
     11__revision__ = "$Id$" 
     12 
    4113     
    4214def app_factory(globalConfig, **localConfig): 
     
    4719 
    4820class AuthZTestMiddleware(object): 
     21    """This class simulates the application to be secured by the NDG Security 
     22    authorization middleware 
     23    """ 
    4924    method = { 
    5025"/": 'default', 
     
    11994 
    12095    def test_403(self, environ, start_response): 
     96        """Trigger the Authorization middleware by returning a 403 Forbidden 
     97        HTTP status code from this URI""" 
     98         
    12199        if 'REMOTE_USER' in environ: 
    122100            response = """<html> 
     
    131109                            ('Content-length', str(len(response)))]) 
    132110        else: 
    133             response = "Trigger AuthZ..." 
     111            response = ("Authorization middleware is triggered becuase this " 
     112                        "page returns a 403 Forbidden status.") 
    134113            start_response('403 Forbidden',  
    135114                           [('Content-type', 'text/plain'), 
     
    138117 
    139118    def test_securedURI(self, environ, start_response): 
     119        """To be secured, the Authorization middleware must have this URI in 
     120        its policy""" 
    140121        if 'REMOTE_USER' in environ: 
    141122            response = """<html> 
     
    150131                            ('Content-length', str(len(response)))]) 
    151132        else: 
    152             response = "Trigger AuthZ..." 
    153             start_response('403 Forbidden',  
     133            response = ("Authorization middleware must have this URI in its " 
     134                        "policy in order to secure it!") 
     135            start_response('200 OK',  
    154136                           [('Content-type', 'text/plain'), 
    155137                            ('Content-length', str(len(response)))]) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securityservices.ini

    r5148 r5154  
    221221# AuthKit Set-up 
    222222authkit.setup.method=openid, cookie 
    223 authkit.cookie.name=ndg.security 
    224 authkit.cookie.secret=secret encryption string 
     223 
     224# This cookie name and secret MUST agree with the name used by the  
     225# Authentication Filter used to secure a given app 
     226authkit.cookie.name=ndg.security.auth 
     227authkit.cookie.secret=9wvZObs9anUEhSIAnJNoY2iJq59FfYZr 
    225228authkit.cookie.signoutpath = /logout 
    226229authkit.openid.path.signedin=/ 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securityservicesapp.py

    r5086 r5154  
    11#!/usr/bin/env python 
    2 """NDG Security test harness for authorisation middleware 
     2"""NDG Security test harness for security web services middleware stack 
    33 
    44NERC DataGrid Project 
Note: See TracChangeset for help on using the changeset viewer.