src/src/tls-openssl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2019 */
   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 SUPPORT_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 /* X509_check_host provides sane certificate hostname checking, but was added
  58 to OpenSSL late, after other projects forked off the code-base.  So in
  59 addition to guarding against the base version number, beware that LibreSSL
  60 does not (at this time) support this function.
  61
  62 If LibreSSL gains a different API, perhaps via libtls, then we'll probably
  63 opt to disentangle and ask a LibreSSL user to provide glue for a third
  64 crypto provider for libtls instead of continuing to tie the OpenSSL glue
  65 into even twistier knots.  If LibreSSL gains the same API, we can just
  66 change this guard and punt the issue for a while longer. */
  67
  68 #ifndef LIBRESSL_VERSION_NUMBER
  69 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
  70 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  71 #  define EXIM_HAVE_OPENSSL_DH_BITS
  72 #  define EXIM_HAVE_OPENSSL_TLS_METHOD
  73 #  define EXIM_HAVE_OPENSSL_KEYLOG
  74 #  define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
  75 #  define EXIM_HAVE_SESSION_TICKET
  76 #  define EXIM_HAVE_OPESSL_TRACE
  77 # else
  78 #  define EXIM_NEED_OPENSSL_INIT
  79 # endif
  80 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
  81     && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
  82 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  83 # endif
  84 #endif
  85
  86 #if !defined(LIBRESSL_VERSION_NUMBER) \
  87     || LIBRESSL_VERSION_NUMBER >= 0x20010000L
  88 # if !defined(OPENSSL_NO_ECDH)
  89 #  if OPENSSL_VERSION_NUMBER >= 0x0090800fL
  90 #   define EXIM_HAVE_ECDH
  91 #  endif
  92 #  if OPENSSL_VERSION_NUMBER >= 0x10002000L
  93 #   define EXIM_HAVE_OPENSSL_EC_NIST2NID
  94 #  endif
  95 # endif
  96 #endif
  97
  98 #ifndef LIBRESSL_VERSION_NUMBER
  99 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
 100 #  define OPENSSL_HAVE_KEYLOG_CB
 101 #  define OPENSSL_HAVE_NUM_TICKETS
 102 #  define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 103 # endif
 104 #endif
 105
 106 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
 107 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
 108 # define DISABLE_OCSP
 109 #endif
 110
 111 #ifdef EXPERIMENTAL_TLS_RESUME
 112 # if OPENSSL_VERSION_NUMBER < 0x0101010L
 113 #  error OpenSSL version too old for session-resumption
 114 # endif
 115 #endif
 116
 117 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
 118 # include <openssl/x509v3.h>
 119 #endif
 120
 121 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 122 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
 123 #  define SSL_CIPHER_get_id(c) (c->id)
 124 # endif
 125 # ifndef MACRO_PREDEF
 126 #  include "tls-cipher-stdname.c"
 127 # endif
 128 #endif
 129
 130 /*************************************************
 131 *        OpenSSL option parse                    *
 132 *************************************************/
 133
 134 typedef struct exim_openssl_option {
 135   uschar *name;
 136   long    value;
 137 } exim_openssl_option;
 138 /* We could use a macro to expand, but we need the ifdef and not all the
 139 options document which version they were introduced in.  Policylet: include
 140 all options unless explicitly for DTLS, let the administrator choose which
 141 to apply.
 142
 143 This list is current as of:
 144   ==>  1.0.1b  <==
 145 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
 146 Plus SSL_OP_NO_TLSv1_3 for 1.1.2-dev
 147 */
 148 static exim_openssl_option exim_openssl_options[] = {
 149 /* KEEP SORTED ALPHABETICALLY! */
 150 #ifdef SSL_OP_ALL
 151   { US"all", SSL_OP_ALL },
 152 #endif
 153 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
 154   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
 155 #endif
 156 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
 157   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
 158 #endif
 159 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
 160   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
 161 #endif
 162 #ifdef SSL_OP_EPHEMERAL_RSA
 163   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
 164 #endif
 165 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
 166   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
 167 #endif
 168 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
 169   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
 170 #endif
 171 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
 172   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
 173 #endif
 174 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
 175   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
 176 #endif
 177 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
 178   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
 179 #endif
 180 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
 181   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
 182 #endif
 183 #ifdef SSL_OP_NO_COMPRESSION
 184   { US"no_compression", SSL_OP_NO_COMPRESSION },
 185 #endif
 186 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
 187   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
 188 #endif
 189 #ifdef SSL_OP_NO_SSLv2
 190   { US"no_sslv2", SSL_OP_NO_SSLv2 },
 191 #endif
 192 #ifdef SSL_OP_NO_SSLv3
 193   { US"no_sslv3", SSL_OP_NO_SSLv3 },
 194 #endif
 195 #ifdef SSL_OP_NO_TICKET
 196   { US"no_ticket", SSL_OP_NO_TICKET },
 197 #endif
 198 #ifdef SSL_OP_NO_TLSv1
 199   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
 200 #endif
 201 #ifdef SSL_OP_NO_TLSv1_1
 202 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
 203   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
 204 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
 205 #else
 206   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
 207 #endif
 208 #endif
 209 #ifdef SSL_OP_NO_TLSv1_2
 210   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
 211 #endif
 212 #ifdef SSL_OP_NO_TLSv1_3
 213   { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
 214 #endif
 215 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
 216   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
 217 #endif
 218 #ifdef SSL_OP_SINGLE_DH_USE
 219   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
 220 #endif
 221 #ifdef SSL_OP_SINGLE_ECDH_USE
 222   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
 223 #endif
 224 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
 225   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
 226 #endif
 227 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
 228   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
 229 #endif
 230 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
 231   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
 232 #endif
 233 #ifdef SSL_OP_TLS_D5_BUG
 234   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
 235 #endif
 236 #ifdef SSL_OP_TLS_ROLLBACK_BUG
 237   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
 238 #endif
 239 };
 240
 241 #ifndef MACRO_PREDEF
 242 static int exim_openssl_options_size = nelem(exim_openssl_options);
 243 #endif
 244
 245 #ifdef MACRO_PREDEF
 246 void
 247 options_tls(void)
 248 {
 249 uschar buf[64];
 250
 251 for (struct exim_openssl_option * o = exim_openssl_options;
 252      o < exim_openssl_options + nelem(exim_openssl_options); o++)
 253   {
 254   /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
 255   being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
 256
 257   spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
 258   builtin_macro_create(buf);
 259   }
 260
 261 # ifdef EXPERIMENTAL_TLS_RESUME
 262 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
 263 # endif
 264 }
 265 #else
 266
 267 /******************************************************************************/
 268
 269 /* Structure for collecting random data for seeding. */
 270
 271 typedef struct randstuff {
 272   struct timeval tv;
 273   pid_t          p;
 274 } randstuff;
 275
 276 /* Local static variables */
 277
 278 static BOOL client_verify_callback_called = FALSE;
 279 static BOOL server_verify_callback_called = FALSE;
 280 static const uschar *sid_ctx = US"exim";
 281
 282 /* We have three different contexts to care about.
 283
 284 Simple case: client, `client_ctx`
 285  As a client, we can be doing a callout or cut-through delivery while receiving
 286  a message.  So we have a client context, which should have options initialised
 287  from the SMTP Transport.  We may also concurrently want to make TLS connections
 288  to utility daemons, so client-contexts are allocated and passed around in call
 289  args rather than using a gobal.
 290
 291 Server:
 292  There are two cases: with and without ServerNameIndication from the client.
 293  Given TLS SNI, we can be using different keys, certs and various other
 294  configuration settings, because they're re-expanded with $tls_sni set.  This
 295  allows vhosting with TLS.  This SNI is sent in the handshake.
 296  A client might not send SNI, so we need a fallback, and an initial setup too.
 297  So as a server, we start out using `server_ctx`.
 298  If SNI is sent by the client, then we as server, mid-negotiation, try to clone
 299  `server_sni` from `server_ctx` and then initialise settings by re-expanding
 300  configuration.
 301 */
 302
 303 typedef struct {
 304   SSL_CTX *     ctx;
 305   SSL *         ssl;
 306   gstring *     corked;
 307 } exim_openssl_client_tls_ctx;
 308
 309 static SSL_CTX *server_ctx = NULL;
 310 static SSL     *server_ssl = NULL;
 311
 312 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 313 static SSL_CTX *server_sni = NULL;
 314 #endif
 315
 316 static char ssl_errstring[256];
 317
 318 static int  ssl_session_timeout = 3600;
 319 static BOOL client_verify_optional = FALSE;
 320 static BOOL server_verify_optional = FALSE;
 321
 322 static BOOL reexpand_tls_files_for_sni = FALSE;
 323
 324
 325 typedef struct tls_ext_ctx_cb {
 326   tls_support * tlsp;
 327   uschar *certificate;
 328   uschar *privatekey;
 329   BOOL is_server;
 330 #ifndef DISABLE_OCSP
 331   STACK_OF(X509) *verify_stack;         /* chain for verifying the proof */
 332   union {
 333     struct {
 334       uschar        *file;
 335       uschar        *file_expanded;
 336       OCSP_RESPONSE *response;
 337     } server;
 338     struct {
 339       X509_STORE    *verify_store;      /* non-null if status requested */
 340       BOOL          verify_required;
 341     } client;
 342   } u_ocsp;
 343 #endif
 344   uschar *dhparam;
 345   /* these are cached from first expand */
 346   uschar *server_cipher_list;
 347   /* only passed down to tls_error: */
 348   host_item *host;
 349   const uschar * verify_cert_hostnames;
 350 #ifndef DISABLE_EVENT
 351   uschar * event_action;
 352 #endif
 353 } tls_ext_ctx_cb;
 354
 355 /* should figure out a cleanup of API to handle state preserved per
 356 implementation, for various reasons, which can be void * in the APIs.
 357 For now, we hack around it. */
 358 tls_ext_ctx_cb *client_static_cbinfo = NULL;    /*XXX should not use static; multiple concurrent clients! */
 359 tls_ext_ctx_cb *server_static_cbinfo = NULL;
 360
 361 static int
 362 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
 363     int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
 364
 365 /* Callbacks */
 366 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 367 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
 368 #endif
 369 #ifndef DISABLE_OCSP
 370 static int tls_server_stapling_cb(SSL *s, void *arg);
 371 #endif
 372
 373
 374
 375 /* Daemon-called key create/rotate */
 376 #ifdef EXPERIMENTAL_TLS_RESUME
 377 static void tk_init(void);
 378 static int tls_exdata_idx = -1;
 379 #endif
 380
 381 void
 382 tls_daemon_init(void)
 383 {
 384 #ifdef EXPERIMENTAL_TLS_RESUME
 385 tk_init();
 386 #endif
 387 return;
 388 }
 389
 390
 391 /*************************************************
 392 *               Handle TLS error                 *
 393 *************************************************/
 394
 395 /* Called from lots of places when errors occur before actually starting to do
 396 the TLS handshake, that is, while the session is still in clear. Always returns
 397 DEFER for a server and FAIL for a client so that most calls can use "return
 398 tls_error(...)" to do this processing and then give an appropriate return. A
 399 single function is used for both server and client, because it is called from
 400 some shared functions.
 401
 402 Argument:
 403   prefix    text to include in the logged error
 404   host      NULL if setting up a server;
 405             the connected host if setting up a client
 406   msg       error message or NULL if we should ask OpenSSL
 407   errstr    pointer to output error message
 408
 409 Returns:    OK/DEFER/FAIL
 410 */
 411
 412 static int
 413 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
 414 {
 415 if (!msg)
 416   {
 417   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 418   msg = US ssl_errstring;
 419   }
 420
 421 msg = string_sprintf("(%s): %s", prefix, msg);
 422 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
 423 if (errstr) *errstr = msg;
 424 return host ? FAIL : DEFER;
 425 }
 426
 427
 428
 429 /*************************************************
 430 *        Callback to generate RSA key            *
 431 *************************************************/
 432
 433 /*
 434 Arguments:
 435   s          SSL connection (not used)
 436   export     not used
 437   keylength  keylength
 438
 439 Returns:     pointer to generated key
 440 */
 441
 442 static RSA *
 443 rsa_callback(SSL *s, int export, int keylength)
 444 {
 445 RSA *rsa_key;
 446 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 447 BIGNUM *bn = BN_new();
 448 #endif
 449
 450 export = export;     /* Shut picky compilers up */
 451 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 452
 453 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 454 if (  !BN_set_word(bn, (unsigned long)RSA_F4)
 455    || !(rsa_key = RSA_new())
 456    || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
 457    )
 458 #else
 459 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
 460 #endif
 461
 462   {
 463   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 464   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 465     ssl_errstring);
 466   return NULL;
 467   }
 468 return rsa_key;
 469 }
 470
 471
 472
 473 /* Extreme debug
 474 #ifndef DISABLE_OCSP
 475 void
 476 x509_store_dump_cert_s_names(X509_STORE * store)
 477 {
 478 STACK_OF(X509_OBJECT) * roots= store->objs;
 479 static uschar name[256];
 480
 481 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
 482   {
 483   X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
 484   if(tmp_obj->type == X509_LU_X509)
 485     {
 486     X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
 487     if (X509_NAME_oneline(sn, CS name, sizeof(name)))
 488       {
 489       name[sizeof(name)-1] = '\0';
 490       debug_printf(" %s\n", name);
 491       }
 492     }
 493   }
 494 }
 495 #endif
 496 */
 497
 498
 499 #ifndef DISABLE_EVENT
 500 static int
 501 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
 502   BOOL *calledp, const BOOL *optionalp, const uschar * what)
 503 {
 504 uschar * ev;
 505 uschar * yield;
 506 X509 * old_cert;
 507
 508 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
 509 if (ev)
 510   {
 511   DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
 512   old_cert = tlsp->peercert;
 513   tlsp->peercert = X509_dup(cert);
 514   /* NB we do not bother setting peerdn */
 515   if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
 516     {
 517     log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
 518                 "depth=%d cert=%s: %s",
 519               tlsp == &tls_out ? deliver_host_address : sender_host_address,
 520               what, depth, dn, yield);
 521     *calledp = TRUE;
 522     if (!*optionalp)
 523       {
 524       if (old_cert) tlsp->peercert = old_cert;  /* restore 1st failing cert */
 525       return 1;                     /* reject (leaving peercert set) */
 526       }
 527     DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
 528       "(host in tls_try_verify_hosts)\n");
 529     }
 530   X509_free(tlsp->peercert);
 531   tlsp->peercert = old_cert;
 532   }
 533 return 0;
 534 }
 535 #endif
 536
 537 /*************************************************
 538 *        Callback for verification               *
 539 *************************************************/
 540
 541 /* The SSL library does certificate verification if set up to do so. This
 542 callback has the current yes/no state is in "state". If verification succeeded,
 543 we set the certificate-verified flag. If verification failed, what happens
 544 depends on whether the client is required to present a verifiable certificate
 545 or not.
 546
 547 If verification is optional, we change the state to yes, but still log the
 548 verification error. For some reason (it really would help to have proper
 549 documentation of OpenSSL), this callback function then gets called again, this
 550 time with state = 1.  We must take care not to set the private verified flag on
 551 the second time through.
 552
 553 Note: this function is not called if the client fails to present a certificate
 554 when asked. We get here only if a certificate has been received. Handling of
 555 optional verification for this case is done when requesting SSL to verify, by
 556 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 557
 558 May be called multiple times for different issues with a certificate, even
 559 for a given "depth" in the certificate chain.
 560
 561 Arguments:
 562   preverify_ok current yes/no state as 1/0
 563   x509ctx      certificate information.
 564   tlsp         per-direction (client vs. server) support data
 565   calledp      has-been-called flag
 566   optionalp    verification-is-optional flag
 567
 568 Returns:     0 if verification should fail, otherwise 1
 569 */
 570
 571 static int
 572 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
 573   tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
 574 {
 575 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 576 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 577 uschar dn[256];
 578
 579 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
 580   {
 581   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
 582   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 583     tlsp == &tls_out ? deliver_host_address : sender_host_address);
 584   return 0;
 585   }
 586 dn[sizeof(dn)-1] = '\0';
 587
 588 if (preverify_ok == 0)
 589   {
 590   uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
 591       *verify_mode, sender_host_address)
 592     : US"";
 593   log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
 594     tlsp == &tls_out ? deliver_host_address : sender_host_address,
 595     extra, depth,
 596     X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
 597   *calledp = TRUE;
 598   if (!*optionalp)
 599     {
 600     if (!tlsp->peercert)
 601       tlsp->peercert = X509_dup(cert);  /* record failing cert */
 602     return 0;                           /* reject */
 603     }
 604   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 605     "tls_try_verify_hosts)\n");
 606   }
 607
 608 else if (depth != 0)
 609   {
 610   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
 611 #ifndef DISABLE_OCSP
 612   if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
 613     {   /* client, wanting stapling  */
 614     /* Add the server cert's signing chain as the one
 615     for the verification of the OCSP stapled information. */
 616
 617     if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
 618                              cert))
 619       ERR_clear_error();
 620     sk_X509_push(client_static_cbinfo->verify_stack, cert);
 621     }
 622 #endif
 623 #ifndef DISABLE_EVENT
 624     if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
 625       return 0;                         /* reject, with peercert set */
 626 #endif
 627   }
 628 else
 629   {
 630   const uschar * verify_cert_hostnames;
 631
 632   if (  tlsp == &tls_out
 633      && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
 634         /* client, wanting hostname check */
 635     {
 636
 637 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
 638 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 639 #  define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
 640 # endif
 641 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
 642 #  define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
 643 # endif
 644     int sep = 0;
 645     const uschar * list = verify_cert_hostnames;
 646     uschar * name;
 647     int rc;
 648     while ((name = string_nextinlist(&list, &sep, NULL, 0)))
 649       if ((rc = X509_check_host(cert, CCS name, 0,
 650                   X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 651                   | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
 652                   NULL)))
 653         {
 654         if (rc < 0)
 655           {
 656           log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 657             tlsp == &tls_out ? deliver_host_address : sender_host_address);
 658           name = NULL;
 659           }
 660         break;
 661         }
 662     if (!name)
 663 #else
 664     if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
 665 #endif
 666       {
 667       uschar * extra = verify_mode
 668         ? string_sprintf(" (during %c-verify for [%s])",
 669           *verify_mode, sender_host_address)
 670         : US"";
 671       log_write(0, LOG_MAIN,
 672         "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
 673         tlsp == &tls_out ? deliver_host_address : sender_host_address,
 674         extra, dn, verify_cert_hostnames);
 675       *calledp = TRUE;
 676       if (!*optionalp)
 677         {
 678         if (!tlsp->peercert)
 679           tlsp->peercert = X509_dup(cert);      /* record failing cert */
 680         return 0;                               /* reject */
 681         }
 682       DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 683         "tls_try_verify_hosts)\n");
 684       }
 685     }
 686
 687 #ifndef DISABLE_EVENT
 688   if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
 689     return 0;                           /* reject, with peercert set */
 690 #endif
 691
 692   DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
 693     *calledp ? "" : " authenticated", dn);
 694   if (!*calledp) tlsp->certificate_verified = TRUE;
 695   *calledp = TRUE;
 696   }
 697
 698 return 1;   /* accept, at least for this level */
 699 }
 700
 701 static int
 702 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
 703 {
 704 return verify_callback(preverify_ok, x509ctx, &tls_out,
 705   &client_verify_callback_called, &client_verify_optional);
 706 }
 707
 708 static int
 709 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
 710 {
 711 return verify_callback(preverify_ok, x509ctx, &tls_in,
 712   &server_verify_callback_called, &server_verify_optional);
 713 }
 714
 715
 716 #ifdef SUPPORT_DANE
 717
 718 /* This gets called *by* the dane library verify callback, which interposes
 719 itself.
 720 */
 721 static int
 722 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
 723 {
 724 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 725 uschar dn[256];
 726 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 727 #ifndef DISABLE_EVENT
 728 BOOL dummy_called, optional = FALSE;
 729 #endif
 730
 731 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
 732   {
 733   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
 734   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 735     deliver_host_address);
 736   return 0;
 737   }
 738 dn[sizeof(dn)-1] = '\0';
 739
 740 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
 741   preverify_ok ? "ok":"BAD", depth, dn);
 742
 743 #ifndef DISABLE_EVENT
 744   if (verify_event(&tls_out, cert, depth, dn,
 745           &dummy_called, &optional, US"DANE"))
 746     return 0;                           /* reject, with peercert set */
 747 #endif
 748
 749 if (preverify_ok == 1)
 750   {
 751   tls_out.dane_verified = tls_out.certificate_verified = TRUE;
 752 #ifndef DISABLE_OCSP
 753   if (client_static_cbinfo->u_ocsp.client.verify_store)
 754     {   /* client, wanting stapling  */
 755     /* Add the server cert's signing chain as the one
 756     for the verification of the OCSP stapled information. */
 757
 758     if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
 759                              cert))
 760       ERR_clear_error();
 761     sk_X509_push(client_static_cbinfo->verify_stack, cert);
 762     }
 763 #endif
 764   }
 765 else
 766   {
 767   int err = X509_STORE_CTX_get_error(x509ctx);
 768   DEBUG(D_tls)
 769     debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
 770   if (err == X509_V_ERR_APPLICATION_VERIFICATION)
 771     preverify_ok = 1;
 772   }
 773 return preverify_ok;
 774 }
 775
 776 #endif  /*SUPPORT_DANE*/
 777
 778
 779 /*************************************************
 780 *           Information callback                 *
 781 *************************************************/
 782
 783 /* The SSL library functions call this from time to time to indicate what they
 784 are doing. We copy the string to the debugging output when TLS debugging has
 785 been requested.
 786
 787 Arguments:
 788   s         the SSL connection
 789   where
 790   ret
 791
 792 Returns:    nothing
 793 */
 794
 795 static void
 796 info_callback(SSL *s, int where, int ret)
 797 {
 798 DEBUG(D_tls)
 799   {
 800   const uschar * str;
 801
 802   if (where & SSL_ST_CONNECT)
 803      str = US"SSL_connect";
 804   else if (where & SSL_ST_ACCEPT)
 805      str = US"SSL_accept";
 806   else
 807      str = US"SSL info (undefined)";
 808
 809   if (where & SSL_CB_LOOP)
 810      debug_printf("%s: %s\n", str, SSL_state_string_long(s));
 811   else if (where & SSL_CB_ALERT)
 812     debug_printf("SSL3 alert %s:%s:%s\n",
 813           str = where & SSL_CB_READ ? US"read" : US"write",
 814           SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
 815   else if (where & SSL_CB_EXIT)
 816      if (ret == 0)
 817         debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
 818      else if (ret < 0)
 819         debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
 820   else if (where & SSL_CB_HANDSHAKE_START)
 821      debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
 822   else if (where & SSL_CB_HANDSHAKE_DONE)
 823      debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
 824   }
 825 }
 826
 827 #ifdef OPENSSL_HAVE_KEYLOG_CB
 828 static void
 829 keylog_callback(const SSL *ssl, const char *line)
 830 {
 831 DEBUG(D_tls) debug_printf("%.200s\n", line);
 832 }
 833 #endif
 834
 835
 836 #ifdef EXPERIMENTAL_TLS_RESUME
 837 /* Manage the keysets used for encrypting the session tickets, on the server. */
 838
 839 typedef struct {                        /* Session ticket encryption key */
 840   uschar        name[16];
 841
 842   const EVP_CIPHER *    aes_cipher;
 843   uschar                aes_key[16];    /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
 844   const EVP_MD *        hmac_hash;
 845   uschar                hmac_key[16];
 846   time_t                renew;
 847   time_t                expire;
 848 } exim_stek;
 849
 850 /*XXX for now just always create/find the one key.
 851 Worry about rotation and overlap later. */
 852
 853 static exim_stek exim_tk;
 854 static exim_stek exim_tk_old;
 855
 856 static void
 857 tk_init(void)
 858 {
 859 if (exim_tk.name[0])
 860   {
 861   if (exim_tk.renew >= time(NULL)) return;
 862   exim_tk_old = exim_tk;
 863   }
 864
 865 if (f.running_in_test_harness) ssl_session_timeout = 6;
 866
 867 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
 868 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
 869 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
 870 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
 871
 872 exim_tk.name[0] = 'E';
 873 exim_tk.aes_cipher = EVP_aes_128_cbc();
 874 exim_tk.hmac_hash = EVP_sha256();
 875 exim_tk.expire = time(NULL) + ssl_session_timeout;
 876 exim_tk.renew = exim_tk.expire - ssl_session_timeout/2;
 877 }
 878
 879 static exim_stek *
 880 tk_current(void)
 881 {
 882 if (!exim_tk.name[0]) return NULL;
 883 return &exim_tk;
 884 }
 885
 886 static exim_stek *
 887 tk_find(const uschar * name)
 888 {
 889 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
 890   : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
 891   : NULL;
 892 }
 893
 894 /* Callback for session tickets, on server */
 895 static int
 896 ticket_key_callback(SSL * ssl, uschar key_name[16],
 897   uschar * iv, EVP_CIPHER_CTX * ctx, HMAC_CTX * hctx, int enc)
 898 {
 899 tls_support * tlsp = server_static_cbinfo->tlsp;
 900 exim_stek * key;
 901
 902 if (enc)
 903   {
 904   DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
 905   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
 906
 907   if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
 908     return -1; /* insufficient random */
 909
 910   if (!(key = tk_current()))    /* current key doesn't exist or isn't valid */
 911      return 0;                  /* key couldn't be created */
 912   memcpy(key_name, key->name, 16);
 913   DEBUG(D_tls) debug_printf("STEK expire %ld\n", key->expire - time(NULL));
 914
 915   /*XXX will want these dependent on the ssl session strength */
 916   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
 917                 key->hmac_hash, NULL);
 918   EVP_EncryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
 919
 920   DEBUG(D_tls) debug_printf("ticket created\n");
 921   return 1;
 922   }
 923 else
 924   {
 925   time_t now = time(NULL);
 926
 927   DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
 928   tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
 929
 930   if (!(key = tk_find(key_name)) || key->expire < now)
 931     {
 932     DEBUG(D_tls)
 933       {
 934       debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
 935       if (key) debug_printf("STEK expire %ld\n", key->expire - now);
 936       }
 937     return 0;
 938     }
 939
 940   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
 941                 key->hmac_hash, NULL);
 942   EVP_DecryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
 943
 944   DEBUG(D_tls) debug_printf("ticket usable, STEK expire %ld\n", key->expire - now);
 945   return key->renew < now ? 2 : 1;
 946   }
 947 }
 948 #endif
 949
 950
 951
 952 /*************************************************
 953 *                Initialize for DH               *
 954 *************************************************/
 955
 956 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 957
 958 Arguments:
 959   sctx      The current SSL CTX (inbound or outbound)
 960   dhparam   DH parameter file or fixed parameter identity string
 961   host      connected host, if client; NULL if server
 962   errstr    error string pointer
 963
 964 Returns:    TRUE if OK (nothing to set up, or setup worked)
 965 */
 966
 967 static BOOL
 968 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
 969 {
 970 BIO *bio;
 971 DH *dh;
 972 uschar *dhexpanded;
 973 const char *pem;
 974 int dh_bitsize;
 975
 976 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
 977   return FALSE;
 978
 979 if (!dhexpanded || !*dhexpanded)
 980   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
 981 else if (dhexpanded[0] == '/')
 982   {
 983   if (!(bio = BIO_new_file(CS dhexpanded, "r")))
 984     {
 985     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
 986           host, US strerror(errno), errstr);
 987     return FALSE;
 988     }
 989   }
 990 else
 991   {
 992   if (Ustrcmp(dhexpanded, "none") == 0)
 993     {
 994     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
 995     return TRUE;
 996     }
 997
 998   if (!(pem = std_dh_prime_named(dhexpanded)))
 999     {
1000     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
1001         host, US strerror(errno), errstr);
1002     return FALSE;
1003     }
1004   bio = BIO_new_mem_buf(CS pem, -1);
1005   }
1006
1007 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
1008   {
1009   BIO_free(bio);
1010   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
1011       host, NULL, errstr);
1012   return FALSE;
1013   }
1014
1015 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
1016  * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
1017  * 2236.  But older OpenSSL can only report in bytes (octets), not bits.
1018  * If someone wants to dance at the edge, then they can raise the limit or use
1019  * current libraries. */
1020 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
1021 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
1022  * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
1023 dh_bitsize = DH_bits(dh);
1024 #else
1025 dh_bitsize = 8 * DH_size(dh);
1026 #endif
1027
1028 /* Even if it is larger, we silently return success rather than cause things
1029  * to fail out, so that a too-large DH will not knock out all TLS; it's a
1030  * debatable choice. */
1031 if (dh_bitsize > tls_dh_max_bits)
1032   {
1033   DEBUG(D_tls)
1034     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
1035         dh_bitsize, tls_dh_max_bits);
1036   }
1037 else
1038   {
1039   SSL_CTX_set_tmp_dh(sctx, dh);
1040   DEBUG(D_tls)
1041     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
1042       dhexpanded ? dhexpanded : US"default", dh_bitsize);
1043   }
1044
1045 DH_free(dh);
1046 BIO_free(bio);
1047
1048 return TRUE;
1049 }
1050
1051
1052
1053
1054 /*************************************************
1055 *               Initialize for ECDH              *
1056 *************************************************/
1057
1058 /* Load parameters for ECDH encryption.
1059
1060 For now, we stick to NIST P-256 because: it's simple and easy to configure;
1061 it avoids any patent issues that might bite redistributors; despite events in
1062 the news and concerns over curve choices, we're not cryptographers, we're not
1063 pretending to be, and this is "good enough" to be better than no support,
1064 protecting against most adversaries.  Given another year or two, there might
1065 be sufficient clarity about a "right" way forward to let us make an informed
1066 decision, instead of a knee-jerk reaction.
1067
1068 Longer-term, we should look at supporting both various named curves and
1069 external files generated with "openssl ecparam", much as we do for init_dh().
1070 We should also support "none" as a value, to explicitly avoid initialisation.
1071
1072 Patches welcome.
1073
1074 Arguments:
1075   sctx      The current SSL CTX (inbound or outbound)
1076   host      connected host, if client; NULL if server
1077   errstr    error string pointer
1078
1079 Returns:    TRUE if OK (nothing to set up, or setup worked)
1080 */
1081
1082 static BOOL
1083 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
1084 {
1085 #ifdef OPENSSL_NO_ECDH
1086 return TRUE;
1087 #else
1088
1089 EC_KEY * ecdh;
1090 uschar * exp_curve;
1091 int nid;
1092 BOOL rv;
1093
1094 if (host)       /* No ECDH setup for clients, only for servers */
1095   return TRUE;
1096
1097 # ifndef EXIM_HAVE_ECDH
1098 DEBUG(D_tls)
1099   debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
1100 return TRUE;
1101 # else
1102
1103 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
1104   return FALSE;
1105 if (!exp_curve || !*exp_curve)
1106   return TRUE;
1107
1108 /* "auto" needs to be handled carefully.
1109  * OpenSSL <  1.0.2: we do not select anything, but fallback to prime256v1
1110  * OpenSSL <  1.1.0: we have to call SSL_CTX_set_ecdh_auto
1111  *                   (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
1112  * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
1113  *                   https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
1114  */
1115 if (Ustrcmp(exp_curve, "auto") == 0)
1116   {
1117 #if OPENSSL_VERSION_NUMBER < 0x10002000L
1118   DEBUG(D_tls) debug_printf(
1119     "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
1120   exp_curve = US"prime256v1";
1121 #else
1122 # if defined SSL_CTRL_SET_ECDH_AUTO
1123   DEBUG(D_tls) debug_printf(
1124     "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
1125   SSL_CTX_set_ecdh_auto(sctx, 1);
1126   return TRUE;
1127 # else
1128   DEBUG(D_tls) debug_printf(
1129     "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
1130   return TRUE;
1131 # endif
1132 #endif
1133   }
1134
1135 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
1136 if (  (nid = OBJ_sn2nid       (CCS exp_curve)) == NID_undef
1137 #   ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
1138    && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
1139 #   endif
1140    )
1141   {
1142   tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
1143     host, NULL, errstr);
1144   return FALSE;
1145   }
1146
1147 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
1148   {
1149   tls_error(US"Unable to create ec curve", host, NULL, errstr);
1150   return FALSE;
1151   }
1152
1153 /* The "tmp" in the name here refers to setting a temporary key
1154 not to the stability of the interface. */
1155
1156 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
1157   tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
1158 else
1159   DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
1160
1161 EC_KEY_free(ecdh);
1162 return !rv;
1163
1164 # endif /*EXIM_HAVE_ECDH*/
1165 #endif /*OPENSSL_NO_ECDH*/
1166 }
1167
1168
1169
1170
1171 #ifndef DISABLE_OCSP
1172 /*************************************************
1173 *       Load OCSP information into state         *
1174 *************************************************/
1175 /* Called to load the server OCSP response from the given file into memory, once
1176 caller has determined this is needed.  Checks validity.  Debugs a message
1177 if invalid.
1178
1179 ASSUMES: single response, for single cert.
1180
1181 Arguments:
1182   sctx            the SSL_CTX* to update
1183   cbinfo          various parts of session state
1184   expanded        the filename putatively holding an OCSP response
1185
1186 */
1187
1188 static void
1189 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
1190 {
1191 BIO * bio;
1192 OCSP_RESPONSE * resp;
1193 OCSP_BASICRESP * basic_response;
1194 OCSP_SINGLERESP * single_response;
1195 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1196 STACK_OF(X509) * sk;
1197 unsigned long verify_flags;
1198 int status, reason, i;
1199
1200 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
1201 if (cbinfo->u_ocsp.server.response)
1202   {
1203   OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
1204   cbinfo->u_ocsp.server.response = NULL;
1205   }
1206
1207 if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
1208   {
1209   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1210       cbinfo->u_ocsp.server.file_expanded);
1211   return;
1212   }
1213
1214 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1215 BIO_free(bio);
1216 if (!resp)
1217   {
1218   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1219   return;
1220   }
1221
1222 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1223   {
1224   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1225       OCSP_response_status_str(status), status);
1226   goto bad;
1227   }
1228
1229 if (!(basic_response = OCSP_response_get1_basic(resp)))
1230   {
1231   DEBUG(D_tls)
1232     debug_printf("OCSP response parse error: unable to extract basic response.\n");
1233   goto bad;
1234   }
1235
1236 sk = cbinfo->verify_stack;
1237 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1238
1239 /* May need to expose ability to adjust those flags?
1240 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1241 OCSP_TRUSTOTHER OCSP_NOINTERN */
1242
1243 /* This does a full verify on the OCSP proof before we load it for serving
1244 up; possibly overkill - just date-checks might be nice enough.
1245
1246 OCSP_basic_verify takes a "store" arg, but does not
1247 use it for the chain verification, which is all we do
1248 when OCSP_NOVERIFY is set.  The content from the wire
1249 "basic_response" and a cert-stack "sk" are all that is used.
1250
1251 We have a stack, loaded in setup_certs() if tls_verify_certificates
1252 was a file (not a directory, or "system").  It is unfortunate we
1253 cannot used the connection context store, as that would neatly
1254 handle the "system" case too, but there seems to be no library
1255 function for getting a stack from a store.
1256 [ In OpenSSL 1.1 - ?  X509_STORE_CTX_get0_chain(ctx) ? ]
1257 We do not free the stack since it could be needed a second time for
1258 SNI handling.
1259
1260 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1261 be a public interface into the OpenSSL library (there's no manual entry) -
1262 But what with?  We also use OCSP_basic_verify in the client stapling callback.
1263 And there we NEED it; we must verify that status... unless the
1264 library does it for us anyway?  */
1265
1266 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1267   {
1268   DEBUG(D_tls)
1269     {
1270     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1271     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1272     }
1273   goto bad;
1274   }
1275
1276 /* Here's the simplifying assumption: there's only one response, for the
1277 one certificate we use, and nothing for anything else in a chain.  If this
1278 proves false, we need to extract a cert id from our issued cert
1279 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1280 right cert in the stack and then calls OCSP_single_get0_status()).
1281
1282 I'm hoping to avoid reworking a bunch more of how we handle state here. */
1283
1284 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1285   {
1286   DEBUG(D_tls)
1287     debug_printf("Unable to get first response from OCSP basic response.\n");
1288   goto bad;
1289   }
1290
1291 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1292 if (status != V_OCSP_CERTSTATUS_GOOD)
1293   {
1294   DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1295       OCSP_cert_status_str(status), status,
1296       OCSP_crl_reason_str(reason), reason);
1297   goto bad;
1298   }
1299
1300 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1301   {
1302   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1303   goto bad;
1304   }
1305
1306 supply_response:
1307   cbinfo->u_ocsp.server.response = resp;        /*XXX stack?*/
1308 return;
1309
1310 bad:
1311   if (f.running_in_test_harness)
1312     {
1313     extern char ** environ;
1314     if (environ) for (uschar ** p = USS environ; *p; p++)
1315       if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1316         {
1317         DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1318         goto supply_response;
1319         }
1320     }
1321 return;
1322 }
1323 #endif  /*!DISABLE_OCSP*/
1324
1325
1326
1327
1328 /* Create and install a selfsigned certificate, for use in server mode */
1329
1330 static int
1331 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
1332 {
1333 X509 * x509 = NULL;
1334 EVP_PKEY * pkey;
1335 RSA * rsa;
1336 X509_NAME * name;
1337 uschar * where;
1338
1339 where = US"allocating pkey";
1340 if (!(pkey = EVP_PKEY_new()))
1341   goto err;
1342
1343 where = US"allocating cert";
1344 if (!(x509 = X509_new()))
1345   goto err;
1346
1347 where = US"generating pkey";
1348 if (!(rsa = rsa_callback(NULL, 0, 2048)))
1349   goto err;
1350
1351 where = US"assigning pkey";
1352 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1353   goto err;
1354
1355 X509_set_version(x509, 2);                              /* N+1 - version 3 */
1356 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
1357 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1358 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60);        /* 1 hour */
1359 X509_set_pubkey(x509, pkey);
1360
1361 name = X509_get_subject_name(x509);
1362 X509_NAME_add_entry_by_txt(name, "C",
1363                           MBSTRING_ASC, CUS "UK", -1, -1, 0);
1364 X509_NAME_add_entry_by_txt(name, "O",
1365                           MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1366 X509_NAME_add_entry_by_txt(name, "CN",
1367                           MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1368 X509_set_issuer_name(x509, name);
1369
1370 where = US"signing cert";
1371 if (!X509_sign(x509, pkey, EVP_md5()))
1372   goto err;
1373
1374 where = US"installing selfsign cert";
1375 if (!SSL_CTX_use_certificate(sctx, x509))
1376   goto err;
1377
1378 where = US"installing selfsign key";
1379 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1380   goto err;
1381
1382 return OK;
1383
1384 err:
1385   (void) tls_error(where, NULL, NULL, errstr);
1386   if (x509) X509_free(x509);
1387   if (pkey) EVP_PKEY_free(pkey);
1388   return DEFER;
1389 }
1390
1391
1392
1393
1394 static int
1395 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1396   uschar ** errstr)
1397 {
1398 DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1399 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1400   return tls_error(string_sprintf(
1401     "SSL_CTX_use_certificate_chain_file file=%s", file),
1402       cbinfo->host, NULL, errstr);
1403 return 0;
1404 }
1405
1406 static int
1407 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1408   uschar ** errstr)
1409 {
1410 DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1411 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1412   return tls_error(string_sprintf(
1413     "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1414 return 0;
1415 }
1416
1417
1418 /*************************************************
1419 *        Expand key and cert file specs          *
1420 *************************************************/
1421
1422 /* Called once during tls_init and possibly again during TLS setup, for a
1423 new context, if Server Name Indication was used and tls_sni was seen in
1424 the certificate string.
1425
1426 Arguments:
1427   sctx            the SSL_CTX* to update
1428   cbinfo          various parts of session state
1429   errstr          error string pointer
1430
1431 Returns:          OK/DEFER/FAIL
1432 */
1433
1434 static int
1435 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1436   uschar ** errstr)
1437 {
1438 uschar *expanded;
1439
1440 if (!cbinfo->certificate)
1441   {
1442   if (!cbinfo->is_server)               /* client */
1443     return OK;
1444                                         /* server */
1445   if (tls_install_selfsign(sctx, errstr) != OK)
1446     return DEFER;
1447   }
1448 else
1449   {
1450   int err;
1451
1452   if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1453       Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1454       Ustrstr(cbinfo->certificate, US"tls_out_sni")
1455      )
1456     reexpand_tls_files_for_sni = TRUE;
1457
1458   if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1459     return DEFER;
1460
1461   if (expanded)
1462     if (cbinfo->is_server)
1463       {
1464       const uschar * file_list = expanded;
1465       int sep = 0;
1466       uschar * file;
1467
1468       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1469         if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1470           return err;
1471       }
1472     else        /* would there ever be a need for multiple client certs? */
1473       if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1474         return err;
1475
1476   if (  cbinfo->privatekey
1477      && !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1478     return DEFER;
1479
1480   /* If expansion was forced to fail, key_expanded will be NULL. If the result
1481   of the expansion is an empty string, ignore it also, and assume the private
1482   key is in the same file as the certificate. */
1483
1484   if (expanded && *expanded)
1485     if (cbinfo->is_server)
1486       {
1487       const uschar * file_list = expanded;
1488       int sep = 0;
1489       uschar * file;
1490
1491       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1492         if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1493           return err;
1494       }
1495     else        /* would there ever be a need for multiple client certs? */
1496       if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1497         return err;
1498   }
1499
1500 #ifndef DISABLE_OCSP
1501 if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
1502   {
1503   /*XXX stack*/
1504   if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
1505     return DEFER;
1506
1507   if (expanded && *expanded)
1508     {
1509     DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
1510     if (  cbinfo->u_ocsp.server.file_expanded
1511        && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
1512       {
1513       DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1514       }
1515     else
1516       ocsp_load_response(sctx, cbinfo, expanded);
1517     }
1518   }
1519 #endif
1520
1521 return OK;
1522 }
1523
1524
1525
1526
1527 /*************************************************
1528 *            Callback to handle SNI              *
1529 *************************************************/
1530
1531 /* Called when acting as server during the TLS session setup if a Server Name
1532 Indication extension was sent by the client.
1533
1534 API documentation is OpenSSL s_server.c implementation.
1535
1536 Arguments:
1537   s               SSL* of the current session
1538   ad              unknown (part of OpenSSL API) (unused)
1539   arg             Callback of "our" registered data
1540
1541 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1542
1543 XXX might need to change to using ClientHello callback,
1544 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
1545 */
1546
1547 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1548 static int
1549 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1550 {
1551 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1552 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1553 int rc;
1554 int old_pool = store_pool;
1555 uschar * dummy_errstr;
1556
1557 if (!servername)
1558   return SSL_TLSEXT_ERR_OK;
1559
1560 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1561     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1562
1563 /* Make the extension value available for expansion */
1564 store_pool = POOL_PERM;
1565 tls_in.sni = string_copy(US servername);
1566 store_pool = old_pool;
1567
1568 if (!reexpand_tls_files_for_sni)
1569   return SSL_TLSEXT_ERR_OK;
1570
1571 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1572 not confident that memcpy wouldn't break some internal reference counting.
1573 Especially since there's a references struct member, which would be off. */
1574
1575 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1576 if (!(server_sni = SSL_CTX_new(TLS_server_method())))
1577 #else
1578 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1579 #endif
1580   {
1581   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1582   DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1583   goto bad;
1584   }
1585
1586 /* Not sure how many of these are actually needed, since SSL object
1587 already exists.  Might even need this selfsame callback, for reneg? */
1588
1589 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1590 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1591 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1592 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1593 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1594 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1595
1596 if (  !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1597    || !init_ecdh(server_sni, NULL, &dummy_errstr)
1598    )
1599   goto bad;
1600
1601 if (  cbinfo->server_cipher_list
1602    && !SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list))
1603   goto bad;
1604
1605 #ifndef DISABLE_OCSP
1606 if (cbinfo->u_ocsp.server.file)
1607   {
1608   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1609   SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1610   }
1611 #endif
1612
1613 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1614                       verify_callback_server, &dummy_errstr)) != OK)
1615   goto bad;
1616
1617 /* do this after setup_certs, because this can require the certs for verifying
1618 OCSP information. */
1619 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1620   goto bad;
1621
1622 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1623 SSL_set_SSL_CTX(s, server_sni);
1624 return SSL_TLSEXT_ERR_OK;
1625
1626 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
1627 }
1628 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1629
1630
1631
1632
1633 #ifndef DISABLE_OCSP
1634
1635 /*************************************************
1636 *        Callback to handle OCSP Stapling        *
1637 *************************************************/
1638
1639 /* Called when acting as server during the TLS session setup if the client
1640 requests OCSP information with a Certificate Status Request.
1641
1642 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1643 project.
1644
1645 */
1646
1647 static int
1648 tls_server_stapling_cb(SSL *s, void *arg)
1649 {
1650 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1651 uschar *response_der;   /*XXX blob */
1652 int response_der_len;
1653
1654 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1655 out which ocsp blob to send.  Unfortunately, SSL_get_certificate is known
1656 buggy in current OpenSSL; it returns the last cert loaded always rather than
1657 the one actually presented.  So we can't support a stack of OCSP proofs at
1658 this time. */
1659
1660 DEBUG(D_tls)
1661   debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1662     cbinfo->u_ocsp.server.response ? "have" : "lack");
1663
1664 tls_in.ocsp = OCSP_NOT_RESP;
1665 if (!cbinfo->u_ocsp.server.response)
1666   return SSL_TLSEXT_ERR_NOACK;
1667
1668 response_der = NULL;
1669 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response,    /*XXX stack*/
1670                       &response_der);
1671 if (response_der_len <= 0)
1672   return SSL_TLSEXT_ERR_NOACK;
1673
1674 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1675 tls_in.ocsp = OCSP_VFIED;
1676 return SSL_TLSEXT_ERR_OK;
1677 }
1678
1679
1680 static void
1681 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1682 {
1683 BIO_printf(bp, "\t%s: ", str);
1684 ASN1_GENERALIZEDTIME_print(bp, time);
1685 BIO_puts(bp, "\n");
1686 }
1687
1688 static int
1689 tls_client_stapling_cb(SSL *s, void *arg)
1690 {
1691 tls_ext_ctx_cb * cbinfo = arg;
1692 const unsigned char * p;
1693 int len;
1694 OCSP_RESPONSE * rsp;
1695 OCSP_BASICRESP * bs;
1696 int i;
1697
1698 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1699 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1700 if(!p)
1701  {
1702   /* Expect this when we requested ocsp but got none */
1703   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1704     log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1705   else
1706     DEBUG(D_tls) debug_printf(" null\n");
1707   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1708  }
1709
1710 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1711  {
1712   tls_out.ocsp = OCSP_FAILED;
1713   if (LOGGING(tls_cipher))
1714     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1715   else
1716     DEBUG(D_tls) debug_printf(" parse error\n");
1717   return 0;
1718  }
1719
1720 if(!(bs = OCSP_response_get1_basic(rsp)))
1721   {
1722   tls_out.ocsp = OCSP_FAILED;
1723   if (LOGGING(tls_cipher))
1724     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1725   else
1726     DEBUG(D_tls) debug_printf(" error parsing response\n");
1727   OCSP_RESPONSE_free(rsp);
1728   return 0;
1729   }
1730
1731 /* We'd check the nonce here if we'd put one in the request. */
1732 /* However that would defeat cacheability on the server so we don't. */
1733
1734 /* This section of code reworked from OpenSSL apps source;
1735    The OpenSSL Project retains copyright:
1736    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
1737 */
1738   {
1739     BIO * bp = NULL;
1740     int status, reason;
1741     ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1742
1743     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1744
1745     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
1746
1747     /* Use the chain that verified the server cert to verify the stapled info */
1748     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1749
1750     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1751               cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1752       {
1753       tls_out.ocsp = OCSP_FAILED;
1754       if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1755               "Received TLS cert status response, itself unverifiable: %s",
1756               ERR_reason_error_string(ERR_peek_error()));
1757       BIO_printf(bp, "OCSP response verify failure\n");
1758       ERR_print_errors(bp);
1759       OCSP_RESPONSE_print(bp, rsp, 0);
1760       goto failed;
1761       }
1762
1763     BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1764
1765     /*XXX So we have a good stapled OCSP status.  How do we know
1766     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
1767     OCSP_resp_find_status() which matches on a cert id, which presumably
1768     we should use. Making an id needs OCSP_cert_id_new(), which takes
1769     issuerName, issuerKey, serialNumber.  Are they all in the cert?
1770
1771     For now, carry on blindly accepting the resp. */
1772
1773       {
1774       OCSP_SINGLERESP * single;
1775
1776 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1777       if (OCSP_resp_count(bs) != 1)
1778 #else
1779       STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1780       if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1781 #endif
1782         {
1783         tls_out.ocsp = OCSP_FAILED;
1784         log_write(0, LOG_MAIN, "OCSP stapling "
1785             "with multiple responses not handled");
1786         goto failed;
1787         }
1788       single = OCSP_resp_get0(bs, 0);
1789       status = OCSP_single_get0_status(single, &reason, &rev,
1790                   &thisupd, &nextupd);
1791       }
1792
1793     DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1794     DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1795     if (!OCSP_check_validity(thisupd, nextupd,
1796           EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1797       {
1798       tls_out.ocsp = OCSP_FAILED;
1799       DEBUG(D_tls) ERR_print_errors(bp);
1800       log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1801       }
1802     else
1803       {
1804       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1805                     OCSP_cert_status_str(status));
1806       switch(status)
1807         {
1808         case V_OCSP_CERTSTATUS_GOOD:
1809           tls_out.ocsp = OCSP_VFIED;
1810           i = 1;
1811           goto good;
1812         case V_OCSP_CERTSTATUS_REVOKED:
1813           tls_out.ocsp = OCSP_FAILED;
1814           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1815               reason != -1 ? "; reason: " : "",
1816               reason != -1 ? OCSP_crl_reason_str(reason) : "");
1817           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1818           break;
1819         default:
1820           tls_out.ocsp = OCSP_FAILED;
1821           log_write(0, LOG_MAIN,
1822               "Server certificate status unknown, in OCSP stapling");
1823           break;
1824         }
1825       }
1826   failed:
1827     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1828   good:
1829     BIO_free(bp);
1830   }
1831
1832 OCSP_RESPONSE_free(rsp);
1833 return i;
1834 }
1835 #endif  /*!DISABLE_OCSP*/
1836
1837
1838 /*************************************************
1839 *            Initialize for TLS                  *
1840 *************************************************/
1841
1842 /* Called from both server and client code, to do preliminary initialization
1843 of the library.  We allocate and return a context structure.
1844
1845 Arguments:
1846   ctxp            returned SSL context
1847   host            connected host, if client; NULL if server
1848   dhparam         DH parameter file
1849   certificate     certificate file
1850   privatekey      private key
1851   ocsp_file       file of stapling info (server); flag for require ocsp (client)
1852   addr            address if client; NULL if server (for some randomness)
1853   cbp             place to put allocated callback context
1854   errstr          error string pointer
1855
1856 Returns:          OK/DEFER/FAIL
1857 */
1858
1859 static int
1860 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1861   uschar *privatekey,
1862 #ifndef DISABLE_OCSP
1863   uschar *ocsp_file,    /*XXX stack, in server*/
1864 #endif
1865   address_item *addr, tls_ext_ctx_cb ** cbp,
1866   tls_support * tlsp,
1867   uschar ** errstr)
1868 {
1869 SSL_CTX * ctx;
1870 long init_options;
1871 int rc;
1872 tls_ext_ctx_cb * cbinfo;
1873
1874 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1875 cbinfo->tlsp = tlsp;
1876 cbinfo->certificate = certificate;
1877 cbinfo->privatekey = privatekey;
1878 cbinfo->is_server = host==NULL;
1879 #ifndef DISABLE_OCSP
1880 cbinfo->verify_stack = NULL;
1881 if (!host)
1882   {
1883   cbinfo->u_ocsp.server.file = ocsp_file;
1884   cbinfo->u_ocsp.server.file_expanded = NULL;
1885   cbinfo->u_ocsp.server.response = NULL;
1886   }
1887 else
1888   cbinfo->u_ocsp.client.verify_store = NULL;
1889 #endif
1890 cbinfo->dhparam = dhparam;
1891 cbinfo->server_cipher_list = NULL;
1892 cbinfo->host = host;
1893 #ifndef DISABLE_EVENT
1894 cbinfo->event_action = NULL;
1895 #endif
1896
1897 #ifdef EXIM_NEED_OPENSSL_INIT
1898 SSL_load_error_strings();          /* basic set up */
1899 OpenSSL_add_ssl_algorithms();
1900 #endif
1901
1902 #ifdef EXIM_HAVE_SHA256
1903 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1904 list of available digests. */
1905 EVP_add_digest(EVP_sha256());
1906 #endif
1907
1908 /* Create a context.
1909 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1910 negotiation in the different methods; as far as I can tell, the only
1911 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1912 when OpenSSL is built without SSLv2 support.
1913 By disabling with openssl_options, we can let admins re-enable with the
1914 existing knob. */
1915
1916 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1917 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1918 #else
1919 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1920 #endif
1921   return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1922
1923 /* It turns out that we need to seed the random number generator this early in
1924 order to get the full complement of ciphers to work. It took me roughly a day
1925 of work to discover this by experiment.
1926
1927 On systems that have /dev/urandom, SSL may automatically seed itself from
1928 there. Otherwise, we have to make something up as best we can. Double check
1929 afterwards. */
1930
1931 if (!RAND_status())
1932   {
1933   randstuff r;
1934   gettimeofday(&r.tv, NULL);
1935   r.p = getpid();
1936
1937   RAND_seed(US (&r), sizeof(r));
1938   RAND_seed(US big_buffer, big_buffer_size);
1939   if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1940
1941   if (!RAND_status())
1942     return tls_error(US"RAND_status", host,
1943       US"unable to seed random number generator", errstr);
1944   }
1945
1946 /* Set up the information callback, which outputs if debugging is at a suitable
1947 level. */
1948
1949 DEBUG(D_tls)
1950   {
1951   SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1952 #if defined(EXIM_HAVE_OPESSL_TRACE) && !defined(OPENSSL_NO_SSL_TRACE)
1953   /* this needs a debug build of OpenSSL */
1954   SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
1955 #endif
1956 #ifdef OPENSSL_HAVE_KEYLOG_CB
1957   SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
1958 #endif
1959   }
1960
1961 /* Automatically re-try reads/writes after renegotiation. */
1962 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1963
1964 /* Apply administrator-supplied work-arounds.
1965 Historically we applied just one requested option,
1966 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1967 moved to an administrator-controlled list of options to specify and
1968 grandfathered in the first one as the default value for "openssl_options".
1969
1970 No OpenSSL version number checks: the options we accept depend upon the
1971 availability of the option value macros from OpenSSL.  */
1972
1973 if (!tls_openssl_options_parse(openssl_options, &init_options))
1974   return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1975
1976 #ifdef EXPERIMENTAL_TLS_RESUME
1977 tlsp->resumption = RESUME_SUPPORTED;
1978 #endif
1979 if (init_options)
1980   {
1981 #ifdef EXPERIMENTAL_TLS_RESUME
1982   /* Should the server offer session resumption? */
1983   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
1984     {
1985     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
1986     init_options &= ~SSL_OP_NO_TICKET;
1987     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
1988     tlsp->host_resumable = TRUE;
1989     }
1990 #endif
1991
1992   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1993   if (!(SSL_CTX_set_options(ctx, init_options)))
1994     return tls_error(string_sprintf(
1995           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
1996   }
1997 else
1998   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1999
2000 /* We'd like to disable session cache unconditionally, but foolish Outlook
2001 Express clients then give up the first TLS connection and make a second one
2002 (which works).  Only when there is an IMAP service on the same machine.
2003 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2004 now, until we work out a decent way of presenting control to the config.  It
2005 will never be used because we use a new context every time. */
2006 #ifdef notdef
2007 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2008 #endif
2009
2010 /* Initialize with DH parameters if supplied */
2011 /* Initialize ECDH temp key parameter selection */
2012
2013 if (  !init_dh(ctx, dhparam, host, errstr)
2014    || !init_ecdh(ctx, host, errstr)
2015    )
2016   return DEFER;
2017
2018 /* Set up certificate and key (and perhaps OCSP info) */
2019
2020 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
2021   return rc;
2022
2023 /* If we need to handle SNI or OCSP, do so */
2024
2025 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2026 # ifndef DISABLE_OCSP
2027   if (!(cbinfo->verify_stack = sk_X509_new_null()))
2028     {
2029     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2030     return FAIL;
2031     }
2032 # endif
2033
2034 if (!host)              /* server */
2035   {
2036 # ifndef DISABLE_OCSP
2037   /* We check u_ocsp.server.file, not server.response, because we care about if
2038   the option exists, not what the current expansion might be, as SNI might
2039   change the certificate and OCSP file in use between now and the time the
2040   callback is invoked. */
2041   if (cbinfo->u_ocsp.server.file)
2042     {
2043     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2044     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2045     }
2046 # endif
2047   /* We always do this, so that $tls_sni is available even if not used in
2048   tls_certificate */
2049   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2050   SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
2051   }
2052 # ifndef DISABLE_OCSP
2053 else                    /* client */
2054   if(ocsp_file)         /* wanting stapling */
2055     {
2056     if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
2057       {
2058       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2059       return FAIL;
2060       }
2061     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2062     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2063     }
2064 # endif
2065 #endif
2066
2067 cbinfo->verify_cert_hostnames = NULL;
2068
2069 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2070 /* Set up the RSA callback */
2071 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2072 #endif
2073
2074 /* Finally, set the session cache timeout, and we are done.
2075 The period appears to be also used for (server-generated) session tickets */
2076
2077 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2078 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2079
2080 *cbp = cbinfo;
2081 *ctxp = ctx;
2082
2083 return OK;
2084 }
2085
2086
2087
2088
2089 /*************************************************
2090 *           Get name of cipher in use            *
2091 *************************************************/
2092
2093 /*
2094 Argument:   pointer to an SSL structure for the connection
2095             pointer to number of bits for cipher
2096 Returns:    pointer to allocated string in perm-pool
2097 */
2098
2099 static uschar *
2100 construct_cipher_name(SSL * ssl, int * bits)
2101 {
2102 int pool = store_pool;
2103 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2104 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2105 the accessor functions use const in the prototype. */
2106
2107 const uschar * ver = CUS SSL_get_version(ssl);
2108 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2109 uschar * s;
2110
2111 SSL_CIPHER_get_bits(c, bits);
2112
2113 store_pool = POOL_PERM;
2114 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2115 store_pool = pool;
2116 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2117 return s;
2118 }
2119
2120
2121 /* Get IETF-standard name for ciphersuite.
2122 Argument:   pointer to an SSL structure for the connection
2123 Returns:    pointer to string
2124 */
2125
2126 static const uschar *
2127 cipher_stdname_ssl(SSL * ssl)
2128 {
2129 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2130 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2131 #else
2132 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2133 return cipher_stdname(id >> 8, id & 0xff);
2134 #endif
2135 }
2136
2137
2138 static void
2139 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2140 {
2141 /*XXX we might consider a list-of-certs variable for the cert chain.
2142 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2143 in list-handling functions, also consider the difference between the entire
2144 chain and the elements sent by the peer. */
2145
2146 tlsp->peerdn = NULL;
2147
2148 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2149 if (!tlsp->peercert)
2150   tlsp->peercert = SSL_get_peer_certificate(ssl);
2151 /* Beware anonymous ciphers which lead to server_cert being NULL */
2152 if (tlsp->peercert)
2153   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2154     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2155   else
2156     {
2157     peerdn[siz-1] = '\0';
2158     tlsp->peerdn = peerdn;              /*XXX a static buffer... */
2159     }
2160 }
2161
2162
2163
2164
2165
2166 /*************************************************
2167 *        Set up for verifying certificates       *
2168 *************************************************/
2169
2170 #ifndef DISABLE_OCSP
2171 /* Load certs from file, return TRUE on success */
2172
2173 static BOOL
2174 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
2175 {
2176 BIO * bp;
2177 X509 * x;
2178
2179 while (sk_X509_num(verify_stack) > 0)
2180   X509_free(sk_X509_pop(verify_stack));
2181
2182 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2183 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
2184   sk_X509_push(verify_stack, x);
2185 BIO_free(bp);
2186 return TRUE;
2187 }
2188 #endif
2189
2190
2191
2192 /* Called by both client and server startup; on the server possibly
2193 repeated after a Server Name Indication.
2194
2195 Arguments:
2196   sctx          SSL_CTX* to initialise
2197   certs         certs file or NULL
2198   crl           CRL file or NULL
2199   host          NULL in a server; the remote host in a client
2200   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
2201                 otherwise passed as FALSE
2202   cert_vfy_cb   Callback function for certificate verification
2203   errstr        error string pointer
2204
2205 Returns:        OK/DEFER/FAIL
2206 */
2207
2208 static int
2209 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
2210     int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
2211 {
2212 uschar *expcerts, *expcrl;
2213
2214 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2215   return DEFER;
2216 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2217
2218 if (expcerts && *expcerts)
2219   {
2220   /* Tell the library to use its compiled-in location for the system default
2221   CA bundle. Then add the ones specified in the config, if any. */
2222
2223   if (!SSL_CTX_set_default_verify_paths(sctx))
2224     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2225
2226   if (Ustrcmp(expcerts, "system") != 0)
2227     {
2228     struct stat statbuf;
2229
2230     if (Ustat(expcerts, &statbuf) < 0)
2231       {
2232       log_write(0, LOG_MAIN|LOG_PANIC,
2233         "failed to stat %s for certificates", expcerts);
2234       return DEFER;
2235       }
2236     else
2237       {
2238       uschar *file, *dir;
2239       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2240         { file = NULL; dir = expcerts; }
2241       else
2242         {
2243         file = expcerts; dir = NULL;
2244 #ifndef DISABLE_OCSP
2245         /* In the server if we will be offering an OCSP proof, load chain from
2246         file for verifying the OCSP proof at load time. */
2247
2248         if (  !host
2249            && statbuf.st_size > 0
2250            && server_static_cbinfo->u_ocsp.server.file
2251            && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
2252            )
2253           {
2254           log_write(0, LOG_MAIN|LOG_PANIC,
2255             "failed to load cert chain from %s", file);
2256           return DEFER;
2257           }
2258 #endif
2259         }
2260
2261       /* If a certificate file is empty, the next function fails with an
2262       unhelpful error message. If we skip it, we get the correct behaviour (no
2263       certificates are recognized, but the error message is still misleading (it
2264       says no certificate was supplied).  But this is better. */
2265
2266       if (  (!file || statbuf.st_size > 0)
2267          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2268         return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
2269
2270       /* Load the list of CAs for which we will accept certs, for sending
2271       to the client.  This is only for the one-file tls_verify_certificates
2272       variant.
2273       If a list isn't loaded into the server, but some verify locations are set,
2274       the server end appears to make a wildcard request for client certs.
2275       Meanwhile, the client library as default behaviour *ignores* the list
2276       we send over the wire - see man SSL_CTX_set_client_cert_cb.
2277       Because of this, and that the dir variant is likely only used for
2278       the public-CA bundle (not for a private CA), not worth fixing.  */
2279
2280       if (file)
2281         {
2282         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2283
2284         SSL_CTX_set_client_CA_list(sctx, names);
2285         DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
2286                                     sk_X509_NAME_num(names));
2287         }
2288       }
2289     }
2290
2291   /* Handle a certificate revocation list. */
2292
2293 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2294
2295   /* This bit of code is now the version supplied by Lars Mainka. (I have
2296   merely reformatted it into the Exim code style.)
2297
2298   "From here I changed the code to add support for multiple crl's
2299   in pem format in one file or to support hashed directory entries in
2300   pem format instead of a file. This method now uses the library function
2301   X509_STORE_load_locations to add the CRL location to the SSL context.
2302   OpenSSL will then handle the verify against CA certs and CRLs by
2303   itself in the verify callback." */
2304
2305   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2306   if (expcrl && *expcrl)
2307     {
2308     struct stat statbufcrl;
2309     if (Ustat(expcrl, &statbufcrl) < 0)
2310       {
2311       log_write(0, LOG_MAIN|LOG_PANIC,
2312         "failed to stat %s for certificates revocation lists", expcrl);
2313       return DEFER;
2314       }
2315     else
2316       {
2317       /* is it a file or directory? */
2318       uschar *file, *dir;
2319       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2320       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2321         {
2322         file = NULL;
2323         dir = expcrl;
2324         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2325         }
2326       else
2327         {
2328         file = expcrl;
2329         dir = NULL;
2330         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2331         }
2332       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2333         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2334
2335       /* setting the flags to check against the complete crl chain */
2336
2337       X509_STORE_set_flags(cvstore,
2338         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2339       }
2340     }
2341
2342 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2343
2344   /* If verification is optional, don't fail if no certificate */
2345
2346   SSL_CTX_set_verify(sctx,
2347     SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2348     cert_vfy_cb);
2349   }
2350
2351 return OK;
2352 }
2353
2354
2355
2356 /*************************************************
2357 *       Start a TLS session in a server          *
2358 *************************************************/
2359
2360 /* This is called when Exim is running as a server, after having received
2361 the STARTTLS command. It must respond to that command, and then negotiate
2362 a TLS session.
2363
2364 Arguments:
2365   require_ciphers   allowed ciphers
2366   errstr            pointer to error message
2367
2368 Returns:            OK on success
2369                     DEFER for errors before the start of the negotiation
2370                     FAIL for errors during the negotiation; the server can't
2371                       continue running.
2372 */
2373
2374 int
2375 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2376 {
2377 int rc;
2378 uschar * expciphers;
2379 tls_ext_ctx_cb * cbinfo;
2380 static uschar peerdn[256];
2381
2382 /* Check for previous activation */
2383
2384 if (tls_in.active.sock >= 0)
2385   {
2386   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2387   smtp_printf("554 Already in TLS\r\n", FALSE);
2388   return FAIL;
2389   }
2390
2391 /* Initialize the SSL library. If it fails, it will already have logged
2392 the error. */
2393
2394 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
2395 #ifndef DISABLE_OCSP
2396     tls_ocsp_file,      /*XXX stack*/
2397 #endif
2398     NULL, &server_static_cbinfo, &tls_in, errstr);
2399 if (rc != OK) return rc;
2400 cbinfo = server_static_cbinfo;
2401
2402 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2403   return FAIL;
2404
2405 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2406 were historically separated by underscores. So that I can use either form in my
2407 tests, and also for general convenience, we turn underscores into hyphens here.
2408
2409 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2410 for TLS 1.3 .  Since we do not call it at present we get the default list:
2411 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2412 */
2413
2414 if (expciphers)
2415   {
2416   for (uschar * s = expciphers; *s; s++ ) if (*s == '_') *s = '-';
2417   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2418   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2419     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2420   cbinfo->server_cipher_list = expciphers;
2421   }
2422
2423 /* If this is a host for which certificate verification is mandatory or
2424 optional, set up appropriately. */
2425
2426 tls_in.certificate_verified = FALSE;
2427 #ifdef SUPPORT_DANE
2428 tls_in.dane_verified = FALSE;
2429 #endif
2430 server_verify_callback_called = FALSE;
2431
2432 if (verify_check_host(&tls_verify_hosts) == OK)
2433   {
2434   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2435                         FALSE, verify_callback_server, errstr);
2436   if (rc != OK) return rc;
2437   server_verify_optional = FALSE;
2438   }
2439 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2440   {
2441   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2442                         TRUE, verify_callback_server, errstr);
2443   if (rc != OK) return rc;
2444   server_verify_optional = TRUE;
2445   }
2446
2447 #ifdef EXPERIMENTAL_TLS_RESUME
2448 SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, ticket_key_callback);
2449 /* despite working, appears to always return failure, so ignoring */
2450 #endif
2451 #ifdef OPENSSL_HAVE_NUM_TICKETS
2452 # ifdef EXPERIMENTAL_TLS_RESUME
2453 SSL_CTX_set_num_tickets(server_ctx, tls_in.host_resumable ? 1 : 0);
2454 # else
2455 SSL_CTX_set_num_tickets(server_ctx, 0); /* send no TLS1.3 stateful-tickets */
2456 # endif
2457 #endif
2458
2459
2460 /* Prepare for new connection */
2461
2462 if (!(server_ssl = SSL_new(server_ctx)))
2463   return tls_error(US"SSL_new", NULL, NULL, errstr);
2464
2465 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2466  *
2467  * With the SSL_clear(), we get strange interoperability bugs with
2468  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
2469  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2470  *
2471  * The SSL_clear() call is to let an existing SSL* be reused, typically after
2472  * session shutdown.  In this case, we have a brand new object and there's no
2473  * obvious reason to immediately clear it.  I'm guessing that this was
2474  * originally added because of incomplete initialisation which the clear fixed,
2475  * in some historic release.
2476  */
2477
2478 /* Set context and tell client to go ahead, except in the case of TLS startup
2479 on connection, where outputting anything now upsets the clients and tends to
2480 make them disconnect. We need to have an explicit fflush() here, to force out
2481 the response. Other smtp_printf() calls do not need it, because in non-TLS
2482 mode, the fflush() happens when smtp_getc() is called. */
2483
2484 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2485 if (!tls_in.on_connect)
2486   {
2487   smtp_printf("220 TLS go ahead\r\n", FALSE);
2488   fflush(smtp_out);
2489   }
2490
2491 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2492 that the OpenSSL library doesn't. */
2493
2494 SSL_set_wfd(server_ssl, fileno(smtp_out));
2495 SSL_set_rfd(server_ssl, fileno(smtp_in));
2496 SSL_set_accept_state(server_ssl);
2497
2498 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2499
2500 sigalrm_seen = FALSE;
2501 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2502 rc = SSL_accept(server_ssl);
2503 ALARM_CLR(0);
2504
2505 if (rc <= 0)
2506   {
2507   (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2508   return FAIL;
2509   }
2510
2511 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2512 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
2513                         anon-authentication ciphersuite negotiated. */
2514
2515 #ifdef EXPERIMENTAL_TLS_RESUME
2516 if (SSL_session_reused(server_ssl))
2517   {
2518   tls_in.resumption |= RESUME_USED;
2519   DEBUG(D_tls) debug_printf("Session reused\n");
2520   }
2521 #endif
2522
2523 /* TLS has been set up. Adjust the input functions to read via TLS,
2524 and initialize things. */
2525
2526 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2527
2528 tls_in.cipher = construct_cipher_name(server_ssl, &tls_in.bits);
2529 tls_in.cipher_stdname = cipher_stdname_ssl(server_ssl);
2530
2531 DEBUG(D_tls)
2532   {
2533   uschar buf[2048];
2534   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)))
2535     debug_printf("Shared ciphers: %s\n", buf);
2536
2537 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
2538   {
2539   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2540   SSL_SESSION_print_keylog(bp, SSL_get_session(server_ssl));
2541   BIO_free(bp);
2542   }
2543 #endif
2544
2545 #ifdef EXIM_HAVE_SESSION_TICKET
2546   {
2547   SSL_SESSION * ss = SSL_get_session(server_ssl);
2548   if (SSL_SESSION_has_ticket(ss))
2549     debug_printf("The session has a ticket, life %lu seconds\n",
2550       SSL_SESSION_get_ticket_lifetime_hint(ss));
2551   }
2552 #endif
2553   }
2554
2555 /* Record the certificate we presented */
2556   {
2557   X509 * crt = SSL_get_certificate(server_ssl);
2558   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2559   }
2560
2561 /* Only used by the server-side tls (tls_in), including tls_getc.
2562    Client-side (tls_out) reads (seem to?) go via
2563    smtp_read_response()/ip_recv().
2564    Hence no need to duplicate for _in and _out.
2565  */
2566 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2567 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2568 ssl_xfer_eof = ssl_xfer_error = FALSE;
2569
2570 receive_getc = tls_getc;
2571 receive_getbuf = tls_getbuf;
2572 receive_get_cache = tls_get_cache;
2573 receive_ungetc = tls_ungetc;
2574 receive_feof = tls_feof;
2575 receive_ferror = tls_ferror;
2576 receive_smtp_buffered = tls_smtp_buffered;
2577
2578 tls_in.active.sock = fileno(smtp_out);
2579 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
2580 return OK;
2581 }
2582
2583
2584
2585
2586 static int
2587 tls_client_basic_ctx_init(SSL_CTX * ctx,
2588     host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2589     uschar ** errstr)
2590 {
2591 int rc;
2592 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2593    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2594    the specified host patterns if one of them is defined */
2595
2596 if (  (  !ob->tls_verify_hosts
2597       && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2598       )
2599    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2600    )
2601   client_verify_optional = FALSE;
2602 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2603   client_verify_optional = TRUE;
2604 else
2605   return OK;
2606
2607 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2608       ob->tls_crl, host, client_verify_optional, verify_callback_client,
2609       errstr)) != OK)
2610   return rc;
2611
2612 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2613   {
2614   cbinfo->verify_cert_hostnames =
2615 #ifdef SUPPORT_I18N
2616     string_domain_utf8_to_alabel(host->name, NULL);
2617 #else
2618     host->name;
2619 #endif
2620   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2621                     cbinfo->verify_cert_hostnames);
2622   }
2623 return OK;
2624 }
2625
2626
2627 #ifdef SUPPORT_DANE
2628 static int
2629 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2630 {
2631 dns_scan dnss;
2632 const char * hostnames[2] = { CS host->name, NULL };
2633 int found = 0;
2634
2635 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2636   return tls_error(US"hostnames load", host, NULL, errstr);
2637
2638 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2639      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2640     ) if (rr->type == T_TLSA && rr->size > 3)
2641   {
2642   const uschar * p = rr->data;
2643   uint8_t usage, selector, mtype;
2644   const char * mdname;
2645
2646   usage = *p++;
2647
2648   /* Only DANE-TA(2) and DANE-EE(3) are supported */
2649   if (usage != 2 && usage != 3) continue;
2650
2651   selector = *p++;
2652   mtype = *p++;
2653
2654   switch (mtype)
2655     {
2656     default: continue;  /* Only match-types 0, 1, 2 are supported */
2657     case 0:  mdname = NULL; break;
2658     case 1:  mdname = "sha256"; break;
2659     case 2:  mdname = "sha512"; break;
2660     }
2661
2662   found++;
2663   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2664     {
2665     default:
2666       return tls_error(US"tlsa load", host, NULL, errstr);
2667     case 0:     /* action not taken */
2668     case 1:     break;
2669     }
2670
2671   tls_out.tlsa_usage |= 1<<usage;
2672   }
2673
2674 if (found)
2675   return OK;
2676
2677 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2678 return DEFER;
2679 }
2680 #endif  /*SUPPORT_DANE*/
2681
2682
2683
2684 #ifdef EXPERIMENTAL_TLS_RESUME
2685 /* On the client, get any stashed session for the given IP from hints db
2686 and apply it to the ssl-connection for attempted resumption. */
2687
2688 static void
2689 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
2690 {
2691 tlsp->resumption |= RESUME_SUPPORTED;
2692 if (tlsp->host_resumable)
2693   {
2694   dbdata_tls_session * dt;
2695   int len;
2696   open_db dbblock, * dbm_file;
2697
2698   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2699   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
2700   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2701     {
2702     /* key for the db is the IP */
2703     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
2704       {
2705       SSL_SESSION * ss = NULL;
2706       const uschar * sess_asn1 = dt->session;
2707
2708       len -= sizeof(dbdata_tls_session);
2709       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
2710         {
2711         DEBUG(D_tls)
2712           {
2713           ERR_error_string_n(ERR_get_error(),
2714             ssl_errstring, sizeof(ssl_errstring));
2715           debug_printf("decoding session: %s\n", ssl_errstring);
2716           }
2717         }
2718       else if (!SSL_set_session(ssl, ss))
2719         {
2720         DEBUG(D_tls)
2721           {
2722           ERR_error_string_n(ERR_get_error(),
2723             ssl_errstring, sizeof(ssl_errstring));
2724           debug_printf("applying session to ssl: %s\n", ssl_errstring);
2725           }
2726         }
2727       else
2728         {
2729         DEBUG(D_tls) debug_printf("good session\n");
2730         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2731         }
2732       }
2733     else
2734       DEBUG(D_tls) debug_printf("no session record\n");
2735     dbfn_close(dbm_file);
2736     }
2737   }
2738 }
2739
2740
2741 /* On the client, save the session for later resumption */
2742
2743 static int
2744 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
2745 {
2746 tls_ext_ctx_cb * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
2747 tls_support * tlsp;
2748
2749 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
2750
2751 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
2752
2753 # ifdef EXIM_HAVE_SESSION_TICKET
2754
2755 if (SSL_SESSION_is_resumable(ss))
2756   {
2757   int len = i2d_SSL_SESSION(ss, NULL);
2758   int dlen = sizeof(dbdata_tls_session) + len;
2759   dbdata_tls_session * dt = store_get(dlen);
2760   uschar * s = dt->session;
2761   open_db dbblock, * dbm_file;
2762
2763   DEBUG(D_tls) debug_printf("session is resumable\n");
2764   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
2765
2766   len = i2d_SSL_SESSION(ss, &s);        /* s gets bumped to end */
2767
2768   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2769     {
2770     const uschar * key = cbinfo->host->address;
2771     dbfn_delete(dbm_file, key);
2772     dbfn_write(dbm_file, key, dt, dlen);
2773     dbfn_close(dbm_file);
2774     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
2775                   (unsigned)dlen);
2776     }
2777   }
2778 # endif
2779 return 1;
2780 }
2781
2782
2783 static void
2784 tls_client_ctx_resume_prehandshake(
2785   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
2786   smtp_transport_options_block * ob, host_item * host)
2787 {
2788 /* Should the client request a session resumption ticket? */
2789 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2790   {
2791   tlsp->host_resumable = TRUE;
2792
2793   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
2794         SSL_SESS_CACHE_CLIENT
2795         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
2796   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
2797   }
2798 }
2799
2800 static BOOL
2801 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
2802   host_item * host, uschar ** errstr)
2803 {
2804 if (tlsp->host_resumable)
2805   {
2806   DEBUG(D_tls)
2807     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
2808   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
2809
2810   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
2811   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_cbinfo))
2812     {
2813     tls_error(US"set ex_data", host, NULL, errstr);
2814     return FALSE;
2815     }
2816   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_cbinfo);
2817   }
2818
2819 tlsp->resumption = RESUME_SUPPORTED;
2820 /* Pick up a previous session, saved on an old ticket */
2821 tls_retrieve_session(tlsp, ssl, host->address);
2822 return TRUE;
2823 }
2824
2825 static void
2826 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
2827   tls_support * tlsp)
2828 {
2829 if (SSL_session_reused(exim_client_ctx->ssl))
2830   {
2831   DEBUG(D_tls) debug_printf("The session was reused\n");
2832   tlsp->resumption |= RESUME_USED;
2833   }
2834 }
2835 #endif  /* EXPERIMENTAL_TLS_RESUME */
2836
2837
2838 /*************************************************
2839 *    Start a TLS session in a client             *
2840 *************************************************/
2841
2842 /* Called from the smtp transport after STARTTLS has been accepted.
2843
2844 Arguments:
2845   cctx          connection context
2846   conn_args     connection details
2847   cookie        datum for randomness; can be NULL
2848   tlsp          record details of TLS channel configuration here; must be non-NULL
2849   errstr        error string pointer
2850
2851 Returns:        TRUE for success with TLS session context set in connection context,
2852                 FALSE on error
2853 */
2854
2855 BOOL
2856 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
2857   void * cookie, tls_support * tlsp, uschar ** errstr)
2858 {
2859 host_item * host = conn_args->host;             /* for msgs and option-tests */
2860 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
2861 smtp_transport_options_block * ob = tb
2862   ? (smtp_transport_options_block *)tb->options_block
2863   : &smtp_transport_option_defaults;
2864 exim_openssl_client_tls_ctx * exim_client_ctx;
2865 uschar * expciphers;
2866 int rc;
2867 static uschar peerdn[256];
2868
2869 #ifndef DISABLE_OCSP
2870 BOOL request_ocsp = FALSE;
2871 BOOL require_ocsp = FALSE;
2872 #endif
2873
2874 rc = store_pool;
2875 store_pool = POOL_PERM;
2876 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx));
2877 exim_client_ctx->corked = NULL;
2878 store_pool = rc;
2879
2880 #ifdef SUPPORT_DANE
2881 tlsp->tlsa_usage = 0;
2882 #endif
2883
2884 #ifndef DISABLE_OCSP
2885   {
2886 # ifdef SUPPORT_DANE
2887   if (  conn_args->dane
2888      && ob->hosts_request_ocsp[0] == '*'
2889      && ob->hosts_request_ocsp[1] == '\0'
2890      )
2891     {
2892     /* Unchanged from default.  Use a safer one under DANE */
2893     request_ocsp = TRUE;
2894     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2895                                       "   {= {4}{$tls_out_tlsa_usage}} } "
2896                                  " {*}{}}";
2897     }
2898 # endif
2899
2900   if ((require_ocsp =
2901         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
2902     request_ocsp = TRUE;
2903   else
2904 # ifdef SUPPORT_DANE
2905     if (!request_ocsp)
2906 # endif
2907       request_ocsp =
2908         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2909   }
2910 #endif
2911
2912 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
2913     ob->tls_certificate, ob->tls_privatekey,
2914 #ifndef DISABLE_OCSP
2915     (void *)(long)request_ocsp,
2916 #endif
2917     cookie, &client_static_cbinfo, tlsp, errstr);
2918 if (rc != OK) return FALSE;
2919
2920 tlsp->certificate_verified = FALSE;
2921 client_verify_callback_called = FALSE;
2922
2923 expciphers = NULL;
2924 #ifdef SUPPORT_DANE
2925 if (conn_args->dane)
2926   {
2927   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2928   other failures should be treated as problems. */
2929   if (ob->dane_require_tls_ciphers &&
2930       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2931         &expciphers, errstr))
2932     return FALSE;
2933   if (expciphers && *expciphers == '\0')
2934     expciphers = NULL;
2935   }
2936 #endif
2937 if (!expciphers &&
2938     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2939       &expciphers, errstr))
2940   return FALSE;
2941
2942 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2943 are separated by underscores. So that I can use either form in my tests, and
2944 also for general convenience, we turn underscores into hyphens here. */
2945
2946 if (expciphers)
2947   {
2948   uschar *s = expciphers;
2949   while (*s) { if (*s == '_') *s = '-'; s++; }
2950   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2951   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
2952     {
2953     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2954     return FALSE;
2955     }
2956   }
2957
2958 #ifdef SUPPORT_DANE
2959 if (conn_args->dane)
2960   {
2961   SSL_CTX_set_verify(exim_client_ctx->ctx,
2962     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2963     verify_callback_client_dane);
2964
2965   if (!DANESSL_library_init())
2966     {
2967     tls_error(US"library init", host, NULL, errstr);
2968     return FALSE;
2969     }
2970   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
2971     {
2972     tls_error(US"context init", host, NULL, errstr);
2973     return FALSE;
2974     }
2975   }
2976 else
2977
2978 #endif
2979
2980   if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
2981         client_static_cbinfo, errstr) != OK)
2982     return FALSE;
2983
2984 #ifdef EXPERIMENTAL_TLS_RESUME
2985 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
2986 #endif
2987
2988
2989 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
2990   {
2991   tls_error(US"SSL_new", host, NULL, errstr);
2992   return FALSE;
2993   }
2994 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
2995
2996 #ifdef EXPERIMENTAL_TLS_RESUME
2997 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
2998       errstr))
2999   return FALSE;
3000 #endif
3001
3002 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3003 SSL_set_connect_state(exim_client_ctx->ssl);
3004
3005 if (ob->tls_sni)
3006   {
3007   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3008     return FALSE;
3009   if (!tlsp->sni)
3010     {
3011     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3012     }
3013   else if (!Ustrlen(tlsp->sni))
3014     tlsp->sni = NULL;
3015   else
3016     {
3017 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3018     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3019     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3020 #else
3021     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3022           tlsp->sni);
3023 #endif
3024     }
3025   }
3026
3027 #ifdef SUPPORT_DANE
3028 if (conn_args->dane)
3029   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3030     return FALSE;
3031 #endif
3032
3033 #ifndef DISABLE_OCSP
3034 /* Request certificate status at connection-time.  If the server
3035 does OCSP stapling we will get the callback (set in tls_init()) */
3036 # ifdef SUPPORT_DANE
3037 if (request_ocsp)
3038   {
3039   const uschar * s;
3040   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3041      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3042      )
3043     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3044         this means we avoid the OCSP request, we wasted the setup
3045         cost in tls_init(). */
3046     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3047     request_ocsp = require_ocsp
3048       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3049     }
3050   }
3051 # endif
3052
3053 if (request_ocsp)
3054   {
3055   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3056   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
3057   tlsp->ocsp = OCSP_NOT_RESP;
3058   }
3059 #endif
3060
3061 #ifndef DISABLE_EVENT
3062 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
3063 #endif
3064
3065 /* There doesn't seem to be a built-in timeout on connection. */
3066
3067 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3068 sigalrm_seen = FALSE;
3069 ALARM(ob->command_timeout);
3070 rc = SSL_connect(exim_client_ctx->ssl);
3071 ALARM_CLR(0);
3072
3073 #ifdef SUPPORT_DANE
3074 if (conn_args->dane)
3075   DANESSL_cleanup(exim_client_ctx->ssl);
3076 #endif
3077
3078 if (rc <= 0)
3079   {
3080   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3081   return FALSE;
3082   }
3083
3084 DEBUG(D_tls)
3085   {
3086   debug_printf("SSL_connect succeeded\n");
3087 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3088   {
3089   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3090   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3091   BIO_free(bp);
3092   }
3093 #endif
3094   }
3095
3096 #ifdef EXPERIMENTAL_TLS_RESUME
3097 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3098 #endif
3099
3100 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3101
3102 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, &tlsp->bits);
3103 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3104
3105 /* Record the certificate we presented */
3106   {
3107   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3108   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3109   }
3110
3111 tlsp->active.sock = cctx->sock;
3112 tlsp->active.tls_ctx = exim_client_ctx;
3113 cctx->tls_ctx = exim_client_ctx;
3114 return TRUE;
3115 }
3116
3117
3118
3119
3120
3121 static BOOL
3122 tls_refill(unsigned lim)
3123 {
3124 int error;
3125 int inbytes;
3126
3127 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
3128   ssl_xfer_buffer, ssl_xfer_buffer_size);
3129
3130 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3131 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
3132                   MIN(ssl_xfer_buffer_size, lim));
3133 error = SSL_get_error(server_ssl, inbytes);
3134 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3135
3136 if (had_command_timeout)                /* set by signal handler */
3137   smtp_command_timeout_exit();          /* does not return */
3138 if (had_command_sigterm)
3139   smtp_command_sigterm_exit();
3140 if (had_data_timeout)
3141   smtp_data_timeout_exit();
3142 if (had_data_sigint)
3143   smtp_data_sigint_exit();
3144
3145 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3146 closed down, not that the socket itself has been closed down. Revert to
3147 non-SSL handling. */
3148
3149 switch(error)
3150   {
3151   case SSL_ERROR_NONE:
3152     break;
3153
3154   case SSL_ERROR_ZERO_RETURN:
3155     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3156
3157     receive_getc = smtp_getc;
3158     receive_getbuf = smtp_getbuf;
3159     receive_get_cache = smtp_get_cache;
3160     receive_ungetc = smtp_ungetc;
3161     receive_feof = smtp_feof;
3162     receive_ferror = smtp_ferror;
3163     receive_smtp_buffered = smtp_buffered;
3164
3165     if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
3166           SSL_shutdown(server_ssl);
3167
3168 #ifndef DISABLE_OCSP
3169     sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3170     server_static_cbinfo->verify_stack = NULL;
3171 #endif
3172     SSL_free(server_ssl);
3173     SSL_CTX_free(server_ctx);
3174     server_ctx = NULL;
3175     server_ssl = NULL;
3176     tls_in.active.sock = -1;
3177     tls_in.active.tls_ctx = NULL;
3178     tls_in.bits = 0;
3179     tls_in.cipher = NULL;
3180     tls_in.peerdn = NULL;
3181     tls_in.sni = NULL;
3182
3183     return FALSE;
3184
3185   /* Handle genuine errors */
3186   case SSL_ERROR_SSL:
3187     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3188     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3189     ssl_xfer_error = TRUE;
3190     return FALSE;
3191
3192   default:
3193     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3194     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3195       debug_printf(" - syscall %s\n", strerror(errno));
3196     ssl_xfer_error = TRUE;
3197     return FALSE;
3198   }
3199
3200 #ifndef DISABLE_DKIM
3201 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3202 #endif
3203 ssl_xfer_buffer_hwm = inbytes;
3204 ssl_xfer_buffer_lwm = 0;
3205 return TRUE;
3206 }
3207
3208
3209 /*************************************************
3210 *            TLS version of getc                 *
3211 *************************************************/
3212
3213 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3214 it refills the buffer via the SSL reading function.
3215
3216 Arguments:  lim         Maximum amount to read/buffer
3217 Returns:    the next character or EOF
3218
3219 Only used by the server-side TLS.
3220 */
3221
3222 int
3223 tls_getc(unsigned lim)
3224 {
3225 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3226   if (!tls_refill(lim))
3227     return ssl_xfer_error ? EOF : smtp_getc(lim);
3228
3229 /* Something in the buffer; return next uschar */
3230
3231 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3232 }
3233
3234 uschar *
3235 tls_getbuf(unsigned * len)
3236 {
3237 unsigned size;
3238 uschar * buf;
3239
3240 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3241   if (!tls_refill(*len))
3242     {
3243     if (!ssl_xfer_error) return smtp_getbuf(len);
3244     *len = 0;
3245     return NULL;
3246     }
3247
3248 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3249   size = *len;
3250 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3251 ssl_xfer_buffer_lwm += size;
3252 *len = size;
3253 return buf;
3254 }
3255
3256
3257 void
3258 tls_get_cache()
3259 {
3260 #ifndef DISABLE_DKIM
3261 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3262 if (n > 0)
3263   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3264 #endif
3265 }
3266
3267
3268 BOOL
3269 tls_could_read(void)
3270 {
3271 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
3272 }
3273
3274
3275 /*************************************************
3276 *          Read bytes from TLS channel           *
3277 *************************************************/
3278
3279 /*
3280 Arguments:
3281   ct_ctx    client context pointer, or NULL for the one global server context
3282   buff      buffer of data
3283   len       size of buffer
3284
3285 Returns:    the number of bytes read
3286             -1 after a failed read, including EOF
3287
3288 Only used by the client-side TLS.
3289 */
3290
3291 int
3292 tls_read(void * ct_ctx, uschar *buff, size_t len)
3293 {
3294 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3295 int inbytes;
3296 int error;
3297
3298 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3299   buff, (unsigned int)len);
3300
3301 inbytes = SSL_read(ssl, CS buff, len);
3302 error = SSL_get_error(ssl, inbytes);
3303
3304 if (error == SSL_ERROR_ZERO_RETURN)
3305   {
3306   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3307   return -1;
3308   }
3309 else if (error != SSL_ERROR_NONE)
3310   return -1;
3311
3312 return inbytes;
3313 }
3314
3315
3316
3317
3318
3319 /*************************************************
3320 *         Write bytes down TLS channel           *
3321 *************************************************/
3322
3323 /*
3324 Arguments:
3325   ct_ctx    client context pointer, or NULL for the one global server context
3326   buff      buffer of data
3327   len       number of bytes
3328   more      further data expected soon
3329
3330 Returns:    the number of bytes after a successful write,
3331             -1 after a failed write
3332
3333 Used by both server-side and client-side TLS.
3334 */
3335
3336 int
3337 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
3338 {
3339 size_t olen = len;
3340 int outbytes, error;
3341 SSL * ssl = ct_ctx
3342   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3343 static gstring * server_corked = NULL;
3344 gstring ** corkedp = ct_ctx
3345   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
3346 gstring * corked = *corkedp;
3347
3348 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
3349   buff, (unsigned long)len, more ? ", more" : "");
3350
3351 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
3352 "more" is notified.  This hack is only ok if small amounts are involved AND only
3353 one stream does it, in one context (i.e. no store reset).  Currently it is used
3354 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
3355 We support callouts done by the server process by using a separate client
3356 context for the stashed information. */
3357 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
3358 a store reset there, so use POOL_PERM. */
3359 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
3360
3361 if ((more || corked))
3362   {
3363 #ifdef EXPERIMENTAL_PIPE_CONNECT
3364   int save_pool = store_pool;
3365   store_pool = POOL_PERM;
3366 #endif
3367
3368   corked = string_catn(corked, buff, len);
3369
3370 #ifdef EXPERIMENTAL_PIPE_CONNECT
3371   store_pool = save_pool;
3372 #endif
3373
3374   if (more)
3375     {
3376     *corkedp = corked;
3377     return len;
3378     }
3379   buff = CUS corked->s;
3380   len = corked->ptr;
3381   *corkedp = NULL;
3382   }
3383
3384 for (int left = len; left > 0;)
3385   {
3386   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
3387   outbytes = SSL_write(ssl, CS buff, left);
3388   error = SSL_get_error(ssl, outbytes);
3389   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
3390   switch (error)
3391     {
3392     case SSL_ERROR_SSL:
3393       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3394       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
3395       return -1;
3396
3397     case SSL_ERROR_NONE:
3398       left -= outbytes;
3399       buff += outbytes;
3400       break;
3401
3402     case SSL_ERROR_ZERO_RETURN:
3403       log_write(0, LOG_MAIN, "SSL channel closed on write");
3404       return -1;
3405
3406     case SSL_ERROR_SYSCALL:
3407       log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
3408         sender_fullhost ? sender_fullhost : US"<unknown>",
3409         strerror(errno));
3410       return -1;
3411
3412     default:
3413       log_write(0, LOG_MAIN, "SSL_write error %d", error);
3414       return -1;
3415     }
3416   }
3417 return olen;
3418 }
3419
3420
3421
3422 /*************************************************
3423 *         Close down a TLS session               *
3424 *************************************************/
3425
3426 /* This is also called from within a delivery subprocess forked from the
3427 daemon, to shut down the TLS library, without actually doing a shutdown (which
3428 would tamper with the SSL session in the parent process).
3429
3430 Arguments:
3431   ct_ctx        client TLS context pointer, or NULL for the one global server context
3432   shutdown      1 if TLS close-alert is to be sent,
3433                 2 if also response to be waited for
3434
3435 Returns:     nothing
3436
3437 Used by both server-side and client-side TLS.
3438 */
3439
3440 void
3441 tls_close(void * ct_ctx, int shutdown)
3442 {
3443 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
3444 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3445 SSL **sslp =     o_ctx ? &o_ctx->ssl : &server_ssl;
3446 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3447
3448 if (*fdp < 0) return;  /* TLS was not active */
3449
3450 if (shutdown)
3451   {
3452   int rc;
3453   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3454     shutdown > 1 ? " (with response-wait)" : "");
3455
3456   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3457      && shutdown > 1)
3458     {
3459     ALARM(2);
3460     rc = SSL_shutdown(*sslp);           /* wait for response */
3461     ALARM_CLR(0);
3462     }
3463
3464   if (rc < 0) DEBUG(D_tls)
3465     {
3466     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3467     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3468     }
3469   }
3470
3471 #ifndef DISABLE_OCSP
3472 if (!o_ctx)             /* server side */
3473   {
3474   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3475   server_static_cbinfo->verify_stack = NULL;
3476   }
3477 #endif
3478
3479 SSL_CTX_free(*ctxp);
3480 SSL_free(*sslp);
3481 *ctxp = NULL;
3482 *sslp = NULL;
3483 *fdp = -1;
3484 }
3485
3486
3487
3488
3489 /*************************************************
3490 *  Let tls_require_ciphers be checked at startup *
3491 *************************************************/
3492
3493 /* The tls_require_ciphers option, if set, must be something which the
3494 library can parse.
3495
3496 Returns:     NULL on success, or error message
3497 */
3498
3499 uschar *
3500 tls_validate_require_cipher(void)
3501 {
3502 SSL_CTX *ctx;
3503 uschar *s, *expciphers, *err;
3504
3505 /* this duplicates from tls_init(), we need a better "init just global
3506 state, for no specific purpose" singleton function of our own */
3507
3508 #ifdef EXIM_NEED_OPENSSL_INIT
3509 SSL_load_error_strings();
3510 OpenSSL_add_ssl_algorithms();
3511 #endif
3512 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
3513 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
3514 list of available digests. */
3515 EVP_add_digest(EVP_sha256());
3516 #endif
3517
3518 if (!(tls_require_ciphers && *tls_require_ciphers))
3519   return NULL;
3520
3521 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3522                   &err))
3523   return US"failed to expand tls_require_ciphers";
3524
3525 if (!(expciphers && *expciphers))
3526   return NULL;
3527
3528 /* normalisation ripped from above */
3529 s = expciphers;
3530 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3531
3532 err = NULL;
3533
3534 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3535 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3536 #else
3537 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3538 #endif
3539   {
3540   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3541   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3542   }
3543
3544 DEBUG(D_tls)
3545   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3546
3547 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3548   {
3549   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3550   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3551                       expciphers, ssl_errstring);
3552   }
3553
3554 SSL_CTX_free(ctx);
3555
3556 return err;
3557 }
3558
3559
3560
3561
3562 /*************************************************
3563 *         Report the library versions.           *
3564 *************************************************/
3565
3566 /* There have historically been some issues with binary compatibility in
3567 OpenSSL libraries; if Exim (like many other applications) is built against
3568 one version of OpenSSL but the run-time linker picks up another version,
3569 it can result in serious failures, including crashing with a SIGSEGV.  So
3570 report the version found by the compiler and the run-time version.
3571
3572 Note: some OS vendors backport security fixes without changing the version
3573 number/string, and the version date remains unchanged.  The _build_ date
3574 will change, so we can more usefully assist with version diagnosis by also
3575 reporting the build date.
3576
3577 Arguments:   a FILE* to print the results to
3578 Returns:     nothing
3579 */
3580
3581 void
3582 tls_version_report(FILE *f)
3583 {
3584 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3585            "                          Runtime: %s\n"
3586            "                                 : %s\n",
3587            OPENSSL_VERSION_TEXT,
3588            SSLeay_version(SSLEAY_VERSION),
3589            SSLeay_version(SSLEAY_BUILT_ON));
3590 /* third line is 38 characters for the %s and the line is 73 chars long;
3591 the OpenSSL output includes a "built on: " prefix already. */
3592 }
3593
3594
3595
3596
3597 /*************************************************
3598 *            Random number generation            *
3599 *************************************************/
3600
3601 /* Pseudo-random number generation.  The result is not expected to be
3602 cryptographically strong but not so weak that someone will shoot themselves
3603 in the foot using it as a nonce in input in some email header scheme or
3604 whatever weirdness they'll twist this into.  The result should handle fork()
3605 and avoid repeating sequences.  OpenSSL handles that for us.
3606
3607 Arguments:
3608   max       range maximum
3609 Returns     a random number in range [0, max-1]
3610 */
3611
3612 int
3613 vaguely_random_number(int max)
3614 {
3615 unsigned int r;
3616 int i, needed_len;
3617 static pid_t pidlast = 0;
3618 pid_t pidnow;
3619 uschar smallbuf[sizeof(r)];
3620
3621 if (max <= 1)
3622   return 0;
3623
3624 pidnow = getpid();
3625 if (pidnow != pidlast)
3626   {
3627   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3628   is unique for each thread", this doesn't apparently apply across processes,
3629   so our own warning from vaguely_random_number_fallback() applies here too.
3630   Fix per PostgreSQL. */
3631   if (pidlast != 0)
3632     RAND_cleanup();
3633   pidlast = pidnow;
3634   }
3635
3636 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3637 if (!RAND_status())
3638   {
3639   randstuff r;
3640   gettimeofday(&r.tv, NULL);
3641   r.p = getpid();
3642
3643   RAND_seed(US (&r), sizeof(r));
3644   }
3645 /* We're after pseudo-random, not random; if we still don't have enough data
3646 in the internal PRNG then our options are limited.  We could sleep and hope
3647 for entropy to come along (prayer technique) but if the system is so depleted
3648 in the first place then something is likely to just keep taking it.  Instead,
3649 we'll just take whatever little bit of pseudo-random we can still manage to
3650 get. */
3651
3652 needed_len = sizeof(r);
3653 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3654 asked for a number less than 10. */
3655 for (r = max, i = 0; r; ++i)
3656   r >>= 1;
3657 i = (i + 7) / 8;
3658 if (i < needed_len)
3659   needed_len = i;
3660
3661 #ifdef EXIM_HAVE_RAND_PSEUDO
3662 /* We do not care if crypto-strong */
3663 i = RAND_pseudo_bytes(smallbuf, needed_len);
3664 #else
3665 i = RAND_bytes(smallbuf, needed_len);
3666 #endif
3667
3668 if (i < 0)
3669   {
3670   DEBUG(D_all)
3671     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3672   return vaguely_random_number_fallback(max);
3673   }
3674
3675 r = 0;
3676 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3677   r = 256 * r + *p;
3678
3679 /* We don't particularly care about weighted results; if someone wants
3680 smooth distribution and cares enough then they should submit a patch then. */
3681 return r % max;
3682 }
3683
3684
3685
3686
3687 /*************************************************
3688 *        OpenSSL option parse                    *
3689 *************************************************/
3690
3691 /* Parse one option for tls_openssl_options_parse below
3692
3693 Arguments:
3694   name    one option name
3695   value   place to store a value for it
3696 Returns   success or failure in parsing
3697 */
3698
3699
3700
3701 static BOOL
3702 tls_openssl_one_option_parse(uschar *name, long *value)
3703 {
3704 int first = 0;
3705 int last = exim_openssl_options_size;
3706 while (last > first)
3707   {
3708   int middle = (first + last)/2;
3709   int c = Ustrcmp(name, exim_openssl_options[middle].name);
3710   if (c == 0)
3711     {
3712     *value = exim_openssl_options[middle].value;
3713     return TRUE;
3714     }
3715   else if (c > 0)
3716     first = middle + 1;
3717   else
3718     last = middle;
3719   }
3720 return FALSE;
3721 }
3722
3723
3724
3725
3726 /*************************************************
3727 *        OpenSSL option parsing logic            *
3728 *************************************************/
3729
3730 /* OpenSSL has a number of compatibility options which an administrator might
3731 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
3732 we look like log_selector.
3733
3734 Arguments:
3735   option_spec  the administrator-supplied string of options
3736   results      ptr to long storage for the options bitmap
3737 Returns        success or failure
3738 */
3739
3740 BOOL
3741 tls_openssl_options_parse(uschar *option_spec, long *results)
3742 {
3743 long result, item;
3744 uschar *end;
3745 uschar keep_c;
3746 BOOL adding, item_parsed;
3747
3748 /* Server: send no (<= TLS1.2) session tickets */
3749 result = SSL_OP_NO_TICKET;
3750
3751 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3752  * from default because it increases BEAST susceptibility. */
3753 #ifdef SSL_OP_NO_SSLv2
3754 result |= SSL_OP_NO_SSLv2;
3755 #endif
3756 #ifdef SSL_OP_NO_SSLv3
3757 result |= SSL_OP_NO_SSLv3;
3758 #endif
3759 #ifdef SSL_OP_SINGLE_DH_USE
3760 result |= SSL_OP_SINGLE_DH_USE;
3761 #endif
3762
3763 if (!option_spec)
3764   {
3765   *results = result;
3766   return TRUE;
3767   }
3768
3769 for (uschar * s = option_spec; *s; /**/)
3770   {
3771   while (isspace(*s)) ++s;
3772   if (*s == '\0')
3773     break;
3774   if (*s != '+' && *s != '-')
3775     {
3776     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3777         "+ or - expected but found \"%s\"\n", s);
3778     return FALSE;
3779     }
3780   adding = *s++ == '+';
3781   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3782   keep_c = *end;
3783   *end = '\0';
3784   item_parsed = tls_openssl_one_option_parse(s, &item);
3785   *end = keep_c;
3786   if (!item_parsed)
3787     {
3788     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3789     return FALSE;
3790     }
3791   DEBUG(D_tls) debug_printf("openssl option, %s %8lx: %lx (%s)\n",
3792       adding ? "adding to    " : "removing from", result, item, s);
3793   if (adding)
3794     result |= item;
3795   else
3796     result &= ~item;
3797   s = end;
3798   }
3799
3800 *results = result;
3801 return TRUE;
3802 }
3803
3804 #endif  /*!MACRO_PREDEF*/
3805 /* vi: aw ai sw=2
3806 */
3807 /* End of tls-openssl.c */