Changeset 1176 for TI12-security


Ignore:
Timestamp:
14/06/06 16:17:49 (13 years ago)
Author:
pjkersha
Message:

Changes to incoporate new getHostInfo Attribute Authority WS method.

Tests/AttAuthorityIOtest.py: new unit test test method

Tests/SecurityClientTest?.py: minor changes to test settings

dist/NDG-Security-0.68.tar.gz: new distribution

www/html/attAuthority.wsdl: updated WSDL contains getHostInfo method.

conf/mapConfig.xml: contains new tags for information about the service provider of the AA e.g. loginURI,
service provider name. This is used by the new getHostInfo WS method.

conf/attAuthorityProperties.xml: remove old commented out tags.

NDG/AttAuthorityIO.py: added HostInfo?* classes for handling getHostInfo WS method I/O.

NDG/attAuthority_services_server.py and NDG/attAuthority_services.py: updated inline with WSDL changes.

NDG/AttAuthority.py:

  • readMapConfig updated to include new 'thisHost' tags.
  • self.mapConfig dictionary re-ordered to include top level keys 'thisHost' and 'trustedHosts'
  • New hostInfo property

NDG/AttCert.py: trivial fixes to commenting

NDG/XMLMsg.py: simplify error message for "Invalid keywords set for update..." error

NDG/CredWallet.py:

  • Client public key is now read in at the point where the corresponding pub key file path is set - i.e. in

setClntPubKeyFilePath method. This means the equivalent code in reqAuthorisation is not needed.

  • reqAuthorisation method has a new flag refreshAttCert. If set, the wallet is checked first for an existing

AC issued by the target AA. If found this is returned, and the call to the AA is skipped.

NDG/SecurityClient.py: added AttAuthorityClient?.getHostInfo WS wrapper method.

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

