Changeset 701 for TI12-security


Ignore:
Timestamp:
23/03/06 17:46:28 (14 years ago)
Author:
pjkersha
Message:

ndgSessionClient.py:

  • Added options to pass in client's private key file and protecting password.

XMLMsg.py:

  • Modified logic for init: if text is passed via xmlTxt keyword and a private key file has

been set (encrPriKeyFilePath) attempt to decrypt using the key.

  • New encrypt and decrypt methods
  • Added xmlTags property - returns XML tags as a dictionary

XMLSecDoc.py:

  • Minor typo fix.

SessionClient?.py:

  • Session Manager public key can now be passed as a local file or remote over HTTP.
  • clntPriKeyFilePath keyword allows private key file to be passed for decrypting response

from Session Manager

  • clntPriKeyPwd - client private key password is required for all methods: addUser, connect

and reqAuthorisation.

sessionMgr_services_server.py: moved encryption/decryption of messages into SOAP callback
methods from where they were in their equivalent methods in Session.SessionMgr?.

Session.py:s

  • removed decryption code from SessionMgr? methods - addUser, coonect, reqAuthorisation.
  • See note above.
  • Fixes to redirectAuthorisationReq(). This method handles redirection to another

Session Manager if user session is held their.

Location:
TI12-security/trunk/python
Files:
6 edited

