source: TI12-security/trunk/python/NDG/SecurityClient.py @ 941

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/python/NDG/SecurityClient.py@941
Revision 941, 29.4 KB checked in by pjkersha, 14 years ago (diff)

Tests/SecurityClientTest?.py: renamed test methods to be prefixed with 'test' so that they are
automatically called by default when the script is called with no args.

ndgSetup.sh: cosmetic changes

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

logs/ -> log/ renamed

setup.py: for new release 0.65

NDG/X509.py: fixed bugs - refs to wrong exception class names 'X509Error' and 'AttCertError?'

NDG/SecurityClient.py: AttAuthorityClient?.reqAuthorisation ref'd 'resp' instead of 'authResp'

NDG/Logging.py: fixed comment error

NDG/Session.py: fixed ref to SessionClient? - is now called SecurityClient?.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#!/usr/bin/env python
2
3"""NDG Security client - client interface classes to Session Manager and
4Attribute Authority Web Services. 
5
6Make requests for authentication and authorisation
7
8NERC Data Grid Project
9
10P J Kershaw 24/04/06
11
12Copyright (C) 2006 CCLRC & NERC
13
14This software may be distributed under the terms of the Q Public License,
15version 1.0 or later.
16"""
17
18from ZSI import ServiceProxy
19import sys
20import os
21from Cookie import SimpleCookie
22
23# Handle retrieval of public key cert for Session Manager/Attribute Authority
24# at remote location
25import tempfile
26import urllib
27
28from NDG.X509 import *
29import NDG.SessionMgrIO as smIO
30import NDG.AttAuthorityIO as aaIO
31
32
33#_____________________________________________________________________________
34class SessionClientError(Exception):
35    """Exception handling for SessionClient class"""
36    def __init__(self, msg):
37        self.__msg = msg
38         
39    def __str__(self):
40        return self.__msg
41
42
43#_____________________________________________________________________________       
44class SessionClient(object):
45    """Client interface to Session Manager Web Service"""
46   
47    #_________________________________________________________________________
48    def __init__(self, 
49                 smWSDL=None, 
50                 smPubKeyFilePath=None,
51                 clntPubKeyFilePath=None,
52                 clntPriKeyFilePath=None,
53                 traceFile=None):
54        """
55        smWSDL:                  WSDL URI for Session Manager WS.  Setting it
56                                 will set the Service Proxy
57        smPubKeyFilePath:   
58                                 Public key of Session Manager used to encrypt
59                                 the outgoing message if required - set as a
60                                 path on the local file system or as a URI
61        clntPubKeyFilePath:      Public key of client.  This is passed to the
62                                 Session Manager so that it can encrypt
63                                 responses.  WARNING: if not set, responses
64                                 are returned as clear text
65        clntPriKeyFilePath:      Private key of client.  If clntPubKeyFilePath
66                                 is set, the private key is needed to decrypt
67                                 the response from the Session Manager
68        traceFile:               set to file object such as sys.stderr to
69                                 give extra WS debug information"""
70
71        self.__smSrv = None
72        self.__smWSDL = None
73        self.__smPubKeyFilePath = None
74        self.__smPubKeyFilePath = None
75        self.__clntPubKeyFilePath = None
76        self.__clntPubKey = None
77        self.__clntPriKeyFilePath = None
78       
79        self.__smPubKeyTempFile = None
80       
81       
82        if smWSDL:
83            self.__setSMwsdl(smWSDL)
84           
85        if smPubKeyFilePath:
86            self.__setSMpubKeyFilePath(smPubKeyFilePath)
87           
88        if clntPriKeyFilePath:
89            self.__setClntPriKeyFilePath(clntPriKeyFilePath)
90           
91        if clntPubKeyFilePath:
92            if clntPriKeyFilePath is None:
93                raise SessionClientError(\
94                    "A Client private key file is required as well a " + \
95                    "public key")
96                   
97            self.__setClntPubKeyFilePath(clntPubKeyFilePath)
98
99           
100        self.__traceFile = traceFile
101
102         
103        # Instantiate Session Manager WS proxy
104        if self.__smWSDL:
105            self.serviceProxy()
106       
107
108    #_________________________________________________________________________
109    def __setSMwsdl(self, smWSDL):
110       
111        if not isinstance(smWSDL, basestring):
112            raise SessionClientError(\
113                            "Session Manager WSDL URI must be a valid string")
114       
115        self.__smWSDL = smWSDL
116       
117    smWSDL = property(fset=__setSMwsdl, doc="Set Session Manager WSDL URI")
118
119
120    #_________________________________________________________________________
121    def __setSMpubKeyFilePath(self, smPubKeyFilePath):
122       
123        if not isinstance(smPubKeyFilePath, basestring):
124            raise SessionClientError(\
125                "Session Manager public key URI must be a valid string")
126       
127        self.__smPubKeyFilePath = smPubKeyFilePath
128       
129    smPubKeyFilePath = property(fset=__setSMpubKeyFilePath,
130                           doc="Set Session Manager public key URI")
131
132 
133    #_________________________________________________________________________
134    def __setClntPubKeyFilePath(self, clntPubKeyFilePath):
135       
136        if not isinstance(clntPubKeyFilePath, basestring):
137            raise SessionClientError(\
138                "Client public key file path must be a valid string")
139       
140        self.__clntPubKeyFilePath = clntPubKeyFilePath
141        try:
142            self.__clntPubKey = open(self.__clntPubKeyFilePath).read()
143           
144        except IOError, (errNo, errMsg):
145            raise SessionClientError(\
146                    "Reading certificate file \"%s\": %s" % \
147                    (self.__clntPubKeyFilePath, errMsg))
148                               
149        except Exception, e:
150            raise SessionClientError(\
151                    "Reading certificate file \"%s\": %s" % \
152                    (self.__clntPubKeyFilePath, str(e)))
153       
154    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath,
155                                  doc="File path for client public key")
156
157 
158    #_________________________________________________________________________
159    def __setClntPriKeyFilePath(self, clntPriKeyFilePath):
160       
161        if not isinstance(clntPriKeyFilePath, basestring):
162            raise SessionClientError(\
163                "Client public key file path must be a valid string")
164       
165        self.__clntPriKeyFilePath = clntPriKeyFilePath
166       
167    clntPriKeyFilePath = property(fset=__setClntPriKeyFilePath,
168                                  doc="File path for client private key")
169
170
171    #_________________________________________________________________________
172    def __getSessionMgrPubKey(self):
173        """Retrieve the public key from the URI"""
174       
175        # Don't proceed unless URI was set - user may have set public key via
176        # smPubKeyFilePath instead
177        if self.__smPubKeyFilePath is not None:
178            return
179               
180        try:
181            self.__smPubKeyTempFile = tempfile.NamedTemporaryFile()
182           
183            pubKey = self.getPubKey()
184            open(self.__smPubKeyTempFile.name, "w").write(pubKey)
185           
186            self.__smPubKeyFilePath = self.__smPubKeyTempFile.name
187           
188        except IOError, (errNo, errMsg):
189            raise SessionClientError(\
190                                "Writing public key to temp \"%s\": %s" % \
191                                (self.__smPubKeyTempFile.name, errMsg))                                                                     
192        except Exception, e:
193            raise SessionClientError("Retrieving Session Manager " + \
194                                     "public key: %s" % str(e))
195   
196       
197    #_________________________________________________________________________
198    def serviceProxy(self, smWSDL=None):
199        """Set the WS proxy for the Session Manager"""
200        if smWSDL:
201            self.__setSMwsdl(smWSDL)
202
203        try:
204            self.__smSrv = ServiceProxy(self.__smWSDL, 
205                                        use_wsdl=True, 
206                                        tracefile=self.__traceFile)
207        except Exception, e:
208            raise SessionClientError("Initialising WSDL Service Proxy: " + \
209                                     str(e))
210
211                                   
212    #_________________________________________________________________________
213    def addUser(self,
214                userName,
215                pPhrase=None,
216                pPhraseFilePath=None,
217                clntPriKeyPwd=None):
218        """Register a new user
219       
220        userName:                the username for the new user
221        pPhrase:                 user's pass-phrase
222        pPhraseFilePath:         a file containing the user's pass-phrase. 
223                                 Use this as an alternative to pPhrase keyword
224        clntPriKeyPwd:           pass-phrase if any for the client's private
225                                 key used to decrypt response from
226                                 Session Manager
227        """
228   
229        if pPhrase is None:
230            try:
231                pPhrase = open(pPhraseFilePath).read().strip()
232           
233            except Exception, e:
234                raise SessionClientError("Pass-phrase not defined: " + str(e))
235
236
237        # If Public key was not set, retrieve from server
238        self.__getSessionMgrPubKey()
239           
240   
241        # Make request for new user
242        try:   
243            addUserReq = smIO.AddUserReq(userName=userName, 
244                                pPhrase=pPhrase,
245                                encrCert=self.__clntPubKey,
246                                encrPubKeyFilePath=self.__smPubKeyFilePath) 
247
248            # Pass encrypted request
249            resp = self.__smSrv.addUser(addUserReq=addUserReq())
250                       
251            addUserResp = smIO.AddUserResp(xmlTxt=resp['addUserResp'],
252                                encrPriKeyFilePath=self.__clntPriKeyFilePath,
253                                encrPriKeyPwd=clntPriKeyPwd)           
254        except Exception, e:
255            raise SessionClientError("Error adding new user: " + str(e))
256 
257                           
258        if 'errMsg' in addUserResp and addUserResp['errMsg']:
259            raise SessionClientError(addUserResp['errMsg'])
260   
261       
262    #_________________________________________________________________________   
263    def connect(self,
264                userName,
265                pPhrase=None,
266                pPhraseFilePath=None,
267                getCookie=True,
268                createServerSess=False,
269                clntPriKeyPwd=None):
270        """Request a new user session from the Session Manager
271       
272        userName:                the username of the user to connect
273        pPhrase:                 user's pass-phrase
274        pPhraseFilePath:         a file containing the user's pass-phrase. 
275                                 Use this as an alternative to pPhrase
276                                 keyword.
277                                 
278        getCookie:               If set to true, return a cookie to be set in
279                                 a web browser client.  Otherwise, return a
280                                 proxy certificate.
281                                 
282        createServerSess:        If set to True, the SessionMgr will create
283                                 and manage a session for the user but note,
284                                 this flag is ignored and set to True if
285                                 getCookie is set. 
286                                 
287                                 For command line case, where getCookie is
288                                 False, it's possible to choose to have a
289                                 client or server side session using this
290                                 keyword.
291        clntPriKeyPwd:           pass-phrase if any for the client's private
292                                 key used to decrypt response from
293                                 Session Manager."""
294   
295        if pPhrase is None:
296            try:
297                pPhrase = open(pPhraseFilePath).read().strip()
298           
299            except Exception, e:
300                raise SessionClientError("Pass-phrase not defined: " + str(e))
301
302
303        # If Public key was not set, retrieve from server
304        self.__getSessionMgrPubKey()
305
306       
307        # Make connection
308        try: 
309            connectReq = smIO.ConnectReq(userName=userName, 
310                                pPhrase=pPhrase,
311                                getCookie=getCookie,
312                                createServerSess=createServerSess,
313                                encrCert=self.__clntPubKey,
314                                encrPubKeyFilePath=self.__smPubKeyFilePath) 
315   
316            # Pass encrypted request
317            resp = self.__smSrv.connect(connectReq=connectReq())
318           
319            connectResp = smIO.ConnectResp(xmlTxt=resp['connectResp'],
320                                encrPriKeyFilePath=self.__clntPriKeyFilePath,
321                                encrPriKeyPwd=clntPriKeyPwd)
322                           
323            if 'errMsg' in connectResp and connectResp['errMsg']:
324                raise Exception(connectResp['errMsg'])
325           
326            if 'sessCookie' in connectResp:
327                return connectResp['sessCookie']
328           
329            elif 'proxyCert' in connectResp:
330                return connectResp['proxyCert']
331           
332            else:
333               raise SessionClientError(\
334               "Neither \"sessCookie\" or \"proxyCert\" found in response")
335               
336        except Exception, e:
337            raise SessionClientError(\
338                            "Error connecting to Session Manager: " + str(e))
339   
340   
341    #_________________________________________________________________________
342    def reqAuthorisation(self,
343                         proxyCert=None,
344                         sessCookie=None,
345                         sessID=None,
346                         encrSessMgrWSDLuri=None,
347                         aaWSDL=None,
348                         aaPubKey=None,
349                         reqRole=None,
350                         mapFromTrustedHosts=None,
351                         rtnExtAttCertList=None,
352                         extAttCertList=None,
353                         extTrustedHostList=None,
354                         clntPriKeyPwd=None):   
355        """Request authorisation from NDG Session Manager Web Service.
356       
357        reqAuthorisation([sessCookie=s]|[sessID=i, encrSessMgrWSDLuri=e]|
358                         [proxyCert=p][key=arg, ...])
359        proxyCert:             proxy certificate - use as ID instead of
360                               a cookie in the case of a command line client.
361        sessCookie:            session cookie returned from call to connect()
362                               for a browser client.  Input as a string or
363                               SimpleCookie type.
364        sessID:                session ID.  Input this as well as
365                               encrSessMgrWSDLuri as an alternative to
366                               sessCookie in the case of a browser client.
367        encrSessMgrWSDLuri:    encrypted Session Manager WSDL URI.
368        aaWSDL:                WSDL URI for Attribute Authority WS.
369        aaPubKey:              The Session Manager uses the Public key of the
370                               Attribute Authority to encrypt requests to it.
371        reqRole:               The required role for access to a data set.
372                               This can be left out in which case the
373                               Attribute Authority just returns whatever
374                               Attribute Certificate it has for the user
375        mapFromTrustedHosts:   Allow a mapped Attribute Certificate to be
376                               created from a user certificate from another
377                               trusted host.
378        rtnExtAttCertList:     Set this flag True so that if authorisation is
379                               denied, a list of potential attribute
380                               certificates for mapping may be returned.
381        extAttCertList:        A list of Attribute Certificates from other
382                               trusted hosts from which the target Attribute
383                               Authority can make a mapped certificate
384        extTrustedHostList:    A list of trusted hosts that can be used to
385                               get Attribute Certificates for making a mapped
386                               AC.
387        clntPriKeyPwd:         pass-phrase if any for the client's private
388                               key used to decrypt response from
389                               Session Manager.
390        """
391       
392        if sessCookie:
393            if isinstance(sessCookie, basestring):
394                try:
395                    sessCookie = SimpleCookie(sessCookie)
396                except Exception, e:
397                    raise SessionClientError(\
398                                    "Error parsing session cookie: " + str(e))
399
400            sessID = sessCookie['NDG-ID1'].value
401            encrSessMgrWSDLuri = sessCookie['NDG-ID2'].value
402           
403        elif not sessID and not encrSessMgrWSDLuri and not proxyCert:
404            raise SessionClientError(\
405                '"proxyCert" or "sessCookie or "sessID" and ' + \
406                '"encrSessMgrWSDLuri" keywords must be set')
407
408
409        # If Public key was not set, retrieve from server
410        self.__getSessionMgrPubKey()
411
412           
413        # Make authorisation request
414        try:
415            authReq = smIO.AuthorisationReq(aaWSDL=aaWSDL,
416                                 aaPubKey=aaPubKey,
417                                 sessID=sessID, 
418                                 encrSessMgrWSDLuri=encrSessMgrWSDLuri,
419                                 proxyCert=proxyCert,
420                                 reqRole=reqRole,
421                                 mapFromTrustedHosts=mapFromTrustedHosts,
422                                 rtnExtAttCertList=rtnExtAttCertList,
423                                 extAttCertList=extAttCertList,
424                                 extTrustedHostList=extTrustedHostList,
425                                 encrCert=self.__clntPubKey,
426                                 encrPubKeyFilePath=self.__smPubKeyFilePath) 
427                                           
428            resp = self.__smSrv.reqAuthorisation(authorisationReq=authReq())
429            authResp = smIO.AuthorisationResp(xmlTxt=resp['authorisationResp'],
430                                encrPriKeyFilePath=self.__clntPriKeyFilePath,
431                                encrPriKeyPwd=clntPriKeyPwd)
432            return authResp
433           
434        except Exception, e:
435            raise SessionClientError(\
436                                "Error in authorisation request: " + str(e))
437
438                                   
439    #_________________________________________________________________________
440    def getPubKey(self):
441        """Retrieve the public key of the Session Manager"""
442       
443        try:   
444            pubKeyReq = smIO.PubKeyReq() 
445
446            # Pass request
447            resp = self.__smSrv.getPubKey(pubKeyReq=pubKeyReq())
448                       
449            pubKeyResp = smIO.PubKeyResp(xmlTxt=resp['pubKeyResp'])
450                           
451            if 'errMsg' in pubKeyResp and pubKeyResp['errMsg']:
452                raise SessionClientError(pubKeyResp['errMsg'])
453           
454            return pubKeyResp['pubKey']
455       
456        except Exception, e:
457            raise SessionClientError("Error retrieving public key: " + str(e))
458
459
460
461
462#_____________________________________________________________________________
463class AttAuthorityClientError(Exception):
464    """Exception handling for SessionClient class"""
465    def __init__(self, msg):
466        self.__msg = msg
467         
468    def __str__(self):
469        return self.__msg
470
471
472#_____________________________________________________________________________
473class AttAuthorityClient(object):
474   
475    #_________________________________________________________________________
476    def __init__(self, 
477                 aaWSDL=None, 
478                 aaPubKeyFilePath=None,
479                 clntPubKeyFilePath=None,
480                 clntPriKeyFilePath=None,
481                 traceFile=None):
482        """
483        aaWSDL:                  WSDL URI for Attribute Authority WS.  Setting
484                                 it will set the Service Proxy
485        aaPubKeyFilePath:   
486                                 Public key of Attribute Authority used to
487                                 encrypt the outgoing message if required -
488                                 set as a path on the local file system or as
489                                 a URI
490        clntPubKeyFilePath:      Public key of client.  This is passed to the
491                                 Attribute Authority so that it can encrypt
492                                 responses.  WARNING: if not set, responses
493                                 are returned as clear text
494        clntPriKeyFilePath:      Private key of client.  If clntPubKeyFilePath
495                                 is set, the private key is needed to decrypt
496                                 the response from the Attribute Authority
497        traceFile:               set to file object such as sys.stderr to
498                                 give extra WS debug information"""
499
500        self.__aaSrv = None
501        self.__aaWSDL = None
502        self.__aaPubKeyFilePath = None
503        self.__aaPubKeyFilePath = None
504        self.__clntPubKeyFilePath = None
505        self.__clntPubKey = None
506        self.__clntPriKeyFilePath = None
507       
508        self.__aaPubKeyTempFile = None
509       
510       
511        if aaWSDL:
512            self.__setAAwsdl(aaWSDL)
513           
514        if aaPubKeyFilePath:
515            self.__setAApubKeyFilePath(aaPubKeyFilePath)
516           
517        if clntPriKeyFilePath:
518            self.__setClntPriKeyFilePath(clntPriKeyFilePath)
519           
520        if clntPubKeyFilePath:
521            if clntPriKeyFilePath is None:
522                raise AttAuthorityClientError(\
523                    "A Client private key file is required as well a " + \
524                    "public key")
525                   
526            self.__setClntPubKeyFilePath(clntPubKeyFilePath)
527
528           
529        self.__traceFile = traceFile
530
531         
532        # Instantiate Attribute Authority WS proxy
533        if self.__aaWSDL:
534            self.serviceProxy()
535       
536
537    #_________________________________________________________________________
538    def __setAAwsdl(self, aaWSDL):
539       
540        if not isinstance(aaWSDL, basestring):
541            raise AttAuthorityClientError(\
542                        "Attribute Authority WSDL URI must be a valid string")
543       
544        self.__aaWSDL = aaWSDL
545       
546    aaWSDL = property(fset=__setAAwsdl,doc="Set Attribute Authority WSDL URI")
547
548
549    #_________________________________________________________________________
550    def __setAApubKeyFilePath(self, aaPubKeyFilePath):
551       
552        if not isinstance(aaPubKeyFilePath, basestring):
553            raise AttAuthorityClientError(\
554                "Attribute Authority public key URI must be a valid string")
555       
556        self.__aaPubKeyFilePath = aaPubKeyFilePath
557       
558    aaPubKeyFilePath = property(fset=__setAApubKeyFilePath,
559                           doc="Set Attribute Authority public key URI")
560
561 
562    #_________________________________________________________________________
563    def __setClntPubKeyFilePath(self, clntPubKeyFilePath):
564       
565        if not isinstance(clntPubKeyFilePath, basestring):
566            raise AttAuthorityClientError(\
567                "Client public key file path must be a valid string")
568       
569        self.__clntPubKeyFilePath = clntPubKeyFilePath
570        try:
571            self.__clntPubKey = open(self.__clntPubKeyFilePath).read()
572           
573        except IOError, (errNo, errMsg):
574            raise AttAuthorityClientError(\
575                    "Reading certificate file \"%s\": %s" % \
576                    (self.__clntPubKeyFilePath, errMsg))
577                               
578        except Exception, e:
579            raise AttAuthorityClientError(\
580                    "Reading certificate file \"%s\": %s" % \
581                    (self.__clntPubKeyFilePath, str(e)))
582       
583    clntPubKeyFilePath = property(fset=__setClntPubKeyFilePath,
584                                  doc="File path for client public key")
585
586 
587    #_________________________________________________________________________
588    def __setClntPriKeyFilePath(self, clntPriKeyFilePath):
589       
590        if not isinstance(clntPriKeyFilePath, basestring):
591            raise AttAuthorityClientError(\
592                "Client public key file path must be a valid string")
593       
594        self.__clntPriKeyFilePath = clntPriKeyFilePath
595       
596    clntPriKeyFilePath = property(fset=__setClntPriKeyFilePath,
597                                  doc="File path for client private key")
598
599
600    #_________________________________________________________________________
601    def __getAttAuthorityPubKey(self):
602        """Retrieve the public key from the URI"""
603       
604        # Don't proceed unless URI was set - user may have set public key via
605        # aaPubKeyFilePath instead
606        if self.__aaPubKeyFilePath is not None:
607            return
608               
609        try:
610            self.__aaPubKeyTempFile = tempfile.NamedTemporaryFile()
611           
612            pubKey = self.getPubKey()
613            open(self.__aaPubKeyTempFile.name, "w").write(pubKey)
614           
615            self.__aaPubKeyFilePath = self.__aaPubKeyTempFile.name
616           
617        except IOError, (errNo, errMsg):
618            raise AttAuthorityClientError(\
619                                "Writing public key to temp \"%s\": %s" % \
620                                (self.__aaPubKeyTempFile.name, errMsg))                                                                     
621        except Exception, e:
622            raise AttAuthorityClientError("Retrieving Attribute Authority " +\
623                                          "public key: %s" % str(e))
624   
625       
626    #_________________________________________________________________________
627    def serviceProxy(self, aaWSDL=None):
628        """Set the WS proxy for the Attribute Authority"""
629        if aaWSDL:
630            self.__setAAwsdl(aaWSDL)
631
632        try:
633            self.__aaSrv = ServiceProxy(self.__aaWSDL, 
634                                        use_wsdl=True, 
635                                        tracefile=self.__traceFile)
636        except Exception, e:
637            raise AttAuthorityClientError(\
638                    "Initialising WSDL Service Proxy: " + str(e))
639
640                                   
641    #_________________________________________________________________________
642    def getTrustedHostInfo(self, role=None, clntPriKeyPwd=None):
643        """Get list of trusted hosts for an Attribute Authority
644       
645        """
646
647        # If Public key was not set, retrieve from server
648        self.__getAttAuthorityPubKey()
649           
650   
651        # Make request for new user
652        try:   
653            trustedHostInfoReq = aaIO.TrustedHostInfoReq(role=role, 
654                                encrCert=self.__clntPubKey,
655                                encrPubKeyFilePath=self.__aaPubKeyFilePath) 
656
657            # Pass encrypted request
658            resp = self.__aaSrv.getTrustedHostInfo(\
659                                    trustedHostInfoReq=trustedHostInfoReq())
660                       
661            trustedHostInfoResp = aaIO.TrustedHostInfoResp(\
662                                xmlTxt=resp['trustedHostInfoResp'],
663                                encrPriKeyFilePath=self.__clntPriKeyFilePath,
664                                encrPriKeyPwd=clntPriKeyPwd)           
665        except Exception, e:
666            raise AttAuthorityClientError("Error: " + str(e))
667 
668                           
669        if 'errMsg' in trustedHostInfoResp and trustedHostInfoResp['errMsg']:
670            raise AttAuthorityClientError(trustedHostInfoResp['errMsg'])
671
672        return trustedHostInfoResp['trustedHosts']
673   
674
675    #_________________________________________________________________________
676    def reqAuthorisation(self, 
677                         proxyCert, 
678                         userAttCert=None, 
679                         clntPriKeyPwd=None):
680        """Request authorisation from NDG Attribute Authority Web Service."""
681
682
683        # If Public key was not set, retrieve from server
684        self.__getAttAuthorityPubKey()
685
686
687        try:   
688            authReq = aaIO.AuthorisationReq(proxyCert=proxyCert,
689                                 userAttCert=userAttCert,
690                                 encrCert=self.__clntPubKey,
691                                 encrPubKeyFilePath=self.__aaPubKeyFilePath) 
692
693            resp = self.__aaSrv.reqAuthorisation(authorisationReq=authReq())
694                                     
695            authResp=aaIO.AuthorisationResp(xmlTxt=resp['authorisationResp'],
696                                encrPriKeyFilePath=self.__clntPriKeyFilePath,
697                                encrPriKeyPwd=clntPriKeyPwd)           
698        except Exception, e:
699            raise AttAuthorityClientError("Error: " + str(e))
700           
701        if 'errMsg' in authResp and authResp['errMsg']:
702            raise AttAuthorityClientError(authResp['errMsg'])
703       
704        return authResp
705
706                                   
707    #_________________________________________________________________________
708    def getPubKey(self):
709        """Retrieve the public key of the Session Manager"""
710       
711        try:   
712            pubKeyReq = aaIO.PubKeyReq() 
713
714            # Pass request
715            resp = self.__aaSrv.getPubKey(pubKeyReq=pubKeyReq())
716                       
717            pubKeyResp = aaIO.PubKeyResp(xmlTxt=resp['pubKeyResp'])
718                           
719            if 'errMsg' in pubKeyResp and pubKeyResp['errMsg']:
720                raise AttAuthorityClientError(pubKeyResp['errMsg'])
721           
722            return pubKeyResp['pubKey']
723       
724        except Exception, e:
725            raise AttAuthorityClientError(\
726                                    "Error retrieving public key: " + str(e))                             
Note: See TracBrowser for help on using the repository browser.