src/src/tls-openssl.c

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