import repository from arizona
[raven.git] / apps / geni / mprepo_geni_libs / sfa / trust / certificate.py
1 ##
2 # Geniwrapper uses two crypto libraries: pyOpenSSL and M2Crypto to implement
3 # the necessary crypto functionality. Ideally just one of these libraries
4 # would be used, but unfortunately each of these libraries is independently
5 # lacking. The pyOpenSSL library is missing many necessary functions, and
6 # the M2Crypto library has crashed inside of some of the functions. The
7 # design decision is to use pyOpenSSL whenever possible as it seems more
8 # stable, and only use M2Crypto for those functions that are not possible
9 # in pyOpenSSL.
10 #
11 # This module exports two classes: Keypair and Certificate.
12 ##
13 #
14 ### $Id: certificate.py 14334 2009-07-07 13:43:48Z baris $
15 ### $URL: https://svn.planet-lab.org/svn/geniwrapper/trunk/sfa/trust/certificate.py $
16 #
17
18 import os
19 import tempfile
20 import base64
21 from OpenSSL import crypto
22 import M2Crypto
23 from M2Crypto import X509
24 from M2Crypto import EVP
25
26 from sfa.util.faults import *
27
28 def convert_public_key(key):
29     keyconvert_path = "/usr/bin/keyconvert"
30     if not os.path.isfile(keyconvert_path):
31         raise IOError, "Could not find keyconvert in %s" % keyconvert_path
32
33     # we can only convert rsa keys 
34     if "ssh-dss" in key:
35         print "XXX: DSA key encountered, ignoring"
36         return None
37     
38     (ssh_f, ssh_fn) = tempfile.mkstemp()
39     ssl_fn = tempfile.mktemp()
40     os.write(ssh_f, key)
41     os.close(ssh_f)
42
43     cmd = keyconvert_path + " " + ssh_fn + " " + ssl_fn
44     os.system(cmd)
45
46     # this check leaves the temporary file containing the public key so
47     # that it can be expected to see why it failed.
48     # TODO: for production, cleanup the temporary files
49     if not os.path.exists(ssl_fn):
50         report.trace("  failed to convert key from " + ssh_fn + " to " + ssl_fn)
51         return None
52
53     k = Keypair()
54     try:
55         k.load_pubkey_from_file(ssl_fn)
56     except:
57         print "XXX: Error while converting key: ", key_str
58         k = None
59
60     # remove the temporary files
61     os.remove(ssh_fn)
62     os.remove(ssl_fn)
63
64     return k
65
66 ##
67 # Public-private key pairs are implemented by the Keypair class.
68 # A Keypair object may represent both a public and private key pair, or it
69 # may represent only a public key (this usage is consistent with OpenSSL).
70
71 class Keypair:
72    key = None       # public/private keypair
73    m2key = None     # public key (m2crypto format)
74
75    ##
76    # Creates a Keypair object
77    # @param create If create==True, creates a new public/private key and
78    #     stores it in the object
79    # @param string If string!=None, load the keypair from the string (PEM)
80    # @param filename If filename!=None, load the keypair from the file
81
82    def __init__(self, create=False, string=None, filename=None):
83       if create:
84          self.create()
85       if string:
86          self.load_from_string(string)
87       if filename:
88          self.load_from_file(filename)
89
90    ##
91    # Create a RSA public/private key pair and store it inside the keypair object
92
93    def create(self):
94       self.key = crypto.PKey()
95       self.key.generate_key(crypto.TYPE_RSA, 1024)
96
97    ##
98    # Save the private key to a file
99    # @param filename name of file to store the keypair in
100
101    def save_to_file(self, filename):
102       open(filename, 'w').write(self.as_pem())
103
104    ##
105    # Load the private key from a file. Implicity the private key includes the public key.
106
107    def load_from_file(self, filename):
108       buffer = open(filename, 'r').read()
109       self.load_from_string(buffer)
110
111    ##
112    # Load the private key from a string. Implicitly the private key includes the public key.
113
114    def load_from_string(self, string):
115       self.key = crypto.load_privatekey(crypto.FILETYPE_PEM, string)
116       self.m2key = M2Crypto.EVP.load_key_string(string)
117
118    ##
119    #  Load the public key from a string. No private key is loaded. 
120
121    def load_pubkey_from_file(self, filename):
122       # load the m2 public key
123       m2rsakey = M2Crypto.RSA.load_pub_key(filename)
124       self.m2key = M2Crypto.EVP.PKey()
125       self.m2key.assign_rsa(m2rsakey)
126
127       # create an m2 x509 cert
128       m2name = M2Crypto.X509.X509_Name()
129       m2name.add_entry_by_txt(field="CN", type=0x1001, entry="junk", len=-1, loc=-1, set=0)
130       m2x509 = M2Crypto.X509.X509()
131       m2x509.set_pubkey(self.m2key)
132       m2x509.set_serial_number(0)
133       m2x509.set_issuer_name(m2name)
134       m2x509.set_subject_name(m2name)
135       ASN1 = M2Crypto.ASN1.ASN1_UTCTIME()
136       ASN1.set_time(500)
137       m2x509.set_not_before(ASN1)
138       m2x509.set_not_after(ASN1)
139       junk_key = Keypair(create=True)
140       m2x509.sign(pkey=junk_key.get_m2_pkey(), md="sha1")
141
142       # convert the m2 x509 cert to a pyopenssl x509
143       m2pem = m2x509.as_pem()
144       pyx509 = crypto.load_certificate(crypto.FILETYPE_PEM, m2pem)
145
146       # get the pyopenssl pkey from the pyopenssl x509
147       self.key = pyx509.get_pubkey()
148
149    ##
150    # Load the public key from a string. No private key is loaded.
151
152    def load_pubkey_from_string(self, string):
153       (f, fn) = tempfile.mkstemp()
154       os.write(f, string)
155       os.close(f)
156       self.load_pubkey_from_file(fn)
157       os.remove(fn)
158
159    ##
160    # Return the private key in PEM format.
161
162    def as_pem(self):
163       return crypto.dump_privatekey(crypto.FILETYPE_PEM, self.key)
164
165    def get_m2_pkey(self):
166       if not self.m2key:
167          self.m2key = M2Crypto.EVP.load_key_string(self.as_pem())
168       return self.m2key
169
170    ##
171    # Return an OpenSSL pkey object
172
173    def get_openssl_pkey(self):
174       return self.key
175
176    ##
177    # Given another Keypair object, return TRUE if the two keys are the same.
178
179    def is_same(self, pkey):
180       return self.as_pem() == pkey.as_pem()
181
182    def sign_string(self, data):
183       k = self.get_m2_pkey()
184       k.sign_init()
185       k.sign_update(data)
186       return base64.b64encode(k.sign_final())
187
188    def verify_string(self, data, sig):
189       k = self.get_m2_pkey()
190       k.verify_init()
191       k.verify_update(data)
192       return M2Crypto.m2.verify_final(k.ctx, base64.b64decode(sig), k.pkey)
193
194 ##
195 # The certificate class implements a general purpose X509 certificate, making
196 # use of the appropriate pyOpenSSL or M2Crypto abstractions. It also adds
197 # several addition features, such as the ability to maintain a chain of
198 # parent certificates, and storage of application-specific data.
199 #
200 # Certificates include the ability to maintain a chain of parents. Each
201 # certificate includes a pointer to it's parent certificate. When loaded
202 # from a file or a string, the parent chain will be automatically loaded.
203 # When saving a certificate to a file or a string, the caller can choose
204 # whether to save the parent certificates as well.
205
206 class Certificate:
207    digest = "md5"
208
209    data = None
210    cert = None
211    issuerKey = None
212    issuerSubject = None
213    parent = None
214
215    separator="-----parent-----"
216
217    ##
218    # Create a certificate object.
219    #
220    # @param create If create==True, then also create a blank X509 certificate.
221    # @param subject If subject!=None, then create a blank certificate and set
222    #     it's subject name.
223    # @param string If string!=None, load the certficate from the string.
224    # @param filename If filename!=None, load the certficiate from the file.
225
226    def __init__(self, create=False, subject=None, string=None, filename=None):
227        if create or subject:
228            self.create()
229        if subject:
230            self.set_subject(subject)
231        if string:
232            self.load_from_string(string)
233        if filename:
234            self.load_from_file(filename)
235
236    ##
237    # Create a blank X509 certificate and store it in this object.
238
239    def create(self):
240        self.cert = crypto.X509()
241        self.cert.set_serial_number(1)
242        self.cert.gmtime_adj_notBefore(0)
243        self.cert.gmtime_adj_notAfter(60*60*24*365*5) # five years
244
245    ##
246    # Given a pyOpenSSL X509 object, store that object inside of this
247    # certificate object.
248
249    def load_from_pyopenssl_x509(self, x509):
250        self.cert = x509
251
252    ##
253    # Load the certificate from a string
254
255    def load_from_string(self, string):
256        # if it is a chain of multiple certs, then split off the first one and
257        # load it
258        parts = string.split(Certificate.separator, 1)
259        self.cert = crypto.load_certificate(crypto.FILETYPE_PEM, parts[0])
260
261        # if there are more certs, then create a parent and let the parent load
262        # itself from the remainder of the string
263        if len(parts) > 1:
264            self.parent = self.__class__()
265            self.parent.load_from_string(parts[1])
266
267    ##
268    # Load the certificate from a file
269
270    def load_from_file(self, filename):
271        file = open(filename)
272        string = file.read()
273        self.load_from_string(string)
274
275    ##
276    # Save the certificate to a string.
277    #
278    # @param save_parents If save_parents==True, then also save the parent certificates.
279
280    def save_to_string(self, save_parents=False):
281        string = crypto.dump_certificate(crypto.FILETYPE_PEM, self.cert)
282        if save_parents and self.parent:
283           string = string + Certificate.separator + self.parent.save_to_string(save_parents)
284        return string
285
286    ##
287    # Save the certificate to a file.
288    # @param save_parents If save_parents==True, then also save the parent certificates.
289
290    def save_to_file(self, filename, save_parents=False):
291        string = self.save_to_string(save_parents=save_parents)
292        open(filename, 'w').write(string)
293
294    ##
295    # Sets the issuer private key and name
296    # @param key Keypair object containing the private key of the issuer
297    # @param subject String containing the name of the issuer
298    # @param cert (optional) Certificate object containing the name of the issuer
299
300    def set_issuer(self, key, subject=None, cert=None):
301        self.issuerKey = key
302        if subject:
303           # it's a mistake to use subject and cert params at the same time
304           assert(not cert)
305           if isinstance(subject, dict) or isinstance(subject, str):
306              req = crypto.X509Req()
307              reqSubject = req.get_subject()
308              if (isinstance(subject, dict)):
309                 for key in reqSubject.keys():
310                     setattr(reqSubject, key, name[key])
311              else:
312                 setattr(reqSubject, "CN", subject)
313              subject = reqSubject
314              # subject is not valid once req is out of scope, so save req
315              self.issuerReq = req
316        if cert:
317           # if a cert was supplied, then get the subject from the cert
318           subject = cert.cert.get_issuer()
319        assert(subject)
320        self.issuerSubject = subject
321
322    ##
323    # Get the issuer name
324
325    def get_issuer(self, which="CN"):
326        x = self.cert.get_issuer()
327        return getattr(x, which)
328
329    ##
330    # Set the subject name of the certificate
331
332    def set_subject(self, name):
333        req = crypto.X509Req()
334        subj = req.get_subject()
335        if (isinstance(name, dict)):
336            for key in name.keys():
337                setattr(subj, key, name[key])
338        else:
339            setattr(subj, "CN", name)
340        self.cert.set_subject(subj)
341    ##
342    # Get the subject name of the certificate
343
344    def get_subject(self, which="CN"):
345        x = self.cert.get_subject()
346        return getattr(x, which)
347
348    ##
349    # Get the public key of the certificate.
350    #
351    # @param key Keypair object containing the public key
352
353    def set_pubkey(self, key):
354        assert(isinstance(key, Keypair))
355        self.cert.set_pubkey(key.get_openssl_pkey())
356
357    ##
358    # Get the public key of the certificate.
359    # It is returned in the form of a Keypair object.
360
361    def get_pubkey(self):
362        m2x509 = X509.load_cert_string(self.save_to_string())
363        pkey = Keypair()
364        pkey.key = self.cert.get_pubkey()
365        pkey.m2key = m2x509.get_pubkey()
366        return pkey
367
368    ##
369    # Add an X509 extension to the certificate. Add_extension can only be called
370    # once for a particular extension name, due to limitations in the underlying
371    # library.
372    #
373    # @param name string containing name of extension
374    # @param value string containing value of the extension
375
376    def add_extension(self, name, critical, value):
377        ext = crypto.X509Extension (name, critical, value)
378        self.cert.add_extensions([ext])
379
380    ##
381    # Get an X509 extension from the certificate
382
383    def get_extension(self, name):
384        # pyOpenSSL does not have a way to get extensions
385        m2x509 = X509.load_cert_string(self.save_to_string())
386        value = m2x509.get_ext(name).get_value()
387        return value
388
389    ##
390    # Set_data is a wrapper around add_extension. It stores the parameter str in
391    # the X509 subject_alt_name extension. Set_data can only be called once, due
392    # to limitations in the underlying library.
393
394    def set_data(self, str):
395        # pyOpenSSL only allows us to add extensions, so if we try to set the
396        # same extension more than once, it will not work
397        if self.data != None:
398           raise "cannot set subjectAltName more than once"
399        self.data = str
400        self.add_extension("subjectAltName", 0, "URI:http://" + str)
401
402    ##
403    # Return the data string that was previously set with set_data
404
405    def get_data(self):
406        if self.data:
407            return self.data
408
409        try:
410            uri = self.get_extension("subjectAltName")
411        except LookupError:
412            self.data = None
413            return self.data
414
415        if not uri.startswith("URI:http://"):
416            raise "bad encoding in subjectAltName"
417        self.data = uri[11:]
418        return self.data
419
420    ##
421    # Sign the certificate using the issuer private key and issuer subject previous set with set_issuer().
422
423    def sign(self):
424        assert self.cert != None
425        assert self.issuerSubject != None
426        assert self.issuerKey != None
427        self.cert.set_issuer(self.issuerSubject)
428        self.cert.sign(self.issuerKey.get_openssl_pkey(), self.digest)
429
430     ##
431     # Verify the authenticity of a certificate.
432     # @param pkey is a Keypair object representing a public key. If Pkey
433     #     did not sign the certificate, then an exception will be thrown.
434
435    def verify(self, pkey):
436        # pyOpenSSL does not have a way to verify signatures
437        m2x509 = X509.load_cert_string(self.save_to_string())
438        m2pkey = pkey.get_m2_pkey()
439        # verify it
440        return m2x509.verify(m2pkey)
441
442        # XXX alternatively, if openssl has been patched, do the much simpler:
443        # try:
444        #   self.cert.verify(pkey.get_openssl_key())
445        #   return 1
446        # except:
447        #   return 0
448
449    ##
450    # Return True if pkey is identical to the public key that is contained in the certificate.
451    # @param pkey Keypair object
452
453    def is_pubkey(self, pkey):
454        return self.get_pubkey().is_same(pkey)
455
456    ##
457    # Given a certificate cert, verify that this certificate was signed by the
458    # public key contained in cert. Throw an exception otherwise.
459    #
460    # @param cert certificate object
461
462    def is_signed_by_cert(self, cert):
463        k = cert.get_pubkey()
464        result = self.verify(k)
465        return result
466
467    ##
468    # Set the parent certficiate.
469    #
470    # @param p certificate object.
471
472    def set_parent(self, p):
473         self.parent = p
474
475    ##
476    # Return the certificate object of the parent of this certificate.
477
478    def get_parent(self):
479         return self.parent
480
481    ##
482    # Verification examines a chain of certificates to ensure that each parent
483    # signs the child, and that some certificate in the chain is signed by a
484    # trusted certificate.
485    #
486    # Verification is a basic recursion: <pre>
487    #     if this_certificate was signed by trusted_certs:
488    #         return
489    #     else
490    #         return verify_chain(parent, trusted_certs)
491    # </pre>
492    #
493    # At each recursion, the parent is tested to ensure that it did sign the
494    # child. If a parent did not sign a child, then an exception is thrown. If
495    # the bottom of the recursion is reached and the certificate does not match
496    # a trusted root, then an exception is thrown.
497    #
498    # @param Trusted_certs is a list of certificates that are trusted.
499    #
500
501    def verify_chain(self, trusted_certs = None):
502         # Verify a chain of certificates. Each certificate must be signed by
503         # the public key contained in it's parent. The chain is recursed
504         # until a certificate is found that is signed by a trusted root.
505
506         # TODO: verify expiration time
507
508         # if this cert is signed by a trusted_cert, then we are set
509         for trusted_cert in trusted_certs:
510             # TODO: verify expiration of trusted_cert ?
511             if self.is_signed_by_cert(trusted_cert):
512                 #print self.get_subject(), "is signed by a root"
513                 return
514
515         # if there is no parent, then no way to verify the chain
516         if not self.parent:
517             #print self.get_subject(), "has no parent"
518             raise CertMissingParent(self.get_subject())
519
520         # if it wasn't signed by the parent...
521         if not self.is_signed_by_cert(self.parent):
522             #print self.get_subject(), "is not signed by parent"
523             return CertNotSignedByParent(self.get_subject())
524
525         # if the parent isn't verified...
526         self.parent.verify_chain(trusted_certs)
527
528         return