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