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