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