Ignore:
Timestamp:
07/01/10 14:12:08 (10 years ago)
Author:
pjkersha
Message:

Working Genshi PEP result handler plugin

Location:
TI12-security/trunk/NDGSecurity/python
Files:
14 added
10 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/__init__.py

    r6265 r6271  
    1616from urlparse import urlunsplit 
    1717from httplib import UNAUTHORIZED, FORBIDDEN 
    18          
     18 
     19from paste.cascade import Cascade 
     20from paste.urlparser import StaticURLParser 
    1921from authkit.authenticate.multi import MultiHandler 
    2022 
     
    3234from ndg.security.server.wsgi.session import (SessionMiddlewareBase,  
    3335                                              SessionHandlerMiddleware) 
    34      
     36from ndg.security.server.wsgi.authz.result_handler import \ 
     37    PEPResultHandlerMiddlewareBase 
     38from ndg.security.server.wsgi.authz.result_handler.basic import \ 
     39    PEPResultHandlerMiddleware 
     40 
    3541from ndg.security.common.authz.msi import (Policy, PIP, PIPBase,  
    3642                                           PIPAttributeQuery,  
     
    4147class PEPFilterError(Exception): 
    4248    """Base class for PEPFilter exception types""" 
     49     
    4350     
    4451class PEPFilterConfigError(PEPFilterError): 
     
    6168     
    6269    SESSION_KEYNAME = 'sessionKey' 
    63  
    64     # Key names for PEP context information 
    65     PEPCTX_SESSION_KEYNAME = 'pepCtx' 
    66     PEPCTX_REQUEST_SESSION_KEYNAME = 'request' 
    67     PEPCTX_RESPONSE_SESSION_KEYNAME = 'response' 
    68     PEPCTX_TIMESTAMP_SESSION_KEYNAME = 'timestamp' 
    6970    POLICY_FILEPATH_PARAMNAME = 'filePath' 
    7071     
     
    622623    """AuthorizationMiddlewareBase configuration related exceptions""" 
    623624  
    624   
    625 # Import here to avoid import error 
    626 from ndg.security.server.wsgi.authz.result_handler.basic import \ 
    627     PEPResultHandlerMiddleware 
    628625    
    629626class AuthorizationMiddlewareBase(NDGSecurityMiddlewareBase): 
     
    640637    PIP_PARAM_PREFIX = 'pip.' 
    641638    PEP_RESULT_HANDLER_PARAMNAME = "pepResultHandler" 
    642      
    643          
     639    PEP_RESULT_HANDLER_PARAM_PREFIX = PEP_RESULT_HANDLER_PARAMNAME + '.' 
     640    PEP_RESULT_HANDLER_STATIC_CONTENT_DIR_PARAMNAME = 'staticContentDir' 
     641     
    644642    class PIP_MIDDLEWARE_CLASS(object): 
    645643        """Policy Information Point WSGI middleware abstract base,  
     
    668666        dictionary 
    669667        """ 
    670         authzPrefix = prefix + AuthorizationMiddlewareBase.PEP_PARAM_PREFIX 
     668        cls = AuthorizationMiddlewareBase 
     669         
     670        # Allow for static content for use with PEP result handler middleware         
     671        pepResultHandlerParamPrefix = prefix + \ 
     672                                            cls.PEP_RESULT_HANDLER_PARAM_PREFIX 
     673        pepResultHandlerStaticContentDirParamName = \ 
     674            pepResultHandlerParamPrefix + \ 
     675            cls.PEP_RESULT_HANDLER_STATIC_CONTENT_DIR_PARAMNAME 
     676         
     677        pepResultHandlerStaticContentDir = app_conf.get( 
     678                                    pepResultHandlerStaticContentDirParamName) 
     679        if pepResultHandlerStaticContentDir is not None:     
     680            staticApp = StaticURLParser(pepResultHandlerStaticContentDir) 
     681            app = Cascade([app, staticApp], catch=(404,)) 
     682 
     683        authzPrefix = prefix + cls.PEP_PARAM_PREFIX 
    671684        pepFilter = PEPFilter(app, 
    672685                              global_conf, 
     
    678691        # so that it can take a copy of the beaker session object from environ 
    679692        # ahead of the PDP's request to it for an Attribute Certificate 
    680         pipPrefix = AuthorizationMiddlewareBase.PIP_PARAM_PREFIX 
     693        pipPrefix = cls.PIP_PARAM_PREFIX 
    681694        pipFilter = self.__class__.PIP_MIDDLEWARE_CLASS(pepFilter, 
    682695                                                        global_conf, 
     
    688701 
    689702        pepResultHandlerClassName = app_conf.pop( 
    690                 prefix+AuthorizationMiddlewareBase.PEP_RESULT_HANDLER_PARAMNAME,  
    691                 None) 
     703                                        prefix+cls.PEP_RESULT_HANDLER_PARAMNAME,  
     704                                        None) 
    692705        if pepResultHandlerClassName is None: 
    693706            pepResultHandler = PEPResultHandlerMiddleware 
    694707        else: 
    695708            pepResultHandler = importClass(pepResultHandlerClassName, 
    696                                         objectType=PEPResultHandlerMiddleware) 
    697              
     709                                    objectType=PEPResultHandlerMiddlewareBase) 
     710                                
    698711        app.add_method(PEPFilter.MIDDLEWARE_ID, 
    699712                       pepResultHandler.filter_app_factory, 
    700713                       global_conf, 
    701                        prefix=prefix, 
     714                       prefix=pepResultHandlerParamPrefix, 
    702715                       **app_conf) 
    703716         
    704         app.add_checker(PEPFilter.MIDDLEWARE_ID, pepInterceptFunc)                 
    705          
    706         super(AuthorizationMiddlewareBase, self).__init__(app, 
    707                                                       global_conf, 
    708                                                       prefix=prefix, 
    709                                                       **app_conf) 
     717        app.add_checker(PEPFilter.MIDDLEWARE_ID, pepInterceptFunc) 
     718 
     719        super(AuthorizationMiddlewareBase, self).__init__(app, {}) 
    710720  
    711721 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/result_handler/__init__.py

    r6264 r6271  
    1212__revision__ = "$Id: $" 
    1313__license__ = "BSD - see LICENSE file in top-level directory" 
     14from ndg.security.server.wsgi.session import SessionMiddlewareBase 
     15 
     16 
     17class PEPResultHandlerMiddlewareBase(SessionMiddlewareBase): 
     18    """Abstract Base class for Policy Enforcement Point result handler  
     19    specialisations""" 
     20     
     21    @SessionMiddlewareBase.initCall 
     22    def __call__(self, environ, start_response): 
     23        """Set access denied response in derived class 
     24         
     25        @type environ: dict 
     26        @param environ: WSGI environment variables dictionary 
     27        @type start_response: function 
     28        @param start_response: standard WSGI start response function 
     29        @rtype: iterable 
     30        @return: response 
     31        """  
     32        raise NotImplementedError() 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/result_handler/basic.py

    r6265 r6271  
    1818 
    1919from ndg.security.server.wsgi import NDGSecurityMiddlewareBase 
    20 from ndg.security.server.wsgi.session import SessionMiddlewareBase 
    21 from ndg.security.server.wsgi.authz import PEPFilter 
     20from ndg.security.server.wsgi.authz.result_handler import ( 
     21                                                PEPResultHandlerMiddlewareBase) 
    2222 
    2323 
    24 class PEPResultHandlerMiddleware(SessionMiddlewareBase): 
     24class PEPResultHandlerMiddleware(PEPResultHandlerMiddlewareBase): 
    2525    """This middleware is invoked if access is denied to a given resource.  It 
    2626    is incorporated into the call stack by passing it in to a MultiHandler  
     
    3535    AuthorizationMiddlewareBase pepResultHandler keyword. 
    3636     
    37     SessionMiddlewareBase base class defines user session key and  
    38     isAuthenticated property 
     37    PEPResultHandlerMiddlewareBase (SessionMiddlewareBase) base class defines  
     38    user session key and isAuthenticated property 
    3939    """ 
    4040     
     
    5656                                                         **app_conf) 
    5757                
    58     @NDGSecurityMiddlewareBase.initCall 
     58    @PEPResultHandlerMiddlewareBase.initCall 
    5959    def __call__(self, environ, start_response): 
    6060         
    6161        log.debug("PEPResultHandlerMiddleware.__call__ ...") 
    6262         
    63         self.session = self.environ.get(self.sessionKey) 
     63        session = self.environ.get(self.sessionKey) 
    6464        if not self.isAuthenticated: 
    6565            # This check is included as a precaution: this condition should be 
     
    7070        else: 
    7171            # Get response message from PDP recorded by PEP 
    72             pepCtx = self.session.get(PEPFilter.PEPCTX_SESSION_KEYNAME, {}) 
    73             pdpResponse = pepCtx.get(PEPFilter.PEPCTX_RESPONSE_SESSION_KEYNAME) 
     72            pepCtx = session.get( 
     73                    PEPResultHandlerMiddleware.PEPCTX_SESSION_KEYNAME, {}) 
     74            pdpResponse = pepCtx.get( 
     75                    PEPResultHandlerMiddleware.PEPCTX_RESPONSE_SESSION_KEYNAME) 
    7476            msg = getattr(pdpResponse, 'message', '') or '' 
    7577                 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/result_handler/genshi/__init__.py

    r6268 r6271  
    1111__revision__ = "$Id: $" 
    1212__license__ = "BSD - see LICENSE file in top-level directory" 
     13import logging 
     14log = logging.getLogger(__name__) 
     15 
     16from os import path 
     17from httplib import UNAUTHORIZED, FORBIDDEN 
    1318from string import Template 
     19 
     20from paste.cascade import Cascade 
     21from paste.urlparser import StaticURLParser 
    1422from genshi.template import TemplateLoader 
    1523 
    16 from httplib import UNAUTHORIZED, FORBIDDEN 
    17  
    18 from ndg.security.server.wsgi import NDGSecurityMiddlewareBase 
    19 from ndg.security.server.wsgi.session import SessionMiddlewareBase 
     24from ndg.security.server.wsgi.authz.result_handler import \ 
     25    PEPResultHandlerMiddlewareBase 
    2026 
    2127 
    22 class GenshiPEPResultHandlerMiddleware(SessionMiddlewareBase): 
     28class GenshiPEPResultHandlerMiddleware(PEPResultHandlerMiddlewareBase): 
    2329    """Genshi based PEP result handler 
    2430    """        
    2531    DEFAULT_TMPL_NAME = 'accessdenied.html' 
    2632    DEFAULT_TMPL_DIR = path.join(path.dirname(__file__), 'templates') 
    27     DEFAULT_STATIC_CONTENT_DIR = path.join(path.dirname(__file__), 'layout') 
    2833     
    2934    MSG_TMPL = ( 
     
    3843        'templateName': DEFAULT_TMPL_NAME, 
    3944        'templateRootDir': DEFAULT_TMPL_DIR, 
    40         'staticContentRootDir': DEFAULT_STATIC_CONTENT_DIR, 
     45        'baseURL': '', 
    4146        'heading': '', 
     47        'title': '', 
    4248        'leftLogo': '', 
    4349        'leftAlt': '', 
     
    6470        dictionary 
    6571        ''' 
    66         super(GenshiPEPResultHandlerMiddleware, self).__init__(app, 
    67                                                                global_conf, 
    68                                                                prefix=prefix, 
    69                                                                **app_conf)  
     72        super(GenshiPEPResultHandlerMiddleware, self).__init__(app, {})  
    7073                
    7174        # Initialise attributes 
     
    7578        # Update from keywords    
    7679        for i in app_conf: 
    77             setattr(self, i, app_conf[i]) 
     80            if prefix and i.startswith(prefix): 
     81                attrName = i.rsplit(prefix, 2)[-1] 
     82                setattr(self, attrName, app_conf[i]) 
    7883             
    7984        self.__loader = TemplateLoader(self.templateRootDir, auto_reload=True) 
    80          
    81     @NDGSecurityMiddlewareBase.initCall 
     85 
     86    @PEPResultHandlerMiddlewareBase.initCall 
    8287    def __call__(self, environ, start_response): 
    8388        """Render access denied message or else if user is not authenticated, 
     
    9196        @return: response 
    9297        """  
     98        session = self.environ.get(self.sessionKey) 
    9399        if not self.isAuthenticated: 
    94100            # sets 401 response to be trapped by authentication handler 
    95             log.warning("PEPResultHandlerMiddleware: user is not " 
     101            log.warning("GenshiPEPResultHandlerMiddleware: user is not " 
    96102                        "authenticated - setting HTTP 401 response") 
    97103            return self._setErrorResponse(code=UNAUTHORIZED) 
    98104        else: 
    99105            # Get response message from PDP recorded by PEP 
    100             pepCtx = self.session.get(PEPFilter.PEPCTX_SESSION_KEYNAME, {}) 
    101             pdpResponse = pepCtx.get(PEPFilter.PEPCTX_RESPONSE_SESSION_KEYNAME) 
     106            cls = GenshiPEPResultHandlerMiddleware 
     107            pepCtx = session.get(cls.PEPCTX_SESSION_KEYNAME, {}) 
     108            pdpResponse = pepCtx.get(cls.PEPCTX_RESPONSE_SESSION_KEYNAME) 
    102109            pdpResponseMsg = getattr(pdpResponse, 'message', '') or '' 
    103110                 
     
    106113 
    107114            response = self._render(xml=msg) 
    108             start_response( 
    109                 GenshiPEPResultHandlerMiddleware.getStatusMessage(FORBIDDEN), 
    110                 [('Content-type', 'text/html'), 
    111                  ('Content-Length', str(len(response)))]) 
     115            start_response(cls.getStatusMessage(FORBIDDEN), 
     116                           [('Content-type', 'text/html'), 
     117                            ('Content-Length', str(len(response)))]) 
    112118             
    113119            return response 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/result_handler/genshi/layout/default.css

    r6268 r6271  
    11/* 
    2 * NDG Security OpenID Provider and Relying Party Stylesheet 
     2* NDG Security PEP Response handler, OpenID Provider and Relying Party  
     3* Stylesheet 
    34*/ 
    45 
     
    1213        line-height:1.4; 
    1314        font-size: small; 
     15} 
     16 
     17/* 
     18* PEP Access Denied message panel 
     19*/ 
     20#accessDeniedMessage { 
     21    font-size:0.9em; 
     22    color: black; 
     23    background-color: #e6f0f8; 
     24    margin-top:10px;  
     25    margin-bottom: 20px;  
     26    padding-top: 10px;  
     27    padding-right: 10px;  
     28    padding-left: 7px;  
     29    padding-bottom: 10px; 
    1430} 
    1531 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authz/result_handler/genshi/templates/accessdenied.html

    r6268 r6271  
    77    </head> 
    88    <body> 
     9        <?python from genshi import HTML ?>         
    910        <div id="main"> 
    1011            <div py:replace="header()"/> 
    1112            <div id="errorContent"> 
    12                 <div class="error" py:if="c.xml"> 
    13                 $xml 
     13                <div class="error" py:if="xml"> 
     14                ${HTML(xml)} 
    1415                </div> 
    1516            </div> 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/openid/relyingparty/signin_interface/genshi/__init__.py

    r6107 r6271  
    1515 
    1616from paste.cascade import Cascade 
    17 from paste.registry import RegistryManager 
    18 from paste.urlparser import StaticURLParser 
    19          
     17from paste.urlparser import StaticURLParser      
    2018from genshi.template import TemplateLoader 
    2119 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/session.py

    r6265 r6271  
    2828        'sessionKey': 'beaker.session.ndg.security' 
    2929    } 
     30 
     31    # Key names for PEP context information 
     32    PEPCTX_SESSION_KEYNAME = 'pepCtx' 
     33    PEPCTX_REQUEST_SESSION_KEYNAME = 'request' 
     34    PEPCTX_RESPONSE_SESSION_KEYNAME = 'response' 
     35    PEPCTX_TIMESTAMP_SESSION_KEYNAME = 'timestamp' 
    3036    
    3137    _isAuthenticated = lambda self: \ 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/integration/authz_lite/securedapp.ini

    r6063 r6271  
    7878paste.filter_app_factory=ndg.security.server.wsgi.authz:SAMLAuthorizationMiddleware.filter_app_factory 
    7979prefix = authz. 
     80authz.pepResultHandler = ndg.security.server.wsgi.authz.result_handler.genshi.GenshiPEPResultHandlerMiddleware 
     81authz.pepResultHandler.staticContentDir = %(here)s/pep_result_handler 
     82authz.pepResultHandler.baseURL = http://localhost:7080 
     83authz.pepResultHandler.heading = Access Denied 
     84authz.pepResultHandler.messageTemplate = Access is forbidden for this resource:<div id="accessDeniedMessage">$pdpResponseMsg</div>Please check with your site administrator that you have the required access privileges. 
     85authz.pepResultHandler.footerText = This site is for test purposes only. 
     86authz.pepResultHandler.rightLink = http://ceda.ac.uk/ 
     87authz.pepResultHandler.rightImage = %(authz.pepResultHandler.baseURL)s/layout/CEDA_RightButton60.png 
     88authz.pepResultHandler.rightAlt = Centre for Environmental Data Archival 
     89authz.pepResultHandler.helpIcon = %(authz.pepResultHandler.baseURL)s/layout/icons/help.png 
     90 
    8091policy.filePath = %(here)s/policy.xml 
    8192 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r6260 r6271  
    3535port = %(portNum)s 
    3636 
    37 [filter-app:OpenIDProviderFilterApp] 
    38 use = egg:Paste#httpexceptions 
    39 next = cascade 
    40  
    41 # Composite for OpenID Provider to enable settings for picking up static  
    42 # content 
    43 [composit:cascade] 
    44 use = egg:Paste#cascade 
    45 app1 = OpenIDProviderStaticContent 
    46 app2 = OpenIDProviderApp 
    47 catch = 404 
    48  
    49 [app:OpenIDProviderStaticContent] 
    50 use = egg:Paste#static 
    51 document_root = %(here)s/openidprovider 
     37# Provider borrows content from RP static content dir so the cascade is not 
     38# needed(!) 
     39#[filter-app:OpenIDProviderFilterApp] 
     40#use = egg:Paste#httpexceptions 
     41#next = cascade 
     42# 
     43## Composite for OpenID Provider to enable settings for picking up static  
     44## content 
     45#[composit:cascade] 
     46#use = egg:Paste#cascade 
     47#app1 = OpenIDProviderStaticContent 
     48#app2 = OpenIDProviderApp 
     49#catch = 404 
     50# 
     51#[app:OpenIDProviderStaticContent] 
     52#use = egg:Paste#static 
     53#document_root = %(here)s/openidprovider 
    5254 
    5355# Ordering of filters and app is critical 
Note: See TracChangeset for help on using the changeset viewer.