Changeset 737


Ignore:
Timestamp:
29/03/06 18:05:39 (13 years ago)
Author:
pjkersha
Message:

ndgSetup.sh: fixed slight typo.

mapConfig.xml: added pubKey tag to allow client to Attribute Authority to use it to encrypt
outbound messages to it.

ndgSessionClient.py:

  • include code to set public key of Attribute Authority so that Session Manager can encrypt

messages to it.

  • -r/--req-autho option now requires the AA WSDL URI. -a is now used to set the AA pub key
  • see previous point.

AttAuthorityIO.py:

  • Changed tag 'clntCert' to 'encrCert' so as to be consistent with SessionMgrIO.py code.

attAuthority_services_server.py:

  • Moved encrypt/decrypt code here from AttAuthority? class to be consistent with

sessionMgr_services_server.py.

AttAuthority?.py:

  • Now inherits from dict to allow convenient access to properties file parameters as dictionary

items.

  • Added code to include pubKey tag from mapConfig file in trustedHostInfo returned from

getTrustedHostInfo.

SessionMgrIO.py:

output XML.

  • Shifted test code into separate file in Tests/

SessionClient?.py:

  • Added aaPubKey to reqAuthorisation method - see above re. passing AA public key for

encryption of messages.

sessionMgr_services_server.py:

  • Changes to comments.

Session.py:

private key info of client to allow encrypt of responses from other WSs that SessionMgr? calls.
These are actually passed into CredWallet? instance of UserSession?.

  • AA Public key is passed into reqAuthorisation. This is written to a temp file for use by

XMLSec encryption code.

CredWallet?.py:

  • CredWalletAuthorisationDenied? - make sure extAttCertList gets set to []
  • Added pub/private functionality for encryption of messages to and from Attribute Authorities.
  • reqAuthorisation and getAATrustedHostInfo methods - read in client public key using

straight open/read: using X509Cert.asString() misses out the actual MIME encoded cert text(!)

  • Changed reqAuthorisation() - a required role is now optional with mapFromTrustedHosts flag set.

It does help though with finding a suitable AttCert? for mapping.

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

