Changeset 546


Ignore:
Timestamp:
10/02/06 17:39:36 (14 years ago)
Author:
pjkersha
Message:

Session.py: SessionMgr?.readProperties - fixed conversion of environment
variables to file paths

SessionClient?.py:

  • fixed setting of and refs to smEncrPubKeyFilePath
  • fixed bug in setSMwsdl()

security.py: new working version - updated WS calls to use SessionClient?
class.

Location:
security/trunk/python
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • security/trunk/python/NDG/Session.py

    r543 r546  
    347347                                                dbPPhrase=credReposPPhrase) 
    348348            elif elem.tag in self.__validKeys: 
    349                 self.__prop[elem.tag] = elem.text 
    350                  
    351349                # Check for environment variables in file paths 
    352350                tagCaps = elem.tag.upper() 
    353351                if 'FILE' in tagCaps or 'PATH' in tagCaps or 'DIR' in tagCaps: 
    354352                    elem.text = os.path.expandvars(elem.text) 
     353                     
     354                self.__prop[elem.tag] = elem.text                 
    355355            else: 
    356356                raise SessionMgrError(\ 
  • security/trunk/python/NDG/SessionClient.py

    r541 r546  
    5050                                 give extra WS debug information""" 
    5151 
    52          
    53         self.__setSMwsdl(smWSDL) 
    54         self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
     52        if smWSDL: 
     53            self.__setSMwsdl(smWSDL) 
     54         
     55        if smEncrPubKeyFilePath: 
     56            self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
     57             
    5558        self.__traceFile = traceFile 
    56          
     59 
     60          
    5761        # Instantiate Session Manager WS proxy 
    5862        if self.__smWSDL: 
     
    7478    def __setSMencrPubKeyFilePath(self, smEncrPubKeyFilePath): 
    7579         
    76         if not isinstance(smWSDL, basestring): 
     80        if not isinstance(smEncrPubKeyFilePath, basestring): 
    7781            raise SessionClientError(\ 
    7882                "Session Manager public key file path must be a valid string") 
     
    210214                         extAttCertList=None, 
    211215                         extTrustedHostList=None, 
    212                          encrCert=None):     
     216                         encrCert=None, 
     217                         smEncrPubKeyFilePath=None):     
    213218        """Request authorisation from NDG Session Manager Web Service. 
    214219         
     
    246251            # Instantiate WS proxy 
    247252            self.serviceProxy(smWSDL) 
     253             
     254        if smEncrPubKeyFilePath: 
     255            self.__setSMencrPubKeyFilePath(smEncrPubKeyFilePath) 
    248256     
    249257             
     
    251259        try: 
    252260            authReq=AuthorisationReq(aaWSDL=aaWSDL, 
    253                                      sessID=sessID, 
    254                                      encrSessMgrWSDLuri=encrSessMgrWSDLuri, 
    255                                      reqRole=reqRole, 
    256                                      mapFromTrustedHosts=mapFromTrustedHosts, 
    257                                      extAttCertList=extAttCertList, 
    258                                      extTrustedHostList=extTrustedHostList, 
    259                                      encrCert=encrCert, 
    260                                      encrPubKeyFilePath=smEncrPubKeyFilePath)  
     261                             sessID=sessID, 
     262                             encrSessMgrWSDLuri=encrSessMgrWSDLuri, 
     263                             reqRole=reqRole, 
     264                             mapFromTrustedHosts=mapFromTrustedHosts, 
     265                             extAttCertList=extAttCertList, 
     266                             extTrustedHostList=extTrustedHostList, 
     267                             encrCert=encrCert, 
     268                             encrPubKeyFilePath=self.__smEncrPubKeyFilePath)  
    261269                                             
    262270            resp = self.__smSrv.reqAuthorisation(authorisationReq=authReq()) 
  • security/trunk/python/Tests/security.py

    r500 r546  
    2222from ZSI import ServiceProxy 
    2323 
    24 try: 
    25     from NDG.AttCert import * 
    26      
    27 except ImportError, e: 
    28     # Temporary Hack - try getting from development area instead 
    29     sys.path.append('/home/users/pjkersha/Development/security/python') 
    30     from NDG.AttCert import * 
     24from NDG.AttCert import * 
     25from NDG.SessionClient import * 
    3126 
    3227 
     
    5146                 userName=None, 
    5247                 passPhrase=None, 
     48                 smEncrPubKeyFilePath=None, 
    5349                 org=None): 
    5450        """Omit username, passphrase and org if running from CGI""" 
     
    5854        self.__userName = userName 
    5955        self.__passPhrase = passPhrase 
     56        self.__smEncrPubKeyFilePath = smEncrPubKeyFilePath 
     57 
    6058 
    6159        # Authenticating organisation 
     
    229227    <option>BODC</option> 
    230228    <option>PML</option> 
    231     <option>SOC</option> 
     229    <option>NOCS</option> 
    232230</td></tr> 
    233231<tr> 
     
    290288            # Instantiate WS proxy and request connection 
    291289            try: 
    292                 smSrv = ServiceProxy(self.__smWSDL, 
    293                                      use_wsdl=True, 
    294                                      tracefile=traceFile)                
    295  
    296                 resp = smSrv.addUser(userName=self.__userName, 
    297                                      passPhrase=self.__passPhrase) 
    298             except socket.error, e: 
     290                smClient = SessionClient( 
     291                        smWSDL=self.__smWSDL, 
     292                        smEncrPubKeyFilePath=self.__smEncrPubKeyFilePath, 
     293                        traceFile=traceFile) 
     294                         
     295 
     296                resp = smClient.addUser(userName=self.__userName, 
     297                                        pPhrase=self.__passPhrase) 
     298            except Exception, e: 
    299299                # Socket error returns tuple - reformat to just give msg 
    300                 raise SecurityCGIError(str(e[1])) 
     300                raise SecurityCGIError("Session Client: " + str(e)) 
    301301             
    302302            if resp['errMsg']: 
     
    359359            # Instantiate WS proxy and request connection 
    360360            try: 
    361                 smSrv = ServiceProxy(self.__smWSDL, 
    362                                      use_wsdl=True, 
    363                                      tracefile=traceFile) 
    364              
    365                 resp = smSrv.connect(userName=self.__userName, 
    366                                      passPhrase=self.__passPhrase, 
    367                                      rtnAsCookie=True)                 
    368             except socket.error, e: 
     361                smClient = SessionClient( 
     362                        smWSDL=self.__smWSDL, 
     363                        smEncrPubKeyFilePath=self.__smEncrPubKeyFilePath, 
     364                        traceFile=traceFile) 
     365 
     366                sessCookie = smClient.connect(userName=self.__userName, 
     367                                              pPhrase=self.__passPhrase)  
     368            except Exception, e: 
    369369                # Socket error returns tuple - reformat to just give msg 
    370                 raise SecurityCGIError(str(e[1])) 
    371  
    372             if resp['errMsg']: 
    373                 raise SecurityCGIError(str(resp['errMsg'])) 
    374  
    375             cookie = str(resp['cookie']) 
    376  
    377             if setCookie: 
    378                  
    379                 print \ 
     370                raise SecurityCGIError("Session client: " + str(e)) 
     371 
     372            print \ 
    380373"""Content-type: text/html 
    381374%s 
     
    391384    <p>User %s authenticated</p> 
    392385    <p>Cookie is: %s</p> 
    393 </body>""" % (cookie, self.__userName, cookie) 
    394  
    395             return cookie 
     386</body>""" % (sessCookie, self.__userName, sessCookie) 
     387            return sessCookie 
    396388         
    397389        except Exception, e: 
     
    449441        bSetCookie = False 
    450442         
     443                                
    451444        try: 
    452445            # Check for session ID input 
     
    454447                bSetCookie = True 
    455448 
    456                 # Get session ID from cookie 
    457                 sessID = SimpleCookie(cookie)['Hash'].value 
    458                  
     449            elif 'HTTP_COOKIE' not in os.environ: 
     450                # Check for session ID set in existing cookie 
     451                     
     452                # Re-display login screen 
     453                print "Content-type: text/html" + os.linesep                     
     454                self.showLogin(bAuthorise=True, 
     455                               bodyTag=True, 
     456                               heading="NDG User Authorisation (Test)") 
     457 
     458                return 
    459459            else: 
    460                 # Check for session ID set in existing cookie 
    461                 if 'HTTP_COOKIE' not in os.environ: 
    462                      
    463                     # Re-display login screen 
    464                     print "Content-type: text/html" + os.linesep                     
    465                     self.showLogin(bAuthorise=True, 
    466                                    bodyTag=True, 
    467                                    heading="NDG User Authorisation (Test)") 
    468  
    469                     return 
    470  
    471                 # Get session ID from existing cookie 
    472                 sessID = SimpleCookie(os.environ['HTTP_COOKIE'])['Hash'].value 
     460                cookie = os.environ['HTTP_COOKIE'] 
     461                 
     462                 
     463            # Get session ID from existing cookie 
     464            cookieObj = SimpleCookie(cookie) 
     465            if "NDG-ID1" not in cookieObj: 
     466                raise SecurityCGIError(\ 
     467                            'Expecting "NDG-ID1" ID for session cookie') 
     468                              
     469            if "NDG-ID2" not in cookieObj: 
     470                raise SecurityCGIError(\ 
     471                            'Expecting "NDG-ID2" ID for session cookie')  
    473472 
    474473 
     
    481480            # Instantiate WS proxy and request authorisation 
    482481            try: 
    483                 smSrv = ServiceProxy(self.__smWSDL, 
    484                                      use_wsdl=True, 
    485                                      tracefile=traceFile) 
    486  
    487                 resp = smSrv.reqAuthorisation(aaWSDL=self.__aaWSDL, 
    488                                     sessID=sessID, 
     482                smClient = SessionClient( 
     483                            smWSDL=self.__smWSDL, 
     484                            smEncrPubKeyFilePath=self.__smEncrPubKeyFilePath, 
     485                            traceFile=traceFile) 
     486 
     487                resp = smClient.reqAuthorisation(cookieObj["NDG-ID1"].value, 
     488                                    cookieObj["NDG-ID2"].value, 
     489                                    aaWSDL=self.__aaWSDL, 
    489490                                    reqRole=reqRole, 
    490491                                    mapFromTrustedHosts=bMapFromTrustedHosts, 
    491                                     extAttCertList='', 
    492492                                    extTrustedHostList=extTrustedHostList) 
    493             except socket.error, e: 
     493            except Exception, e: 
    494494                # Socket error returns tuple - reformat to just give msg 
    495                 raise SecurityCGIError(str(e[1])) 
     495                raise SecurityCGIError("Session client: " + str(e)) 
    496496 
    497497            if resp['statCode'] == 'AccessGranted': 
     
    503503                if not resp['extAttCertList']: 
    504504                    raise SecurityCGIError(str(resp['errMsg'])) 
    505                                             
    506                 # Convert from unicode 
    507                 extAttCertList = [str(attCert) \ 
    508                                   for attCert in resp['extAttCertList']] 
    509505 
    510506            elif resp['statCode'] == 'AccessError': 
     
    538534                      re.sub("<", "&lt;", re.sub(">", "&gt;", self.__attCert)) 
    539535                 
    540             elif extAttCertList: 
     536            elif 'extAttCertList' in resp: 
    541537                # Display available certificates from other AAs in a table 
    542                 self.showExtAttCertSelect(extAttCertList) 
     538                self.showExtAttCertSelect(resp['extAttCertList']) 
    543539                 
    544540            print "</body>"  
     
    703699if __name__ == "__main__": 
    704700     
     701    smWSDL = "http://glue.badc.rl.ac.uk/sessionMgr.wsdl" 
     702    aaWSDL = "http://glue.badc.rl.ac.uk/attAuthority.wsdl" 
     703    smPubKey = os.path.expandvars("/usr/local/NDG/conf/certs/badc-sm-cert.pem") 
     704     
    705705    # Instantiate and call CGI 
    706     security = SecurityCGI("http://glue.badc.rl.ac.uk/sessionMgr.wsdl", 
    707                            #"../html/sessionMgr.wsdl", 
    708                            "http://glue.badc.rl.ac.uk/attAuthority.wsdl") 
    709                            #"../html/attAuthority.wsdl") 
     706    security = SecurityCGI(smWSDL, aaWSDL, smEncrPubKeyFilePath=smPubKey) 
    710707    security.cgi() 
Note: See TracChangeset for help on using the changeset viewer.