src/src/tls-openssl.c

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