src/src/tls-openssl.c

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