4224c1de08f152d93922dc4eda09c8b03480f98e
[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 bool_t builtInTestCertificate;
68
69 havege_state hs; /* exported to crypt.c */
70
71 /* DH prime */
72 char *my_dhm_P =
73         "9CE85640903BF123906947FEDE767261" \
74         "D9B4A973EB8F7D984A8C656E2BCC161C" \
75         "183D4CA471BA78225F940F16D1D99CA3" \
76         "E66152CC68EDCE1311A390F307741835" \
77         "44FF6AB553EC7073AD0CB608F2A3B480" \
78         "19E6C02BCED40BD30E91BB2469089670" \
79         "DEF409C08E8AC24D1732A6128D2220DC53";
80 char *my_dhm_G = "4";
81
82 static void initTestCert()
83 {
84         int rc;
85         builtInTestCertificate = true;
86         rc = x509parse_crt(&certificate, (unsigned char *)test_srv_crt,
87                                            strlen(test_srv_crt));       
88         if (rc != 0)
89                 Log_fatal("Could not parse built-in test certificate");
90         rc = x509parse_crt(&certificate, (unsigned char *)test_ca_crt,
91                                            strlen(test_ca_crt));
92         if (rc != 0)
93                 Log_fatal("Could not parse built-in test CA certificate");
94 }
95
96 static void initTestKey()
97 {
98         int rc;
99         
100         rc = x509parse_key(&key, (unsigned char *)test_srv_key,
101                                            strlen(test_srv_key), NULL, 0);
102         if (rc != 0)
103                 Log_fatal("Could not parse built-in test RSA key");
104 }
105
106 /*
107  * openssl genrsa 1024 > host.key
108  * openssl req -new -x509 -nodes -sha1 -days 365 -key host.key > host.cert
109  */
110 static void initCert()
111 {
112         int rc;
113         char *crtfile = (char *)getStrConf(CERTIFICATE);
114         char *ca_file, *p;
115         
116         if (crtfile == NULL) {
117                 Log_warn("No certificate file specified");
118                 initTestCert();
119                 return;
120         }
121         rc = x509parse_crtfile(&certificate, crtfile);
122         if (rc != 0) {
123                 Log_warn("Could not read certificate file %s", crtfile);
124                 initTestCert();
125                 return;
126         }
127         
128         /* Look for CA certificate file in same dir */
129         ca_file = malloc(strlen(crtfile) + strlen(CA_CRT_FILENAME) + 1);
130         strcpy(ca_file, crtfile);
131         p = strrchr(ca_file, '/');
132         if (p != NULL)
133                 strcpy(p + 1, CA_CRT_FILENAME);
134         else
135                 strcpy(ca_file, CA_CRT_FILENAME);
136         
137         rc = x509parse_crtfile(&certificate, ca_file);
138         if (rc != 0) { /* No CA certifiacte found. Assume self-signed. */
139                 Log_info("CA certificate file %s not found. Assuming self-signed certificate.", ca_file);
140         }
141         
142         /*
143          * PolarSSL 0.11 - 0.12,1 has a bug; it ignores the last certificate in the chain.
144          * Read the certificate again so that it gets last in chain. Later releases like 0.14.0 works
145          * fine with the extra certificate, so I don't see any harm in doing so.
146          */
147         rc = x509parse_crtfile(&certificate, crtfile);
148         if (rc != 0)
149                 Log_fatal("Could not read certificate file %s", crtfile);
150         
151         free(ca_file);
152 }
153
154 static void initKey()
155 {
156         int rc;
157         char *keyfile = (char *)getStrConf(KEY);
158
159         if (keyfile == NULL)
160                 Log_fatal("No key file specified"); 
161         rc = x509parse_keyfile(&key, keyfile, NULL);
162         if (rc != 0)
163                 Log_fatal("Could not read RSA key file %s", keyfile);
164 }
165
166 #define DEBUG_LEVEL 0
167 static void pssl_debug(void *ctx, int level, const char *str)
168 {
169     if (level <= DEBUG_LEVEL)
170                 Log_debug("PolarSSL [level %d]: %s", level, str);
171 }
172
173 void SSLi_init(void)
174 {
175         initCert();
176         if (builtInTestCertificate) {
177                 Log_warn("*** Using built-in test certificate and RSA key ***");
178                 Log_warn("*** This is not secure! Please use a CA-signed certificate or create a self-signed certificate ***");
179                 initTestKey();
180         }
181         else
182                 initKey();
183     havege_init(&hs);
184         Log_info("PolarSSL library initialized");
185 }
186
187 void SSLi_deinit(void)
188 {
189         x509_free(&certificate);
190         rsa_free(&key);
191 }
192
193 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
194 {
195         ssl_context *ssl;
196         ssl_session *ssn;
197         int rc;
198         
199         ssl = malloc(sizeof(ssl_context));
200         ssn = malloc(sizeof(ssl_session));
201         if (!ssl || !ssn)
202                 Log_fatal("Out of memory");
203         memset(ssl, 0, sizeof(ssl_context));
204         memset(ssn, 0, sizeof(ssl_session));
205         
206         rc = ssl_init(ssl);
207         if (rc != 0 )
208                 Log_fatal("Failed to initalize: %d", rc);
209         
210         ssl_set_endpoint(ssl, SSL_IS_SERVER);   
211     ssl_set_authmode(ssl, SSL_VERIFY_OPTIONAL);
212
213     ssl_set_rng(ssl, havege_rand, &hs);
214     ssl_set_dbg(ssl, pssl_debug, NULL);
215     ssl_set_bio(ssl, net_recv, fd, net_send, fd);
216
217     ssl_set_ciphers(ssl, ciphers);
218     ssl_set_session(ssl, 0, 0, ssn);
219
220     ssl_set_ca_chain(ssl, certificate.next, NULL, NULL);
221     ssl_set_own_cert(ssl, &certificate, &key);
222     ssl_set_dh_param(ssl, my_dhm_P, my_dhm_G);
223
224         return ssl;
225 }
226
227 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
228 {
229         int rc;
230         
231         rc = ssl_handshake(ssl);
232         if (rc != 0) {
233                 if (rc == POLARSSL_ERR_NET_TRY_AGAIN) {
234                         return 0;
235                 } else {
236                         Log_warn("SSL handshake failed: %d", rc);
237                         return -1;
238                 }
239         }
240         *SSLready = true;
241         return 0;
242 }
243
244 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
245 {
246         int rc;
247         rc = ssl_read(ssl, buf, len);
248         if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
249                 return SSLI_ERROR_WANT_READ;
250         return rc;
251 }
252
253 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
254 {
255         int rc;
256         rc = ssl_write(ssl, buf, len);
257         if (rc == POLARSSL_ERR_NET_TRY_AGAIN)
258                 return SSLI_ERROR_WANT_WRITE;
259         return rc;
260 }
261
262 int SSLi_get_error(SSL_handle_t *ssl, int code)
263 {
264         return code;
265 }
266
267 bool_t SSLi_data_pending(SSL_handle_t *ssl)
268 {
269         return ssl_get_bytes_avail(ssl) > 0;
270 }
271
272 void SSLi_shutdown(SSL_handle_t *ssl)
273 {
274         ssl_close_notify(ssl);
275 }
276
277 void SSLi_free(SSL_handle_t *ssl)
278 {
279         Log_debug("SSLi_free");
280         free(ssl->session); /* XXX - Hmmm. */
281         ssl_free(ssl);
282         free(ssl);
283 }
284
285 #else
286 /*
287  * OpenSSL interface
288  */
289
290 #include <openssl/x509v3.h>
291 #include <openssl/ssl.h>
292 #include <openssl/err.h>
293 #include <openssl/safestack.h>
294 static X509 *x509;
295 static RSA *rsa;
296 static SSL_CTX *context;
297 static EVP_PKEY *pkey;
298
299 static int SSL_add_ext(X509 * crt, int nid, char *value) {
300         X509_EXTENSION *ex;
301         X509V3_CTX ctx;
302         X509V3_set_ctx_nodb(&ctx);
303         X509V3_set_ctx(&ctx, crt, crt, NULL, NULL, 0);
304         ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value);
305         if (!ex)
306                 return 0;
307
308         X509_add_ext(crt, ex, -1);
309         X509_EXTENSION_free(ex);
310         return 1;
311 }
312
313 static X509 *SSL_readcert(char *certfile)
314 {
315         FILE *fp;
316         X509 *x509;
317                         
318         /* open the private key file */
319         fp = fopen(certfile, "r");
320         if (fp == NULL) {
321                 Log_warn("Unable to open the X509 file %s for reading.", certfile);
322                 return NULL;
323         }
324         
325         /* allocate memory for the cert structure */    
326         x509 = X509_new();
327         
328         if (PEM_read_X509(fp, &x509, NULL, NULL) == 0) {
329                 /* error reading the x509 information - check the error stack */
330                 Log_warn("Error trying to read X509 info.");
331                 fclose(fp);
332                 X509_free(x509);
333                 return NULL;
334         }
335         fclose(fp);
336         return x509;
337 }
338
339 static RSA *SSL_readprivatekey(char *keyfile)
340 {
341         FILE *fp;
342         RSA *rsa;
343
344 /* open the private key file for reading */
345         fp = fopen(keyfile, "r");
346         if (fp == NULL) {
347                 Log_warn("Unable to open the private key file %s for reading.", keyfile);
348                 return NULL;
349         }
350         
351 /* allocate memory for the RSA structure */
352         rsa = RSA_new();
353         
354         /* assign a callback function for the password */
355         
356         /* read a private key from file */      
357         if (PEM_read_RSAPrivateKey(fp, &rsa, NULL, NULL) <= 0) {
358                 /* error reading the key - check the error stack */
359                 Log_warn("Error trying to read private key.");
360                 RSA_free(rsa);
361                 fclose(fp);
362                 return NULL;
363         }
364         fclose(fp);
365         return rsa;
366 }
367
368 static void SSL_writecert(char *certfile, X509 *x509)
369 {
370         FILE *fp;
371         BIO *err_output;
372         
373         /* prepare a BIO for outputting error messages */
374         
375         err_output = BIO_new_fp(stderr,BIO_NOCLOSE);
376         
377         /* open the private key file */
378         fp = fopen(certfile, "w");
379         if (fp == NULL) {
380                 BIO_printf(err_output, "Unable to open the X509 file for writing.\n");
381                 BIO_free(err_output);
382                 return;
383         }
384                 
385         if (PEM_write_X509(fp, x509) == 0) {
386                 BIO_printf(err_output, "Error trying to write X509 info.\n");
387                 ERR_print_errors(err_output);
388         }
389         fclose(fp);
390 }
391
392 static void SSL_writekey(char *keyfile, RSA *rsa)
393 {
394         FILE *fp;
395         BIO *err_output;
396         /* prepare a BIO for outputing error messages */        
397         err_output = BIO_new_fp(stderr, BIO_NOCLOSE);
398         
399         /* open the private key file for reading */
400         fp = fopen(keyfile, "w");
401         if (fp == NULL) {
402                 BIO_printf(err_output, "Unable to open the private key file %s for writing.\n", keyfile);
403                 BIO_free(err_output);
404                 return;
405         }
406         
407         if (PEM_write_RSAPrivateKey(fp, rsa, NULL, NULL, 0, NULL, NULL) == 0) {
408                 /* error reading the key - check the error stack */
409                 BIO_printf(err_output, "Error trying to write private key\n");
410                 ERR_print_errors(err_output);
411         }
412         fclose(fp);
413 }
414
415 static void SSL_initializeCert() {
416         char *crt, *key, *pass;
417         
418         crt = (char *)getStrConf(CERTIFICATE);
419         key = (char *)getStrConf(KEY);
420         pass = (char *)getStrConf(PASSPHRASE);
421
422         x509 = SSL_readcert(crt);
423         rsa = SSL_readprivatekey(key);
424         if (rsa != NULL) {
425                 pkey = EVP_PKEY_new();
426                 EVP_PKEY_assign_RSA(pkey, rsa);
427         }               
428         
429 #if 0
430         /* Later ... */
431         if (key && !x509) {             
432                 qscCert = QSslCertificate(key);
433                 if (! qscCert.isNull()) {
434                         logthis("Using certificate from key.");
435                 }
436         }
437
438         if (! qscCert.isNull()) {
439                 QSsl::KeyAlgorithm alg = qscCert.publicKey().algorithm();
440                 /* Fetch algorith from cert */
441                 if (! key.isEmpty()) {
442                         /* get key */
443                         qskKey = QSslKey(key, alg, QSsl::Pem, QSsl::PrivateKey, pass);
444                         if (qskKey.isNull()) {
445                                 logthis("Failed to parse key.");
446                         }
447                 }
448
449                 if (! crt.isEmpty() && qskKey.isNull()) {
450                         /* get key from certificate */
451                         qskKey = QSslKey(crt, alg, QSsl::Pem, QSsl::PrivateKey, pass);
452                         if (! qskKey.isNull()) {
453                                 logthis("Using key from certificate.");
454                         }
455                 }
456
457         }
458 #endif
459         
460         if (!rsa || !x509) {
461                 logthis("Generating new server certificate.");
462
463                 BIO *bio_err;
464                 
465                 CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
466                 
467                 bio_err=BIO_new_fp(stderr, BIO_NOCLOSE);
468                 
469                 x509 = X509_new();
470                 pkey = EVP_PKEY_new();
471                 rsa = RSA_generate_key(1024,RSA_F4,NULL,NULL);
472                 EVP_PKEY_assign_RSA(pkey, rsa);
473                 
474                 X509_set_version(x509, 2);
475                 ASN1_INTEGER_set(X509_get_serialNumber(x509),1);
476                 X509_gmtime_adj(X509_get_notBefore(x509),0);
477                 X509_gmtime_adj(X509_get_notAfter(x509),60*60*24*365);
478                 X509_set_pubkey(x509, pkey);
479                 
480                 X509_NAME *name=X509_get_subject_name(x509);
481                 
482                 X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC, (const uint8_t *)"Murmur Autogenerated Certificate v2", -1, -1, 0);
483                 X509_set_issuer_name(x509, name);
484                 SSL_add_ext(x509, NID_basic_constraints, "critical,CA:FALSE");
485                 SSL_add_ext(x509, NID_ext_key_usage, "serverAuth,clientAuth");
486                 SSL_add_ext(x509, NID_subject_key_identifier, "hash");
487                 SSL_add_ext(x509, NID_netscape_comment, "Generated from umurmur");
488                 
489                 X509_sign(x509, pkey, EVP_md5());
490                 
491                 SSL_writecert(crt, x509);
492                 SSL_writekey(key, rsa);
493         }
494
495 }
496
497 void SSLi_init(void)
498 {
499         const SSL_METHOD *method;
500         SSL *ssl;
501         int i, offset = 0;
502         STACK_OF(SSL_CIPHER) *cipherlist = NULL, *cipherlist_new = NULL;
503         SSL_CIPHER *cipher;
504         char cipherstring[1024];
505                 
506         SSL_library_init();
507     OpenSSL_add_all_algorithms();               /* load & register all cryptos, etc. */
508     SSL_load_error_strings();                   /* load all error messages */
509     ERR_load_crypto_strings();                  /* load all error messages */
510     method = SSLv23_server_method();            /* create new server-method instance */
511     context = SSL_CTX_new(method);                      /* create new context from method */
512     if (context == NULL)
513     {
514         ERR_print_errors_fp(stderr);
515         abort();
516     }
517         SSL_initializeCert();
518         if (SSL_CTX_use_certificate(context, x509) <= 0)
519                 Log_fatal("Failed to initialize cert");
520         if (SSL_CTX_use_PrivateKey(context, pkey) <= 0) {
521                 ERR_print_errors_fp(stderr);
522                 Log_fatal("Failed to initialize private key");
523         }
524
525         /* Set cipher list */
526         ssl = SSL_new(context); 
527         cipherlist = (STACK_OF(SSL_CIPHER) *) SSL_get_ciphers(ssl);
528         cipherlist_new = (STACK_OF(SSL_CIPHER) *) sk_SSL_CIPHER_new_null();
529         
530         for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist, i)) != NULL; i++) {
531                 if (SSL_CIPHER_get_bits(cipher, NULL) >= 128) {
532                         sk_SSL_CIPHER_push(cipherlist_new, cipher);
533                 }
534         }
535         Log_debug("List of ciphers:");
536         if (cipherlist_new) {
537                 for ( i = 0; (cipher = sk_SSL_CIPHER_value(cipherlist_new, i)) != NULL; i++) {
538                         Log_debug("%s", SSL_CIPHER_get_name(cipher));
539                         offset += snprintf(cipherstring + offset, 1024 - offset, "%s:", SSL_CIPHER_get_name(cipher));
540                 }
541                 cipherstring[offset - 1] = '\0';
542         }
543         
544         if (cipherlist_new)
545                 sk_SSL_CIPHER_free(cipherlist_new);
546         
547         if (strlen(cipherstring) == 0)
548                 Log_fatal("No suitable ciphers found!");
549         
550         if (SSL_CTX_set_cipher_list(context, cipherstring) == 0)
551                 Log_fatal("Failed to set cipher list!");
552                 
553         
554         SSL_free(ssl);
555         Log_info("OpenSSL library initialized");
556
557 }
558
559 void SSLi_deinit(void)
560 {
561         SSL_CTX_free(context);
562         EVP_cleanup();
563 }
564
565 int SSLi_nonblockaccept(SSL_handle_t *ssl, bool_t *SSLready)
566 {
567         int rc;
568         rc = SSL_accept(ssl);
569         if (rc < 0) {
570                 if (SSL_get_error(ssl, rc) == SSL_ERROR_WANT_READ ||
571                         SSL_get_error(ssl, rc) == SSL_ERROR_WANT_WRITE) {
572                         Log_debug("SSL not ready");
573                         return 0;
574                 } else {
575                         Log_warn("SSL error: %s", ERR_error_string(SSL_get_error(ssl, rc), NULL));
576                         return -1;
577                 }
578         }
579         *SSLready = true;
580         return 0;
581 }
582
583 SSL_handle_t *SSLi_newconnection(int *fd, bool_t *SSLready)
584 {
585         SSL *ssl;
586         
587         *SSLready = false;
588         ssl = SSL_new(context);
589         SSL_set_fd(ssl, *fd);
590         if (SSLi_nonblockaccept(ssl, SSLready) < 0) {
591                 SSL_free(ssl);
592                 return NULL;
593         }
594         return ssl;
595 }
596
597 void SSLi_closeconnection(SSL_handle_t *ssl)
598 {
599         SSL_free(ssl);
600 }
601
602 void SSLi_shutdown(SSL_handle_t *ssl)
603 {
604         SSL_shutdown(ssl);
605 }
606
607 int SSLi_read(SSL_handle_t *ssl, uint8_t *buf, int len)
608 {
609         return SSL_read(ssl, buf, len);
610 }
611
612 int SSLi_write(SSL_handle_t *ssl, uint8_t *buf, int len)
613 {
614         return SSL_write(ssl, buf, len);
615 }
616
617 int SSLi_get_error(SSL_handle_t *ssl, int code)
618 {
619         return SSL_get_error(ssl, code);
620 }
621
622 bool_t SSLi_data_pending(SSL_handle_t *ssl)
623 {
624         return SSL_pending(ssl);
625 }
626
627 void SSLi_free(SSL_handle_t *ssl)
628 {
629         SSL_free(ssl);
630 }
631
632 #endif