Legend:

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

    r1142 r1176  
    582582        # Dictionaries: 
    583583        # 1) to hold all the data 
    584         self.__mapConfig = {} 
     584        self.__mapConfig = {'thisHost': {}, 'trustedHosts': {}} 
    585585 
    586586        # ... look-up 
     
    590590        self.__localRole2RemoteRole = {} 
    591591        self.__remoteRole2LocalRole = {} 
    592          
     592 
     593 
     594        # Information about this host 
     595        try: 
     596            thisHostElem = rootElem.findall('thisHost')[0] 
     597             
     598        except Exception, e: 
     599            raise AttAuthorityError, \ 
     600            "\"thisHost\" tag not found in Map Configuration file \"%s\"" % \ 
     601            self.__prop['mapConfigFile'] 
     602 
     603        try: 
     604            hostName = thisHostElem.attrib.values()[0] 
     605             
     606        except Exception, e: 
     607            raise AttAuthorityError, "\"name\" attribute of \"thisHost\" " + \ 
     608                        "tag not found in Map Configuration file \"%s\"" % \ 
     609                        self.__prop['mapConfigFile'] 
     610 
     611 
     612        # hostname is also stored in the AA's config file in the 'name' tag.   
     613        # Check the two match as the latter is copied into Attribute  
     614        # Certificates issued by this AA 
     615        # 
     616        # TODO: would be better to rationalise this so that the hostname is  
     617        # stored in one place only. 
     618        # 
     619        # P J Kershaw 14/06/06 
     620        if hostName != self.__prop['name']: 
     621            raise AttAuthorityError, "\"name\" attribute of \"thisHost\" " + \ 
     622                "tag in Map Configuration file doesn't match config file " + \ 
     623                "\"name\" tag" 
     624         
     625        self.__mapConfig['thisHost'][hostName] = \ 
     626        { 
     627            'loginURI':     thisHostElem.findtext('loginURI'), 
     628            'wsdl':         thisHostElem.findtext('wsdl') 
     629        }         
     630         
     631         
     632        # Information about trusted hosts 
    593633        for elem in trustedElem: 
    594634 
     
    602642                 
    603643            except Exception, e: 
    604                 raise AttAuthorityError(\ 
    605                                     "Error setting trusted host name: %s" % e) 
     644                raise AttAuthorityError, \ 
     645                                    "Error reading trusted host name: %s" % e 
    606646 
    607647             
     
    615655            # 
    616656            # P J Kershaw 25/05/06 
    617             self.__mapConfig[trustedHost] = \ 
     657            self.__mapConfig['trustedHosts'][trustedHost] = \ 
    618658            { 
    619659                'loginURI':     elem.findtext('loginURI'), 
     
    626666            self.__remoteRole2LocalRole[trustedHost] = {} 
    627667             
    628             for role in self.__mapConfig[trustedHost]['role']: 
     668            for role in self.__mapConfig['trustedHosts'][trustedHost]['role']: 
    629669 
    630670                localRole = role['local'] 
     
    681721        except Exception, e: 
    682722            raise AttAuthorityError("Getting user roles: %s" % e) 
     723 
     724 
     725 
     726     
     727    def __getHostInfo(self): 
     728        """Return the host that this Attribute Authority represents: its ID, 
     729        the user login URI and WSDL address.  Call this method via the 
     730        'hostInfo' property""" 
     731         
     732        return self.__mapConfig['thisHost'] 
     733         
     734    hostInfo = property(fget=__getHostInfo,  
     735                        doc="Return information about this host") 
    683736 
    684737 
     
    721774                        ).keys() 
    722775                    } 
    723                 ) for k, v in self.__mapConfig.items() 
     776                ) for k, v in self.__mapConfig['trustedHosts'].items() 
    724777            ]) 
    725778 
     
    735788            # identified and return as a dictionary indexed by host name 
    736789            trustedHostInfo = dict(\ 
    737             [\ 
    738                 (\ 
    739                     host, \ 
    740                     { 
    741                         'wsdl':     self.__mapConfig[host]['wsdl'], 
    742                         'loginURI': self.__mapConfig[host]['loginURI'], 
    743                         'role':     self.__localRole2RemoteRole[host][role] 
    744                     }\ 
    745                  ) for host in trustedHosts 
    746             ]) 
     790   [(\ 
     791        host, \ 
     792        { 
     793            'wsdl':     self.__mapConfig['trustedHosts'][host]['wsdl'], 
     794            'loginURI': self.__mapConfig['trustedHosts'][host]['loginURI'], 
     795            'role':     self.__localRole2RemoteRole[host][role] 
     796        }\ 
     797    ) for host in trustedHosts]) 
    747798                          
    748799        return trustedHostInfo 
  • TI12-security/trunk/python/NDG/AttAuthorityIO.py

    r1021 r1176  
    253253 
    254254#_____________________________________________________________________________ 
     255class HostInfoReqError(XMLMsgError):     
     256    """Exception handling for NDG AttAuthority WS GetHostInfo request  
     257    class.""" 
     258    pass 
     259 
     260 
     261#_____________________________________________________________________________ 
     262class HostInfoReq(XMLMsg): 
     263    """For client to Attribute Authority WS GetHostInfo(): formats  
     264    inputs for request into XML and encrypts. 
     265     
     266    Attribute Authority enables decryption of result""" 
     267     
     268    # Override base class class variables 
     269    xmlTagTmpl = {"encrCert": ""} 
     270 
     271 
     272#_____________________________________________________________________________ 
     273class HostInfoRespError(XMLMsgError):     
     274    """Exception handling for NDG AttAuthority WS GetHostInfo response  
     275    class.""" 
     276    pass 
     277 
     278 
     279#_____________________________________________________________________________ 
     280class HostInfoResp(XMLMsg):                               
     281    """For client to Attribute Authority WS getTrustedInfo(): formats  
     282    response from AttAuthority. 
     283     
     284    For client, enables decryption of response""" 
     285     
     286    # Override base class class variables 
     287    xmlTagTmpl = {"thisHost": "", "errMsg": ""} 
     288 
     289 
     290    def __init__(self, **xmlMsgKeys): 
     291        """XML for receiving output from Attribute Authority authorisation  
     292        call 
     293         
     294        xmlMsgKeys:    keywords for XMLMsg super-class.  If XML tags are  
     295                       input as keywords then 'errMsg' or 'statCode'  
     296                       must be set. 
     297        """         
     298         
     299        # Allow user credentials to be access like dictionary keys 
     300        super(self.__class__, self).__init__(**xmlMsgKeys) 
     301         
     302         
     303    #_________________________________________________________________________ 
     304    def updateXML(self, **xmlTags): 
     305        """Override base class implementation to include extra code 
     306        to allow attribute certificate to be set from a string or AttCert 
     307        type""" 
     308         
     309        # Update dictionary 
     310        self.update(**xmlTags) 
     311         
     312        # Create XML formatted string ready for encryption 
     313        try: 
     314            xmlTxt = self.xmlHdr + os.linesep + \ 
     315                "<" + self.__class__.__name__ + ">" + os.linesep 
     316                 
     317            if "thisHost" in xmlTags: 
     318                host, hostInfo = xmlTags['thisHost'].items()[0] 
     319                xmlTxt += """ 
     320    <thisHost> 
     321        <name>%s</name> 
     322        <wsdl>%s</wsdl> 
     323        <loginURI>%s</loginURI>  
     324    </thisHost>""" % (host, hostInfo['wsdl'], hostInfo['loginURI']) 
     325 
     326            if "errMsg" in xmlTags: 
     327                xmlTxt += "    <errMsg>%s</errMsg>%s" % \ 
     328                                            (xmlTags['errMsg'], os.linesep) 
     329                     
     330            xmlTxt += "</" + self.__class__.__name__ + ">" + os.linesep    
     331            self.xmlTxt = xmlTxt 
     332             
     333 
     334        except Exception, e: 
     335            raise XMLMsgError("Creating XML: %s" % e) 
     336 
     337 
     338    #_________________________________________________________________________ 
     339    def parseXML(self): 
     340        """Override base class implementation to include extra code 
     341        to parse trusted hosts info""" 
     342         
     343        rootElem = super(self.__class__, self).parseXML(rtnRootElem=True) 
     344         
     345        if 'thisHost' not in self: 
     346            raise HostInfoRespError, \ 
     347                "\"thisHost\" tag is missing from the host info response" 
     348         
     349        self['thisHost'] = {} 
     350         
     351        hostElem = rootElem.find('thisHost') 
     352        if not hostElem: 
     353            raise HostInfoRespError, "No \"thisHost\" tag found in response" 
     354          
     355        try: 
     356            hostName = hostElem.find('name').text.strip() 
     357             
     358            # Add key for trusted host name 
     359            self['thisHost'][hostName] = {} 
     360             
     361            # Add WSDL URI, loginURI and role set for that host 
     362            self['thisHost'][hostName]['wsdl'] = \ 
     363                                        hostElem.find('wsdl').text.strip() 
     364                                         
     365            self['thisHost'][hostName]['loginURI'] = \ 
     366                                        hostElem.find('loginURI').text.strip()               
     367        except Exception, e: 
     368            raise HostInfoRespError, \ 
     369                        "Error parsing tag \"%s\" in host info response: %s" \ 
     370                        % (trusted.tag, str(e)) 
     371 
     372 
     373#_____________________________________________________________________________ 
    255374class TrustedHostInfoReqError(XMLMsgError):     
    256375    """Exception handling for NDG AttAuthority WS GetTrustedHostInfo request  
  • TI12-security/trunk/python/NDG/AttCert.py

    r1142 r1176  
    136136        elif self.__dat['validity'].has_key(key): 
    137137 
    138             # Allow indexing via validity keys - a shorthand way of referencing 
    139             # for convenience 
     138            # Allow indexing via validity keys - a shorthand way of  
     139            # referencing for convenience 
    140140            return self.__dat['validity'][key] 
    141141 
    142142        elif self.__dat['attributes'].has_key(key): 
    143143 
    144             # Allow indexing via attirbutes keys - a shorthand way of  
     144            # Allow indexing via attributes keys - a shorthand way of  
    145145            # referencing for convenience 
    146146            return self.__dat['attributes'][key] 
  • TI12-security/trunk/python/NDG/CredWallet.py

    r1129 r1176  
    332332                 
    333333        self.__clntPubKeyFilePath = clntPubKeyFilePath 
     334         
     335        # Read the file into string ready to be passed over WS interface as 
     336        # required 
     337        if self.__clntPubKeyFilePath: 
     338            try: 
     339                self.__clntPubKey = open(self.__clntPubKeyFilePath).read() 
     340                 
     341            except IOError, (errNo, errMsg): 
     342                raise CredWalletError(\ 
     343                            "Reading client public key file \"%s\": %s" %\ 
     344                            (self.__clntPubKeyFilePath, errMsg)) 
     345                                    
     346            except Exception, e: 
     347                raise CredWalletError(\ 
     348                            "Reading client public key file \"%s\": %s" %\ 
     349                            (self.__clntPubKeyFilePath, str(e)))                 
    334350        
    335351         
     
    377393            raise CredWalletError("Credential Wallet: %s" % e) 
    378394 
    379  
     395     
    380396    #_________________________________________________________________________ 
    381397    def addCredential(self, attCert, bUpdateCredRepos=True): 
     
    554570                    raise CredWalletError(\ 
    555571                        "Retrieving Attribute Authority public key: "+ str(e)) 
    556  
    557                  
    558             if self.__clntPubKeyFilePath: 
    559                 try: 
    560                     clntCert = open(self.__clntPubKeyFilePath).read() 
    561                      
    562                 except IOError, (errNo, errMsg): 
    563                     raise CredWalletError(\ 
    564                                 "Reading client public key file \"%s\": %s" %\ 
    565                                 (self.__clntPubKeyFilePath, errMsg)) 
    566                                         
    567                 except Exception, e: 
    568                     raise CredWalletError(\ 
    569                                 "Reading client public key file \"%s\": %s" %\ 
    570                                 (self.__clntPubKeyFilePath, str(e)))                 
    571             else: 
    572                 clntCert = None 
    573572                 
    574573                 
     
    580579                                        proxyCert=self.__proxyCertTxt, 
    581580                                        userAttCert=extAttCert, 
    582                                         encrCert=clntCert, 
     581                                        encrCert=self.__clntPubKey, 
    583582                                        encrPubKeyFilePath=aaPubKeyFilePath) 
    584583                               
     
    812811                         rtnExtAttCertList=None, 
    813812                         extAttCertList=None, 
    814                          extTrustedHostList=None): 
     813                         extTrustedHostList=None, 
     814                         refreshAttCert=False): 
    815815         
    816816        """For a given role, get authorisation from an Attribute Authority 
     
    878878                                the wallet.  Matching certificates will then 
    879879                                be used to try to get mapped authorisation. 
     880         
     881        refreshAttCert:         if set to True, the authorisation request will 
     882                                will go ahead even if the wallet already  
     883                                contains an Attribute Certificate from 
     884                                the target Attribute Authority.  The existing 
     885                                AC in the wallet will be replaced by the new 
     886                                one obtained from this call. 
     887                                 
     888                                If set to False, this method will check to see 
     889                                if an AC issued by the target AA already  
     890                                exists in the wallet.  If so, it will return 
     891                                this AC to the caller without proceeding to  
     892                                make a call to the AA. 
    880893                                 
    881894        The procedure is: 
     
    891904        certificate from the original AA 
    892905        6) If this fails access is denied""" 
    893  
    894  
     906                               
     907                               
     908        if aaPubKeyFilePath is None: 
     909            # Try retrieving public key from the web service and making a  
     910            # temporary file to hold it 
     911            try: 
     912                pubKeyReq = PubKeyReq() 
     913                resp = aaSrv.getPubKey(pubKeyReq=pubKeyReq()) 
     914                pubKeyResp = PubKeyResp(xmlTxt=resp['pubKeyResp']) 
     915         
     916                if 'errMsg' in pubKeyResp and pubKeyResp['errMsg']: 
     917                    raise Exception(pubKeyResp['errMsg']) 
     918                 
     919                aaPubKeyTmpFile = tempfile.NamedTemporaryFile() 
     920                open(aaPubKeyTmpFile.name,"w").write(pubKeyResp['pubKey']) 
     921     
     922                aaPubKeyFilePath = aaPubKeyTmpFile.name 
     923                 
     924            except IOError, (errNo, errMsg): 
     925                raise CredWalletError(\ 
     926                    "Writing public key to temporary file: %s" % errMsg) 
     927                                                       
     928            except Exception, e: 
     929                raise CredWalletError(\ 
     930                    "Retrieving Attribute Authority public key: "+ str(e)) 
     931 
     932 
     933        if not refreshAttCert and self.__credentials: 
     934            # Refresh flag is not set so it's OK to check for any existing 
     935            # Attribute Certificate in the wallet whose issuerName match the  
     936            # target AA's name 
     937             
     938            # Find out the site ID for the target AA by calling AA's host 
     939            # info WS method 
     940            aaClnt = AttAuthorityClient(aaWSDL=aaWSDL,  
     941                                 aaPubKeyFilePath=aaPubKeyFilePath, 
     942                                 clntPubKeyFilePath=self.__clntPubKeyFilePath, 
     943                                 clntPriKeyFilePath=self.__clntPriKeyFilePath) 
     944             
     945            hostInfo = aaClnt.getHostInfo(encrPriKeyPwd=self.__clntPriKeyPwd) 
     946            aaName = hostInfo.keys()[0] 
     947             
     948            # Look in the wallet for an AC with the same issuer name 
     949            if aaName in self.__credentials: 
     950                # Existing Attribute Certificate found in wallet - return this 
     951                return self.__credentials[aaName] 
     952             
     953             
    895954        # Check for settings from input, if not set use previous settings 
    896955        # made 
  • TI12-security/trunk/python/NDG/SecurityClient.py

    r941 r1176  
    539539         
    540540        if not isinstance(aaWSDL, basestring): 
    541             raise AttAuthorityClientError(\ 
    542                         "Attribute Authority WSDL URI must be a valid string") 
     541            raise AttAuthorityClientError, \ 
     542                        "Attribute Authority WSDL URI must be a valid string" 
    543543         
    544544        self.__aaWSDL = aaWSDL 
     
    551551         
    552552        if not isinstance(aaPubKeyFilePath, basestring): 
    553             raise AttAuthorityClientError(\ 
    554                 "Attribute Authority public key URI must be a valid string") 
     553            raise AttAuthorityClientError, \ 
     554                "Attribute Authority public key URI must be a valid string" 
    555555         
    556556        self.__aaPubKeyFilePath = aaPubKeyFilePath 
    557557         
    558558    aaPubKeyFilePath = property(fset=__setAApubKeyFilePath, 
    559                            doc="Set Attribute Authority public key URI") 
     559                                doc="Set Attribute Authority public key URI") 
    560560 
    561561  
     
    577577                                
    578578        except Exception, e: 
    579             raise AttAuthorityClientError(\ 
    580                     "Reading certificate file \"%s\": %s" % \ 
    581                     (self.__clntPubKeyFilePath, str(e))) 
     579            raise AttAuthorityClientError, \ 
     580                                    "Reading certificate file \"%s\": %s" % \ 
     581                                    (self.__clntPubKeyFilePath, str(e)) 
    582582         
    583583    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath, 
     
    620620                                (self.__aaPubKeyTempFile.name, errMsg))                                                                       
    621621        except Exception, e: 
    622             raise AttAuthorityClientError("Retrieving Attribute Authority " +\ 
    623                                           "public key: %s" % str(e)) 
     622            raise AttAuthorityClientError, "Retrieving Attribute Authority " +\ 
     623                                          "public key: %s" % str(e) 
    624624     
    625625         
     
    635635                                        tracefile=self.__traceFile) 
    636636        except Exception, e: 
    637             raise AttAuthorityClientError(\ 
    638                     "Initialising WSDL Service Proxy: " + str(e)) 
     637            raise AttAuthorityClientError, \ 
     638                    "Initialising WSDL Service Proxy: " + str(e) 
     639 
     640                                     
     641    #_________________________________________________________________________ 
     642    def getHostInfo(self, clntPriKeyPwd=None): 
     643        """Get host information for the data provider which the  
     644        Attribute Authority represents 
     645         
     646        """ 
     647 
     648        # If Public key was not set, retrieve from server 
     649        self.__getAttAuthorityPubKey() 
     650             
     651        try:    
     652            hostInfoReq = aaIO.HostInfoReq(encrCert=self.__clntPubKey, 
     653                                encrPubKeyFilePath=self.__aaPubKeyFilePath)  
     654 
     655            # Pass encrypted request 
     656            resp = self.__aaSrv.getHostInfo(hostInfoReq=hostInfoReq()) 
     657                         
     658            hostInfoResp = aaIO.HostInfoResp(\ 
     659                                xmlTxt=resp['hostInfoResp'], 
     660                                encrPriKeyFilePath=self.__clntPriKeyFilePath, 
     661                                encrPriKeyPwd=clntPriKeyPwd)             
     662        except Exception, e: 
     663            raise AttAuthorityClientError, "Error: " + str(e) 
     664   
     665                             
     666        if 'errMsg' in hostInfoResp and hostInfoResp['errMsg']: 
     667            raise AttAuthorityClientError, hostInfoResp['errMsg'] 
     668 
     669        return hostInfoResp['thisHost'] 
    639670 
    640671                                     
     
    648679        self.__getAttAuthorityPubKey() 
    649680             
    650      
    651         # Make request for new user 
    652681        try:    
    653682            trustedHostInfoReq = aaIO.TrustedHostInfoReq(role=role,  
     
    664693                                encrPriKeyPwd=clntPriKeyPwd)             
    665694        except Exception, e: 
    666             raise AttAuthorityClientError("Error: " + str(e)) 
     695            raise AttAuthorityClientError, "Error: " + str(e) 
    667696   
    668697                             
    669698        if 'errMsg' in trustedHostInfoResp and trustedHostInfoResp['errMsg']: 
    670             raise AttAuthorityClientError(trustedHostInfoResp['errMsg']) 
     699            raise AttAuthorityClientError, trustedHostInfoResp['errMsg'] 
    671700 
    672701        return trustedHostInfoResp['trustedHosts'] 
     
    697726                                encrPriKeyPwd=clntPriKeyPwd)            
    698727        except Exception, e: 
    699             raise AttAuthorityClientError("Error: " + str(e)) 
     728            raise AttAuthorityClientError, "Error: " + str(e) 
    700729             
    701730        if 'errMsg' in authResp and authResp['errMsg']: 
    702             raise AttAuthorityClientError(authResp['errMsg']) 
     731            raise AttAuthorityClientError, authResp['errMsg'] 
    703732         
    704733        return authResp 
     
    723752         
    724753        except Exception, e: 
    725             raise AttAuthorityClientError(\ 
    726                                     "Error retrieving public key: " + str(e))                               
     754            raise AttAuthorityClientError, \ 
     755                                    "Error retrieving public key: " + str(e)                               
  • TI12-security/trunk/python/NDG/XMLMsg.py

    r920 r1176  
    340340        unknownKeys = [key for key in xmlTags if key not in self.xmlTagTmpl] 
    341341        if unknownKeys: 
    342             raise KeyError(\ 
    343                 "Invalid keywords set for update: \"%s\"" % \ 
    344                 '", "'.join(unknownKeys)) 
     342            raise KeyError, "Invalid keywords set for update: \"%s\"" % \ 
     343                            '", "'.join(unknownKeys) 
    345344                 
    346345        # Copy keywords - but only those that are NOT None 
  • TI12-security/trunk/python/NDG/attAuthority_services.py

    r739 r1176  
    1818 
    1919class attAuthorityServiceLocator(attAuthorityServiceInterface): 
    20     attAuthority_address = "http://glue.badc.rl.ac.uk/attAuthority" 
     20    attAuthority_address = "" 
    2121    def getattAuthorityAddress(self): 
    2222        return attAuthorityServiceLocator.attAuthority_address 
     
    3939 
    4040 
     41    def getHostInfo(self, request): 
     42        """ 
     43        @param: request to hostInfoRequest:: 
     44          _hostInfoReq: str 
     45 
     46        @return: response from hostInfoResponse:: 
     47          _hostInfoResp: str 
     48        """ 
     49 
     50        if not isinstance(request, hostInfoRequest) and\ 
     51            not issubclass(hostInfoRequest, request.__class__): 
     52            raise TypeError, "%s incorrect request type" %(request.__class__) 
     53        kw = {} 
     54        response = self.binding.Send(None, None, request, soapaction="urn:attAuthority#getHostInfo", **kw) 
     55        response = self.binding.Receive(hostInfoResponseWrapper()) 
     56        if not isinstance(response, hostInfoResponse) and\ 
     57            not issubclass(hostInfoResponse, response.__class__): 
     58            raise TypeError, "%s incorrect response type" %(response.__class__) 
     59        return response 
     60 
     61 
    4162    def getPubKey(self, request): 
    4263        """ 
     
    139160        authorisationResponse.__init__( self, name='reqAuthorisationResponse', ns='urn:attAuthority' ) 
    140161 
     162class hostInfoRequest (ZSI.TCcompound.Struct):  
     163    def __init__(self, name=None, ns=None): 
     164        self._hostInfoReq = None 
     165 
     166        oname = None 
     167        if name: 
     168            oname = name 
     169            if ns: 
     170                oname += ' xmlns="%s"' % ns 
     171            ZSI.TC.Struct.__init__(self, hostInfoRequest, [ZSI.TC.String(pname="hostInfoReq",aname="_hostInfoReq",optional=1),], pname=name, aname="_%s" % name, oname=oname ) 
     172 
     173class hostInfoRequestWrapper(hostInfoRequest): 
     174    """wrapper for rpc:encoded message""" 
     175 
     176    typecode = hostInfoRequest(name='getHostInfo', ns='urn:attAuthority') 
     177    def __init__( self, name=None, ns=None, **kw ): 
     178        hostInfoRequest.__init__( self, name='getHostInfo', ns='urn:attAuthority' ) 
     179 
     180class hostInfoResponse (ZSI.TCcompound.Struct):  
     181    def __init__(self, name=None, ns=None): 
     182        self._hostInfoResp = None 
     183 
     184        oname = None 
     185        if name: 
     186            oname = name 
     187            if ns: 
     188                oname += ' xmlns="%s"' % ns 
     189            ZSI.TC.Struct.__init__(self, hostInfoResponse, [ZSI.TC.String(pname="hostInfoResp",aname="_hostInfoResp",optional=1),], pname=name, aname="_%s" % name, oname=oname ) 
     190 
     191class hostInfoResponseWrapper(hostInfoResponse): 
     192    """wrapper for rpc:encoded message""" 
     193 
     194    typecode = hostInfoResponse(name='getHostInfoResponse', ns='urn:attAuthority') 
     195    def __init__( self, name=None, ns=None, **kw ): 
     196        hostInfoResponse.__init__( self, name='getHostInfoResponse', ns='urn:attAuthority' ) 
     197 
    141198class pubKeyRequest (ZSI.TCcompound.Struct):  
    142199    def __init__(self, name=None, ns=None): 
  • TI12-security/trunk/python/NDG/attAuthority_services_server.py

    r1021 r1176  
    2727class attAuthority(ServiceSOAPBinding): 
    2828    soapAction = { 
     29        'urn:attAuthority#getHostInfo': 'soap_getHostInfo', 
    2930        'urn:attAuthority#getTrustedHostInfo': 'soap_getTrustedHostInfo', 
    3031        'urn:attAuthority#reqAuthorisation': 'soap_reqAuthorisation', 
     
    4344         
    4445        self.__debug = debug 
     46         
     47 
     48    #_________________________________________________________________________ 
     49    def soap_getHostInfo(self, ps): 
     50        
     51        if self.__debug: 
     52            import pdb 
     53            pdb.set_trace() 
     54         
     55        # input vals in request object 
     56        reqArgs = ps.Parse(hostInfoRequestWrapper) 
     57        reqTxt = str(reqArgs._hostInfoReq) 
     58         
     59        # assign return values to response object 
     60        resp = hostInfoResponseWrapper() 
     61         
     62         
     63        try: 
     64            # Decrypt and parse input 
     65            reqKeys = HostInfoReq(xmlTxt=reqTxt, 
     66                                  encrPriKeyFilePath=self.__srv['keyFile'], 
     67                                  encrPriKeyPwd=self.__srv['keyPwd']) 
     68                      
     69            hostInfoResp = HostInfoResp(thisHost=self.__srv.hostInfo)  
     70                                          
     71        except Exception, e: 
     72            hostInfoResp = HostInfoResp(errMsg=str(e)) 
     73             
     74             
     75        try: 
     76            # Encrypt response and convert into XML formatted string 
     77            if 'encrCert' in reqKeys: 
     78                 
     79                # ConnectResp class expects the public key to be in a file 
     80                # - Copy public key string content into a temporary file 
     81                encrCertTmpFile = tempfile.NamedTemporaryFile()                     
     82                open(encrCertTmpFile.name, "w").write(reqKeys['encrCert']) 
     83     
     84                hostInfoResp.encrypt(encrPubKeyFilePath=encrCertTmpFile.name) 
     85                 
     86        except Exception, e: 
     87            hostInfoResp = HostInfoResp(statCode=hostInfoResp.accessError, 
     88                                        errMsg=str(e)) 
     89 
     90         
     91        # Convert response into encrypted XML formatted string     
     92        resp._hostInfoResp = hostInfoResp() 
     93        return resp 
    4594         
    4695 
  • TI12-security/trunk/python/Tests/AttAuthorityIOtest.py

    r849 r1176  
    223223        print self.authorisationReq['userAttCert'] 
    224224 
    225                      
     225 
     226    def testSetHostInfoResponse(self): 
     227         
     228        hi = {\ 
     229              'Gabriel': \ 
     230              { 
     231              'wsdl': 'http://gabriel.bnsc.rl.ac.uk/attAuthority.wsdl',  
     232              'loginURI': 'https://gabriel.bnsc.rl.ac.uk/cgi-bin/security.py' 
     233              } 
     234          } 
     235         
     236        import pdb 
     237        pdb.set_trace() 
     238        try:        
     239            self.hostInfoResp = HostInfoResp(thisHost=hi) 
     240        except Exception, e: 
     241            self.fail(str(e)) 
     242             
     243        print self.hostInfoResp() 
     244        print self.hostInfoResp['thisHost'] 
     245 
     246         
    226247    def testTrustedHosts1(self): 
    227248         
  • TI12-security/trunk/python/Tests/SecurityClientTest.py

    r1036 r1176  
    5050 
    5151            # Attribute Authority client tests 
    52             self.aaWSDL = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
     52            self.aaWSDL = '/home/pjkersha/Development/security/python/Tests/attAuthority.wsdl' 
     53#            self.aaWSDL = 'http://glue.badc.rl.ac.uk/attAuthority.wsdl' 
    5354            aaPubKeyFilePath = None 
    5455             
     
    180181            
    181182 
     183    def testAAgetHostInfo(self): 
     184        """Call Attribute Authority getHostInfo""" 
     185         
     186        import pdb 
     187        pdb.set_trace() 
     188        try: 
     189            hostInfo = self.aaClnt.getHostInfo( 
     190                                           clntPriKeyPwd=self.__clntPriKeyPwd) 
     191            print hostInfo 
     192             
     193        except Exception, e: 
     194            self.fail(str(e)) 
     195            
     196 
    182197    def testAAgetTrustedHostInfo(self): 
    183         """Call Attribute Authority GetTrustedHostInfo""" 
     198        """Call Attribute Authority getTrustedHostInfo with a given role 
     199        to match against""" 
    184200         
    185201        import pdb 
     
    197213 
    198214    def testAAgetTrustedHostInfoWithNoRoleSet(self): 
    199         """Call Attribute Authority GetTrustedHostInfo""" 
     215        """Call Attribute Authority getTrustedHostInfo""" 
    200216         
    201217        import pdb 
  • TI12-security/trunk/python/bin/AttAuthorityServer.py

    r917 r1176  
    106106 
    107107    propFilePath = None 
    108     port = 5000 #80 # temporary port for testing 
     108     
     109    # Port may be set from an environment variable.  Note that this will be 
     110    # overridden if the port command line argument is set  
     111    if 'NDG_AA_PORT_NUM' in os.environ: 
     112        port = int(os.environ['NDG_AA_PORT_NUM']) 
     113    else: 
     114        # Default port number 
     115        port = 5000 
     116         
    109117    debug = False 
    110118     
  • TI12-security/trunk/python/conf/attAuthorityProperties.xml

    r687 r1176  
    11<?xml version="1.0" encoding="utf-8"?> 
    22<AAprop> 
    3 <!-- 
    4     <name>BODC</name> 
    5     <keyFile></keyFile> 
    6     <keyPwd></keyPwd> 
    7     <certFile></certFile> 
    8 --> 
    93    <name>BADC</name> 
    104    <keyFile></keyFile> 
  • TI12-security/trunk/python/conf/mapConfig.xml

    r1018 r1176  
    11<?xml version="1.0" encoding="utf-8"?> 
    22<AAmap> 
     3        <thisHost name="BADC"> 
     4            <wsdl>badcAttAuthorityURI</wsdl> 
     5            <loginURI>badcLoginPageURI</loginURI> 
     6        </thisHost> 
    37    <trusted name="BODC"> 
    48            <wsdl>bodcAttAuthorityURI</wsdl> 
  • TI12-security/trunk/python/www/html/attAuthority.wsdl

    r739 r1176  
    1717  <message name="authorisationResponse"> 
    1818    <part name="authorisationResp" type="xsd:string"/> 
     19  </message> 
     20 
     21  <message name="hostInfoRequest"> 
     22    <part name="hostInfoReq" type="xsd:string"/> 
     23  </message> 
     24 
     25  <message name="hostInfoResponse"> 
     26    <part name="hostInfoResp" type="xsd:string"/> 
    1927  </message> 
    2028 
     
    4250    </operation> 
    4351 
     52    <operation name="getHostInfo"> 
     53      <input message="tns:hostInfoRequest"/> 
     54      <output message="tns:hostInfoResponse"/> 
     55    </operation> 
     56 
    4457    <operation name="getTrustedHostInfo"> 
    4558      <input message="tns:trustedHostInfoRequest"/> 
     
    5871    <operation name="reqAuthorisation"> 
    5972      <soap:operation soapAction="urn:attAuthority#reqAuthorisation"/> 
     73      <input> 
     74        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" 
     75                    namespace="urn:attAuthority" use="encoded"/> 
     76      </input> 
     77      <output> 
     78        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" 
     79                    namespace="urn:attAuthority" use="encoded"/> 
     80      </output>  
     81    </operation> 
     82 
     83    <operation name="getHostInfo"> 
     84      <soap:operation soapAction="urn:attAuthority#getHostInfo"/> 
    6085      <input> 
    6186        <soap:body encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" 
Note: See TracChangeset for help on using the changeset viewer.