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