Changeset 5782


Ignore:
Timestamp:
30/09/09 16:36:04 (10 years ago)
Author:
pjkersha
Message:

Re-testing OpenID Attribute Exchange interface - added CSV file based test AX Response class.

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

Legend:

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

    r5774 r5782  
    396396                     
    397397                # Reset cookie removing user data 
    398                 environ[ 
    399                     SessionHandlerMiddleware.AUTH_TKT_SET_USER_ENVIRON_KEYNAME]( 
    400                         session[SessionHandlerMiddleware.ID_SESSION_KEYNAME]) 
     398                setUser = environ[ 
     399                    SessionHandlerMiddleware.AUTH_TKT_SET_USER_ENVIRON_KEYNAME] 
     400                setUser( 
     401                    session[SessionHandlerMiddleware.USERNAME_SESSION_KEYNAME]) 
    401402 
    402403            _start_response = start_response 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/__init__.py

    r5453 r5782  
    1414import sys 
    1515import os 
     16import traceback 
    1617import logging 
    1718log = logging.getLogger(__name__) 
     
    254255    userIdentifierPat = '([^/]*)' 
    255256     
     257    USERNAME_SESSIONKEY = 'username' 
     258    USERIDENTIFIER_SESSIONKEY = 'userIdentifier' 
     259    OPENID_SESSIONKEY = 'openID' 
     260    APPROVED_FLAG_SESSIONKEY = 'approved' 
     261    LAST_CHECKID_REQUEST_SESSIONKEY = 'lastCheckIDRequest' 
     262     
    256263    def __init__(self, app, app_conf=None, prefix='openid.provider.', **kw): 
    257264        ''' 
     
    399406            self.axResponse = None 
    400407        else: 
     408            axResponseModuleFilePath = opt.pop('axResponse_moduleFilePath', 
     409                                               None) 
    401410            axResponseProperties = dict( 
    402411                [(k.replace('axResponse_', ''), v)  
     
    405414            try: 
    406415                self.axResponse = instantiateClass( 
    407                                         axResponseClassName,  
    408                                         None,  
    409                                         objectType=AXInterface,  
    410                                         classProperties=axResponseProperties) 
     416                                    axResponseClassName,  
     417                                    None,  
     418                                    moduleFilePath=axResponseModuleFilePath, 
     419                                    objectType=AXInterface,  
     420                                    classProperties=axResponseProperties) 
    411421            except Exception, e: 
    412422                log.error("Error instantiating AX interface: %s" % e) 
     
    419429                            os.path.expandvars(opt['consumer_store_dirpath'])) 
    420430        self.oidserver = server.Server(store, self.urls['url_openidserver']) 
    421  
    422431         
    423432    @classmethod 
     
    476485            raise TypeError("Invalid input option(s) set: %s" %  
    477486                            (", ".join(badOptNames))) 
    478              
    479              
     487                        
    480488    def _matchIdentityURI(self): 
    481489        idPaths = (self.paths['path_id'], self.paths['path_yadis']) 
     
    489497             
    490498        return None 
    491  
    492499 
    493500    def _isAnIdentityURI(self): 
     
    517524        return self._matchIdentityURI() is not None 
    518525 
    519  
    520526    def _parseIdentityURI(self): 
    521527        '''Split path into identity and path fragment components 
     
    525531        user identifier respectively. 
    526532        ''' 
    527         return OpenIDProviderMiddleware.parseIdentityURI(self.path) 
    528      
     533        return OpenIDProviderMiddleware.parseIdentityURI(self.path)    
    529534 
    530535    @classmethod 
     
    710715        """ 
    711716         
    712         oidRequest = self.session.get('lastCheckIDRequest') 
     717        oidRequest = self.session.get( 
     718                    OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
    713719        if oidRequest is None: 
    714720            log.error("Suspected do_allow called from stale request") 
     
    737743            trust_root = oidRequest.trust_root 
    738744            if self.query.get('remember', 'No') == 'Yes': 
    739                 self.session['approved'] = {trust_root: 'always'} 
     745                self.session[ 
     746                    OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY] = { 
     747                        trust_root: 'always' 
     748                    } 
    740749                self.session.save() 
    741750              
     
    816825            if 'username' in self.query: 
    817826                # login 
    818                 if 'username' in self.session: 
     827                if OpenIDProviderMiddleware.USERNAME_SESSIONKEY in self.session: 
    819828                    log.error("Attempting login for user %s: user %s is " 
    820                               "already logged in", self.session['username'], 
    821                               self.session['username']) 
     829                              "already logged in",  
     830                    self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY], 
     831                    self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
     832                     
    822833                    return self._redirect(start_response,self.query['fail_to']) 
    823834                 
    824                 oidRequest = self.session.get('lastCheckIDRequest') 
     835                oidRequest = self.session.get( 
     836                    OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
    825837                if oidRequest is None: 
    826838                    log.error("Getting OpenID request for login - No request " 
     
    865877                    return response 
    866878                        
    867                 self.session['username'] = self.query['username'] 
    868                 self.session['approved'] = {} 
     879                self.session[ 
     880                    OpenIDProviderMiddleware.USERNAME_SESSIONKEY 
     881                ] = self.query['username'] 
     882                 
     883                self.session[ 
     884                    OpenIDProviderMiddleware.USERIDENTIFIER_SESSIONKEY 
     885                ] = userIdentifier 
     886                 
     887                self.session[ 
     888                    OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY] = {} 
     889                     
    869890                self.session.save() 
    870891                 
    871                 log.info("user [%s] logged in", self.session['username']) 
     892                log.info("user [%s] logged in",  
     893                    self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
    872894            else: 
    873895                # logout 
    874                 if 'username' not in self.session: 
     896                if OpenIDProviderMiddleware.USERNAME_SESSIONKEY not in \ 
     897                   self.session: 
    875898                    log.error("No user is logged in") 
    876                     return self._redirect(start_response, 
     899                    return self._redirect(start_response,  
    877900                                          self.query['fail_to']) 
    878901                 
    879                 log.info("user [%s] logging out ...",self.session['username']) 
    880  
    881                 del self.session['username'] 
    882                 self.session.pop('approved', None) 
     902                log.info("user [%s] logging out ...", 
     903                    self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY]) 
     904 
     905                del self.session[OpenIDProviderMiddleware.USERNAME_SESSIONKEY] 
     906                self.session.pop( 
     907                            OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY,  
     908                            None) 
    883909                self.session.save() 
    884910                 
     
    886912                    self._authN.logout() 
    887913                     
    888                 except Exception, e: 
     914                except Exception: 
    889915                    log.error("Unexpected exception raised during " 
    890                               "logout: %s" % e) 
     916                              "logout: %s" % traceback.format_exc()) 
    891917                    msg = ("An internal error occured during logout.  If the " 
    892918                           "problem persists contact your system " 
     
    896922                                                      msg)  
    897923                    return response 
    898                  
    899924                 
    900925            return self._redirect(start_response, self.query['success_to']) 
     
    942967        """ 
    943968 
    944         oidRequest = self.session.get('lastCheckIDRequest') 
     969        oidRequest = self.session.get( 
     970                    OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY) 
    945971        if oidRequest is None: 
    946972            log.error("No OpenID request set in session") 
     
    951977                                          code=400) 
    952978         
    953         approvedRoots = self.session.get('approved', {}) 
     979        approvedRoots = self.session.get( 
     980                            OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY,  
     981                            {}) 
    954982         
    955983        if oidRequest.trust_root in approvedRoots and \ 
     
    10061034        @return: True/False is user authorized 
    10071035        ''' 
    1008         username = self.session.get('username') 
     1036        username = self.session.get(OpenIDProviderMiddleware.USERNAME_SESSIONKEY) 
    10091037        if username is None: 
    10101038            return False 
     
    10461074        @return: True - trust has already been approved, False - trust root is 
    10471075        not approved''' 
    1048         approvedRoots = self.session.get('approved', {}) 
     1076        approvedRoots = self.session.get(OpenIDProviderMiddleware.APPROVED_FLAG_SESSIONKEY, {}) 
    10491077        return approvedRoots.get(trust_root) is not None 
    10501078 
     
    10661094        # Callout to external callable sets additional user attributes to be 
    10671095        # returned in response to Relying Party         
    1068         sreg_data = self.sregResponseHandler(self.session.get('username')) 
     1096        sreg_data = self.sregResponseHandler(self.session.get(OpenIDProviderMiddleware.USERNAME_SESSIONKEY)) 
    10691097        sreg_resp = sreg.SRegResponse.extractResponse(sreg_req, sreg_data) 
    10701098        oidResponse.addExtension(sreg_resp) 
     
    11061134        # possibly via FetchRequest.getRequiredAttrs() 
    11071135        try: 
    1108             self.axResponse(ax_req, ax_resp, self._authN) 
     1136            self.axResponse(ax_req, ax_resp, self._authN, self.session) 
    11091137         
    11101138        except OpenIDProviderMissingRequiredAXAttrs, e: 
     
    11191147        except Exception, e: 
    11201148            log.error("%s exception raised setting requested Attribute " 
    1121                       "Exchange values: %s", e.__class__.__name__, e) 
     1149                      "Exchange values: %s",  
     1150                      e.__class__.__name__,  
     1151                      traceback.format_exc()) 
    11221152            raise 
    11231153         
     
    11591189         
    11601190        # Save request 
    1161         self.session['lastCheckIDRequest'] = oidRequest 
     1191        self.session[ 
     1192            OpenIDProviderMiddleware.LAST_CHECKID_REQUEST_SESSIONKEY 
     1193        ] = oidRequest 
     1194         
    11621195        self.session.save() 
    11631196         
     
    12091242        elif oidRequest.immediate: 
    12101243            oidResponse = oidRequest.answer(False) 
    1211             return self._displayResponse(oidResponse) 
    1212          
     1244            return self._displayResponse(oidResponse)         
    12131245        else: 
    12141246            # User is not logged in 
     
    12211253            return response 
    12221254 
    1223  
    12241255    def _displayResponse(self, oidResponse): 
    12251256        """Serialize an OpenID Response object, set headers and return WSGI 
     
    12341265        @rtype: basestring 
    12351266        @return: WSGI response''' 
    1236         """ 
    1237          
     1267        """       
    12381268        try: 
    12391269            webresponse = self.oidserver.encodeResponse(oidResponse) 
     
    12661296        return response 
    12671297 
    1268  
    12691298    def _redirect(self, start_response, url): 
    12701299        """Do a HTTP 302 redirect 
     
    12811310                        ('Location', url)]) 
    12821311        return [] 
    1283     
     1312 
    12841313     
    12851314class RenderingInterfaceError(Exception): 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/__init__.py

    r5285 r5782  
    3939        raise NotImplementedError() 
    4040     
    41     def __call__(self, ax_req, ax_resp, authNInterface): 
     41    def __call__(self, ax_req, ax_resp, authnInterface, authnCtx): 
    4242        """Add the attributes to the ax_resp object requested in the ax_req 
    4343        object.  If it is not possible to return them, raise  
     
    5151        @param ax_resp: attribute exchange response object.  This method should 
    5252        update the settings in this object.  Use addValue and setValues methods 
    53         @type authNInterfaceCtx: AbstractAuthNInterface 
    54         @param authNInterfaceCtx: custom authentication interface set 
     53        @type authnInterface: AbstractAuthNInterface 
     54        @param authnInterface: custom authentication interface set 
    5555        at login.  See  
    5656        ndg.security.server.openid.provider.AbstractAuthNInterface for more  
    5757        information 
     58        @type authnCtx: dict like 
     59        @param authnCtx: session containing authentication context information 
     60        such as username and OpenID user identifier URI snippet 
    5861        """ 
    5962        raise NotImplementedError() 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/sessionmanager.py

    r5285 r5782  
    5252            setattr(self, name, val) 
    5353         
    54     def __call__(self, ax_req, ax_resp, authNInterface): 
     54    def __call__(self, ax_req, ax_resp, authnInterface, authnCtx): 
    5555        """Add the attributes to the ax_resp object requested in the ax_req 
    5656        object.  If it is not possible to return them, raise  
     
    6464        @param ax_resp: attribute exchange response object.  This method should 
    6565        update the settings in this object.  Use addValue and setValues methods 
    66         @type authNInterface: AbstractAuthNInterface 
    67         @param authNInterface: custom authentication context information set 
     66        @type authnInterface: AbstractAuthNInterface 
     67        @param authnInterface: custom authentication context information set 
    6868        at login.  See  
    6969        ndg.security.server.openid.provider.AbstractAuthNInterface for more 
    7070        information 
     71        @type authnCtx: dict like 
     72        @param authnCtx: session containing authentication context information 
     73        such as username and OpenID user identifier URI snippet 
    7174        """ 
    7275        reqAttrURIs = ax_req.getRequiredAttrs() 
     
    8083             
    8184        if self.sessionIdTypeURI in reqAttrURIs: 
    82             if not isinstance(authNInterface, AbstractAuthNInterface): 
     85            if not isinstance(authnInterface, AbstractAuthNInterface): 
    8386                raise AXInterfaceConfigError("Expecting " 
    8487                                             "AbstractAuthNInterface derived " 
    85                                              "type for authNInterface arg; " 
     88                                             "type for authnInterface arg; " 
    8689                                             "got: %s" %  
    87                                             authNInterface.__class__.__name__) 
     90                                            authnInterface.__class__.__name__) 
    8891                 
    8992            # Check for uninitialised session 
    90             if not authNInterface.sessionId: 
     93            if not authnInterface.sessionId: 
    9194                raise MissingRequiredAttrs("The Session Manager session ID " 
    9295                                           "is not set to a valid session") 
     
    9699                 
    97100            log.debug("Adding AX parameter %s=%s ...", self.sessionIdTypeURI, 
    98                                                     authNInterface.sessionId) 
     101                                                    authnInterface.sessionId) 
    99102             
    100             ax_resp.addValue(self.sessionIdTypeURI, authNInterface.sessionId) 
     103            ax_resp.addValue(self.sessionIdTypeURI, authnInterface.sessionId) 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/buffet/layout/ndg2.css

    r5315 r5782  
    8989#contentsRight  {border-left: 1px solid #3c78b5; margin-left:250px;} 
    9090 
    91 .error {display:block;text-align:center;font-size:150%;background-color:red; padding:10px;} 
     91.error {display:block;text-align:center;padding:10px;} 
    9292 
    9393/* The following is the css associated with pretty printing xml */ 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/openidprovider/layout/ndg2.css

    r5447 r5782  
    8989#contentsRight  {border-left: 1px solid #3c78b5; margin-left:250px;} 
    9090 
    91 .error {display:block;text-align:center;font-size:150%;background-color:red; padding:10px;} 
     91.error {display:block;padding:10px;} 
    9292 
    9393/* The following is the css associated with pretty printing xml */ 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r5774 r5782  
    172172#authkit.openid.urltouser =  
    173173 
     174# Attribute Exchange - all are optional unless the relevant ax.required.<name>  
     175# is set to True.  The alias defers to the parameter name given unless explicity 
     176# specified - see commented out entry for firstName below.  The number of 
     177# attributes for each attribute name defaults to 1 unless otherwise set 
     178authkit.openid.ax.typeuri.firstName=http://openid.net/schema/namePerson/first 
     179#authkit.openid.ax.alias.firstName=first_name 
     180#authkit.openid.ax.count.firstName=1 
     181authkit.openid.ax.typeuri.lastName=http://openid.net/schema/namePerson/last 
     182authkit.openid.ax.typeuri.emailAddress=http://openid.net/schema/contact/internet/email 
     183#authkit.openid.ax.required.emailAddress=True 
     184 
     185 
     186[filter:SSLCientAuthenticationRedirectFilter] 
    174187# Redirect to original requested URI following SSL Client Authentication.  This 
    175188# filter must be placed AFTER the AuthKit cookie setting middleware.  In this 
     
    177190# OpenID Relying Party filter is removed, a separate AuthKit middleware entry 
    178191# would need to be made so that this redirect filter can still function 
    179 [filter:SSLCientAuthenticationRedirectFilter] 
    180192paste.filter_app_factory = ndg.security.server.wsgi.authn:AuthKitRedirectResponseMiddleware 
    181193prefix = ssl. 
     
    245257#openid.provider.usercreds=pjk:test 
    246258 
     259# Attribute Exchange interface 
     260openid.provider.axResponse.class=ndg.security.server.wsgi.openid.provider.axinterface.csv.CSVFileAXInterface 
     261openid.provider.axResponse.csvFilePath=%(here)s/openidprovider/attributeexchange.csv 
     262openid.provider.axResponse.attributeNames=http://openid.net/schema/namePerson/first 
     263    http://openid.net/schema/namePerson/last 
     264    http://openid.net/schema/contact/internet/email 
     265 
    247266#______________________________________________________________________________ 
    248267# Attribute Authority WSGI settings 
Note: See TracChangeset for help on using the changeset viewer.