Legend:

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

    r712 r737  
    6161 
    6262#_____________________________________________________________________________ 
    63 class AttAuthority: 
     63class AttAuthority(dict): 
    6464 
    6565    """NDG Attribute Authority - server for user authentication/authorization. 
     
    9898                        this flag to False to override. 
    9999        """ 
     100 
     101        # Base class initialisation 
     102        dict.__init__(self) 
    100103         
    101104        if not isinstance(propFilePath, basestring): 
     
    184187            raise AttAuthorityError(\ 
    185188                "Error instantiating User Roles interface: " + str(e)) 
     189      
     190         
     191    #_________________________________________________________________________ 
     192    # Methods for Attribute Authority dictionary like behaviour         
     193    def __delitem__(self, key): 
     194        self.__class__.__name__ + " keys cannot be removed"         
     195        raise KeyError('Keys cannot be deleted from '+self.__class__.__name__) 
     196 
     197 
     198    def __getitem__(self, key): 
     199        self.__class__.__name__ + """ behaves as data dictionary of Attribute 
     200        Authority properties 
     201        """ 
     202        if key not in self.__prop: 
     203            raise KeyError("Invalid key " + key) 
     204         
     205        return self.__prop[key] 
     206         
     207 
     208    def clear(self): 
     209        raise KeyError("Data cannot be cleared from "+self.__class__.__name__) 
     210    
     211    def keys(self): 
     212        return self.__prop.keys() 
     213 
     214    def items(self): 
     215        return self.__prop.items() 
     216 
     217    def values(self): 
     218        return self.__prop.values() 
     219 
     220    def has_key(self, key): 
     221        return self.__prop.has_key(key) 
     222 
     223    # 'in' operator 
     224    def __contains__(self, key): 
     225        return key in self.__prop 
    186226 
    187227         
     
    568608            { 
    569609                'wsdl': elem.findtext('wsdl'), 
     610                'pubKey': elem.findtext('pubKey'), 
    570611                'role': [dict(i.items()) for i in roleElem] 
    571612            } 
     
    634675 
    635676     
    636     def getTrustedHostInfo(self, reqXMLtxt=None, **reqKeys): 
     677    def getTrustedHostInfo(self, **reqKeys): 
    637678        """Return a dictionary of the hosts that have trust relationships 
    638679        with this AA.  The dictionary is indexed by the trusted host name 
     
    643684        their possible roles 
    644685 
    645         Returns None if role isn't recognised 
    646          
    647         reqXMLtxt:              input keywords as tags in formatted XML string 
    648                                 String must follow format for  
    649                                 AttAuthorityIO.TrustedHostInfoReq class to 
    650                                 parse. 
    651                                 """ 
    652  
    653         if reqXMLtxt is not None: 
    654             # Parse XML text into keywords corresponding to the input 
    655             # parameters 
    656             if not isinstance(reqXMLtxt, basestring): 
    657                 raise AttAuthorityError(\ 
    658                             "XML Authorisation request must be a string") 
    659                                         
    660             # Parse and decrypt as necessary 
    661             try: 
    662                 # 1st assume that the request was encrypted 
    663                 reqKeys = TrustedHostInfoReq(encrXMLtxt=reqXMLtxt, 
    664                                     encrPriKeyFilePath=self.__prop['keyFile'], 
    665                                     encrPriKeyPwd=self.__prop['keyPwd']) 
    666             except Exception, e: 
    667                  
    668                 # Error occured decrypting - Trying parsing again, but this  
    669                 # time assuming non-encrypted 
    670                 try: 
    671                     reqKeys = TrustedHostInfoReq(xmlTxt=reqXMLtxt) 
    672                      
    673                 except Exception, e: 
    674                     raise AttAuthorityError(\ 
    675                         "Error parsing authorisation request: %s" % e) 
    676                                           
     686        Returns None if role isn't recognised""" 
    677687                                          
    678688        if not self.__localRole2Trusted: 
     
    687697               (k, \ 
    688698                {'wsdl': v['wsdl'], \ 
     699                 'pubKey': v['pubKey'], \ 
    689700                 'role': [role['remote'] for role in v['role']]}) \ 
    690701                for k, v in self.__mapConfig.items()]) 
     
    701712            trustedHostInfo = dict([(host, \ 
    702713                {'wsdl': self.__mapConfig[host]['wsdl'], \ 
     714                 'pubKey': self.__mapConfig[host]['pubKey'], \ 
    703715                 'role': self.__localRole2Trusted[host][reqKeys['role']]}) \ 
    704716                 for host in trustedHosts]) 
  • TI12-security/trunk/python/NDG/AttAuthorityIO.py

    r674 r737  
    3636    xmlTagTmpl = {  "proxyCert":    "", 
    3737                    "userAttCert":  "", 
    38                     "clntCert":     ""    } 
     38                    "encrCert":     ""    } 
    3939                     
    4040    xmlMandTags = ["proxyCert"] 
     
    267267     
    268268    # Override base class class variables 
    269     xmlTagTmpl = {  "role":    ""} 
     269    xmlTagTmpl = {"role": "", "encrCert": ""} 
    270270 
    271271 
  • TI12-security/trunk/python/NDG/CredWallet.py

    r674 r737  
    8484        self.__msg = msg 
    8585        self.__trustedHostInfo = trustedHostInfo 
     86         
     87        # Prevent None type setting 
     88        if extAttCertList is None: 
     89            extAttCertList = [] 
     90             
    8691        self.__extAttCertList = extAttCertList 
    8792 
     
    129134    def __init__(self, 
    130135                 proxyCertTxt, 
    131                  caCertFilePath=None, 
    132                  clntCertFilePath=None, 
     136                 caPubKeyFilePath=None, 
     137                 aaPubKeyFilePath=None, 
     138                 clntPubKeyFilePath=None, 
     139                 clntPriKeyFilePath=None, 
     140                 clntPriKeyPwd=None, 
    133141                 credRepos=None, 
    134142                 mapFromTrustedHosts=False, 
     
    137145 
    138146        proxy certificate:      users proxy certificate as string text 
    139         caCertFilePath:         Certificate Authority's certificate - used in 
     147        caPubKeyFilePath:       Certificate Authority's certificate - used in 
    140148                                validation of signed Attribute Certificates. 
    141149                                If not set here, it must be input in call 
    142                                 to reqAuthorisation 
    143         clntCertFilePath:       Public key certificate for this client.  
     150                                to reqAuthorisation. 
     151        aaPubKeyFilePath:       Public key of AA used to encrypt client  
     152                                requests to the AA. 
     153        clntPubKeyFilePath:     Public key certificate for this client.  
    144154                                Setting this enables return message from AA  
    145155                                WSDL to be encrypted by the AA. 
     156        clntPriKeyFilePath:     Client's Private key used to decrypt response 
     157                                from AA. 
     158        clntPriKeyPwd:          Password protecting the client private key. 
    146159        credRepos:              Credential Repository instance 
    147         mapFromTrustedHosts:   sets behaviour for reqAuthorisation().  If 
     160        mapFromTrustedHosts:    sets behaviour for reqAuthorisation().  If 
    148161                                set True and authorisation fails with the 
    149162                                given Attribute Authority, attempt to get 
     
    163176        self.proxyCertTxt = proxyCertTxt 
    164177         
    165         if caCertFilePath: 
    166             self.__setCAcertFilePath(caCertFilePath) 
    167         else: 
    168             self.__caCertFilePath = None 
    169              
    170         if clntCertFilePath: 
    171             self.__setClntCertFilePath(clntCertFilePath) 
    172         else: 
    173             self.__clntCertFilePath = None 
    174                   
     178        self.__setCApubKeyFilePath(caPubKeyFilePath) 
     179        self.__setAApubKeyFilePath(aaPubKeyFilePath) 
     180        self.__setClntPubKeyFilePath(clntPubKeyFilePath) 
     181        self.__setClntPriKeyFilePath(clntPriKeyFilePath) 
     182        self.__setClntPriKeyPwd(clntPriKeyPwd) 
     183                 
    175184        self.__credRepos = credRepos 
    176185         
     
    216225                     
    217226                    self.__credentials[issuerName] = \ 
    218                                              {'id':cred.id, 'attCert':attCert} 
     227                                             {'id':cred.id, 'attCert':attCert}                                            
    219228            except Exception, e: 
    220229                try: 
     
    227236                                          "Certificate retrieved from " + \ 
    228237                                          "the Credentials Repository: %s:" \ 
    229                                           % e) 
     238                                          % str(e)) 
    230239             
    231240             
     
    238247    def __str__(self): 
    239248        return "<Credential Wallet instance>" 
     249 
    240250 
    241251    #_________________________________________________________________________     
     
    303313 
    304314    #_________________________________________________________________________ 
    305     def __setCAcertFilePath(self, caCertFilePath): 
    306          
    307         if not isinstance(caCertFilePath, basestring): 
     315    def __setCApubKeyFilePath(self, caPubKeyFilePath): 
     316         
     317        if not isinstance(caPubKeyFilePath, basestring) and \ 
     318           caPubKeyFilePath is not None: 
    308319            raise CredWalletError(\ 
    309                 "Input CA Certificate file path is not valid") 
    310                  
    311         self.__caCertFilePath = caCertFilePath 
     320                "Input CA Certificate file path is not a valid string") 
     321                 
     322        self.__caPubKeyFilePath = caPubKeyFilePath 
    312323        
    313324         
    314     caCertFilePath = property(fset=__setCAcertFilePath, 
     325    caPubKeyFilePath = property(fset=__setCApubKeyFilePath, 
    315326                              doc="CA Certificate  - use to check AC XML Sig") 
    316327 
    317328 
    318329    #_________________________________________________________________________ 
    319     def __setClntCertFilePath(self, clntCertFilePath): 
    320          
    321         if not isinstance(clntCertFilePath, basestring): 
     330    def __setClntPubKeyFilePath(self, clntPubKeyFilePath): 
     331         
     332        if not isinstance(clntPubKeyFilePath, basestring) and \ 
     333           clntPubKeyFilePath is not None: 
    322334            raise CredWalletError(\ 
    323                 "Input Client Certificate file path is not valid") 
    324                  
    325         self.__clntCertFilePath = clntCertFilePath 
     335                "Input Client Certificate file path is not a valid string") 
     336                 
     337        self.__clntPubKeyFilePath = clntPubKeyFilePath 
    326338        
    327339         
    328     clntCertFilePath = property(fset=__setClntCertFilePath, 
    329                     doc="Client Certificate  - use to encrypt resp from AA") 
    330  
    331  
    332  
     340    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     341                        doc="Client Public Key - use to encrypt resp from AA") 
     342 
     343 
     344    #_________________________________________________________________________ 
     345    def __setClntPriKeyFilePath(self, clntPriKeyFilePath): 
     346         
     347        if not isinstance(clntPriKeyFilePath, basestring) and \ 
     348           clntPriKeyFilePath is not None: 
     349            raise CredWalletError(\ 
     350                "Input Client Private Key file path is not a valid string") 
     351                 
     352        self.__clntPriKeyFilePath = clntPriKeyFilePath 
     353        
     354         
     355    clntPriKeyFilePath = property(fset=__setClntPriKeyFilePath, 
     356                    doc="Client Private Key - use to decrypt resp from AA") 
     357 
     358 
     359    #_________________________________________________________________________ 
     360    def __setClntPriKeyPwd(self, clntPriKeyPwd): 
     361         
     362        if not isinstance(clntPriKeyPwd, basestring) and \ 
     363           clntPriKeyPwd is not None: 
     364            raise CredWalletError(\ 
     365                "Input Client Private Key password is not a valid string") 
     366                 
     367        self.__clntPriKeyPwd = clntPriKeyPwd 
     368        
     369         
     370    clntPriKeyPwd = property(fset=__setClntPriKeyPwd, 
     371                             doc="Password for Client Private Key") 
     372 
     373 
     374    #_________________________________________________________________________ 
    333375    def isValid(self, **x509CertKeys): 
    334376        """Check wallet's proxy cert.  If expired return False""" 
     
    340382 
    341383 
    342      
     384    #_________________________________________________________________________ 
    343385    def addCredential(self, attCert, bUpdateCredRepos=True): 
    344386        """Add a new attribute certificate to the list of credentials held. 
     
    447489                           aaPropFilePath=None, 
    448490                           aaWSDL=None, 
    449                            aaCertFilePath=None, 
     491                           aaPubKeyFilePath=None, 
    450492                           extAttCert=None, 
    451493                           bDebug=False): 
     
    465507                                specify a local Attribute Authority 
    466508                                configuration file. 
    467   
    468         aaCertFilePath:         Public key certificate for Attribute  
    469                                 Authority.  Pass this to enable message level 
    470                                 encryption of outgoing message to AA WS. 
    471                                 Applies only where aaWSDL is set.  If omitted, 
    472                                 outgoing message is not enrypted.  In this 
    473                                 case SSL could be used instead to encrypt the  
    474                                 message. 
    475509        extAttCert:             an existing Attribute Certificate which can be 
    476510                                used to making a mapping should the user not 
     
    480514            if not isinstance(extAttCert, AttCert): 
    481515                raise CredWalletError(\ 
    482                     "Input Attribute Certificate must be AttCert type") 
     516                        "Input Attribute Certificate must be AttCert type") 
    483517             
    484518        if aaWSDL is not None: 
     
    487521                                      "path must be a valid string") 
    488522 
    489             if self.__clntCertFilePath: 
    490                 clntCertTxt = \ 
    491                     X509Cert(filePath=self.__clntCertFilePath).asString() 
     523            if self.__clntPubKeyFilePath: 
     524                try: 
     525                    clntCert = open(self.__clntPubKeyFilePath).read() 
     526                     
     527                except IOError, (errNo, errMsg): 
     528                    raise optparse.OptionValueError(\ 
     529                                "Reading client public key file \"%s\": %s" %\ 
     530                                (self.__clntPubKeyFilePath, errMsg)) 
     531                                        
     532                except Exception, e: 
     533                    raise optparse.OptionValueError(\ 
     534                                "Reading client public key file \"%s\": %s" %\ 
     535                                (self.__clntPubKeyFilePath, str(e)))                 
    492536            else: 
    493                 clntCertTxt = None 
     537                clntCert = None 
    494538                 
    495539                 
     
    507551                # Format XML request message 
    508552                # 
    509                 # Message will be encrypted if aaCertFilePath was set 
     553                # Message will be encrypted if aaPubKeyFilePath was set 
    510554                authorisationReq = AuthorisationReq(\ 
    511                                             proxyCert=self.__proxyCertTxt, 
    512                                             userAttCert=extAttCert, 
    513                                             clntCert=clntCertTxt, 
    514                                             encrPubKeyFilePath=aaCertFilePath) 
     555                                proxyCert=self.__proxyCertTxt, 
     556                                userAttCert=extAttCert, 
     557                                encrCert=clntCert, 
     558                                encrPubKeyFilePath=aaPubKeyFilePath) 
    515559                               
    516560                # Call Attribute Authority's Web service 
     
    522566                 
    523567            except Exception, e: 
    524                 raise CredWalletError("Requesting authorisation: %s" % e) 
     568                raise CredWalletError("Requesting authorisation: %s" % str(e)) 
    525569 
    526570 
    527571            # Parse the response 
    528572            authorisationResp = AuthorisationResp(\ 
    529                                     xmlTxt=str(resp['authorisationResp'])) 
     573                                 xmlTxt=resp['authorisationResp'], 
     574                                 encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     575                                 encrPriKeyPwd=self.__clntPriKeyPwd) 
    530576                                     
    531577            # Check the status code returned from the authorisation request 
     
    579625        # Update attribute Certificate instance with CA's certificate ready  
    580626        # for signature check in addCredential() 
    581         if self.__caCertFilePath is None: 
     627        if self.__caPubKeyFilePath is None: 
    582628            raise CredWalletError("No CA certificate has been set") 
    583629         
    584         attCert.certFilePathList = self.__caCertFilePath 
     630        attCert.certFilePathList = self.__caPubKeyFilePath 
    585631 
    586632         
     
    597643 
    598644    def getAATrustedHostInfo(self, 
    599                              userRole, 
     645                             userRole=None, 
    600646                             aaWSDL=None, 
     647                             aaPubKeyFilePath=None, 
    601648                             aaPropFilePath=None): 
    602649        """Wrapper to Attribute Authority getTrustedHostInfo 
     
    609656                                configuration file.""" 
    610657 
    611         if not isinstance(userRole, basestring) or not userRole: 
     658        if userRole is not None and not isinstance(userRole, basestring): 
    612659            raise CredWalletError("User Role must be a valid string") 
    613660 
    614661         
    615662        if aaWSDL is not None: 
    616  
     663            # Call Attribute Authority WS 
    617664            if not isinstance(aaWSDL, basestring): 
    618665                raise CredWalletError("Attribute Authority WSDL file " + \ 
    619666                                      "path must be a valid string") 
    620667 
     668 
     669            if self.__clntPubKeyFilePath: 
     670                # Read client certificate into a string ready to pass over  
     671                # SOAP connection 
     672                try: 
     673                    clntCert = open(self.__clntPubKeyFilePath).read() 
     674                     
     675                except IOError, (errNo, errMsg): 
     676                    raise optparse.OptionValueError(\ 
     677                                "Reading client public key file \"%s\": %s" %\ 
     678                                (self.__clntPubKeyFilePath, errMsg)) 
     679                                        
     680                except Exception, e: 
     681                    raise optparse.OptionValueError(\ 
     682                                "Reading client public key file \"%s\": %s" %\ 
     683                                (self.__clntPubKeyFilePath, str(e)))                 
     684            else: 
     685                clntCert = None 
     686 
     687 
    621688            try:                 
    622689                # Get Attribute Authority web service interface 
     
    624691                 
    625692                # Format request 
    626                 trustedHostInfoReq = TrustedHostInfoReq(role=userRole) 
     693                trustedHostInfoReq = TrustedHostInfoReq(role=userRole, 
     694                                encrCert=clntCert, 
     695                                encrPubKeyFilePath=aaPubKeyFilePath) 
    627696                 
    628697                # Call Attribute Authority's Web service 
    629698                resp = aaSrv.getTrustedHostInfo(\ 
    630                                     trustedHostInfoReq=trustedHostInfoReq()) 
    631                                      
     699                                     trustedHostInfoReq=trustedHostInfoReq()) 
     700                                    
    632701                # Parse response 
    633702                trustedHostInfoResp = TrustedHostInfoResp(\ 
    634                                     xmlTxt=str(resp['trustedHostInfoResp'])) 
     703                                 xmlTxt=resp['trustedHostInfoResp'], 
     704                                 encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     705                                 encrPriKeyPwd=self.__clntPriKeyPwd) 
     706                                  
    635707                if 'errMsg' in trustedHostInfoResp and \ 
    636708                   trustedHostInfoResp['errMsg']: 
     
    650722            # Call local based Attribute Authority with settings from the  
    651723            # configuration file aaPropFilePath 
    652  
    653724            if not instance(aaWSDL, basestring): 
    654725                raise CredWalletError("Attribute Authority Configuration " + \ 
     
    677748                         aaPropFilePath=None, 
    678749                         aaWSDL=None, 
    679                          aaCertFilePath=None, 
    680                          clntCertFilePath=None, 
    681                          caCertFilePath=None, 
     750                         aaPubKeyFilePath=None, 
    682751                         mapFromTrustedHosts=None, 
    683752                         rtnExtAttCertList=None, 
     
    696765                                specify a local Attribute Authority 
    697766                                configuration file. 
    698  
    699         aaCertFilePath:         Public key certificate for Attribute  
    700                                 Authority.  Pass this to enable message level 
    701                                 encryption of outgoing message to AA WS. 
    702                                 Applies only where aaWSDL is set.  If omitted, 
    703                                 outgoing message is not enrypted.  In this 
    704                                 case SSL could be used instead to encrypt the  
    705                                 message. 
    706767                                 
    707         clntCertFilePath:       Public key certificate for this client.  
    708                                 Setting this enables return message from AA  
    709                                 WSDL to be encrypted by the AA. 
    710  
    711         caCertFilePath:         Certificate Authority's certificate used to 
    712                                 validate the signature of any Attribute 
    713                                 Certificate returned from the Attribute 
    714                                 Authority 
     768        aaPubKeyFilePath:       Public key of AA used to encrypt client  
     769                                requests to the AA. 
    715770 
    716771        mapFromTrustedHosts:    if authorisation fails via the user's proxy 
     
    778833 
    779834 
    780         if caCertFilePath is not None: 
    781             self.caCertFilePath = caCertFilePath 
    782              
    783         if clntCertFilePath is not None: 
    784             self.clntCertFilePath = clntCertFilePath 
    785  
    786              
    787835        # Check for settings from input, if not set use previous settings 
    788836        # made 
     
    841889            try: 
    842890                attCert = self.__reqAuthorisation(aaWSDL=aaWSDL, 
    843                                                 aaPropFilePath=aaPropFilePath, 
    844                                                 aaCertFilePath=aaCertFilePath, 
    845                                                 extAttCert=extAttCert)                 
     891                                            aaPubKeyFilePath=aaPubKeyFilePath, 
     892                                            aaPropFilePath=aaPropFilePath, 
     893                                            extAttCert=extAttCert)                 
    846894                # Access granted 
    847895                return attCert 
     
    851899                # If a required role was set then it's possible to go 
    852900                # to get certificates with mapped roles from trusted hosts 
    853                 if not reqRole: 
    854                     raise CredWalletAuthorisationDenied(\ 
    855                         "No user role was input in order to map to " + \ 
    856                         "a role in a trusted host") 
     901                # Shouldn't need to set a role - setting a role makes it more 
     902                # efficient but it's not essential 
     903                # 
     904                # P J Kershaw 29/03/06 
     905#                if not reqRole: 
     906#                    raise CredWalletAuthorisationDenied(\ 
     907#                        "No user role was input in order to map to " + \ 
     908#                        "a role in a trusted host") 
    857909 
    858910 
     
    908960 
    909961                        try: 
     962                            # Get public key of Attribute Authority to allow 
     963                            # outgoing message to be encrypted 
     964                            aaPubKeyTemp = self.__retrieveURI(val['pubKey']) 
     965                             
    910966                            extAttCert = self.__reqAuthorisation(\ 
    911                                                        aaWSDL=val['wsdl']) 
     967                                           aaWSDL=val['wsdl'] 
     968                                           aaPubKeyFilePath=aaPubKeyTemp.name) 
    912969 
    913970                            # Check the certificate contains at least one of 
     
    9491006                raise authorisationError 
    9501007             
    951   
     1008 
     1009    #_________________________________________________________________________ 
     1010    def __retrieveURI(self, uri): 
     1011        """Retrieve content from a URI - use to get public key from a  
     1012        remote Attribute Authority 
     1013         
     1014        Nb. If tempFile goes out of scope the temporary file containing the  
     1015        URI content will be deleted also""" 
     1016         
     1017        try: 
     1018            tempFile = tempfile.NamedTemporaryFile() 
     1019            (fileName, httpResp) = urllib.urlretrieve(uri, 
     1020                                                      tempFile.name) 
     1021        except Exception, e: 
     1022            raise SessionMgrError("Error retrieving from URI " + \ 
     1023                                  "\"%s\": %s" % (uri, str(e))) 
     1024     
     1025        # Expecting plain text format for returned public key file 
     1026        # 404 error would come back as 'text/html' 
     1027        if 'text/plain' not in httpResp['Content-type']: 
     1028            raise SessionMgrError("Error retrieving from URI " + \ 
     1029                                  "\"%s\": expecting \"plain/text\"" % uri) 
     1030             
     1031        return tempFile 
    9521032  
    9531033         
  • TI12-security/trunk/python/NDG/Session.py

    r712 r737  
    402402        self.__class__.__name__ + """ behaves as data dictionary of Session 
    403403        Manager properties 
    404  
    405         Nb. also possible to apply keys belonging validity and attributes 
    406         sub dictionaries 
    407404        """ 
    408405        if key not in self.__prop: 
     
    699696                # Create a new user session using the new proxy certificate 
    700697                # and session ID 
    701                 userSess=UserSession(proxyCert,  
    702                                      caCertFilePath=self.__prop['caCertFile'], 
    703                                      credRepos=self.__credRepos)                 
     698                # 
     699                # Nb. Client pub/pri key info to allow message level  
     700                # encryption for responses from Attribute Authority WS 
     701                userSess = UserSession(proxyCert,  
     702                                caPubKeyFilePath=self.__prop['caCertFile'], 
     703                                clntPubKeyFilePath=self.__prop['certFile'], 
     704                                clntPriKeyFilePath=self.__prop['keyFile'], 
     705                                clntPriKeyPwd=self.__prop['keyPPhrase'], 
     706                                credRepos=self.__credRepos)                 
    704707                newSessID = userSess.latestSessID 
    705708                 
     
    833836                   'encrCert', 
    834837                   'encrSessMgrWSDLuri',  
    835                    'encrSessMgrPubKeyURI') 
     838                   'encrSessMgrPubKeyURI', 
     839                   'aaPubKey') 
    836840                    
    837841        aaKeys = dict([i for i in reqKeys.items() if i[0] not in delKeys]) 
    838                  
    839          
    840         # Ensure CA certificate file is set 
    841         if not "caCertFilePath" in aaKeys: 
    842             aaKeys['caCertFilePath'] = self.__prop['caCertFile'] 
    843  
    844              
     842 
     843 
     844        # Make a temporary file to hold Attribute Authority Public Key.  The 
     845        # Credential Wallet needs this to encrypt requests to the Attribute 
     846        # Authority 
     847        try: 
     848            aaPubKeyTmpFile = tempfile.NamedTemporaryFile() 
     849            open(aaPubKeyTmpFile.name, "w").write(reqKeys['aaPubKey']) 
     850            aaKeys['aaPubKeyFilePath'] = aaPubKeyTmpFile.name 
     851             
     852        except Exception, e: 
     853            raise SessionMgrError("Making temporary file for Attribute " + \ 
     854                                  "Authority public key: %s" % str(e)) 
     855                                   
     856                                               
    845857        # User's Credential Wallet carries out authorisation request to the 
    846858        # Attribute Authority 
  • TI12-security/trunk/python/NDG/SessionClient.py

    r712 r737  
    348348                         proxyCert=None, 
    349349                         aaWSDL=None, 
     350                         aaPubKey=None, 
    350351                         reqRole=None, 
    351352                         mapFromTrustedHosts=False, 
     
    362363                               a cookie in the case of a command line client. 
    363364        aaWSDL:                WSDL URI for Attribute Authority WS. 
     365        aaPubKey:              The Session Manager uses the Public key of the 
     366                               Attribute Authority to encrypt requests to it. 
    364367        reqRole:               The required role for access to a data set. 
    365368                               This can be left out in which case the  
     
    399402        try: 
    400403            authReq = AuthorisationReq(aaWSDL=aaWSDL, 
     404                             aaPubKey=aaPubKey, 
    401405                             sessID=sessCookie['NDG-ID1'].value,  
    402406                             encrSessMgrWSDLuri=sessCookie['NDG-ID2'].value, 
  • TI12-security/trunk/python/NDG/SessionMgrIO.py

    r686 r737  
    231231                    "proxyCert":              "", 
    232232                    "aaWSDL":                 "", 
     233                    "aaPubKey":               "", 
    233234                    "reqRole":                "", 
    234235                    "mapFromTrustedHosts":    "", 
     
    330331 
    331332        if extAttCertList is not None: 
    332             if not isinstance(extAttCertList, list): 
    333                 raise TypeError(\ 
    334                     "\"extAttCertList\" must be of list type") 
    335       
    336       
    337             # Join into single string and filter out XML headers as   
    338             # ElementTree doesn't like these nested into a doc                         
    339             attCertList = map(setAttCert, extAttCertList) 
    340         else: 
    341             attCertList = None 
     333            if isinstance(extAttCertList, list): 
     334                  
     335                # Join into single string and filter out XML headers as   
     336                # ElementTree doesn't like these nested into a doc                         
     337                extAttCertList = map(setAttCert, extAttCertList) 
     338             
     339            elif extAttCertList == '': 
     340                extAttCertList = [] 
     341            else: 
     342                raise TypeError("\"extAttCertList\" must be of list type") 
    342343                 
    343344        # Call super class update with revised attribute certificate list 
    344345        super(self.__class__, self).update(attCert=setAttCert(attCert), 
    345                                            extAttCertList=attCertList, 
     346                                           extAttCertList=extAttCertList, 
    346347                                           **xmlTags) 
    347348 
     
    378379                elif isinstance(self[tag], bool): 
    379380                    text = "%d" % self[tag] 
     381                     
     382                elif self[tag] is None: 
     383                    # Leave out altogether if set to None 
     384                    continue 
    380385                else:         
    381386                    text = self[tag] 
     
    396401         
    397402        rootElem = super(self.__class__, self).parseXML(rtnRootElem=True) 
    398          
     403 
    399404        extAttCertListElem = rootElem.find("extAttCertList") 
    400405        if extAttCertListElem: 
     
    409414                raise AuthorisationRespError(\ 
    410415                    "Error parsing Ext. Attribute Certificate List: "+str(e))                                 
    411   
    412                                          
    413 #_____________________________________________________________________________     
    414 if __name__ == "__main__": 
    415      # Client side - Set up input for SessionMgr WSDL connect() 
    416 #    cr = ConnectReq(userName="WileECoyote",  
    417 #                    pPhrase="ACME Road Runner catcher",  
    418 #                    encrPubKeyFilePath="../certs/badc-aa-cert.pem") 
    419  
    420     # Server side - decrypt connectReq from connect() request 
    421 #    cr = ConnectReq(encrXMLtxt=open("../Tests/xmlsec/connectReq.xml").read(), 
    422 #                  encrPriKeyFilePath="../certs/badc-aa-key.pem", 
    423 #                  encrPriKeyPwd="    ") 
    424  
    425     # Server side - make a connect response message 
    426 #    cr1 = ConnectResp(sessCookie="A proxy certificate") 
    427 # 
    428 #    cr2 = ConnectResp(sessCookie="A session cookie",  
    429 #                      encrPubKeyFilePath="../certs/badc-aa-cert.pem") 
    430                    
    431 #    import pdb 
    432 #    pdb.set_trace() 
    433      
    434     extAttCertList = [ 
    435 """<?xml version="1.0"?> 
    436 <attributeCertificate> 
    437     <acInfo> 
    438         <version>1.0</version> 
    439         <holder>/CN=pjkersha/O=NDG/OU=BADC</holder> 
    440         <issuer>/CN=Attribute Authority/O=NDG/OU=BADC</issuer> 
    441         <issuerName>BADC</issuerName> 
    442         <issuerSerialNumber>6578</issuerSerialNumber>  
    443     <validity> 
    444           <notBefore>2005 09 16 11 53 36</notBefore>  
    445         <notAfter>2005 09 16 19 53 29</notAfter>  
    446     </validity> 
    447     <attributes> 
    448         <roleSet> 
    449                 <role> 
    450                 <name>government</name> 
    451         </role> 
    452         </roleSet> 
    453     </attributes> 
    454     <provenance>original</provenance>  
    455     </acInfo> 
    456 <Signature xmlns="http://www.w3.org/2000/09/xmldsig#"> 
    457 <SignedInfo> 
    458 <CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/> 
    459 <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/> 
    460 <Reference> 
    461 <Transforms> 
    462 <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/> 
    463 </Transforms> 
    464 <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/> 
    465 <DigestValue>i1q2jwEDy0Sxc+ChxW9p4KCBynU=</DigestValue> 
    466 </Reference> 
    467 </SignedInfo> 
    468 <SignatureValue>aXmExRkD4mZ9OdSlUcVUPIZ/r5v31Dq6IwU7Ox2/evd6maZeECVH4kGvGGez2VA5 
    469 lKhghRqgmAPsgEfZlZ3XwFxxo8tQuY6pi19OqwLV51R5klysX6fKkyK2JVoUG8Y3 
    470 7fACirNGZrZyf93X8sTvd02xN1DOTp7zt1afDsu3qGE=</SignatureValue> 
    471 <KeyInfo> 
    472 <X509Data> 
    473  
    474  
    475  
    476 <X509Certificate>MIICKDCCAZGgAwIBAgICGbIwDQYJKoZIhvcNAQEEBQAwYTEMMAoGA1UEChMDTkRH 
    477 MQ0wCwYDVQQLEwRCQURDMScwJQYDVQQLFB5uZGdwdXJzZWNhQGZvZWhuLmJhZGMu 
    478 cmwuYWMudWsxGTAXBgNVBAMTEEdsb2J1cyBTaW1wbGUgQ0EwHhcNMDUwODExMTQ1 
    479 NjM4WhcNMDYwODExMTQ1NjM4WjA7MQwwCgYDVQQKEwNOREcxDTALBgNVBAsTBEJB 
    480 REMxHDAaBgNVBAMTE0F0dHJpYnV0ZSBBdXRob3JpdHkwgZ8wDQYJKoZIhvcNAQEB 
    481 BQADgY0AMIGJAoGBALgmuDF/jKxKlCMqhF835Yge6rHxZFLby9BbXGsa2pa/1BAY 
    482 xJUiou8sIXO7yaWaRP7M9FwW64Vdk+HQI5zluG2Gtx4MgKYElUDCgPYXsvAXg0QG 
    483 bo0KSPr+X489j07HegXGjekNejLwwvB7qTSqxHjAaKAKL7vBfWf5mn0mlIwbAgMB 
    484 AAGjFTATMBEGCWCGSAGG+EIBAQQEAwIE8DANBgkqhkiG9w0BAQQFAAOBgQAmmqnd 
    485 rj6mgbaruLepn5pyh8sQ+Qd7fwotW00rEBRYzJNUUObmIry5ZM5zuVMcaPSY57qY 
    486 vWqnavydIPdu6N97/Tf/RLk8crLVOrqj2Mo0bwgnEnjmrQicIDsWj6bFNsX1kr6V 
    487 MtUg6T1zo/Yz1aYgGcW4A/ws5tmcEHS0PUGIGA==</X509Certificate> 
    488 <X509SubjectName>CN=Attribute Authority,OU=BADC,O=NDG</X509SubjectName> 
    489 <X509IssuerSerial> 
    490 <X509IssuerName>CN=Globus Simple CA,OU=ndgpurseca@foehn.badc.rl.ac.uk,OU=BADC,O=NDG</X509IssuerName> 
    491 <X509SerialNumber>6578</X509SerialNumber> 
    492 </X509IssuerSerial> 
    493 </X509Data> 
    494 </KeyInfo> 
    495 </Signature></attributeCertificate>""", 
    496 """<?xml version="1.0"?> 
    497 <attributeCertificate> 
    498     <acInfo> 
    499         <version>1.0</version> 
    500         <holder>/CN=pjkersha/O=NDG/OU=BADC</holder> 
    501         <issuer>/CN=Attribute Authority/O=NDG/OU=BADC</issuer> 
    502         <issuerName>BADC</issuerName> 
    503         <issuerSerialNumber>6578</issuerSerialNumber>  
    504     <validity> 
    505           <notBefore>2005 09 29 15 45 49</notBefore>  
    506         <notAfter>2005 09 29 23 45 49</notAfter>  
    507     </validity> 
    508     <attributes> 
    509         <roleSet> 
    510                 <role> 
    511                 <name>government</name> 
    512         </role> 
    513         </roleSet> 
    514     </attributes> 
    515     <provenance>original</provenance>  
    516     </acInfo> 
    517 <Signature xmlns="http://www.w3.org/2000/09/xmldsig#"> 
    518 <SignedInfo> 
    519 <CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/> 
    520 <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/> 
    521 <Reference> 
    522 <Transforms> 
    523 <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/> 
    524 </Transforms> 
    525 <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/> 
    526 <DigestValue>/Kw9IbBQuQAdNYAgvp2m01l663k=</DigestValue> 
    527 </Reference> 
    528 </SignedInfo> 
    529 <SignatureValue>Q7lhq/jt+m2trRPyWrZ6BQcIibXrstVS/xKTAhR4puv7kVngIm64r45MJ2GQpQan 
    530 QaVdVuOl8QPX8ila0j8sIz47FtriRWZ8fCssFYWR/7n3AKjNd22ChAshxHfZCJY4 
    531 fzJSXgEN+FN0ArOWT49FbhDVf7LEGO+MR+TP+ZKt6uY=</SignatureValue> 
    532 <KeyInfo> 
    533 <X509Data> 
    534  
    535  
    536  
    537 <X509Certificate>MIICKDCCAZGgAwIBAgICGbIwDQYJKoZIhvcNAQEEBQAwYTEMMAoGA1UEChMDTkRH 
    538 MQ0wCwYDVQQLEwRCQURDMScwJQYDVQQLFB5uZGdwdXJzZWNhQGZvZWhuLmJhZGMu 
    539 cmwuYWMudWsxGTAXBgNVBAMTEEdsb2J1cyBTaW1wbGUgQ0EwHhcNMDUwODExMTQ1 
    540 NjM4WhcNMDYwODExMTQ1NjM4WjA7MQwwCgYDVQQKEwNOREcxDTALBgNVBAsTBEJB 
    541 REMxHDAaBgNVBAMTE0F0dHJpYnV0ZSBBdXRob3JpdHkwgZ8wDQYJKoZIhvcNAQEB 
    542 BQADgY0AMIGJAoGBALgmuDF/jKxKlCMqhF835Yge6rHxZFLby9BbXGsa2pa/1BAY 
    543 xJUiou8sIXO7yaWaRP7M9FwW64Vdk+HQI5zluG2Gtx4MgKYElUDCgPYXsvAXg0QG 
    544 bo0KSPr+X489j07HegXGjekNejLwwvB7qTSqxHjAaKAKL7vBfWf5mn0mlIwbAgMB 
    545 AAGjFTATMBEGCWCGSAGG+EIBAQQEAwIE8DANBgkqhkiG9w0BAQQFAAOBgQAmmqnd 
    546 rj6mgbaruLepn5pyh8sQ+Qd7fwotW00rEBRYzJNUUObmIry5ZM5zuVMcaPSY57qY 
    547 vWqnavydIPdu6N97/Tf/RLk8crLVOrqj2Mo0bwgnEnjmrQicIDsWj6bFNsX1kr6V 
    548 MtUg6T1zo/Yz1aYgGcW4A/ws5tmcEHS0PUGIGA==</X509Certificate> 
    549 <X509SubjectName>CN=Attribute Authority,OU=BADC,O=NDG</X509SubjectName> 
    550 <X509IssuerSerial> 
    551 <X509IssuerName>CN=Globus Simple CA,OU=ndgpurseca@foehn.badc.rl.ac.uk,OU=BADC,O=NDG</X509IssuerName> 
    552 <X509SerialNumber>6578</X509SerialNumber> 
    553 </X509IssuerSerial> 
    554 </X509Data> 
    555 </KeyInfo> 
    556 </Signature></attributeCertificate>""", 
    557 """<?xml version="1.0"?> 
    558 <attributeCertificate> 
    559     <acInfo> 
    560         <version>1.0</version> 
    561         <holder>/CN=pjkersha/O=NDG/OU=BADC</holder> 
    562         <issuer>/CN=Attribute Authority/O=NDG/OU=BADC</issuer> 
    563         <issuerName>BADC</issuerName> 
    564         <issuerSerialNumber>6578</issuerSerialNumber>  
    565     <validity> 
    566           <notBefore>2005 09 16 10 19 32</notBefore>  
    567         <notAfter>2005 09 16 18 19 14</notAfter>  
    568     </validity> 
    569     <attributes> 
    570         <roleSet> 
    571                 <role> 
    572                 <name>government</name> 
    573         </role> 
    574         </roleSet> 
    575     </attributes> 
    576     <provenance>original</provenance>  
    577     </acInfo> 
    578 <Signature xmlns="http://www.w3.org/2000/09/xmldsig#"> 
    579 <SignedInfo> 
    580 <CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/> 
    581 <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/> 
    582 <Reference> 
    583 <Transforms> 
    584 <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/> 
    585 </Transforms> 
    586 <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/> 
    587 <DigestValue>tvftcf7fevu4PQqK2PhGFVzZlFo=</DigestValue> 
    588 </Reference> 
    589 </SignedInfo> 
    590 <SignatureValue>cga7gcRSeKkI8+k5HiRdfxDz0wRA741lRaI0FCZ0e7rJH3IwxEv6C3fNB0a8Slgv 
    591 R2/1b+xCHtNX0jaMLDnAv/AvtC8DfcV8yiDZOAQ/qXDkASB2OHDo6qM+Zlkf97U+ 
    592 dbjIuZ6bgXa2c9OlT9PUiCcDZt6uLmiu//28ZnFy7Pw=</SignatureValue> 
    593 <KeyInfo> 
    594 <X509Data> 
    595  
    596  
    597  
    598 <X509Certificate>MIICKDCCAZGgAwIBAgICGbIwDQYJKoZIhvcNAQEEBQAwYTEMMAoGA1UEChMDTkRH 
    599 MQ0wCwYDVQQLEwRCQURDMScwJQYDVQQLFB5uZGdwdXJzZWNhQGZvZWhuLmJhZGMu 
    600 cmwuYWMudWsxGTAXBgNVBAMTEEdsb2J1cyBTaW1wbGUgQ0EwHhcNMDUwODExMTQ1 
    601 NjM4WhcNMDYwODExMTQ1NjM4WjA7MQwwCgYDVQQKEwNOREcxDTALBgNVBAsTBEJB 
    602 REMxHDAaBgNVBAMTE0F0dHJpYnV0ZSBBdXRob3JpdHkwgZ8wDQYJKoZIhvcNAQEB 
    603 BQADgY0AMIGJAoGBALgmuDF/jKxKlCMqhF835Yge6rHxZFLby9BbXGsa2pa/1BAY 
    604 xJUiou8sIXO7yaWaRP7M9FwW64Vdk+HQI5zluG2Gtx4MgKYElUDCgPYXsvAXg0QG 
    605 bo0KSPr+X489j07HegXGjekNejLwwvB7qTSqxHjAaKAKL7vBfWf5mn0mlIwbAgMB 
    606 AAGjFTATMBEGCWCGSAGG+EIBAQQEAwIE8DANBgkqhkiG9w0BAQQFAAOBgQAmmqnd 
    607 rj6mgbaruLepn5pyh8sQ+Qd7fwotW00rEBRYzJNUUObmIry5ZM5zuVMcaPSY57qY 
    608 vWqnavydIPdu6N97/Tf/RLk8crLVOrqj2Mo0bwgnEnjmrQicIDsWj6bFNsX1kr6V 
    609 MtUg6T1zo/Yz1aYgGcW4A/ws5tmcEHS0PUGIGA==</X509Certificate> 
    610 <X509SubjectName>CN=Attribute Authority,OU=BADC,O=NDG</X509SubjectName> 
    611 <X509IssuerSerial> 
    612 <X509IssuerName>CN=Globus Simple CA,OU=ndgpurseca@foehn.badc.rl.ac.uk,OU=BADC,O=NDG</X509IssuerName> 
    613 <X509SerialNumber>6578</X509SerialNumber> 
    614 </X509IssuerSerial> 
    615 </X509Data> 
    616 </KeyInfo> 
    617 </Signature></attributeCertificate>""" 
    618 ] 
    619  
    620     ar1 = AuthorisationResp(extAttCertList=extAttCertList, 
    621                             statCode=AuthorisationResp.accessDenied, 
    622                             errMsg="User is not registered at data centre") 
    623 #    import pdb 
    624 #    pdb.set_trace()                           
    625  
    626     ar2 = AuthorisationResp(xmlTxt=str(ar1)) 
    627      
    628     # check XMLSecDoc.__del__ error 
    629     del ar1 
    630     del ar2 
    631      
     416 
     417     
  • TI12-security/trunk/python/NDG/attAuthority_services_server.py

    r674 r737  
    6060         
    6161        try: 
    62             trustedHosts = self.__srv.getTrustedHostInfo(reqXMLtxt=reqTxt) 
     62            # Decrypt and parse input 
     63            reqKeys = TrustedHostInfoReq(xmlTxt=reqTxt, 
     64                                     encrPriKeyFilePath=self.__srv['keyFile'], 
     65                                     encrPriKeyPwd=self.__srv['keyPwd']) 
     66                    
     67            trustedHosts = self.__srv.getTrustedHostInfo(**reqKeys.xmlTags) 
    6368            trustedHostInfoResp = TrustedHostInfoResp(\ 
    6469                                                   trustedHosts=trustedHosts)                                          
    6570        except Exception, e: 
    6671            trustedHostInfoResp = TrustedHostInfoResp(errMsg=str(e)) 
     72             
     73             
     74        try: 
     75            # Encrypt response and convert into XML formatted string 
     76            if 'encrCert' in reqKeys: 
     77                 
     78                # ConnectResp class expects the public key to be in a file 
     79                # - Copy public key string content into a temporary file 
     80                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     81                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     82     
     83                trustedHostInfoResp.encrypt(\ 
     84                                    encrPubKeyFilePath=encrCertTmpFile.name) 
     85                 
     86        except Exception, e: 
     87            trustedHostInfoResp = TrustedHostInfoResp(\ 
     88                                  statCode=TrustedHostInfoResp.accessError, 
     89                                  errMsg=str(e)) 
    6790 
    68         resp._trustedHostInfoResp = str(trustedHostInfoResp) 
     91         
     92        # Convert response into encrypted XML formatted string     
     93        resp._trustedHostInfoResp = trustedHostInfoResp() 
    6994        return resp 
    7095 
     
    84109        resp = authorisationResponseWrapper() 
    85110         
    86          
     111                 
    87112        try: 
    88             attCert = self.__srv.authorise(reqXMLtxt=reqTxt) 
     113            # Decrypt and parse input 
     114            reqKeys = AuthorisationReq(xmlTxt=reqTxt, 
     115                                     encrPriKeyFilePath=self.__srv['keyFile'], 
     116                                     encrPriKeyPwd=self.__srv['keyPwd']) 
     117 
     118            # Make request to local instance 
     119            attCert = self.__srv.authorise(**reqKeys.xmlTags) 
    89120             
    90             authorisationResp = AuthorisationResp(\ 
     121            authResp = AuthorisationResp(\ 
    91122                                    credential=attCert, 
    92123                                    statCode=AuthorisationResp.accessGranted) 
    93124             
    94125        except AttAuthorityAccessDenied, e: 
    95             authorisationResp = AuthorisationResp(errMsg=str(e), 
     126            authResp = AuthorisationResp(errMsg=str(e), 
    96127                                    statCode=AuthorisationResp.accessDenied) 
    97128             
    98129        except Exception, e: 
    99             authorisationResp = AuthorisationResp(errMsg=str(e), 
     130            authResp = AuthorisationResp(errMsg=str(e), 
    100131                                    statCode=AuthorisationResp.accessError) 
     132 
     133 
     134        try: 
     135            # Encrypt response and convert into XML formatted string 
     136            if 'encrCert' in reqKeys: 
     137                 
     138                # ConnectResp class expects the public key to be in a file 
     139                # - Copy public key string content into a temporary file 
     140                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     141                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     142     
     143                authResp.encrypt(encrPubKeyFilePath=encrCertTmpFile.name) 
     144                 
     145        except Exception, e: 
     146            authResp = AuthorisationResp(\ 
     147                                      statCode=AuthorisationResp.accessError, 
     148                                      errMsg=str(e)) 
     149 
    101150         
    102          
    103         resp._authorisationResp = str(authorisationResp) 
     151        # Convert response into encrypted XML formatted string     
     152        resp._authorisationResp = authResp()                                                             
    104153        return resp 
  • TI12-security/trunk/python/NDG/sessionMgr_services_server.py

    r701 r737  
    6363 
    6464         
    65         # Decrypt and parse input 
    66         try: 
    67             # Connect request object returned behaves like a dictionary 
     65        try: 
     66            # Decrypt and parse input 
    6867            reqKeys = AddUserReq(xmlTxt=reqTxt, 
    6968                                 encrPriKeyFilePath=self.__srv['keyFile'], 
     
    115114 
    116115         
    117         # Decrypt and parse input 
    118         try: 
    119             # Connect request object returned behaves like a dictionary 
     116        try: 
     117            # Decrypt and parse input 
    120118            reqKeys = ConnectReq(xmlTxt=reqTxt, 
    121119                                 encrPriKeyFilePath=self.__srv['keyFile'], 
     
    166164 
    167165         
    168         # Decrypt and parse input 
    169         try: 
    170             # Authorisation request object returned behaves like a dictionary 
     166        try: 
     167            # Decrypt and parse input 
    171168            reqKeys = AuthorisationReq(xmlTxt=reqTxt, 
    172169                                     encrPriKeyFilePath=self.__srv['keyFile'], 
    173170                                     encrPriKeyPwd=self.__srv['keyPPhrase']) 
    174  
    175                     
     171             
     172            # Make request to local instance       
    176173            authResp = self.__srv.reqAuthorisation(**reqKeys.xmlTags) 
    177174 
  • TI12-security/trunk/python/bin/ndgSessionClient.py

    r712 r737  
    7979                    "Reading password from file \"%s\": %s" % (value, str(e))) 
    8080        
    81                   
     81 
     82#_____________________________________________________________________________ 
     83def setAApubKey(option, optStr, value, parser): 
     84    """Parser callback function for reading Attribute Authority Public key""" 
     85     
     86    try: 
     87        parser.values.aaPubKey = open(value).read().strip() 
     88         
     89    except IOError, (errNo, errMsg): 
     90        raise optparse.OptionValueError(\ 
     91                "Reading Attribute Authority Public key file \"%s\": %s" % \ 
     92                (value, errMsg)) 
     93                            
     94    except Exception, e: 
     95        raise optparse.OptionValueError(\ 
     96                "Reading Attribute Authority Public key file \"%s\": %s" % \ 
     97                (value, str(e))) 
     98                 
     99                       
    82100#_____________________________________________________________________________ 
    83101if __name__ == '__main__': 
     
    96114                      "--connect", 
    97115                      dest="userName", 
    98                       help="""\ 
    99 login in to a Session Manager with username, see also: -u, -p, -x, -y and -s 
    100 options""") 
     116                      help="""login in to a Session Manager with username.""") 
    101117     
    102118    parser.add_option("-r",  
    103119                      "--req-autho",  
    104                       action="store_true", 
    105                       dest="reqAuthorisation",  
    106                       default=False,  
     120                      dest="attAuthorityWSDLuri",  
    107121                      help=\ 
    108122"""Get a Session Manager to request authorisation from an Attribute Authority  
    109 on behalf of a user; see also: -i, -s, -a, -x, -y [, -t]""") 
     123with the given address.""") 
     124     
     125    parser.add_option("-a",  
     126                      "--att-authority-pubkey-file", 
     127                      action="callback", 
     128                      callback=setAApubKey, 
     129                      dest="aaPubKey", 
     130                      type="string",  
     131                      help=\ 
     132"""File Path of Public key of Attribute Authority used by the Session Manager  
     133to encrypt requests to it.  WARNING: If this is not set, requests will be sent 
     134in clear text.""") 
    110135 
    111136    parser.add_option("-x", 
     
    183208                      dest="sessCookie", 
    184209                      help="Read session cookie from stdin.") 
    185  
    186     parser.add_option("-a", 
    187                       "--att-authority-wsdl-uri", 
    188                       dest="attAuthorityWSDLuri", 
    189                       help="""\ 
    190 For use with --req-autho/-r flag.  The address of the Attribute Authority from 
    191 which to request an Attribute Certificate.""") 
    192210 
    193211    parser.add_option("-m", 
     
    336354            # Don't exit here - req-autho may have been set too 
    337355             
    338         if options.reqAuthorisation: 
     356        if options.attAuthorityWSDLuri: 
    339357            methodCall = True 
    340358 
     
    347365                            sessCookie=options.sessCookie, 
    348366                            aaWSDL=options.attAuthorityWSDLuri, 
     367                            aaPubKey=options.aaPubKey, 
    349368                            mapFromTrustedHosts=options.mapFromTrustedHosts, 
    350369                            reqRole=options.reqRole, 
  • TI12-security/trunk/python/conf/mapConfig.xml

    r689 r737  
    33    <trusted name="BODC"> 
    44        <wsdl>bodcAttAuthorityURI</wsdl> 
     5        <pubKey>bodcAttAuthorityPubKeyURI</pubKey> 
    56        <role remote="aBODCrole" local="aLocalRole"/> 
    67    </trusted> 
    78    <trusted name="escience"> 
    89        <wsdl>eScienceAttAuthorityURI</wsdl> 
     10        <pubKey>eScienceAttAuthorityURI</pubKey> 
    911        <role remote="anEScienceRole" local="anotherLocalRole"/> 
    1012    </trusted> 
  • TI12-security/trunk/python/ndgSetup.sh

    r639 r737  
    4040if [ ! `echo ${PATH} | grep "${NDG_DIR}/<Python location>"` ]; then 
    4141 
    42     export PATH=${NDG_DIR}/<Python location>n:$PATH 
     42    export PATH=${NDG_DIR}/<Python location>:$PATH 
    4343fi 
    4444 
Note: See TracChangeset for help on using the changeset viewer.