Legend:

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

    r687 r701  
    5353from cStringIO import StringIO 
    5454 
    55 # Use in SessionMgr __redirectAuthorisationReq to store Public key 
     55# Use in SessionMgr __redirectAuthorisationReq to retrieve and store Public  
     56# key 
    5657import tempfile 
    57  
     58import urllib 
    5859 
    5960#_____________________________________________________________________________ 
     
    520521                # Only update other keys if they are not None or "" 
    521522                if value: 
    522                     self.__prop[key] = value 
    523                  
     523                    self.__prop[key] = value                 
    524524            else: 
    525525                raise SessionMgrError(\ 
     
    529529 
    530530    #_________________________________________________________________________ 
    531     def addUser(self,  
    532                 caConfigFilePath=None, 
    533                 caPassPhrase=None, 
    534                 reqXMLtxt=None,  
    535                 **addUserReqKeys):         
     531    def addUser(self, caConfigFilePath=None, caPassPhrase=None, **reqKeys):         
    536532        """Register a new user with NDG data centre 
    537533         
    538         addUser([caConfigFilePath, ]|[, caPassPhrase][, reqXMLtxt] 
     534        addUser([caConfigFilePath, ]|[, caPassPhrase] 
    539535                |[, userName=u, pPhrase=p]) 
    540536 
     
    552548                                        passphrase is required. 
    553549                                         
    554         reqXMLtxt:                      XML containing credentials - may be  
    555                                         encrypted or plain text 
    556                                         for new user: username, pass-phrase 
    557         addUserReqKeys:                 use as alternative to  
     550        **reqKeys:                      use as alternative to  
    558551                                        reqXMLtxt keyword - pass in  
    559552                                        username and pass-phrase for new user  
    560553                                        unencrypted as keywords username 
    561                                         and pPhrase respectively.""" 
    562          
    563  
    564         if reqXMLtxt is not None: 
    565             if not isinstance(reqXMLtxt, basestring): 
    566                 raise SessionMgrError(\ 
    567                     "New user credentials must be a string") 
    568                                         
    569             try: 
    570                 # Assume text was input encrypted 
    571                 # 
    572                 # UserReq object returned behaves like a dictionary 
    573                 addUserReqKeys = AddUserReq(encrXMLtxt=reqXMLtxt, 
    574                                     encrPriKeyFilePath=self.__prop['keyFile'], 
    575                                     encrPriKeyPwd=self.__prop['keyPPhrase']) 
    576             except: 
    577                 try: 
    578                     # Check for plain text input 
    579                     addUserReqKeys = AddUserReq(xmlTxt=reqXMLtxt) 
    580                                      
    581                 except Exception, e: 
    582                     raise SessionMgrError(\ 
    583                         "Error parsing user credentials: %s" % e) 
    584          
     554                                        and pPhrase respectively.  See 
     555                                        SessionMgrIO.AddUserRequest class for 
     556                                        reference.""" 
     557               
    585558        try: 
    586559            # Add new user certificate to MyProxy Repository 
    587             user = self.__myPx.addUser(addUserReqKeys['userName'], 
    588                                        addUserReqKeys['pPhrase'], 
     560            user = self.__myPx.addUser(reqKeys['userName'], 
     561                                       reqKeys['pPhrase'], 
    589562                                       caConfigFilePath=caConfigFilePath, 
    590563                                       caPassPhrase=caPassPhrase, 
     
    592565             
    593566            # Add to user database 
    594             self.__credRepos.addUser(addUserReqKeys['userName'], user['dn']) 
    595              
    596         except Exception, e: 
    597             raise SessionMgrError("%s" % e) 
    598  
    599  
    600         return str(AddUserResp(errMsg='')) 
     567            self.__credRepos.addUser(reqKeys['userName'], user['dn']) 
     568             
     569        except Exception, e: 
     570            raise AddUserResp(errMsg=str(e)) 
     571 
     572        return AddUserResp(errMsg='') 
    601573     
    602574     
    603575    #_________________________________________________________________________         
    604     def connect(self, reqXMLtxt=None, **connectReqKeys):         
    605         """Create and return a new user session or connect to an existing 
    606         one: 
    607  
    608         connect([, reqXMLtxt=txt]| 
    609                 [getCookie=True/False][createServerSess=Tue/False, ] 
     576    def connect(self, **reqKeys):         
     577        """Create a new user session or connect to an existing one: 
     578 
     579        connect([getCookie=True/False][createServerSess=Tue/False, ] 
    610580                [, userName=u, pPhrase=p]|[, proxyCert=px]|[, sessID=id]) 
    611581 
     
    625595        reqXMLtxt:              encrypted XML containing user credentials - 
    626596                                user name, pass-phrase or proxy cert etc 
    627         connectReqKeys:         username and pass-phrase or the proxy  
    628                                 certificate or browser session ID  
    629                                 corresponding to an existing session""" 
    630          
    631  
    632         if reqXMLtxt is not None: 
    633             if not isinstance(reqXMLtxt, basestring): 
    634                 raise SessionMgrError(\ 
    635                     "Encrypted user credentials must be a string") 
    636                                         
    637             # Decrypt and parse 
    638             try: 
    639                 # Connect request object returned behaves like a dictionary 
    640                 connectReqKeys = ConnectReq(encrXMLtxt=reqXMLtxt, 
    641                                     encrPriKeyFilePath=self.__prop['keyFile'], 
    642                                     encrPriKeyPwd=self.__prop['keyPPhrase']) 
    643             except: 
    644                 try: 
    645                     connectReqKeys = ConnectReq(xmlTxt=reqXMLtxt) 
    646                      
    647                 except Exception, e: 
    648                     raise SessionMgrError(\ 
    649                         "Error parsing user credentials: %s" % e) 
    650  
    651          
    652             if 'encrCert' in connectReqKeys: 
    653                 # ConnectResp class expects the public key to be in a file 
    654                 # - Copy public key string content into a temporary file 
    655                 try: 
    656                     fdPubKeyTmp = NamedTemporaryFile() 
    657                     open(fdPubKeyTmp.name).write(connectReqKeys['encrCert']) 
    658                      
    659                     clntPubKeyFilePath = fdPubKeyTmp.name 
    660                      
    661                 except Exception, e: 
    662                     raise SessionMgrError(\ 
    663                     "Error creating temporary file for client public key: %s"\ 
    664                         % e) 
    665             else: 
    666                 clntPubKeyFilePath = None 
    667  
    668                                            
    669         if 'sessID' in connectReqKeys: 
    670              
    671             # Connect to an existing session identified by a session ID 
     597        reqKeys:                username and pass-phrase or the proxy""" 
     598         
     599 
     600        if 'sessID' in reqKeys: 
     601             
     602            # Connect to an existing session identified by a session ID and  
     603            # return equivalent proxy cert 
    672604            userSess = self.__connect2UserSession(sessID=sessID) 
    673             return userSess.credWallet.proxyCertTxt 
    674          
    675         elif 'proxyCert' in connectReqKeys: 
    676             # Connect to an existing session identified by a session ID or  
    677             # proxy certificate 
    678              
    679             # What should this return?? 
    680             # PJK 20/12/05  
    681             return self.__connect2UserSession(sessID=sessID,  
    682                                               proxyCert=proxyCert) 
     605            return ConnectResp(proxyCert=userSess.credWallet.proxyCertTxt) 
     606         
     607        elif 'proxyCert' in reqKeys: 
     608            # Connect to an existing session identified by a proxy  
     609            # certificate and return an equivalent session cookie 
     610            userSess = self.__connect2UserSession(proxyCert=proxyCert) 
     611            sessCookie = userSess.createCookie(self.__prop['sessMgrWSDLuri'], 
     612                                           self.__prop['sessMgrPubKeyURI'], 
     613                                           self.__prop['sessMgrEncrKey']) 
     614            return ConnectResp(sessCookie=sessCookie) 
     615         
    683616        else: 
    684617            # Create a fresh session 
    685             proxyCert = self.__delegateProxy(connectReqKeys['userName'],  
    686                                              connectReqKeys['pPhrase']) 
    687  
    688             bGetCookie = 'getCookie' in connectReqKeys and \ 
    689                                                 connectReqKeys['getCookie'] 
     618            proxyCert = self.__delegateProxy(reqKeys['userName'],  
     619                                             reqKeys['pPhrase']) 
     620 
     621            bGetCookie = 'getCookie' in reqKeys and reqKeys['getCookie'] 
    690622                                                 
    691             bCreateServerSess = 'createServerSess' in connectReqKeys and \ 
    692                                             connectReqKeys['createServerSess'] 
     623            bCreateServerSess = 'createServerSess' in reqKeys and \ 
     624                                            reqKeys['createServerSess'] 
    693625                                             
    694626            if bGetCookie or bCreateServerSess: 
     
    708640                try: 
    709641                    # Encrypt response if a client public key is available 
    710                     connectResp = ConnectResp(sessCookie=sessCookie, 
    711                                       encrPubKeyFilePath=clntPubKeyFilePath) 
     642                    return ConnectResp(sessCookie=sessCookie) 
     643                 
    712644                except Exception, e: 
    713645                    raise SessionMgrError(\ 
     
    715647            else: 
    716648                # NDG Command line client - Return proxy certificate 
    717                 try: 
    718                     connectResp = ConnectResp(proxyCert=proxyCert, 
    719                                       encrPubKeyFilePath=clntPubKeyFilePath) 
    720                 except Exception, e: 
    721                     raise SessionMgrError(\ 
    722                         "Error formatting connect response: %s" % e) 
    723                  
    724             # Return connection response as XML formatted string 
    725             return str(connectResp) 
     649                return ConnectResp(proxyCert=proxyCert) 
    726650             
    727651                 
     
    849773 
    850774    #_________________________________________________________________________ 
    851     def reqAuthorisation(self, reqXMLtxt=None, **reqKeys): 
     775    def reqAuthorisation(self, **reqKeys): 
    852776        """For given sessID, request authorisation from an Attribute Authority 
    853777        given by aaWSDL.  If sucessful, an attribute certificate is 
    854778        returned. 
    855779 
    856         reqXMLtxt:            pass formatted XML request - see SessionMgrIO 
    857                               AuthorisationReq class for details 
    858         **reqKeys:            pass equivalent to XML as keywords instead 
     780        **reqKeys:            pass equivalent to XML as keywords instead. 
     781                              See SessionMgrIO.AuthorisationReq class 
    859782        """ 
    860          
    861         # Parse XML text into keywords corresponding to the input parameters 
    862         if reqXMLtxt: 
    863             try: 
    864                 reqKeys = AuthorisationReq(xmlTxt=reqXMLtxt, 
    865                                     encrPriKeyFilePath=self.__prop['keyFile'], 
    866                                     encrPriKeyPwd=self.__prop['keyPPhrase']) 
    867             except Exception, e: 
    868                 raise SessionMgrError(\ 
    869                             "Error parsing authorisation request: " + str(e)) 
    870  
    871783         
    872784        # Web browser client input will include the encrypted address of the 
     
    881793            # Check the address against the address of THIS Session Manager   
    882794            if userSessMgrWSDLuri != self.__prop['sessMgrWSDLuri']: 
     795                 
    883796                # Session is held on a remote Session  Manager 
    884                 return self.__redirectAuthorisationReq() 
     797                return self.__redirectAuthorisationReq(userSessMgrWSDLuri, 
     798                                                       **reqKeys) 
    885799 
    886800             
     
    909823        # Nb. the following keys aren't required 
    910824        delKeys = ('proxyCert', 
    911                    'sessID',  
     825                   'sessID', 
     826                   'encrCert', 
    912827                   'encrSessMgrWSDLuri',  
    913828                   'encrSessMgrPubKeyURI') 
     
    920835            aaKeys['caCertFilePath'] = self.__prop['caCertFile'] 
    921836 
    922  
    923         # Check to see if the client passed a public key to encrypt the  
    924         # response message 
    925         if 'encrCert' in reqKeys: 
    926             # AuthorisationResp class expects the public key to be in a file 
    927             # - Copy public key string content into a temporary file 
    928             try: 
    929                 fdPubKeyTmp = NamedTemporaryFile() 
    930                 open(fdPubKeyTmp.name).write(reqKeys['encrCert']) 
    931                  
    932                 clntPubKeyFilePath = fdPubKeyTmp.name 
    933                  
    934             except Exception, e: 
    935                 raise SessionMgrError(\ 
    936                 "Error creating temporary file for client public key: %s"\ 
    937                     % e) 
    938         else: 
    939             # No client public key passed 
    940             clntPubKeyFilePath = None 
    941  
    942837             
    943838        # User's Credential Wallet carries out authorisation request to the 
     
    949844            # allow dictionary-like access to XML tags 
    950845            resp = AuthorisationResp(attCert=attCert,  
    951                                      statCode=AuthorisationResp.accessGranted, 
    952                                      encrPubKeyFilePath=clntPubKeyFilePath) 
     846                                     statCode=AuthorisationResp.accessGranted) 
    953847             
    954848        except CredWalletAuthorisationDenied, e: 
     
    958852            resp = AuthorisationResp(extAttCertList=e.extAttCertList, 
    959853                                     statCode=AuthorisationResp.accessDenied, 
    960                                      errMsg=str(e), 
    961                                      encrPubKeyFilePath=clntPubKeyFilePath) 
     854                                     errMsg=str(e)) 
    962855         
    963856        except Exception, e: 
     
    965858            # response 
    966859            resp = AuthorisationResp(statCode=AuthorisationResp.accessError, 
    967                                      errMsg=str(e), 
    968                                      encrPubKeyFilePath=clntPubKeyFilePath) 
     860                                     errMsg=str(e)) 
    969861     
    970862        return resp 
     
    972864 
    973865    #_________________________________________________________________________ 
    974     def __redirectAuthorisationReq(self): 
     866    def __redirectAuthorisationReq(self, userSessMgrWSDLuri, **reqKeys): 
    975867        """Handle case where User session resides on another Session Manager - 
    976868        forward the request""" 
     
    979871        try: 
    980872            smSrv = ServiceProxy(userSessMgrWSDLuri, use_wsdl=True) 
     873             
    981874        except Exception, e: 
    982875            raise SessionMgrError("Error initialising WS for \"%s\": %s" % \ 
     
    1012905        # remote Session Manager can use it to encrypt its reply 
    1013906        try: 
    1014             encrCert = open(self.__prop['certFile']).read() 
     907            reqKeys['encrCert'] = open(self.__prop['certFile']).read() 
    1015908             
    1016909        except IOError, (errNo, errMsg): 
    1017910            raise SessionMgrError(\ 
    1018                 "Reading Session Manager public key \"%s\": %s" % \ 
    1019                 (self.__prop['certFile'], errMsg)) 
    1020                  
    1021         except Exception, e: 
    1022             raise SessionMgrError(\ 
    1023                             "Reading Session Manager public key: " + str(e)) 
     911                        "Reading Session Manager public key \"%s\": %s" % \ 
     912                        (self.__prop['certFile'], errMsg)) 
     913                 
     914        except Exception, e: 
     915            raise SessionMgrError("Reading Session Manager public key: " + \ 
     916                                  str(e)) 
    1024917 
    1025918             
     
    1031924            redirectAuthReq = AuthorisationReq(\ 
    1032925                                    encrPubKeyFilePath=userSessMgrPubKey.name, 
    1033                                     encrCert=encrCert, 
    1034                                     **dict(reqKeys.items())) 
     926                                    **reqKeys) 
    1035927                                 
    1036928            # Call remote SessionMgr where users session lies 
     
    1040932            # Decrypt and parse XML contained in response                   
    1041933            resp = AuthorisationResp(\ 
    1042                         encrXMLtxt=str(redirectAuthResp['authorisationResp']), 
    1043                         encrPriKeyFilePath=self.__prop['keyFile'], 
    1044                         encrPriKeyPwd=self.__prop['keyPPhrase']) 
     934                            encrXMLtxt=redirectAuthResp['authorisationResp'], 
     935                            encrPriKeyFilePath=self.__prop['keyFile'], 
     936                            encrPriKeyPwd=self.__prop['keyPPhrase']) 
    1045937            return resp 
    1046938         
  • TI12-security/trunk/python/NDG/SessionClient.py

    r687 r701  
    2323from SessionMgrIO import * 
    2424 
     25# Handle retrieval of public key cert for Session Manager at remote location 
    2526import tempfile 
    26  
     27import urllib 
    2728 
    2829#_____________________________________________________________________________ 
     
    4344    def __init__(self,  
    4445                 smWSDL=None,  
    45                  smPubKeyFilePath=None, 
    4646                 smPubKeyURI=None, 
    4747                 clntPubKeyFilePath=None, 
     48                 clntPriKeyFilePath=None, 
    4849                 traceFile=None): 
    4950        """ 
    5051        smWSDL:                  WSDL URI for Session Manager WS.  Setting it  
    5152                                 will set the Service Proxy 
    52         smPubKeyFilePath|smPubKeyURI:     
     53        smPubKeyURI:     
    5354                                 Public key of Session Manager used to encrypt 
    5455                                 the outgoing message if required - set as a 
     
    5859                                 responses.  WARNING: if not set, responses 
    5960                                 are returned as clear text 
     61        clntPriKeyFilePath:      Private key of client.  If clntPubKeyFilePath 
     62                                 is set, the private key is needed to decrypt  
     63                                 the response from the Session Manager 
    6064        traceFile:               set to file object such as sys.stderr to  
    6165                                 give extra WS debug information""" 
     
    6569        self.__smPubKeyURI = None 
    6670        self.__clntPubKeyFilePath = None 
     71        self.__clntPubKey = None 
     72        self.__clntPriKeyFilePath = None 
     73         
     74        self.__smPubKeyTempFile = None 
     75         
    6776         
    6877        if smWSDL: 
    6978            self.__setSMwsdl(smWSDL) 
    7079             
    71         if smPubKeyFilePath: 
    72             self.__setSMpubKeyFilePath(smPubKeyFilePath) 
    73              
    74         elif smPubKeyURI: 
     80        if smPubKeyURI: 
    7581            self.__setSMpubKeyURI(smPubKeyURI) 
    7682             
     83        if clntPriKeyFilePath: 
     84            self.__setClntPriKeyFilePath(clntPriKeyFilePath) 
     85             
    7786        if clntPubKeyFilePath: 
     87            if clntPriKeyFilePath is None: 
     88                raise SessionClientError(\ 
     89                    "A Client private key file is required as well a " + \ 
     90                    "public key") 
     91                     
    7892            self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
    79              
     93 
     94            
    8095        self.__traceFile = traceFile 
    8196 
     
    96111         
    97112    smWSDL = property(fset=__setSMwsdl, doc="Set Session Manager WSDL URI") 
    98                        
    99      
    100     #_________________________________________________________________________ 
    101     def __setSMpubKeyFilePath(self, smPubKeyFilePath): 
    102          
    103         if not isinstance(smPubKeyFilePath, basestring): 
    104             raise SessionClientError(\ 
    105                 "Session Manager public key file path must be a valid string") 
    106          
    107         self.__smPubKeyFilePath = smPubKeyFilePath 
    108         self.__smPubKeyURI = None 
    109          
    110     smPubKeyFilePath = property(fset=__setSMpubKeyFilePath, 
    111                             doc="Set Session Manager public key file path") 
    112113 
    113114 
     
    134135         
    135136        self.__clntPubKeyFilePath = clntPubKeyFilePath 
     137        try: 
     138            self.__clntPubKey = open(self.__clntPubKeyFilePath).read() 
     139             
     140        except IOError, (errNo, errMsg): 
     141            raise optparse.OptionValueError(\ 
     142                    "Reading certificate file \"%s\": %s" % (value, errMsg)) 
     143                                
     144        except Exception, e: 
     145            raise optparse.OptionValueError(\ 
     146                    "Reading certificate file \"%s\": %s" % (value, str(e))) 
    136147         
    137148    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
    138149                                  doc="File path for client public key") 
    139150 
    140  
    141     #_________________________________________________________________________ 
    142     def __retrieveSMpubKeyFromURI(self): 
     151  
     152    #_________________________________________________________________________ 
     153    def __setClntPriKeyFilePath(self, clntPriKeyFilePath): 
     154         
     155        if not isinstance(clntPriKeyFilePath, basestring): 
     156            raise SessionClientError(\ 
     157                "Client public key file path must be a valid string") 
     158         
     159        self.__clntPriKeyFilePath = clntPriKeyFilePath 
     160         
     161    clntPriKeyFilePath = property(fset=__setClntPriKeyFilePath, 
     162                                  doc="File path for client private key") 
     163 
     164 
     165    #_________________________________________________________________________ 
     166    def __convSMpubKeyURI2File(self): 
    143167        """Retrieve the public key from the URI""" 
    144168         
     
    146170        # smPubKeyFilePath instead 
    147171        if self.__smPubKeyURI is None: 
    148             return None 
     172            return 
     173         
     174        # If no http prefix, assume a local file 
     175        if self.__smPubKeyURI[:5] != "http:": 
     176            self.__smPubKeyFilePath = self.__smPubKeyURI 
     177            return 
    149178         
    150179        try: 
    151             smPubKey = tempfile.NamedTemporaryFile() 
    152             (fileName, httpResp) = urllib.urlretrieve(smMgrPubKeyURI, 
    153                                                       smMgrPubKey.name) 
     180            self.__smPubKeyTempFile = tempfile.NamedTemporaryFile() 
     181             
     182            (self.__smPubKeyFilePath, httpResp) = \ 
     183                            urllib.urlretrieve(self.__smPubKeyURI, 
     184                                               self.__smPubKeyTempFile.name) 
     185                                           
    154186        except Exception, e: 
    155187            raise SessionClientError("Error retrieving Session Manager "+\ 
    156188                                     "public key from \"%s\": %s" % \ 
    157                                      (self.__smPubkeyURI, str(e))) 
     189                                     (self.__smPubKeyURI, str(e))) 
    158190 
    159191        # Expecting plain text format for returned public key file 
     
    162194            raise SessionClientError("Error retrieving Session Manager "+\ 
    163195                "public key from \"%s\": expecting \"plain/text\"" % \ 
    164                 self.__smPubkeyURI) 
    165               
    166         # Return tempfile object as otherwise it will go out of scope and the  
    167         # temporary file will be deleted    
    168         return smPubKey 
     196                self.__smPubKeyURI) 
    169197     
    170198         
     
    187215                userName, 
    188216                pPhrase=None, 
    189                 pPhraseFilePath=None): 
     217                pPhraseFilePath=None, 
     218                clntPriKeyPwd=None): 
    190219        """Register a new user 
    191220         
     
    194223        pPhraseFilePath:         a file containing the user's pass-phrase.   
    195224                                 Use this as an alternative to pPhrase keyword 
     225        clntPriKeyPwd:           pass-phrase if any for the client's private 
     226                                 key used to decrypt response from 
     227                                 Session Manager 
    196228        """ 
    197229     
     
    204236 
    205237 
    206         # If Public key was set by URI, retrieve otherwise get from  
    207         # smPubKeyFilePath 
    208         smPubKeyTmpFile = self.__retrieveSMpubKeyFromURI() 
    209         if smPubKeyTmpFile: 
    210             smPubKeyFilePath = smPubKeyTmpFile.name 
    211         else: 
    212             smPubKeyFilePath = self.__smPubKeyFilePath  
     238        # If Public key was set by URI, retrieve to local temp file 
     239        self.__convSMpubKeyURI2File() 
    213240             
    214241     
     
    216243        try:    
    217244            addUserReq = AddUserReq(userName=userName,  
    218                                     pPhrase=pPhrase, 
    219                                     encrCert=self.__clntPubKeyFilePath, 
    220                                     encrPubKeyFilePath=smPubKeyFilePath)  
     245                                pPhrase=pPhrase, 
     246                                encrCert=self.__clntPubKey, 
     247                                encrPubKeyFilePath=self.__smPubKeyFilePath)  
    221248 
    222249            # Pass encrypted request 
    223             resp = self.__smSrv.addUser(addUserReq=addUserReq())             
    224             addUserResp = AddUserResp(xmlTxt=str(resp['addUserResp'])) 
     250            resp = self.__smSrv.addUser(addUserReq=addUserReq()) 
     251                         
     252            addUserResp = AddUserResp(xmlTxt=resp['addUserResp'], 
     253                                encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     254                                encrPriKeyPwd=clntPriKeyPwd) 
     255                             
    225256            if 'errMsg' in addUserResp and addUserResp['errMsg']: 
    226257                raise SessionClientError(addUserResp['errMsg']) 
     
    236267                pPhraseFilePath=None, 
    237268                getCookie=True, 
    238                 createServerSess=False): 
     269                createServerSess=False, 
     270                clntPriKeyPwd=None): 
    239271        """Request a new user session from the Session Manager 
    240272         
     
    257289                                 False, it's possible to choose to have a  
    258290                                 client or server side session using this  
    259                                  keyword.""" 
     291                                 keyword. 
     292        clntPriKeyPwd:           pass-phrase if any for the client's private 
     293                                 key used to decrypt response from 
     294                                 Session Manager.""" 
    260295     
    261296        if pPhrase is None: 
     
    269304        # If Public key was set by URI, retrieve otherwise get from  
    270305        # smPubKeyFilePath 
    271         smPubKeyTmpFile = self.__retrieveSMpubKeyFromURI() 
    272         if smPubKeyTmpFile: 
    273             smPubKeyFilePath = smPubKeyTmpFile.name 
    274         else: 
    275             smPubKeyFilePath = self.__smPubKeyFilePath  
     306        self.__convSMpubKeyURI2File() 
    276307 
    277308         
     
    282313                                getCookie=getCookie, 
    283314                                createServerSess=createServerSess, 
    284                                 encrCert=self.__clntPubKeyFilePath, 
    285                                 encrPubKeyFilePath=smPubKeyFilePath)  
     315                                encrCert=self.__clntPubKey, 
     316                                encrPubKeyFilePath=self.__smPubKeyFilePath)  
    286317     
    287318            # Pass encrypted request 
    288319            resp = self.__smSrv.connect(connectReq=connectReq()) 
    289             connectResp = ConnectResp(xmlTxt=str(resp['connectResp'])) 
     320             
     321            connectResp = ConnectResp(xmlTxt=resp['connectResp'], 
     322                                encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     323                                encrPriKeyPwd=clntPriKeyPwd) 
     324                             
    290325            if 'errMsg' in connectResp and connectResp['errMsg']: 
    291326                raise Exception(connectResp['errMsg']) 
     
    315350                         rtnExtAttCertList=False, 
    316351                         extAttCertList=None, 
    317                          extTrustedHostList=None):     
     352                         extTrustedHostList=None, 
     353                         clntPriKeyPwd=None):     
    318354        """Request authorisation from NDG Session Manager Web Service. 
    319355         
     
    330366        mapFromTrustedHosts:   Allow a mapped Attribute Certificate to be 
    331367                               created from a user certificate from another 
    332                                trusted host 
     368                               trusted host. 
    333369        rtnExtAttCertList:     Set this flag True so that if authorisation is  
    334370                               denied, a list of potential attribute  
     
    339375        extTrustedHostList:    A list of trusted hosts that can be used to 
    340376                               get Attribute Certificates for making a mapped 
    341                                AC 
     377                               AC. 
     378        clntPriKeyPwd:         pass-phrase if any for the client's private 
     379                               key used to decrypt response from 
     380                               Session Manager. 
    342381        """ 
    343382 
     
    352391        # If Public key was set by URI, retrieve otherwise get from  
    353392        # smPubKeyFilePath 
    354         smPubKeyTmpFile = self.__retrieveSMpubKeyFromURI() 
    355         if smPubKeyTmpFile: 
    356             smPubKeyFilePath = smPubKeyTmpFile.name 
    357         else: 
    358             smPubKeyFilePath = self.__smPubKeyFilePath  
     393        self.__convSMpubKeyURI2File() 
    359394 
    360395             
     
    371406                             extAttCertList=extAttCertList, 
    372407                             extTrustedHostList=extTrustedHostList, 
    373                              encrCert=self.__clntPubKeyFilePath, 
    374                              encrPubKeyFilePath=smPubKeyFilePath)  
     408                             encrCert=self.__clntPubKey, 
     409                             encrPubKeyFilePath=self.__smPubKeyFilePath)  
    375410                                             
    376411            resp = self.__smSrv.reqAuthorisation(authorisationReq=authReq()) 
    377             authResp = AuthorisationResp(\ 
    378                                         xmlTxt=str(resp['authorisationResp'])) 
     412             
     413            authResp = AuthorisationResp(xmlTxt=resp['authorisationResp'], 
     414                                encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     415                                encrPriKeyPwd=clntPriKeyPwd) 
    379416            return authResp 
    380417             
  • TI12-security/trunk/python/NDG/XMLMsg.py

    r686 r701  
    4646 
    4747    # Set Mandatory tags - if any of these are not present raise an exception 
    48     xmlMandTags = [] 
     48    xmlMandatoryTags = [] 
    4949     
    5050    def __init__(self,  
     
    114114             
    115115            try: 
    116                 self.__xmlSecDoc.decrypt(xmlTxt=encrXMLtxt, 
    117                                          encrPriKeyPwd=encrPriKeyPwd) 
    118                                            
    119                 self.__xmlTxt = str(self.__xmlSecDoc) 
     116                self.decrypt(encrPriKeyPwd, encrXMLtxt) 
    120117                            
    121118            except Exception, e: 
     
    126123            self.parseXML() 
    127124        else: 
    128             # XML text or XML tags input ready for encryption 
     125            # XML text or XML tags input  
    129126            if xmlTxt: 
    130                 # Input XML text set - parse tags into dictionary self.__xmlTags 
     127                # Input XML text set - parse tags into dictionary  
     128                # self.__xmlTags 
    131129                try: 
     130                    if encrPriKeyFilePath: 
     131                        # decrypt if a private key was set 
     132                        self.decrypt(encrPriKeyPwd, xmlTxt) 
     133                         
    132134                    self.parseXML() 
    133                 except: 
    134                     # May have failed because text was encrypted - try  
    135                     # decrypting if a private key is available 
    136                     try: 
    137                         self.__xmlSecDoc.decrypt(xmlTxt=xmlTxt, 
    138                                                  encrPriKeyPwd=encrPriKeyPwd) 
    139                                                
    140                         self.__xmlTxt = str(self.__xmlSecDoc) 
    141                     except: 
    142                         raise XMLMsgError("Error parsing text")                 
     135                except Exception, e: 
     136                    raise XMLMsgError("Error parsing text: " + str(e))                 
    143137            else: 
    144138                # XML text will be set from tags set as keywords 
     
    146140                 
    147141            if encrPubKeyFilePath: 
     142                # Public key set - encrypt the data 
    148143                try: 
    149                     self.__xmlSecDoc.encrypt(xmlTxt=self.__xmlTxt) 
    150                     self.__encrXMLtxt = str(self.__xmlSecDoc) 
     144                    self.encrypt() 
    151145                     
    152146                except Exception, e: 
    153147                    raise XMLMsgError("Error encrypting credentials: %s" % e) 
    154148 
    155         # Check for any mandatory tags that have not been set 
    156         missingTags = [tag for tag in self.xmlMandTags if not tag in self] 
    157         if missingTags: 
    158             raise XMLMsgError(\ 
    159                 'The following tag(s) must be set: "%s"' % \ 
    160                                                     '", "'.join(missingTags)) 
    161                  
     149        self.chkTags() 
     150         
    162151                 
    163152    def __repr__(self): 
     
    177166         
    178167 
     168    # There doesn't seem to be an implicit function to allow a dict subclass 
     169    # to yield a dictionary for dict(obj) - Make a 'xmlTags' property instead 
     170    def __getXMLtags(self): 
     171        """Return dictonary of XML tags""" 
     172        return self.__xmlTags 
     173     
     174    xmlTags = property(fget=__getXMLtags, doc="XML tags as a dictionary") 
     175  
     176                       
    179177    def __getXMLhdr(self): 
    180178        return self.__xmlHdr 
     
    392390 
    393391        return rootElem 
    394      
     392 
     393 
     394    #_________________________________________________________________________ 
     395    def chkTags(self): 
     396        """Check for any mandatory tags that have not been set""" 
     397        missingTags=[tag for tag in self.xmlMandatoryTags if not tag in self] 
     398        if missingTags: 
     399            raise XMLMsgError(\ 
     400                'The following tag(s) must be set: "%s"' % \ 
     401                                                    '", "'.join(missingTags)) 
     402 
     403 
     404    #_________________________________________________________________________ 
     405    def encrypt(self, encrPubKeyFilePath=None): 
     406        """Encrypt message""" 
     407        self.__xmlSecDoc.encrypt(xmlTxt=self.__xmlTxt, 
     408                                 encrPubKeyFilePath=encrPubKeyFilePath) 
     409        self.__encrXMLtxt = str(self.__xmlSecDoc) 
     410 
     411 
     412    #_________________________________________________________________________ 
     413    def decrypt(self, encrPriKeyPwd, xmlTxt=None): 
     414        """Decrypt encrypted text""" 
     415         
     416        if xmlTxt is None: 
     417            xmlTxt = self.__encrXMLtxt 
     418             
     419        self.__xmlSecDoc.decrypt(xmlTxt=xmlTxt, encrPriKeyPwd=encrPriKeyPwd) 
     420        self.__xmlTxt = str(self.__xmlSecDoc) 
     421    
  • TI12-security/trunk/python/NDG/XMLSecDoc.py

    r540 r701  
    194194 
    195195        except Exception, excep: 
    196             raise XMLSecDocError("Error parsing dccument: %s" % str(excep)) 
     196            raise XMLSecDocError("Error parsing document: %s" % str(excep)) 
    197197         
    198198        if self.__libxml2Doc is None or \ 
  • TI12-security/trunk/python/NDG/sessionMgr_services_server.py

    r686 r701  
    6161        # assign return values to response object 
    6262        resp = addUserResponseWrapper() 
    63          
    64          
    65         # Request a connection from the Session Manager 
    66         try: 
    67             resp._addUserResp = self.__srv.addUser(reqXMLtxt=reqTxt) 
    68                 
    69         except Exception, e: 
    70             resp._addUserResp = str(AddUserResp(errMsg=str(e))) 
    71  
     63 
     64         
     65        # Decrypt and parse input 
     66        try: 
     67            # Connect request object returned behaves like a dictionary 
     68            reqKeys = AddUserReq(xmlTxt=reqTxt, 
     69                                 encrPriKeyFilePath=self.__srv['keyFile'], 
     70                                 encrPriKeyPwd=self.__srv['keyPPhrase']) 
     71        
     72            # New user request for Session Manager 
     73            addUserResp = self.__srv.addUser(**reqKeys.xmlTags) 
     74 
     75        except Exception, e: 
     76            # Nb. catch exception here so that error message will be encrypted 
     77            # if 'encrCert' key was set 
     78            addUserResp = AddUserResp(errMsg=str(e)) 
     79 
     80 
     81        try: 
     82            # Encrypt response and convert into XML formatted string 
     83            if 'encrCert' in reqKeys: 
     84                 
     85                # ConnectResp class expects the public key to be in a file 
     86                # - Copy public key string content into a temporary file 
     87                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     88                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     89     
     90                addUserResp.encrypt(encrPubKeyFilePath=encrCertTmpFile.name) 
     91                 
     92        except Exception, e: 
     93            addUserResp = AddUserResp(errMsg=str(e)) 
     94         
     95 
     96        # Convert response into encrypted XML formatted string 
     97        resp._addUserResp = addUserResp() 
    7298        return resp 
    7399 
     
    87113        # assign return values to response object 
    88114        resp = connectResponseWrapper() 
    89          
    90          
    91         # Request a connection from the Session Manager 
    92         try: 
    93             resp._connectResp = self.__srv.connect(reqXMLtxt=reqTxt)  
    94                
    95         except Exception, e: 
    96             resp._connectResp = str(ConnectResp(errMsg=str(e))) 
    97          
     115 
     116         
     117        # Decrypt and parse input 
     118        try: 
     119            # Connect request object returned behaves like a dictionary 
     120            reqKeys = ConnectReq(xmlTxt=reqTxt, 
     121                                 encrPriKeyFilePath=self.__srv['keyFile'], 
     122                                 encrPriKeyPwd=self.__srv['keyPPhrase']) 
     123        
     124            # Request a connection from the Session Manager 
     125            connectResp = self.__srv.connect(**reqKeys.xmlTags)  
     126 
     127        except Exception, e: 
     128            # Nb. catch exception here so that error message will be encrypted 
     129            # if 'encrCert' key was set 
     130            connectResp = ConnectResp(errMsg=str(e)) 
     131 
     132 
     133        try: 
     134            # Encrypt response and convert into XML formatted string 
     135            if 'encrCert' in reqKeys: 
     136                 
     137                # ConnectResp class expects the public key to be in a file 
     138                # - Copy public key string content into a temporary file 
     139                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     140                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     141     
     142                connectResp.encrypt(encrPubKeyFilePath=encrCertTmpFile.name) 
     143                 
     144        except Exception, e: 
     145            connectResp = ConnectResp(errMsg=str(e)) 
     146                    
     147                                         
     148        resp._connectResp = connectResp()         
    98149        return resp 
    99150 
     
    101152    #_________________________________________________________________________ 
    102153    def soap_reqAuthorisation(self, ps): 
     154        """Make an authorisation request via the session manager""" 
    103155         
    104156        if self.__debug: 
     
    113165        resp = authorisationResponseWrapper() 
    114166 
    115  
    116         # Make an authorisation request via the session manager 
    117         try: 
    118             authResp = self.__srv.reqAuthorisation(reqXMLtxt=reqTxt) 
    119              
    120         except Exception, e: 
    121             authResp=AuthorisationResp(statCode=AuthorisationResp.accessError, 
    122                                        errMsg=str(e)) 
    123                                         
    124         # Convert response into XML formatted string     
    125         resp._authorisationResp = str(authResp) 
    126                                                              
     167         
     168        # Decrypt and parse input 
     169        try: 
     170            # Authorisation request object returned behaves like a dictionary 
     171            reqKeys = AuthorisationReq(xmlTxt=reqTxt, 
     172                                     encrPriKeyFilePath=self.__srv['keyFile'], 
     173                                     encrPriKeyPwd=self.__srv['keyPPhrase']) 
     174 
     175                    
     176            authResp = self.__srv.reqAuthorisation(**reqKeys.xmlTags) 
     177 
     178        except Exception, e: 
     179            # Nb. catch exception here so that error message will be encrypted 
     180            # if 'encrCert' key was set 
     181            authResp = AuthorisationResp(errMsg=str(e)) 
     182 
     183 
     184        try: 
     185            # Encrypt response and convert into XML formatted string 
     186            if 'encrCert' in reqKeys: 
     187                 
     188                # ConnectResp class expects the public key to be in a file 
     189                # - Copy public key string content into a temporary file 
     190                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     191                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     192     
     193                authResp.encrypt(encrPubKeyFilePath=encrCertTmpFile.name) 
     194                 
     195        except Exception, e: 
     196            authResp = AuthorisationResp(\ 
     197                                      statCode=AuthorisationResp.accessError, 
     198                                      errMsg=str(e)) 
     199 
     200         
     201        # Convert response into encrypted XML formatted string     
     202        resp._authorisationResp = authResp()                                                             
    127203        return resp 
    128204 
  • TI12-security/trunk/python/bin/ndgSessionClient.py

    r690 r701  
    1818import optparse 
    1919import re 
     20import getpass 
    2021 
    2122from Cookie import SimpleCookie 
     
    6263                    (optStr, value, str(e))) 
    6364                     
    64                      
     65 
     66#_____________________________________________________________________________ 
     67def setClntPriKeyPwd(option, optStr, value, parser): 
     68    """Parser Callback function for reading client private key password""" 
     69    try: 
     70        parser.values.clntPriKeyPwd = open(value).read().strip() 
     71         
     72    except IOError, (errNo, errMsg): 
     73        raise optparse.OptionValueError(\ 
     74                    "Reading password from file \"%s\": %s" % (value, errMsg)) 
     75                            
     76    except Exception, e: 
     77        raise optparse.OptionValueError(\ 
     78                    "Reading password from file \"%s\": %s" % (value, str(e))) 
     79        
     80                  
    6581#_____________________________________________________________________________ 
    6682if __name__ == '__main__': 
     
    92108on behalf of a user; see also: -i, -s, -a, -x, -y [, -t]""") 
    93109 
    94     parser.add_option("-y", 
    95                       "--clnt-cert-file", 
    96                       dest="clntCertFile", 
     110    parser.add_option("-x", 
     111                      "--clnt-pubkey-file", 
     112                      dest="clntPubKeyFilePath", 
    97113                      help=\ 
    98114"""X.509 Certificate of client.  This is used by the Session Manager to  
     
    100116back in clear text""") 
    101117 
    102     parser.add_option("-x", 
    103                       "--session-mgr-cert-file", 
    104                       dest="smPubKeyFilePath", 
     118    parser.add_option("-k", 
     119                      "--clnt-prikey-file", 
     120                      dest="clntPriKeyFilePath", 
     121                      help=\ 
     122"""Private key file of client.  This is used by the client to decrypt 
     123responses.  This must be set if -x/--clnt-pubkey-file is set.""") 
     124 
     125    parser.add_option("-w", 
     126                      "--clnt-prikey-pwd-file", 
     127                      dest="clntPriKeyPwd", 
     128                      action="callback", 
     129                      callback=setClntPriKeyPwd, 
     130                      type="string", 
     131                      help=\ 
     132"""Pass a file containing the password for the client private key.  If not 
     133set, it is prompted for from tty.""") 
     134 
     135    parser.add_option("-y", 
     136                      "--session-mgr-pubkey-uri", 
     137                      dest="smPubKeyURI", 
    105138                      help=\ 
    106139"""X.509 Certificate of Session Manager.  This is used to encrypt the request 
    107 to the Session Manager.  WARNING: If this is not set, the request will be sent  
    108 back in clear text""") 
     140to the Session Manager.  Set as a local file path or remote URI.  WARNING: 
     141If this is not set, the request will be sent back in clear text""") 
    109142 
    110143    parser.add_option("-s", 
     
    144177 
    145178    parser.add_option("-e", 
    146                       "--pass-cookie-from-stdin", 
     179                      "--cookie-from-stdin", 
    147180                      action="callback", 
    148181                      callback=setSessCookieFromStdin, 
     
    223256        else: 
    224257            # Obtain from prompt 
    225             import getpass 
    226258            try: 
    227                 passPhrase = getpass.getpass(prompt="pass-phrase: ")  
     259                passPhrase = getpass.getpass(prompt="Login pass-phrase: ")  
    228260            except KeyboardInterrupt: 
    229261                sys.exit(1) 
    230262 
    231                 
     263    if options.clntPriKeyPwd is None and options.clntPriKeyFilePath: 
     264        # Obtain from prompt 
     265        try: 
     266            passPhrase = getpass.getpass(\ 
     267                                    prompt="Client private key pass-phrase: ")  
     268        except KeyboardInterrupt: 
     269            sys.exit(1) 
     270 
     271                   
    232272    extAttCertList = None 
    233273                 
     
    259299                (arg, "--ext-trusted-host-file\"/\"-t", str(e))) 
    260300 
    261 #    import pdb 
    262 #    pdb.set_trace() 
    263301 
    264302    # Initialise session client 
    265303    try: 
    266304        sessClnt = SessionClient(smWSDL=options.sessMgrWSDLuri, 
    267                                  smPubKeyFilePath=options.smPubKeyFilePath, 
    268                                  clntPubKeyFilePath=options.clntCertFile, 
    269                                  traceFile=options.soapDebug) 
     305                             smPubKeyURI=options.smPubKeyURI, 
     306                             clntPubKeyFilePath=options.clntPubKeyFilePath, 
     307                             clntPriKeyFilePath=options.clntPriKeyFilePath, 
     308                             traceFile=options.soapDebug) 
    270309    except Exception, e: 
    271310        sys.stderr.write("Initialising client: %s\n" % str(e)) 
     
    277316            methodCall = True 
    278317             
    279             sessClnt.addUser(userName=options.newUserName, pPhrase=passPhrase) 
     318            sessClnt.addUser(userName=options.newUserName,  
     319                             pPhrase=passPhrase, 
     320                             clntPriKeyPwd=options.clntPriKeyPwd) 
    280321            sys.exit(0) 
    281322                             
     
    284325             
    285326            sSessCookie = sessClnt.connect(userName=options.userName,  
    286                                            pPhrase=passPhrase)             
     327                                       pPhrase=passPhrase, 
     328                                       clntPriKeyPwd=options.clntPriKeyPwd)             
    287329            print sSessCookie 
    288330            # Don't exit here - req-autho may have been set too 
     
    303345                            rtnExtAttCertList=options.rtnExtAttCertList, 
    304346                            extAttCertList=extAttCertList, 
    305                             extTrustedHostList=extTrustedHostList) 
     347                            extTrustedHostList=extTrustedHostList, 
     348                            clntPriKeyPwd=options.clntPriKeyPwd) 
    306349            print authResp 
    307350         
Note: See TracChangeset for help on using the changeset viewer.