Changeset 4120 for TI12-security


Ignore:
Timestamp:
11/08/08 11:35:00 (11 years ago)
Author:
pjkersha
Message:

Fix for ndg.security.test.sessionMgr.test.SessionMgrTestCase?.test1Connect: use asPEM method to convert self.userCert to a string for output to file.

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

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/Tests/openid-provider/op/op/lib/rendering.py

    r4105 r4120  
    2828        self.xml = '' 
    2929        self.headExtras = '' 
     30        self.session = {} 
     31        self.loginStatus = True 
    3032 
    3133def _render(templateName, **kw): 
     
    4850    """Provide Kid Templating for OpenID Provider Middleware""" 
    4951     
    50     def renderLogin(self): 
     52    def renderLogin(self, environ): 
    5153        """Set-up Kid template for OpenID Provider Login""" 
    5254        c = State() 
     55        c.loginStatus = False 
    5356        c.title = "OpenID Login" 
    5457        c.path_loginsubmit = self.paths['path_loginsubmit'] 
     
    5962         
    6063         
    61     def renderMainPage(path_serveryadis): 
     64    def renderMainPage(self, environ): 
    6265        """Set-up Kid template for OpenID Provider Login""" 
    6366        c = State() 
     67        c.session = environ['beaker.session'] 
    6468        c.title = "OpenID Provider" 
    6569        c.path_serveryadis = self.paths['path_serveryadis'] 
     
    6872     
    6973        return _render('ndg.security.mainPage', c=c, g=config['pylons.g'], h=h) 
     74     
     75    def renderDecidePage(self, environ, oidRequest): 
     76        id_url_base = self.base_url+self.paths['path_id'] + '/' 
     77         
     78        # XXX: This may break if there are any synonyms for id_url_base, 
     79        # such as referring to it by IP address or a CNAME. 
     80         
     81        # TODO: OpenID 2.0 Allows oidRequest.identity to be set to  
     82        # http://specs.openid.net/auth/2.0/identifier_select.  See, 
     83        # http://openid.net/specs/openid-authentication-2_0.html.  This code 
     84        # implements this overriding the behaviour of the example code on 
     85        # which this is based.  - Check is the example code based on OpenID 1.0 
     86        # and therefore wrong for this behaviour? 
     87#        assert oidRequest.identity.startswith(id_url_base), \ 
     88#               repr((oidRequest.identity, id_url_base)) 
     89        expected_user = oidRequest.identity[len(id_url_base):] 
     90        c = State() 
     91        c.title = 'Approve OpenID Request?' 
     92        c.oidRequest = oidRequest 
     93         
     94        if oidRequest.idSelect(): # We are being asked to select an ID 
     95            msg = '''\ 
     96            <p>A site has asked for your identity.  You may select an 
     97            identifier by which you would like this site to know you. 
     98            On a production site this would likely be a drop down list 
     99            of pre-created accounts or have the facility to generate 
     100            a random anonymous identifier. 
     101            </p> 
     102            ''' 
     103             
     104            c.path_allow = self.paths['path_allow'] 
     105            c.id_url_base = id_url_base 
     106            c.trust_root = oidRequest.trust_root 
     107             
     108             
     109            fdata = { 
     110                'path_allow': self.paths['path_allow'], 
     111                'id_url_base': id_url_base, 
     112                'trust_root': oidRequest.trust_root, 
     113                } 
     114            form = '''\ 
     115            <form method="POST" action="%(path_allow)s"> 
     116            <table> 
     117              <tr><td>Identity:</td> 
     118                 <td>%(id_url_base)s<input type='text' name='identifier'></td></tr> 
     119              <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     120            </table> 
     121            <p>Allow this authentication to proceed?</p> 
     122            <input type="checkbox" id="remember" name="remember" value="yes" 
     123                /><label for="remember">Remember this 
     124                decision</label><br /> 
     125            <input type="submit" name="yes" value="yes" /> 
     126            <input type="submit" name="no" value="no" /> 
     127            </form> 
     128            '''%fdata 
     129             
     130        elif expected_user == self.user: 
     131            msg = '''\ 
     132            <p>A new site has asked to confirm your identity.  If you 
     133            approve, the site represented by the trust root below will 
     134            be told that you control identity URL listed below. (If 
     135            you are using a delegated identity, the site will take 
     136            care of reversing the delegation on its own.)</p>''' 
     137 
     138            fdata = { 
     139                'path_allow': self.paths['path_allow'], 
     140                'identity': oidRequest.identity, 
     141                'trust_root': oidRequest.trust_root, 
     142                } 
     143            form = '''\ 
     144            <table> 
     145              <tr><td>Identity:</td><td>%(identity)s</td></tr> 
     146              <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     147            </table> 
     148            <p>Allow this authentication to proceed?</p> 
     149            <form method="POST" action="%(path_allow)s"> 
     150              <input type="checkbox" id="remember" name="remember" value="yes" 
     151                  /><label for="remember">Remember this 
     152                  decision</label><br /> 
     153              <input type="submit" name="yes" value="yes" /> 
     154              <input type="submit" name="no" value="no" /> 
     155            </form>''' % fdata 
     156        else: 
     157            mdata = { 
     158                'expected_user': expected_user, 
     159                'user': self.user, 
     160                } 
     161            msg = '''\ 
     162            <p>A site has asked for an identity belonging to 
     163            %(expected_user)s, but you are logged in as %(user)s.  To 
     164            log in as %(expected_user)s and approve the login oidRequest, 
     165            hit OK below.  The "Remember this decision" checkbox 
     166            applies only to the trust root decision.</p>''' % mdata 
     167 
     168            fdata = { 
     169                'path_allow': self.paths['path_allow'], 
     170                'identity': oidRequest.identity, 
     171                'trust_root': oidRequest.trust_root, 
     172                'expected_user': expected_user, 
     173                } 
     174            form = '''\ 
     175            <table> 
     176              <tr><td>Identity:</td><td>%(identity)s</td></tr> 
     177              <tr><td>Trust Root:</td><td>%(trust_root)s</td></tr> 
     178            </table> 
     179            <p>Allow this authentication to proceed?</p> 
     180            <form method="POST" action="%(path_allow)s"> 
     181              <input type="checkbox" id="remember" name="remember" value="yes" 
     182                  /><label for="remember">Remember this 
     183                  decision</label><br /> 
     184              <input type="hidden" name="login_as" value="%(expected_user)s"/> 
     185              <input type="submit" name="yes" value="yes" /> 
     186              <input type="submit" name="no" value="no" /> 
     187            </form>''' % fdata 
     188 
     189        return _render('ndg.security.decidePage', c=c,g=config['pylons.g'],h=h) 
  • TI12-security/trunk/python/Tests/openid-provider/op/op/templates/ndg/security/login.kid

    r4105 r4120  
    88                <tr> 
    99                    <td>Username:</td>  
    10                     <td><input type="text" name="user" value=""/></td> 
     10                    <td><input type="text" name="username" value=""/></td> 
    1111                </tr><tr> 
    12                     <td>Pass-phrase:</td> 
    13                     <td><input type="password" name="passphrase"/></td> 
     12                    <td>Password:</td> 
     13                    <td><input type="password" name="password"/></td> 
    1414                </tr><tr> 
    1515                    <td colspan="2" align="right"> 
  • TI12-security/trunk/python/Tests/openid-provider/op/op/templates/ndg/security/ndgPage.kid

    r4105 r4120  
    5656                </td> 
    5757                <td width="40%" align="center"> 
     58                    <div py:if="c.loginStatus" id="loginStatus"> 
     59                        <!--! now we choose one of the next two (logged in or not) --> 
     60                        <div py:if="'username' in c.session" id="loggedIn"> 
     61                            <table><tbody><tr><td>  
     62                                <!-- Create link using embedded python  
     63                                    construct because including a link with '&' 
     64                                    directly causes an error 
     65                                --> 
     66                                <?python 
     67                                    logOutLink='%s/loginsubmit?submit=true&success_to=%s/login' % ((g.server,)*2) 
     68                                ?> 
     69                                Logged in as ${c.session['username']}.  
     70                                [<a href="$logOutLink"> 
     71                                    Log out 
     72                                </a>] 
     73                            </td></tr></tbody></table> 
     74                        </div> 
     75                        <div py:if="'username' not in c.session" id="loggedOut"> 
     76                            <table><tbody><tr><td>  
     77                                Other services may be available if you <a href="$g.server/login">login</a>. 
     78                            </td></tr></tbody></table> 
     79                        </div> 
     80                    </div> 
    5881                </td> 
    5982                <td align="right"><span py:replace="linkimage(g.stfcLink,g.stfcImage,'Hosted by the STFC CEDA')"/></td> 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/X509.py

    r2958 r4120  
    4343        if filePath is not None: 
    4444            if not isinstance(filePath, basestring): 
    45                 raise X509CertError, \ 
    46                         "Certificate File Path input must be a valid string" 
     45                raise X509CertError( 
     46                        "Certificate File Path input must be a valid string") 
    4747             
    4848        self.__filePath = filePath             
     
    6161        if filePath is not None: 
    6262            if not isinstance(filePath, basestring): 
    63                 raise X509CertError, \ 
    64                     "Certificate File Path input must be a valid string" 
     63                raise X509CertError( 
     64                    "Certificate File Path input must be a valid string") 
    6565             
    6666            self.__filePath = filePath 
     
    6969            self.__m2CryptoX509 = M2Crypto.X509.load_cert(self.__filePath) 
    7070        except Exception, e: 
    71             raise X509CertError, "Error loading certificate \"%s\": %s" % \ 
    72                                 (self.__filePath, str(e)) 
     71            raise X509CertError("Error loading certificate \"%s\": %s" % \ 
     72                                (self.__filePath, str(e))) 
    7373 
    7474        # Update DN and validity times from M2Crypto X509 object just 
     
    9696        self.__setM2CryptoX509() 
    9797 
    98  
    99          
    100          
     98       
    10199    def __setM2CryptoX509(self, m2CryptoX509=None): 
    102100        """Private method allows class members to be updated from the 
     
    140138 
    141139 
    142     #_________________________________________________________________________ 
    143140    def __getM2CryptoX509(self, m2CryptoX509=None): 
    144141        "Return M2Crypto X.509 cert object" 
     
    176173 
    177174     
    178     #_________________________________________________________________________ 
    179175    # Make some attributes accessible as read-only 
    180176    def __getDN(self): 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/sessionMgr.tac

    r3652 r4120  
    229229                            caCertFilePathList=srv.sm.get('caCertFileList'), 
    230230                                        refC14nKw=refC14nKw, 
    231                                         signedInfoC14nKw=signedInfoC14nKw) 
     231                                        signedInfoC14nKw=signedInfoC14nKw, 
     232                                        applySignatureConfirmation=True) 
    232233 
    233234# Add Service to Session Manager branch 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid_provider.py

    r4104 r4120  
    9090 
    9191        try: 
    92             self._renderer = RenderingInterface(self.base_url, self.paths) 
     92            self._renderer = renderingClass(self.base_url, self.paths) 
    9393        except Exception, e: 
    9494            log.error("Error instantiating rendering interface...") 
    9595            raise 
    9696             
    97         self.user = None 
     97        self.username = None 
    9898        self.app = app 
    9999         
     
    153153    def do_id(self, environ, start_response): 
    154154        '''Handle ID request''' 
    155         response = self.renderIdentityPage() 
     155        response = self._renderer.renderIdentityPage(environ) 
    156156 
    157157        start_response("200 OK", [('Content-length', str(len(response)))]) 
     
    178178        """Generate Yadis document""" 
    179179 
    180         self.user = self.path.split('/')[-1] 
     180        self.username = self.path.split('/')[-1] 
    181181         
    182182        endpoint_url = self.base_url + self.paths['path_openidserver'] 
    183         user_url = self.base_url + self.paths['path_id'] + '/' + self.user 
     183        user_url = self.base_url + self.paths['path_id'] + '/' + self.username 
    184184         
    185185        yadisDict = dict(openid20type=discover.OPENID_2_0_TYPE,  
     
    225225        # pretend this next bit is keying off the user's session or something, 
    226226        # right? 
    227         request = self.lastCheckIDRequest.get(self.user) 
     227        request = self.lastCheckIDRequest.get(self.username) 
    228228 
    229229        if 'yes' in self.query: 
    230230            if 'login_as' in self.query: 
    231                 self.user = self.query['login_as'] 
     231                self.username = self.query['login_as'] 
    232232 
    233233            if request.idSelect(): 
     
    237237                identity = request.identity 
    238238                 
    239             if self.user is None: 
    240                 self.user = identity.split('/')[-1] 
     239            if self.username is None: 
     240                self.username = identity.split('/')[-1] 
    241241 
    242242            trust_root = request.trust_root 
     
    286286        """Display Login form""" 
    287287         
    288         response = self._renderer.renderLogin() 
     288        response = self._renderer.renderLogin(environ) 
    289289        start_response('200 OK',  
    290290                       [('Content-type', 'text/html'+self.charset), 
     
    297297         
    298298        if 'submit' in self.query: 
    299             if 'user' in self.query: 
    300                 self.user = self.query['user'] 
     299            if 'username' in self.query: 
     300                self.username = self.query['username'] 
     301                session = environ['beaker.session'] 
     302                session['username'] = self.query['username'] 
     303                session.save() 
    301304            else: 
    302                 self.user = None 
     305                self.username = None 
    303306            return self._redirect(start_response, self.query['success_to']) 
    304307        elif 'cancel' in self.query: 
    305308            return self._redirect(start_response, self.query['fail_to']) 
    306309        else: 
    307             raise OpenIDProviderMiddlewareError('strange login %r'%self.query)    
     310            raise OpenIDProviderMiddlewareError('Login input not recognised ' 
     311                                                '%r' % self.query)    
    308312             
    309313 
    310314    def do_mainpage(self, environ, start_response): 
    311315 
    312         response = self.renderMainPage(self.paths['path_serveryadis']) 
     316        response = self._renderer.renderMainPage(environ) 
    313317        start_response('200 OK',  
    314318                       [('Content-type', 'text/html'+self.charset), 
    315319                        ('Content-length', str(len(response)))]) 
    316320        return response 
    317              
    318                          
    319     def _setUser(self): 
    320         session = environ[self.session_middleware] 
    321         self.user = session.get('openid_provider_username') 
     321 
    322322         
    323323    def _isAuthorized(self, identity_url, trust_root): 
    324         if self.user is None: 
     324        session = self.environ[self.session_middleware] 
     325        username = session.get('username') 
     326        if username is None: 
    325327            return False 
    326328 
    327         if identity_url != self.base_url+self.paths['path_id']+'/'+self.user: 
     329        if identity_url != self.base_url+self.paths['path_id']+'/'+username: 
    328330            return False 
    329331 
     
    339341        # TODO: role/user attribute look-up in database vs. username? 
    340342        sreg_data = { 
    341             'nickname':self.user 
     343            'nickname':self.username 
    342344            } 
    343345 
     
    350352        return response 
    351353 
    352     def _handleCheckIDRequest(self, request): 
    353         is_authorized = self._isAuthorized(request.identity,request.trust_root) 
    354         if is_authorized: 
    355             response = self._identityApproved(request) 
    356             return self._displayResponse(response) 
    357         elif request.immediate: 
    358             response = request.answer(False) 
    359             return self._displayResponse(response) 
    360         else: 
    361             self.lastCheckIDRequest[self.user] = request 
    362             return self._showDecidePage(request) 
     354    def _handleCheckIDRequest(self, oidRequest): 
     355        isAuthorized = self._isAuthorized(oidRequest.identity, 
     356                                          oidRequest.trust_root) 
     357        if isAuthorized: 
     358            oidResponse = self._identityApproved(oidRequest) 
     359            return self._displayResponse(oidResponse) 
     360        elif oidRequest.immediate: 
     361            oidResponse = oidRequest.answer(False) 
     362            return self._displayResponse(oidResponse) 
     363        else: 
     364            self.lastCheckIDRequest[self.username] = oidRequest 
     365#            response = self._renderer.renderDecidePage(self.environ,oidRequest) 
     366            response = self._renderer.renderLogin(self.environ) 
     367            return response 
    363368 
    364369    def _displayResponse(self, response): 
     
    395400 
    396401    def _writeUserHeader(self): 
    397         if self.user is None: 
     402        if self.username is None: 
    398403            # TODO: Refactor this out when replaced with beaker.session /  
    399404            # AuthKit 
     
    402407            expires = time.strftime( 
    403408                'Expires=%a, %d-%b-%y %H:%M:%S GMT', t1970) 
    404             return [('Set-Cookie', 'user=;%s' % expires)] 
    405         else: 
    406             return [('Set-Cookie', 'user=%s' % self.user)] 
     409            return [('Set-Cookie', 'username=;%s' % expires)] 
     410        else: 
     411            return [('Set-Cookie', 'username=%s' % self.username)] 
    407412 
    408413    def _showAboutPage(self): 
     
    470475        ''' % error_message) 
    471476 
    472     def _showDecidePage(self, request): 
     477 
     478    def _showIdPage(self, path): 
     479        link_tag = '<link rel="openid.server" href="%sopenidserver">' %\ 
     480              self.base_url 
     481        yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">'%\ 
     482            (self.base_url+self.paths['path_yadis']+'/'+path[4:]) 
     483        disco_tags = link_tag + yadis_loc_tag 
     484        ident = self.base_url + path[1:] 
     485 
     486        approved_trust_roots = [] 
     487        for (aident, trust_root) in self.approved.keys(): 
     488            if aident == ident: 
     489                trs = '<li><tt>%s</tt></li>\n' % cgi.escape(trust_root) 
     490                approved_trust_roots.append(trs) 
     491 
     492        if approved_trust_roots: 
     493            prepend = '<p>Approved trust roots:</p>\n<ul>\n' 
     494            approved_trust_roots.insert(0, prepend) 
     495            approved_trust_roots.append('</ul>\n') 
     496            msg = ''.join(approved_trust_roots) 
     497        else: 
     498            msg = '' 
     499 
     500        self._showPage(200, 'An Identity Page',head_extras=disco_tags, msg='''\ 
     501        <p>This is an identity page for %s.</p> 
     502        %s 
     503        ''' % (ident, msg)) 
     504 
     505 
     506class RenderingInterface(object): 
     507    """Interface class for rendering of OpenID Provider pages.  Create a 
     508    derivative from this class to override the default look and feel and  
     509    behaviour of these pages.  Pass the new class name via the renderClass 
     510    keyword to OpenIDProviderMiddleware.__init__""" 
     511     
     512    def __init__(self, base_url, paths): 
     513        self.base_url = base_url 
     514        self.paths = paths 
     515        self.username = '' 
     516 
     517    def renderIdentityPage(self, environ): 
     518        """Render the identity page.""" 
     519        path = environ.get('PATH_INFO') 
     520         
     521        link_tag = '<link rel="openid.server" href="%s%s">' % \ 
     522              (self.base_url, self.paths['path_openidserver']) 
     523               
     524        yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">'%\ 
     525            (self.base_url+self.paths['path_yadis']+'/'+path[4:]) 
     526             
     527        disco_tags = link_tag + yadis_loc_tag 
     528        ident = self.base_url + path 
     529 
     530#        approved_trust_roots = [] 
     531#        for (aident, trust_root) in self.approved.keys(): 
     532#            if aident == ident: 
     533#                trs = '<li><tt>%s</tt></li>\n' % cgi.escape(trust_root) 
     534#                approved_trust_roots.append(trs) 
     535# 
     536#        if approved_trust_roots: 
     537#            prepend = '<p>Approved trust roots:</p>\n<ul>\n' 
     538#            approved_trust_roots.insert(0, prepend) 
     539#            approved_trust_roots.append('</ul>\n') 
     540#            msg = ''.join(approved_trust_roots) 
     541#        else: 
     542#            msg = '' 
     543        msg = '' 
     544        return self._showPage('Identity Page',  
     545                              head_extras=disco_tags,  
     546                              msg='''<p>This is the identity page for %s.</p> 
     547                                %s 
     548                                ''' % (ident, msg)) 
     549         
     550         
     551    def renderLogin(self, environ): 
     552        """Render the login form.""" 
     553        success_to, fail_to = (self.paths['path_mainpage'],)*2 
     554         
     555        return self._showPage('Login Page', form='''\ 
     556            <h2>Login</h2> 
     557            <form method="GET" action="%s"> 
     558              <input type="hidden" name="success_to" value="%s" /> 
     559              <input type="hidden" name="fail_to" value="%s" /> 
     560              <input type="text" name="username" value="" /> 
     561              <input type="submit" name="submit" value="Log In" /> 
     562              <input type="submit" name="cancel" value="Cancel" /> 
     563            </form> 
     564            ''' % (self.paths['path_loginsubmit'], success_to, fail_to)) 
     565 
     566 
     567    def renderMainPage(self, environ): 
     568        """Rendering the main page.""" 
     569         
     570        yadis_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
     571                    (self.base_url + self.paths['path_serveryadis']) 
     572             
     573        if self.username: 
     574            openid_url = self.base_url + self.paths['path_id'] + '/' + \ 
     575                        self.username 
     576            user_message = """\ 
     577            <p>You are logged in as %s. Your OpenID identity URL is 
     578            <tt><a href=%s>%s</a></tt>. Enter that URL at an OpenID 
     579            consumer to test this server.</p> 
     580            """ % (self.username, quoteattr(openid_url), openid_url) 
     581        else: 
     582            user_message = "<p>You are not <a href='%s'>logged in</a>.</p>" % \ 
     583                            self.paths['path_login'] 
     584 
     585        return self._showPage('Main Page', head_extras=yadis_tag, msg='''\ 
     586            <p>OpenID server</p> 
     587     
     588            %s 
     589     
     590            <p>The URL for this server is <a href=%s><tt>%s</tt></a>.</p> 
     591        ''' % (user_message, quoteattr(self.base_url), self.base_url)) 
     592     
     593    def renderDecidePage(self, environ, oidRequest): 
    473594        id_url_base = self.base_url+self.paths['path_id'] + '/' 
     595         
    474596        # XXX: This may break if there are any synonyms for id_url_base, 
    475597        # such as referring to it by IP address or a CNAME. 
    476598         
    477         # TODO: OpenID 2.0 Allows request.identity to be set to  
     599        # TODO: OpenID 2.0 Allows oidRequest.identity to be set to  
    478600        # http://specs.openid.net/auth/2.0/identifier_select.  See, 
    479601        # http://openid.net/specs/openid-authentication-2_0.html.  This code 
     
    481603        # which this is based.  - Check is the example code based on OpenID 1.0 
    482604        # and therefore wrong for this behaviour? 
    483 #        assert request.identity.startswith(id_url_base), \ 
    484 #               repr((request.identity, id_url_base)) 
    485         expected_user = request.identity[len(id_url_base):] 
    486  
    487         if request.idSelect(): # We are being asked to select an ID 
     605#        assert oidRequest.identity.startswith(id_url_base), \ 
     606#               repr((oidRequest.identity, id_url_base)) 
     607        expected_user = oidRequest.identity[len(id_url_base):] 
     608 
     609        if oidRequest.idSelect(): # We are being asked to select an ID 
    488610            msg = '''\ 
    489611            <p>A site has asked for your identity.  You may select an 
     
    497619                'path_allow': self.paths['path_allow'], 
    498620                'id_url_base': id_url_base, 
    499                 'trust_root': request.trust_root, 
     621                'trust_root': oidRequest.trust_root, 
    500622                } 
    501623            form = '''\ 
     
    515637            '''%fdata 
    516638             
    517         elif expected_user == self.user: 
     639        elif expected_user == self.username: 
    518640            msg = '''\ 
    519641            <p>A new site has asked to confirm your identity.  If you 
     
    525647            fdata = { 
    526648                'path_allow': self.paths['path_allow'], 
    527                 'identity': request.identity, 
    528                 'trust_root': request.trust_root, 
     649                'identity': oidRequest.identity, 
     650                'trust_root': oidRequest.trust_root, 
    529651                } 
    530652            form = '''\ 
     
    544666            mdata = { 
    545667                'expected_user': expected_user, 
    546                 'user': self.user, 
     668                'username': self.username, 
    547669                } 
    548670            msg = '''\ 
    549671            <p>A site has asked for an identity belonging to 
    550             %(expected_user)s, but you are logged in as %(user)s.  To 
    551             log in as %(expected_user)s and approve the login request, 
     672            %(expected_user)s, but you are logged in as %(username)s.  To 
     673            log in as %(expected_user)s and approve the login oidRequest, 
    552674            hit OK below.  The "Remember this decision" checkbox 
    553675            applies only to the trust root decision.</p>''' % mdata 
     
    555677            fdata = { 
    556678                'path_allow': self.paths['path_allow'], 
    557                 'identity': request.identity, 
    558                 'trust_root': request.trust_root, 
     679                'identity': oidRequest.identity, 
     680                'trust_root': oidRequest.trust_root, 
    559681                'expected_user': expected_user, 
    560682                } 
     
    575697 
    576698        return self._showPage('Approve OpenID request?', msg=msg, form=form) 
    577  
    578  
    579     def _showIdPage(self, path): 
    580         link_tag = '<link rel="openid.server" href="%sopenidserver">' %\ 
    581               self.base_url 
    582         yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">'%\ 
    583             (self.base_url+self.paths['path_yadis']+'/'+path[4:]) 
    584         disco_tags = link_tag + yadis_loc_tag 
    585         ident = self.base_url + path[1:] 
    586  
    587         approved_trust_roots = [] 
    588         for (aident, trust_root) in self.approved.keys(): 
    589             if aident == ident: 
    590                 trs = '<li><tt>%s</tt></li>\n' % cgi.escape(trust_root) 
    591                 approved_trust_roots.append(trs) 
    592  
    593         if approved_trust_roots: 
    594             prepend = '<p>Approved trust roots:</p>\n<ul>\n' 
    595             approved_trust_roots.insert(0, prepend) 
    596             approved_trust_roots.append('</ul>\n') 
    597             msg = ''.join(approved_trust_roots) 
    598         else: 
    599             msg = '' 
    600  
    601         self._showPage(200, 'An Identity Page',head_extras=disco_tags, msg='''\ 
    602         <p>This is an identity page for %s.</p> 
    603         %s 
    604         ''' % (ident, msg)) 
    605  
    606  
    607 class RenderingInterface(object): 
    608     """Interface class for rendering of OpenID Provider pages.  Create a 
    609     derivative from this class to override the default look and feel and  
    610     behaviour of these pages.  Pass the new class name via the renderClass 
    611     keyword to OpenIDProviderMiddleware.__init__""" 
    612      
    613     def __init__(self, base_url, paths): 
    614         self.base_url = base_url 
    615         self.paths = paths 
    616         self.user = '' 
    617  
    618     def renderIdentityPage(self): 
    619         """Render the identity page.""" 
    620  
    621         link_tag = '<link rel="openid.server" href="%s%s">' % \ 
    622               (self.base_url, self.paths['path_openidserver']) 
    623                
    624         yadis_loc_tag = '<meta http-equiv="x-xrds-location" content="%s">'%\ 
    625             (self.base_url+self.paths['path_yadis']+'/'+self.path[4:]) 
    626              
    627         disco_tags = link_tag + yadis_loc_tag 
    628         ident = self.base_url + self.path 
    629  
    630         approved_trust_roots = [] 
    631         for (aident, trust_root) in self.approved.keys(): 
    632             if aident == ident: 
    633                 trs = '<li><tt>%s</tt></li>\n' % cgi.escape(trust_root) 
    634                 approved_trust_roots.append(trs) 
    635  
    636         if approved_trust_roots: 
    637             prepend = '<p>Approved trust roots:</p>\n<ul>\n' 
    638             approved_trust_roots.insert(0, prepend) 
    639             approved_trust_roots.append('</ul>\n') 
    640             msg = ''.join(approved_trust_roots) 
    641         else: 
    642             msg = '' 
    643  
    644         response = self._showPage('An Identity Page',  
    645                               head_extras=disco_tags,  
    646                               msg='''<p>This is an identity page for %s.</p> 
    647                                 %s 
    648                                 ''' % (ident, msg)) 
    649          
    650          
    651     def renderLogin(self): 
    652         """Render the login form.""" 
    653         success_to, fail_to = (self.paths['path_mainpage'],)*2 
    654          
    655         return self._showPage('Login Page', form='''\ 
    656             <h2>Login</h2> 
    657             <form method="GET" action="%s"> 
    658               <input type="hidden" name="success_to" value="%s" /> 
    659               <input type="hidden" name="fail_to" value="%s" /> 
    660               <input type="text" name="user" value="" /> 
    661               <input type="submit" name="submit" value="Log In" /> 
    662               <input type="submit" name="cancel" value="Cancel" /> 
    663             </form> 
    664             ''' % (self.paths['path_loginsubmit'], success_to, fail_to)) 
    665  
    666  
    667     def renderMainPage(self): 
    668         """Rendering the main page.""" 
    669          
    670         yadis_tag = '<meta http-equiv="x-xrds-location" content="%s">' % \ 
    671                     (self.base_url + self.paths['path_serveryadis']) 
    672              
    673         if self.user: 
    674             openid_url = self.base_url + self.paths['path_id'] + '/' + \ 
    675                         self.user 
    676             user_message = """\ 
    677             <p>You are logged in as %s. Your OpenID identity URL is 
    678             <tt><a href=%s>%s</a></tt>. Enter that URL at an OpenID 
    679             consumer to test this server.</p> 
    680             """ % (self.user, quoteattr(openid_url), openid_url) 
    681         else: 
    682             user_message = "<p>You are not <a href='%s'>logged in</a>.</p>" % \ 
    683                             self.paths['path_login'] 
    684  
    685         return self._showPage('Main Page', head_extras=yadis_tag, msg='''\ 
    686             <p>OpenID server</p> 
    687      
    688             %s 
    689      
    690             <p>The URL for this server is <a href=%s><tt>%s</tt></a>.</p> 
    691         ''' % (user_message, quoteattr(self.base_url), self.base_url)) 
    692699         
    693700 
    694701    def _showPage(self, title, head_extras='', msg=None, err=None, form=None): 
    695702 
    696         if self.user is None: 
     703        if self.username is None: 
    697704            user_link = '<a href="/login">not logged in</a>.' 
    698705        else: 
     
    700707                        '<a href="%s?submit=true&'\ 
    701708                        'success_to=%s">Log out</a>' % \ 
    702                         (self.paths['path_id'], self.user, self.user,  
     709                        (self.paths['path_id'], self.username, self.username,  
    703710                         self.paths['path_loginsubmit'], 
    704711                         self.paths['path_login']) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionMgr/README

    r3199 r4120  
    3131should be set. 
    3232  
    33 3) Two test Attribute Authority services are required.  These can be run from  
     334) Two test Attribute Authority services are required.  These can be run from  
    3434the Attribute Authority unit test directory.  It's path relative to this  
    3535directory is ../attAuthority.   
     
    7070 $ openssl x509 -in  /etc/grid-security/certificates/abcdef01.0 -text 
    7171  
    72 4) Run the tests with the command: 
     725) Run the tests with the command: 
    7373 
    7474$ python ./test.py 
    7575 
    76 5) To run individual tests give the test method name: 
     766) To run individual tests give the test method name: 
    7777 
    7878$ python ./test.py SessionMgrTestCase.test1Connect 
     
    8282 * See the installation guide for MyProxy trouble shooting information. 
    8383 
     84Troubleshooting: 
     85 * http_proxy environment variable settings can cause connection problems to 
     86the Attribute Authorities.  unset http_proxy or set no_proxy: 
     87 
     88$ export no_proxy=http://localhost:5000/AttributeAuthority,http://localhost:5100/AttributeAuthority 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionMgr/test.py

    r3203 r4120  
    2828mkPath = lambda file: jnPath(os.environ['NDGSEC_SM_UNITTEST_DIR'], file) 
    2929 
     30import logging 
     31logging.basicConfig(level=logging.ERROR) 
     32 
    3033 
    3134class SessionMgrTestCase(unittest.TestCase): 
     
    8184        print "User '%s' connected to Session Manager:\n%s" % \ 
    8285                                                        (username, self.sessID) 
    83         creds='\n'.join((self.issuingCert or '',self.userCert,self.userPriKey)) 
     86        creds='\n'.join((self.issuingCert or '', 
     87                         self.userCert.asPEM().strip(), 
     88                         self.userPriKey)) 
    8489        open(mkPath("user.creds"), "w").write(creds) 
    8590     
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionMgrClient/SessionMgrClientTest.py

    r3652 r4120  
    169169                                                        (username, self.sessID) 
    170170             
    171         creds='\n'.join((self.issuingCert or '',self.userCert,self.userPriKey)) 
     171        creds='\n'.join((self.issuingCert or '', 
     172                         self.userCert, 
     173                         self.userPriKey)) 
    172174        open(mkPath("user.creds"), "w").write(creds) 
    173175             
Note: See TracChangeset for help on using the changeset viewer.