Changeset 1771


Ignore:
Timestamp:
27/11/06 14:52:53 (13 years ago)
Author:
pjkersha
Message:

Replaced references to 'PubKey?' with 'Cert' as this is more accurate - they refer to X.509 certs which
contain public keys.

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

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/Tests/AttAuthority/AttAuthority_services.py

    r1696 r1771  
    7070 
    7171    # op: <ZSI.wstools.WSDLTools.Message instance at 0xb7855b8c> 
    72     def getPubKey(self): 
     72    def getCert(self): 
    7373 
    7474        request = getPubKeyInputMsg() 
  • TI12-security/trunk/python/Tests/LogClientTest.py

    r1636 r1771  
    3030            # Omit traceFile keyword to leave out SOAP debug info 
    3131            self.logClnt = LogClient(wsdl=wsdl,  
    32                  signingPubKeyFilePath="./Junk-cert.pem", 
     32                 signingCertFilePath="./Junk-cert.pem", 
    3333                 signingPriKeyFilePath="./Junk-key.pem", 
    3434                 signingPriKeyPwd=open("./tmp2").read().strip(),  
  • TI12-security/trunk/python/Tests/SecurityCGItest.py

    r1639 r1771  
    3030        aaWSDLuri = "http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl" 
    3131         
    32         smPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
    33         aaPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
     32        smCertFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
     33        aaCertFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
    3434     
    35         clntPubKeyFilePath = "./Junk-cert.pem" 
     35        clntCertFilePath = "./Junk-cert.pem" 
    3636        clntPriKeyFilePath = "./Junk-key.pem" 
    3737        clntPriKeyPwd = open('./tmp2').read().strip() 
     
    3939        self.idpCGI = IdentityProviderSecurityCGI(os.path.basename(__file__), 
    4040                                        smWSDLuri, 
    41                                         smPubKeyFilePath=smPubKeyFilePath, 
    42                                         clntPubKeyFilePath=clntPubKeyFilePath, 
     41                                        smCertFilePath=smCertFilePath, 
     42                                        clntCertFilePath=clntCertFilePath, 
    4343                                        clntPriKeyFilePath=clntPriKeyFilePath, 
    4444                                        clntPriKeyPwd=clntPriKeyPwd) 
     
    4747                                        self.returnURI, 
    4848                                        aaWSDLuri, 
    49                                         aaPubKeyFilePath=aaPubKeyFilePath, 
    50                                         clntPubKeyFilePath=clntPubKeyFilePath, 
     49                                        aaCertFilePath=aaCertFilePath, 
     50                                        clntCertFilePath=clntCertFilePath, 
    5151                                        clntPriKeyFilePath=clntPriKeyFilePath, 
    5252                                        clntPriKeyPwd=clntPriKeyPwd) 
  • TI12-security/trunk/python/Tests/security.py

    r1636 r1771  
    274274    aaWSDL = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
    275275 
    276     smPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
    277     aaPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
    278  
    279     clntPubKeyFilePath = "../certs/GabrielCGI-cert.pem" 
     276    smCertFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
     277    aaCertFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
     278 
     279    clntCertFilePath = "../certs/GabrielCGI-cert.pem" 
    280280    clntPriKeyFilePath = "../certs/GabrielCGI-key.pem" 
    281281 
     
    283283                                  aaWSDL, 
    284284                                                                  scriptName=os.path.basename(__file__), 
    285                                   smPubKeyFilePath=smPubKeyFilePath, 
    286                                   aaPubKeyFilePath=aaPubKeyFilePath, 
    287                                   clntPubKeyFilePath=clntPubKeyFilePath, 
     285                                  smCertFilePath=smCertFilePath, 
     286                                  aaCertFilePath=aaCertFilePath, 
     287                                  clntCertFilePath=clntCertFilePath, 
    288288                                  clntPriKeyFilePath=clntPriKeyFilePath) 
    289289    securityCGI() 
  • TI12-security/trunk/python/ndg.security.client/ndg/security/client/LogClient.py

    r1638 r1771  
    3636    def __init__(self,  
    3737                 wsdl=None, 
    38                  signingPubKeyFilePath=None, 
     38                 signingCertFilePath=None, 
    3939                 signingPriKeyFilePath=None, 
    4040                 signingPriKeyPwd=None,  
     
    5555        self.__traceFile = traceFile 
    5656         
    57         self.__signingPubKeyFilePath = signingPubKeyFilePath 
     57        self.__signingCertFilePath = signingCertFilePath 
    5858        self.__signingPriKeyFilePath = signingPriKeyFilePath 
    5959        self.__signingPriKeyPwd = signingPriKeyPwd 
     
    104104            debugReq.sign(self.__signingPriKeyFilePath, 
    105105                          self.__signingPriKeyPwd, 
    106                           self.__signingPubKeyFilePath) 
     106                          self.__signingCertFilePath) 
    107107         
    108108            resp = self.__srvPx.debug(debugReq=debugReq()) 
     
    123123            infoReq.sign(self.__signingPriKeyFilePath, 
    124124                         self.__signingPriKeyPwd, 
    125                          self.__signingPubKeyFilePath) 
     125                         self.__signingCertFilePath) 
    126126         
    127127            resp = self.__srvPx.info(infoReq=infoReq()) 
     
    142142            warningReq.sign(self.__signingPriKeyFilePath, 
    143143                            self.__signingPriKeyPwd, 
    144                             self.__signingPubKeyFilePath) 
     144                            self.__signingCertFilePath) 
    145145         
    146146            resp = self.__srvPx.warning(warningReq=warningReq()) 
     
    161161            errorReq.sign(self.__signingPriKeyFilePath, 
    162162                          self.__signingPriKeyPwd, 
    163                           self.__signingPubKeyFilePath) 
     163                          self.__signingCertFilePath) 
    164164         
    165165            resp = self.__srvPx.error(errorReq=errorReq()) 
  • TI12-security/trunk/python/ndg.security.client/ndg/security/client/ndgSessionClient.py

    r1653 r1771  
    8181 
    8282#_____________________________________________________________________________ 
    83 def setAApubKey(option, optStr, value, parser): 
     83def setAAcert(option, optStr, value, parser): 
    8484    """Parser callback function for reading Attribute Authority Public key""" 
    8585     
    8686    try: 
    87         parser.values.aaPubKey = open(value).read().strip() 
     87        parser.values.aaCert = open(value).read().strip() 
    8888         
    8989    except IOError, (errNo, errMsg): 
     
    126126                      "--att-authority-pubkey-file", 
    127127                      action="callback", 
    128                       callback=setAApubKey, 
    129                       dest="aaPubKey", 
     128                      callback=setAAcert, 
     129                      dest="aaCert", 
    130130                      type="string",  
    131131                      help=\ 
     
    136136    parser.add_option("-x", 
    137137                      "--clnt-pubkey-file", 
    138                       dest="clntPubKeyFilePath", 
     138                      dest="clntCertFilePath", 
    139139                      help=\ 
    140140"""X.509 Certificate of client.  This is used by the Session Manager to  
     
    161161    parser.add_option("-y", 
    162162                      "--session-mgr-pubkey-file", 
    163                       dest="smPubKeyFilePath", 
     163                      dest="smCertFilePath", 
    164164                      help=\ 
    165165"""X.509 Certificate of Session Manager.  This is used to encrypt the request 
     
    328328    try: 
    329329        sessClnt = SessionClient(smWSDL=options.sessMgrWSDLuri, 
    330                              smPubKeyFilePath=options.smPubKeyFilePath, 
    331                              clntPubKeyFilePath=options.clntPubKeyFilePath, 
     330                             smCertFilePath=options.smCertFilePath, 
     331                             clntCertFilePath=options.clntCertFilePath, 
    332332                             clntPriKeyFilePath=options.clntPriKeyFilePath, 
    333333                             traceFile=options.soapDebug) 
     
    366366                            sessCookie=options.sessCookie, 
    367367                            aaWSDL=options.attAuthorityWSDLuri, 
    368                             aaPubKey=options.aaPubKey, 
     368                            aaCert=options.aaCert, 
    369369                            mapFromTrustedHosts=options.mapFromTrustedHosts, 
    370370                            reqRole=options.reqRole, 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/AttAuthority/__init__.py

    r1770 r1771  
    4343    def __init__(self,  
    4444                 uri=None,  
    45                  aaPubKeyFilePath=None, 
    46                  clntPubKeyFilePath=None, 
     45                 aaCertFilePath=None, 
     46                 clntCertFilePath=None, 
    4747                 clntPriKeyFilePath=None, 
    4848                 tracefile=None): 
     
    5050        uri:                    WSDL URI for Attribute Authority WS.  Setting  
    5151                                 it will set the Service Proxy 
    52         aaPubKeyFilePath:        Public key of Attribute Authority used to  
     52        aaCertFilePath:        Public key of Attribute Authority used to  
    5353                                 encrypt the outgoing message if required -  
    5454                                 set as a path on the local file system or as  
    5555                                 a URI 
    56         clntPubKeyFilePath:      Public key of client.  This is passed to the 
     56        clntCertFilePath:      Public key of client.  This is passed to the 
    5757                                 Attribute Authority so that it can encrypt 
    5858                                 responses.  WARNING: if not set, responses 
    5959                                 are returned as clear text 
    60         clntPriKeyFilePath:      Private key of client.  If clntPubKeyFilePath 
     60        clntPriKeyFilePath:      Private key of client.  If clntCertFilePath 
    6161                                 is set, the private key is needed to decrypt  
    6262                                 the response from the Attribute Authority 
     
    6666        self.__srv = None 
    6767        self.__uri = None 
    68         self.__aaPubKeyFilePath = None 
    69         self.__aaPubKeyFilePath = None 
    70         self.__clntPubKeyFilePath = None 
    71         self.__clntPubKey = None 
     68        self.__aaCertFilePath = None 
     69        self.__aaCertFilePath = None 
     70        self.__clntCertFilePath = None 
     71        self.__clntCert = None 
    7272        self.__clntPriKeyFilePath = None 
    7373         
    74         self.__aaPubKeyTempFile = None 
     74        self.__aaCertTempFile = None 
    7575         
    7676         
     
    7878            self.__setURI(uri) 
    7979             
    80         if aaPubKeyFilePath: 
    81             self.__setAApubKeyFilePath(aaPubKeyFilePath) 
     80        if aaCertFilePath: 
     81            self.__setAAcertFilePath(aaCertFilePath) 
    8282             
    8383        if clntPriKeyFilePath: 
    8484            self.__setClntPriKeyFilePath(clntPriKeyFilePath) 
    8585             
    86         if clntPubKeyFilePath: 
     86        if clntCertFilePath: 
    8787            if clntPriKeyFilePath is None: 
    8888                raise AttAuthorityClientError, \ 
     
    9090                    "public key" 
    9191                     
    92             self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
     92            self.__setClntCertFilePath(clntCertFilePath) 
    9393 
    9494            
     
    114114 
    115115    #_________________________________________________________________________ 
    116     def __setAApubKeyFilePath(self, aaPubKeyFilePath): 
    117          
    118         if not isinstance(aaPubKeyFilePath, basestring): 
     116    def __setAAcertFilePath(self, aaCertFilePath): 
     117         
     118        if not isinstance(aaCertFilePath, basestring): 
    119119            raise AttAuthorityClientError, \ 
    120120                "Attribute Authority public key URI must be a valid string" 
    121121         
    122         self.__aaPubKeyFilePath = aaPubKeyFilePath 
    123          
    124     aaPubKeyFilePath = property(fset=__setAApubKeyFilePath, 
     122        self.__aaCertFilePath = aaCertFilePath 
     123         
     124    aaCertFilePath = property(fset=__setAAcertFilePath, 
    125125                                doc="Set Attribute Authority public key URI") 
    126126 
    127127  
    128128    #_________________________________________________________________________ 
    129     def __setClntPubKeyFilePath(self, clntPubKeyFilePath): 
    130          
    131         if not isinstance(clntPubKeyFilePath, basestring): 
     129    def __setClntCertFilePath(self, clntCertFilePath): 
     130         
     131        if not isinstance(clntCertFilePath, basestring): 
    132132            raise AttAuthorityClientError(\ 
    133133                "Client public key file path must be a valid string") 
    134134         
    135         self.__clntPubKeyFilePath = clntPubKeyFilePath 
     135        self.__clntCertFilePath = clntCertFilePath 
    136136        try: 
    137             self.__clntPubKey = open(self.__clntPubKeyFilePath).read() 
     137            self.__clntCert = open(self.__clntCertFilePath).read() 
    138138             
    139139        except IOError, (errNo, errMsg): 
    140140            raise AttAuthorityClientError(\ 
    141141                    "Reading certificate file \"%s\": %s" % \ 
    142                     (self.__clntPubKeyFilePath, errMsg)) 
     142                    (self.__clntCertFilePath, errMsg)) 
    143143                                
    144144        except Exception, e: 
    145145            raise AttAuthorityClientError, \ 
    146146                                    "Reading certificate file \"%s\": %s" % \ 
    147                                     (self.__clntPubKeyFilePath, str(e)) 
    148          
    149     clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     147                                    (self.__clntCertFilePath, str(e)) 
     148         
     149    clntCertFilePath = property(fset=__setClntCertFilePath, 
    150150                                  doc="File path for client public key") 
    151151 
     
    165165 
    166166    #_________________________________________________________________________ 
    167     def __getAttAuthorityPubKey(self): 
     167    def __getAttAuthorityCert(self): 
    168168        """Retrieve the public key from the URI""" 
    169169         
    170170        # Don't proceed unless URI was set - user may have set public key via 
    171         # aaPubKeyFilePath instead 
    172         if self.__aaPubKeyFilePath is not None: 
     171        # aaCertFilePath instead 
     172        if self.__aaCertFilePath is not None: 
    173173            return 
    174174                 
    175175        try: 
    176             self.__aaPubKeyTempFile = tempfile.NamedTemporaryFile() 
    177              
    178             pubKey = self.getPubKey() 
    179             open(self.__aaPubKeyTempFile.name, "w").write(pubKey) 
    180              
    181             self.__aaPubKeyFilePath = self.__aaPubKeyTempFile.name 
     176            self.__aaCertTempFile = tempfile.NamedTemporaryFile() 
     177             
     178            cert = self.getCert() 
     179            open(self.__aaCertTempFile.name, "w").write(cert) 
     180             
     181            self.__aaCertFilePath = self.__aaCertTempFile.name 
    182182             
    183183        except IOError, (errNo, errMsg): 
    184184            raise AttAuthorityClientError, \ 
    185185                                "Writing public key to temp \"%s\": %s" % \ 
    186                                 (self.__aaPubKeyTempFile.name, errMsg)                                                                       
     186                                (self.__aaCertTempFile.name, errMsg)                                                                       
    187187        except Exception, e: 
    188188            raise AttAuthorityClientError, "Retrieving Attribute Authority "+\ 
     
    219219 
    220220        # If Public key was not set, retrieve from server 
    221         self.__getAttAuthorityPubKey() 
     221        self.__getAttAuthorityCert() 
    222222             
    223223        try:    
     
    237237 
    238238        # If Public key was not set, retrieve from server 
    239         self.__getAttAuthorityPubKey() 
     239        self.__getAttAuthorityCert() 
    240240             
    241241        try:    
     
    259259 
    260260        # If Public key was not set, retrieve from server 
    261         self.__getAttAuthorityPubKey() 
     261        self.__getAttAuthorityCert() 
    262262 
    263263 
     
    272272                                     
    273273    #_________________________________________________________________________ 
    274     def getPubKey(self): 
     274    def getCert(self): 
    275275        """Retrieve the public key of the Attribute Authority""" 
    276276         
    277277        try:    
    278             pubKey = self.__srv.getPubKey()                 
    279             return pubKey 
     278            cert = self.__srv.getCert()                 
     279            return cert 
    280280         
    281281        except Exception, e: 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/AttAuthorityIO.py

    r1642 r1771  
    532532     
    533533    # Override base class class variables 
    534     xmlTagTmpl = {"pubKey": "", "errMsg": ""} 
     534    xmlTagTmpl = {"cert": "", "errMsg": ""} 
    535535                         
    536536 
     
    550550        # XML tags input as keywords expected - check minimum  
    551551        # required are present for SessionMgr getPubKey response 
    552         if 'pubKey' not in self and 'errMsg' not in self:             
     552        if 'cert' not in self and 'errMsg' not in self:             
    553553            raise PubKeyRespError(\ 
    554                 "PubKey response document must contain: \"pubKey\"" + \ 
     554                "Cert response document must contain: \"cert\"" + \ 
    555555                " or \"errMsg\" keywords") 
    556556                 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/CredWallet.py

    r1711 r1771  
    129129    def __init__(self, 
    130130                 proxyCertTxt, 
    131                  caPubKeyFilePath=None, 
    132                  clntPubKeyFilePath=None, 
     131                 caCertFilePath=None, 
     132                 clntCertFilePath=None, 
    133133                 clntPriKeyFilePath=None, 
    134134                 clntPriKeyPwd=None, 
     
    139139 
    140140        proxy certificate:      users proxy certificate as string text 
    141         caPubKeyFilePath:       Certificate Authority's certificate - used in 
     141        caCertFilePath:       Certificate Authority's certificate - used in 
    142142                                validation of signed Attribute Certificates. 
    143143                                If not set here, it must be input in call 
    144144                                to reqAuthorisation. 
    145         clntPubKeyFilePath:     Public key certificate for this client.  
     145        clntCertFilePath:     Public key certificate for this client.  
    146146                                Setting this enables return message from AA  
    147147                                WSDL to be encrypted by the AA. 
     
    168168        self.proxyCertTxt = proxyCertTxt 
    169169         
    170         self.__setCApubKeyFilePath(caPubKeyFilePath) 
    171         self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
     170        self.__setCAcertFilePath(caCertFilePath) 
     171        self.__setClntCertFilePath(clntCertFilePath) 
    172172        self.__setClntPriKeyFilePath(clntPriKeyFilePath) 
    173173        self.__setClntPriKeyPwd(clntPriKeyPwd) 
     
    306306 
    307307    #_________________________________________________________________________ 
    308     def __setCApubKeyFilePath(self, caPubKeyFilePath): 
    309          
    310         if not isinstance(caPubKeyFilePath, basestring) and \ 
    311            caPubKeyFilePath is not None: 
     308    def __setCAcertFilePath(self, caCertFilePath): 
     309         
     310        if not isinstance(caCertFilePath, basestring) and \ 
     311           caCertFilePath is not None: 
    312312            raise CredWalletError(\ 
    313313                "Input CA Certificate file path is not a valid string") 
    314314                 
    315         self.__caPubKeyFilePath = caPubKeyFilePath 
     315        self.__caCertFilePath = caCertFilePath 
    316316        
    317317         
    318     caPubKeyFilePath = property(fset=__setCApubKeyFilePath, 
     318    caCertFilePath = property(fset=__setCAcertFilePath, 
    319319                              doc="CA Certificate  - use to check AC XML Sig") 
    320320 
    321321 
    322322    #_________________________________________________________________________ 
    323     def __setClntPubKeyFilePath(self, clntPubKeyFilePath): 
    324          
    325         if not isinstance(clntPubKeyFilePath, basestring) and \ 
    326            clntPubKeyFilePath is not None: 
     323    def __setClntCertFilePath(self, clntCertFilePath): 
     324         
     325        if not isinstance(clntCertFilePath, basestring) and \ 
     326           clntCertFilePath is not None: 
    327327            raise CredWalletError(\ 
    328328                "Input Client Certificate file path is not a valid string") 
    329329                 
    330         self.__clntPubKeyFilePath = clntPubKeyFilePath 
     330        self.__clntCertFilePath = clntCertFilePath 
    331331         
    332332        # Read the file into string ready to be passed over WS interface as 
    333333        # required 
    334         if self.__clntPubKeyFilePath: 
     334        if self.__clntCertFilePath: 
    335335            try: 
    336                 self.__clntPubKey = open(self.__clntPubKeyFilePath).read() 
     336                self.__clntCert = open(self.__clntCertFilePath).read() 
    337337                 
    338338            except IOError, (errNo, errMsg): 
    339339                raise CredWalletError(\ 
    340340                            "Reading client public key file \"%s\": %s" %\ 
    341                             (self.__clntPubKeyFilePath, errMsg)) 
     341                            (self.__clntCertFilePath, errMsg)) 
    342342                                    
    343343            except Exception, e: 
    344344                raise CredWalletError(\ 
    345345                            "Reading client public key file \"%s\": %s" %\ 
    346                             (self.__clntPubKeyFilePath, str(e)))                 
     346                            (self.__clntCertFilePath, str(e)))                 
    347347        
    348348         
    349     clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     349    clntCertFilePath = property(fset=__setClntCertFilePath, 
    350350                        doc="Client Public Key - use to encrypt resp from AA") 
    351351 
     
    498498                           aaPropFilePath=None, 
    499499                           aaWSDL=None, 
    500                            aaPubKeyFilePath=None, 
     500                           aaCertFilePath=None, 
    501501                           extAttCert=None, 
    502502                           bDebug=False): 
     
    523523            try: 
    524524                aaClnt = AttAuthorityClient(aaWSDL=aaWSDL, 
    525                                 aaPubKeyFilePath=aaPubKeyFilePath, 
    526                                 clntPubKeyFilePath=self.__clntPubKeyFilePath, 
     525                                aaCertFilePath=aaCertFilePath, 
     526                                clntCertFilePath=self.__clntCertFilePath, 
    527527                                clntPriKeyFilePath=self.__clntPriKeyFilePath) 
    528528                                     
     
    583583        # Update attribute Certificate instance with CA's certificate ready  
    584584        # for signature check in addCredential() 
    585         if self.__caPubKeyFilePath is None: 
     585        if self.__caCertFilePath is None: 
    586586            raise CredWalletError, "No CA certificate has been set" 
    587587         
    588         attCert.certFilePathList = self.__caPubKeyFilePath 
     588        attCert.certFilePathList = self.__caCertFilePath 
    589589 
    590590         
     
    603603                             userRole=None, 
    604604                             aaWSDL=None, 
    605                              aaPubKeyFilePath=None, 
     605                             aaCertFilePath=None, 
    606606                             aaPropFilePath=None, 
    607607                             bDebug=False): 
     
    619619            try: 
    620620                aaClnt = AttAuthorityClient(aaWSDL=aaWSDL, 
    621                                 aaPubKeyFilePath=aaPubKeyFilePath, 
    622                                 clntPubKeyFilePath=self.__clntPubKeyFilePath, 
     621                                aaCertFilePath=aaCertFilePath, 
     622                                clntCertFilePath=self.__clntCertFilePath, 
    623623                                clntPriKeyFilePath=self.__clntPriKeyFilePath) 
    624624                                     
     
    661661                         aaPropFilePath=None, 
    662662                         aaWSDL=None, 
    663                          aaPubKeyFilePath=None, 
     663                         aaCertFilePath=None, 
    664664                         mapFromTrustedHosts=None, 
    665665                         rtnExtAttCertList=None, 
     
    680680                                configuration file. 
    681681                                 
    682         aaPubKeyFilePath:       Public key of AA used to encrypt client  
     682        aaCertFilePath:       Public key of AA used to encrypt client  
    683683                                requests to the AA. 
    684684 
     
    760760                               
    761761                               
    762         if aaPubKeyFilePath is None: 
     762        if aaCertFilePath is None: 
    763763            # Try retrieving public key from the web service and making a  
    764764            # temporary file to hold it 
    765765            try: 
    766                 pubKeyReq = PubKeyReq() 
    767                 resp = aaSrv.getPubKey(pubKeyReq=pubKeyReq()) 
    768                 pubKeyResp = PubKeyResp(xmlTxt=resp['pubKeyResp']) 
    769          
    770                 if 'errMsg' in pubKeyResp and pubKeyResp['errMsg']: 
    771                     raise Exception(pubKeyResp['errMsg']) 
    772                  
    773                 aaPubKeyTmpFile = tempfile.NamedTemporaryFile() 
    774                 open(aaPubKeyTmpFile.name,"w").write(pubKeyResp['pubKey']) 
    775      
    776                 aaPubKeyFilePath = aaPubKeyTmpFile.name 
     766                certReq = CertReq() 
     767                resp = aaSrv.getCert(certReq=certReq()) 
     768                certResp = CertResp(xmlTxt=resp['certResp']) 
     769         
     770                if 'errMsg' in certResp and certResp['errMsg']: 
     771                    raise Exception(certResp['errMsg']) 
     772                 
     773                aaCertTmpFile = tempfile.NamedTemporaryFile() 
     774                open(aaCertTmpFile.name,"w").write(certResp['cert']) 
     775     
     776                aaCertFilePath = aaCertTmpFile.name 
    777777                 
    778778            except IOError, (errNo, errMsg): 
     
    793793            # info WS method 
    794794            aaClnt = AttAuthorityClient(aaWSDL=aaWSDL,  
    795                                  aaPubKeyFilePath=aaPubKeyFilePath, 
    796                                  clntPubKeyFilePath=self.__clntPubKeyFilePath, 
     795                                 aaCertFilePath=aaCertFilePath, 
     796                                 clntCertFilePath=self.__clntCertFilePath, 
    797797                                 clntPriKeyFilePath=self.__clntPriKeyFilePath) 
    798798             
     
    879879            try: 
    880880                attCert = self.__reqAuthorisation(aaWSDL=aaWSDL, 
    881                                             aaPubKeyFilePath=aaPubKeyFilePath, 
     881                                            aaCertFilePath=aaCertFilePath, 
    882882                                            aaPropFilePath=aaPropFilePath, 
    883883                                            extAttCert=extAttCert)                 
     
    918918                    trustedHostInfo = self.getAATrustedHostInfo(reqRole, 
    919919                                            aaWSDL=aaWSDL, 
    920                                             aaPubKeyFilePath=aaPubKeyFilePath, 
     920                                            aaCertFilePath=aaCertFilePath, 
    921921                                            aaPropFilePath=aaPropFilePath) 
    922922                except Exception, e: 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SecurityCGI.py

    r1642 r1771  
    8484    def __init__(self, 
    8585                 scriptName, 
    86                  clntPubKeyFilePath=None, 
     86                 clntCertFilePath=None, 
    8787                 clntPriKeyFilePath=None, 
    8888                 clntPriKeyPwd=None, 
     
    9191        """scriptName:            Name of IdP script specified as the action 
    9292                                  for HTML forms 
    93         clntPubKeyFilePath:    file path to client public key.  The CGI 
     93        clntCertFilePath:    file path to client public key.  The CGI 
    9494                                  script must have access to a public/private 
    9595                                  key to enable encryption of return traffic 
     
    103103        """ 
    104104         
    105         self.clntPubKeyFilePath = clntPubKeyFilePath 
     105        self.clntCertFilePath = clntCertFilePath 
    106106        self.clntPriKeyFilePath = clntPriKeyFilePath 
    107107        self.clntPriKeyPwd = clntPriKeyPwd 
     
    209209                self._smClnt = SessionClient(\ 
    210210                            smWSDLuri=self.smWSDLuri, 
    211                             smPubKeyFilePath=self.smPubKeyFilePath, 
    212                             clntPubKeyFilePath=self.clntPubKeyFilePath, 
     211                            smCertFilePath=self.smCertFilePath, 
     212                            clntCertFilePath=self.clntCertFilePath, 
    213213                            clntPriKeyFilePath=self.clntPriKeyFilePath, 
    214214                            traceFile=self._wsDebug and sys.stderr or None) 
     
    216216            authzResp = self._smClnt.reqAuthorisation(sessCookie=sessCookie, 
    217217                                    aaWSDLuri=self.aaWSDLuri, 
    218                                     aaPubKey=self.aaPubKey, 
     218                                    aaCert=self.aaCert, 
    219219                                    reqRole=reqRole, 
    220220                                    mapFromTrustedHosts=bMapFromTrustedHosts, 
     
    332332                 returnURI, 
    333333                 aaWSDLuri, 
    334                  aaPubKeyFilePath=None, 
     334                 aaCertFilePath=None, 
    335335                 smWSDLuri=None, 
    336                  smPubKeyFilePath=None, 
     336                 smCertFilePath=None, 
    337337                 trustedIdPs=None, 
    338338                 cookieLifetimeHrs=8, 
     
    351351                              user session wallet for Attribute Certificates. 
    352352                              Only needed for _getAttCert calls 
    353         aaPubKeyFilePath:     file path to Attribute Authority public key. 
     353        aaCertFilePath:     file path to Attribute Authority public key. 
    354354                              If not set, the client will make a WS call for 
    355355                              it. 
    356         smPubKeyFilePath:     file path to Session Manager public key. 
     356        smCertFilePath:     file path to Session Manager public key. 
    357357                              If not set, the client will make a WS call for 
    358358                              it.  See information for smWSDLuri above. 
     
    368368        self._aaClnt = None 
    369369         
    370         self.aaPubKeyFilePath = aaPubKeyFilePath 
     370        self.aaCertFilePath = aaCertFilePath 
    371371 
    372372        self.smWSDLuri = smWSDLuri 
    373373        self._smClnt = None 
    374374         
    375         self.smPubKeyFilePath = smPubKeyFilePath 
     375        self.smCertFilePath = smCertFilePath 
    376376 
    377377 
     
    576576            if not self._aaClnt: 
    577577                self._aaClnt = AttAuthorityClient(aaWSDL=self.aaWSDLuri, 
    578                             aaPubKeyFilePath=self.aaPubKeyFilePath, 
    579                             clntPubKeyFilePath=self.clntPubKeyFilePath, 
     578                            aaCertFilePath=self.aaCertFilePath, 
     579                            clntCertFilePath=self.clntCertFilePath, 
    580580                            clntPriKeyFilePath=self.clntPriKeyFilePath, 
    581581                            traceFile=self._wsDebug and sys.stderr or None) 
     
    699699                 scriptName,  
    700700                 smWSDLuri, 
    701                  smPubKeyFilePath=None, 
     701                 smCertFilePath=None, 
    702702                 userName=None, 
    703703                 passPhrase=None, 
     
    707707        smWSDLuri:            URI For Session Manager WSDL used for user 
    708708                              authentication 
    709         smPubKeyFilePath:     file path for Session Manager public key.  If 
     709        smCertFilePath:     file path for Session Manager public key.  If 
    710710                              not set it will be retrieved using a  
    711711                              Session Manager WS call. 
     
    717717        self._smClnt = None 
    718718         
    719         self.smPubKeyFilePath = smPubKeyFilePath 
     719        self.smCertFilePath = smCertFilePath 
    720720         
    721721        self.userName = userName 
     
    921921            if not self._smClnt: 
    922922                self._smClnt = SessionClient(smWSDL=self.smWSDLuri, 
    923                                smPubKeyFilePath=self.smPubKeyFilePath, 
    924                                clntPubKeyFilePath=self.clntPubKeyFilePath, 
     923                               smCertFilePath=self.smCertFilePath, 
     924                               clntCertFilePath=self.clntCertFilePath, 
    925925                               clntPriKeyFilePath=self.clntPriKeyFilePath, 
    926926                               traceFile=self._wsDebug and sys.stderr or None) 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgr/__init__.py

    r1770 r1771  
    4242    def __init__(self,  
    4343                 uri=None,  
    44                  smPubKeyFilePath=None, 
    45                  clntPubKeyFilePath=None, 
     44                 smCertFilePath=None, 
     45                 clntCertFilePath=None, 
    4646                 clntPriKeyFilePath=None, 
    4747                 traceFile=None): 
     
    4949        uri:                  WSDL URI for Session Manager WS.  Setting it  
    5050                                 will set the Service Proxy 
    51         smPubKeyFilePath:     
     51        smCertFilePath:     
    5252                                 Public key of Session Manager used to encrypt 
    5353                                 the outgoing message if required - set as a 
    5454                                 path on the local file system or as a URI 
    55         clntPubKeyFilePath:      Public key of client.  This is passed to the 
     55        clntCertFilePath:      Public key of client.  This is passed to the 
    5656                                 Session Manager so that it can encrypt 
    5757                                 responses.  WARNING: if not set, responses 
    5858                                 are returned as clear text 
    59         clntPriKeyFilePath:      Private key of client.  If clntPubKeyFilePath 
     59        clntPriKeyFilePath:      Private key of client.  If clntCertFilePath 
    6060                                 is set, the private key is needed to decrypt  
    6161                                 the response from the Session Manager 
     
    6565        self.__smSrv = None 
    6666        self.__uri = None 
    67         self.__smPubKeyFilePath = None 
    68         self.__smPubKeyFilePath = None 
    69         self.__clntPubKeyFilePath = None 
    70         self.__clntPubKey = None 
     67        self.__smCertFilePath = None 
     68        self.__smCertFilePath = None 
     69        self.__clntCertFilePath = None 
     70        self.__clntCert = None 
    7171        self.__clntPriKeyFilePath = None 
    7272         
    73         self.__smPubKeyTempFile = None 
     73        self.__smCertTempFile = None 
    7474         
    7575         
     
    7777            self.__setURI(uri) 
    7878             
    79         if smPubKeyFilePath: 
    80             self.__setSMpubKeyFilePath(smPubKeyFilePath) 
     79        if smCertFilePath: 
     80            self.__setSMcertFilePath(smCertFilePath) 
    8181             
    8282        if clntPriKeyFilePath: 
    8383            self.__setClntPriKeyFilePath(clntPriKeyFilePath) 
    8484             
    85         if clntPubKeyFilePath: 
     85        if clntCertFilePath: 
    8686            if clntPriKeyFilePath is None: 
    8787                raise SessionMgrClientError, \ 
     
    8989                    "public key" 
    9090                     
    91             self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
     91            self.__setClntCertFilePath(clntCertFilePath) 
    9292 
    9393            
     
    113113 
    114114    #_________________________________________________________________________ 
    115     def __setSMpubKeyFilePath(self, smPubKeyFilePath): 
    116          
    117         if not isinstance(smPubKeyFilePath, basestring): 
     115    def __setSMcertFilePath(self, smCertFilePath): 
     116         
     117        if not isinstance(smCertFilePath, basestring): 
    118118            raise SessionMgrClientError, \ 
    119119                "Session Manager public key URI must be a valid string" 
    120120         
    121         self.__smPubKeyFilePath = smPubKeyFilePath 
    122          
    123     smPubKeyFilePath = property(fset=__setSMpubKeyFilePath, 
     121        self.__smCertFilePath = smCertFilePath 
     122         
     123    smCertFilePath = property(fset=__setSMcertFilePath, 
    124124                                doc="Set Session Manager public key URI") 
    125125 
    126126  
    127127    #_________________________________________________________________________ 
    128     def __setClntPubKeyFilePath(self, clntPubKeyFilePath): 
    129          
    130         if not isinstance(clntPubKeyFilePath, basestring): 
     128    def __setClntCertFilePath(self, clntCertFilePath): 
     129         
     130        if not isinstance(clntCertFilePath, basestring): 
    131131            raise SessionMgrClientError(\ 
    132132                "Client public key file path must be a valid string") 
    133133         
    134         self.__clntPubKeyFilePath = clntPubKeyFilePath 
     134        self.__clntCertFilePath = clntCertFilePath 
    135135        try: 
    136             self.__clntPubKey = open(self.__clntPubKeyFilePath).read() 
     136            self.__clntCert = open(self.__clntCertFilePath).read() 
    137137             
    138138        except IOError, (errNo, errMsg): 
    139139            raise SessionMgrClientError, "Reading certificate file \"%s\": %s" %\ 
    140                                         (self.__clntPubKeyFilePath, errMsg) 
     140                                        (self.__clntCertFilePath, errMsg) 
    141141                                
    142142        except Exception, e: 
    143143            raise SessionMgrClientError, "Reading certificate file \"%s\": %s" %\ 
    144                                         (self.__clntPubKeyFilePath, str(e)) 
    145          
    146     clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     144                                        (self.__clntCertFilePath, str(e)) 
     145         
     146    clntCertFilePath = property(fset=__setClntCertFilePath, 
    147147                                  doc="File path for client public key") 
    148148 
     
    162162 
    163163    #_________________________________________________________________________ 
    164     def __getSessionMgrPubKey(self): 
     164    def __getSessionMgrCert(self): 
    165165        """Retrieve the public key from the URI""" 
    166166         
    167167        # Don't proceed unless URI was set - user may have set public key via 
    168         # smPubKeyFilePath instead 
    169         if self.__smPubKeyFilePath is not None: 
     168        # smCertFilePath instead 
     169        if self.__smCertFilePath is not None: 
    170170            return 
    171171                 
    172172        try: 
    173             self.__smPubKeyTempFile = tempfile.NamedTemporaryFile() 
    174              
    175             pubKey = self.getPubKey() 
    176             open(self.__smPubKeyTempFile.name, "w").write(pubKey) 
    177              
    178             self.__smPubKeyFilePath = self.__smPubKeyTempFile.name 
     173            self.__smCertTempFile = tempfile.NamedTemporaryFile() 
     174             
     175            cert = self.getCert() 
     176            open(self.__smCertTempFile.name, "w").write(cert) 
     177             
     178            self.__smCertFilePath = self.__smCertTempFile.name 
    179179             
    180180        except IOError, (errNo, errMsg): 
    181181            raise SessionMgrClientError, \ 
    182182                                "Writing public key to temp \"%s\": %s" % \ 
    183                                 (self.__smPubKeyTempFile.name, errMsg)                                                                     
     183                                (self.__smCertTempFile.name, errMsg)                                                                     
    184184        except Exception, e: 
    185185            raise SessionMgrClientError, "Retrieving Session Manager " + \ 
     
    235235 
    236236        # If Public key was not set, retrieve from server 
    237         self.__getSessionMgrPubKey() 
     237        self.__getSessionMgrCert() 
    238238             
    239239     
     
    288288 
    289289        # If Public key was not set, retrieve from server 
    290         self.__getSessionMgrPubKey() 
     290        self.__getSessionMgrCert() 
    291291 
    292292         
     
    381381 
    382382        # If Public key was not set, retrieve from server 
    383         self.__getSessionMgrPubKey() 
     383        self.__getSessionMgrCert() 
    384384 
    385385             
     
    404404                                     
    405405    #_________________________________________________________________________ 
    406     def getPubKey(self): 
     406    def getCert(self): 
    407407        """Retrieve the public key of the Session Manager""" 
    408408         
    409409        try:    
    410             resp = self.__srv.getPubKey() 
     410            resp = self.__srv.getCert() 
    411411            return resp 
    412412         
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/SessionMgrIO.py

    r1642 r1771  
    235235                    "proxyCert":              "", 
    236236                    "aaWSDL":                 "", 
    237                     "aaPubKey":               "", 
     237                    "aaCert":               "", 
    238238                    "reqRole":                "", 
    239239                    "mapFromTrustedHosts":    "", 
     
    568568 
    569569#_____________________________________________________________________________ 
    570 class PubKeyReqError(XMLMsgError):     
    571     """Exception handling for NDG SessionMgr WS getPubKey request class.""" 
     570class CertReqError(XMLMsgError):     
     571    """Exception handling for NDG SessionMgr WS getCert request class.""" 
    572572    pass 
    573573 
     
    592592     
    593593    # Override base class class variables 
    594     xmlTagTmpl = {"pubKey": "", "errMsg": ""} 
     594    xmlTagTmpl = {"cert": "", "errMsg": ""} 
    595595                         
    596596 
     
    610610        # XML tags input as keywords expected - check minimum  
    611611        # required are present for SessionMgr getPubKey response 
    612         if 'pubKey' not in self and 'errMsg' not in self:             
     612        if 'cert' not in self and 'errMsg' not in self:             
    613613            raise PubKeyRespError(\ 
    614                 "PubKey response document must contain: \"pubKey\"" + \ 
     614                "PubKey response document must contain: \"cert\"" + \ 
    615615                " or \"errMsg\" keywords") 
    616616     
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/XMLSecDoc.py

    r1642 r1771  
    5252                 filePath=None, 
    5353                 signingKeyFilePath=None, 
    54                  encrPubKeyFilePath=None, 
     54                 encrCertFilePath=None, 
    5555                 encrPriKeyFilePath=None, 
    5656                 certFilePathList=None): 
     
    6767        self.__filePath = None 
    6868        self.__signingKeyFilePath = None 
    69         self.__encrPubKeyFilePath = None 
     69        self.__encrCertFilePath = None 
    7070        self.__encrPriKeyFilePath = None 
    7171        self.__certFilePathList = None 
     
    8787 
    8888        # Public key file to be used to encrypt document 
    89         if encrPubKeyFilePath is not None: 
    90             self.__setEncrPubKeyFilePath(encrPubKeyFilePath) 
     89        if encrCertFilePath is not None: 
     90            self.__setEncrCertFilePath(encrCertFilePath) 
    9191 
    9292 
     
    425425                "Certificate key file path must be a valid string") 
    426426 
    427         self.__encrPubKeyFilePath = filePath 
     427        self.__encrCertFilePath = filePath 
    428428 
    429429    # Publish attribute as write only 
    430     encrPubKeyFilePath = property(fset=__setEncrPubKeyFilePath, 
     430    encrCertFilePath = property(fset=__setEncrPubKeyFilePath, 
    431431        doc="file path for certificate publiv key used to decrypt doc") 
    432432 
     
    916916                xmlTxt=None,  
    917917                filePath=None,  
    918                 encrPubKeyFilePath=None, 
     918                encrCertFilePath=None, 
    919919                inclX509SubjName=True, 
    920920                inclX509IssSerial=True, 
     
    934934                                by self.__filePath is read instead. 
    935935                                 
    936         encrPubKeyFilePath:     file path to RSA public key file used to 
     936        encrCertFilePath:     file path to RSA public key file used to 
    937937                                encrypt the document. 
    938938                                 
     
    946946                                result instead as a string.""" 
    947947         
    948         if encrPubKeyFilePath: 
    949             self.__setEncrPubKeyFilePath(encrPubKeyFilePath) 
     948        if encrCertFilePath: 
     949            self.__setEncrPubKeyFilePath(encrCertFilePath) 
    950950             
    951951             
     
    962962        # Nb. 7 value corresponds to XMLSec "xmlSecKeyDataFormatCertPem" -  
    963963        # there isn't a variable set up for it in pyXMLSec 
    964         encrKey = xmlsec.cryptoAppKeyLoad(self.__encrPubKeyFilePath,  
     964        encrKey = xmlsec.cryptoAppKeyLoad(self.__encrCertFilePath,  
    965965                                          7, 
    966966                                          None,  
     
    970970            raise XMLSecDocError(\ 
    971971                "Error loading RSA public key from file \"%s\"" % \ 
    972                 self.__encrPubKeyFilePath) 
     972                self.__encrCertFilePath) 
    973973 
    974974 
    975975        # Set key name to the file name, this is just an example! 
    976         if encrKey.setName(self.__encrPubKeyFilePath) < 0: 
     976        if encrKey.setName(self.__encrCertFilePath) < 0: 
    977977            raise XMLSecDocError(\ 
    978978                "Error setting key name for RSA public key from \"%s\"" % \ 
    979                 self.__encrPubKeyFilePath) 
     979                self.__encrCertFilePath) 
    980980 
    981981 
     
    986986            raise XMLSecDocError(\ 
    987987                "Error adding RSA public key from \"%s\" to keys manager" % \ 
    988                 self.__encrPubKeyFilePath) 
     988                self.__encrCertFilePath) 
    989989 
    990990    
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/AttAuthority/AttAuthority_services.py

    r1727 r1771  
    7070 
    7171    # op: <ZSI.wstools.WSDLTools.Message instance at 0xb77f7bec> 
    72     def getPubKey(self): 
     72    def getCert(self): 
    7373 
    74         request = getPubKeyInputMsg() 
     74        request = getCertInputMsg() 
    7575 
    7676        kw = {} 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/__init__.py

    r1706 r1771  
    699699                # encryption for responses from Attribute Authority WS 
    700700                userSess = UserSession(proxyCert,  
    701                                    caPubKeyFilePath=self.__prop['caCertFile'], 
    702                                    clntPubKeyFilePath=self.__prop['certFile'], 
     701                                   caCertFilePath=self.__prop['caCertFile'], 
     702                                   clntCertFilePath=self.__prop['certFile'], 
    703703                                   clntPriKeyFilePath=self.__prop['keyFile'], 
    704704                                   clntPriKeyPwd=self.__prop['keyPPhrase'], 
     
    906906                   'encrCert', 
    907907                   'encrSessMgrWSDLuri',  
    908                    'aaPubKey') 
     908                   'aaCert') 
    909909                    
    910910        aaKeys = dict([i for i in reqKeys.items() if i[0] not in delKeys]) 
    911911 
    912912 
    913         if 'aaPubKey' not in reqKeys: 
     913        if 'aaCert' not in reqKeys: 
    914914            # Get public key using WS 
    915915            try: 
    916916                aaClnt = AttAuthorityClient(aaWSDL=reqKeys['aaWSDL'])                 
    917                 reqKeys['aaPubKey'] = aaClnt.getPubKey() 
     917                reqKeys['aaCert'] = aaClnt.getCert() 
    918918 
    919919            except Exception, e: 
     
    926926        # Attribute Authority 
    927927        try: 
    928             aaPubKeyTmpFile = tempfile.NamedTemporaryFile() 
    929             open(aaPubKeyTmpFile.name, "w").write(reqKeys['aaPubKey']) 
    930             aaKeys['aaPubKeyFilePath'] = aaPubKeyTmpFile.name 
     928            aaCertTmpFile = tempfile.NamedTemporaryFile() 
     929            open(aaCertTmpFile.name, "w").write(reqKeys['aaCert']) 
     930            aaKeys['aaCertFilePath'] = aaCertTmpFile.name 
    931931             
    932932        except IOError, (errNo, errMsg): 
     
    974974        try: 
    975975            sessClnt = SessionClient(smWSDL=userSessMgrWSDLuri, 
    976                                  clntPubKeyFilePath=self.__prop['certFile'], 
     976                                 clntCertFilePath=self.__prop['certFile'], 
    977977                                 clntPriKeyFilePath=self.__prop['keyFile'])            
    978978        except Exception, e: 
     
    986986        try: 
    987987            # encrCert key not needed - it gets set above via  
    988             # 'clntPubKeyFilePath' 
     988            # 'clntCertFilePath' 
    989989            if 'encrCert' in reqKeys: 
    990990                del reqKeys['encrCert'] 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/SessionMgrClientTest.py

    r1770 r1771  
    3232        # Gabriel settings 
    3333        gabrielConfig = {} 
    34         gabrielConfig['smWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl' 
    35         gabrielConfig['aaWSDL'] = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
     34        gabrielConfig['smURI'] = 'http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl' 
     35        gabrielConfig['aaURI'] = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
    3636 
    3737         
     
    4040        gabrielConfig['trustedHostRequiredRole'] = 'academic' 
    4141 
    42         gabrielConfig['aaPubKeyFilePath'] = None 
     42        gabrielConfig['aaCertFilePath'] = None 
    4343 
    4444        # Public key of session manager used to encrypt requests 
    4545        # If no public key is set, it will be retrieved using the 
    46         # getPubKey WS method 
    47         gabrielConfig['smPubKeyFilePath'] = None 
     46        # getCert WS method 
     47        gabrielConfig['smCertFilePath'] = None 
    4848 
    4949         
    5050        # Glue settings 
    5151        glueConfig = {} 
    52         glueConfig['smWSDL'] = 'http://glue.badc.rl.ac.uk/sessionMgr.wsdl' 
    53         glueConfig['aaWSDL'] = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
     52        glueConfig['smURI'] = 'http://glue.badc.rl.ac.uk/sessionMgr.wsdl' 
     53        glueConfig['aaURI'] = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
    5454 
    5555         
     
    5959        #glueConfig['trustedHostRequiredRole'] = 'coapec' 
    6060 
    61         glueConfig['aaPubKeyFilePath'] = None 
     61        glueConfig['aaCertFilePath'] = None 
    6262 
    6363        # Public key of session manager used to encrypt requests 
    6464        # If no public key is set, it will be retrieved using the 
    65         # getPubKey WS method 
    66         glueConfig['smPubKeyFilePath'] = None 
     65        # getCert WS method 
     66        glueConfig['smCertFilePath'] = None 
    6767 
    6868 
     
    7474        self.__clntPriKeyPwd = open("./tmp2").read().strip() 
    7575 
    76         clntPubKeyFilePath = "./Junk-cert.pem" 
     76        clntCertFilePath = "./Junk-cert.pem" 
    7777        clntPriKeyFilePath = "./Junk-key.pem" 
    7878        traceFile = None#sys.stderr 
     
    8080        # Initialise the Session Manager client connection 
    8181        # Omit traceFile keyword to leave out SOAP debug info 
    82         self.clnt = SessionMgrClient(smURI=self.config['smWSDL'], 
    83                         smPubKeyFilePath=self.config['smPubKeyFilePath'], 
    84                         clntPubKeyFilePath=clntPubKeyFilePath, 
     82        self.clnt = SessionMgrClient(smURI=self.config['smURI'], 
     83                        smCertFilePath=self.config['smCertFilePath'], 
     84                        clntCertFilePath=clntCertFilePath, 
    8585                        clntPriKeyFilePath=clntPriKeyFilePath, 
    8686                        traceFile=traceFile)  
     
    154154        authResp = self.clnt.reqAuthorisation(\ 
    155155                    sessID=self.sessCookie['NDG-ID1'].value,  
    156                     aaWSDL=self.config['aaWSDL'], 
     156                    aaURI=self.config['aaURI'], 
    157157                    encrSessMgrWSDLuri=self.sessCookie['NDG-ID2'].value, 
    158158                    clntPriKeyPwd=self.__clntPriKeyPwd) 
     
    178178        authResp = self.clnt.reqAuthorisation(\ 
    179179                                     proxyCert=self.proxyCert, 
    180                                      aaWSDL=self.config['aaWSDL'], 
     180                                     aaURI=self.config['aaURI'], 
    181181                                     clntPriKeyPwd=self.__clntPriKeyPwd) 
    182182                                              
    183         # The authorisation response is returned as an object which  
    184         # behaves like a python dictionary.  See  
    185         # ndg.security.SessionMgrIO.AuthorisationResp 
    186         if 'errMsg' in authResp: 
    187             print "Authorisation failed for user %s" % authResp['errMsg']            
    188         else: 
    189             print "User authorised" 
    190              
    191183        print authResp 
    192184 
    193185 
    194     def testGetPubKey(self): 
    195         "testGetPubKey: return the Session Manager's public key" 
    196         pubKey = self.clnt.getPubKey() 
     186    def testGetCert(self): 
     187        "testGetCert: return the Session Manager's public key" 
     188        cert = self.clnt.getCert() 
    197189                                              
    198         print "Public Key:\n" + pubKey 
     190        print "Public Key:\n" + cert 
    199191             
    200192             
     
    212204                    "testCookieReqAuthorisation", 
    213205                    "testProxyCertReqAuthorisation", 
    214                     "testGetPubKey", 
     206                    "testGetCert", 
    215207                  )) 
    216208        unittest.TestSuite.__init__(self, map) 
  • TI12-security/trunk/python/www/cgi-bin/idp.py

    r1636 r1771  
    2929 
    3030    smWSDLuri = "http://gabriel.bnsc.rl.ac.uk/sessionMgr.wsdl" 
    31     smPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
     31    smCertFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
    3232 
    33     clntPubKeyFilePath = "../certs/GabrielCGI-cert.pem" 
     33    clntCertFilePath = "../certs/GabrielCGI-cert.pem" 
    3434    clntPriKeyFilePath = "../certs/GabrielCGI-key.pem" 
    3535 
    3636    IdPcgi(os.path.basename(__file__), 
    3737           smWSDLuri, 
    38            smPubKeyFilePath=smPubKeyFilePath, 
    39            clntPubKeyFilePath=clntPubKeyFilePath, 
     38           smCertFilePath=smCertFilePath, 
     39           clntCertFilePath=clntCertFilePath, 
    4040           clntPriKeyFilePath=clntPriKeyFilePath)() 
  • TI12-security/trunk/python/www/cgi-bin/security.py

    r1636 r1771  
    274274    aaWSDL = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
    275275 
    276     smPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
    277     aaPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
    278  
    279     clntPubKeyFilePath = "../certs/GabrielCGI-cert.pem" 
     276    smCertFilePath = "/usr/local/NDG/conf/certs/gabriel-sm-cert.pem" 
     277    aaCertFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
     278 
     279    clntCertFilePath = "../certs/GabrielCGI-cert.pem" 
    280280    clntPriKeyFilePath = "../certs/GabrielCGI-key.pem" 
    281281 
     
    283283                                  aaWSDL, 
    284284                                                  scriptName=os.path.basename(__file__), 
    285                                   smPubKeyFilePath=smPubKeyFilePath, 
    286                                   aaPubKeyFilePath=aaPubKeyFilePath, 
    287                                   clntPubKeyFilePath=clntPubKeyFilePath, 
     285                                  smCertFilePath=smCertFilePath, 
     286                                  aaCertFilePath=aaCertFilePath, 
     287                                  clntCertFilePath=clntCertFilePath, 
    288288                                  clntPriKeyFilePath=clntPriKeyFilePath) 
    289289    securityCGI() 
  • TI12-security/trunk/python/www/cgi-bin/sp.py

    r1636 r1771  
    4444    returnURI = 'https://gabriel.bnsc.rl.ac.uk/cgi-bin/sp.py' 
    4545    aaWSDL = 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl' 
    46     aaPubKeyFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
     46    aaCertFilePath = "/usr/local/NDG/conf/certs/gabriel-aa-cert.pem" 
    4747 
    48     clntPubKeyFilePath = "../certs/GabrielCGI-cert.pem" 
     48    clntCertFilePath = "../certs/GabrielCGI-cert.pem" 
    4949    clntPriKeyFilePath = "../certs/GabrielCGI-key.pem" 
    5050 
     
    5252          returnURI, 
    5353          aaWSDL, 
    54           aaPubKeyFilePath=aaPubKeyFilePath, 
    55           clntPubKeyFilePath=clntPubKeyFilePath, 
     54          aaCertFilePath=aaCertFilePath, 
     55          clntCertFilePath=clntCertFilePath, 
    5656          clntPriKeyFilePath=clntPriKeyFilePath)() 
    5757 
Note: See TracChangeset for help on using the changeset viewer.