Changeset 662


Ignore:
Timestamp:
06/03/06 18:03:41 (14 years ago)
Author:
pjkersha
Message:

padlock.gif, ndgCurrentlitRev.gif: images for security test CGI.

SessionClientTest?.py: added example using proxy certificate.

Session.py, SessionClient?.py, SessionMgrIO.py: ConnectReq? webClnt keyword
renamed getCookie to make more clear. New keyword createServerSess, allows
option for user session to be managed on the server side when using proxy
certificate as ID. This is the command line client case.

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

Legend:

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

    r661 r662  
    465465        one: 
    466466 
    467         connect([webClnt=True/False][, reqXMLtxt] 
    468                 |[, userName=u, pPhrase=p]|[, proxyCert=px]|[, sessID=id]) 
    469  
    470         webClnt:                If True, allocate a user session with a  
     467        connect([, reqXMLtxt=txt]| 
     468                [getCookie=True/False][createServerSess=Tue/False, ] 
     469                [, userName=u, pPhrase=p]|[, proxyCert=px]|[, sessID=id]) 
     470 
     471        getCookie:              If True, allocate a user session with a  
    471472                                wallet in the session manager and return a  
    472473                                cookie containing the new session ID  
     
    474475                                certificate only.  The client is then  
    475476                                responsible for Credential Wallet management. 
     477        createServerSess:       If set to True, the SessionMgr will create 
     478                                and manage a session for the user.  Nb. 
     479                                this flag is ignored and set to True if 
     480                                getCookie is set.  For command line case, 
     481                                where getCookie is False, it's possible 
     482                                to choose to have a client or server side 
     483                                session using this keyword. 
    476484        reqXMLtxt:              encrypted XML containing user credentials - 
    477485                                user name, pass-phrase or proxy cert etc 
     
    528536            # proxy certificate 
    529537             
    530             # What shopuld this return?? 
     538            # What should this return?? 
    531539            # PJK 20/12/05  
    532540            return self.__connect2UserSession(sessID=sessID,  
     
    536544            proxyCert = self.__delegateProxy(connectReqKeys['userName'],  
    537545                                             connectReqKeys['pPhrase']) 
    538                                         
    539             if 'webClnt' in connectReqKeys and connectReqKeys['webClnt']: 
    540                  
    541                 # Return session cookies 
    542                 sessCookie = self.__createUserSession(proxyCert) 
     546 
     547            bGetCookie = 'getCookie' in connectReqKeys and \ 
     548                                                connectReqKeys['getCookie'] 
     549                                                 
     550            bCreateServerSess = 'createServerSess' in connectReqKeys and \ 
     551                                            connectReqKeys['createServerSess'] 
     552                                             
     553            if bGetCookie or bCreateServerSess: 
     554                # Session Manager creates and manages user's session 
     555                userSess = self.__createUserSession(proxyCert) 
     556  
     557                                
     558            if bGetCookie: 
     559                 
     560                # Web browser client - Return session cookie 
     561                sessCookie = userSess.createCookie(self.encrSessMgrWSDLuri) 
    543562                 
    544563                try: 
     
    550569                        "Error formatting connect response: %s" % e)                
    551570            else: 
    552                 # Return proxy certificate 
     571                # NDG Command line client - Return proxy certificate 
    553572                try: 
    554573                    connectResp = ConnectResp(proxyCert=proxyCert, 
     
    586605    def __createUserSession(self, proxyCert): 
    587606        """Create a new user session from input user credentials        
    588         and return cookie text for setting in browser client 
     607        and return 
    589608         
    590609        """ 
     
    625644                self.__sessList.append(userSess) 
    626645 
    627             # Return session cookies text 
    628             return userSess.createCookie(self.encrSessMgrWSDLuri) 
     646            # Return new session 
     647            return userSess 
    629648         
    630649        except Exception, e: 
     
    660679            # User session not found with given ID 
    661680            raise SessionMgrError(\ 
    662                 "No user session found with ID: " + idKeys['sessID']) 
     681                "No user session found matching input session ID") 
    663682         
    664683        elif 'proxyCert' in idKeys: 
     
    677696            # User session not found with given proxy cert 
    678697            raise SessionMgrError(\ 
    679                     "No user session found with ID: " + idKeys['proxyCert']) 
     698                    "No user session found matching input proxy certificate") 
    680699        else: 
    681700            raise SessionMgrError(\ 
     
    771790 
    772791         
    773         # Decrypt the URI for where the user's session resides 
    774         userSessMgrWSDLuri = self.decryptSessMgrWSDLuri(\ 
     792        if 'encrSessMgrWSDLuri' in reqKeys: 
     793            # Decrypt the URI for where the user's session resides 
     794            userSessMgrWSDLuri = self.decryptSessMgrWSDLuri(\ 
    775795                                                reqKeys['encrSessMgrWSDLuri']) 
    776  
    777                                         
    778         # Check the address against the address of THIS Session Manager   
    779         if userSessMgrWSDLuri != self.__prop['sessMgrWSDLuri']: 
    780             # User session resides on another Session Manager - forward the 
    781             # request 
    782              
    783             # Instantiate WS proxy for remote session manager 
    784             try: 
    785                 smSrv = ServiceProxy(userSessMgrWSDLuri, use_wsdl=True) 
    786             except Exception, e: 
    787                 raise SessionMgrError(\ 
    788                     "Error initialising WS for \"%s\": %s\n\n%s" % \ 
    789                     (userSessMgrWSDLuri, e, traceFile.getvalue())) 
    790              
    791              
    792             # Call remote session manager's authorisation request method 
    793             # and return result to caller 
    794             # 
    795             # TODO: Message level encryption public key of target SessionMgr 
    796             # is needed here in order to be able to apply message level  
    797             # encryption.  Get from cookie?? 
    798             # 
    799             # P J Kershaw 02/03/06 
    800             try:     
    801                 # Format parsed request into a new request encrypted by the 
    802                 # target SessionMgr's public key 
    803                 redirectAuthReq = AuthorisationReq(\ 
    804                                     #encrPubKeyFilePath=userSessMgrPubKeyURI, 
    805                                     **dict(reqKeys.items())) 
    806                                      
    807                 # Call remote SessionMgr where users session lies 
    808                 redirectAuthResp = smSrv.reqAuthorisation(\ 
    809                                         authorisationReq=redirectAuthReq()) 
    810                
    811                 # Parse XML contained in response                   
    812                 resp = AuthorisationResp(\ 
    813                         xmlTxt=str(redirectAuthResp['authorisationResp'])) 
    814                 return resp 
    815              
    816             except Exception, e: 
    817                 raise SessionMgrError(\ 
    818                 "Error requesting authorisation for Session Manager %s: %s" %\ 
    819                 (userSessMgrWSDLuri, e)) 
    820  
    821              
    822         # User's session resides with THIS Session Manager ... 
     796     
     797                                            
     798            # Check the address against the address of THIS Session Manager   
     799            if userSessMgrWSDLuri != self.__prop['sessMgrWSDLuri']: 
     800                # User session resides on another Session Manager - forward the 
     801                # request 
     802                 
     803                # Instantiate WS proxy for remote session manager 
     804                try: 
     805                    smSrv = ServiceProxy(userSessMgrWSDLuri, use_wsdl=True) 
     806                except Exception, e: 
     807                    raise SessionMgrError(\ 
     808                        "Error initialising WS for \"%s\": %s" % \ 
     809                        (userSessMgrWSDLuri, e)) 
     810                 
     811                 
     812                # Call remote session manager's authorisation request method 
     813                # and return result to caller 
     814                # 
     815                # TODO: Message level encryption public key of target SessionMgr 
     816                # is needed here in order to be able to apply message level  
     817                # encryption.  Get from cookie?? 
     818                # 
     819                # P J Kershaw 02/03/06 
     820                try:     
     821                    # Format parsed request into a new request encrypted by the 
     822                    # target SessionMgr's public key 
     823                    redirectAuthReq = AuthorisationReq(\ 
     824                                        #encrPubKeyFilePath=userSessMgrPubKeyURI, 
     825                                        **dict(reqKeys.items())) 
     826                                         
     827                    # Call remote SessionMgr where users session lies 
     828                    redirectAuthResp = smSrv.reqAuthorisation(\ 
     829                                            authorisationReq=redirectAuthReq()) 
     830                   
     831                    # Parse XML contained in response                   
     832                    resp = AuthorisationResp(\ 
     833                            xmlTxt=str(redirectAuthResp['authorisationResp'])) 
     834                    return resp 
     835                 
     836                except Exception, e: 
     837                    raise SessionMgrError(\ 
     838                    "Error requesting authorisation for Session Manager %s: %s" %\ 
     839                    (userSessMgrWSDLuri, e)) 
     840             
     841        # User's session resides with THIS Session Manager / no encrypted 
     842        # WSDL address passed in (as in command line context for security) ... 
    823843 
    824844            
  • TI12-security/trunk/python/NDG/SessionClient.py

    r661 r662  
    157157                pPhrase=None, 
    158158                pPhraseFilePath=None, 
    159                 webClnt=True, 
     159                getCookie=True, 
     160                createServerSess=False, 
    160161                smWSDL=None, 
    161162                smEncrPubKeyFilePath=None): 
     
    165166        pPhrase:                 user's pass-phrase 
    166167        pPhraseFilePath:         a file containing the user's pass-phrase.   
    167                                  Use this as an alternative to pPhrase keyword 
    168         webClnt:                 If set to true, return a cookie to be set in  
     168                                 Use this as an alternative to pPhrase  
     169                                 keyword. 
     170                                  
     171        getCookie:               If set to true, return a cookie to be set in  
    169172                                 a web browser client.  Otherwise, return a  
    170                                  proxy certificate 
     173                                 proxy certificate. 
     174                                  
     175        createServerSess:        If set to True, the SessionMgr will create 
     176                                 and manage a session for the user but note, 
     177                                 this flag is ignored and set to True if 
     178                                 getCookie is set.   
     179                                  
     180                                 For command line case, where getCookie is  
     181                                 False, it's possible to choose to have a  
     182                                 client or server side session using this  
     183                                 keyword. 
     184                                  
    171185        smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
    172                                  will reset the Service Proxy 
     186                                 will reset the Service Proxy. 
     187                                  
    173188        smEncrPubKeyFilePath:    Public key of Session Manager used to encrypt 
    174189                                 the outgoing message if required""" 
     
    192207            connectReq = ConnectReq(userName=userName,  
    193208                            pPhrase=pPhrase, 
    194                             webClnt=webClnt, 
     209                            getCookie=getCookie, 
     210                            createServerSess=createServerSess, 
    195211                            encrPubKeyFilePath=self.__smEncrPubKeyFilePath)  
    196212     
     
    201217                raise Exception(connectResp['errMsg']) 
    202218             
    203             return connectResp['sessCookie'] 
    204              
     219            if 'sessCookie' in connectResp: 
     220                return connectResp['sessCookie'] 
     221             
     222            elif 'proxyCert' in connectResp: 
     223                return connectResp['proxyCert'] 
     224             
     225            else: 
     226               raise SessionClientError(\ 
     227               "Neither \"sessCookie\" or \"proxyCert\" found in response") 
     228                
    205229        except Exception, e: 
    206230            raise SessionClientError(\ 
     
    210234    #_________________________________________________________________________  
    211235    def reqAuthorisation(self, 
    212                          sessID, 
    213                          encrSessMgrWSDLuri, 
     236                         sessID=None, 
     237                         encrSessMgrWSDLuri=None, 
     238                         proxyCert=None, 
    214239                         smWSDL=None, 
    215240                         aaWSDL=None, 
     
    231256                               corresponds to a different Session Manager, it 
    232257                               will re-direct the request there. 
     258        proxyCert:             proxy certificate - use as ID instead of  
     259                               session ID + encrSessMgrWSDLuri in the case of 
     260                               command line client. 
    233261        smWSDL:                WSDL URI for Session Manager WS call this may 
    234262                               not be the same as the encrypted address in 
     
    269297                             sessID=sessID, 
    270298                             encrSessMgrWSDLuri=encrSessMgrWSDLuri, 
     299                             proxyCert=proxyCert, 
    271300                             reqRole=reqRole, 
    272301                             mapFromTrustedHosts=mapFromTrustedHosts, 
  • TI12-security/trunk/python/NDG/SessionMgrIO.py

    r661 r662  
    4848                    "proxyCert":         "", 
    4949                    "sessID":            "", 
    50                     "webClnt":           "", 
     50                    "getCookie":         "", 
     51                    "createServerSess":  "", 
    5152                    "encrCert":          ""    } 
    5253                         
     
    7879 
    7980 
     81    #_________________________________________________________________________ 
     82    def parseXML(self): 
     83        """Override base class implementation to include extra code 
     84        to parse extAttCertList tag""" 
     85         
     86        rootElem = super(self.__class__, self).parseXML(rtnRootElem=True) 
     87        self['getCookie'] = bool(int(self['getCookie'])) 
     88 
     89 
    8090#_____________________________________________________________________________ 
    8191class ConnectRespError(XMLMsgError):     
     
    218228    xmlTagTmpl = {  "sessID":                 "", 
    219229                    "encrSessMgrWSDLuri":     "", 
     230                    "proxyCert":              "", 
    220231                    "aaWSDL":                 "", 
    221232                    "reqRole":                "", 
     
    241252                                
    242253        # Check for encrypted text or valid credentials 
    243         if 'sessID' not in self or \ 
    244            'encrSessMgrWSDLuri' not in self or \ 
    245            'aaWSDL' not in self:             
     254        if 'sessID' not in self and 'encrSessMgrWSDLuri' not in self: 
     255            if 'proxyCert' not in self: 
     256                raise AuthorisationReqError(\ 
     257                "Authorisation request must include the credentials: " + \ 
     258                "\"sessID\" and \"encrSessMgrWSDLuri\" or " + \ 
     259                "\"proxyCert\"") 
     260                 
     261        if 'aaWSDL' not in self:             
    246262            raise AuthorisationReqError(\ 
    247                 "Authorisation request must include: \"sessID\", " + \ 
    248                 "\"encrSessMgrWSDLuri\" and \"aaWSDL\"") 
     263                "Authorisation request must include: \"aaWSDL\"") 
    249264 
    250265 
  • TI12-security/trunk/python/Tests/SessionClientTest.py

    r652 r662  
    3535        # Session Manager WSDL 
    3636        smWSDL = 'http://.../sessionMgr.wsdl' 
    37          
     37        #smWSDL = 'http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl' 
     38 
    3839        # Public key of session manager used to encrypt requests 
    3940        smEncrPubKeyFilePath = \ 
    4041            os.path.expandvars("$NDG_DIR/conf/certs/<name>-sm-cert.pem") 
     42        #smEncrPubKeyFilePath = None 
     43         
    4144        # 
    4245        # If no public key is set, requests will be made in clear text without 
     
    4548         
    4649        # User ID to register with NDG MyProxy OR an existing ID to connect 
     50        #userName = 'gabriel' 
    4751        userName = 'a.n.other@somewhere.ac.uk' 
    4852 
    4953        # Initialise the Session Manager client connection 
    50         # Nb. Include traceFile keyword to print SOAP debug info 
     54        # Omit traceFile keyword to leave out SOAP debug info 
    5155        sessClnt = SessionClient(smWSDL=smWSDL, 
    52                                  smEncrPubKeyFilePath=smEncrPubKeyFilePath)#, 
    53 #                                 traceFile=sys.stderr) 
     56                                 smEncrPubKeyFilePath=smEncrPubKeyFilePath, 
     57                                 traceFile=sys.stderr) 
    5458 
    5559        # Uncomment to add a new user ID to the MyProxy repository 
    5660        # Note the pass-phrase is read from the file tmp.txt.  To pass 
    5761        # explicitly as a string use the 'pPhrase' keyword instead 
    58 #        sessClnt.addUser(userName, pPhraseFilePath="tmp.txt") 
     62#        sessClnt.addUser(userName, pPhraseFilePath="./tmp") 
    5963#        print "Added user '%s'" % userName 
    60  
     64         
    6165        # Connect using an existing user ID or using the one just created  
    6266        # above 
    6367        # 
    6468        # Connect as if acting as a browser client - a cookie is returned 
    65 #        sSessCookie = sessClnt.connect(userName, pPhraseFilePath="tmp.txt") 
     69#        sSessCookie = sessClnt.connect(userName, pPhraseFilePath="./tmp") 
    6670#        sessCookie = SimpleCookie(sSessCookie) 
    6771#        print "User '%s' connected to Session Manager" % userName 
     72# 
     73#        # Request an attribute certificate from an Attribute Authority using  
     74#        # the cookie returned from connect() 
     75#        authResp = sessClnt.reqAuthorisation( 
     76#                            sessID=sessCookie['NDG-ID1'].value,  
     77#                            encrSessMgrWSDLuri=sessCookie['NDG-ID2'].value, 
     78#                            aaWSDL=aaWSDL) 
     79 
     80        proxyCert = sessClnt.connect(userName,  
     81                                     pPhraseFilePath="./tmp", 
     82                                     createServerSess=True, 
     83                                     getCookie=False) 
     84        print "User '%s' connected to Session Manager" % userName 
    6885 
    6986        # Request an attribute certificate from an Attribute Authority using  
    7087        # the cookie returned from connect() 
    71 #        authResp = sessClnt.reqAuthorisation(sessCookie['NDG-ID1'].value,  
    72 #                                             sessCookie['NDG-ID2'].value, 
    73 #                                             aaWSDL=aaWSDL) 
     88        authResp = sessClnt.reqAuthorisation(proxyCert=proxyCert, 
     89                                             aaWSDL=aaWSDL) 
     90                                              
    7491        # The authorisation response is returned as an object which behaves 
    7592        # like a python dictionary.  See NDG.SessionMgrIO.AuthorisationResp 
    76 #        print "User '%s' authorised:\n" % userName 
    77 #        print authResp 
     93        if 'errMsg' in authResp: 
     94            print "Authorisation failed for user '%s':\n" % userName             
     95        else: 
     96            print "User '%s' authorised:\n" % userName 
     97             
     98        print authResp 
    7899        sys.exit(0) 
    79100         
Note: See TracChangeset for help on using the changeset viewer.