src/src/tls-openssl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2012 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
   9 library. It is #included into the tls.c file when that library is used. The
  10 code herein is based on a patch that was originally contributed by Steve
  11 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
  12
  13 No cryptographic code is included in Exim. All this module does is to call
  14 functions from the OpenSSL library. */
  15
  16
  17 /* Heading stuff */
  18
  19 #include <openssl/lhash.h>
  20 #include <openssl/ssl.h>
  21 #include <openssl/err.h>
  22 #include <openssl/rand.h>
  23 #ifdef EXPERIMENTAL_OCSP
  24 #include <openssl/ocsp.h>
  25 #endif
  26
  27 #ifdef EXPERIMENTAL_OCSP
  28 #define EXIM_OCSP_SKEW_SECONDS (300L)
  29 #define EXIM_OCSP_MAX_AGE (-1L)
  30 #endif
  31
  32 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
  33 #define EXIM_HAVE_OPENSSL_TLSEXT
  34 #endif
  35
  36 /* Structure for collecting random data for seeding. */
  37
  38 typedef struct randstuff {
  39   struct timeval tv;
  40   pid_t          p;
  41 } randstuff;
  42
  43 /* Local static variables */
  44
  45 static BOOL verify_callback_called = FALSE;
  46 static const uschar *sid_ctx = US"exim";
  47
  48 static SSL_CTX *ctx = NULL;
  49 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
  50 static SSL_CTX *ctx_sni = NULL;
  51 #endif
  52 static SSL *ssl = NULL;
  53
  54 static char ssl_errstring[256];
  55
  56 static int  ssl_session_timeout = 200;
  57 static BOOL verify_optional = FALSE;
  58
  59 static BOOL    reexpand_tls_files_for_sni = FALSE;
  60
  61
  62 typedef struct tls_ext_ctx_cb {
  63   uschar *certificate;
  64   uschar *privatekey;
  65 #ifdef EXPERIMENTAL_OCSP
  66   uschar *ocsp_file;
  67   uschar *ocsp_file_expanded;
  68   OCSP_RESPONSE *ocsp_response;
  69 #endif
  70   uschar *dhparam;
  71   /* these are cached from first expand */
  72   uschar *server_cipher_list;
  73   /* only passed down to tls_error: */
  74   host_item *host;
  75 } tls_ext_ctx_cb;
  76
  77 /* should figure out a cleanup of API to handle state preserved per
  78 implementation, for various reasons, which can be void * in the APIs.
  79 For now, we hack around it. */
  80 tls_ext_ctx_cb *static_cbinfo = NULL;
  81
  82 static int
  83 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional);
  84
  85 /* Callbacks */
  86 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
  87 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
  88 #endif
  89 #ifdef EXPERIMENTAL_OCSP
  90 static int tls_stapling_cb(SSL *s, void *arg);
  91 #endif
  92
  93
  94 /*************************************************
  95 *               Handle TLS error                 *
  96 *************************************************/
  97
  98 /* Called from lots of places when errors occur before actually starting to do
  99 the TLS handshake, that is, while the session is still in clear. Always returns
 100 DEFER for a server and FAIL for a client so that most calls can use "return
 101 tls_error(...)" to do this processing and then give an appropriate return. A
 102 single function is used for both server and client, because it is called from
 103 some shared functions.
 104
 105 Argument:
 106   prefix    text to include in the logged error
 107   host      NULL if setting up a server;
 108             the connected host if setting up a client
 109   msg       error message or NULL if we should ask OpenSSL
 110
 111 Returns:    OK/DEFER/FAIL
 112 */
 113
 114 static int
 115 tls_error(uschar *prefix, host_item *host, uschar *msg)
 116 {
 117 if (msg == NULL)
 118   {
 119   ERR_error_string(ERR_get_error(), ssl_errstring);
 120   msg = (uschar *)ssl_errstring;
 121   }
 122
 123 if (host == NULL)
 124   {
 125   uschar *conn_info = smtp_get_connection_info();
 126   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
 127     conn_info += 5;
 128   log_write(0, LOG_MAIN, "TLS error on %s (%s): %s",
 129     conn_info, prefix, msg);
 130   return DEFER;
 131   }
 132 else
 133   {
 134   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s): %s",
 135     host->name, host->address, prefix, msg);
 136   return FAIL;
 137   }
 138 }
 139
 140
 141
 142 /*************************************************
 143 *        Callback to generate RSA key            *
 144 *************************************************/
 145
 146 /*
 147 Arguments:
 148   s          SSL connection
 149   export     not used
 150   keylength  keylength
 151
 152 Returns:     pointer to generated key
 153 */
 154
 155 static RSA *
 156 rsa_callback(SSL *s, int export, int keylength)
 157 {
 158 RSA *rsa_key;
 159 export = export;     /* Shut picky compilers up */
 160 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 161 rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL);
 162 if (rsa_key == NULL)
 163   {
 164   ERR_error_string(ERR_get_error(), ssl_errstring);
 165   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 166     ssl_errstring);
 167   return NULL;
 168   }
 169 return rsa_key;
 170 }
 171
 172
 173
 174
 175 /*************************************************
 176 *        Callback for verification               *
 177 *************************************************/
 178
 179 /* The SSL library does certificate verification if set up to do so. This
 180 callback has the current yes/no state is in "state". If verification succeeded,
 181 we set up the tls_peerdn string. If verification failed, what happens depends
 182 on whether the client is required to present a verifiable certificate or not.
 183
 184 If verification is optional, we change the state to yes, but still log the
 185 verification error. For some reason (it really would help to have proper
 186 documentation of OpenSSL), this callback function then gets called again, this
 187 time with state = 1. In fact, that's useful, because we can set up the peerdn
 188 value, but we must take care not to set the private verified flag on the second
 189 time through.
 190
 191 Note: this function is not called if the client fails to present a certificate
 192 when asked. We get here only if a certificate has been received. Handling of
 193 optional verification for this case is done when requesting SSL to verify, by
 194 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 195
 196 Arguments:
 197   state      current yes/no state as 1/0
 198   x509ctx    certificate information.
 199
 200 Returns:     1 if verified, 0 if not
 201 */
 202
 203 static int
 204 verify_callback(int state, X509_STORE_CTX *x509ctx)
 205 {
 206 static uschar txt[256];
 207
 208 X509_NAME_oneline(X509_get_subject_name(x509ctx->current_cert),
 209   CS txt, sizeof(txt));
 210
 211 if (state == 0)
 212   {
 213   log_write(0, LOG_MAIN, "SSL verify error: depth=%d error=%s cert=%s",
 214     x509ctx->error_depth,
 215     X509_verify_cert_error_string(x509ctx->error),
 216     txt);
 217   tls_certificate_verified = FALSE;
 218   verify_callback_called = TRUE;
 219   if (!verify_optional) return 0;    /* reject */
 220   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 221     "tls_try_verify_hosts)\n");
 222   return 1;                          /* accept */
 223   }
 224
 225 if (x509ctx->error_depth != 0)
 226   {
 227   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d cert=%s\n",
 228      x509ctx->error_depth, txt);
 229   }
 230 else
 231   {
 232   DEBUG(D_tls) debug_printf("SSL%s peer: %s\n",
 233     verify_callback_called? "" : " authenticated", txt);
 234   tls_peerdn = txt;
 235   }
 236
 237 if (!verify_callback_called) tls_certificate_verified = TRUE;
 238 verify_callback_called = TRUE;
 239
 240 return 1;   /* accept */
 241 }
 242
 243
 244
 245 /*************************************************
 246 *           Information callback                 *
 247 *************************************************/
 248
 249 /* The SSL library functions call this from time to time to indicate what they
 250 are doing. We copy the string to the debugging output when TLS debugging has
 251 been requested.
 252
 253 Arguments:
 254   s         the SSL connection
 255   where
 256   ret
 257
 258 Returns:    nothing
 259 */
 260
 261 static void
 262 info_callback(SSL *s, int where, int ret)
 263 {
 264 where = where;
 265 ret = ret;
 266 DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
 267 }
 268
 269
 270
 271 /*************************************************
 272 *                Initialize for DH               *
 273 *************************************************/
 274
 275 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 276
 277 Arguments:
 278   dhparam   DH parameter file or fixed parameter identity string
 279   host      connected host, if client; NULL if server
 280
 281 Returns:    TRUE if OK (nothing to set up, or setup worked)
 282 */
 283
 284 static BOOL
 285 init_dh(SSL_CTX *sctx, uschar *dhparam, host_item *host)
 286 {
 287 BIO *bio;
 288 DH *dh;
 289 uschar *dhexpanded;
 290 const char *pem;
 291
 292 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded))
 293   return FALSE;
 294
 295 if (dhexpanded == NULL || *dhexpanded == '\0')
 296   {
 297   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
 298   }
 299 else if (dhexpanded[0] == '/')
 300   {
 301   bio = BIO_new_file(CS dhexpanded, "r");
 302   if (bio == NULL)
 303     {
 304     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
 305           host, US strerror(errno));
 306     return FALSE;
 307     }
 308   }
 309 else
 310   {
 311   if (Ustrcmp(dhexpanded, "none") == 0)
 312     {
 313     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
 314     return TRUE;
 315     }
 316
 317   pem = std_dh_prime_named(dhexpanded);
 318   if (!pem)
 319     {
 320     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
 321         host, US strerror(errno));
 322     return FALSE;
 323     }
 324   bio = BIO_new_mem_buf(CS pem, -1);
 325   }
 326
 327 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
 328 if (dh == NULL)
 329   {
 330   BIO_free(bio);
 331   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
 332       host, NULL);
 333   return FALSE;
 334   }
 335
 336 /* Even if it is larger, we silently return success rather than cause things
 337  * to fail out, so that a too-large DH will not knock out all TLS; it's a
 338  * debatable choice. */
 339 if ((8*DH_size(dh)) > tls_dh_max_bits)
 340   {
 341   DEBUG(D_tls)
 342     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d",
 343         8*DH_size(dh), tls_dh_max_bits);
 344   }
 345 else
 346   {
 347   SSL_CTX_set_tmp_dh(sctx, dh);
 348   DEBUG(D_tls)
 349     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
 350       dhexpanded ? dhexpanded : US"default", 8*DH_size(dh));
 351   }
 352
 353 DH_free(dh);
 354 BIO_free(bio);
 355
 356 return TRUE;
 357 }
 358
 359
 360
 361
 362 #ifdef EXPERIMENTAL_OCSP
 363 /*************************************************
 364 *       Load OCSP information into state         *
 365 *************************************************/
 366
 367 /* Called to load the OCSP response from the given file into memory, once
 368 caller has determined this is needed.  Checks validity.  Debugs a message
 369 if invalid.
 370
 371 ASSUMES: single response, for single cert.
 372
 373 Arguments:
 374   sctx            the SSL_CTX* to update
 375   cbinfo          various parts of session state
 376   expanded        the filename putatively holding an OCSP response
 377
 378 */
 379
 380 static void
 381 ocsp_load_response(SSL_CTX *sctx,
 382     tls_ext_ctx_cb *cbinfo,
 383     const uschar *expanded)
 384 {
 385 BIO *bio;
 386 OCSP_RESPONSE *resp;
 387 OCSP_BASICRESP *basic_response;
 388 OCSP_SINGLERESP *single_response;
 389 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
 390 X509_STORE *store;
 391 unsigned long verify_flags;
 392 int status, reason, i;
 393
 394 cbinfo->ocsp_file_expanded = string_copy(expanded);
 395 if (cbinfo->ocsp_response)
 396   {
 397   OCSP_RESPONSE_free(cbinfo->ocsp_response);
 398   cbinfo->ocsp_response = NULL;
 399   }
 400
 401 bio = BIO_new_file(CS cbinfo->ocsp_file_expanded, "rb");
 402 if (!bio)
 403   {
 404   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
 405       cbinfo->ocsp_file_expanded);
 406   return;
 407   }
 408
 409 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
 410 BIO_free(bio);
 411 if (!resp)
 412   {
 413   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
 414   return;
 415   }
 416
 417 status = OCSP_response_status(resp);
 418 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL)
 419   {
 420   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
 421       OCSP_response_status_str(status), status);
 422   return;
 423   }
 424
 425 basic_response = OCSP_response_get1_basic(resp);
 426 if (!basic_response)
 427   {
 428   DEBUG(D_tls)
 429     debug_printf("OCSP response parse error: unable to extract basic response.\n");
 430   return;
 431   }
 432
 433 store = SSL_CTX_get_cert_store(sctx);
 434 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
 435
 436 /* May need to expose ability to adjust those flags?
 437 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
 438 OCSP_TRUSTOTHER OCSP_NOINTERN */
 439
 440 i = OCSP_basic_verify(basic_response, NULL, store, verify_flags);
 441 if (i <= 0)
 442   {
 443   DEBUG(D_tls) {
 444     ERR_error_string(ERR_get_error(), ssl_errstring);
 445     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
 446   }
 447   return;
 448   }
 449
 450 /* Here's the simplifying assumption: there's only one response, for the
 451 one certificate we use, and nothing for anything else in a chain.  If this
 452 proves false, we need to extract a cert id from our issued cert
 453 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
 454 right cert in the stack and then calls OCSP_single_get0_status()).
 455
 456 I'm hoping to avoid reworking a bunch more of how we handle state here. */
 457 single_response = OCSP_resp_get0(basic_response, 0);
 458 if (!single_response)
 459   {
 460   DEBUG(D_tls)
 461     debug_printf("Unable to get first response from OCSP basic response.\n");
 462   return;
 463   }
 464
 465 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
 466 /* how does this status differ from the one above? */
 467 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL)
 468   {
 469   DEBUG(D_tls) debug_printf("OCSP response not valid (take 2): %s (%d)\n",
 470       OCSP_response_status_str(status), status);
 471   return;
 472   }
 473
 474 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
 475   {
 476   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
 477   return;
 478     if (environ) for (p = USS environ; *p != NULL; p++)
 479   }
 480
 481 cbinfo->ocsp_response = resp;
 482 }
 483 #endif
 484
 485
 486
 487
 488 /*************************************************
 489 *        Expand key and cert file specs          *
 490 *************************************************/
 491
 492 /* Called once during tls_init and possibly againt during TLS setup, for a
 493 new context, if Server Name Indication was used and tls_sni was seen in
 494 the certificate string.
 495
 496 Arguments:
 497   sctx            the SSL_CTX* to update
 498   cbinfo          various parts of session state
 499
 500 Returns:          OK/DEFER/FAIL
 501 */
 502
 503 static int
 504 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo)
 505 {
 506 uschar *expanded;
 507
 508 if (cbinfo->certificate == NULL)
 509   return OK;
 510
 511 if (Ustrstr(cbinfo->certificate, US"tls_sni"))
 512   reexpand_tls_files_for_sni = TRUE;
 513
 514 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded))
 515   return DEFER;
 516
 517 if (expanded != NULL)
 518   {
 519   DEBUG(D_tls) debug_printf("tls_certificate file %s\n", expanded);
 520   if (!SSL_CTX_use_certificate_chain_file(sctx, CS expanded))
 521     return tls_error(string_sprintf(
 522       "SSL_CTX_use_certificate_chain_file file=%s", expanded),
 523         cbinfo->host, NULL);
 524   }
 525
 526 if (cbinfo->privatekey != NULL &&
 527     !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded))
 528   return DEFER;
 529
 530 /* If expansion was forced to fail, key_expanded will be NULL. If the result
 531 of the expansion is an empty string, ignore it also, and assume the private
 532 key is in the same file as the certificate. */
 533
 534 if (expanded != NULL && *expanded != 0)
 535   {
 536   DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", expanded);
 537   if (!SSL_CTX_use_PrivateKey_file(sctx, CS expanded, SSL_FILETYPE_PEM))
 538     return tls_error(string_sprintf(
 539       "SSL_CTX_use_PrivateKey_file file=%s", expanded), cbinfo->host, NULL);
 540   }
 541
 542 #ifdef EXPERIMENTAL_OCSP
 543 if (cbinfo->ocsp_file != NULL)
 544   {
 545   if (!expand_check(cbinfo->ocsp_file, US"tls_ocsp_file", &expanded))
 546     return DEFER;
 547
 548   if (expanded != NULL && *expanded != 0)
 549     {
 550     DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
 551     if (cbinfo->ocsp_file_expanded &&
 552         (Ustrcmp(expanded, cbinfo->ocsp_file_expanded) == 0))
 553       {
 554       DEBUG(D_tls)
 555         debug_printf("tls_ocsp_file value unchanged, using existing values.\n");
 556       } else {
 557         ocsp_load_response(sctx, cbinfo, expanded);
 558       }
 559     }
 560   }
 561 #endif
 562
 563 return OK;
 564 }
 565
 566
 567
 568
 569 /*************************************************
 570 *            Callback to handle SNI              *
 571 *************************************************/
 572
 573 /* Called when acting as server during the TLS session setup if a Server Name
 574 Indication extension was sent by the client.
 575
 576 API documentation is OpenSSL s_server.c implementation.
 577
 578 Arguments:
 579   s               SSL* of the current session
 580   ad              unknown (part of OpenSSL API) (unused)
 581   arg             Callback of "our" registered data
 582
 583 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
 584 */
 585
 586 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 587 static int
 588 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
 589 {
 590 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
 591 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
 592 int rc;
 593 int old_pool = store_pool;
 594
 595 if (!servername)
 596   return SSL_TLSEXT_ERR_OK;
 597
 598 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
 599     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
 600
 601 /* Make the extension value available for expansion */
 602 store_pool = POOL_PERM;
 603 tls_sni = string_copy(US servername);
 604 store_pool = old_pool;
 605
 606 if (!reexpand_tls_files_for_sni)
 607   return SSL_TLSEXT_ERR_OK;
 608
 609 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
 610 not confident that memcpy wouldn't break some internal reference counting.
 611 Especially since there's a references struct member, which would be off. */
 612
 613 ctx_sni = SSL_CTX_new(SSLv23_server_method());
 614 if (!ctx_sni)
 615   {
 616   ERR_error_string(ERR_get_error(), ssl_errstring);
 617   DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
 618   return SSL_TLSEXT_ERR_NOACK;
 619   }
 620
 621 /* Not sure how many of these are actually needed, since SSL object
 622 already exists.  Might even need this selfsame callback, for reneg? */
 623
 624 SSL_CTX_set_info_callback(ctx_sni, SSL_CTX_get_info_callback(ctx));
 625 SSL_CTX_set_mode(ctx_sni, SSL_CTX_get_mode(ctx));
 626 SSL_CTX_set_options(ctx_sni, SSL_CTX_get_options(ctx));
 627 SSL_CTX_set_timeout(ctx_sni, SSL_CTX_get_timeout(ctx));
 628 SSL_CTX_set_tlsext_servername_callback(ctx_sni, tls_servername_cb);
 629 SSL_CTX_set_tlsext_servername_arg(ctx_sni, cbinfo);
 630 if (cbinfo->server_cipher_list)
 631   SSL_CTX_set_cipher_list(ctx_sni, CS cbinfo->server_cipher_list);
 632 #ifdef EXPERIMENTAL_OCSP
 633 if (cbinfo->ocsp_file)
 634   {
 635   SSL_CTX_set_tlsext_status_cb(ctx_sni, tls_stapling_cb);
 636   SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
 637   }
 638 #endif
 639
 640 rc = setup_certs(ctx_sni, tls_verify_certificates, tls_crl, NULL, FALSE);
 641 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
 642
 643 /* do this after setup_certs, because this can require the certs for verifying
 644 OCSP information. */
 645 rc = tls_expand_session_files(ctx_sni, cbinfo);
 646 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
 647
 648 rc = init_dh(ctx_sni, cbinfo->dhparam, NULL);
 649 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
 650
 651 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
 652 SSL_set_SSL_CTX(s, ctx_sni);
 653
 654 return SSL_TLSEXT_ERR_OK;
 655 }
 656 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
 657
 658
 659
 660
 661 #ifdef EXPERIMENTAL_OCSP
 662 /*************************************************
 663 *        Callback to handle OCSP Stapling        *
 664 *************************************************/
 665
 666 /* Called when acting as server during the TLS session setup if the client
 667 requests OCSP information with a Certificate Status Request.
 668
 669 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
 670 project.
 671
 672 */
 673
 674 static int
 675 tls_stapling_cb(SSL *s, void *arg)
 676 {
 677 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
 678 uschar *response_der;
 679 int response_der_len;
 680
 681 DEBUG(D_tls) debug_printf("Received TLS status request (OCSP stapling); %s response.\n",
 682     cbinfo->ocsp_response ? "have" : "lack");
 683 if (!cbinfo->ocsp_response)
 684   return SSL_TLSEXT_ERR_NOACK;
 685
 686 response_der = NULL;
 687 response_der_len = i2d_OCSP_RESPONSE(cbinfo->ocsp_response, &response_der);
 688 if (response_der_len <= 0)
 689   return SSL_TLSEXT_ERR_NOACK;
 690
 691 SSL_set_tlsext_status_ocsp_resp(ssl, response_der, response_der_len);
 692 return SSL_TLSEXT_ERR_OK;
 693 }
 694
 695 #endif /* EXPERIMENTAL_OCSP */
 696
 697
 698
 699
 700 /*************************************************
 701 *            Initialize for TLS                  *
 702 *************************************************/
 703
 704 /* Called from both server and client code, to do preliminary initialization of
 705 the library.
 706
 707 Arguments:
 708   host            connected host, if client; NULL if server
 709   dhparam         DH parameter file
 710   certificate     certificate file
 711   privatekey      private key
 712   addr            address if client; NULL if server (for some randomness)
 713
 714 Returns:          OK/DEFER/FAIL
 715 */
 716
 717 static int
 718 tls_init(host_item *host, uschar *dhparam, uschar *certificate,
 719   uschar *privatekey,
 720 #ifdef EXPERIMENTAL_OCSP
 721   uschar *ocsp_file,
 722 #endif
 723   address_item *addr)
 724 {
 725 long init_options;
 726 int rc;
 727 BOOL okay;
 728 tls_ext_ctx_cb *cbinfo;
 729
 730 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
 731 cbinfo->certificate = certificate;
 732 cbinfo->privatekey = privatekey;
 733 #ifdef EXPERIMENTAL_OCSP
 734 cbinfo->ocsp_file = ocsp_file;
 735 #endif
 736 cbinfo->dhparam = dhparam;
 737 cbinfo->host = host;
 738
 739 SSL_load_error_strings();          /* basic set up */
 740 OpenSSL_add_ssl_algorithms();
 741
 742 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
 743 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
 744 list of available digests. */
 745 EVP_add_digest(EVP_sha256());
 746 #endif
 747
 748 /* Create a context.
 749 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
 750 negotiation in the different methods; as far as I can tell, the only
 751 *_{server,client}_method which allows negotiation is SSLv23, which exists even
 752 when OpenSSL is built without SSLv2 support.
 753 By disabling with openssl_options, we can let admins re-enable with the
 754 existing knob. */
 755
 756 ctx = SSL_CTX_new((host == NULL)?
 757   SSLv23_server_method() : SSLv23_client_method());
 758
 759 if (ctx == NULL) return tls_error(US"SSL_CTX_new", host, NULL);
 760
 761 /* It turns out that we need to seed the random number generator this early in
 762 order to get the full complement of ciphers to work. It took me roughly a day
 763 of work to discover this by experiment.
 764
 765 On systems that have /dev/urandom, SSL may automatically seed itself from
 766 there. Otherwise, we have to make something up as best we can. Double check
 767 afterwards. */
 768
 769 if (!RAND_status())
 770   {
 771   randstuff r;
 772   gettimeofday(&r.tv, NULL);
 773   r.p = getpid();
 774
 775   RAND_seed((uschar *)(&r), sizeof(r));
 776   RAND_seed((uschar *)big_buffer, big_buffer_size);
 777   if (addr != NULL) RAND_seed((uschar *)addr, sizeof(addr));
 778
 779   if (!RAND_status())
 780     return tls_error(US"RAND_status", host,
 781       US"unable to seed random number generator");
 782   }
 783
 784 /* Set up the information callback, which outputs if debugging is at a suitable
 785 level. */
 786
 787 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
 788
 789 /* Automatically re-try reads/writes after renegotiation. */
 790 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
 791
 792 /* Apply administrator-supplied work-arounds.
 793 Historically we applied just one requested option,
 794 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
 795 moved to an administrator-controlled list of options to specify and
 796 grandfathered in the first one as the default value for "openssl_options".
 797
 798 No OpenSSL version number checks: the options we accept depend upon the
 799 availability of the option value macros from OpenSSL.  */
 800
 801 okay = tls_openssl_options_parse(openssl_options, &init_options);
 802 if (!okay)
 803   return tls_error(US"openssl_options parsing failed", host, NULL);
 804
 805 if (init_options)
 806   {
 807   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
 808   if (!(SSL_CTX_set_options(ctx, init_options)))
 809     return tls_error(string_sprintf(
 810           "SSL_CTX_set_option(%#lx)", init_options), host, NULL);
 811   }
 812 else
 813   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
 814
 815 /* Initialize with DH parameters if supplied */
 816
 817 if (!init_dh(ctx, dhparam, host)) return DEFER;
 818
 819 /* Set up certificate and key (and perhaps OCSP info) */
 820
 821 rc = tls_expand_session_files(ctx, cbinfo);
 822 if (rc != OK) return rc;
 823
 824 /* If we need to handle SNI, do so */
 825 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 826 if (host == NULL)
 827   {
 828 #ifdef EXPERIMENTAL_OCSP
 829   /* We check ocsp_file, not ocsp_response, because we care about if
 830   the option exists, not what the current expansion might be, as SNI might
 831   change the certificate and OCSP file in use between now and the time the
 832   callback is invoked. */
 833   if (cbinfo->ocsp_file)
 834     {
 835     SSL_CTX_set_tlsext_status_cb(ctx, tls_stapling_cb);
 836     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
 837     }
 838 #endif
 839   /* We always do this, so that $tls_sni is available even if not used in
 840   tls_certificate */
 841   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
 842   SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
 843   }
 844 #endif
 845
 846 /* Set up the RSA callback */
 847
 848 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
 849
 850 /* Finally, set the timeout, and we are done */
 851
 852 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
 853 DEBUG(D_tls) debug_printf("Initialized TLS\n");
 854
 855 static_cbinfo = cbinfo;
 856
 857 return OK;
 858 }
 859
 860
 861
 862
 863 /*************************************************
 864 *           Get name of cipher in use            *
 865 *************************************************/
 866
 867 /* The answer is left in a static buffer, and tls_cipher is set to point
 868 to it.
 869
 870 Argument:   pointer to an SSL structure for the connection
 871 Returns:    nothing
 872 */
 873
 874 static void
 875 construct_cipher_name(SSL *ssl)
 876 {
 877 static uschar cipherbuf[256];
 878 /* With OpenSSL 1.0.0a, this needs to be const but the documentation doesn't
 879 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
 880 the accessor functions use const in the prototype. */
 881 const SSL_CIPHER *c;
 882 uschar *ver;
 883
 884 switch (ssl->session->ssl_version)
 885   {
 886   case SSL2_VERSION:
 887   ver = US"SSLv2";
 888   break;
 889
 890   case SSL3_VERSION:
 891   ver = US"SSLv3";
 892   break;
 893
 894   case TLS1_VERSION:
 895   ver = US"TLSv1";
 896   break;
 897
 898 #ifdef TLS1_1_VERSION
 899   case TLS1_1_VERSION:
 900   ver = US"TLSv1.1";
 901   break;
 902 #endif
 903
 904 #ifdef TLS1_2_VERSION
 905   case TLS1_2_VERSION:
 906   ver = US"TLSv1.2";
 907   break;
 908 #endif
 909
 910   default:
 911   ver = US"UNKNOWN";
 912   }
 913
 914 c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
 915 SSL_CIPHER_get_bits(c, &tls_bits);
 916
 917 string_format(cipherbuf, sizeof(cipherbuf), "%s:%s:%u", ver,
 918   SSL_CIPHER_get_name(c), tls_bits);
 919 tls_cipher = cipherbuf;
 920
 921 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
 922 }
 923
 924
 925
 926
 927
 928 /*************************************************
 929 *        Set up for verifying certificates       *
 930 *************************************************/
 931
 932 /* Called by both client and server startup
 933
 934 Arguments:
 935   sctx          SSL_CTX* to initialise
 936   certs         certs file or NULL
 937   crl           CRL file or NULL
 938   host          NULL in a server; the remote host in a client
 939   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
 940                 otherwise passed as FALSE
 941
 942 Returns:        OK/DEFER/FAIL
 943 */
 944
 945 static int
 946 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional)
 947 {
 948 uschar *expcerts, *expcrl;
 949
 950 if (!expand_check(certs, US"tls_verify_certificates", &expcerts))
 951   return DEFER;
 952
 953 if (expcerts != NULL)
 954   {
 955   struct stat statbuf;
 956   if (!SSL_CTX_set_default_verify_paths(sctx))
 957     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL);
 958
 959   if (Ustat(expcerts, &statbuf) < 0)
 960     {
 961     log_write(0, LOG_MAIN|LOG_PANIC,
 962       "failed to stat %s for certificates", expcerts);
 963     return DEFER;
 964     }
 965   else
 966     {
 967     uschar *file, *dir;
 968     if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
 969       { file = NULL; dir = expcerts; }
 970     else
 971       { file = expcerts; dir = NULL; }
 972
 973     /* If a certificate file is empty, the next function fails with an
 974     unhelpful error message. If we skip it, we get the correct behaviour (no
 975     certificates are recognized, but the error message is still misleading (it
 976     says no certificate was supplied.) But this is better. */
 977
 978     if ((file == NULL || statbuf.st_size > 0) &&
 979           !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
 980       return tls_error(US"SSL_CTX_load_verify_locations", host, NULL);
 981
 982     if (file != NULL)
 983       {
 984       SSL_CTX_set_client_CA_list(sctx, SSL_load_client_CA_file(CS file));
 985       }
 986     }
 987
 988   /* Handle a certificate revocation list. */
 989
 990   #if OPENSSL_VERSION_NUMBER > 0x00907000L
 991
 992   /* This bit of code is now the version supplied by Lars Mainka. (I have
 993    * merely reformatted it into the Exim code style.)
 994
 995    * "From here I changed the code to add support for multiple crl's
 996    * in pem format in one file or to support hashed directory entries in
 997    * pem format instead of a file. This method now uses the library function
 998    * X509_STORE_load_locations to add the CRL location to the SSL context.
 999    * OpenSSL will then handle the verify against CA certs and CRLs by
1000    * itself in the verify callback." */
1001
1002   if (!expand_check(crl, US"tls_crl", &expcrl)) return DEFER;
1003   if (expcrl != NULL && *expcrl != 0)
1004     {
1005     struct stat statbufcrl;
1006     if (Ustat(expcrl, &statbufcrl) < 0)
1007       {
1008       log_write(0, LOG_MAIN|LOG_PANIC,
1009         "failed to stat %s for certificates revocation lists", expcrl);
1010       return DEFER;
1011       }
1012     else
1013       {
1014       /* is it a file or directory? */
1015       uschar *file, *dir;
1016       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1017       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1018         {
1019         file = NULL;
1020         dir = expcrl;
1021         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1022         }
1023       else
1024         {
1025         file = expcrl;
1026         dir = NULL;
1027         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1028         }
1029       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1030         return tls_error(US"X509_STORE_load_locations", host, NULL);
1031
1032       /* setting the flags to check against the complete crl chain */
1033
1034       X509_STORE_set_flags(cvstore,
1035         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1036       }
1037     }
1038
1039   #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1040
1041   /* If verification is optional, don't fail if no certificate */
1042
1043   SSL_CTX_set_verify(sctx,
1044     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1045     verify_callback);
1046   }
1047
1048 return OK;
1049 }
1050
1051
1052
1053 /*************************************************
1054 *       Start a TLS session in a server          *
1055 *************************************************/
1056
1057 /* This is called when Exim is running as a server, after having received
1058 the STARTTLS command. It must respond to that command, and then negotiate
1059 a TLS session.
1060
1061 Arguments:
1062   require_ciphers   allowed ciphers
1063
1064 Returns:            OK on success
1065                     DEFER for errors before the start of the negotiation
1066                     FAIL for errors during the negotation; the server can't
1067                       continue running.
1068 */
1069
1070 int
1071 tls_server_start(const uschar *require_ciphers)
1072 {
1073 int rc;
1074 uschar *expciphers;
1075 tls_ext_ctx_cb *cbinfo;
1076
1077 /* Check for previous activation */
1078
1079 if (tls_active >= 0)
1080   {
1081   tls_error(US"STARTTLS received after TLS started", NULL, US"");
1082   smtp_printf("554 Already in TLS\r\n");
1083   return FAIL;
1084   }
1085
1086 /* Initialize the SSL library. If it fails, it will already have logged
1087 the error. */
1088
1089 rc = tls_init(NULL, tls_dhparam, tls_certificate, tls_privatekey,
1090 #ifdef EXPERIMENTAL_OCSP
1091     tls_ocsp_file,
1092 #endif
1093     NULL);
1094 if (rc != OK) return rc;
1095 cbinfo = static_cbinfo;
1096
1097 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
1098   return FAIL;
1099
1100 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1101 were historically separated by underscores. So that I can use either form in my
1102 tests, and also for general convenience, we turn underscores into hyphens here.
1103 */
1104
1105 if (expciphers != NULL)
1106   {
1107   uschar *s = expciphers;
1108   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1109   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1110   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
1111     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL);
1112   cbinfo->server_cipher_list = expciphers;
1113   }
1114
1115 /* If this is a host for which certificate verification is mandatory or
1116 optional, set up appropriately. */
1117
1118 tls_certificate_verified = FALSE;
1119 verify_callback_called = FALSE;
1120
1121 if (verify_check_host(&tls_verify_hosts) == OK)
1122   {
1123   rc = setup_certs(ctx, tls_verify_certificates, tls_crl, NULL, FALSE);
1124   if (rc != OK) return rc;
1125   verify_optional = FALSE;
1126   }
1127 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1128   {
1129   rc = setup_certs(ctx, tls_verify_certificates, tls_crl, NULL, TRUE);
1130   if (rc != OK) return rc;
1131   verify_optional = TRUE;
1132   }
1133
1134 /* Prepare for new connection */
1135
1136 if ((ssl = SSL_new(ctx)) == NULL) return tls_error(US"SSL_new", NULL, NULL);
1137
1138 /* Warning: we used to SSL_clear(ssl) here, it was removed.
1139  *
1140  * With the SSL_clear(), we get strange interoperability bugs with
1141  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
1142  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
1143  *
1144  * The SSL_clear() call is to let an existing SSL* be reused, typically after
1145  * session shutdown.  In this case, we have a brand new object and there's no
1146  * obvious reason to immediately clear it.  I'm guessing that this was
1147  * originally added because of incomplete initialisation which the clear fixed,
1148  * in some historic release.
1149  */
1150
1151 /* Set context and tell client to go ahead, except in the case of TLS startup
1152 on connection, where outputting anything now upsets the clients and tends to
1153 make them disconnect. We need to have an explicit fflush() here, to force out
1154 the response. Other smtp_printf() calls do not need it, because in non-TLS
1155 mode, the fflush() happens when smtp_getc() is called. */
1156
1157 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
1158 if (!tls_on_connect)
1159   {
1160   smtp_printf("220 TLS go ahead\r\n");
1161   fflush(smtp_out);
1162   }
1163
1164 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1165 that the OpenSSL library doesn't. */
1166
1167 SSL_set_wfd(ssl, fileno(smtp_out));
1168 SSL_set_rfd(ssl, fileno(smtp_in));
1169 SSL_set_accept_state(ssl);
1170
1171 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
1172
1173 sigalrm_seen = FALSE;
1174 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1175 rc = SSL_accept(ssl);
1176 alarm(0);
1177
1178 if (rc <= 0)
1179   {
1180   tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL);
1181   if (ERR_get_error() == 0)
1182     log_write(0, LOG_MAIN,
1183         "TLS client disconnected cleanly (rejected our certificate?)");
1184   return FAIL;
1185   }
1186
1187 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
1188
1189 /* TLS has been set up. Adjust the input functions to read via TLS,
1190 and initialize things. */
1191
1192 construct_cipher_name(ssl);
1193
1194 DEBUG(D_tls)
1195   {
1196   uschar buf[2048];
1197   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)) != NULL)
1198     debug_printf("Shared ciphers: %s\n", buf);
1199   }
1200
1201
1202 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1203 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
1204 ssl_xfer_eof = ssl_xfer_error = 0;
1205
1206 receive_getc = tls_getc;
1207 receive_ungetc = tls_ungetc;
1208 receive_feof = tls_feof;
1209 receive_ferror = tls_ferror;
1210 receive_smtp_buffered = tls_smtp_buffered;
1211
1212 tls_active = fileno(smtp_out);
1213 return OK;
1214 }
1215
1216
1217
1218
1219
1220 /*************************************************
1221 *    Start a TLS session in a client             *
1222 *************************************************/
1223
1224 /* Called from the smtp transport after STARTTLS has been accepted.
1225
1226 Argument:
1227   fd               the fd of the connection
1228   host             connected host (for messages)
1229   addr             the first address
1230   dhparam          DH parameter file
1231   certificate      certificate file
1232   privatekey       private key file
1233   sni              TLS SNI to send to remote host
1234   verify_certs     file for certificate verify
1235   crl              file containing CRL
1236   require_ciphers  list of allowed ciphers
1237   timeout          startup timeout
1238
1239 Returns:           OK on success
1240                    FAIL otherwise - note that tls_error() will not give DEFER
1241                      because this is not a server
1242 */
1243
1244 int
1245 tls_client_start(int fd, host_item *host, address_item *addr, uschar *dhparam,
1246   uschar *certificate, uschar *privatekey, uschar *sni,
1247   uschar *verify_certs, uschar *crl,
1248   uschar *require_ciphers, int timeout)
1249 {
1250 static uschar txt[256];
1251 uschar *expciphers;
1252 X509* server_cert;
1253 int rc;
1254
1255 rc = tls_init(host, dhparam, certificate, privatekey,
1256 #ifdef EXPERIMENTAL_OCSP
1257     NULL,
1258 #endif
1259     addr);
1260 if (rc != OK) return rc;
1261
1262 tls_certificate_verified = FALSE;
1263 verify_callback_called = FALSE;
1264
1265 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
1266   return FAIL;
1267
1268 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1269 are separated by underscores. So that I can use either form in my tests, and
1270 also for general convenience, we turn underscores into hyphens here. */
1271
1272 if (expciphers != NULL)
1273   {
1274   uschar *s = expciphers;
1275   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1276   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1277   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
1278     return tls_error(US"SSL_CTX_set_cipher_list", host, NULL);
1279   }
1280
1281 rc = setup_certs(ctx, verify_certs, crl, host, FALSE);
1282 if (rc != OK) return rc;
1283
1284 if ((ssl = SSL_new(ctx)) == NULL) return tls_error(US"SSL_new", host, NULL);
1285 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
1286 SSL_set_fd(ssl, fd);
1287 SSL_set_connect_state(ssl);
1288
1289 if (sni)
1290   {
1291   if (!expand_check(sni, US"tls_sni", &tls_sni))
1292     return FAIL;
1293   if (!Ustrlen(tls_sni))
1294     tls_sni = NULL;
1295   else
1296     {
1297 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1298     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_sni);
1299     SSL_set_tlsext_host_name(ssl, tls_sni);
1300 #else
1301     DEBUG(D_tls)
1302       debug_printf("OpenSSL at build-time lacked SNI support, ignoring \"%s\"\n",
1303           tls_sni);
1304 #endif
1305     }
1306   }
1307
1308 /* There doesn't seem to be a built-in timeout on connection. */
1309
1310 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
1311 sigalrm_seen = FALSE;
1312 alarm(timeout);
1313 rc = SSL_connect(ssl);
1314 alarm(0);
1315
1316 if (rc <= 0)
1317   return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL);
1318
1319 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
1320
1321 /* Beware anonymous ciphers which lead to server_cert being NULL */
1322 server_cert = SSL_get_peer_certificate (ssl);
1323 if (server_cert)
1324   {
1325   tls_peerdn = US X509_NAME_oneline(X509_get_subject_name(server_cert),
1326     CS txt, sizeof(txt));
1327   tls_peerdn = txt;
1328   }
1329 else
1330   tls_peerdn = NULL;
1331
1332 construct_cipher_name(ssl);   /* Sets tls_cipher */
1333
1334 tls_active = fd;
1335 return OK;
1336 }
1337
1338
1339
1340
1341
1342 /*************************************************
1343 *            TLS version of getc                 *
1344 *************************************************/
1345
1346 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1347 it refills the buffer via the SSL reading function.
1348
1349 Arguments:  none
1350 Returns:    the next character or EOF
1351 */
1352
1353 int
1354 tls_getc(void)
1355 {
1356 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
1357   {
1358   int error;
1359   int inbytes;
1360
1361   DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
1362     ssl_xfer_buffer, ssl_xfer_buffer_size);
1363
1364   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1365   inbytes = SSL_read(ssl, CS ssl_xfer_buffer, ssl_xfer_buffer_size);
1366   error = SSL_get_error(ssl, inbytes);
1367   alarm(0);
1368
1369   /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
1370   closed down, not that the socket itself has been closed down. Revert to
1371   non-SSL handling. */
1372
1373   if (error == SSL_ERROR_ZERO_RETURN)
1374     {
1375     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
1376
1377     receive_getc = smtp_getc;
1378     receive_ungetc = smtp_ungetc;
1379     receive_feof = smtp_feof;
1380     receive_ferror = smtp_ferror;
1381     receive_smtp_buffered = smtp_buffered;
1382
1383     SSL_free(ssl);
1384     ssl = NULL;
1385     tls_active = -1;
1386     tls_bits = 0;
1387     tls_cipher = NULL;
1388     tls_peerdn = NULL;
1389     tls_sni = NULL;
1390
1391     return smtp_getc();
1392     }
1393
1394   /* Handle genuine errors */
1395
1396   else if (error == SSL_ERROR_SSL)
1397     {
1398     ERR_error_string(ERR_get_error(), ssl_errstring);
1399     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
1400     ssl_xfer_error = 1;
1401     return EOF;
1402     }
1403
1404   else if (error != SSL_ERROR_NONE)
1405     {
1406     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
1407     ssl_xfer_error = 1;
1408     return EOF;
1409     }
1410
1411 #ifndef DISABLE_DKIM
1412   dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
1413 #endif
1414   ssl_xfer_buffer_hwm = inbytes;
1415   ssl_xfer_buffer_lwm = 0;
1416   }
1417
1418 /* Something in the buffer; return next uschar */
1419
1420 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
1421 }
1422
1423
1424
1425 /*************************************************
1426 *          Read bytes from TLS channel           *
1427 *************************************************/
1428
1429 /*
1430 Arguments:
1431   buff      buffer of data
1432   len       size of buffer
1433
1434 Returns:    the number of bytes read
1435             -1 after a failed read
1436 */
1437
1438 int
1439 tls_read(uschar *buff, size_t len)
1440 {
1441 int inbytes;
1442 int error;
1443
1444 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
1445   buff, (unsigned int)len);
1446
1447 inbytes = SSL_read(ssl, CS buff, len);
1448 error = SSL_get_error(ssl, inbytes);
1449
1450 if (error == SSL_ERROR_ZERO_RETURN)
1451   {
1452   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
1453   return -1;
1454   }
1455 else if (error != SSL_ERROR_NONE)
1456   {
1457   return -1;
1458   }
1459
1460 return inbytes;
1461 }
1462
1463
1464
1465
1466
1467 /*************************************************
1468 *         Write bytes down TLS channel           *
1469 *************************************************/
1470
1471 /*
1472 Arguments:
1473   buff      buffer of data
1474   len       number of bytes
1475
1476 Returns:    the number of bytes after a successful write,
1477             -1 after a failed write
1478 */
1479
1480 int
1481 tls_write(const uschar *buff, size_t len)
1482 {
1483 int outbytes;
1484 int error;
1485 int left = len;
1486
1487 DEBUG(D_tls) debug_printf("tls_do_write(%p, %d)\n", buff, left);
1488 while (left > 0)
1489   {
1490   DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
1491   outbytes = SSL_write(ssl, CS buff, left);
1492   error = SSL_get_error(ssl, outbytes);
1493   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
1494   switch (error)
1495     {
1496     case SSL_ERROR_SSL:
1497     ERR_error_string(ERR_get_error(), ssl_errstring);
1498     log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
1499     return -1;
1500
1501     case SSL_ERROR_NONE:
1502     left -= outbytes;
1503     buff += outbytes;
1504     break;
1505
1506     case SSL_ERROR_ZERO_RETURN:
1507     log_write(0, LOG_MAIN, "SSL channel closed on write");
1508     return -1;
1509
1510     default:
1511     log_write(0, LOG_MAIN, "SSL_write error %d", error);
1512     return -1;
1513     }
1514   }
1515 return len;
1516 }
1517
1518
1519
1520 /*************************************************
1521 *         Close down a TLS session               *
1522 *************************************************/
1523
1524 /* This is also called from within a delivery subprocess forked from the
1525 daemon, to shut down the TLS library, without actually doing a shutdown (which
1526 would tamper with the SSL session in the parent process).
1527
1528 Arguments:   TRUE if SSL_shutdown is to be called
1529 Returns:     nothing
1530 */
1531
1532 void
1533 tls_close(BOOL shutdown)
1534 {
1535 if (tls_active < 0) return;  /* TLS was not active */
1536
1537 if (shutdown)
1538   {
1539   DEBUG(D_tls) debug_printf("tls_close(): shutting down SSL\n");
1540   SSL_shutdown(ssl);
1541   }
1542
1543 SSL_free(ssl);
1544 ssl = NULL;
1545
1546 tls_active = -1;
1547 }
1548
1549
1550
1551
1552 /*************************************************
1553 *  Let tls_require_ciphers be checked at startup *
1554 *************************************************/
1555
1556 /* The tls_require_ciphers option, if set, must be something which the
1557 library can parse.
1558
1559 Returns:     NULL on success, or error message
1560 */
1561
1562 uschar *
1563 tls_validate_require_cipher(void)
1564 {
1565 SSL_CTX *ctx;
1566 uschar *s, *expciphers, *err;
1567
1568 /* this duplicates from tls_init(), we need a better "init just global
1569 state, for no specific purpose" singleton function of our own */
1570
1571 SSL_load_error_strings();
1572 OpenSSL_add_ssl_algorithms();
1573 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
1574 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1575 list of available digests. */
1576 EVP_add_digest(EVP_sha256());
1577 #endif
1578
1579 if (!(tls_require_ciphers && *tls_require_ciphers))
1580   return NULL;
1581
1582 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers))
1583   return US"failed to expand tls_require_ciphers";
1584
1585 if (!(expciphers && *expciphers))
1586   return NULL;
1587
1588 /* normalisation ripped from above */
1589 s = expciphers;
1590 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1591
1592 err = NULL;
1593
1594 ctx = SSL_CTX_new(SSLv23_server_method());
1595 if (!ctx)
1596   {
1597   ERR_error_string(ERR_get_error(), ssl_errstring);
1598   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
1599   }
1600
1601 DEBUG(D_tls)
1602   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
1603
1604 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
1605   {
1606   ERR_error_string(ERR_get_error(), ssl_errstring);
1607   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed", expciphers);
1608   }
1609
1610 SSL_CTX_free(ctx);
1611
1612 return err;
1613 }
1614
1615
1616
1617
1618 /*************************************************
1619 *         Report the library versions.           *
1620 *************************************************/
1621
1622 /* There have historically been some issues with binary compatibility in
1623 OpenSSL libraries; if Exim (like many other applications) is built against
1624 one version of OpenSSL but the run-time linker picks up another version,
1625 it can result in serious failures, including crashing with a SIGSEGV.  So
1626 report the version found by the compiler and the run-time version.
1627
1628 Arguments:   a FILE* to print the results to
1629 Returns:     nothing
1630 */
1631
1632 void
1633 tls_version_report(FILE *f)
1634 {
1635 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
1636            "                          Runtime: %s\n",
1637            OPENSSL_VERSION_TEXT,
1638            SSLeay_version(SSLEAY_VERSION));
1639 }
1640
1641
1642
1643
1644 /*************************************************
1645 *            Random number generation            *
1646 *************************************************/
1647
1648 /* Pseudo-random number generation.  The result is not expected to be
1649 cryptographically strong but not so weak that someone will shoot themselves
1650 in the foot using it as a nonce in input in some email header scheme or
1651 whatever weirdness they'll twist this into.  The result should handle fork()
1652 and avoid repeating sequences.  OpenSSL handles that for us.
1653
1654 Arguments:
1655   max       range maximum
1656 Returns     a random number in range [0, max-1]
1657 */
1658
1659 int
1660 vaguely_random_number(int max)
1661 {
1662 unsigned int r;
1663 int i, needed_len;
1664 uschar *p;
1665 uschar smallbuf[sizeof(r)];
1666
1667 if (max <= 1)
1668   return 0;
1669
1670 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
1671 if (!RAND_status())
1672   {
1673   randstuff r;
1674   gettimeofday(&r.tv, NULL);
1675   r.p = getpid();
1676
1677   RAND_seed((uschar *)(&r), sizeof(r));
1678   }
1679 /* We're after pseudo-random, not random; if we still don't have enough data
1680 in the internal PRNG then our options are limited.  We could sleep and hope
1681 for entropy to come along (prayer technique) but if the system is so depleted
1682 in the first place then something is likely to just keep taking it.  Instead,
1683 we'll just take whatever little bit of pseudo-random we can still manage to
1684 get. */
1685
1686 needed_len = sizeof(r);
1687 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1688 asked for a number less than 10. */
1689 for (r = max, i = 0; r; ++i)
1690   r >>= 1;
1691 i = (i + 7) / 8;
1692 if (i < needed_len)
1693   needed_len = i;
1694
1695 /* We do not care if crypto-strong */
1696 i = RAND_pseudo_bytes(smallbuf, needed_len);
1697 if (i < 0)
1698   {
1699   DEBUG(D_all)
1700     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
1701   return vaguely_random_number_fallback(max);
1702   }
1703
1704 r = 0;
1705 for (p = smallbuf; needed_len; --needed_len, ++p)
1706   {
1707   r *= 256;
1708   r += *p;
1709   }
1710
1711 /* We don't particularly care about weighted results; if someone wants
1712 smooth distribution and cares enough then they should submit a patch then. */
1713 return r % max;
1714 }
1715
1716
1717
1718
1719 /*************************************************
1720 *        OpenSSL option parse                    *
1721 *************************************************/
1722
1723 /* Parse one option for tls_openssl_options_parse below
1724
1725 Arguments:
1726   name    one option name
1727   value   place to store a value for it
1728 Returns   success or failure in parsing
1729 */
1730
1731 struct exim_openssl_option {
1732   uschar *name;
1733   long    value;
1734 };
1735 /* We could use a macro to expand, but we need the ifdef and not all the
1736 options document which version they were introduced in.  Policylet: include
1737 all options unless explicitly for DTLS, let the administrator choose which
1738 to apply.
1739
1740 This list is current as of:
1741   ==>  1.0.1b  <==  */
1742 static struct exim_openssl_option exim_openssl_options[] = {
1743 /* KEEP SORTED ALPHABETICALLY! */
1744 #ifdef SSL_OP_ALL
1745   { US"all", SSL_OP_ALL },
1746 #endif
1747 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
1748   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
1749 #endif
1750 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
1751   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
1752 #endif
1753 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
1754   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
1755 #endif
1756 #ifdef SSL_OP_EPHEMERAL_RSA
1757   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
1758 #endif
1759 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
1760   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
1761 #endif
1762 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
1763   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
1764 #endif
1765 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
1766   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
1767 #endif
1768 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
1769   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
1770 #endif
1771 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
1772   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
1773 #endif
1774 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
1775   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
1776 #endif
1777 #ifdef SSL_OP_NO_COMPRESSION
1778   { US"no_compression", SSL_OP_NO_COMPRESSION },
1779 #endif
1780 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1781   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
1782 #endif
1783 #ifdef SSL_OP_NO_SSLv2
1784   { US"no_sslv2", SSL_OP_NO_SSLv2 },
1785 #endif
1786 #ifdef SSL_OP_NO_SSLv3
1787   { US"no_sslv3", SSL_OP_NO_SSLv3 },
1788 #endif
1789 #ifdef SSL_OP_NO_TICKET
1790   { US"no_ticket", SSL_OP_NO_TICKET },
1791 #endif
1792 #ifdef SSL_OP_NO_TLSv1
1793   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
1794 #endif
1795 #ifdef SSL_OP_NO_TLSv1_1
1796 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
1797   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
1798 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
1799 #else
1800   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
1801 #endif
1802 #endif
1803 #ifdef SSL_OP_NO_TLSv1_2
1804   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
1805 #endif
1806 #ifdef SSL_OP_SINGLE_DH_USE
1807   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
1808 #endif
1809 #ifdef SSL_OP_SINGLE_ECDH_USE
1810   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
1811 #endif
1812 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
1813   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
1814 #endif
1815 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
1816   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
1817 #endif
1818 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
1819   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
1820 #endif
1821 #ifdef SSL_OP_TLS_D5_BUG
1822   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
1823 #endif
1824 #ifdef SSL_OP_TLS_ROLLBACK_BUG
1825   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
1826 #endif
1827 };
1828 static int exim_openssl_options_size =
1829   sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
1830
1831
1832 static BOOL
1833 tls_openssl_one_option_parse(uschar *name, long *value)
1834 {
1835 int first = 0;
1836 int last = exim_openssl_options_size;
1837 while (last > first)
1838   {
1839   int middle = (first + last)/2;
1840   int c = Ustrcmp(name, exim_openssl_options[middle].name);
1841   if (c == 0)
1842     {
1843     *value = exim_openssl_options[middle].value;
1844     return TRUE;
1845     }
1846   else if (c > 0)
1847     first = middle + 1;
1848   else
1849     last = middle;
1850   }
1851 return FALSE;
1852 }
1853
1854
1855
1856
1857 /*************************************************
1858 *        OpenSSL option parsing logic            *
1859 *************************************************/
1860
1861 /* OpenSSL has a number of compatibility options which an administrator might
1862 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
1863 we look like log_selector.
1864
1865 Arguments:
1866   option_spec  the administrator-supplied string of options
1867   results      ptr to long storage for the options bitmap
1868 Returns        success or failure
1869 */
1870
1871 BOOL
1872 tls_openssl_options_parse(uschar *option_spec, long *results)
1873 {
1874 long result, item;
1875 uschar *s, *end;
1876 uschar keep_c;
1877 BOOL adding, item_parsed;
1878
1879 result = 0L;
1880 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
1881  * from default because it increases BEAST susceptibility. */
1882 #ifdef SSL_OP_NO_SSLv2
1883 result |= SSL_OP_NO_SSLv2;
1884 #endif
1885
1886 if (option_spec == NULL)
1887   {
1888   *results = result;
1889   return TRUE;
1890   }
1891
1892 for (s=option_spec; *s != '\0'; /**/)
1893   {
1894   while (isspace(*s)) ++s;
1895   if (*s == '\0')
1896     break;
1897   if (*s != '+' && *s != '-')
1898     {
1899     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
1900         "+ or - expected but found \"%s\"\n", s);
1901     return FALSE;
1902     }
1903   adding = *s++ == '+';
1904   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
1905   keep_c = *end;
1906   *end = '\0';
1907   item_parsed = tls_openssl_one_option_parse(s, &item);
1908   if (!item_parsed)
1909     {
1910     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
1911     return FALSE;
1912     }
1913   DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
1914       adding ? "adding" : "removing", result, item, s);
1915   if (adding)
1916     result |= item;
1917   else
1918     result &= ~item;
1919   *end = keep_c;
1920   s = end;
1921   }
1922
1923 *results = result;
1924 return TRUE;
1925 }
1926
1927 /* End of tls-openssl.c */