Changeset 5786 for TI12-security


Ignore:
Timestamp:
01/10/09 14:21:07 (10 years ago)
Author:
pjkersha
Message:

Updated OpenID AX (Attribute Exchange) interface. Attributes passed over this interface are now stored in the authentication session at the Relying Party.

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

Legend:

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

    r5782 r5786  
    223223                                                                start_response) 
    224224        
    225          
    226 class SessionHandlerMiddlewareConfigError(Exception): 
     225 
     226class SessionHandlerMiddlewareError(Exception): 
     227    """Base exception for SessionHandlerMiddleware""" 
     228             
     229class SessionHandlerMiddlewareConfigError(SessionHandlerMiddlewareError): 
    227230    """Configuration errors from SessionHandlerMiddleware""" 
     231     
     232class OpenIdAXConfigError(SessionHandlerMiddlewareError): 
     233    """Error parsing OpenID Ax (Attribute Exchange) parameters""" 
    228234     
    229235     
     
    235241    URI as implemented in AuthKit 
    236242    ''' 
    237      
     243    AX_SESSION_KEYNAME = 'openid.ax' 
    238244    SM_URI_SESSION_KEYNAME = 'sessionManagerURI' 
    239245    ID_SESSION_KEYNAME = 'sessionId' 
     
    375381                       SessionHandlerMiddleware.AX_KEYNAME in axData: 
    376382                         
    377                         sessionManagerURI = axData[ 
    378                             SessionHandlerMiddleware.AX_KEYNAME].get( 
     383                        ax = axData[SessionHandlerMiddleware.AX_KEYNAME] 
     384                         
     385                        # Save attributes keyed by attribute name 
     386                        session[ 
     387                            SessionHandlerMiddleware.AX_SESSION_KEYNAME 
     388                        ] = SessionHandlerMiddleware._parseOpenIdAX(ax) 
     389                         
     390                        log.debug("SessionHandlerMiddleware: updated session " 
     391                                  "with OpenID AX values: %r" %  
     392                                  session[ 
     393                                    SessionHandlerMiddleware.AX_SESSION_KEYNAME 
     394                                  ]) 
     395                             
     396                        # Save Session Manager specific attributes 
     397                        sessionManagerURI = ax.get( 
    379398                                SessionHandlerMiddleware.SM_URI_AX_KEYNAME) 
    380399                             
     
    382401                                ] = sessionManagerURI 
    383402     
    384                         sessionId = axData[ 
    385                             SessionHandlerMiddleware.AX_KEYNAME].get( 
     403                        sessionId = ax.get( 
    386404                                SessionHandlerMiddleware.SESSION_ID_AX_KEYNAME) 
    387405                        session[SessionHandlerMiddleware.ID_SESSION_KEYNAME 
    388406                                ] = sessionId 
     407                                 
    389408                        session.save() 
    390409                         
     
    404423             
    405424        return self._app(environ, _start_response) 
     425     
     426    @staticmethod                     
     427    def _parseOpenIdAX(ax): 
     428        """Return a dictionary of attribute exchange attributes parsed from the  
     429        OpenID Provider response set in the REMOTE_USER_DATA AuthKit environ 
     430        key 
     431         
     432        @param ax: dictionary of AX parameters - format of keys is e.g. 
     433        count.paramName, value.paramName.<n>, type.paramName 
     434        @type ax: dict 
     435        @return: dictionary of parameters keyed by parameter with values for 
     436        each parameter a tuple of count.paramName values 
     437        @rtype: dict 
     438        """ 
     439         
     440        # Copy Attributes into session 
     441        outputKeys = [k.replace('type.', '') for k in ax.keys() 
     442                      if k.startswith('type.')] 
     443         
     444        output = {} 
     445        for outputKey in outputKeys: 
     446            axCountKeyName = 'count.' + outputKey 
     447            axCount = int(ax[axCountKeyName]) 
     448             
     449            axValueKeyPrefix = 'value.%s.' % outputKey 
     450            output[outputKey] = tuple([v for k, v in ax.items()  
     451                                       if k.startswith(axValueKeyPrefix)]) 
     452             
     453            nVals = len(output[outputKey]) 
     454            if nVals != axCount: 
     455                raise OpenIdAXConfigError('Got %d parameters for AX attribute ' 
     456                                          '"%s"; but "%s" AX key is set to %d' 
     457                                          % (nVals, 
     458                                             axCountKeyName, 
     459                                             axCountKeyName, 
     460                                             axCount)) 
     461                                              
     462        return output 
    406463 
    407464 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/authz.py

    r5774 r5786  
    8282                        "Please check with your site administrator that you " 
    8383                        "have the required access privileges." %  
    84                         msg.join('\n\n'*2)) 
     84                        msg.join(('\n\n',)*2)) 
    8585 
    8686            return self._setErrorResponse(code=FORBIDDEN, msg=response) 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/__init__.py

    r5782 r5786  
    3131from ndg.security.common.utils.classfactory import instantiateClass 
    3232from ndg.security.server.wsgi import NDGSecurityMiddlewareBase         
     33from ndg.security.server.wsgi.openid.provider.authninterface import \ 
     34    AbstractAuthNInterface, AuthNInterfaceError 
    3335from ndg.security.server.wsgi.openid.provider.axinterface import AXInterface,\ 
    3436    MissingRequiredAttrs, AXInterfaceReloginRequired 
    3537 
    36  
    37 class AuthNInterfaceError(Exception): 
    38     """Base class for AbstractAuthNInterface exceptions 
    39      
    40     A standard message is raised set by the msg class variable but the actual 
    41     exception details are logged to the error log.  The use of a standard  
    42     message enables callers to use its content for user error messages. 
    43      
    44     @type msg: basestring 
    45     @cvar msg: standard message to be raised for this exception""" 
    46     userMsg = ("An internal error occurred during login,  Please contact your " 
    47                "system administrator") 
    48     errorMsg = "AuthNInterface error" 
    49      
    50     def __init__(self, *arg, **kw): 
    51         if len(arg) > 0: 
    52             msg = arg[0] 
    53         else: 
    54             msg = self.__class__.errorMsg 
    55              
    56         log.error(msg) 
    57         Exception.__init__(self, msg, **kw) 
    58          
    59 class AuthNInterfaceInvalidCredentials(AuthNInterfaceError): 
    60     """User has provided incorrect username/password.  Raise from logon""" 
    61     userMsg = ("Invalid username / password provided.  Please try again.  If " 
    62                "the problem persists please contact your system " 
    63                "administrator") 
    64     errorMsg = "Invalid username/password provided" 
    65  
    66 class AuthNInterfaceUsername2IdentifierMismatch(AuthNInterfaceError):  
    67     """User has provided a username which doesn't match the identifier from 
    68     the OpenID URL that they provided.  DOESN'T apply to ID Select mode where 
    69     the user has given a generic URL for their OpenID Provider.""" 
    70     userMsg = ("Invalid username for the OpenID entered.  Please ensure you " 
    71                "have the correct OpenID and username and try again.  If the " 
    72                "problem persists contact your system administrator") 
    73     errorMsg = "invalid username / OpenID identifier combination" 
    74      
    75 class AuthNInterfaceRetrieveError(AuthNInterfaceError): 
    76     """Error with retrieval of information to authenticate user e.g. error with 
    77     database look-up.  Raise from logon""" 
    78     errorMsg = ("An error occurred retrieving information to check the login " 
    79                 "credentials") 
    80  
    81 class AuthNInterfaceInitError(AuthNInterfaceError): 
    82     """Error with initialisation of AuthNInterface.  Raise from __init__""" 
    83     errorMsg = "AuthNInterface initialisation error" 
    84      
    85 class AuthNInterfaceConfigError(AuthNInterfaceError): 
    86     """Error with Authentication configuration.  Raise from __init__""" 
    87     errorMsg = "AuthNInterface configuration error" 
    88      
    89 class AbstractAuthNInterface(object): 
    90     '''OpenID Provider abstract base class for authentication configuration. 
    91     Derive from this class to define the authentication interface for users 
    92     logging into the OpenID Provider''' 
    93      
    94     def __init__(self, **prop): 
    95         """Make any initial settings 
    96          
    97         Settings are held in a dictionary which can be set from **prop, 
    98         a call to setProperties() or by passing settings in an XML file 
    99         given by propFilePath 
    100          
    101         @type **prop: dict 
    102         @param **prop: set properties via keywords  
    103         @raise AuthNInterfaceInitError: error with initialisation 
    104         @raise AuthNInterfaceConfigError: error with configuration 
    105         @raise AuthNInterfaceError: generic exception not described by the  
    106         other specific exception types. 
    107         """ 
    108      
    109     def logon(self, environ, userIdentifier, username, password): 
    110         """Interface login method 
    111          
    112         @type environ: dict 
    113         @param environ: standard WSGI environ parameter 
    114          
    115         @type userIdentifier: basestring or None 
    116         @param userIdentifier: OpenID user identifier - this implementation of 
    117         an OpenID Provider uses the suffix of the user's OpenID URL to specify 
    118         a unique user identifier.  It ID Select mode was chosen, the identifier 
    119         will be None and can be ignored.  In this case, the implementation of 
    120         the decide method in the rendering interface must match up the username 
    121         to a corresponding identifier in order to construct a complete OpenID 
    122         user URL. 
    123          
    124         @type username: basestring 
    125         @param username: user identifier for authentication 
    126          
    127         @type password: basestring 
    128         @param password: corresponding password for username givens 
    129          
    130         @raise AuthNInterfaceInvalidCredentials: invalid username/password 
    131         @raise AuthNInterfaceUsername2IdentifierMismatch: username doesn't  
    132         match the OpenID URL provided by the user.  (Doesn't apply to ID Select 
    133         type requests). 
    134         @raise AuthNInterfaceRetrieveError: error with retrieval of information 
    135         to authenticate user e.g. error with database look-up. 
    136         @raise AuthNInterfaceError: generic exception not described by the  
    137         other specific exception types. 
    138         """ 
    139         raise NotImplementedError() 
    140      
    141     def username2UserIdentifiers(self, environ, username): 
    142         """Map the login username to an identifier which will become the 
    143         unique path suffix to the user's OpenID identifier.  The  
    144         OpenIDProviderMiddleware takes self.urls['id_url']/ 
    145         self.urls['id_yadis'] and adds it to this identifier: 
    146          
    147             identifier = self._authN.username2UserIdentifiers(environ, 
    148                                                               username) 
    149             identityURL = self.createIdentityURI(self.urls['url_id'], 
    150                                                  identifier) 
    151          
    152         @type environ: dict 
    153         @param environ: standard WSGI environ parameter 
    154  
    155         @type username: basestring 
    156         @param username: user identifier 
    157          
    158         @rtype: tuple 
    159         @return: one or more identifiers to be used to make OpenID user  
    160         identity URL(s). 
    161          
    162         @raise AuthNInterfaceConfigError: problem with the configuration  
    163         @raise AuthNInterfaceRetrieveError: error with retrieval of information 
    164         to identifier e.g. error with database look-up. 
    165         @raise AuthNInterfaceError: generic exception not described by the  
    166         other specific exception types. 
    167         """ 
    168         raise NotImplementedError() 
    169  
    170     def logout(self, authNInterface): 
    171         """Stub to enable custom actions for logout. 
    172          
    173         @type authNInterface: AbstractAuthNInterface derived type 
    174         @param authNInterface: authentication interface object.  See 
    175         AbstractAuthNInterface class for details 
    176         """ 
    177         raise NotImplementedError() 
    178      
    17938 
    18039# Aliases to AXInterface exception types     
     
    18948# end aliases to AXInterface exception types 
    19049 
     50 
    19151class OpenIDProviderMiddlewareError(Exception): 
    19252    """OpenID Provider WSGI Middleware Error""" 
     
    19454class OpenIDProviderConfigError(OpenIDProviderMiddlewareError): 
    19555    """OpenID Provider Configuration Error""" 
     56 
    19657 
    19758class OpenIDProviderMissingAXResponseHandler(OpenIDProviderMiddlewareError):  
    19859    """Raise if a Relying Party *requires* one or more attributes via 
    19960    the AX interface but no AX Response handler has been set""" 
     61   
    20062   
    20163class OpenIDProviderMiddleware(NDGSecurityMiddlewareBase): 
     
    251113        authNInterface=AbstractAuthNInterface) 
    252114     
    253     defPaths = dict([(k, v) for k, v in defOpt.items() if k.startswith('path_')]) 
     115    defPaths = dict([(k, v) for k, v in defOpt.items()  
     116                     if k.startswith('path_')]) 
    254117     
    255118    userIdentifierPat = '([^/]*)' 
    256119     
    257     USERNAME_SESSIONKEY = 'username' 
    258     USERIDENTIFIER_SESSIONKEY = 'userIdentifier' 
    259     OPENID_SESSIONKEY = 'openID' 
    260     APPROVED_FLAG_SESSIONKEY = 'approved' 
    261     LAST_CHECKID_REQUEST_SESSIONKEY = 'lastCheckIDRequest' 
    262      
    263     def __init__(self, app, app_conf=None, prefix='openid.provider.', **kw): 
     120    USERNAME_SESSION_KEYNAME = 'username' 
     121    IDENTITY_URI_SESSION_KEYNAME = 'identityURI' 
     122    APPROVED_FLAG_SESSION_KEYNAME = 'approved' 
     123    LAST_CHECKID_REQUEST_SESSION_KEYNAME = 'lastCheckIDRequest' 
     124    PARAM_PREFIX = 'openid.provider.' 
     125     
     126    IDENTITY_URI_TMPL_PARAMNAME = 'identityUriTemplate' 
     127     
     128    def __init__(self, app, app_conf=None, prefix=PARAM_PREFIX, **kw): 
    264129        ''' 
    265130        @type app: callable following WSGI interface 
     
    347212        self.base_url = opt['base_url'] 
    348213 
     214 
     215        self.identityUriTmpl = opt.get( 
     216                        OpenIDProviderMiddleware.IDENTITY_URI_TMPL_PARAMNAME) 
     217        if not self.identityUriTmpl: 
     218            raise TypeError("%s is not set" %  
     219                        OpenIDProviderMiddleware.IDENTITY_URI_TMPL_PARAMNAME) 
     220         
    349221        # Full Paths 
    350222        self.urls = dict([(k.replace('path_', 'url_'), self.base_url + v) 
     
    468340                    else: 
    469341                        opt[filtOptName] = optVal 
    470 #                else: 
    471                     # Options not starting with prefix are ignored - omit debug 
    472                     # it's too verbose even for debug setting :) 
    473 #                    log.debug("Skipping option \"%s\": it doesn't start with " 
    474 #                              "the prefix \"%s\"", optName, prefix) 
    475342            else: 
    476343                filtOptName = '_'.join(optName.split('.')) 
     
    537404        '''Split uri into identity and uri fragment components 
    538405         
     406        FIXME: this method assumes a fixed identity URI scheme and should be 
     407        refactored to use a template based parsing 
     408         
    539409        @type uri: basestring 
    540410        @param uri: identity URI to be parsed 
     
    545415        return uri.rsplit('/', 1) 
    546416     
    547  
    548417    @classmethod 
    549418    def createIdentityURI(cls, uri, userIdentifier): 
     
    608477            return self._setResponse(environ, start_response) 
    609478 
    610  
    611479    def do_id(self, environ, start_response): 
    612480        '''URL based discovery with an ID provided 
     
    623491        return response 
    624492 
    625  
    626493    def do_yadis(self, environ, start_response): 
    627494        """Handle Yadis based discovery with an ID provided 
     
    637504        response = self._render.yadis(environ, start_response) 
    638505        return response 
    639  
    640506 
    641507    def do_serveryadis(self, environ, start_response): 
     
    654520        return response 
    655521 
    656  
    657522    def do_openidserver(self, environ, start_response): 
    658523        """OpenID Server endpoint - handles OpenID Request following discovery 
     
    665530        @return: WSGI response 
    666531        """ 
    667  
    668532        try: 
    669533            oidRequest = self.oidserver.decodeRequest(self.query) 
     
    685549             
    686550        return response 
    687              
    688551 
    689552    def do_allow(self, environ, start_response): 
     
    716579         
    717580        oidRequest = self.session.get( 
    718                     OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
     581                    OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSION_KEYNAME) 
    719582        if oidRequest is None: 
    720583            log.error("Suspected do_allow called from stale request") 
     
    744607            if self.query.get('remember', 'No') == 'Yes': 
    745608                self.session[ 
    746                     OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY] = { 
     609                    OpenIDProviderMiddleware.APPROVED_FLAG_SESSION_KEYNAME] = { 
    747610                        trust_root: 'always' 
    748611                    } 
     
    790653                                          code=400) 
    791654 
    792  
    793655    def do_login(self, environ, start_response, **kw): 
    794656        """Display Login form 
     
    810672        return response 
    811673 
    812  
    813674    def do_loginsubmit(self, environ, start_response): 
    814675        """Handle user submission from login and logout 
     
    825686            if 'username' in self.query: 
    826687                # login 
    827                 if OpenIDProviderMiddleware.USERNAME_SESSIONKEY in self.session: 
    828                     log.error("Attempting login for user %s: user %s is " 
    829                               "already logged in",  
    830                     self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY], 
    831                     self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
     688                if OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME in \ 
     689                   self.session: 
     690                    log.error("Attempting login for user %s: user is already " 
     691                              "logged in", self.session[ 
     692                            OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME]) 
    832693                     
    833                     return self._redirect(start_response,self.query['fail_to']) 
     694                    return self._redirect(start_response, 
     695                                          self.query['fail_to']) 
    834696                 
    835697                oidRequest = self.session.get( 
    836                     OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
     698                OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSION_KEYNAME) 
     699                 
    837700                if oidRequest is None: 
    838701                    log.error("Getting OpenID request for login - No request " 
     
    848711                    # ID select mode enables the user to request specifying 
    849712                    # their OpenID Provider without giving a personal user URL  
    850                     userIdentifier = None 
     713                    userIdentifiers = self._authN.username2UserIdentifiers( 
     714                                                        environ, 
     715                                                        self.query['username']) 
     716                    if not isinstance(userIdentifiers, (list, tuple)): 
     717                        log.error("Unexpected type %r returned from %r for " 
     718                                  "user identifiers; expecting list or tuple" 
     719                                  % (type(userIdentifiers), type(self._authN))) 
     720                                   
     721                        return self._render.errorPage(environ, start_response, 
     722                            "An internal error occurred setting your default " 
     723                            "OpenID URL.  Please retry from the site where " 
     724                            "you entered your OpenID providing your full " 
     725                            "identity URL.  If the problem persists report it " 
     726                            "to your site administrator.") 
     727                         
     728                    # FIXME: Assume the *first* user identifier entry is the 
     729                    # one to use.  The user could have multiple identifiers 
     730                    # but in practice it's more manageable to have a single one 
     731                    identityURI = self.createIdentityURI(self.identityUriTmpl, 
     732                                                         userIdentifiers[0]) 
    851733                else: 
    852734                    # Get the unique user identifier from the user's OpenID URL 
    853                     userIdentifier = OpenIDProviderMiddleware.parseIdentityURI( 
    854                                                     oidRequest.identity)[-1] 
     735                    identityURI = oidRequest.identity 
    855736                     
    856737                # Invoke custom authentication interface plugin 
    857738                try: 
    858739                    self._authN.logon(environ, 
    859                                       userIdentifier, 
     740                                      identityURI, 
    860741                                      self.query['username'], 
    861742                                      self.query.get('password', '')) 
     
    863744                except AuthNInterfaceError, e: 
    864745                    return self._render.login(environ, start_response, 
    865                                           msg=e.userMsg, 
    866                                           success_to=self.urls['url_decide'])                    
     746                                            msg=e.userMsg, 
     747                                            success_to=self.urls['url_decide'])                    
    867748                except Exception, e: 
    868                     log.error("Unexpected exception raised during " 
    869                               "authentication: %s" % e) 
     749                    log.error("Unexpected %s type exception raised during " 
     750                              "authentication: %s" %  
     751                              e.__class__.__name__, 
     752                              traceback.format_exc()) 
    870753                    msg = ("An internal error occurred.  " 
    871754                           "Please try again or if the problems persists " 
     
    873756 
    874757                    response = self._render.login(environ, start_response, 
    875                                       msg=msg, 
    876                                       success_to=self.urls['url_decide']) 
     758                                          msg=msg, 
     759                                          success_to=self.urls['url_decide']) 
    877760                    return response 
    878761                        
    879762                self.session[ 
    880                     OpenIDProviderMiddleware.USERNAME_SESSIONKEY 
     763                    OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME 
    881764                ] = self.query['username'] 
    882765                 
    883766                self.session[ 
    884                     OpenIDProviderMiddleware.USERIDENTIFIER_SESSIONKEY 
    885                 ] = userIdentifier 
     767                    OpenIDProviderMiddleware.IDENTITY_URI_SESSION_KEYNAME 
     768                ] = identityURI 
    886769                 
    887770                self.session[ 
    888                     OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY] = {} 
     771                    OpenIDProviderMiddleware.APPROVED_FLAG_SESSION_KEYNAME] = {} 
    889772                     
    890773                self.session.save() 
    891774                 
    892                 log.info("user [%s] logged in",  
    893                     self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
     775                log.info("user [%s] logged in", self.session[ 
     776                        OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME]) 
    894777            else: 
    895778                # logout 
    896                 if OpenIDProviderMiddleware.USERNAME_SESSIONKEY not in \ 
     779                if OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME not in \ 
    897780                   self.session: 
    898781                    log.error("No user is logged in") 
     
    900783                                          self.query['fail_to']) 
    901784                 
    902                 log.info("user [%s] logging out ...", 
    903                     self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
    904  
    905                 del self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY] 
     785                log.info("user [%s] logging out ...", self.session[ 
     786                        OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME]) 
     787 
     788                del self.session[ 
     789                        OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME] 
    906790                self.session.pop( 
    907                             OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY,  
    908                             None) 
     791                        OpenIDProviderMiddleware.APPROVED_FLAG_SESSION_KEYNAME,  
     792                        None) 
    909793                self.session.save() 
    910794                 
     
    929813        else: 
    930814            log.error('Login input not recognised %r' % self.query) 
    931             return self._redirect(start_response, self.query['fail_to']) 
    932              
     815            return self._redirect(start_response, self.query['fail_to'])   
    933816 
    934817    def do_mainpage(self, environ, start_response): 
     
    954837    render = property(fget=_getRender, doc="Rendering interface instance") 
    955838     
    956      
    957839    def do_decide(self, environ, start_response): 
    958840        """Display page prompting the user to decide whether to trust the site 
     
    966848        @return: WSGI response 
    967849        """ 
    968  
    969850        oidRequest = self.session.get( 
    970                     OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
     851                    OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSION_KEYNAME) 
    971852        if oidRequest is None: 
    972853            log.error("No OpenID request set in session") 
     
    978859         
    979860        approvedRoots = self.session.get( 
    980                             OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY,  
     861                            OpenIDProviderMiddleware.APPROVED_FLAG_SESSION_KEYNAME,  
    981862                            {}) 
    982863         
     
    997878            except Exception, e: 
    998879                log.error("%s type exception raised setting response " 
    999                           "following ID Approval: %s", e.__class__.__name__,e) 
     880                          "following ID Approval: %s",  
     881                          e.__class__.__name__, 
     882                          traceback.format_exc()) 
    1000883                response = self._render.errorPage(environ, start_response, 
    1001884                        'An error occurred setting additional parameters ' 
     
    1013896                log.error("%s type exception raised calling decide page " 
    1014897                          "rendering - an OpenID identifier look-up error? " 
    1015                           "message is: %s", e.__class__.__name__,e) 
     898                          "message is: %s", e.__class__.__name__, 
     899                          traceback.format_exc()) 
    1016900                response = self._render.errorPage(environ, start_response, 
    1017901                        'An error has occurred displaying an options page ' 
     
    1020904                        'your site administrator.') 
    1021905                return response 
    1022                  
    1023          
    1024          
     906 
    1025907    def _identityIsAuthorized(self, oidRequest): 
    1026908        '''Check that a user is authorized i.e. does a session exist for their 
     
    1034916        @return: True/False is user authorized 
    1035917        ''' 
    1036         username = self.session.get(OpenIDProviderMiddleware.USERNAME_SESSIONKEY) 
     918        username = self.session.get( 
     919                            OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME) 
    1037920        if username is None: 
    1038921            return False 
     
    1043926            return True 
    1044927         
    1045         identifiers = self._authN.username2UserIdentifiers(self.environ, 
    1046                                                            username) 
    1047  
    1048         # Take two passes to allow for yadis and non-based discovery 
    1049         identityURIs = [self.createIdentityURI(self.urls['url_id'], i) 
    1050                         for i in identifiers] 
    1051          
    1052         identityURIs += [self.createIdentityURI(self.urls['url_yadis'], i) 
    1053                          for i in identifiers] 
    1054          
    1055         if oidRequest.identity not in identityURIs: 
    1056             log.debug("OpenIDProviderMiddleware._identityIsAuthorized - " 
    1057                       "user is already logged in with a different ID=%s" % \ 
    1058                       username) 
     928        identityURI = self.session.get( 
     929                        OpenIDProviderMiddleware.IDENTITY_URI_SESSION_KEYNAME) 
     930        if identityURI is None: 
     931            return False 
     932         
     933        if oidRequest.identity != identityURI: 
     934            log.debug("OpenIDProviderMiddleware._identityIsAuthorized - user " 
     935                      "is already logged in with a different ID=%s and " 
     936                      "identityURI=%s" % 
     937                      (username, identityURI)) 
    1059938            return False 
    1060939         
     
    1063942        return True 
    1064943     
    1065      
     944 
    1066945    def _trustRootIsAuthorized(self, trust_root): 
    1067946        '''Return True/False for the given trust root (Relying Party)  
     
    1074953        @return: True - trust has already been approved, False - trust root is 
    1075954        not approved''' 
    1076         approvedRoots = self.session.get(OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY, {}) 
     955        approvedRoots = self.session.get( 
     956                        OpenIDProviderMiddleware.APPROVED_FLAG_SESSION_KEYNAME,  
     957                        {}) 
    1077958        return approvedRoots.get(trust_root) is not None 
    1078  
    1079959 
    1080960    def _addSRegResponse(self, oidRequest, oidResponse): 
     
    1094974        # Callout to external callable sets additional user attributes to be 
    1095975        # returned in response to Relying Party         
    1096         sreg_data = self.sregResponseHandler(self.session.get(OpenIDProviderMiddleware.USERNAME_SESSIONKEY)) 
     976        sreg_data = self.sregResponseHandler(self.session.get( 
     977                            OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME)) 
    1097978        sreg_resp = sreg.SRegResponse.extractResponse(sreg_req, sreg_data) 
    1098979        oidResponse.addExtension(sreg_resp) 
    1099  
    1100980 
    1101981    def _addAXResponse(self, oidRequest, oidResponse): 
     
    1107987        @type oidResponse: openid.server.server.OpenIDResponse 
    1108988        @param oidResponse: OpenID response object''' 
    1109  
    1110989 
    1111990        ax_req = ax.FetchRequest.fromOpenIDRequest(oidRequest) 
     
    11561035        log.debug("Added AX parameters to response") 
    11571036         
    1158          
    11591037    def _identityApprovedPostProcessing(self, oidRequest, identifier=None): 
    11601038        '''Action following approval of a Relying Party by the user.  Add 
     
    11761054        return oidResponse 
    11771055 
    1178  
    11791056    def _handleCheckIDRequest(self, oidRequest): 
    11801057        """Handle "checkid_immediate" and "checkid_setup" type requests from 
     
    11901067        # Save request 
    11911068        self.session[ 
    1192             OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY 
     1069            OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSION_KEYNAME 
    11931070        ] = oidRequest 
    11941071         
     
    12121089                except (OpenIDProviderMissingRequiredAXAttrs, 
    12131090                        OpenIDProviderMissingAXResponseHandler): 
    1214                     response = self._render.errorPage(environ, start_response, 
     1091                    response = self._render.errorPage(self.environ,  
     1092                                                      self.start_response, 
    12151093                        'The site where you wish to signin requires ' 
    12161094                        'additional information which this site isn\'t ' 
     
    12201098                     
    12211099                except OpenIDProviderReloginRequired, e: 
    1222                     response = self._render.errorPage(environ, start_response, 
     1100                    response = self._render.errorPage(self.environ,  
     1101                                                      self.start_response, 
    12231102                        'An error occurred setting additional parameters ' 
    12241103                        'required by the site requesting your ID.  Please ' 
     
    12281107                except Exception, e: 
    12291108                    log.error("%s type exception raised setting response " 
    1230                           "following ID Approval: %s", e.__class__.__name__,e) 
    1231                     log.exception(e) 
    1232                     response = self._render.errorPage(environ, start_response, 
     1109                              "following ID Approval: %s",  
     1110                              e.__class__.__name__,  
     1111                              traceback.format_exc()) 
     1112                    response = self._render.errorPage(self.environ, 
     1113                                                      self.start_response, 
    12331114                        'An error occurred setting additional parameters ' 
    12341115                        'required by the site requesting your ID.  Please ' 
     
    12701151        except server.EncodingError, why: 
    12711152            text = why.response.encodeToKVForm() 
    1272             return self.showErrorPage(text) 
     1153            response = self._render.errorPage(environ, start_response, text) 
     1154            return response 
    12731155         
    12741156        hdr = webresponse.headers.items() 
     
    13461228    methods for handling Yadis requests only.  All other interface methods 
    13471229    return a 404 error response.  Create a derivative from this class to  
    1348     implement the other rendering methods as required.  DemoRenderingInterface 
     1230    implement the other rendering methods as required.   
     1231    ndg.security.server.wsgi.openid.provider.renderingInterface.demo.DemoRenderingInterface 
    13491232    provides an example of how to do this.  To apply a custom  
    13501233    RenderingInterface class pass it's name in the OpenIDProviderMiddleware 
     
    14541337        # username identifier 
    14551338        userIdentifier = OpenIDProviderMiddleware.parseIdentityURI( 
    1456                                                     environ['PATH_INFO'])[ - 1] 
     1339                                                    environ['PATH_INFO'])[-1] 
    14571340         
    14581341        endpoint_url = self.urls['url_openidserver'] 
     
    14841367        """ 
    14851368        response = "Page is not implemented" 
    1486         start_response('%d %s' % (404, httplib.responses[code]), 
     1369        start_response('%d %s' % (404, httplib.responses[404]), 
    14871370                       [('Content-type', 'text/html' + self.charset), 
    14881371                        ('Content-length', str(len(response)))]) 
     
    15151398         
    15161399        response = "Page is not implemented" 
    1517         start_response('%d %s' % (404, httplib.responses[code]), 
     1400        start_response('%d %s' % (404, httplib.responses[404]), 
    15181401                       [('Content-type', 'text/html' + self.charset), 
    15191402                        ('Content-length', str(len(response)))]) 
     
    15331416        """    
    15341417        response = "Page is not implemented" 
    1535         start_response('%d %s' % (404, httplib.responses[code]), 
     1418        start_response('%d %s' % (404, httplib.responses[404]), 
    15361419                       [('Content-type', 'text/html' + self.charset), 
    15371420                        ('Content-length', str(len(response)))]) 
     
    15711454        """ 
    15721455        response = "Page is not implemented" 
    1573         start_response('%d %s' % (404, httplib.responses[code]), 
     1456        start_response('%d %s' % (404, httplib.responses[404]), 
    15741457                       [('Content-type', 'text/html' + self.charset), 
    15751458                        ('Content-length', str(len(response)))]) 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/__init__.py

    r4840 r5786  
    22plugins sub-package 
    33 
    4 NERC Data Grid Project""" 
     4NERC DataGrid Project""" 
    55__author__ = "P J Kershaw" 
    66__date__ = "05/12/08" 
     
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id$' 
     11 
     12class AuthNInterfaceError(Exception): 
     13    """Base class for AbstractAuthNInterface exceptions 
     14     
     15    A standard message is raised set by the msg class variable but the actual 
     16    exception details are logged to the error log.  The use of a standard  
     17    message enables callers to use its content for user error messages. 
     18     
     19    @type msg: basestring 
     20    @cvar msg: standard message to be raised for this exception""" 
     21    userMsg = ("An internal error occurred during login,  Please contact your " 
     22               "system administrator") 
     23    errorMsg = "AuthNInterface error" 
     24     
     25    def __init__(self, *arg, **kw): 
     26        if len(arg) > 0: 
     27            msg = arg[0] 
     28        else: 
     29            msg = self.__class__.errorMsg 
     30             
     31        log.error(msg) 
     32        Exception.__init__(self, msg, **kw) 
     33         
     34         
     35class AuthNInterfaceInvalidCredentials(AuthNInterfaceError): 
     36    """User has provided incorrect username/password.  Raise from logon""" 
     37    userMsg = ("Invalid username / password provided.  Please try again.  If " 
     38               "the problem persists please contact your system " 
     39               "administrator") 
     40    errorMsg = "Invalid username/password provided" 
     41 
     42 
     43class AuthNInterfaceUsername2IdentifierMismatch(AuthNInterfaceError):  
     44    """User has provided a username which doesn't match the identifier from 
     45    the OpenID URL that they provided.  DOESN'T apply to ID Select mode where 
     46    the user has given a generic URL for their OpenID Provider.""" 
     47    userMsg = ("Invalid username for the OpenID entered.  Please ensure you " 
     48               "have the correct OpenID and username and try again.  If the " 
     49               "problem persists contact your system administrator") 
     50    errorMsg = "invalid username / OpenID identifier combination" 
     51     
     52     
     53class AuthNInterfaceRetrieveError(AuthNInterfaceError): 
     54    """Error with retrieval of information to authenticate user e.g. error with 
     55    database look-up.  Raise from logon""" 
     56    errorMsg = ("An error occurred retrieving information to check the login " 
     57                "credentials") 
     58 
     59 
     60class AuthNInterfaceInitError(AuthNInterfaceError): 
     61    """Error with initialisation of AuthNInterface.  Raise from __init__""" 
     62    errorMsg = "AuthNInterface initialisation error" 
     63     
     64     
     65class AuthNInterfaceConfigError(AuthNInterfaceError): 
     66    """Error with Authentication configuration.  Raise from __init__""" 
     67    errorMsg = "AuthNInterface configuration error" 
     68     
     69     
     70class AbstractAuthNInterface(object): 
     71    '''OpenID Provider abstract base class for authentication configuration. 
     72    Derive from this class to define the authentication interface for users 
     73    logging into the OpenID Provider''' 
     74     
     75    def __init__(self, **prop): 
     76        """Make any initial settings 
     77         
     78        Settings are held in a dictionary which can be set from **prop, 
     79        a call to setProperties() or by passing settings in an XML file 
     80        given by propFilePath 
     81         
     82        @type **prop: dict 
     83        @param **prop: set properties via keywords  
     84        @raise AuthNInterfaceInitError: error with initialisation 
     85        @raise AuthNInterfaceConfigError: error with configuration 
     86        @raise AuthNInterfaceError: generic exception not described by the  
     87        other specific exception types. 
     88        """ 
     89     
     90    def logon(self, environ, identityURI, username, password): 
     91        """Interface login method 
     92         
     93        @type environ: dict 
     94        @param environ: standard WSGI environ parameter 
     95         
     96        @type identityURI: basestring 
     97        @param identityURI: user's identity URL e.g.  
     98        'https://joebloggs.somewhere.ac.uk/' 
     99         
     100        @type username: basestring 
     101        @param username: user identifier for authentication 
     102         
     103        @type password: basestring 
     104        @param password: corresponding password for username givens 
     105         
     106        @raise AuthNInterfaceInvalidCredentials: invalid username/password 
     107        @raise AuthNInterfaceUsername2IdentifierMismatch: username doesn't  
     108        match the OpenID URL provided by the user.  (Doesn't apply to ID Select 
     109        type requests). 
     110        @raise AuthNInterfaceRetrieveError: error with retrieval of information 
     111        to authenticate user e.g. error with database look-up. 
     112        @raise AuthNInterfaceError: generic exception not described by the  
     113        other specific exception types. 
     114        """ 
     115        raise NotImplementedError() 
     116     
     117    def username2UserIdentifiers(self, environ, username): 
     118        """Map the login username to an identifier which will become the 
     119        unique path suffix to the user's OpenID identifier.  The  
     120        OpenIDProviderMiddleware takes self.urls['id_url']/ 
     121        self.urls['id_yadis'] and adds it to this identifier: 
     122         
     123            identifier = self._authN.username2UserIdentifiers(environ, 
     124                                                              username) 
     125            identityURL = self.createIdentityURI(self.urls['url_id'], 
     126                                                 identifier) 
     127         
     128        @type environ: dict 
     129        @param environ: standard WSGI environ parameter 
     130 
     131        @type username: basestring 
     132        @param username: user identifier 
     133         
     134        @rtype: tuple 
     135        @return: one or more identifiers to be used to make OpenID user  
     136        identity URL(s). 
     137         
     138        @raise AuthNInterfaceConfigError: problem with the configuration  
     139        @raise AuthNInterfaceRetrieveError: error with retrieval of information 
     140        to identifier e.g. error with database look-up. 
     141        @raise AuthNInterfaceError: generic exception not described by the  
     142        other specific exception types. 
     143        """ 
     144        raise NotImplementedError() 
     145 
     146    def logout(self, authNInterface): 
     147        """Stub to enable custom actions for logout. 
     148         
     149        @type authNInterface: AbstractAuthNInterface derived type 
     150        @param authNInterface: authentication interface object.  See 
     151        AbstractAuthNInterface class for details 
     152        """ 
     153        raise NotImplementedError() 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/basic.py

    r5452 r5786  
    1717log = logging.getLogger(__name__) 
    1818 
    19 from ndg.security.server.wsgi.openid.provider import AbstractAuthNInterface, \ 
    20     AuthNInterfaceInvalidCredentials, AuthNInterfaceRetrieveError, \ 
    21     AuthNInterfaceConfigError, AuthNInterfaceUsername2IdentifierMismatch 
     19from ndg.security.server.wsgi.openid.provider.authninterface import \ 
     20    AbstractAuthNInterface, AuthNInterfaceInvalidCredentials, \ 
     21    AuthNInterfaceRetrieveError, AuthNInterfaceConfigError, \ 
     22    AuthNInterfaceUsername2IdentifierMismatch 
    2223  
    2324     
     
    2829    entry.  This class is for testing only.  NOT for production use''' 
    2930     
    30     propertyKeyNames = ('userCreds', 'username2UserIdentifiers') 
     31    IDENTITY_URI_TMPL_KEYNAME = 'identityUriTemplate' 
     32    USERCREDS_PROPERTY_KEYNAME = 'userCreds' 
     33    USERCREDS_KEYNAMES = ('password', 'identifiers') 
     34     
     35    propertyKeyNames = ( 
     36        USERCREDS_PROPERTY_KEYNAME 
     37    ) 
     38     
     39    getUserIdentifier = staticmethod(lambda identityURI:  
     40                                     identityURI.rsplit('/')[-1]) 
    3141     
    3242    def __init__(self, **prop): 
     
    4252        """ 
    4353        # Test/Admin username/password set from ini/kw args 
    44         userCredsField = prop.get('userCreds') 
     54        self._identityUriTemplate = prop.get( 
     55                                BasicAuthNInterface.IDENTITY_URI_TMPL_KEYNAME) 
     56        userCredsField = prop.get( 
     57                                BasicAuthNInterface.USERCREDS_PROPERTY_KEYNAME) 
    4558        if not userCredsField: 
    46             raise AuthNInterfaceConfigError('No "userCreds" config option ' 
    47                                             "found") 
     59            raise AuthNInterfaceConfigError('No "%s" config option found' % 
     60                                BasicAuthNInterface.USERCREDS_PROPERTY_KEYNAME) 
     61 
    4862        self._userCreds = {} 
    4963        for userEntry in userCredsField.split():  
     
    5569             
    5670            # Convert into a dictionary indexed by username 
    57             userCredsKeys = ('password', 'identifiers') 
     71            userCredsKeys = BasicAuthNInterface.USERCREDS_KEYNAMES 
    5872            self._userCreds[userCreds[0]] = dict(zip(userCredsKeys,  
    5973                                                     userCreds[1:]))   
    6074     
    61     def logon(self, environ, userIdentifier, username, password): 
     75    def logon(self, environ, identityURI, username, password): 
    6276        """Interface login method 
    6377         
     
    6579        @param environ: standard WSGI environ parameter 
    6680 
     81        @type identityURI: basestring 
     82        @param identityURI: user's identity URL e.g.  
     83        'https://joebloggs.somewhere.ac.uk/' 
     84 
    6785        @type username: basestring 
    68         @param username: user identifier 
     86        @param username: username 
    6987         
    7088        @type password: basestring 
     
    7896            raise AuthNInterfaceInvalidCredentials() 
    7997         
    80         if userIdentifier is not None and \ 
    81            userIdentifier not in self._userCreds[username]['identifiers']: 
    82             raise AuthNInterfaceUsername2IdentifierMismatch() 
     98        # Assume identifier is at the end of the URI 
     99        if identityURI is not None: 
     100            userIdentifier = BasicAuthNInterface.getUserIdentifier(identityURI) 
     101         
     102            if userIdentifier not in self._userCreds[username]['identifiers']: 
     103                raise AuthNInterfaceUsername2IdentifierMismatch() 
    83104 
    84105    def logout(self): 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/authninterface/sessionmanager.py

    r5254 r5786  
    1818from sqlalchemy import create_engine 
    1919 
    20 from ndg.security.server.wsgi.openid.provider import AbstractAuthNInterface, \ 
    21     AuthNInterfaceConfigError, AuthNInterfaceInvalidCredentials, \ 
    22     AuthNInterfaceUsername2IdentifierMismatch 
     20from ndg.security.server.wsgi.openid.provider.authninterface import \ 
     21    AbstractAuthNInterface, AuthNInterfaceConfigError, \ 
     22    AuthNInterfaceInvalidCredentials, AuthNInterfaceUsername2IdentifierMismatch 
    2323     
    2424from ndg.security.server.wsgi.utils.sessionmanagerclient import \ 
     
    7070        @type environ: dict 
    7171        @param environ: standard WSGI environ parameter 
     72 
     73        @type userIdentifier: basestring 
     74        @param userIdentifier: portion of user's identity URL which uniquely  
     75        identifies them e.g. 'joebloggs' in the identity URL  
     76        'https://joebloggs.somewhere.ac.uk/' 
    7277         
    7378        @type username: basestring 
    74         @param username: user identifier 
     79        @param username: username 
    7580         
    7681        @type password: basestring 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/csv.py

    r5782 r5786  
    2929    The expected file format is: 
    3030     
    31     <userID>, <role1>, <role2>, ... <roleN> 
     31    <OpenID>, <attr 1>, <attr 2>, ... <attr N> 
    3232    """ 
    3333    __slots__ = ( 
     
    3636        "attributeMap", 
    3737    ) 
    38     USERIDENTIFIER_SESSIONKEY = \ 
    39         OpenIDProviderMiddleware.USERIDENTIFIER_SESSIONKEY 
     38    IDENTITY_URI_SESSION_KEYNAME = \ 
     39                        OpenIDProviderMiddleware.IDENTITY_URI_SESSION_KEYNAME 
    4040     
    4141    def __init__(self, **properties): 
     
    140140        log.debug('CSVFileAXInterface.__call__  ...') 
    141141         
    142         userIdentifier = authnCtx.get( 
    143                                 CSVFileAXInterface.USERIDENTIFIER_SESSIONKEY) 
    144         if userIdentifier is None: 
     142        identityURI = authnCtx.get( 
     143                                CSVFileAXInterface.IDENTITY_URI_SESSION_KEYNAME) 
     144        if identityURI is None: 
    145145            raise AXInterfaceConfigError("No OpenID user identifier set in " 
    146146                                         "session context") 
    147147         
    148148        requiredAttributeURIs = ax_req.getRequiredAttrs() 
     149             
     150        userAttributeMap = self.attributeMap.get(identityURI) 
     151        if userAttributeMap is None: 
     152            raise AXInterfaceConfigError("No attribute entry for user [%s] " % 
     153                                         identityURI) 
     154                                      
    149155        missingAttributeURIs = [ 
    150156            requiredAttributeURI  
     
    158164                                       ', '.join(missingAttributeURIs)) 
    159165         
    160         userAttributeMap = self.attributeMap.get 
    161166        # Add the required attributes 
    162167        for requiredAttributeURI in requiredAttributeURIs: 
    163168            log.info("Adding required AX parameter %s=%s ...",  
    164169                     requiredAttributeURI, 
    165                      self.attributeMap[authnCtx][requiredAttributeURI]) 
     170                     userAttributeMap[requiredAttributeURI]) 
    166171             
    167172            ax_resp.addValue(requiredAttributeURI, 
    168                              self.attributeMap[authnCtx][requiredAttributeURI]) 
     173                             userAttributeMap[requiredAttributeURI]) 
    169174             
    170175        # Append requested attribute if available 
     
    172177            if requestedAttributeURI in self.attributeNames: 
    173178                log.info("Adding requested AX parameter %s=%s ...",  
    174                           requiredAttributeURI, 
    175                           self.attributeMap[authnCtx][requiredAttributeURI]) 
     179                         requestedAttributeURI, 
     180                         userAttributeMap[requestedAttributeURI]) 
    176181                 
    177                 ax_resp.addValue(requiredAttributeURI, 
    178                              self.attributeMap[authnCtx][requiredAttributeURI]) 
     182                ax_resp.addValue(requestedAttributeURI, 
     183                                 userAttributeMap[requestedAttributeURI]) 
    179184            else: 
    180185                log.info("Skipping Relying Party requested AX parameter %s: " 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/relyingparty/__init__.py

    r5770 r5786  
    179179                      environ['REMOTE_USER']) 
    180180            return self._app(environ, start_response) 
    181          
     181 
    182182        session = environ.get(self.sessionKey) 
    183183        if session is None: 
     
    188188        # Check for return to address in URI query args set by  
    189189        # AuthnRedirectMiddleware in application code stack 
    190         if environ['REQUEST_METHOD'] == "GET": 
    191             params = dict(parse_querystring(environ)) 
    192         else: 
    193             params = {} 
    194          
    195         quotedReferrer=params.get(AuthnRedirectMiddleware.RETURN2URI_ARGNAME,'') 
     190        params = dict(parse_querystring(environ)) 
     191        quotedReferrer = params.get(AuthnRedirectMiddleware.RETURN2URI_ARGNAME, 
     192                                    '') 
     193         
    196194        referrer = urllib.unquote(quotedReferrer) 
    197195        referrerPathInfo = urlsplit(referrer)[2] 
     
    218216                                                 (filteredQuery,) + \ 
    219217                                                 splitURI[4:]) 
    220          
     218                             
    221219        # See _start_response doc for an explanation... 
    222220        if environ['PATH_INFO'] == self._authKitVerifyPath:  
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/relyingparty/validation.py

    r5779 r5786  
    7979    """Parser for IdP and Attribute Provider config 
    8080    """ 
    81      
    8281    def getValidators(self, source):   
    8382        """Retrieve IdP Validator objects from XML file 
     
    288287        by maintaining its own error storage managed by verify_callback. 
    289288        ''' 
    290          
    291289        x509Cert = x509StoreCtx.get_current_cert() 
    292290        dnTxt = x509Cert.get_subject().as_text() 
     
    298296            raise IdPInvalidException("Peer certificate CN=%s is not in list " 
    299297                                      "of valid OpenID Providers" % commonName) 
     298 
    300299 
    301300class IdPValidationDriver(object): 
     
    443442 
    444443        for validatorConfig in validatorConfigs: 
    445             trace = None 
    446444            try: 
    447445                validator = instantiateClass(validatorConfig.className, 
     
    456454            except Exception, e:  
    457455                raise ConfigException("Validator class %r initialisation " 
    458                                       "failed with %s exception: %s\n\n%s" % 
     456                                      "failed with %s exception: %s" % 
    459457                                      (validatorConfig.className,  
    460458                                       e.__class__.__name__, 
    461                                        e, 
    462459                                       traceback.format_exc())) 
    463             finally: 
    464                 del trace 
    465460                 
    466461        return validators 
     
    493488                          validator.__class__.__name__,  
    494489                          e.__class__.__name__, 
    495                           e)        
     490                          traceback.format_exc())        
    496491                return 0 
    497492             
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securedapp.ini

    r5770 r5786  
    5656# Set redirect for OpenID Relying Party in the Security Services app instance 
    5757#authN.redirectURI = http://localhost:7443/verify 
     58# Test with an SSL endpoint 
    5859authN.redirectURI = https://localhost/verify 
    5960 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r5782 r5786  
    6060                   SSLCientAuthKitFilter 
    6161                   SSLClientAuthenticationFilter 
    62                    SSLCientAuthenticationRedirectFilter 
     62                   SSLCientAuthnRedirectResponseFilter 
    6363                   OpenIDRelyingPartyFilter 
    6464                   OpenIDProviderApp 
     
    184184 
    185185 
    186 [filter:SSLCientAuthenticationRedirectFilter] 
     186[filter:SSLCientAuthnRedirectResponseFilter] 
    187187# Redirect to original requested URI following SSL Client Authentication.  This 
    188188# filter must be placed AFTER the AuthKit cookie setting middleware.  In this 
     
    203203openid.provider.path.loginsubmit=/OpenID/Provider/loginsubmit 
    204204 
    205 # Yadis based discovery only - the 'id' path is configured to return 404 not 
    206 # found - see ndg.security.server.wsgi.openid.provider.renderinginterface. 
    207 # buffet.BuffetRendering class 
     205# Yadis based discovery only - the 'id' path is configured may be set to page 
     206# with <link rel="openid.server" href="..."> and Yadis  
     207# <meta http-equiv="x-xrds-location" content="..."> links if required but in  
     208# this implementation it set to return 404 not found - see  
     209# ndg.security.server.wsgi.openid.provider.renderinginterface.buffet.BuffetRendering  
     210# class 
    208211openid.provider.path.id=/OpenID/Provider/id/${userIdentifier} 
    209212openid.provider.path.yadis=%(openIDProviderIDBase)s/${userIdentifier} 
     
    220223openid.provider.session_middleware=%(beakerSessionKeyName)s 
    221224openid.provider.base_url=%(baseURI)s 
     225 
     226# Enable login to construct an identity URI if IDSelect mode was chosen and 
     227# no identity URI was passed from the Relying Party.  This value should 
     228# match openid.provider.path.id and/or openid.provider.path.yadis - see above 
     229identityUriTemplate=%(baseURI)s%(openIDProviderIDBase)s/${userIdentifier} 
     230 
    222231openid.provider.trace=False 
    223232openid.provider.consumer_store_dirpath=%(here)s/openidprovider 
Note: See TracChangeset for help on using the changeset viewer.