src/src/tls-openssl.c

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