source: TI12-security/trunk/python/Tests/MyProxyClient/m2CryptoMyPxClnt.py @ 4770

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/python/Tests/MyProxyClient/m2CryptoMyPxClnt.py@5907
Revision 4770, 29.5 KB checked in by pjkersha, 12 years ago (diff)

Updated copyright

  • Property svn:executable set to *
Line 
1#!/usr/bin/env python
2"""MyProxy Client interface
3
4Based on original program myproxy_logon Tom Uram <turam@mcs.anl.gov>
5
6NERC Data Grid Project
7
8@author P J Kershaw 05/12/06
9
10@copyright (C) 2009 Science and Technology Facilities Council
11
12@license This software may be distributed under the terms of the Q Public
13License, version 1.0 or later.
14"""
15
16import os
17import socket
18from M2Crypto import X509, RSA, EVP, m2, BIO
19from M2Crypto.SSL.Context import Context
20from M2Crypto.SSL.Connection import Connection
21
22import re
23import base64
24
25
26class MyProxyClientError(Exception):
27    """Catch all exception class"""
28   
29class GetError(Exception):
30    """Exceptions arising from get request to server"""
31   
32class RetrieveError(Exception):
33    """Error recovering a response from MyProxy"""
34
35
36class MyProxyClient(object):
37    """MyProxy client interface
38   
39    Based on protocol definitions in:
40   
41    http://grid.ncsa.uiuc.edu/myproxy/protocol/
42   
43    @cvar __getCmd: get command string
44    @cvar __storeCmd: store command string
45    @cvar _certReqParamName: names of parameters needed to generate a
46    certificate request e.g. CN, OU etc.
47    """
48     
49    __getCmd="""VERSION=MYPROXYv2
50COMMAND=0
51USERNAME=%s
52PASSPHRASE=%s
53LIFETIME=%d\0"""
54 
55    __infoCmd="""VERSION=MYPROXYv2
56COMMAND=2
57USERNAME=%s
58PASSPHRASE=PASSPHRASE
59LIFETIME=0"""
60 
61    __destroyCmd="""VERSION=MYPROXYv2
62COMMAND=3
63USERNAME=%s
64PASSPHRASE=PASSPHRASE
65LIFETIME=0"""
66
67    __changePassphraseCmd="""VERSION=MYPROXYv2
68 COMMAND=4
69 USERNAME=%s
70 PASSPHRASE=%s
71 NEW_PHRASE=%s
72 LIFETIME=0"""
73   
74    __storeCmd="""VERSION=MYPROXYv2
75COMMAND=5
76USERNAME=%s
77PASSPHRASE=
78LIFETIME=%d\0"""
79
80 
81    _certReqParamName = ('O', 'OU')
82
83    #_________________________________________________________________________           
84    def __init__(self, 
85                 hostname=os.environ.get('MYPROXY_SERVER'), 
86                 port=7512,
87                 **certReqKw):
88        """
89        @param hostname string for MyProxy server - defaults to
90        MYPROXY_SERVER environment variable
91        @param integer port number MyProxy is running on
92        """
93        self.hostname = hostname
94        self.port = port
95       
96        # Set-up parameter names for certificate request
97        self.__certReqParam = {}.fromkeys(MyProxyClient._certReqParamName)
98       
99        # Check for parameter names set from input
100        self.certReqParam = certReqKw
101
102    #_________________________________________________________________________       
103    def __setCertReqParam(self, dict):
104        '''certReqParam property set method - forces setting of certificate
105        request parameter names to valid values
106       
107        @param dict: dictionary of parameters'''
108       
109        invalidKw = [k for k in dict \
110                     if k not in MyProxyClient._certReqParamName]
111        if invalidKw:
112            raise MyProxyClientError, \
113    "Invalid certificate request keyword(s): %s.  Valid keywords are: %s" % \
114    (', '.join(invalidKw), ', '.join(MyProxyClient._certReqParamName))
115   
116        self.__certReqParam.update(dict)
117
118    #_________________________________________________________________________       
119    def __getCertReqParam(self):
120        """certReqParam property set method - for Certificate request
121        parameters dict"""
122        return self.__certReqParam
123   
124   
125    certReqParam = property(fset=__setCertReqParam,
126                            fget=__getCertReqParam,
127                            doc="Dictionary of parameters for cert. request")
128   
129    #_________________________________________________________________________       
130    def _createCertReq(self, CN, nBitsForKey=1024, messageDigest="md5"):
131        """
132        Create a certificate request.
133       
134        @param CN: Common Name for certificate - effectively the same as the
135        username for the MyProxy credential
136        @param nBitsForKey: number of bits for private key generation -
137        default is 1024
138        @param messageDigest: message disgest type - default is MD5
139        @return tuple of certificate request PEM text and private key PEM text
140        """
141       
142        # Check all required certifcate request DN parameters are set               
143        # Create certificate request
144        req = X509.Request()
145   
146        # Generate keys
147        key = RSA.gen_key(nBitsForKey, m2.RSA_F4)
148   
149        # Create public key object
150        pubKey = EVP.PKey()
151        pubKey.assign_rsa(key)
152       
153        # Add the public key to the request
154        req.set_version(0)
155        req.set_pubkey(pubKey)
156       
157        # Set DN
158        x509Name = X509.X509_Name()
159        x509Name.CN = CN
160        x509Name.OU = self.__certReqParam['OU']
161        x509Name.O = self.__certReqParam['O']
162        req.set_subject_name(x509Name)
163       
164        req.sign(pubKey, messageDigest)
165       
166        return (req.as_asn1(), key.as_pem(cipher=None))
167   
168   
169    #_________________________________________________________________________           
170    def _deserializeResponse(self, msg, *fieldNames):
171        """
172        Deserialize a MyProxy server response
173       
174        @param msg: string response message from MyProxy server
175        @*fieldNames: the content of additional fields can be returned by
176        specifying the field name or names as additional arguments e.g. info
177        method passes 'CRED_START_TIME', 'CRED_END_TIME' and 'CRED_OWNER'
178        field names.  The content of fields is returned as an extra element
179        in the tuple response.  This element is itself a dictionary indexed
180        by field name.
181        @return tuple of integer response and errorTxt string (if any)
182        """
183       
184        lines = msg.split('\n')
185       
186        # get response value
187        responselines = filter(lambda x: x.startswith('RESPONSE'), lines)
188        responseline = responselines[0]
189        respCode = int(responseline.split('=')[1])
190       
191        # get error text
192        errorTxt = ""
193        errorlines = filter(lambda x: x.startswith('ERROR'), lines)
194        for e in errorlines:
195            etext = e.split('=', 1)[1]
196            errorTxt += etext
197       
198        if fieldNames:
199            fields = {}
200                       
201            for fieldName in fieldNames:
202                fieldlines = filter(lambda x: x.startswith(fieldName), lines)
203                try:
204                    # Nb. '1' arg to split ensures owner DN is not split up.
205                    field = fieldlines[0].split('=', 1)[1]
206                    fields[fieldName]=field.isdigit() and int(field) or field
207
208                except IndexError:
209                    # Ignore fields that aren't found
210                    pass
211               
212            return respCode, errorTxt, fields
213        else:
214            return respCode, errorTxt
215   
216 
217    #_________________________________________________________________________             
218    def _deserializeCerts(self, inputDat):
219        """Unpack certificates returned from a get delegation call to the
220        server
221       
222        @param inputDat: string containing the proxy cert and private key
223        and signing cert all in DER format
224       
225        @return list containing the equivalent to the input in PEM format"""
226        pemCerts = []       
227        dat = inputDat
228       
229        while dat:   
230            # find start of cert, get length       
231            ind = dat.find('\x30\x82')
232            if ind < 0:
233                break
234               
235            len = 256*ord(dat[ind+2]) + ord(dat[ind+3])
236   
237            # extract der-format cert, and convert to pem
238            derCert = dat[ind:ind+len+4]
239           
240            x509 = X509.load_cert_string(derCert, type=X509.TYPE_ASN1)
241            pemCert = x509.as_pem()
242           
243            pemCerts.append(pemCert)
244   
245            # trim cert from data
246            dat = dat[ind + len + 4:]
247           
248        return pemCerts
249
250
251    #_________________________________________________________________________   
252    def info(self,
253             username, 
254             ownerCertFile=None,
255             ownerKeyFile=None,
256             ownerPassphrase=None):
257        """return True/False whether credentials exist on the server for a
258        given username
259       
260        Exceptions:  GetError, StoreCredError
261       
262        @param username: username selected for credential
263        @param ownerCertFile: certificate used for client authentication with
264        the MyProxy server SSL connection.  This ID will be set as the owner
265        of the stored credentials.  Only the owner can later remove
266        credentials with myproxy-destroy or the destroy method.  If not set,
267        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem
268        @param ownerKeyFile: corresponding private key file.  See explanation
269        for ownerCertFile
270        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the
271        private key is not password protected. 
272        @return none
273        """
274        globusLoc = os.environ.get('GLOBUS_LOCATION')
275        if not ownerCertFile or not ownerKeyFile:
276            if globusLoc:
277                ownerCertFile = os.path.join(globusLoc, 'etc', 'hostcert.pem')
278                ownerKeyFile = os.path.join(globusLoc, 'etc', 'hostkey.pem')
279            else:
280                raise MyProxyClientError, \
281            "No client authentication cert. and private key file were given"
282       
283
284        context = Context(protocol='sslv3')
285        context.load_cert(ownerCertFile,
286                          keyfile=ownerKeyFile,
287                          callback=lambda *ar, **kw: ownerPassphrase)
288   
289        # Disable for compatibility with myproxy server (er, globus)
290        # globus doesn't handle this case, apparently, and instead
291        # chokes in proxy delegation code
292        context.set_options(m2.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
293       
294        # connect to myproxy server
295        conn = Connection(context, sock=socket.socket())
296       
297        # Fudge to avoid checking client cert - seems to pick globus
298        # host/<hostname> one
299        conn.clientPostConnectionCheck = None
300        conn.connect((self.hostname, self.port))
301       
302        # send globus compatibility stuff
303        conn.write('0')
304   
305        # send info command
306        cmd = MyProxyClient.__infoCmd % username
307        conn.write(cmd)
308   
309        # process server response
310        dat = conn.recv(8192)
311         
312        # Pass in the names of fields to return in the dictionary 'field'
313        respCode, errorTxt, field = self._deserializeResponse(dat, 
314                                                         'CRED_START_TIME', 
315                                                         'CRED_END_TIME', 
316                                                         'CRED_OWNER')
317
318        return not bool(respCode), errorTxt, field
319
320
321    #_________________________________________________________________________   
322    def changePassphrase(self,
323                         username, 
324                         passphrase,
325                         newPassphrase,
326                         ownerCertFile=None,
327                         ownerKeyFile=None,
328                         ownerPassphrase=None):
329        """change pass-phrase protecting the credentials for a given username
330       
331        Exceptions:  GetError, StoreCredError
332       
333        @param username: username of credential
334        @param passphrase: existing pass-phrase for credential
335        @param newPassphrase: new pass-phrase to replace the existing one.
336        @param ownerCertFile: certificate used for client authentication with
337        the MyProxy server SSL connection.  This ID will be set as the owner
338        of the stored credentials.  Only the owner can later remove
339        credentials with myproxy-destroy or the destroy method.  If not set,
340        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem
341        @param ownerKeyFile: corresponding private key file.  See explanation
342        for ownerCertFile
343        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the
344        private key is not password protected. 
345        @return none
346        """
347        globusLoc = os.environ.get('GLOBUS_LOCATION')
348        if not ownerCertFile or not ownerKeyFile:
349            if globusLoc:
350                ownerCertFile = os.path.join(globusLoc, 'etc', 'hostcert.pem')
351                ownerKeyFile = os.path.join(globusLoc, 'etc', 'hostkey.pem')
352            else:
353                raise MyProxyClientError, \
354            "No client authentication cert. and private key file were given"
355       
356        import pdb;pdb.set_trace()
357        context = Context(protocol='sslv3')
358        context.load_cert(ownerCertFile,
359                          keyfile=ownerKeyFile,
360                          callback=lambda *ar, **kw: ownerPassphrase)
361   
362        # Disable for compatibility with myproxy server (er, globus)
363        # globus doesn't handle this case, apparently, and instead
364        # chokes in proxy delegation code
365        context.set_options(m2.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
366       
367        # connect to myproxy server
368        conn = Connection(context, sock=socket.socket())
369       
370        # Fudge to avoid checking client cert - seems to pick globus
371        # host/<hostname> one
372        conn.clientPostConnectionCheck = None
373        conn.connect((self.hostname, self.port))
374       
375        # send globus compatibility stuff
376        conn.write('0')
377   
378        # send command
379        cmd = MyProxyClient.__changePassphraseCmd % (username, 
380                                                     passphrase,
381                                                     newPassphrase)
382        conn.write(cmd)
383   
384        # process server response
385        dat = conn.recv(8192)
386           
387        respCode, errorTxt = self._deserializeResponse(dat)
388        if respCode:
389            raise GetError, errorTxt
390
391
392    #_________________________________________________________________________   
393    def destroy(self,
394                username, 
395                ownerCertFile=None,
396                ownerKeyFile=None,
397                ownerPassphrase=None):
398        """destroy credentials from the server for a given username
399       
400        Exceptions:  GetError, StoreCredError
401       
402        @param username: username selected for credential
403        @param ownerCertFile: certificate used for client authentication with
404        the MyProxy server SSL connection.  This ID will be set as the owner
405        of the stored credentials.  Only the owner can later remove
406        credentials with myproxy-destroy or the destroy method.  If not set,
407        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem
408        @param ownerKeyFile: corresponding private key file.  See explanation
409        for ownerCertFile
410        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the
411        private key is not password protected. 
412        @return none
413        """
414        globusLoc = os.environ.get('GLOBUS_LOCATION')
415        if not ownerCertFile or not ownerKeyFile:
416            if globusLoc:
417                ownerCertFile = os.path.join(globusLoc, 'etc', 'hostcert.pem')
418                ownerKeyFile = os.path.join(globusLoc, 'etc', 'hostkey.pem')
419            else:
420                raise MyProxyClientError, \
421            "No client authentication cert. and private key file were given"
422       
423
424        context = Context(protocol='sslv3')
425        context.load_cert(ownerCertFile,
426                          keyfile=ownerKeyFile,
427                          callback=lambda *ar, **kw: ownerPassphrase)
428   
429        # Disable for compatibility with myproxy server (er, globus)
430        # globus doesn't handle this case, apparently, and instead
431        # chokes in proxy delegation code
432        context.set_options(m2.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
433       
434        # connect to myproxy server
435        conn = Connection(context, sock=socket.socket())
436       
437        # Fudge to avoid checking client cert - seems to pick globus
438        # host/<hostname> one
439        conn.clientPostConnectionCheck = None
440        conn.connect((self.hostname, self.port))
441       
442        # send globus compatibility stuff
443        conn.write('0')
444   
445        # send destroy command
446        cmd = MyProxyClient.__destroyCmd % username
447        conn.write(cmd)
448   
449        # process server response
450        dat = conn.recv(8192)
451           
452        respCode, errorTxt = self._deserializeResponse(dat)
453        if respCode:
454            raise GetError, errorTxt
455
456
457    #_________________________________________________________________________   
458    def store(self,
459              username, 
460              certFile,
461              keyFile,
462              ownerCertFile=None,
463              ownerKeyFile=None,
464              ownerPassphrase=None,
465              lifetime=43200):
466        """Upload credentials to the server
467       
468        Exceptions:  GetError, StoreCredError
469       
470        @param username: username selected for credential
471        @param certFile: user's X.509 certificate in PEM format
472        @param keyFile: equivalent private key file in PEM format
473        @param ownerCertFile: certificate used for client authentication with
474        the MyProxy server SSL connection.  This ID will be set as the owner
475        of the stored credentials.  Only the owner can later remove
476        credentials with myproxy-destroy or the destroy method.  If not set,
477        this argument defaults to $GLOBUS_LOCATION/etc/hostcert.pem or if this
478        is not set, certFile
479        @param ownerKeyFile: corresponding private key file.  See explanation
480        for ownerCertFile
481        @param ownerPassphrase: passphrase for ownerKeyFile.  Omit if the
482        private key is not password protected.  Nb. keyFile is expected to
483        be passphrase protected as this will be the passphrase used for
484        logon / getDelegation.
485        @return none
486        """
487        globusLoc = os.environ.get('GLOBUS_LOCATION')
488        if not ownerCertFile or not ownerKeyFile:
489            if globusLoc:
490                ownerCertFile = os.path.join(globusLoc, 'etc', 'hostcert.pem')
491                ownerKeyFile = os.path.join(globusLoc, 'etc', 'hostkey.pem')
492            else:
493                ownerCertFile = certFile
494                ownerKeyFile = keyFile
495       
496
497        context = Context(protocol='sslv3')
498        context.load_cert(ownerCertFile,
499                          keyfile=ownerKeyFile,
500                          callback=lambda *ar, **kw: ownerPassphrase)
501#        context.load_cert('../hostcert.pem',
502#                          keyfile='../hostkey.pem',
503#                          callback=lambda *ar, **kw: ownerPassphrase)
504   
505        # Disable for compatibility with myproxy server (er, globus)
506        # globus doesn't handle this case, apparently, and instead
507        # chokes in proxy delegation code
508        context.set_options(m2.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
509       
510        # connect to myproxy server
511        conn = Connection(context, sock=socket.socket())
512       
513        # Fudge to avoid checking client cert - seems to pick globus
514        # host/<hostname> one
515        #conn.clientPostConnectionCheck = None
516        conn.connect((self.hostname, self.port))
517       
518        # send globus compatibility stuff
519        conn.write('0')
520   
521        # send store command
522        cmd = MyProxyClient.__storeCmd % (username, lifetime)
523        conn.write(cmd)
524   
525        # process server response
526        dat = conn.recv(8192)
527           
528        respCode, errorTxt = self._deserializeResponse(dat)
529        if respCode:
530            raise GetError, errorTxt
531       
532        # Send certificate and private key
533        certTxt = X509.load_cert(certFile).as_pem()
534        keyTxt = open(keyFile).read()
535       
536        conn.send(certTxt + keyTxt)
537   
538   
539        # process server response
540        resp = conn.recv(8192)
541        respCode, errorTxt = self._deserializeResponse(resp)
542        if respCode:
543            raise RetrieveError, errorTxt
544       
545    #_________________________________________________________________________           
546    def logon(self, username, passphrase, lifetime=43200):
547        """Retrieve a proxy credential from a MyProxy server
548       
549        Exceptions:  GetError, RetrieveError
550       
551        @param username: username of credential
552        @param passphrase: pass-phrase for private key of credential held on
553        server
554        @return list containing the credentials as strings in PEM format: the
555        proxy certificate, it's private key and the signing certificate.
556        """
557   
558        context = Context(protocol='sslv3')
559       
560        # disable for compatibility with myproxy server (er, globus)
561        # globus doesn't handle this case, apparently, and instead
562        # chokes in proxy delegation code
563        context.set_options(m2.SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS)
564       
565        # connect to myproxy server
566        conn = Connection(context, sock=socket.socket())
567       
568        # Fudge to avoid checking client cert - seems to pick globus
569        # host/<hostname> one
570        conn.clientPostConnectionCheck = None
571        conn.connect((self.hostname, self.port))
572       
573        # send globus compatibility stuff
574        conn.write('0')
575   
576        # send get command
577        cmd = MyProxyClient.__getCmd % (username,passphrase,lifetime)
578        conn.write(cmd)
579   
580        # process server response
581        dat = conn.recv(8192)
582        respCode, errorTxt = self._deserializeResponse(dat)
583        if respCode:
584            raise GetError, errorTxt
585       
586        # generate and send certificate request
587        # - The client will generate a public/private key pair and send a
588        #   NULL-terminated PKCS#10 certificate request to the server.
589        certReq, priKey = self._createCertReq(username)
590        conn.send(certReq)
591   
592        # process certificates
593        # - 1 byte , number of certs
594        dat = conn.recv(1)
595        nCerts = ord(dat[0])
596       
597        # - n certs
598        dat = conn.recv(8192)
599   
600        # process server response
601        resp = conn.recv(8192)
602        respCode, errorTxt = self._deserializeResponse(resp)
603        if respCode:
604            raise RetrieveError, errorTxt
605   
606        # deserialize certs from received cert data
607        pemCerts = self._deserializeCerts(dat)
608        if len(pemCerts) != nCerts:
609            RetrieveError, "%d certs expected, %d received" % \
610                                                    (nCerts, len(pemCerts))
611   
612        # write certs and private key to file
613        # - proxy cert
614        # - private key
615        # - rest of cert chain
616        creds = pemCerts[0]+priKey+''.join([cert for cert in pemCerts[1:]])
617       
618        return creds
619       
620
621    def getDelegation(self, *arg, **kw):
622        """Retrieve proxy cert for user - same as logon"""
623        self.logon(*arg, **kw)
624
625
626#_____________________________________________________________________________   
627def main():
628    import sys
629    import optparse
630    import getpass
631   
632    parser = optparse.OptionParser()
633    parser.add_option("-i", 
634                      "--info", 
635                      dest="info", 
636                      default=False,
637                      action="store_true",
638                      help="check whether a credential exists")
639
640    parser.add_option("-z", 
641                      "--destroy", 
642                      dest="destroy", 
643                      default=False,
644                      action="store_true",
645                      help="destroy credential")
646
647    parser.add_option("-C", 
648                      "--change-pass-phrase", 
649                      dest="changePassphrase", 
650                      default=False,
651                      action="store_true",
652                      help="change pass-phrase protecting credential")
653
654    parser.add_option("-g", 
655                      "--get-delegation", 
656                      dest="getDelegation", 
657                      default=False,
658                      action="store_true",
659                      help="Get delegation / logon")
660   
661    parser.add_option("-c", 
662                      "--certfile", 
663                      dest="certFile", 
664                      default=None,
665                      help="Certificate to be stored")
666   
667    parser.add_option("-y", 
668                      "--keyfile", 
669                      dest="keyFile", 
670                      default=None,
671                      help="Private key to be stored")
672   
673    parser.add_option("-w", 
674                      "--keyfile-passphrase", 
675                      dest="ownerPassphrase", 
676                      default=None,
677                      help="Pass-phrase for Private key used for SSL client")
678
679    parser.add_option("-s", 
680                      "--pshost", 
681                      dest="host", 
682                      help="The hostname of the MyProxy server to contact")
683   
684    parser.add_option("-p", 
685                      "--psport", 
686                      dest="port", 
687                      default=7512,
688                      type="int",
689                      help="The port of the MyProxy server to contact")
690   
691    parser.add_option("-l", 
692                      "--username", 
693                      dest="username", 
694                      help=\
695    "The username with which the credential is stored on the MyProxy server")
696
697    parser.add_option("-o", 
698                      "--out", 
699                      dest="outfile", 
700                      help=\
701    "The username with which the credential is stored on the MyProxy server")
702
703    parser.add_option("-t", 
704                      "--proxy-lifetime", 
705                      dest="lifetime", 
706                      default=43200,
707                      type="int",
708                      help=\
709    "The username with which the credential is stored on the MyProxy server")
710
711    (options, args) = parser.parse_args()
712   
713
714    # process options   
715    username = options.username
716    if not username:
717        if sys.platform == 'win32':
718            username = os.environ["USERNAME"]
719        else:
720            import pwd
721            username = pwd.getpwuid(os.geteuid())[0]
722
723    hostname = options.host or os.environ.get('MYPROXY_SERVER')
724    myProxy = MyProxyClient(hostname=hostname,
725                            port=options.port,
726                            O='NDG',
727                            OU='BADC')
728   
729    if options.getDelegation:
730               
731        outfile = options.outfile
732        if not outfile:
733            if sys.platform == 'win32':
734                outfile = 'proxy'
735            elif sys.platform in ['linux2','darwin']:
736                outfile = '/tmp/x509up_u%s' % (os.getuid())
737   
738        # Get MyProxy password
739        passphrase = getpass.getpass()
740           
741        # Retrieve proxy cert
742        try:
743            creds = myProxy.logon(username, 
744                                  passphrase, 
745                                  lifetime=options.lifetime)
746            open(outfile, 'w').write(creds)
747            print "A proxy has been received for user %s in %s." % \
748                (username, outfile)
749           
750        except Exception,e:
751            print "Error:", e
752            sys.exit(1)
753           
754    elif options.changePassphrase:
755               
756        # Get MyProxy password
757        passphrase = getpass.getpass(\
758                     prompt='Enter (current) MyProxy pass phrase: ')
759       
760        newPassphrase = getpass.getpass(\
761                                 prompt='Enter new MyProxy pass phrase: ')
762       
763        if newPassphrase != getpass.getpass(\
764                     prompt='Verifying - Enter new MyProxy pass phrase: '):
765            raise Exception, "Pass-phrases entered don't match"
766       
767       
768        # Retrieve proxy cert
769        try:
770            myProxy.changePassphrase(username,
771                             passphrase,
772                             newPassphrase, 
773                             options.certFile,
774                             options.keyFile,
775                             ownerPassphrase=open('../tmp2').read().strip())           
776        except Exception,e:
777            print "Error:", e
778            sys.exit(1)
779               
780    elif options.info:
781        try:
782            credExists, errorTxt, fields = myProxy.info(username, 
783                             options.certFile,
784                             options.keyFile,
785                             ownerPassphrase=open('../tmp2').read().strip())
786            if credExists:
787                print "username: %s" % username
788                print "owner: %s" % fields['CRED_OWNER']
789                print "  time left: %d" % \
790                        (fields['CRED_END_TIME'] - fields['CRED_START_TIME'])
791            else:
792                ownerCert = X509.load_cert(options.certFile)
793                ownerCertDN = '/' + \
794                    ownerCert.get_subject().as_text().replace(', ', '/')
795                print "no credentials found for user %s, owner \"%s\"" % \
796                    (username, ownerCertDN)
797
798        except Exception, e:
799            print "Error:", e
800            sys.exit(1)
801               
802    elif options.destroy:
803        try:
804            myProxy.destroy(username, 
805                            ownerCertFile=options.certFile,
806                            ownerKeyFile=options.keyFile,
807                            ownerPassphrase=open('../tmp2').read().strip())
808           
809        except Exception, e:
810            print "Error:", e
811            sys.exit(1)
812    else:
813        try:
814            myProxy.store(username, 
815                          options.certFile,
816                          options.keyFile,
817                          ownerCertFile=options.certFile,
818                          ownerKeyFile=options.keyFile,
819                          ownerPassphrase=open('../tmp2').read().strip(),
820                          lifetime=options.lifetime)
821           
822        except Exception, e:
823            print "Error:", e
824            sys.exit(1)
825
826
827if __name__ == '__main__':
828    main()
829   
Note: See TracBrowser for help on using the repository browser.