Changeset 5080 for TI12-security


Ignore:
Timestamp:
09/03/09 10:03:50 (11 years ago)
Author:
pjkersha
Message:

ndg.security.test.integration.openid: working combined OpenID Provider and Relying Party in same WSGI stack

  • Removed call to paste.request.parse_formvars in ndg.security.server.wsgi.openid.relyingparty.OpenIDRelyingPartyMiddleware.__call__: for Paste 1.7.1 this seems to gobbled up environwsgi.input? such that a 2nd call to it yields nothing!
  • TODO: add login to OpenID Relying Party template so that for a given site, home users can skip OpenID URI entry and login directly.
Location:
TI12-security/trunk/python
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/__init__.py

    r5067 r5080  
    2020_debugLevel = log.getEffectiveLevel() <= logging.DEBUG 
    2121 
     22import re 
     23from string import Template 
     24 
    2225import paste.request 
    2326from paste.util.import_string import eval_import 
     
    138141        """Map the login username to an identifier which will become the 
    139142        unique path suffix to the user's OpenID identifier.  The  
    140         OpenIDProviderMiddleware takes self.urls['id_url'] and adds it to this 
    141         identifier: 
     143        OpenIDProviderMiddleware takes self.urls['id_url']/ 
     144        self.urls['id_yadis'] and adds it to this identifier: 
    142145         
    143146            identifier = self._authN.username2UserIdentifiers(environ,username) 
    144             identityURL = self.urls['url_id'] + '/' + identifier 
     147            identityURL = self.createIdentityURI(self.urls['url_id'], 
     148                                                 identifier) 
    145149         
    146150        @type environ: dict 
     
    214218        path_login='/login', 
    215219        path_loginsubmit='/loginsubmit', 
    216         path_id='/id', 
    217         path_yadis='/yadis', 
     220        path_id='/id/${userIdentifier}', 
     221        path_yadis='/yadis/${userIdentifier}', 
    218222        path_serveryadis='/serveryadis', 
    219223        path_allow='/allow', 
    220224        path_decide='/decide', 
    221225        path_mainpage='/', 
    222         session_middleware='beaker.session',  
     226        session_middleware='beaker.session', 
    223227        base_url='', 
    224228        consumer_store_dirpath='./', 
     
    230234        authNInterface=AbstractAuthNInterface) 
    231235     
    232     defPaths=dict([(k,v) for k,v in defOpt.items() if k.startswith('path_')]) 
    233       
     236    defPaths = dict([(k, v) for k, v in defOpt.items() if k.startswith('path_')]) 
     237     
     238    userIdentifierPat = '([^/]*)' 
     239     
    234240    def __init__(self, app, app_conf=None, prefix='openid.provider.', **kw): 
    235241        ''' 
     
    293299                                                    "class %r is not a %r " 
    294300                                                    "derived type" %  
    295                                                     (authNInterfaceClass,  
     301                                                    (authNInterfaceClass, 
    296302                                                     AbstractAuthNInterface)) 
    297303        else: 
     
    300306        # Extract Authentication interface specific properties 
    301307        authNInterfaceProperties = dict([(k.replace('authN_', ''), v)  
    302                                          for k,v in opt.items()  
     308                                         for k, v in opt.items()  
    303309                                         if k.startswith('authN_')])  
    304310          
     
    312318        self.paths = dict([(k, opt[k].rstrip('/')) 
    313319                           for k in OpenIDProviderMiddleware.defPaths]) 
    314          
     320                         
    315321        if not opt['base_url']: 
    316322            raise TypeError("base_url is not set") 
     
    319325 
    320326        # Full Paths 
    321         self.urls = dict([(k.replace('path_', 'url_'), self.base_url+v) 
    322                           for k,v in self.paths.items()]) 
     327        self.urls = dict([(k.replace('path_', 'url_'), self.base_url + v) 
     328                          for k, v in self.paths.items()]) 
    323329 
    324330        self.method = dict([(v, k.replace('path_', 'do_')) 
    325                             for k,v in self.paths.items()]) 
     331                            for k, v in self.paths.items()]) 
    326332 
    327333        self.session_middleware = opt['session_middleware'] 
     
    330336            self.charset = '' 
    331337        else: 
    332             self.charset = '; charset='+charset 
     338            self.charset = '; charset=' + charset 
    333339         
    334340        # If True and debug log level is set display content of response 
     
    344350                                                "class %r is not a %r " 
    345351                                                "derived type" % \ 
    346                                                 (renderingClass,  
     352                                                (renderingClass, 
    347353                                                 RenderingInterface)) 
    348354         
    349355        # Extract rendering interface specific properties 
    350356        renderingProperties = dict([(k.replace('rendering_', ''), v)  
    351                                          for k,v in opt.items()  
     357                                         for k, v in opt.items()  
    352358                                         if k.startswith('rendering_')])     
    353359 
     
    367373            raise OpenIDProviderMiddlewareError("Expecting callable for " 
    368374                                                "sregResponseHandler keyword, " 
    369                                                 "got %r" % 
     375                                                "got %r" %  
    370376                                                self.sregResponseHandler) 
    371377             
     
    376382            raise OpenIDProviderMiddlewareError("Expecting callable for " 
    377383                                                "axResponseHandler keyword, " 
    378                                                 "got %r" % 
     384                                                "got %r" %  
    379385                                                self.axResponseHandler) 
    380386         
     
    441447            raise TypeError("Invalid input option(s) set: %s" %  
    442448                            (", ".join(badOptNames))) 
    443  
    444  
    445     def _isAnIdentityURI(self, uri=None): 
     449             
     450             
     451    def _matchIdentityURI(self): 
     452        idPaths = (self.paths['path_id'], self.paths['path_yadis']) 
     453        idPathMatches = [Template(path).substitute( 
     454                    userIdentifier=OpenIDProviderMiddleware.userIdentifierPat) 
     455                    for path in idPaths] 
     456         
     457        for idPathMatch, idPath in zip(idPathMatches, idPaths): 
     458            if re.search(idPathMatch, self.path): 
     459                return idPath 
     460             
     461        return None 
     462 
     463 
     464    def _isAnIdentityURI(self): 
    446465        """Check input URI is an identity URI.  Use to determine whether a 
    447466        RP discovery request has been made based on a provided user OpenID.  
    448467        i.e. do_id / do_yadis should be invoked - see __call__ method for  
    449         details.  It assumes that identity the component of the OpenID URI is 
    450         the last part of the path: 
    451          
    452         <http/https>://<domainname>/<path>/<user identifier> 
     468        details.  It takes the identity portion of the URI from the config 
     469        path_id / path_yadis settings - which ever matches e.g. 
     470         
     471        <http/https>://<domainname>/<path>/${userIdentifier} 
    453472         
    454473        e.g. 
     
    461480        https://johnsmith.badc.rl.ac.uk 
    462481         
    463         @type uri: basestring 
    464         @param uri: URI to be tested 
     482        but note also see _matchIdentityURI method 
     483         
    465484        @rtype: bool 
    466485        @return: return True if the given URI is an identity URI, otherwise 
    467486        False 
    468         """ 
    469         if uri is None: 
    470             uri = self.path 
    471              
    472         return uri.rsplit('/', 1)[0] in (self.paths['path_id'],  
    473                                          self.paths['path_yadis']) 
     487        """         
     488        return self._matchIdentityURI() is not None 
     489 
    474490 
    475491    def _parseIdentityURI(self): 
    476         return self.path.rsplit('/', 1) 
    477      
     492        '''Split path into identity and path fragment components 
     493         
     494        @rtype: list 
     495        @return: 2 element list containing the Identity URI path fragment and 
     496        user identifier respectively. 
     497        ''' 
     498        return OpenIDProviderMiddleware.parseIdentityURI(self.path) 
     499     
     500 
     501    @classmethod 
     502    def parseIdentityURI(cls, uri): 
     503        '''Split uri into identity and uri fragment components 
     504         
     505        @type uri: basestring 
     506        @param uri: identity URI to be parsed 
     507        @rtype: list 
     508        @return: 2 element list containing the Identity URI fragment and 
     509        user identifier respectively. 
     510        ''' 
     511        return uri.rsplit('/', 1) 
     512     
     513 
     514    @classmethod 
     515    def createIdentityURI(cls, uri, userIdentifier): 
     516        '''This method is the compliment to parseIdentityURI.  Make an OpenID 
     517        URI from a user identifier and URI fragment 
     518         
     519        @type uri: basestring 
     520        @param uri: identity URI containing $userIdentifier where user id is 
     521        to be substituted in  
     522        @type userIdentifier: basestring 
     523        @param userIdentifier: identity URI to be parsed 
     524        @rtype: basestring 
     525        @return: user OpenID URI 
     526        ''' 
     527        return Template(uri).substitute(userIdentifier=userIdentifier) 
     528         
    478529    @NDGSecurityMiddlewareBase.initCall 
    479530    def __call__(self, environ, start_response): 
     
    491542            raise OpenIDProviderConfigError('The session middleware %r is not ' 
    492543                                            'present. Have you set up the ' 
    493                                             'session middleware?' % \ 
     544                                            'session middleware?' % 
    494545                                            self.session_middleware) 
    495546 
    496547        # Beware path is a property and invokes the _setPath method 
    497 #        self.path = environ.get('PATH_INFO').rstrip('/') 
    498 #        self.environ = environ 
    499 #        self.start_response = start_response 
    500548        self.session = environ[self.session_middleware] 
    501549        self._render.session = self.session 
    502550         
    503         if self.path in (self.paths['path_id'], self.paths['path_yadis']): 
    504             log.debug("No user id given in URL %s" % self.path) 
    505              
    506             # Disallow identifier and yadis URIs where no ID was specified 
    507             return self._app(environ, start_response) 
    508              
    509         elif self._isAnIdentityURI(): 
    510              
    511             # Match against path minus ID as this is not known in advance             
    512             pathMatch, userId = self._parseIdentityURI() 
    513         else: 
     551        pathMatch = self._matchIdentityURI() 
     552        if not pathMatch: 
    514553            pathMatch = self.path 
    515              
     554 
    516555        if pathMatch in self.method: 
     556            # Calls to parse_formvars seem to gobble up the POST content such 
     557            # that a 2nd call yields nothing! (with Paste 1.7.1)  
    517558            self.query = dict(paste.request.parse_formvars(environ))  
    518559            log.debug("Calling method %s ..." % self.method[pathMatch])  
     
    666707              
    667708            try: 
    668                 oidResponse = self._identityApprovedPostProcessing(oidRequest,  
     709                oidResponse = self._identityApprovedPostProcessing(oidRequest, 
    669710                                                                   identity) 
    670711 
    671             except (OpenIDProviderMissingRequiredAXAttrs,  
     712            except (OpenIDProviderMissingRequiredAXAttrs, 
    672713                    OpenIDProviderMissingAXResponseHandler): 
    673714                response = self._render.errorPage(environ, start_response, 
     
    739780                              "already logged in", self.session['username'], 
    740781                              self.session['username']) 
    741                     return self._redirect(start_response,self.query['fail_to']) 
     782                    return self._redirect(start_response, self.query['fail_to']) 
    742783                 
    743784                oidRequest = self.session.get('lastCheckIDRequest') 
     
    758799                else: 
    759800                    # Get the unique user identifier from the user's OpenID URL 
    760                     userIdentifier = oidRequest.identity.split('/')[-1] 
     801                    userIdentifier = OpenIDProviderMiddleware.parseIdentityURI( 
     802                                                    oidRequest.identity)[-1] 
    761803                     
    762804                # Invoke custom authentication interface plugin 
     
    854896           not oidRequest.idSelect(): 
    855897            try: 
    856                 response = self._identityApprovedPostProcessing(oidRequest,  
     898                response = self._identityApprovedPostProcessing(oidRequest, 
    857899                                                        oidRequest.identity) 
    858             except (OpenIDProviderMissingRequiredAXAttrs,  
     900            except (OpenIDProviderMissingRequiredAXAttrs, 
    859901                    OpenIDProviderMissingAXResponseHandler): 
    860902                response = self._render.errorPage(environ, start_response, 
     
    900942        identifiers = self._authN.username2UserIdentifiers(self.environ, 
    901943                                                           username) 
    902         idURLBase = self.urls['url_id']+'/' 
    903         identityURLs = [idURLBase+i for i in identifiers] 
    904         if oidRequest.identity not in identityURLs: 
     944 
     945        # Take two passes to allow for yadis and non-based discovery 
     946        identityURIs = [self.createIdentityURI(self.urls['url_id'], i) 
     947                        for i in identifiers] 
     948         
     949        identityURIs += [self.createIdentityURI(self.urls['url_yadis'], i) 
     950                         for i in identifiers] 
     951         
     952        if oidRequest.identity not in identityURIs: 
    905953            log.debug("OpenIDProviderMiddleware._identityIsAuthorized - " 
    906954                      "user is already logged in with a different ID=%s" % \ 
     
    909957         
    910958        log.debug("OpenIDProviderMiddleware._identityIsAuthorized - " 
    911                   "user is logged in with ID matching ID URL") 
     959                  "user is logged in with ID matching ID URI") 
    912960        return True 
    913961     
     
    9801028        # possibly via FetchRequest.getRequiredAttrs() 
    9811029        try: 
    982             self.axResponseHandler(ax_req,ax_resp,self.session.get('username')) 
     1030            self.axResponseHandler(ax_req, ax_resp, self.session.get('username')) 
    9831031             
    9841032        except OpenIDProviderMissingRequiredAXAttrs, e: 
     
    10451093                    oidResponse = self._identityApprovedPostProcessing( 
    10461094                                                                    oidRequest) 
    1047                 except (OpenIDProviderMissingRequiredAXAttrs,  
     1095                except (OpenIDProviderMissingRequiredAXAttrs, 
    10481096                        OpenIDProviderMissingAXResponseHandler): 
    10491097                    response = self._render.errorPage(environ, start_response, 
     
    11171165            response = webresponse.body 
    11181166             
    1119         hdr += [('Content-type', 'text/html'+self.charset), 
     1167        hdr += [('Content-type', 'text/html' + self.charset), 
    11201168                ('Content-length', str(len(response)))] 
    11211169             
    1122         self.start_response('%d %s' % (webresponse.code,  
    1123                                        httplib.responses[webresponse.code]),  
     1170        self.start_response('%d %s' % (webresponse.code, 
     1171                                       httplib.responses[webresponse.code]), 
    11241172                            hdr) 
    11251173        return response 
     
    11361184        @return: empty HTML body 
    11371185        """ 
    1138         start_response('302 %s' % httplib.responses[302],  
    1139                        [('Content-type', 'text/html'+self.charset), 
     1186        start_response('302 %s' % httplib.responses[302], 
     1187                       [('Content-type', 'text/html' + self.charset), 
    11401188                        ('Location', url)]) 
    11411189        return [] 
     
    12611309        endpoint_url = self.urls['url_openidserver'] 
    12621310        response = RenderingInterface.tmplServerYadis % \ 
    1263                                 {'openid20type': discover.OPENID_IDP_2_0_TYPE,  
     1311                                {'openid20type': discover.OPENID_IDP_2_0_TYPE, 
    12641312                                 'endpoint_url': endpoint_url} 
    12651313              
    1266         start_response("200 OK",  
     1314        start_response("200 OK", 
    12671315                       [('Content-type', 'application/xrds+xml'), 
    12681316                        ('Content-length', str(len(response)))]) 
     
    12831331        # Override this method to implement an alternate means to derive the  
    12841332        # username identifier 
    1285         userIdentifier = environ['PATH_INFO'].rstrip('/').split('/')[-1] 
     1333        userIdentifier = OpenIDProviderMiddleware.parseIdentityURI( 
     1334                                                    environ['PATH_INFO'])[ - 1] 
    12861335         
    12871336        endpoint_url = self.urls['url_openidserver'] 
    12881337        user_url = self.urls['url_id'] + '/' + userIdentifier 
    12891338         
    1290         yadisDict = dict(openid20type=discover.OPENID_2_0_TYPE,  
     1339        yadisDict = dict(openid20type=discover.OPENID_2_0_TYPE, 
    12911340                         openid10type=discover.OPENID_1_0_TYPE, 
    1292                          endpoint_url=endpoint_url,  
     1341                         endpoint_url=endpoint_url, 
    12931342                         user_url=user_url) 
    12941343         
     
    12961345      
    12971346        start_response('200 OK', 
    1298                        [('Content-type', 'application/xrds+xml'+self.charset), 
     1347                       [('Content-type', 'application/xrds+xml' + self.charset), 
    12991348                        ('Content-length', str(len(response)))]) 
    13001349        return response 
     
    13131362        """ 
    13141363        response = "Page is not implemented" 
    1315         start_response('%d %s' % (404, httplib.responses[code]),  
    1316                        [('Content-type', 'text/html'+self.charset), 
     1364        start_response('%d %s' % (404, httplib.responses[code]), 
     1365                       [('Content-type', 'text/html' + self.charset), 
    13171366                        ('Content-length', str(len(response)))]) 
    13181367        return response 
    13191368     
    13201369         
    1321     def login(self, environ, start_response,  
     1370    def login(self, environ, start_response, 
    13221371              success_to=None, fail_to=None, msg=''): 
    13231372        """Render the login form. 
     
    13441393         
    13451394        response = "Page is not implemented" 
    1346         start_response('%d %s' % (404, httplib.responses[code]),  
    1347                        [('Content-type', 'text/html'+self.charset), 
     1395        start_response('%d %s' % (404, httplib.responses[code]), 
     1396                       [('Content-type', 'text/html' + self.charset), 
    13481397                        ('Content-length', str(len(response)))]) 
    13491398        return response 
     
    13621411        """    
    13631412        response = "Page is not implemented" 
    1364         start_response('%d %s' % (404, httplib.responses[code]),  
    1365                        [('Content-type', 'text/html'+self.charset), 
     1413        start_response('%d %s' % (404, httplib.responses[code]), 
     1414                       [('Content-type', 'text/html' + self.charset), 
    13661415                        ('Content-length', str(len(response)))]) 
    13671416        return response 
     
    14001449        """ 
    14011450        response = "Page is not implemented" 
    1402         start_response('%d %s' % (404, httplib.responses[code]),  
    1403                        [('Content-type', 'text/html'+self.charset), 
     1451        start_response('%d %s' % (404, httplib.responses[code]), 
     1452                       [('Content-type', 'text/html' + self.charset), 
    14041453                        ('Content-length', str(len(response)))]) 
    14051454        return response 
     
    14221471        """      
    14231472        response = "Page is not implemented" 
    1424         start_response('%d %s' % (404, httplib.responses[code]),  
    1425                        [('Content-type', 'text/html'+self.charset), 
     1473        start_response('%d %s' % (404, httplib.responses[code]), 
     1474                       [('Content-type', 'text/html' + self.charset), 
    14261475                        ('Content-length', str(len(response)))]) 
    14271476        return response 
     
    14431492        """ 
    14441493        path = environ.get('PATH_INFO').rstrip('/') 
    1445         userIdentifier = path.split('/')[-1] 
     1494        userIdentifier = path.split('/')[ - 1] 
    14461495         
    14471496        link_tag = '<link rel="openid.server" href="%s">' % \ 
     
    14491498               
    14501499        yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
    1451             (self.urls['url_yadis']+'/'+userIdentifier) 
     1500            (self.urls['url_yadis'] + '/' + userIdentifier) 
    14521501             
    14531502        disco_tags = link_tag + yadis_loc_tag 
    14541503        ident = self.base_url + path 
    14551504 
    1456         response = self._showPage(environ,  
    1457                                   'Identity Page',  
    1458                                   head_extras=disco_tags,  
     1505        response = self._showPage(environ, 
     1506                                  'Identity Page', 
     1507                                  head_extras=disco_tags, 
    14591508                                  msg='<p>This is the identity page for %s.' 
    14601509                                      '</p>' % ident) 
    14611510         
    1462         start_response("200 OK",  
    1463                        [('Content-type', 'text/html'+self.charset), 
     1511        start_response("200 OK", 
     1512                       [('Content-type', 'text/html' + self.charset), 
    14641513                        ('Content-length', str(len(response)))]) 
    14651514        return response 
    14661515     
    14671516         
    1468     def login(self, environ, start_response,  
     1517    def login(self, environ, start_response, 
    14691518              success_to=None, fail_to=None, msg=''): 
    14701519        """Render the login form. 
     
    15171566 
    15181567        response = self._showPage(environ, 'Login Page', form=form) 
    1519         start_response('200 OK',  
    1520                        [('Content-type', 'text/html'+self.charset), 
     1568        start_response('200 OK', 
     1569                       [('Content-type', 'text/html' + self.charset), 
    15211570                        ('Content-length', str(len(response)))]) 
    15221571        return response 
     
    15571606''' % (user_message, quoteattr(self.base_url), self.base_url) 
    15581607        response = self._showPage(environ, 
    1559                                   'Main Page',  
    1560                                   head_extras=yadis_tag,  
     1608                                  'Main Page', 
     1609                                  head_extras=yadis_tag, 
    15611610                                  msg=msg) 
    15621611     
    1563         start_response('200 OK',  
    1564                        [('Content-type', 'text/html'+self.charset), 
     1612        start_response('200 OK', 
     1613                       [('Content-type', 'text/html' + self.charset), 
    15651614                        ('Content-length', str(len(response)))]) 
    15661615        return response 
     
    16951744</form>''' % fdata 
    16961745 
    1697         response = self._showPage(environ, 'Approve OpenID request?',  
     1746        response = self._showPage(environ, 'Approve OpenID request?', 
    16981747                                  msg=msg, form=form)             
    1699         start_response('200 OK',  
    1700                        [('Content-type', 'text/html'+self.charset), 
     1748        start_response('200 OK', 
     1749                       [('Content-type', 'text/html' + self.charset), 
    17011750                        ('Content-length', str(len(response)))]) 
    17021751        return response 
    17031752     
    17041753 
    1705     def _showPage(self,  
    1706                   environ,  
    1707                   title,  
    1708                   head_extras='',  
    1709                   msg=None,  
    1710                   err=None,  
     1754    def _showPage(self, 
     1755                  environ, 
     1756                  title, 
     1757                  head_extras='', 
     1758                  msg=None, 
     1759                  err=None, 
    17111760                  form=None): 
    17121761        """Generic page rendering method.  Derived classes may ignore this. 
     
    17351784                        '<a href="%s?submit=true&'\ 
    17361785                        'success_to=%s">Log out</a>' % \ 
    1737                         (self.urls['url_id'], username, username,  
     1786                        (self.urls['url_id'], username, username, 
    17381787                         self.urls['url_loginsubmit'], 
    17391788                         self.urls['url_login']) 
     
    17421791 
    17431792        if err is not None: 
    1744             body +=  '''\ 
     1793            body += '''\ 
    17451794            <div class="error"> 
    17461795              %s 
     
    18971946        ''' % msg) 
    18981947         
    1899         start_response('%d %s' % (code, httplib.responses[code]),  
    1900                        [('Content-type', 'text/html'+self.charset), 
     1948        start_response('%d %s' % (code, httplib.responses[code]), 
     1949                       [('Content-type', 'text/html' + self.charset), 
    19011950                        ('Content-length', str(len(response)))]) 
    19021951        return response 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/authninterface/sessionmanager.py

    r4855 r5080  
    117117        """Map the login username to an identifier which will become the 
    118118        unique path suffix to the user's OpenID identifier.  The  
    119         OpenIDProviderMiddleware takes self.urls['id_url'] and adds it to this 
    120         identifier: 
     119        OpenIDProviderMiddleware takes the ID URL template and adds it to this 
     120        identifier e.g. 
    121121         
    122122            identifier = self._authN.username2UserIdentifiers(username) 
    123             identityURL = self.urls['url_id'] + '/' + identifier 
     123            identityURL = http://mysite/openid/${userIdentifier} 
    124124         
    125125        @type environ: dict 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/renderinginterface/buffet/__init__.py

    r4863 r5080  
    1616from pylons.templating import Buffet 
    1717 
     18from openid.consumer import discover 
     19 
    1820# Rendering classes for OpenID Provider must derive from generic render  
    1921# interface 
    2022from ndg.security.server.wsgi.openid.provider import RenderingInterface, \ 
    2123    RenderingInterfaceConfigError 
     24     
     25from ndg.security.server.wsgi.openid.provider import OpenIDProviderMiddleware 
    2226 
    2327# Boiler plate to create renderer 
     
    7882                                        namespace=kw) 
    7983        return rendering 
    80      
     84 
     85 
     86    def yadis(self, environ, start_response): 
     87        """Render Yadis document containing user URL - override base  
     88        implementation to specify Yadis based discovery for user URL 
     89         
     90        @type environ: dict 
     91        @param environ: dictionary of environment variables 
     92        @type start_response: callable 
     93        @param start_response: WSGI start response function.  Should be called 
     94        from this method to set the response code and HTTP header content 
     95        @rtype: basestring 
     96        @return: WSGI response 
     97        """ 
     98        userIdentifier = OpenIDProviderMiddleware.parseIdentityURI( 
     99                                                    environ['PATH_INFO'])[-1] 
     100         
     101        # This is where this implementation differs from the base class one 
     102        user_url = OpenIDProviderMiddleware.createIdentityURI( 
     103                                                        self.urls['url_yadis'], 
     104                                                        userIdentifier) 
     105         
     106        yadisDict = dict(openid20type=discover.OPENID_2_0_TYPE,  
     107                         openid10type=discover.OPENID_1_0_TYPE, 
     108                         endpoint_url=self.urls['url_openidserver'],  
     109                         user_url=user_url) 
     110         
     111        response = RenderingInterface.tmplYadis % yadisDict 
     112      
     113        start_response('200 OK', 
     114                       [('Content-type', 'application/xrds+xml'+self.charset), 
     115                        ('Content-length', str(len(response)))]) 
     116        return response 
     117  
    81118    def login(self, environ, start_response, success_to=None, fail_to=None,  
    82119              msg=''): 
     
    107144        return response 
    108145 
     146 
    109147    def identityPage(self, environ, start_response): 
    110         """Render the user's Identity page""" 
    111         path = environ['PATH_INFO'].rstrip('/') 
    112         idPath = self.urls['url_id'].replace(self.base_url, '') 
    113         userIdentifier = path[len(idPath)+1:] 
    114         if not userIdentifier: 
    115             h.redirect_to(self.urls['url_mainpage']) 
    116              
    117         self.title = "OpenID Identity Page" 
    118                          
    119         link_tag = '<link rel="openid.server" href="%s"/>' % \ 
    120                     self.urls['url_openidserver'] 
    121                
    122         yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s"/>' % \ 
    123             (self.urls['url_yadis']+'/'+userIdentifier) 
    124              
    125         self.headExtras = link_tag + yadis_loc_tag 
    126         identityURL = self.base_url + path 
    127         self.xml = "<b><pre>%s</pre></b>" % identityURL 
    128          
    129         response = self._render('ndg.security.identityPage')     
    130         start_response("200 OK",  
    131                        [('Content-type', 'text/html'+self.charset), 
    132                         ('Content-length', str(len(response)))]) 
    133         self.xml = '' 
     148        """This page would normally render the user's Identity page but it's 
     149        not needed for Yadis only based discovery""" 
     150 
     151        self.xml = 'Invalid page requested for OpenID Provider' 
     152        response = self._render('ndg.security.error')  
     153        self.xml = ''    
     154        start_response("404 Not Found",  
     155                       [('Content-type', 'text/html'+self.charset), 
     156                        ('Content-length', str(len(response)))]) 
    134157        return response 
    135158 
     
    143166        self.environ = environ 
    144167         
     168        if oidRequest.idSelect(): 
     169            if 'username' not in self.session: 
     170                log.error("No 'username' key set in sessin object for " 
     171                          "idselect mode do decide page") 
     172                msg = ('An internal error has occurred.  Please contact ' 
     173                       'your system administrator') 
     174                response = self.errorPage(environ, start_response, msg) 
     175                return response 
     176                 
     177            userIdentifier = self._authN.username2UserIdentifiers( 
     178                                            environ, 
     179                                            self.session['username'])[0] 
     180                                             
     181            # Use the Yadis path because we want to use Yadis only 
     182            # based discovery 
     183            self.identityURI = OpenIDProviderMiddleware.createIdentityURI( 
     184                                                        self.urls['url_yadis'], 
     185                                                        userIdentifier) 
     186        else: 
     187            self.identityURI = oidRequest.identity 
     188         
    145189        response = self._render('ndg.security.decidePage') 
     190        self.identityURI = '' 
     191         
    146192        start_response("200 OK",  
    147193                       [('Content-type', 'text/html'+self.charset), 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/renderinginterface/buffet/templates/ndg/security/decidePage.kid

    r4565 r5080  
    1010        <div py:replace="header()"/> 
    1111        <div class="decidePageContent" style="text-indent:5px">   
    12                 <?python 
    13                         if c.oidRequest.idSelect(): 
    14                                 userIdentifier = c._authN.username2UserIdentifiers( 
    15                                                                                                 c.environ, 
    16                                                                                                 c.session['username'])[0] 
    17                                 identityURL = c.urls['url_id']+'/'+userIdentifier 
    18                         else: 
    19                                 identityURL = c.oidRequest.identity 
    20                 ?> 
    2112            <h2>Login to $c.oidRequest.trust_root?</h2> 
    22 <!--            <div class="loginHdr">Login<span py:replace="helpIcon('fts_help')"/></div> 
    23                 <div id="fts_help" class="hidden"> 
    24                         <div class="helptxt"> 
    25                                 <p> 
    26                                         Although you are logged into this site, you also need  
    27                                         to decide whether to allow your details to be 
    28                                         returned to $c.oidRequest.trust_root so that you are  
    29                                         logged in there too.  The details passed back include 
    30                                         the OpenID identifier given below.  The details don't 
    31                                         include you login password. 
    32                                 </p> 
    33                         </div> 
    34                 </div> 
    35 --> 
    3613                <form method="POST" action="${c.urls['url_allow']}"> 
    3714                        <table> 
    38                                 <input type="hidden" name="identity" value="$identityURL" /> 
     15                                <input type="hidden" name="identity" value="$c.identityURI" /> 
    3916                                <tr> 
    4017                                        <td> 
     
    4522                                <tr> 
    4623                                <td> 
    47                                         <pre><b>$identityURL</b></pre> 
     24                                        <pre><b>$c.identityURI</b></pre> 
    4825                                </td> 
    4926                        </tr> 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/relyingparty/__init__.py

    r5057 r5080  
    133133            params = dict(parse_querystring(environ)) 
    134134        else: 
    135             params = dict(parse_formvars(environ)) 
     135            params = {} 
    136136         
    137137        quotedReferrer=params.get(AuthNRedirectMiddleware.return2URIArgName,'') 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securedapp.ini

    r5046 r5080  
    99use = egg:Paste#http 
    1010host = 0.0.0.0 
    11 port = 9080 
     11port = 5080 
    1212 
    1313[pipeline:main] 
     
    3737 
    3838# Set redirect for OpenID Relying Party in the Security Services app instance 
    39 authN.redirectURI = http://localhost:9443/verify 
     39authN.redirectURI = http://localhost:5443/verify 
    4040 
    4141# AuthKit Set-up 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securedapp.py

    r5046 r5080  
    5252        port = int(sys.argv[1]) 
    5353    else: 
    54         port = 9080 
     54        port = 5080 
    5555         
    5656    cfgFilePath = os.path.join(dirname(abspath(__file__)), 'securedapp.ini') 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securityservices.ini

    r5046 r5080  
    1515 
    1616[DEFAULT] 
    17 portNum = 9443 
     17portNum = 5443 
    1818hostname = localhost 
    1919scheme = http 
     
    228228[app:OpenIDProviderMiddlewareApp] 
    229229paste.app_factory=ndg.security.server.wsgi.openid.provider:OpenIDProviderMiddleware.app_factory 
    230 openid.provider.path.openidserver=/openid/endpoint 
    231 openid.provider.path.login=/openid/login 
    232 openid.provider.path.loginsubmit=/openid/loginsubmit 
    233  
    234 # Comment out next two lines and uncomment the third to disable URL based  
    235 # discovery and allow only Yadis based instead 
    236 #openid.provider.path.id=/openid/id 
    237 #openid.provider.path.yadis=/openid/yadis 
    238 openid.provider.path.yadis=/id/ 
    239  
    240 openid.provider.path.serveryadis=/openid/serveryadis 
    241 openid.provider.path.allow=/openid/allow 
    242 openid.provider.path.decide=/openid/decide 
    243 openid.provider.path.mainpage=/openid/ 
     230openid.provider.path.openidserver=/OpenID/Provider/server 
     231openid.provider.path.login=/OpenID/Provider/login 
     232openid.provider.path.loginsubmit=/OpenID/Provider/loginsubmit 
     233 
     234# Yadis based discovery only - the 'id' path is configured to return 404 not 
     235# found - see ndg.security.server.wsgi.openid.provider.renderinginterface. 
     236# buffet.BuffetRendering class 
     237openid.provider.path.id=/OpenID/Provider/id/${userIdentifier} 
     238openid.provider.path.yadis=/openid/${userIdentifier} 
     239 
     240# Yadis based discovery for idselect mode - this is where the user has entered 
     241# a URI at the Relying Party which identifies their Provider only and not their 
     242# full ID URI.  e.g. https://badc.nerc.ac.uk instead of  
     243# https://badc.nerc.ac.uk/John 
     244openid.provider.path.serveryadis=/openid 
     245openid.provider.path.allow=/OpenID/Provider/allow 
     246openid.provider.path.decide=/OpenID/Provider/decide 
     247openid.provider.path.mainpage=/OpenID/Provider/home 
     248 
    244249openid.provider.session_middleware=beaker.session  
    245250openid.provider.base_url=%(baseURI)s 
    246251openid.provider.trace=False 
     252openid.provider.consumer_store_dirpath=%(here)s/openidprovider 
    247253openid.provider.renderingClass=ndg.security.server.wsgi.openid.provider.renderinginterface.buffet.BuffetRendering 
    248254#openid.provider.renderingClass=ndg.security.server.wsgi.openid.provider.DemoRenderingInterface 
     
    279285# Omit or leave as blank if the Session Manager is accessible locally in the 
    280286# same WSGI stack. 
    281 openid.provider.authN.sessionManagerURI= 
     287#openid.provider.authN.sessionManagerURI= 
    282288 
    283289# environ dictionary key to Session Manager WSGI instance held locally.  The 
    284290# setting below is the default and can be omitted if it matches the filterID 
    285291# set for the Session Manager 
    286 #openid.provider.authN.environKey=filter:SessionManagerFilter 
     292openid.provider.authN.environKey=filter:SessionManagerFilter 
    287293 
    288294# Database connection to enable check between username and OpenID identifier 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securityservicesapp.py

    r5046 r5080  
    2525        port = int(sys.argv[1]) 
    2626    else: 
    27         port = 9443 
     27        port = 5443 
    2828         
    2929    cfgFilePath = os.path.join(dirname(abspath(__file__)),  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidprovider/securityservices.ini

    r5067 r5080  
    188188[app:OpenIDProviderMiddlewareApp] 
    189189paste.app_factory=ndg.security.server.wsgi.openid.provider:OpenIDProviderMiddleware.app_factory 
    190 openid.provider.path.openidserver=/openidserver 
    191 openid.provider.path.login=/openid/login 
    192 openid.provider.path.loginsubmit=/openid/loginsubmit 
    193  
    194 # Comment out next two lines and uncomment the third to disable URL based  
    195 # discovery and allow only Yadis based instead 
    196 openid.provider.path.id=/openid/id 
    197 openid.provider.path.yadis=/openid/yadis 
     190#openid.provider.path.openidserver=/openidserver 
     191#openid.provider.path.login=/openid/login 
     192#openid.provider.path.loginsubmit=/openid/loginsubmit 
     193# 
     194## Comment out next two lines and uncomment the third to disable URL based  
     195## discovery and allow only Yadis based instead 
     196##openid.provider.path.id=/openid/id 
     197##openid.provider.path.yadis=/openid/yadis 
    198198#openid.provider.path.yadis=/openid/id/ 
    199  
    200 openid.provider.path.serveryadis=/openid/serveryadis 
    201 openid.provider.path.allow=/openid/allow 
    202 openid.provider.path.decide=/openid/decide 
    203 openid.provider.path.mainpage=/openid/ 
     199# 
     200#openid.provider.path.serveryadis=/openid/serveryadis 
     201#openid.provider.path.allow=/openid/allow 
     202#openid.provider.path.decide=/openid/decide 
     203#openid.provider.path.mainpage=/openid/ 
     204 
     205openid.provider.path.openidserver=/OpenID/Provider/server 
     206openid.provider.path.login=/OpenID/Provider/login 
     207openid.provider.path.loginsubmit=/OpenID/Provider/loginsubmit 
     208 
     209# Yadis based discovery only - the id path is configured to return 404 not 
     210# found - see ndg.security.server.wsgi.openid.provider.renderinginterface. 
     211# buffet.BuffetRendering class 
     212openid.provider.path.id=/OpenID/Provider/id/${userIdentifier} 
     213openid.provider.path.yadis=/openid/${userIdentifier} 
     214 
     215openid.provider.path.serveryadis=/openid 
     216openid.provider.path.allow=/OpenID/Provider/allow 
     217openid.provider.path.decide=/OpenID/Provider/decide 
     218openid.provider.path.mainpage=/OpenID/Provider/main 
     219 
    204220openid.provider.session_middleware=beaker.session  
    205221openid.provider.base_url=%(baseURI)s 
    206222openid.provider.trace=False 
     223openid.provider.consumer_store_dirpath=%(here)s/openidprovider 
    207224openid.provider.renderingClass=ndg.security.server.wsgi.openid.provider.renderinginterface.buffet.BuffetRendering 
    208225#openid.provider.renderingClass=ndg.security.server.wsgi.openid.provider.DemoRenderingInterface 
Note: See TracChangeset for help on using the changeset viewer.