src/src/tls-openssl.c

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