9d82cac4fbb097bdd8ece12af9ace8d8eedc0d39
[umurmur.git] / src / ssl.c
1 /* Copyright (C) 2009-2010, Martin Johansson <martin@fatbob.nu>
2    Copyright (C) 2005-2010, Thorvald Natvig <thorvald@natvig.com>
3
4    All rights reserved.
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions
8    are met:
9
10    - Redistributions of source code must retain the above copyright notice,
11      this list of conditions and the following disclaimer.
12    - Redistributions in binary form must reproduce the above copyright notice,
13      this list of conditions and the following disclaimer in the documentation
14      and/or other materials provided with the distribution.
15    - Neither the name of the Developers nor the names of its contributors may
16      be used to endorse or promote products derived from this software without
17      specific prior written permission.
18
19    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22    A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
23    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
26    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
27    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
28    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
29    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31 #include <string.h>
32 #include <stdlib.h>
33
34 #include "conf.h"
35 #include "log.h"
36 #include "ssl.h"
37
38 #ifdef USE_POLARSSL
39 /*
40  * PolarSSL interface
41  */
42
43 #include <polarssl/havege.h>
44 #include <polarssl/certs.h>
45 #include <polarssl/x509.h>
46 #include <polarssl/ssl.h>
47 #include <polarssl/net.h>
48
49 #define CA_CRT_FILENAME "ca.crt"
50
51 int ciphers[] =
52 {
53     SSL_EDH_RSA_AES_256_SHA,
54     SSL_EDH_RSA_CAMELLIA_256_SHA,
55     SSL_EDH_RSA_DES_168_SHA,
56     SSL_RSA_AES_256_SHA,
57     SSL_RSA_CAMELLIA_256_SHA,
58     SSL_RSA_AES_128_SHA,
59     SSL_RSA_CAMELLIA_128_SHA,
60     SSL_RSA_DES_168_SHA,
61     SSL_RSA_RC4_128_SHA,
62     SSL_RSA_RC4_128_MD5,
63     0
64 };
65 static x509_cert certificate;
66 static rsa_context key;
67 havege_state hs; /* exported to crypt.c */
68
69 /* DH prime */
70 char *my_dhm_P =
71         "9CE85640903BF123906947FEDE767261" \
72         "D9B4A973EB8F7D984A8C656E2BCC161C" \
73         "183D4CA471BA78225F940F16D1D99CA3" \
74         "E66152CC68EDCE1311A390F307741835" \
75         "44FF6AB553EC7073AD0CB608F2A3B480" \
76         "19E6C02BCED40BD30E91BB2469089670" \
77         "DEF409C08E8AC24D1732A6128D2220DC53";
78 char *my_dhm_G = "4";
79
80 static void initCert()
81 {
82         int rc;
83         char *crtfile = (char *)getStrConf(CERTIFICATE);
84         char *ca_file, *p;
85         
86         if (crtfile == NULL)
87                 Log_fatal("No certificate file specified"); 
88         rc = x509parse_crtfile(&certificate, crtfile);
89         if (rc != 0)
90                 Log_fatal("Could not read certificate file %s", crtfile);
91         
92         /* Look for CA certificate file in same dir */
93         ca_file = malloc(strlen(crtfile) + strlen(CA_CRT_FILENAME) + 1);
94         strcpy(ca_file, crtfile);
95         p = strrchr(ca_file, '/');
96         if (p != NULL)
97                 strcpy(p + 1, CA_CRT_FILENAME);
98         else
99                 strcpy(ca_file, CA_CRT_FILENAME);
100         
101         rc = x509parse_crtfile(&certificate, ca_file);
102         if (rc != 0) { /* No CA certifiacte found. Assume self-signed. */
103                 Log_info("CA certificate file %s not found. Assuming self-signed certificate.", ca_file);
104                 /*
105                  * Apparently PolarSSL needs to read something more into certificate chain.
106                  * Doesn't seem to matter what. Read own certificate again.
107                  */
108                 rc = x509parse_crtfile(&certificate, crtfile);
109                 if (rc != 0)
110                         Log_fatal("Could not read certificate file %s", crtfile);
111         }
112         free(ca_file);
113 }
114
115 static void initKey()
116 {
117         int rc;
118         char *keyfile = (char *)getStrConf(KEY);
119         
120         if (keyfile == NULL)
121                 Log_fatal("No key file specified"); 
122         rc = x509parse_keyfile(&key, keyfile, NULL);
123         if (rc != 0)
124                 Log_fatal("Could not read RSA key file %s", keyfile);
125 }
126
127 #define DEBUG_LEVEL 0
128 static void pssl_debug(void *ctx, int level, char *str)
129 {
130     if (level <= DEBUG_LEVEL)
131                 Log_debug("PolarSSL [level %d]: %s", level, str);
132 }
133
134 void SSLi_init(void)
135 {
136         initCert();
137         initKey();
138     havege_init(&hs);
139         Log_info("PolarSSL library initialized");
140 }
141
142 void SSLi_deinit(void)
143 {
144         x509_free(&certificate);
145         rsa_free(&key);
146 }
147
148 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
149 {
150         ssl_context *ssl;
151         ssl_session *ssn;
152         int rc;
153         
154         ssl = malloc(sizeof(ssl_context));
155         ssn = malloc(sizeof(ssl_session));
156         if (!ssl || !ssn)
157                 Log_fatal("Out of memory");
158         memset(ssl, 0, sizeof(ssl_context));
159         memset(ssn, 0, sizeof(ssl_session));
160         
161         rc = ssl_init(ssl);
162         if (rc != 0 )
163                 Log_fatal("Failed to initalize: %d", rc);
164         
165         ssl_set_endpoint(ssl, SSL_IS_SERVER);   
166     ssl_set_authmode(ssl, SSL_VERIFY_OPTIONAL);
167
168     ssl_set_rng(ssl, havege_rand, &hs);
169     ssl_set_dbg(ssl, pssl_debug, NULL);
170     ssl_set_bio(ssl, net_recv, fd, net_send, fd);
171
172     ssl_set_ciphers(ssl, ciphers);
173     ssl_set_session(ssl, 0, 0, ssn);
174
175     ssl_set_ca_chain(ssl, certificate.next, NULL, NULL);
176     ssl_set_own_cert(ssl, &certificate, &key);
177     ssl_set_dh_param(ssl, my_dhm_P, my_dhm_G);
178
179         return ssl;
180 }
181
182 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
183 {
184         int rc;
185         
186         rc = ssl_handshake(ssl);
187         if (rc != 0) {
188                 if (rc == POLARSSL_ERR_NET_TRY_AGAIN) {
189                         return 0;
190                 } else {
191                         Log_warn("SSL handshake failed: %d", rc);
192                         return -1;
193                 }
194         }
195         *SSLready = true;
196         return 0;
197 }
198
199 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
200 {
201         int rc;
202         rc = ssl_read(ssl, buf, len);
203         if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
204                 return SSLI_ERROR_WANT_READ;
205         return rc;
206 }
207
208 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
209 {
210         int rc;
211         rc = ssl_write(ssl, buf, len);
212         if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
213                 return SSLI_ERROR_WANT_WRITE;
214         return rc;
215 }
216
217 int SSLi_get_error(SSL_handle_t *ssl, int code)
218 {
219         return code;
220 }
221
222 bool_t SSLi_data_pending(SSL_handle_t *ssl)
223 {
224         return ssl_get_bytes_avail(ssl) > 0;
225 }
226
227 void SSLi_shutdown(SSL_handle_t *ssl)
228 {
229         ssl_close_notify(ssl);
230 }
231
232 void SSLi_free(SSL_handle_t *ssl)
233 {
234         Log_debug("SSLi_free");
235         free(ssl->session); /* XXX - Hmmm. */
236         ssl_free(ssl);
237         free(ssl);
238 }
239
240 #else
241 /*
242  * OpenSSL interface
243  */
244
245 #include <openssl/x509v3.h>
246 #include <openssl/ssl.h>
247 #include <openssl/err.h>
248 #include <openssl/safestack.h>
249 static X509 *x509;
250 static RSA *rsa;
251 static SSL_CTX *context;
252 static EVP_PKEY *pkey;
253
254 static int SSL_add_ext(X509 * crt, int nid, char *value) {
255         X509_EXTENSION *ex;
256         X509V3_CTX ctx;
257         X509V3_set_ctx_nodb(&ctx);
258         X509V3_set_ctx(&ctx, crt, crt, NULL, NULL, 0);
259         ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
260         if (!ex)
261                 return 0;
262
263         X509_add_ext(crt, ex, -1);
264         X509_EXTENSION_free(ex);
265         return 1;
266 }
267
268 static X509 *SSL_readcert(char *certfile)
269 {
270         FILE *fp;
271         X509 *x509;
272                         
273         /* open the private key file */
274         fp = fopen(certfile, "r");
275         if (fp == NULL) {
276                 Log_warn("Unable to open the X509 file %s for reading.", certfile);
277                 return NULL;
278         }
279         
280         /* allocate memory for the cert structure */    
281         x509 = X509_new();
282         
283         if (PEM_read_X509(fp, &x509, NULL, NULL) == 0) {
284                 /* error reading the x509 information - check the error stack */
285                 Log_warn("Error trying to read X509 info.");
286                 fclose(fp);
287                 X509_free(x509);
288                 return NULL;
289         }
290         fclose(fp);
291         return x509;
292 }
293
294 static RSA *SSL_readprivatekey(char *keyfile)
295 {
296         FILE *fp;
297         RSA *rsa;
298
299 /* open the private key file for reading */
300         fp = fopen(keyfile, "r");
301         if (fp == NULL) {
302                 Log_warn("Unable to open the private key file %s for reading.", keyfile);
303                 return NULL;
304         }
305         
306 /* allocate memory for the RSA structure */
307         rsa = RSA_new();
308         
309         /* assign a callback function for the password */
310         
311         /* read a private key from file */      
312         if (PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL) <= 0) {
313                 /* error reading the key - check the error stack */
314                 Log_warn("Error trying to read private key.");
315                 RSA_free(rsa);
316                 fclose(fp);
317                 return NULL;
318         }
319         fclose(fp);
320         return rsa;
321 }
322
323 static void SSL_writecert(char *certfile, X509 *x509)
324 {
325         FILE *fp;
326         BIO *err_output;
327         
328         /* prepare a BIO for outputting error messages */
329         
330         err_output = BIO_new_fp(stderr,BIO_NOCLOSE);
331         
332         /* open the private key file */
333         fp = fopen(certfile, "w");
334         if (fp == NULL) {
335                 BIO_printf(err_output, "Unable to open the X509 file for writing.\n");
336                 BIO_free(err_output);
337                 return;
338         }
339                 
340         if (PEM_write_X509(fp, x509) == 0) {
341                 BIO_printf(err_output, "Error trying to write X509 info.\n");
342                 ERR_print_errors(err_output);
343         }
344         fclose(fp);
345 }
346
347 static void SSL_writekey(char *keyfile, RSA *rsa)
348 {
349         FILE *fp;
350         BIO *err_output;
351         /* prepare a BIO for outputing error messages */        
352         err_output = BIO_new_fp(stderr, BIO_NOCLOSE);
353         
354         /* open the private key file for reading */
355         fp = fopen(keyfile, "w");
356         if (fp == NULL) {
357                 BIO_printf(err_output, "Unable to open the private key file %s for writing.\n", keyfile);
358                 BIO_free(err_output);
359                 return;
360         }
361         
362         if (PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL) == 0) {
363                 /* error reading the key - check the error stack */
364                 BIO_printf(err_output, "Error trying to write private key\n");
365                 ERR_print_errors(err_output);
366         }
367         fclose(fp);
368 }
369
370 static void SSL_initializeCert() {
371         char *crt, *key, *pass;
372         
373         crt = (char *)getStrConf(CERTIFICATE);
374         key = (char *)getStrConf(KEY);
375         pass = (char *)getStrConf(PASSPHRASE);
376
377         x509 = SSL_readcert(crt);
378         rsa = SSL_readprivatekey(key);
379         if (rsa != NULL) {
380                 pkey = EVP_PKEY_new();
381                 EVP_PKEY_assign_RSA(pkey, rsa);
382         }               
383         
384 #if 0
385         /* Later ... */
386         if (key && !x509) {             
387                 qscCert = QSslCertificate(key);
388                 if (! qscCert.isNull()) {
389                         logthis("Using certificate from key.");
390                 }
391         }
392
393         if (! qscCert.isNull()) {
394                 QSsl::KeyAlgorithm alg = qscCert.publicKey().algorithm();
395                 /* Fetch algorith from cert */
396                 if (! key.isEmpty()) {
397                         /* get key */
398                         qskKey = QSslKey(key, alg, QSsl::Pem, QSsl::PrivateKey, pass);
399                         if (qskKey.isNull()) {
400                                 logthis("Failed to parse key.");
401                         }
402                 }
403
404                 if (! crt.isEmpty() && qskKey.isNull()) {
405                         /* get key from certificate */
406                         qskKey = QSslKey(crt, alg, QSsl::Pem, QSsl::PrivateKey, pass);
407                         if (! qskKey.isNull()) {
408                                 logthis("Using key from certificate.");
409                         }
410                 }
411
412         }
413 #endif
414         
415         if (!rsa || !x509) {
416                 logthis("Generating new server certificate.");
417
418                 BIO *bio_err;
419                 
420                 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
421                 
422                 bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
423                 
424                 x509 = X509_new();
425                 pkey = EVP_PKEY_new();
426                 rsa = RSA_generate_key(1024,RSA_F4,NULL,NULL);
427                 EVP_PKEY_assign_RSA(pkey, rsa);
428                 
429                 X509_set_version(x509, 2);
430                 ASN1_INTEGER_set(X509_get_serialNumber(x509),1);
431                 X509_gmtime_adj(X509_get_notBefore(x509),0);
432                 X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365);
433                 X509_set_pubkey(x509, pkey);
434                 
435                 X509_NAME *name=X509_get_subject_name(x509);
436                 
437                 X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (const uint8_t *)"Murmur Autogenerated Certificate v2", -1, -1, 0);
438                 X509_set_issuer_name(x509, name);
439                 SSL_add_ext(x509, NID_basic_constraints, "critical,CA:FALSE");
440                 SSL_add_ext(x509, NID_ext_key_usage, "serverAuth,clientAuth");
441                 SSL_add_ext(x509, NID_subject_key_identifier, "hash");
442                 SSL_add_ext(x509, NID_netscape_comment, "Generated from umurmur");
443                 
444                 X509_sign(x509, pkey, EVP_md5());
445                 
446                 SSL_writecert(crt, x509);
447                 SSL_writekey(key, rsa);
448         }
449
450 }
451
452 void SSLi_init(void)
453 {
454         const SSL_METHOD *method;
455         SSL *ssl;
456         int i, offset = 0;
457         STACK_OF(SSL_CIPHER) *cipherlist = NULL, *cipherlist_new = NULL;
458         SSL_CIPHER *cipher;
459         char cipherstring[1024];
460                 
461         SSL_library_init();
462     OpenSSL_add_all_algorithms();               /* load & register all cryptos, etc. */
463     SSL_load_error_strings();                   /* load all error messages */
464     ERR_load_crypto_strings();                  /* load all error messages */
465     method = SSLv23_server_method();            /* create new server-method instance */
466     context = SSL_CTX_new(method);                      /* create new context from method */
467     if (context == NULL)
468     {
469         ERR_print_errors_fp(stderr);
470         abort();
471     }
472         SSL_initializeCert();
473         if (SSL_CTX_use_certificate(context, x509) <= 0)
474                 Log_fatal("Failed to initialize cert");
475         if (SSL_CTX_use_PrivateKey(context, pkey) <= 0) {
476                 ERR_print_errors_fp(stderr);
477                 Log_fatal("Failed to initialize private key");
478         }
479
480         /* Set cipher list */
481         ssl = SSL_new(context); 
482         cipherlist = (STACK_OF(SSL_CIPHER) *) SSL_get_ciphers(ssl);
483         cipherlist_new = (STACK_OF(SSL_CIPHER) *) sk_SSL_CIPHER_new_null();
484         
485         for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist, i)) != NULL; i++) {
486                 if (SSL_CIPHER_get_bits(cipher, NULL) >= 128) {
487                         sk_SSL_CIPHER_push(cipherlist_new, cipher);
488                 }
489         }
490         Log_debug("List of ciphers:");
491         if (cipherlist_new) {
492                 for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
493                         Log_debug("%s", SSL_CIPHER_get_name(cipher));
494                         offset += snprintf(cipherstring + offset, 1024 - offset, "%s:", SSL_CIPHER_get_name(cipher));
495                 }
496                 cipherstring[offset - 1] = '\0';
497         }
498         
499         if (cipherlist_new)
500                 sk_SSL_CIPHER_free(cipherlist_new);
501         
502         if (strlen(cipherstring) == 0)
503                 Log_fatal("No suitable ciphers found!");
504         
505         if (SSL_CTX_set_cipher_list(context, cipherstring) == 0)
506                 Log_fatal("Failed to set cipher list!");
507                 
508         
509         SSL_free(ssl);
510         Log_info("OpenSSL library initialized");
511
512 }
513
514 void SSLi_deinit(void)
515 {
516         SSL_CTX_free(context);
517         EVP_cleanup();
518 }
519
520 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
521 {
522         int rc;
523         rc = SSL_accept(ssl);
524         if (rc < 0) {
525                 if (SSL_get_error(ssl, rc) == SSL_ERROR_WANT_READ ||
526                         SSL_get_error(ssl, rc) == SSL_ERROR_WANT_WRITE) {
527                         Log_debug("SSL not ready");
528                         return 0;
529                 } else {
530                         Log_warn("SSL error: %s", ERR_error_string(SSL_get_error(ssl, rc), NULL));
531                         return -1;
532                 }
533         }
534         *SSLready = true;
535         return 0;
536 }
537
538 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
539 {
540         SSL *ssl;
541         
542         *SSLready = false;
543         ssl = SSL_new(context);
544         SSL_set_fd(ssl, *fd);
545         if (SSLi_nonblockaccept(ssl, SSLready) < 0) {
546                 SSL_free(ssl);
547                 return NULL;
548         }
549         return ssl;
550 }
551
552 void SSLi_closeconnection(SSL_handle_t *ssl)
553 {
554         SSL_free(ssl);
555 }
556
557 void SSLi_shutdown(SSL_handle_t *ssl)
558 {
559         SSL_shutdown(ssl);
560 }
561
562 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
563 {
564         return SSL_read(ssl, buf, len);
565 }
566
567 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
568 {
569         return SSL_write(ssl, buf, len);
570 }
571
572 int SSLi_get_error(SSL_handle_t *ssl, int code)
573 {
574         return SSL_get_error(ssl, code);
575 }
576
577 bool_t SSLi_data_pending(SSL_handle_t *ssl)
578 {
579         return SSL_pending(ssl);
580 }
581
582 void SSLi_free(SSL_handle_t *ssl)
583 {
584         SSL_free(ssl);
585 }
586
587 #endif