src/src/tls-gnu.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2018 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Copyright (c) Phil Pennock 2012 */
   9
  10 /* This file provides TLS/SSL support for Exim using the GnuTLS library,
  11 one of the available supported implementations.  This file is #included into
  12 tls.c when USE_GNUTLS has been set.
  13
  14 The code herein is a revamp of GnuTLS integration using the current APIs; the
  15 original tls-gnu.c was based on a patch which was contributed by Nikos
  16 Mavrogiannopoulos.  The revamp is partially a rewrite, partially cut&paste as
  17 appropriate.
  18
  19 APIs current as of GnuTLS 2.12.18; note that the GnuTLS manual is for GnuTLS 3,
  20 which is not widely deployed by OS vendors.  Will note issues below, which may
  21 assist in updating the code in the future.  Another sources of hints is
  22 mod_gnutls for Apache (SNI callback registration and handling).
  23
  24 Keeping client and server variables more split than before and is currently
  25 the norm, in anticipation of TLS in ACL callouts.
  26
  27 I wanted to switch to gnutls_certificate_set_verify_function() so that
  28 certificate rejection could happen during handshake where it belongs, rather
  29 than being dropped afterwards, but that was introduced in 2.10.0 and Debian
  30 (6.0.5) is still on 2.8.6.  So for now we have to stick with sub-par behaviour.
  31
  32 (I wasn't looking for libraries quite that old, when updating to get rid of
  33 compiler warnings of deprecated APIs.  If it turns out that a lot of the rest
  34 require current GnuTLS, then we'll drop support for the ancient libraries).
  35 */
  36
  37 #include <gnutls/gnutls.h>
  38 /* needed for cert checks in verification and DN extraction: */
  39 #include <gnutls/x509.h>
  40 /* man-page is incorrect, gnutls_rnd() is not in gnutls.h: */
  41 #include <gnutls/crypto.h>
  42
  43 /* needed to disable PKCS11 autoload unless requested */
  44 #if GNUTLS_VERSION_NUMBER >= 0x020c00
  45 # include <gnutls/pkcs11.h>
  46 # define SUPPORT_PARAM_TO_PK_BITS
  47 #endif
  48 #if GNUTLS_VERSION_NUMBER < 0x030103 && !defined(DISABLE_OCSP)
  49 # warning "GnuTLS library version too old; define DISABLE_OCSP in Makefile"
  50 # define DISABLE_OCSP
  51 #endif
  52 #if GNUTLS_VERSION_NUMBER < 0x020a00 && !defined(DISABLE_EVENT)
  53 # warning "GnuTLS library version too old; tls:cert event unsupported"
  54 # define DISABLE_EVENT
  55 #endif
  56 #if GNUTLS_VERSION_NUMBER >= 0x030306
  57 # define SUPPORT_CA_DIR
  58 #else
  59 # undef  SUPPORT_CA_DIR
  60 #endif
  61 #if GNUTLS_VERSION_NUMBER >= 0x030014
  62 # define SUPPORT_SYSDEFAULT_CABUNDLE
  63 #endif
  64 #if GNUTLS_VERSION_NUMBER >= 0x030104
  65 # define GNUTLS_CERT_VFY_STATUS_PRINT
  66 #endif
  67 #if GNUTLS_VERSION_NUMBER >= 0x030109
  68 # define SUPPORT_CORK
  69 #endif
  70 #if GNUTLS_VERSION_NUMBER >= 0x03010a
  71 # define SUPPORT_GNUTLS_SESS_DESC
  72 #endif
  73 #if GNUTLS_VERSION_NUMBER >= 0x030500
  74 # define SUPPORT_GNUTLS_KEYLOG
  75 #endif
  76 #if GNUTLS_VERSION_NUMBER >= 0x030506 && !defined(DISABLE_OCSP)
  77 # define SUPPORT_SRV_OCSP_STACK
  78 #endif
  79 #if GNUTLS_VERSION_NUMBER >= 0x030600
  80 # define GNUTLS_AUTO_DHPARAMS
  81 #endif
  82 #if GNUTLS_VERSION_NUMBER >= 0x030603
  83 # define EXIM_HAVE_TLS1_3
  84 # define SUPPORT_GNUTLS_EXT_RAW_PARSE
  85 # define GNUTLS_OCSP_STATUS_REQUEST_GET2
  86 #endif
  87
  88 #ifdef SUPPORT_DANE
  89 # if GNUTLS_VERSION_NUMBER >= 0x030000
  90 #  define DANESSL_USAGE_DANE_TA 2
  91 #  define DANESSL_USAGE_DANE_EE 3
  92 # else
  93 #  error GnuTLS version too early for DANE
  94 # endif
  95 # if GNUTLS_VERSION_NUMBER < 0x999999
  96 #  define GNUTLS_BROKEN_DANE_VALIDATION
  97 # endif
  98 #endif
  99
 100 #ifdef EXPERIMENTAL_TLS_RESUME
 101 # if GNUTLS_VERSION_NUMBER < 0x030603
 102 #  error GNUTLS version too early for session-resumption
 103 # endif
 104 #endif
 105
 106 #ifndef DISABLE_OCSP
 107 # include <gnutls/ocsp.h>
 108 #endif
 109 #ifdef SUPPORT_DANE
 110 # include <gnutls/dane.h>
 111 #endif
 112
 113 #include "tls-cipher-stdname.c"
 114
 115
 116 #ifdef MACRO_PREDEF
 117 void
 118 options_tls(void)
 119 {
 120 # ifdef EXPERIMENTAL_TLS_RESUME
 121 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
 122 # endif
 123 # ifdef EXIM_HAVE_TLS1_3
 124 builtin_macro_create(US"_HAVE_TLS1_3");
 125 # endif
 126 }
 127 #else
 128
 129
 130 /* GnuTLS 2 vs 3
 131
 132 GnuTLS 3 only:
 133   gnutls_global_set_audit_log_function()
 134
 135 Changes:
 136   gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
 137 */
 138
 139 /* Local static variables for GnuTLS */
 140
 141 /* Values for verify_requirement */
 142
 143 enum peer_verify_requirement
 144   { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED, VERIFY_DANE };
 145
 146 /* This holds most state for server or client; with this, we can set up an
 147 outbound TLS-enabled connection in an ACL callout, while not stomping all
 148 over the TLS variables available for expansion.
 149
 150 Some of these correspond to variables in globals.c; those variables will
 151 be set to point to content in one of these instances, as appropriate for
 152 the stage of the process lifetime.
 153
 154 Not handled here: global tls_channelbinding_b64.
 155 */
 156
 157 typedef struct exim_gnutls_state {
 158   gnutls_session_t      session;
 159   gnutls_certificate_credentials_t x509_cred;
 160   gnutls_priority_t     priority_cache;
 161   enum peer_verify_requirement verify_requirement;
 162   int                   fd_in;
 163   int                   fd_out;
 164   BOOL                  peer_cert_verified;
 165   BOOL                  peer_dane_verified;
 166   BOOL                  trigger_sni_changes;
 167   BOOL                  have_set_peerdn;
 168   const struct host_item *host;         /* NULL if server */
 169   gnutls_x509_crt_t     peercert;
 170   uschar                *peerdn;
 171   uschar                *ciphersuite;
 172   uschar                *received_sni;
 173
 174   const uschar *tls_certificate;
 175   const uschar *tls_privatekey;
 176   const uschar *tls_sni; /* client send only, not received */
 177   const uschar *tls_verify_certificates;
 178   const uschar *tls_crl;
 179   const uschar *tls_require_ciphers;
 180
 181   uschar *exp_tls_certificate;
 182   uschar *exp_tls_privatekey;
 183   uschar *exp_tls_verify_certificates;
 184   uschar *exp_tls_crl;
 185   uschar *exp_tls_require_ciphers;
 186   const uschar *exp_tls_verify_cert_hostnames;
 187 #ifndef DISABLE_EVENT
 188   uschar *event_action;
 189 #endif
 190 #ifdef SUPPORT_DANE
 191   char * const *        dane_data;
 192   const int *           dane_data_len;
 193 #endif
 194
 195   tls_support *tlsp;    /* set in tls_init() */
 196
 197   uschar *xfer_buffer;
 198   int xfer_buffer_lwm;
 199   int xfer_buffer_hwm;
 200   BOOL xfer_eof;        /*XXX never gets set! */
 201   BOOL xfer_error;
 202 } exim_gnutls_state_st;
 203
 204 static const exim_gnutls_state_st exim_gnutls_state_init = {
 205   /* all elements not explicitly intialised here get 0/NULL/FALSE */
 206   .fd_in =              -1,
 207   .fd_out =             -1,
 208 };
 209
 210 /* Not only do we have our own APIs which don't pass around state, assuming
 211 it's held in globals, GnuTLS doesn't appear to let us register callback data
 212 for callbacks, or as part of the session, so we have to keep a "this is the
 213 context we're currently dealing with" pointer and rely upon being
 214 single-threaded to keep from processing data on an inbound TLS connection while
 215 talking to another TLS connection for an outbound check.  This does mean that
 216 there's no way for heart-beats to be responded to, for the duration of the
 217 second connection.
 218 XXX But see gnutls_session_get_ptr()
 219 */
 220
 221 static exim_gnutls_state_st state_server;
 222
 223 #ifndef GNUTLS_AUTO_DHPARAMS
 224 /* dh_params are initialised once within the lifetime of a process using TLS;
 225 if we used TLS in a long-lived daemon, we'd have to reconsider this.  But we
 226 don't want to repeat this. */
 227
 228 static gnutls_dh_params_t dh_server_params = NULL;
 229 #endif
 230
 231 static int ssl_session_timeout = 7200;  /* Two hours */
 232
 233 static const uschar * const exim_default_gnutls_priority = US"NORMAL";
 234
 235 /* Guard library core initialisation */
 236
 237 static BOOL exim_gnutls_base_init_done = FALSE;
 238
 239 #ifndef DISABLE_OCSP
 240 static BOOL gnutls_buggy_ocsp = FALSE;
 241 static BOOL exim_testharness_disable_ocsp_validity_check = FALSE;
 242 #endif
 243
 244 #ifdef EXPERIMENTAL_TLS_RESUME
 245 static gnutls_datum_t server_sessticket_key;
 246 #endif
 247
 248 /* ------------------------------------------------------------------------ */
 249 /* macros */
 250
 251 #define MAX_HOST_LEN 255
 252
 253 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
 254 the library logging; a value less than 0 disables the calls to set up logging
 255 callbacks.  GNuTLS also looks for an environment variable - except not for
 256 setuid binaries, making it useless - "GNUTLS_DEBUG_LEVEL".
 257 Allegedly the testscript line "GNUTLS_DEBUG_LEVEL=9 sudo exim ..." would work,
 258 but the env var must be added to /etc/sudoers too. */
 259 #ifndef EXIM_GNUTLS_LIBRARY_LOG_LEVEL
 260 # define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
 261 #endif
 262
 263 #ifndef EXIM_CLIENT_DH_MIN_BITS
 264 # define EXIM_CLIENT_DH_MIN_BITS 1024
 265 #endif
 266
 267 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
 268 can ask for a bit-strength.  Without that, we stick to the constant we had
 269 before, for now. */
 270 #ifndef EXIM_SERVER_DH_BITS_PRE2_12
 271 # define EXIM_SERVER_DH_BITS_PRE2_12 1024
 272 #endif
 273
 274 #define expand_check_tlsvar(Varname, errstr) \
 275   expand_check(state->Varname, US #Varname, &state->exp_##Varname, errstr)
 276
 277 #if GNUTLS_VERSION_NUMBER >= 0x020c00
 278 # define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
 279 # define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
 280 # define HAVE_GNUTLS_RND
 281 /* The security fix we provide with the gnutls_allow_auto_pkcs11 option
 282  * (4.82 PP/09) introduces a compatibility regression. The symbol simply
 283  * isn't available sometimes, so this needs to become a conditional
 284  * compilation; the sanest way to deal with this being a problem on
 285  * older OSes is to block it in the Local/Makefile with this compiler
 286  * definition  */
 287 # ifndef AVOID_GNUTLS_PKCS11
 288 #  define HAVE_GNUTLS_PKCS11
 289 # endif /* AVOID_GNUTLS_PKCS11 */
 290 #endif
 291
 292
 293
 294
 295 /* ------------------------------------------------------------------------ */
 296 /* Callback declarations */
 297
 298 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
 299 static void exim_gnutls_logger_cb(int level, const char *message);
 300 #endif
 301
 302 static int exim_sni_handling_cb(gnutls_session_t session);
 303
 304 #ifdef EXPERIMENTAL_TLS_RESUME
 305 static int
 306 tls_server_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
 307   unsigned incoming, const gnutls_datum_t * msg);
 308 #endif
 309
 310
 311 /* Daemon one-time initialisation */
 312 void
 313 tls_daemon_init(void)
 314 {
 315 #ifdef EXPERIMENTAL_TLS_RESUME
 316 /* We are dependent on the GnuTLS implementation of the Session Ticket
 317 encryption; both the strength and the key rotation period.  We hope that
 318 the strength at least matches that of the ciphersuite (but GnuTLS does not
 319 document this). */
 320
 321 static BOOL once = FALSE;
 322 if (once) return;
 323 once = TRUE;
 324 gnutls_session_ticket_key_generate(&server_sessticket_key);     /* >= 2.10.0 */
 325 if (f.running_in_test_harness) ssl_session_timeout = 6;
 326 #endif
 327 }
 328
 329 /* ------------------------------------------------------------------------ */
 330 /* Static functions */
 331
 332 /*************************************************
 333 *               Handle TLS error                 *
 334 *************************************************/
 335
 336 /* Called from lots of places when errors occur before actually starting to do
 337 the TLS handshake, that is, while the session is still in clear. Always returns
 338 DEFER for a server and FAIL for a client so that most calls can use "return
 339 tls_error(...)" to do this processing and then give an appropriate return. A
 340 single function is used for both server and client, because it is called from
 341 some shared functions.
 342
 343 Argument:
 344   prefix    text to include in the logged error
 345   msg       additional error string (may be NULL)
 346             usually obtained from gnutls_strerror()
 347   host      NULL if setting up a server;
 348             the connected host if setting up a client
 349   errstr    pointer to returned error string
 350
 351 Returns:    OK/DEFER/FAIL
 352 */
 353
 354 static int
 355 tls_error(const uschar *prefix, const uschar *msg, const host_item *host,
 356   uschar ** errstr)
 357 {
 358 if (errstr)
 359   *errstr = string_sprintf("(%s)%s%s", prefix, msg ? ": " : "", msg ? msg : US"");
 360 return host ? FAIL : DEFER;
 361 }
 362
 363
 364 static int
 365 tls_error_gnu(const uschar *prefix, int err, const host_item *host,
 366   uschar ** errstr)
 367 {
 368 return tls_error(prefix, US gnutls_strerror(err), host, errstr);
 369 }
 370
 371 static int
 372 tls_error_sys(const uschar *prefix, int err, const host_item *host,
 373   uschar ** errstr)
 374 {
 375 return tls_error(prefix, US strerror(err), host, errstr);
 376 }
 377
 378
 379 /*************************************************
 380 *    Deal with logging errors during I/O         *
 381 *************************************************/
 382
 383 /* We have to get the identity of the peer from saved data.
 384
 385 Argument:
 386   state    the current GnuTLS exim state container
 387   rc       the GnuTLS error code, or 0 if it's a local error
 388   when     text identifying read or write
 389   text     local error text when rc is 0
 390
 391 Returns:   nothing
 392 */
 393
 394 static void
 395 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
 396 {
 397 const uschar * msg;
 398 uschar * errstr;
 399
 400 if (rc == GNUTLS_E_FATAL_ALERT_RECEIVED)
 401   msg = string_sprintf("A TLS fatal alert has been received: %s",
 402     US gnutls_alert_get_name(gnutls_alert_get(state->session)));
 403 else
 404   msg = US gnutls_strerror(rc);
 405
 406 (void) tls_error(when, msg, state->host, &errstr);
 407
 408 if (state->host)
 409   log_write(0, LOG_MAIN, "H=%s [%s] TLS error on connection %s",
 410     state->host->name, state->host->address, errstr);
 411 else
 412   {
 413   uschar * conn_info = smtp_get_connection_info();
 414   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0) conn_info += 5;
 415   /* I'd like to get separated H= here, but too hard for now */
 416   log_write(0, LOG_MAIN, "TLS error on %s %s", conn_info, errstr);
 417   }
 418 }
 419
 420
 421
 422
 423 /*************************************************
 424 *        Set various Exim expansion vars         *
 425 *************************************************/
 426
 427 #define exim_gnutls_cert_err(Label) \
 428   do \
 429     { \
 430     if (rc != GNUTLS_E_SUCCESS) \
 431       { \
 432       DEBUG(D_tls) debug_printf("TLS: cert problem: %s: %s\n", \
 433         (Label), gnutls_strerror(rc)); \
 434       return rc; \
 435       } \
 436     } while (0)
 437
 438 static int
 439 import_cert(const gnutls_datum_t * cert, gnutls_x509_crt_t * crtp)
 440 {
 441 int rc;
 442
 443 rc = gnutls_x509_crt_init(crtp);
 444 exim_gnutls_cert_err(US"gnutls_x509_crt_init (crt)");
 445
 446 rc = gnutls_x509_crt_import(*crtp, cert, GNUTLS_X509_FMT_DER);
 447 exim_gnutls_cert_err(US"failed to import certificate [gnutls_x509_crt_import(cert)]");
 448
 449 return rc;
 450 }
 451
 452 #undef exim_gnutls_cert_err
 453
 454
 455 /* We set various Exim global variables from the state, once a session has
 456 been established.  With TLS callouts, may need to change this to stack
 457 variables, or just re-call it with the server state after client callout
 458 has finished.
 459
 460 Make sure anything set here is unset in tls_getc().
 461
 462 Sets:
 463   tls_active                fd
 464   tls_bits                  strength indicator
 465   tls_certificate_verified  bool indicator
 466   tls_channelbinding_b64    for some SASL mechanisms
 467   tls_cipher                a string
 468   tls_peercert              pointer to library internal
 469   tls_peerdn                a string
 470   tls_sni                   a (UTF-8) string
 471   tls_ourcert               pointer to library internal
 472
 473 Argument:
 474   state      the relevant exim_gnutls_state_st *
 475 */
 476
 477 static void
 478 extract_exim_vars_from_tls_state(exim_gnutls_state_st * state)
 479 {
 480 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
 481 int old_pool;
 482 int rc;
 483 gnutls_datum_t channel;
 484 #endif
 485 tls_support * tlsp = state->tlsp;
 486
 487 tlsp->active.sock = state->fd_out;
 488 tlsp->active.tls_ctx = state;
 489
 490 DEBUG(D_tls) debug_printf("cipher: %s\n", state->ciphersuite);
 491
 492 tlsp->certificate_verified = state->peer_cert_verified;
 493 #ifdef SUPPORT_DANE
 494 tlsp->dane_verified = state->peer_dane_verified;
 495 #endif
 496
 497 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
 498 only available for use for authenticators while this TLS session is running. */
 499
 500 tls_channelbinding_b64 = NULL;
 501 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
 502 channel.data = NULL;
 503 channel.size = 0;
 504 if ((rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel)))
 505   { DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc)); }
 506 else
 507   {
 508   old_pool = store_pool;
 509   store_pool = POOL_PERM;
 510   tls_channelbinding_b64 = b64encode(CUS channel.data, (int)channel.size);
 511   store_pool = old_pool;
 512   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage.\n");
 513   }
 514 #endif
 515
 516 /* peercert is set in peer_status() */
 517 tlsp->peerdn = state->peerdn;
 518 tlsp->sni =    state->received_sni;
 519
 520 /* record our certificate */
 521   {
 522   const gnutls_datum_t * cert = gnutls_certificate_get_ours(state->session);
 523   gnutls_x509_crt_t crt;
 524
 525   tlsp->ourcert = cert && import_cert(cert, &crt)==0 ? crt : NULL;
 526   }
 527 }
 528
 529
 530
 531
 532 #ifndef GNUTLS_AUTO_DHPARAMS
 533 /*************************************************
 534 *            Setup up DH parameters              *
 535 *************************************************/
 536
 537 /* Generating the D-H parameters may take a long time. They only need to
 538 be re-generated every so often, depending on security policy. What we do is to
 539 keep these parameters in a file in the spool directory. If the file does not
 540 exist, we generate them. This means that it is easy to cause a regeneration.
 541
 542 The new file is written as a temporary file and renamed, so that an incomplete
 543 file is never present. If two processes both compute some new parameters, you
 544 waste a bit of effort, but it doesn't seem worth messing around with locking to
 545 prevent this.
 546
 547 Returns:     OK/DEFER/FAIL
 548 */
 549
 550 static int
 551 init_server_dh(uschar ** errstr)
 552 {
 553 int fd, rc;
 554 unsigned int dh_bits;
 555 gnutls_datum_t m = {.data = NULL, .size = 0};
 556 uschar filename_buf[PATH_MAX];
 557 uschar *filename = NULL;
 558 size_t sz;
 559 uschar *exp_tls_dhparam;
 560 BOOL use_file_in_spool = FALSE;
 561 host_item *host = NULL; /* dummy for macros */
 562
 563 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params.\n");
 564
 565 if ((rc = gnutls_dh_params_init(&dh_server_params)))
 566   return tls_error_gnu(US"gnutls_dh_params_init", rc, host, errstr);
 567
 568 if (!expand_check(tls_dhparam, US"tls_dhparam", &exp_tls_dhparam, errstr))
 569   return DEFER;
 570
 571 if (!exp_tls_dhparam)
 572   {
 573   DEBUG(D_tls) debug_printf("Loading default hard-coded DH params\n");
 574   m.data = US std_dh_prime_default();
 575   m.size = Ustrlen(m.data);
 576   }
 577 else if (Ustrcmp(exp_tls_dhparam, "historic") == 0)
 578   use_file_in_spool = TRUE;
 579 else if (Ustrcmp(exp_tls_dhparam, "none") == 0)
 580   {
 581   DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
 582   return OK;
 583   }
 584 else if (exp_tls_dhparam[0] != '/')
 585   {
 586   if (!(m.data = US std_dh_prime_named(exp_tls_dhparam)))
 587     return tls_error(US"No standard prime named", exp_tls_dhparam, NULL, errstr);
 588   m.size = Ustrlen(m.data);
 589   }
 590 else
 591   filename = exp_tls_dhparam;
 592
 593 if (m.data)
 594   {
 595   if ((rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM)))
 596     return tls_error_gnu(US"gnutls_dh_params_import_pkcs3", rc, host, errstr);
 597   DEBUG(D_tls) debug_printf("Loaded fixed standard D-H parameters\n");
 598   return OK;
 599   }
 600
 601 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
 602 /* If you change this constant, also change dh_param_fn_ext so that we can use a
 603 different filename and ensure we have sufficient bits. */
 604
 605 if (!(dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL)))
 606   return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL, errstr);
 607 DEBUG(D_tls)
 608   debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits.\n",
 609       dh_bits);
 610 #else
 611 dh_bits = EXIM_SERVER_DH_BITS_PRE2_12;
 612 DEBUG(D_tls)
 613   debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits.\n",
 614       dh_bits);
 615 #endif
 616
 617 /* Some clients have hard-coded limits. */
 618 if (dh_bits > tls_dh_max_bits)
 619   {
 620   DEBUG(D_tls)
 621     debug_printf("tls_dh_max_bits clamping override, using %d bits instead.\n",
 622         tls_dh_max_bits);
 623   dh_bits = tls_dh_max_bits;
 624   }
 625
 626 if (use_file_in_spool)
 627   {
 628   if (!string_format(filename_buf, sizeof(filename_buf),
 629         "%s/gnutls-params-%d", spool_directory, dh_bits))
 630     return tls_error(US"overlong filename", NULL, NULL, errstr);
 631   filename = filename_buf;
 632   }
 633
 634 /* Open the cache file for reading and if successful, read it and set up the
 635 parameters. */
 636
 637 if ((fd = Uopen(filename, O_RDONLY, 0)) >= 0)
 638   {
 639   struct stat statbuf;
 640   FILE *fp;
 641   int saved_errno;
 642
 643   if (fstat(fd, &statbuf) < 0)  /* EIO */
 644     {
 645     saved_errno = errno;
 646     (void)close(fd);
 647     return tls_error_sys(US"TLS cache stat failed", saved_errno, NULL, errstr);
 648     }
 649   if (!S_ISREG(statbuf.st_mode))
 650     {
 651     (void)close(fd);
 652     return tls_error(US"TLS cache not a file", NULL, NULL, errstr);
 653     }
 654   if (!(fp = fdopen(fd, "rb")))
 655     {
 656     saved_errno = errno;
 657     (void)close(fd);
 658     return tls_error_sys(US"fdopen(TLS cache stat fd) failed",
 659         saved_errno, NULL, errstr);
 660     }
 661
 662   m.size = statbuf.st_size;
 663   if (!(m.data = store_malloc(m.size)))
 664     {
 665     fclose(fp);
 666     return tls_error_sys(US"malloc failed", errno, NULL, errstr);
 667     }
 668   if (!(sz = fread(m.data, m.size, 1, fp)))
 669     {
 670     saved_errno = errno;
 671     fclose(fp);
 672     store_free(m.data);
 673     return tls_error_sys(US"fread failed", saved_errno, NULL, errstr);
 674     }
 675   fclose(fp);
 676
 677   rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
 678   store_free(m.data);
 679   if (rc)
 680     return tls_error_gnu(US"gnutls_dh_params_import_pkcs3", rc, host, errstr);
 681   DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
 682   }
 683
 684 /* If the file does not exist, fall through to compute new data and cache it.
 685 If there was any other opening error, it is serious. */
 686
 687 else if (errno == ENOENT)
 688   {
 689   rc = -1;
 690   DEBUG(D_tls)
 691     debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
 692   }
 693 else
 694   return tls_error(string_open_failed(errno, "\"%s\" for reading", filename),
 695       NULL, NULL, errstr);
 696
 697 /* If ret < 0, either the cache file does not exist, or the data it contains
 698 is not useful. One particular case of this is when upgrading from an older
 699 release of Exim in which the data was stored in a different format. We don't
 700 try to be clever and support both formats; we just regenerate new data in this
 701 case. */
 702
 703 if (rc < 0)
 704   {
 705   uschar *temp_fn;
 706   unsigned int dh_bits_gen = dh_bits;
 707
 708   if ((PATH_MAX - Ustrlen(filename)) < 10)
 709     return tls_error(US"Filename too long to generate replacement",
 710         filename, NULL, errstr);
 711
 712   temp_fn = string_copy(US"%s.XXXXXXX");
 713   if ((fd = mkstemp(CS temp_fn)) < 0)   /* modifies temp_fn */
 714     return tls_error_sys(US"Unable to open temp file", errno, NULL, errstr);
 715   (void)exim_chown(temp_fn, exim_uid, exim_gid);   /* Probably not necessary */
 716
 717   /* GnuTLS overshoots!  If we ask for 2236, we might get 2237 or more.  But
 718   there's no way to ask GnuTLS how many bits there really are.  We can ask
 719   how many bits were used in a TLS session, but that's it!  The prime itself
 720   is hidden behind too much abstraction.  So we ask for less, and proceed on
 721   a wing and a prayer.  First attempt, subtracted 3 for 2233 and got 2240.  */
 722
 723   if (dh_bits >= EXIM_CLIENT_DH_MIN_BITS + 10)
 724     {
 725     dh_bits_gen = dh_bits - 10;
 726     DEBUG(D_tls)
 727       debug_printf("being paranoid about DH generation, make it '%d' bits'\n",
 728           dh_bits_gen);
 729     }
 730
 731   DEBUG(D_tls)
 732     debug_printf("requesting generation of %d bit Diffie-Hellman prime ...\n",
 733         dh_bits_gen);
 734   if ((rc = gnutls_dh_params_generate2(dh_server_params, dh_bits_gen)))
 735     return tls_error_gnu(US"gnutls_dh_params_generate2", rc, host, errstr);
 736
 737   /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
 738   and I confirmed that a NULL call to get the size first is how the GnuTLS
 739   sample apps handle this. */
 740
 741   sz = 0;
 742   m.data = NULL;
 743   if (  (rc = gnutls_dh_params_export_pkcs3(dh_server_params,
 744                 GNUTLS_X509_FMT_PEM, m.data, &sz))
 745      && rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
 746     return tls_error_gnu(US"gnutls_dh_params_export_pkcs3(NULL) sizing",
 747               rc, host, errstr);
 748   m.size = sz;
 749   if (!(m.data = store_malloc(m.size)))
 750     return tls_error_sys(US"memory allocation failed", errno, NULL, errstr);
 751
 752   /* this will return a size 1 less than the allocation size above */
 753   if ((rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
 754       m.data, &sz)))
 755     {
 756     store_free(m.data);
 757     return tls_error_gnu(US"gnutls_dh_params_export_pkcs3() real", rc, host, errstr);
 758     }
 759   m.size = sz; /* shrink by 1, probably */
 760
 761   if ((sz = write_to_fd_buf(fd, m.data, (size_t) m.size)) != m.size)
 762     {
 763     store_free(m.data);
 764     return tls_error_sys(US"TLS cache write D-H params failed",
 765         errno, NULL, errstr);
 766     }
 767   store_free(m.data);
 768   if ((sz = write_to_fd_buf(fd, US"\n", 1)) != 1)
 769     return tls_error_sys(US"TLS cache write D-H params final newline failed",
 770         errno, NULL, errstr);
 771
 772   if ((rc = close(fd)))
 773     return tls_error_sys(US"TLS cache write close() failed", errno, NULL, errstr);
 774
 775   if (Urename(temp_fn, filename) < 0)
 776     return tls_error_sys(string_sprintf("failed to rename \"%s\" as \"%s\"",
 777           temp_fn, filename), errno, NULL, errstr);
 778
 779   DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
 780   }
 781
 782 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
 783 return OK;
 784 }
 785 #endif
 786
 787
 788
 789
 790 /* Create and install a selfsigned certificate, for use in server mode */
 791
 792 static int
 793 tls_install_selfsign(exim_gnutls_state_st * state, uschar ** errstr)
 794 {
 795 gnutls_x509_crt_t cert = NULL;
 796 time_t now;
 797 gnutls_x509_privkey_t pkey = NULL;
 798 const uschar * where;
 799 int rc;
 800
 801 where = US"initialising pkey";
 802 if ((rc = gnutls_x509_privkey_init(&pkey))) goto err;
 803
 804 where = US"initialising cert";
 805 if ((rc = gnutls_x509_crt_init(&cert))) goto err;
 806
 807 where = US"generating pkey";
 808 if ((rc = gnutls_x509_privkey_generate(pkey, GNUTLS_PK_RSA,
 809 #ifdef SUPPORT_PARAM_TO_PK_BITS
 810 # ifndef GNUTLS_SEC_PARAM_MEDIUM
 811 #  define GNUTLS_SEC_PARAM_MEDIUM GNUTLS_SEC_PARAM_HIGH
 812 # endif
 813             gnutls_sec_param_to_pk_bits(GNUTLS_PK_RSA, GNUTLS_SEC_PARAM_MEDIUM),
 814 #else
 815             2048,
 816 #endif
 817             0)))
 818   goto err;
 819
 820 where = US"configuring cert";
 821 now = 1;
 822 if (  (rc = gnutls_x509_crt_set_version(cert, 3))
 823    || (rc = gnutls_x509_crt_set_serial(cert, &now, sizeof(now)))
 824    || (rc = gnutls_x509_crt_set_activation_time(cert, now = time(NULL)))
 825    || (rc = gnutls_x509_crt_set_expiration_time(cert, now + 60 * 60)) /* 1 hr */
 826    || (rc = gnutls_x509_crt_set_key(cert, pkey))
 827
 828    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
 829               GNUTLS_OID_X520_COUNTRY_NAME, 0, "UK", 2))
 830    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
 831               GNUTLS_OID_X520_ORGANIZATION_NAME, 0, "Exim Developers", 15))
 832    || (rc = gnutls_x509_crt_set_dn_by_oid(cert,
 833               GNUTLS_OID_X520_COMMON_NAME, 0,
 834               smtp_active_hostname, Ustrlen(smtp_active_hostname)))
 835    )
 836   goto err;
 837
 838 where = US"signing cert";
 839 if ((rc = gnutls_x509_crt_sign(cert, cert, pkey))) goto err;
 840
 841 where = US"installing selfsign cert";
 842                                         /* Since: 2.4.0 */
 843 if ((rc = gnutls_certificate_set_x509_key(state->x509_cred, &cert, 1, pkey)))
 844   goto err;
 845
 846 rc = OK;
 847
 848 out:
 849   if (cert) gnutls_x509_crt_deinit(cert);
 850   if (pkey) gnutls_x509_privkey_deinit(pkey);
 851   return rc;
 852
 853 err:
 854   rc = tls_error_gnu(where, rc, NULL, errstr);
 855   goto out;
 856 }
 857
 858
 859
 860
 861 /* Add certificate and key, from files.
 862
 863 Return:
 864   Zero or negative: good.  Negate value for certificate index if < 0.
 865   Greater than zero: FAIL or DEFER code.
 866 */
 867
 868 static int
 869 tls_add_certfile(exim_gnutls_state_st * state, const host_item * host,
 870   uschar * certfile, uschar * keyfile, uschar ** errstr)
 871 {
 872 int rc = gnutls_certificate_set_x509_key_file(state->x509_cred,
 873     CS certfile, CS keyfile, GNUTLS_X509_FMT_PEM);
 874 if (rc < 0)
 875   return tls_error_gnu(
 876     string_sprintf("cert/key setup: cert=%s key=%s", certfile, keyfile),
 877     rc, host, errstr);
 878 return -rc;
 879 }
 880
 881
 882 #if !defined(DISABLE_OCSP) && !defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
 883 /* Load an OCSP proof from file for sending by the server.  Called
 884 on getting a status-request handshake message, for earlier versions
 885 of GnuTLS. */
 886
 887 static int
 888 server_ocsp_stapling_cb(gnutls_session_t session, void * ptr,
 889   gnutls_datum_t * ocsp_response)
 890 {
 891 int ret;
 892 DEBUG(D_tls) debug_printf("OCSP stapling callback: %s\n", US ptr);
 893
 894 if ((ret = gnutls_load_file(ptr, ocsp_response)) < 0)
 895   {
 896   DEBUG(D_tls) debug_printf("Failed to load ocsp stapling file %s\n",
 897                               CS ptr);
 898   tls_in.ocsp = OCSP_NOT_RESP;
 899   return GNUTLS_E_NO_CERTIFICATE_STATUS;
 900   }
 901
 902 tls_in.ocsp = OCSP_VFY_NOT_TRIED;
 903 return 0;
 904 }
 905 #endif
 906
 907
 908 #ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
 909 /* Make a note that we saw a status-request */
 910 static int
 911 tls_server_clienthello_ext(void * ctx, unsigned tls_id,
 912   const unsigned char *data, unsigned size)
 913 {
 914 /* https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml */
 915 if (tls_id == 5)        /* status_request */
 916   {
 917   DEBUG(D_tls) debug_printf("Seen status_request extension from client\n");
 918   tls_in.ocsp = OCSP_NOT_RESP;
 919   }
 920 return 0;
 921 }
 922
 923 /* Callback for client-hello, on server, if we think we might serve stapled-OCSP */
 924 static int
 925 tls_server_clienthello_cb(gnutls_session_t session, unsigned int htype,
 926   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
 927 {
 928 /* Call fn for each extension seen.  3.6.3 onwards */
 929 return gnutls_ext_raw_parse(NULL, tls_server_clienthello_ext, msg,
 930                            GNUTLS_EXT_RAW_FLAG_TLS_CLIENT_HELLO);
 931 }
 932
 933
 934 /* Make a note that we saw a status-response */
 935 static int
 936 tls_server_servercerts_ext(void * ctx, unsigned tls_id,
 937   const unsigned char *data, unsigned size)
 938 {
 939 /* debug_printf("%s %u\n", __FUNCTION__, tls_id); */
 940 /* https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml */
 941 if (FALSE && tls_id == 5)       /* status_request */
 942   {
 943   DEBUG(D_tls) debug_printf("Seen status_request extension\n");
 944   tls_in.ocsp = exim_testharness_disable_ocsp_validity_check
 945     ? OCSP_VFY_NOT_TRIED : OCSP_VFIED;  /* We know that GnuTLS verifies responses */
 946   }
 947 return 0;
 948 }
 949
 950 /* Callback for certificates packet, on server, if we think we might serve stapled-OCSP */
 951 static int
 952 tls_server_servercerts_cb(gnutls_session_t session, unsigned int htype,
 953   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
 954 {
 955 /* Call fn for each extension seen.  3.6.3 onwards */
 956 #ifdef notdef
 957 /*XXX crashes */
 958 return gnutls_ext_raw_parse(NULL, tls_server_servercerts_ext, msg, 0);
 959 #endif
 960 }
 961 #endif
 962
 963 /*XXX in tls1.3 the cert-status travel as an extension next to the cert, in the
 964  "Handshake Protocol: Certificate" record.
 965 So we need to spot the Certificate handshake message, parse it and spot any status_request extension(s)
 966
 967 This is different to tls1.2 - where it is a separate record (wireshake term) / handshake message (gnutls term).
 968 */
 969
 970 #if defined(EXPERIMENTAL_TLS_RESUME) || defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
 971 /* Callback for certificate-status, on server. We sent stapled OCSP. */
 972 static int
 973 tls_server_certstatus_cb(gnutls_session_t session, unsigned int htype,
 974   unsigned when, unsigned int incoming, const gnutls_datum_t * msg)
 975 {
 976 DEBUG(D_tls) debug_printf("Sending certificate-status\n");              /*XXX we get this for tls1.2 but not for 1.3 */
 977 #ifdef SUPPORT_SRV_OCSP_STACK
 978 tls_in.ocsp = exim_testharness_disable_ocsp_validity_check
 979   ? OCSP_VFY_NOT_TRIED : OCSP_VFIED;    /* We know that GnuTLS verifies responses */
 980 #else
 981 tls_in.ocsp = OCSP_VFY_NOT_TRIED;
 982 #endif
 983 return 0;
 984 }
 985
 986 /* Callback for handshake messages, on server */
 987 static int
 988 tls_server_hook_cb(gnutls_session_t sess, u_int htype, unsigned when,
 989   unsigned incoming, const gnutls_datum_t * msg)
 990 {
 991 /* debug_printf("%s: htype %u\n", __FUNCTION__, htype); */
 992 switch (htype)
 993   {
 994 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
 995   case GNUTLS_HANDSHAKE_CLIENT_HELLO:
 996     return tls_server_clienthello_cb(sess, htype, when, incoming, msg);
 997   case GNUTLS_HANDSHAKE_CERTIFICATE_PKT:
 998     return tls_server_servercerts_cb(sess, htype, when, incoming, msg);
 999 # endif
1000   case GNUTLS_HANDSHAKE_CERTIFICATE_STATUS:
1001     return tls_server_certstatus_cb(sess, htype, when, incoming, msg);
1002 # ifdef EXPERIMENTAL_TLS_RESUME
1003   case GNUTLS_HANDSHAKE_NEW_SESSION_TICKET:
1004     return tls_server_ticket_cb(sess, htype, when, incoming, msg);
1005 # endif
1006   default:
1007     return 0;
1008   }
1009 }
1010 #endif
1011
1012
1013 #if !defined(DISABLE_OCSP) && defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1014 static void
1015 tls_server_testharness_ocsp_fiddle(void)
1016 {
1017 extern char ** environ;
1018 if (environ) for (uschar ** p = USS environ; *p; p++)
1019   if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1020     {
1021     DEBUG(D_tls) debug_printf("Permitting known bad OCSP response\n");
1022     exim_testharness_disable_ocsp_validity_check = TRUE;
1023     }
1024 }
1025 #endif
1026
1027 /*************************************************
1028 *       Variables re-expanded post-SNI           *
1029 *************************************************/
1030
1031 /* Called from both server and client code, via tls_init(), and also from
1032 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
1033
1034 We can tell the two apart by state->received_sni being non-NULL in callback.
1035
1036 The callback should not call us unless state->trigger_sni_changes is true,
1037 which we are responsible for setting on the first pass through.
1038
1039 Arguments:
1040   state           exim_gnutls_state_st *
1041   errstr          error string pointer
1042
1043 Returns:          OK/DEFER/FAIL
1044 */
1045
1046 static int
1047 tls_expand_session_files(exim_gnutls_state_st * state, uschar ** errstr)
1048 {
1049 struct stat statbuf;
1050 int rc;
1051 const host_item *host = state->host;  /* macro should be reconsidered? */
1052 uschar *saved_tls_certificate = NULL;
1053 uschar *saved_tls_privatekey = NULL;
1054 uschar *saved_tls_verify_certificates = NULL;
1055 uschar *saved_tls_crl = NULL;
1056 int cert_count;
1057
1058 /* We check for tls_sni *before* expansion. */
1059 if (!host)      /* server */
1060   if (!state->received_sni)
1061     {
1062     if (  state->tls_certificate
1063        && (  Ustrstr(state->tls_certificate, US"tls_sni")
1064           || Ustrstr(state->tls_certificate, US"tls_in_sni")
1065           || Ustrstr(state->tls_certificate, US"tls_out_sni")
1066        )  )
1067       {
1068       DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
1069       state->trigger_sni_changes = TRUE;
1070       }
1071     }
1072   else
1073     {
1074     /* useful for debugging */
1075     saved_tls_certificate = state->exp_tls_certificate;
1076     saved_tls_privatekey = state->exp_tls_privatekey;
1077     saved_tls_verify_certificates = state->exp_tls_verify_certificates;
1078     saved_tls_crl = state->exp_tls_crl;
1079     }
1080
1081 if ((rc = gnutls_certificate_allocate_credentials(&state->x509_cred)))
1082   return tls_error_gnu(US"gnutls_certificate_allocate_credentials",
1083             rc, host, errstr);
1084
1085 #ifdef SUPPORT_SRV_OCSP_STACK
1086 gnutls_certificate_set_flags(state->x509_cred, GNUTLS_CERTIFICATE_API_V2);
1087
1088 # if !defined(DISABLE_OCSP) && defined(SUPPORT_GNUTLS_EXT_RAW_PARSE)
1089 if (!host && tls_ocsp_file)
1090   {
1091   if (f.running_in_test_harness)
1092     tls_server_testharness_ocsp_fiddle();
1093
1094   if (exim_testharness_disable_ocsp_validity_check)
1095     gnutls_certificate_set_flags(state->x509_cred,
1096       GNUTLS_CERTIFICATE_API_V2 | GNUTLS_CERTIFICATE_SKIP_OCSP_RESPONSE_CHECK);
1097   }
1098 # endif
1099 #endif
1100
1101 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
1102 state members, assuming consistent naming; and expand_check() returns
1103 false if expansion failed, unless expansion was forced to fail. */
1104
1105 /* check if we at least have a certificate, before doing expensive
1106 D-H generation. */
1107
1108 if (!expand_check_tlsvar(tls_certificate, errstr))
1109   return DEFER;
1110
1111 /* certificate is mandatory in server, optional in client */
1112
1113 if (  !state->exp_tls_certificate
1114    || !*state->exp_tls_certificate
1115    )
1116   if (!host)
1117     return tls_install_selfsign(state, errstr);
1118   else
1119     DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
1120
1121 if (state->tls_privatekey && !expand_check_tlsvar(tls_privatekey, errstr))
1122   return DEFER;
1123
1124 /* tls_privatekey is optional, defaulting to same file as certificate */
1125
1126 if (!state->tls_privatekey || !*state->tls_privatekey)
1127   {
1128   state->tls_privatekey = state->tls_certificate;
1129   state->exp_tls_privatekey = state->exp_tls_certificate;
1130   }
1131
1132
1133 if (state->exp_tls_certificate && *state->exp_tls_certificate)
1134   {
1135   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
1136       state->exp_tls_certificate, state->exp_tls_privatekey);
1137
1138   if (state->received_sni)
1139     if (  Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0
1140        && Ustrcmp(state->exp_tls_privatekey,  saved_tls_privatekey)  == 0
1141        )
1142       {
1143       DEBUG(D_tls) debug_printf("TLS SNI: cert and key unchanged\n");
1144       }
1145     else
1146       {
1147       DEBUG(D_tls) debug_printf("TLS SNI: have a changed cert/key pair.\n");
1148       }
1149
1150   if (!host)    /* server */
1151     {
1152     const uschar * clist = state->exp_tls_certificate;
1153     const uschar * klist = state->exp_tls_privatekey;
1154     const uschar * olist;
1155     int csep = 0, ksep = 0, osep = 0, cnt = 0;
1156     uschar * cfile, * kfile, * ofile;
1157 #ifndef DISABLE_OCSP
1158 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1159     gnutls_x509_crt_fmt_t ocsp_fmt = GNUTLS_X509_FMT_DER;
1160 # endif
1161
1162     if (!expand_check(tls_ocsp_file, US"tls_ocsp_file", &ofile, errstr))
1163       return DEFER;
1164     olist = ofile;
1165 #endif
1166
1167     while (cfile = string_nextinlist(&clist, &csep, NULL, 0))
1168
1169       if (!(kfile = string_nextinlist(&klist, &ksep, NULL, 0)))
1170         return tls_error(US"cert/key setup: out of keys", NULL, host, errstr);
1171       else if (0 < (rc = tls_add_certfile(state, host, cfile, kfile, errstr)))
1172         return rc;
1173       else
1174         {
1175         int gnutls_cert_index = -rc;
1176         DEBUG(D_tls) debug_printf("TLS: cert/key %d %s registered\n",
1177                                   gnutls_cert_index, cfile);
1178
1179 #ifndef DISABLE_OCSP
1180         if (tls_ocsp_file)
1181           {
1182           /* Set the OCSP stapling server info */
1183           if (gnutls_buggy_ocsp)
1184             {
1185             DEBUG(D_tls)
1186               debug_printf("GnuTLS library is buggy for OCSP; avoiding\n");
1187             }
1188           else if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1189             {
1190             DEBUG(D_tls) debug_printf("OCSP response file %d  = %s\n",
1191                                       gnutls_cert_index, ofile);
1192 # ifdef SUPPORT_GNUTLS_EXT_RAW_PARSE
1193             if (Ustrncmp(ofile, US"PEM ", 4) == 0)
1194               {
1195               ocsp_fmt = GNUTLS_X509_FMT_PEM;
1196               ofile += 4;
1197               }
1198             else if (Ustrncmp(ofile, US"DER ", 4) == 0)
1199               {
1200               ocsp_fmt = GNUTLS_X509_FMT_DER;
1201               ofile += 4;
1202               }
1203
1204             if  ((rc = gnutls_certificate_set_ocsp_status_request_file2(
1205                       state->x509_cred, CCS ofile, gnutls_cert_index,
1206                       ocsp_fmt)) < 0)
1207               return tls_error_gnu(
1208                       US"gnutls_certificate_set_ocsp_status_request_file2",
1209                       rc, host, errstr);
1210             DEBUG(D_tls)
1211               debug_printf(" %d response%s loaded\n", rc, rc>1 ? "s":"");
1212
1213             /* Arrange callbacks for OCSP request observability */
1214
1215             gnutls_handshake_set_hook_function(state->session,
1216               GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
1217
1218 # else
1219 #  if defined(SUPPORT_SRV_OCSP_STACK)
1220             if ((rc = gnutls_certificate_set_ocsp_status_request_function2(
1221                          state->x509_cred, gnutls_cert_index,
1222                          server_ocsp_stapling_cb, ofile)))
1223                 return tls_error_gnu(
1224                       US"gnutls_certificate_set_ocsp_status_request_function2",
1225                       rc, host, errstr);
1226             else
1227 #  endif
1228               {
1229               if (cnt++ > 0)
1230                 {
1231                 DEBUG(D_tls)
1232                   debug_printf("oops; multiple OCSP files not supported\n");
1233                 break;
1234                 }
1235               gnutls_certificate_set_ocsp_status_request_function(
1236                 state->x509_cred, server_ocsp_stapling_cb, ofile);
1237               }
1238 # endif /* SUPPORT_GNUTLS_EXT_RAW_PARSE */
1239             }
1240           else
1241             DEBUG(D_tls) debug_printf("ran out of OCSP response files in list\n");
1242           }
1243 #endif /* DISABLE_OCSP */
1244         }
1245     }
1246   else  /* client */
1247     {
1248     if (0 < (rc = tls_add_certfile(state, host,
1249                 state->exp_tls_certificate, state->exp_tls_privatekey, errstr)))
1250       return rc;
1251     DEBUG(D_tls) debug_printf("TLS: cert/key registered\n");
1252     }
1253
1254   } /* tls_certificate */
1255
1256
1257 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
1258 provided. Experiment shows that, if the certificate file is empty, an unhelpful
1259 error message is provided. However, if we just refrain from setting anything up
1260 in that case, certificate verification fails, which seems to be the correct
1261 behaviour. */
1262
1263 if (state->tls_verify_certificates && *state->tls_verify_certificates)
1264   {
1265   if (!expand_check_tlsvar(tls_verify_certificates, errstr))
1266     return DEFER;
1267 #ifndef SUPPORT_SYSDEFAULT_CABUNDLE
1268   if (Ustrcmp(state->exp_tls_verify_certificates, "system") == 0)
1269     state->exp_tls_verify_certificates = NULL;
1270 #endif
1271   if (state->tls_crl && *state->tls_crl)
1272     if (!expand_check_tlsvar(tls_crl, errstr))
1273       return DEFER;
1274
1275   if (!(state->exp_tls_verify_certificates &&
1276         *state->exp_tls_verify_certificates))
1277     {
1278     DEBUG(D_tls)
1279       debug_printf("TLS: tls_verify_certificates expanded empty, ignoring\n");
1280     /* With no tls_verify_certificates, we ignore tls_crl too */
1281     return OK;
1282     }
1283   }
1284 else
1285   {
1286   DEBUG(D_tls)
1287     debug_printf("TLS: tls_verify_certificates not set or empty, ignoring\n");
1288   return OK;
1289   }
1290
1291 #ifdef SUPPORT_SYSDEFAULT_CABUNDLE
1292 if (Ustrcmp(state->exp_tls_verify_certificates, "system") == 0)
1293   cert_count = gnutls_certificate_set_x509_system_trust(state->x509_cred);
1294 else
1295 #endif
1296   {
1297   if (Ustat(state->exp_tls_verify_certificates, &statbuf) < 0)
1298     {
1299     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat '%s' "
1300         "(tls_verify_certificates): %s", state->exp_tls_verify_certificates,
1301         strerror(errno));
1302     return DEFER;
1303     }
1304
1305 #ifndef SUPPORT_CA_DIR
1306   /* The test suite passes in /dev/null; we could check for that path explicitly,
1307   but who knows if someone has some weird FIFO which always dumps some certs, or
1308   other weirdness.  The thing we really want to check is that it's not a
1309   directory, since while OpenSSL supports that, GnuTLS does not.
1310   So s/!S_ISREG/S_ISDIR/ and change some messaging ... */
1311   if (S_ISDIR(statbuf.st_mode))
1312     {
1313     DEBUG(D_tls)
1314       debug_printf("verify certificates path is a dir: \"%s\"\n",
1315           state->exp_tls_verify_certificates);
1316     log_write(0, LOG_MAIN|LOG_PANIC,
1317         "tls_verify_certificates \"%s\" is a directory",
1318         state->exp_tls_verify_certificates);
1319     return DEFER;
1320     }
1321 #endif
1322
1323   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
1324           state->exp_tls_verify_certificates, statbuf.st_size);
1325
1326   if (statbuf.st_size == 0)
1327     {
1328     DEBUG(D_tls)
1329       debug_printf("cert file empty, no certs, no verification, ignoring any CRL\n");
1330     return OK;
1331     }
1332
1333   cert_count =
1334
1335 #ifdef SUPPORT_CA_DIR
1336     (statbuf.st_mode & S_IFMT) == S_IFDIR
1337     ?
1338     gnutls_certificate_set_x509_trust_dir(state->x509_cred,
1339       CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM)
1340     :
1341 #endif
1342     gnutls_certificate_set_x509_trust_file(state->x509_cred,
1343       CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM);
1344
1345 #ifdef SUPPORT_CA_DIR
1346   /* Mimic the behaviour with OpenSSL of not advertising a usable-cert list
1347   when using the directory-of-certs config model. */
1348
1349   if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1350     gnutls_certificate_send_x509_rdn_sequence(state->session, 1);
1351 #endif
1352   }
1353
1354 if (cert_count < 0)
1355   return tls_error_gnu(US"setting certificate trust", cert_count, host, errstr);
1356 DEBUG(D_tls)
1357   debug_printf("Added %d certificate authorities.\n", cert_count);
1358
1359 if (state->tls_crl && *state->tls_crl &&
1360     state->exp_tls_crl && *state->exp_tls_crl)
1361   {
1362   DEBUG(D_tls) debug_printf("loading CRL file = %s\n", state->exp_tls_crl);
1363   if ((cert_count = gnutls_certificate_set_x509_crl_file(state->x509_cred,
1364       CS state->exp_tls_crl, GNUTLS_X509_FMT_PEM)) < 0)
1365     return tls_error_gnu(US"gnutls_certificate_set_x509_crl_file",
1366               cert_count, host, errstr);
1367
1368   DEBUG(D_tls) debug_printf("Processed %d CRLs.\n", cert_count);
1369   }
1370
1371 return OK;
1372 }
1373
1374
1375
1376
1377 /*************************************************
1378 *          Set X.509 state variables             *
1379 *************************************************/
1380
1381 /* In GnuTLS, the registered cert/key are not replaced by a later
1382 set of a cert/key, so for SNI support we need a whole new x509_cred
1383 structure.  Which means various other non-re-expanded pieces of state
1384 need to be re-set in the new struct, so the setting logic is pulled
1385 out to this.
1386
1387 Arguments:
1388   state           exim_gnutls_state_st *
1389   errstr          error string pointer
1390
1391 Returns:          OK/DEFER/FAIL
1392 */
1393
1394 static int
1395 tls_set_remaining_x509(exim_gnutls_state_st *state, uschar ** errstr)
1396 {
1397 int rc;
1398 const host_item *host = state->host;  /* macro should be reconsidered? */
1399
1400 #ifndef GNUTLS_AUTO_DHPARAMS
1401 /* Create D-H parameters, or read them from the cache file. This function does
1402 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
1403 client-side params. */
1404
1405 if (!state->host)
1406   {
1407   if (!dh_server_params)
1408     if ((rc = init_server_dh(errstr)) != OK) return rc;
1409
1410   /* Unnecessary & discouraged with 3.6.0 or later */
1411   gnutls_certificate_set_dh_params(state->x509_cred, dh_server_params);
1412   }
1413 #endif
1414
1415 /* Link the credentials to the session. */
1416
1417 if ((rc = gnutls_credentials_set(state->session,
1418             GNUTLS_CRD_CERTIFICATE, state->x509_cred)))
1419   return tls_error_gnu(US"gnutls_credentials_set", rc, host, errstr);
1420
1421 return OK;
1422 }
1423
1424 /*************************************************
1425 *            Initialize for GnuTLS               *
1426 *************************************************/
1427
1428
1429 #ifndef DISABLE_OCSP
1430
1431 static BOOL
1432 tls_is_buggy_ocsp(void)
1433 {
1434 const uschar * s;
1435 uschar maj, mid, mic;
1436
1437 s = CUS gnutls_check_version(NULL);
1438 maj = atoi(CCS s);
1439 if (maj == 3)
1440   {
1441   while (*s && *s != '.') s++;
1442   mid = atoi(CCS ++s);
1443   if (mid <= 2)
1444     return TRUE;
1445   else if (mid >= 5)
1446     return FALSE;
1447   else
1448     {
1449     while (*s && *s != '.') s++;
1450     mic = atoi(CCS ++s);
1451     return mic <= (mid == 3 ? 16 : 3);
1452     }
1453   }
1454 return FALSE;
1455 }
1456
1457 #endif
1458
1459
1460 /* Called from both server and client code. In the case of a server, errors
1461 before actual TLS negotiation return DEFER.
1462
1463 Arguments:
1464   host            connected host, if client; NULL if server
1465   certificate     certificate file
1466   privatekey      private key file
1467   sni             TLS SNI to send, sometimes when client; else NULL
1468   cas             CA certs file
1469   crl             CRL file
1470   require_ciphers tls_require_ciphers setting
1471   caller_state    returned state-info structure
1472   errstr          error string pointer
1473
1474 Returns:          OK/DEFER/FAIL
1475 */
1476
1477 static int
1478 tls_init(
1479     const host_item *host,
1480     const uschar *certificate,
1481     const uschar *privatekey,
1482     const uschar *sni,
1483     const uschar *cas,
1484     const uschar *crl,
1485     const uschar *require_ciphers,
1486     exim_gnutls_state_st **caller_state,
1487     tls_support * tlsp,
1488     uschar ** errstr)
1489 {
1490 exim_gnutls_state_st * state;
1491 int rc;
1492 size_t sz;
1493 const char * errpos;
1494 const uschar * p;
1495
1496 if (!exim_gnutls_base_init_done)
1497   {
1498   DEBUG(D_tls) debug_printf("GnuTLS global init required.\n");
1499
1500 #ifdef HAVE_GNUTLS_PKCS11
1501   /* By default, gnutls_global_init will init PKCS11 support in auto mode,
1502   which loads modules from a config file, which sounds good and may be wanted
1503   by some sysadmin, but also means in common configurations that GNOME keyring
1504   environment variables are used and so breaks for users calling mailq.
1505   To prevent this, we init PKCS11 first, which is the documented approach. */
1506   if (!gnutls_allow_auto_pkcs11)
1507     if ((rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL)))
1508       return tls_error_gnu(US"gnutls_pkcs11_init", rc, host, errstr);
1509 #endif
1510
1511   if ((rc = gnutls_global_init()))
1512     return tls_error_gnu(US"gnutls_global_init", rc, host, errstr);
1513
1514 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1515   DEBUG(D_tls)
1516     {
1517     gnutls_global_set_log_function(exim_gnutls_logger_cb);
1518     /* arbitrarily chosen level; bump up to 9 for more */
1519     gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
1520     }
1521 #endif
1522
1523 #ifndef DISABLE_OCSP
1524   if (tls_ocsp_file && (gnutls_buggy_ocsp = tls_is_buggy_ocsp()))
1525     log_write(0, LOG_MAIN, "OCSP unusable with this GnuTLS library version");
1526 #endif
1527
1528   exim_gnutls_base_init_done = TRUE;
1529   }
1530
1531 if (host)
1532   {
1533   /* For client-side sessions we allocate a context. This lets us run
1534   several in parallel. */
1535   int old_pool = store_pool;
1536   store_pool = POOL_PERM;
1537   state = store_get(sizeof(exim_gnutls_state_st), FALSE);
1538   store_pool = old_pool;
1539
1540   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1541   state->tlsp = tlsp;
1542   DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
1543   rc = gnutls_init(&state->session, GNUTLS_CLIENT);
1544   }
1545 else
1546   {
1547   state = &state_server;
1548   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1549   state->tlsp = tlsp;
1550   DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
1551   rc = gnutls_init(&state->session, GNUTLS_SERVER);
1552   }
1553 if (rc)
1554   return tls_error_gnu(US"gnutls_init", rc, host, errstr);
1555
1556 state->host = host;
1557
1558 state->tls_certificate = certificate;
1559 state->tls_privatekey = privatekey;
1560 state->tls_require_ciphers = require_ciphers;
1561 state->tls_sni = sni;
1562 state->tls_verify_certificates = cas;
1563 state->tls_crl = crl;
1564
1565 /* This handles the variables that might get re-expanded after TLS SNI;
1566 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
1567
1568 DEBUG(D_tls)
1569   debug_printf("Expanding various TLS configuration options for session credentials.\n");
1570 if ((rc = tls_expand_session_files(state, errstr)) != OK) return rc;
1571
1572 /* These are all other parts of the x509_cred handling, since SNI in GnuTLS
1573 requires a new structure afterwards. */
1574
1575 if ((rc = tls_set_remaining_x509(state, errstr)) != OK) return rc;
1576
1577 /* set SNI in client, only */
1578 if (host)
1579   {
1580   if (!expand_check(sni, US"tls_out_sni", &state->tlsp->sni, errstr))
1581     return DEFER;
1582   if (state->tlsp->sni && *state->tlsp->sni)
1583     {
1584     DEBUG(D_tls)
1585       debug_printf("Setting TLS client SNI to \"%s\"\n", state->tlsp->sni);
1586     sz = Ustrlen(state->tlsp->sni);
1587     if ((rc = gnutls_server_name_set(state->session,
1588           GNUTLS_NAME_DNS, state->tlsp->sni, sz)))
1589       return tls_error_gnu(US"gnutls_server_name_set", rc, host, errstr);
1590     }
1591   }
1592 else if (state->tls_sni)
1593   DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
1594       "have an SNI set for a server [%s]\n", state->tls_sni);
1595
1596 /* This is the priority string support,
1597 http://www.gnutls.org/manual/html_node/Priority-Strings.html
1598 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
1599 This was backwards incompatible, but means Exim no longer needs to track
1600 all algorithms and provide string forms for them. */
1601
1602 p = NULL;
1603 if (state->tls_require_ciphers && *state->tls_require_ciphers)
1604   {
1605   if (!expand_check_tlsvar(tls_require_ciphers, errstr))
1606     return DEFER;
1607   if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
1608     {
1609     p = state->exp_tls_require_ciphers;
1610     DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n", p);
1611     }
1612   }
1613 if (!p)
1614   {
1615   p = exim_default_gnutls_priority;
1616   DEBUG(D_tls)
1617     debug_printf("GnuTLS using default session cipher/priority \"%s\"\n", p);
1618   }
1619
1620 if ((rc = gnutls_priority_init(&state->priority_cache, CCS p, &errpos)))
1621   return tls_error_gnu(string_sprintf(
1622                       "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
1623                       p, errpos - CS p, errpos),
1624                   rc, host, errstr);
1625
1626 if ((rc = gnutls_priority_set(state->session, state->priority_cache)))
1627   return tls_error_gnu(US"gnutls_priority_set", rc, host, errstr);
1628
1629 /* This also sets the server ticket expiration time to the same, and
1630 the STEK rotation time to 3x. */
1631
1632 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
1633
1634 /* Reduce security in favour of increased compatibility, if the admin
1635 decides to make that trade-off. */
1636 if (gnutls_compat_mode)
1637   {
1638 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
1639   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
1640   gnutls_session_enable_compatibility_mode(state->session);
1641 #else
1642   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
1643 #endif
1644   }
1645
1646 *caller_state = state;
1647 return OK;
1648 }
1649
1650
1651
1652 /*************************************************
1653 *            Extract peer information            *
1654 *************************************************/
1655
1656 static const uschar *
1657 cipher_stdname_kcm(gnutls_kx_algorithm_t kx, gnutls_cipher_algorithm_t cipher,
1658   gnutls_mac_algorithm_t mac)
1659 {
1660 uschar cs_id[2];
1661 gnutls_kx_algorithm_t kx_i;
1662 gnutls_cipher_algorithm_t cipher_i;
1663 gnutls_mac_algorithm_t mac_i;
1664
1665 for (size_t i = 0;
1666      gnutls_cipher_suite_info(i, cs_id, &kx_i, &cipher_i, &mac_i, NULL);
1667      i++)
1668   if (kx_i == kx && cipher_i == cipher && mac_i == mac)
1669     return cipher_stdname(cs_id[0], cs_id[1]);
1670 return NULL;
1671 }
1672
1673
1674
1675 /* Called from both server and client code.
1676 Only this is allowed to set state->peerdn and state->have_set_peerdn
1677 and we use that to detect double-calls.
1678
1679 NOTE: the state blocks last while the TLS connection is up, which is fine
1680 for logging in the server side, but for the client side, we log after teardown
1681 in src/deliver.c.  While the session is up, we can twist about states and
1682 repoint tls_* globals, but those variables used for logging or other variable
1683 expansion that happens _after_ delivery need to have a longer life-time.
1684
1685 So for those, we get the data from POOL_PERM; the re-invoke guard keeps us from
1686 doing this more than once per generation of a state context.  We set them in
1687 the state context, and repoint tls_* to them.  After the state goes away, the
1688 tls_* copies of the pointers remain valid and client delivery logging is happy.
1689
1690 tls_certificate_verified is a BOOL, so the tls_peerdn and tls_cipher issues
1691 don't apply.
1692
1693 Arguments:
1694   state           exim_gnutls_state_st *
1695   errstr          pointer to error string
1696
1697 Returns:          OK/DEFER/FAIL
1698 */
1699
1700 static int
1701 peer_status(exim_gnutls_state_st * state, uschar ** errstr)
1702 {
1703 gnutls_session_t session = state->session;
1704 const gnutls_datum_t * cert_list;
1705 int old_pool, rc;
1706 unsigned int cert_list_size = 0;
1707 gnutls_protocol_t protocol;
1708 gnutls_cipher_algorithm_t cipher;
1709 gnutls_kx_algorithm_t kx;
1710 gnutls_mac_algorithm_t mac;
1711 gnutls_certificate_type_t ct;
1712 gnutls_x509_crt_t crt;
1713 uschar * dn_buf;
1714 size_t sz;
1715
1716 if (state->have_set_peerdn)
1717   return OK;
1718 state->have_set_peerdn = TRUE;
1719
1720 state->peerdn = NULL;
1721
1722 /* tls_cipher */
1723 cipher = gnutls_cipher_get(session);
1724 protocol = gnutls_protocol_get_version(session);
1725 mac = gnutls_mac_get(session);
1726 kx =
1727 #ifdef GNUTLS_TLS1_3
1728     protocol >= GNUTLS_TLS1_3 ? 0 :
1729 #endif
1730   gnutls_kx_get(session);
1731
1732 old_pool = store_pool;
1733   {
1734   tls_support * tlsp = state->tlsp;
1735   store_pool = POOL_PERM;
1736
1737 #ifdef SUPPORT_GNUTLS_SESS_DESC
1738     {
1739     gstring * g = NULL;
1740     uschar * s = US gnutls_session_get_desc(session), c;
1741
1742     /* Nikos M suggests we use this by preference.  It returns like:
1743     (TLS1.3)-(ECDHE-SECP256R1)-(RSA-PSS-RSAE-SHA256)-(AES-256-GCM)
1744
1745     For partial back-compat, put a colon after the TLS version, replace the
1746     )-( grouping with __, replace in-group - with _ and append the :keysize. */
1747
1748     /* debug_printf("peer_status: gnutls_session_get_desc %s\n", s); */
1749
1750     for (s++; (c = *s) && c != ')'; s++) g = string_catn(g, s, 1);
1751     g = string_catn(g, US":", 1);
1752     if (*s) s++;                /* now on _ between groups */
1753     while ((c = *s))
1754       {
1755       for (*++s && ++s; (c = *s) && c != ')'; s++) g = string_catn(g, c == '-' ? US"_" : s, 1);
1756       /* now on ) closing group */
1757       if ((c = *s) && *++s == '-') g = string_catn(g, US"__", 2);
1758       /* now on _ between groups */
1759       }
1760     g = string_catn(g, US":", 1);
1761     g = string_cat(g, string_sprintf("%d", (int) gnutls_cipher_get_key_size(cipher) * 8));
1762     state->ciphersuite = string_from_gstring(g);
1763     }
1764 #else
1765   state->ciphersuite = string_sprintf("%s:%s:%d",
1766       gnutls_protocol_get_name(protocol),
1767       gnutls_cipher_suite_get_name(kx, cipher, mac),
1768       (int) gnutls_cipher_get_key_size(cipher) * 8);
1769
1770   /* I don't see a way that spaces could occur, in the current GnuTLS
1771   code base, but it was a concern in the old code and perhaps older GnuTLS
1772   releases did return "TLS 1.0"; play it safe, just in case. */
1773
1774   for (uschar * p = state->ciphersuite; *p; p++) if (isspace(*p)) *p = '-';
1775 #endif
1776
1777 /* debug_printf("peer_status: ciphersuite %s\n", state->ciphersuite); */
1778
1779   tlsp->cipher = state->ciphersuite;
1780   tlsp->bits = gnutls_cipher_get_key_size(cipher) * 8;
1781
1782   tlsp->cipher_stdname = cipher_stdname_kcm(kx, cipher, mac);
1783   }
1784 store_pool = old_pool;
1785
1786 /* tls_peerdn */
1787 cert_list = gnutls_certificate_get_peers(session, &cert_list_size);
1788
1789 if (!cert_list || cert_list_size == 0)
1790   {
1791   DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
1792       cert_list, cert_list_size);
1793   if (state->verify_requirement >= VERIFY_REQUIRED)
1794     return tls_error(US"certificate verification failed",
1795         US"no certificate received from peer", state->host, errstr);
1796   return OK;
1797   }
1798
1799 if ((ct = gnutls_certificate_type_get(session)) != GNUTLS_CRT_X509)
1800   {
1801   const uschar * ctn = US gnutls_certificate_type_get_name(ct);
1802   DEBUG(D_tls)
1803     debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
1804   if (state->verify_requirement >= VERIFY_REQUIRED)
1805     return tls_error(US"certificate verification not possible, unhandled type",
1806         ctn, state->host, errstr);
1807   return OK;
1808   }
1809
1810 #define exim_gnutls_peer_err(Label) \
1811   do { \
1812     if (rc != GNUTLS_E_SUCCESS) \
1813       { \
1814       DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", \
1815         (Label), gnutls_strerror(rc)); \
1816       if (state->verify_requirement >= VERIFY_REQUIRED) \
1817         return tls_error_gnu((Label), rc, state->host, errstr); \
1818       return OK; \
1819       } \
1820     } while (0)
1821
1822 rc = import_cert(&cert_list[0], &crt);
1823 exim_gnutls_peer_err(US"cert 0");
1824
1825 state->tlsp->peercert = state->peercert = crt;
1826
1827 sz = 0;
1828 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
1829 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
1830   {
1831   exim_gnutls_peer_err(US"getting size for cert DN failed");
1832   return FAIL; /* should not happen */
1833   }
1834 dn_buf = store_get_perm(sz, TRUE);      /* tainted */
1835 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
1836 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1837
1838 state->peerdn = dn_buf;
1839
1840 return OK;
1841 #undef exim_gnutls_peer_err
1842 }
1843
1844
1845
1846
1847 /*************************************************
1848 *            Verify peer certificate             *
1849 *************************************************/
1850
1851 /* Called from both server and client code.
1852 *Should* be using a callback registered with
1853 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1854 the peer information, but that's too new for some OSes.
1855
1856 Arguments:
1857   state         exim_gnutls_state_st *
1858   errstr        where to put an error message
1859
1860 Returns:
1861   FALSE     if the session should be rejected
1862   TRUE      if the cert is okay or we just don't care
1863 */
1864
1865 static BOOL
1866 verify_certificate(exim_gnutls_state_st * state, uschar ** errstr)
1867 {
1868 int rc;
1869 uint verify;
1870
1871 DEBUG(D_tls) debug_printf("TLS: checking peer certificate\n");
1872 *errstr = NULL;
1873 rc = peer_status(state, errstr);
1874
1875 if (state->verify_requirement == VERIFY_NONE)
1876   return TRUE;
1877
1878 if (rc != OK || !state->peerdn)
1879   {
1880   verify = GNUTLS_CERT_INVALID;
1881   *errstr = US"certificate not supplied";
1882   }
1883 else
1884
1885   {
1886 #ifdef SUPPORT_DANE
1887   if (state->verify_requirement == VERIFY_DANE && state->host)
1888     {
1889     /* Using dane_verify_session_crt() would be easy, as it does it all for us
1890     including talking to a DNS resolver.  But we want to do that bit ourselves
1891     as the testsuite intercepts and fakes its own DNS environment. */
1892
1893     dane_state_t s;
1894     dane_query_t r;
1895     uint lsize;
1896     const gnutls_datum_t * certlist =
1897       gnutls_certificate_get_peers(state->session, &lsize);
1898     int usage = tls_out.tlsa_usage;
1899
1900 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1901     /* Split the TLSA records into two sets, TA and EE selectors.  Run the
1902     dane-verification separately so that we know which selector verified;
1903     then we know whether to do name-verification (needed for TA but not EE). */
1904
1905     if (usage == ((1<<DANESSL_USAGE_DANE_TA) | (1<<DANESSL_USAGE_DANE_EE)))
1906       {                                         /* a mixed-usage bundle */
1907       int i, j, nrec;
1908       const char ** dd;
1909       int * ddl;
1910
1911       for(nrec = 0; state->dane_data_len[nrec]; ) nrec++;
1912       nrec++;
1913
1914       dd = store_get(nrec * sizeof(uschar *), FALSE);
1915       ddl = store_get(nrec * sizeof(int), FALSE);
1916       nrec--;
1917
1918       if ((rc = dane_state_init(&s, 0)))
1919         goto tlsa_prob;
1920
1921       for (usage = DANESSL_USAGE_DANE_EE;
1922            usage >= DANESSL_USAGE_DANE_TA; usage--)
1923         {                               /* take records with this usage */
1924         for (j = i = 0; i < nrec; i++)
1925           if (state->dane_data[i][0] == usage)
1926             {
1927             dd[j] = state->dane_data[i];
1928             ddl[j++] = state->dane_data_len[i];
1929             }
1930         if (j)
1931           {
1932           dd[j] = NULL;
1933           ddl[j] = 0;
1934
1935           if ((rc = dane_raw_tlsa(s, &r, (char * const *)dd, ddl, 1, 0)))
1936             goto tlsa_prob;
1937
1938           if ((rc = dane_verify_crt_raw(s, certlist, lsize,
1939                             gnutls_certificate_type_get(state->session),
1940                             r, 0,
1941                             usage == DANESSL_USAGE_DANE_EE
1942                             ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
1943                             &verify)))
1944             {
1945             DEBUG(D_tls)
1946               debug_printf("TLSA record problem: %s\n", dane_strerror(rc));
1947             }
1948           else if (verify == 0) /* verification passed */
1949             {
1950             usage = 1 << usage;
1951             break;
1952             }
1953           }
1954         }
1955
1956         if (rc) goto tlsa_prob;
1957       }
1958     else
1959 # endif
1960       {
1961       if (  (rc = dane_state_init(&s, 0))
1962          || (rc = dane_raw_tlsa(s, &r, state->dane_data, state->dane_data_len,
1963                         1, 0))
1964          || (rc = dane_verify_crt_raw(s, certlist, lsize,
1965                         gnutls_certificate_type_get(state->session),
1966                         r, 0,
1967 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1968                         usage == (1 << DANESSL_USAGE_DANE_EE)
1969                         ? DANE_VFLAG_ONLY_CHECK_EE_USAGE : 0,
1970 # else
1971                         0,
1972 # endif
1973                         &verify))
1974          )
1975         goto tlsa_prob;
1976       }
1977
1978     if (verify != 0)            /* verification failed */
1979       {
1980       gnutls_datum_t str;
1981       (void) dane_verification_status_print(verify, &str, 0);
1982       *errstr = US str.data;    /* don't bother to free */
1983       goto badcert;
1984       }
1985
1986 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1987     /* If a TA-mode TLSA record was used for verification we must additionally
1988     verify the cert name (but not the CA chain).  For EE-mode, skip it. */
1989
1990     if (usage & (1 << DANESSL_USAGE_DANE_EE))
1991 # endif
1992       {
1993       state->peer_dane_verified = state->peer_cert_verified = TRUE;
1994       goto goodcert;
1995       }
1996 # ifdef GNUTLS_BROKEN_DANE_VALIDATION
1997     /* Assume that the name on the A-record is the one that should be matching
1998     the cert.  An alternate view is that the domain part of the email address
1999     is also permissible. */
2000
2001     if (gnutls_x509_crt_check_hostname(state->tlsp->peercert,
2002           CS state->host->name))
2003       {
2004       state->peer_dane_verified = state->peer_cert_verified = TRUE;
2005       goto goodcert;
2006       }
2007 # endif
2008     }
2009 #endif  /*SUPPORT_DANE*/
2010
2011   rc = gnutls_certificate_verify_peers2(state->session, &verify);
2012   }
2013
2014 /* Handle the result of verification. INVALID is set if any others are. */
2015
2016 if (rc < 0 || verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED))
2017   {
2018   state->peer_cert_verified = FALSE;
2019   if (!*errstr)
2020     {
2021 #ifdef GNUTLS_CERT_VFY_STATUS_PRINT
2022     DEBUG(D_tls)
2023       {
2024       gnutls_datum_t txt;
2025
2026       if (gnutls_certificate_verification_status_print(verify,
2027             gnutls_certificate_type_get(state->session), &txt, 0)
2028           == GNUTLS_E_SUCCESS)
2029         {
2030         debug_printf("%s\n", txt.data);
2031         gnutls_free(txt.data);
2032         }
2033       }
2034 #endif
2035     *errstr = verify & GNUTLS_CERT_REVOKED
2036       ? US"certificate revoked" : US"certificate invalid";
2037     }
2038
2039   DEBUG(D_tls)
2040     debug_printf("TLS certificate verification failed (%s): peerdn=\"%s\"\n",
2041         *errstr, state->peerdn ? state->peerdn : US"<unset>");
2042
2043   if (state->verify_requirement >= VERIFY_REQUIRED)
2044     goto badcert;
2045   DEBUG(D_tls)
2046     debug_printf("TLS verify failure overridden (host in tls_try_verify_hosts)\n");
2047   }
2048
2049 else
2050   {
2051   /* Client side, check the server's certificate name versus the name on the
2052   A-record for the connection we made.  What to do for server side - what name
2053   to use for client?  We document that there is no such checking for server
2054   side. */
2055
2056   if (  state->exp_tls_verify_cert_hostnames
2057      && !gnutls_x509_crt_check_hostname(state->tlsp->peercert,
2058                 CS state->exp_tls_verify_cert_hostnames)
2059      )
2060     {
2061     DEBUG(D_tls)
2062       debug_printf("TLS certificate verification failed: cert name mismatch\n");
2063     if (state->verify_requirement >= VERIFY_REQUIRED)
2064       goto badcert;
2065     return TRUE;
2066     }
2067
2068   state->peer_cert_verified = TRUE;
2069   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=\"%s\"\n",
2070       state->peerdn ? state->peerdn : US"<unset>");
2071   }
2072
2073 goodcert:
2074   state->tlsp->peerdn = state->peerdn;
2075   return TRUE;
2076
2077 #ifdef SUPPORT_DANE
2078 tlsa_prob:
2079   *errstr = string_sprintf("TLSA record problem: %s",
2080     rc == DANE_E_REQUESTED_DATA_NOT_AVAILABLE ? "none usable" : dane_strerror(rc));
2081 #endif
2082
2083 badcert:
2084   gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
2085   return FALSE;
2086 }
2087
2088
2089
2090
2091 /* ------------------------------------------------------------------------ */
2092 /* Callbacks */
2093
2094 /* Logging function which can be registered with
2095  *   gnutls_global_set_log_function()
2096  *   gnutls_global_set_log_level() 0..9
2097  */
2098 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
2099 static void
2100 exim_gnutls_logger_cb(int level, const char *message)
2101 {
2102   size_t len = strlen(message);
2103   if (len < 1)
2104     {
2105     DEBUG(D_tls) debug_printf("GnuTLS<%d> empty debug message\n", level);
2106     return;
2107     }
2108   DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s%s", level, message,
2109       message[len-1] == '\n' ? "" : "\n");
2110 }
2111 #endif
2112
2113
2114 /* Called after client hello, should handle SNI work.
2115 This will always set tls_sni (state->received_sni) if available,
2116 and may trigger presenting different certificates,
2117 if state->trigger_sni_changes is TRUE.
2118
2119 Should be registered with
2120   gnutls_handshake_set_post_client_hello_function()
2121
2122 "This callback must return 0 on success or a gnutls error code to terminate the
2123 handshake.".
2124
2125 For inability to get SNI information, we return 0.
2126 We only return non-zero if re-setup failed.
2127 Only used for server-side TLS.
2128 */
2129
2130 static int
2131 exim_sni_handling_cb(gnutls_session_t session)
2132 {
2133 char sni_name[MAX_HOST_LEN];
2134 size_t data_len = MAX_HOST_LEN;
2135 exim_gnutls_state_st *state = &state_server;
2136 unsigned int sni_type;
2137 int rc, old_pool;
2138 uschar * dummy_errstr;
2139
2140 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
2141 if (rc != GNUTLS_E_SUCCESS)
2142   {
2143   DEBUG(D_tls)
2144     if (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
2145       debug_printf("TLS: no SNI presented in handshake.\n");
2146     else
2147       debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
2148         gnutls_strerror(rc), rc);
2149   return 0;
2150   }
2151
2152 if (sni_type != GNUTLS_NAME_DNS)
2153   {
2154   DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
2155   return 0;
2156   }
2157
2158 /* We now have a UTF-8 string in sni_name */
2159 old_pool = store_pool;
2160 store_pool = POOL_PERM;
2161 state->received_sni = string_copy_taint(US sni_name, TRUE);
2162 store_pool = old_pool;
2163
2164 /* We set this one now so that variable expansions below will work */
2165 state->tlsp->sni = state->received_sni;
2166
2167 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
2168     state->trigger_sni_changes ? "" : " (unused for certificate selection)");
2169
2170 if (!state->trigger_sni_changes)
2171   return 0;
2172
2173 if ((rc = tls_expand_session_files(state, &dummy_errstr)) != OK)
2174   {
2175   /* If the setup of certs/etc failed before handshake, TLS would not have
2176   been offered.  The best we can do now is abort. */
2177   return GNUTLS_E_APPLICATION_ERROR_MIN;
2178   }
2179
2180 rc = tls_set_remaining_x509(state, &dummy_errstr);
2181 if (rc != OK) return GNUTLS_E_APPLICATION_ERROR_MIN;
2182
2183 return 0;
2184 }
2185
2186
2187
2188 #ifndef DISABLE_EVENT
2189 /*
2190 We use this callback to get observability and detail-level control
2191 for an exim TLS connection (either direction), raising a tls:cert event
2192 for each cert in the chain presented by the peer.  Any event
2193 can deny verification.
2194
2195 Return 0 for the handshake to continue or non-zero to terminate.
2196 */
2197
2198 static int
2199 verify_cb(gnutls_session_t session)
2200 {
2201 const gnutls_datum_t * cert_list;
2202 unsigned int cert_list_size = 0;
2203 gnutls_x509_crt_t crt;
2204 int rc;
2205 uschar * yield;
2206 exim_gnutls_state_st * state = gnutls_session_get_ptr(session);
2207
2208 if ((cert_list = gnutls_certificate_get_peers(session, &cert_list_size)))
2209   while (cert_list_size--)
2210   {
2211   if ((rc = import_cert(&cert_list[cert_list_size], &crt)) != GNUTLS_E_SUCCESS)
2212     {
2213     DEBUG(D_tls) debug_printf("TLS: peer cert problem: depth %d: %s\n",
2214       cert_list_size, gnutls_strerror(rc));
2215     break;
2216     }
2217
2218   state->tlsp->peercert = crt;
2219   if ((yield = event_raise(state->event_action,
2220               US"tls:cert", string_sprintf("%d", cert_list_size))))
2221     {
2222     log_write(0, LOG_MAIN,
2223               "SSL verify denied by event-action: depth=%d: %s",
2224               cert_list_size, yield);
2225     return 1;                     /* reject */
2226     }
2227   state->tlsp->peercert = NULL;
2228   }
2229
2230 return 0;
2231 }
2232
2233 #endif
2234
2235
2236 static gstring *
2237 ddump(gnutls_datum_t * d)
2238 {
2239 gstring * g = string_get((d->size+1) * 2);
2240 uschar * s = d->data;
2241 for (unsigned i = d->size; i > 0; i--, s++)
2242   {
2243   g = string_catn(g, US "0123456789abcdef" + (*s >> 4), 1);
2244   g = string_catn(g, US "0123456789abcdef" + (*s & 0xf), 1);
2245   }
2246 return g;
2247 }
2248
2249 static void
2250 post_handshake_debug(exim_gnutls_state_st * state)
2251 {
2252 #ifdef SUPPORT_GNUTLS_SESS_DESC
2253 debug_printf("%s\n", gnutls_session_get_desc(state->session));
2254 #endif
2255 #ifdef SUPPORT_GNUTLS_KEYLOG
2256
2257 # ifdef EXIM_HAVE_TLS1_3
2258 if (gnutls_protocol_get_version(state->session) < GNUTLS_TLS1_3)
2259 #else
2260 if (TRUE)
2261 #endif
2262   {
2263   gnutls_datum_t c, s;
2264   gstring * gc, * gs;
2265   /* we only want the client random and the master secret */
2266   gnutls_session_get_random(state->session, &c, &s);
2267   gnutls_session_get_master_secret(state->session, &s);
2268   gc = ddump(&c);
2269   gs = ddump(&s);
2270   debug_printf("CLIENT_RANDOM %.*s %.*s\n", (int)gc->ptr, gc->s, (int)gs->ptr, gs->s);
2271   }
2272 else
2273   debug_printf("To get keying info for TLS1.3 is hard:\n"
2274     " set environment variable SSLKEYLOGFILE to a filename writable by uid exim\n"
2275     " add SSLKEYLOGFILE to keep_environment in the exim config\n"
2276     " run exim as root\n"
2277     " if using sudo, add SSLKEYLOGFILE to env_keep in /etc/sudoers\n"
2278     " (works for TLS1.2 also, and saves cut-paste into file)\n");
2279 #endif
2280 }
2281
2282
2283 #ifdef EXPERIMENTAL_TLS_RESUME
2284 static int
2285 tls_server_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
2286   unsigned incoming, const gnutls_datum_t * msg)
2287 {
2288 DEBUG(D_tls) debug_printf("newticket cb\n");
2289 tls_in.resumption |= RESUME_CLIENT_REQUESTED;
2290 return 0;
2291 }
2292
2293 static void
2294 tls_server_resume_prehandshake(exim_gnutls_state_st * state)
2295 {
2296 /* Should the server offer session resumption? */
2297 tls_in.resumption = RESUME_SUPPORTED;
2298 if (verify_check_host(&tls_resumption_hosts) == OK)
2299   {
2300   int rc;
2301   /* GnuTLS appears to not do ticket overlap, but does emit a fresh ticket when
2302   an offered resumption is unacceptable.  We lose one resumption per ticket
2303   lifetime, and sessions cannot be indefinitely re-used.  There seems to be no
2304   way (3.6.7) of changing the default number of 2 TLS1.3 tickets issued, but at
2305   least they go out in a single packet. */
2306
2307   if (!(rc = gnutls_session_ticket_enable_server(state->session,
2308               &server_sessticket_key)))
2309     tls_in.resumption |= RESUME_SERVER_TICKET;
2310   else
2311     DEBUG(D_tls)
2312       debug_printf("enabling session tickets: %s\n", US gnutls_strerror(rc));
2313
2314   /* Try to tell if we see a ticket request */
2315   gnutls_handshake_set_hook_function(state->session,
2316     GNUTLS_HANDSHAKE_ANY, GNUTLS_HOOK_POST, tls_server_hook_cb);
2317   }
2318 }
2319
2320 static void
2321 tls_server_resume_posthandshake(exim_gnutls_state_st * state)
2322 {
2323 if (gnutls_session_resumption_requested(state->session))
2324   {
2325   /* This tells us the client sent a full ticket.  We use a
2326   callback on session-ticket request, elsewhere, to tell
2327   if a client asked for a ticket. */
2328
2329   tls_in.resumption |= RESUME_CLIENT_SUGGESTED;
2330   DEBUG(D_tls) debug_printf("client requested resumption\n");
2331   }
2332 if (gnutls_session_is_resumed(state->session))
2333   {
2334   tls_in.resumption |= RESUME_USED;
2335   DEBUG(D_tls) debug_printf("Session resumed\n");
2336   }
2337 }
2338 #endif
2339 /* ------------------------------------------------------------------------ */
2340 /* Exported functions */
2341
2342
2343
2344
2345 /*************************************************
2346 *       Start a TLS session in a server          *
2347 *************************************************/
2348
2349 /* This is called when Exim is running as a server, after having received
2350 the STARTTLS command. It must respond to that command, and then negotiate
2351 a TLS session.
2352
2353 Arguments:
2354   require_ciphers  list of allowed ciphers or NULL
2355   errstr           pointer to error string
2356
2357 Returns:           OK on success
2358                    DEFER for errors before the start of the negotiation
2359                    FAIL for errors during the negotiation; the server can't
2360                      continue running.
2361 */
2362
2363 int
2364 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2365 {
2366 int rc;
2367 exim_gnutls_state_st * state = NULL;
2368
2369 /* Check for previous activation */
2370 if (tls_in.active.sock >= 0)
2371   {
2372   tls_error(US"STARTTLS received after TLS started", US "", NULL, errstr);
2373   smtp_printf("554 Already in TLS\r\n", FALSE);
2374   return FAIL;
2375   }
2376
2377 /* Initialize the library. If it fails, it will already have logged the error
2378 and sent an SMTP response. */
2379
2380 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
2381
2382 if ((rc = tls_init(NULL, tls_certificate, tls_privatekey,
2383     NULL, tls_verify_certificates, tls_crl,
2384     require_ciphers, &state, &tls_in, errstr)) != OK) return rc;
2385
2386 #ifdef EXPERIMENTAL_TLS_RESUME
2387 tls_server_resume_prehandshake(state);
2388 #endif
2389
2390 /* If this is a host for which certificate verification is mandatory or
2391 optional, set up appropriately. */
2392
2393 if (verify_check_host(&tls_verify_hosts) == OK)
2394   {
2395   DEBUG(D_tls)
2396     debug_printf("TLS: a client certificate will be required.\n");
2397   state->verify_requirement = VERIFY_REQUIRED;
2398   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2399   }
2400 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2401   {
2402   DEBUG(D_tls)
2403     debug_printf("TLS: a client certificate will be requested but not required.\n");
2404   state->verify_requirement = VERIFY_OPTIONAL;
2405   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
2406   }
2407 else
2408   {
2409   DEBUG(D_tls)
2410     debug_printf("TLS: a client certificate will not be requested.\n");
2411   state->verify_requirement = VERIFY_NONE;
2412   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
2413   }
2414
2415 #ifndef DISABLE_EVENT
2416 if (event_action)
2417   {
2418   state->event_action = event_action;
2419   gnutls_session_set_ptr(state->session, state);
2420   gnutls_certificate_set_verify_function(state->x509_cred, verify_cb);
2421   }
2422 #endif
2423
2424 /* Register SNI handling; always, even if not in tls_certificate, so that the
2425 expansion variable $tls_sni is always available. */
2426
2427 gnutls_handshake_set_post_client_hello_function(state->session,
2428     exim_sni_handling_cb);
2429
2430 /* Set context and tell client to go ahead, except in the case of TLS startup
2431 on connection, where outputting anything now upsets the clients and tends to
2432 make them disconnect. We need to have an explicit fflush() here, to force out
2433 the response. Other smtp_printf() calls do not need it, because in non-TLS
2434 mode, the fflush() happens when smtp_getc() is called. */
2435
2436 if (!state->tlsp->on_connect)
2437   {
2438   smtp_printf("220 TLS go ahead\r\n", FALSE);
2439   fflush(smtp_out);
2440   }
2441
2442 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2443 that the GnuTLS library doesn't.
2444 From 3.1.0 there is gnutls_handshake_set_timeout() - but it requires you
2445 to set (and clear down afterwards) up a pull-timeout callback function that does
2446 a select, so we're no better off unless avoiding signals becomes an issue. */
2447
2448 gnutls_transport_set_ptr2(state->session,
2449     (gnutls_transport_ptr_t)(long) fileno(smtp_in),
2450     (gnutls_transport_ptr_t)(long) fileno(smtp_out));
2451 state->fd_in = fileno(smtp_in);
2452 state->fd_out = fileno(smtp_out);
2453
2454 sigalrm_seen = FALSE;
2455 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2456 do
2457   rc = gnutls_handshake(state->session);
2458 while (rc == GNUTLS_E_AGAIN ||  rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
2459 ALARM_CLR(0);
2460
2461 if (rc != GNUTLS_E_SUCCESS)
2462   {
2463   /* It seems that, except in the case of a timeout, we have to close the
2464   connection right here; otherwise if the other end is running OpenSSL it hangs
2465   until the server times out. */
2466
2467   if (sigalrm_seen)
2468     {
2469     tls_error(US"gnutls_handshake", US"timed out", NULL, errstr);
2470     gnutls_db_remove_session(state->session);
2471     }
2472   else
2473     {
2474     tls_error_gnu(US"gnutls_handshake", rc, NULL, errstr);
2475     (void) gnutls_alert_send_appropriate(state->session, rc);
2476     gnutls_deinit(state->session);
2477     gnutls_certificate_free_credentials(state->x509_cred);
2478     millisleep(500);
2479     shutdown(state->fd_out, SHUT_WR);
2480     for (int i = 1024; fgetc(smtp_in) != EOF && i > 0; ) i--;   /* drain skt */
2481     (void)fclose(smtp_out);
2482     (void)fclose(smtp_in);
2483     smtp_out = smtp_in = NULL;
2484     }
2485
2486   return FAIL;
2487   }
2488
2489 #ifdef EXPERIMENTAL_TLS_RESUME
2490 tls_server_resume_posthandshake(state);
2491 #endif
2492
2493 DEBUG(D_tls) post_handshake_debug(state);
2494
2495 /* Verify after the fact */
2496
2497 if (!verify_certificate(state, errstr))
2498   {
2499   if (state->verify_requirement != VERIFY_OPTIONAL)
2500     {
2501     (void) tls_error(US"certificate verification failed", *errstr, NULL, errstr);
2502     return FAIL;
2503     }
2504   DEBUG(D_tls)
2505     debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
2506         *errstr);
2507   }
2508
2509 /* Sets various Exim expansion variables; always safe within server */
2510
2511 extract_exim_vars_from_tls_state(state);
2512
2513 /* TLS has been set up. Adjust the input functions to read via TLS,
2514 and initialize appropriately. */
2515
2516 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2517
2518 receive_getc = tls_getc;
2519 receive_getbuf = tls_getbuf;
2520 receive_get_cache = tls_get_cache;
2521 receive_ungetc = tls_ungetc;
2522 receive_feof = tls_feof;
2523 receive_ferror = tls_ferror;
2524 receive_smtp_buffered = tls_smtp_buffered;
2525
2526 return OK;
2527 }
2528
2529
2530
2531
2532 static void
2533 tls_client_setup_hostname_checks(host_item * host, exim_gnutls_state_st * state,
2534   smtp_transport_options_block * ob)
2535 {
2536 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2537   {
2538   state->exp_tls_verify_cert_hostnames =
2539 #ifdef SUPPORT_I18N
2540     string_domain_utf8_to_alabel(host->name, NULL);
2541 #else
2542     host->name;
2543 #endif
2544   DEBUG(D_tls)
2545     debug_printf("TLS: server cert verification includes hostname: \"%s\".\n",
2546                     state->exp_tls_verify_cert_hostnames);
2547   }
2548 }
2549
2550
2551
2552
2553 #ifdef SUPPORT_DANE
2554 /* Given our list of RRs from the TLSA lookup, build a lookup block in
2555 GnuTLS-DANE's preferred format.  Hang it on the state str for later
2556 use in DANE verification.
2557
2558 We point at the dnsa data not copy it, so it must remain valid until
2559 after verification is done.*/
2560
2561 static BOOL
2562 dane_tlsa_load(exim_gnutls_state_st * state, dns_answer * dnsa)
2563 {
2564 dns_scan dnss;
2565 int i;
2566 const char **   dane_data;
2567 int *           dane_data_len;
2568
2569 i = 1;
2570 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2571      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2572     ) if (rr->type == T_TLSA) i++;
2573
2574 dane_data = store_get(i * sizeof(uschar *), FALSE);
2575 dane_data_len = store_get(i * sizeof(int), FALSE);
2576
2577 i = 0;
2578 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2579      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2580     ) if (rr->type == T_TLSA && rr->size > 3)
2581   {
2582   const uschar * p = rr->data;
2583 /*XXX need somehow to mark rr and its data as tainted.  Doues this mean copying it? */
2584   uint8_t usage = p[0], sel = p[1], type = p[2];
2585
2586   DEBUG(D_tls)
2587     debug_printf("TLSA: %d %d %d size %d\n", usage, sel, type, rr->size);
2588
2589   if (  (usage != DANESSL_USAGE_DANE_TA && usage != DANESSL_USAGE_DANE_EE)
2590      || (sel != 0 && sel != 1)
2591      )
2592     continue;
2593   switch(type)
2594     {
2595     case 0:     /* Full: cannot check at present */
2596                 break;
2597     case 1:     if (rr->size != 3 + 256/8) continue;    /* sha2-256 */
2598                 break;
2599     case 2:     if (rr->size != 3 + 512/8) continue;    /* sha2-512 */
2600                 break;
2601     default:    continue;
2602     }
2603
2604   tls_out.tlsa_usage |= 1<<usage;
2605   dane_data[i] = CS p;
2606   dane_data_len[i++] = rr->size;
2607   }
2608
2609 if (!i) return FALSE;
2610
2611 dane_data[i] = NULL;
2612 dane_data_len[i] = 0;
2613
2614 state->dane_data = (char * const *)dane_data;
2615 state->dane_data_len = dane_data_len;
2616 return TRUE;
2617 }
2618 #endif
2619
2620
2621
2622 #ifdef EXPERIMENTAL_TLS_RESUME
2623 /* On the client, get any stashed session for the given IP from hints db
2624 and apply it to the ssl-connection for attempted resumption.  Although
2625 there is a gnutls_session_ticket_enable_client() interface it is
2626 documented as unnecessary (as of 3.6.7) as "session tickets are emabled
2627 by deafult".  There seems to be no way to disable them, so even hosts not
2628 enabled by the transport option will be sent a ticket request.  We will
2629 however avoid storing and retrieving session information. */
2630
2631 static void
2632 tls_retrieve_session(tls_support * tlsp, gnutls_session_t session,
2633   host_item * host, smtp_transport_options_block * ob)
2634 {
2635 tlsp->resumption = RESUME_SUPPORTED;
2636 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2637   {
2638   dbdata_tls_session * dt;
2639   int len, rc;
2640   open_db dbblock, * dbm_file;
2641
2642   DEBUG(D_tls)
2643     debug_printf("check for resumable session for %s\n", host->address);
2644   tlsp->host_resumable = TRUE;
2645   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2646   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2647     {
2648     /* Key for the db is the IP.  We'd like to filter the retrieved session
2649     for ticket advisory expiry, but 3.6.1 seems to give no access to that */
2650
2651     if ((dt = dbfn_read_with_length(dbm_file, host->address, &len)))
2652       if (!(rc = gnutls_session_set_data(session,
2653                     CUS dt->session, (size_t)len - sizeof(dbdata_tls_session))))
2654         {
2655         DEBUG(D_tls) debug_printf("good session\n");
2656         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2657         }
2658       else DEBUG(D_tls) debug_printf("setting session resumption data: %s\n",
2659             US gnutls_strerror(rc));
2660     dbfn_close(dbm_file);
2661     }
2662   }
2663 }
2664
2665
2666 static void
2667 tls_save_session(tls_support * tlsp, gnutls_session_t session, const host_item * host)
2668 {
2669 /* TLS 1.2 - we get both the callback and the direct posthandshake call,
2670 but this flag is not set until the second.  TLS 1.3 it's the other way about.
2671 Keep both calls as the session data cannot be extracted before handshake
2672 completes. */
2673
2674 if (gnutls_session_get_flags(session) & GNUTLS_SFLAGS_SESSION_TICKET)
2675   {
2676   gnutls_datum_t tkt;
2677   int rc;
2678
2679   DEBUG(D_tls) debug_printf("server offered session ticket\n");
2680   tlsp->ticket_received = TRUE;
2681   tlsp->resumption |= RESUME_SERVER_TICKET;
2682
2683   if (tlsp->host_resumable)
2684     if (!(rc = gnutls_session_get_data2(session, &tkt)))
2685       {
2686       open_db dbblock, * dbm_file;
2687       int dlen = sizeof(dbdata_tls_session) + tkt.size;
2688       dbdata_tls_session * dt = store_get(dlen, TRUE);
2689
2690       DEBUG(D_tls) debug_printf("session data size %u\n", (unsigned)tkt.size);
2691       memcpy(dt->session, tkt.data, tkt.size);
2692       gnutls_free(tkt.data);
2693
2694       if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2695         {
2696         /* key for the db is the IP */
2697         dbfn_delete(dbm_file, host->address);
2698         dbfn_write(dbm_file, host->address, dt, dlen);
2699         dbfn_close(dbm_file);
2700
2701         DEBUG(D_tls)
2702           debug_printf("wrote session db (len %u)\n", (unsigned)dlen);
2703         }
2704       }
2705     else DEBUG(D_tls)
2706       debug_printf("extract session data: %s\n", US gnutls_strerror(rc));
2707   }
2708 }
2709
2710
2711 /* With a TLS1.3 session, the ticket(s) are not seen until
2712 the first data read is attempted.  And there's often two of them.
2713 Pick them up with this callback.  We are also called for 1.2
2714 but we do nothing.
2715 */
2716 static int
2717 tls_client_ticket_cb(gnutls_session_t sess, u_int htype, unsigned when,
2718   unsigned incoming, const gnutls_datum_t * msg)
2719 {
2720 exim_gnutls_state_st * state = gnutls_session_get_ptr(sess);
2721 tls_support * tlsp = state->tlsp;
2722
2723 DEBUG(D_tls) debug_printf("newticket cb\n");
2724
2725 if (!tlsp->ticket_received)
2726   tls_save_session(tlsp, sess, state->host);
2727 return 0;
2728 }
2729
2730
2731 static void
2732 tls_client_resume_prehandshake(exim_gnutls_state_st * state,
2733   tls_support * tlsp, host_item * host,
2734   smtp_transport_options_block * ob)
2735 {
2736 gnutls_session_set_ptr(state->session, state);
2737 gnutls_handshake_set_hook_function(state->session,
2738   GNUTLS_HANDSHAKE_NEW_SESSION_TICKET, GNUTLS_HOOK_POST, tls_client_ticket_cb);
2739
2740 tls_retrieve_session(tlsp, state->session, host, ob);
2741 }
2742
2743 static void
2744 tls_client_resume_posthandshake(exim_gnutls_state_st * state,
2745   tls_support * tlsp, host_item * host)
2746 {
2747 if (gnutls_session_is_resumed(state->session))
2748   {
2749   DEBUG(D_tls) debug_printf("Session resumed\n");
2750   tlsp->resumption |= RESUME_USED;
2751   }
2752
2753 tls_save_session(tlsp, state->session, host);
2754 }
2755 #endif  /* EXPERIMENTAL_TLS_RESUME */
2756
2757
2758 /*************************************************
2759 *    Start a TLS session in a client             *
2760 *************************************************/
2761
2762 /* Called from the smtp transport after STARTTLS has been accepted.
2763
2764 Arguments:
2765   cctx          connection context
2766   conn_args     connection details
2767   cookie        datum for randomness (not used)
2768   tlsp          record details of channel configuration here; must be non-NULL
2769   errstr        error string pointer
2770
2771 Returns:        TRUE for success with TLS session context set in smtp context,
2772                 FALSE on error
2773 */
2774
2775 BOOL
2776 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
2777   void * cookie ARG_UNUSED,
2778   tls_support * tlsp, uschar ** errstr)
2779 {
2780 host_item * host = conn_args->host;          /* for msgs and option-tests */
2781 transport_instance * tb = conn_args->tblock; /* always smtp or NULL */
2782 smtp_transport_options_block * ob = tb
2783   ? (smtp_transport_options_block *)tb->options_block
2784   : &smtp_transport_option_defaults;
2785 int rc;
2786 exim_gnutls_state_st * state = NULL;
2787 uschar * cipher_list = NULL;
2788
2789 #ifndef DISABLE_OCSP
2790 BOOL require_ocsp =
2791   verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
2792 BOOL request_ocsp = require_ocsp ? TRUE
2793   : verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2794 #endif
2795
2796 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", cctx->sock);
2797
2798 #ifdef SUPPORT_DANE
2799 /* If dane is flagged, have either request or require dane for this host, and
2800 a TLSA record found.  Therefore, dane verify required.  Which implies cert must
2801 be requested and supplied, dane verify must pass, and cert verify irrelevant
2802 (incl.  hostnames), and (caller handled) require_tls */
2803
2804 if (conn_args->dane && ob->dane_require_tls_ciphers)
2805   {
2806   /* not using expand_check_tlsvar because not yet in state */
2807   if (!expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2808       &cipher_list, errstr))
2809     return FALSE;
2810   cipher_list = cipher_list && *cipher_list
2811     ? ob->dane_require_tls_ciphers : ob->tls_require_ciphers;
2812   }
2813 #endif
2814
2815 if (!cipher_list)
2816   cipher_list = ob->tls_require_ciphers;
2817
2818 if (tls_init(host, ob->tls_certificate, ob->tls_privatekey,
2819     ob->tls_sni, ob->tls_verify_certificates, ob->tls_crl,
2820     cipher_list, &state, tlsp, errstr) != OK)
2821   return FALSE;
2822
2823   {
2824   int dh_min_bits = ob->tls_dh_min_bits;
2825   if (dh_min_bits < EXIM_CLIENT_DH_MIN_MIN_BITS)
2826     {
2827     DEBUG(D_tls)
2828       debug_printf("WARNING: tls_dh_min_bits far too low,"
2829                     " clamping %d up to %d\n",
2830           dh_min_bits, EXIM_CLIENT_DH_MIN_MIN_BITS);
2831     dh_min_bits = EXIM_CLIENT_DH_MIN_MIN_BITS;
2832     }
2833
2834   DEBUG(D_tls) debug_printf("Setting D-H prime minimum"
2835                     " acceptable bits to %d\n",
2836       dh_min_bits);
2837   gnutls_dh_set_prime_bits(state->session, dh_min_bits);
2838   }
2839
2840 /* Stick to the old behaviour for compatibility if tls_verify_certificates is
2841 set but both tls_verify_hosts and tls_try_verify_hosts are unset. Check only
2842 the specified host patterns if one of them is defined */
2843
2844 #ifdef SUPPORT_DANE
2845 if (conn_args->dane && dane_tlsa_load(state, &conn_args->tlsa_dnsa))
2846   {
2847   DEBUG(D_tls)
2848     debug_printf("TLS: server certificate DANE required.\n");
2849   state->verify_requirement = VERIFY_DANE;
2850   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2851   }
2852 else
2853 #endif
2854     if (  (  state->exp_tls_verify_certificates
2855           && !ob->tls_verify_hosts
2856           && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2857           )
2858         || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2859        )
2860   {
2861   tls_client_setup_hostname_checks(host, state, ob);
2862   DEBUG(D_tls)
2863     debug_printf("TLS: server certificate verification required.\n");
2864   state->verify_requirement = VERIFY_REQUIRED;
2865   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
2866   }
2867 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2868   {
2869   tls_client_setup_hostname_checks(host, state, ob);
2870   DEBUG(D_tls)
2871     debug_printf("TLS: server certificate verification optional.\n");
2872   state->verify_requirement = VERIFY_OPTIONAL;
2873   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
2874   }
2875 else
2876   {
2877   DEBUG(D_tls)
2878     debug_printf("TLS: server certificate verification not required.\n");
2879   state->verify_requirement = VERIFY_NONE;
2880   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
2881   }
2882
2883 #ifndef DISABLE_OCSP
2884                         /* supported since GnuTLS 3.1.3 */
2885 if (request_ocsp)
2886   {
2887   DEBUG(D_tls) debug_printf("TLS: will request OCSP stapling\n");
2888   if ((rc = gnutls_ocsp_status_request_enable_client(state->session,
2889                     NULL, 0, NULL)) != OK)
2890     {
2891     tls_error_gnu(US"cert-status-req", rc, state->host, errstr);
2892     return FALSE;
2893     }
2894   tlsp->ocsp = OCSP_NOT_RESP;
2895   }
2896 #endif
2897
2898 #ifdef EXPERIMENTAL_TLS_RESUME
2899 tls_client_resume_prehandshake(state, tlsp, host, ob);
2900 #endif
2901
2902 #ifndef DISABLE_EVENT
2903 if (tb && tb->event_action)
2904   {
2905   state->event_action = tb->event_action;
2906   gnutls_session_set_ptr(state->session, state);
2907   gnutls_certificate_set_verify_function(state->x509_cred, verify_cb);
2908   }
2909 #endif
2910
2911 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr_t)(long) cctx->sock);
2912 state->fd_in = cctx->sock;
2913 state->fd_out = cctx->sock;
2914
2915 DEBUG(D_tls) debug_printf("about to gnutls_handshake\n");
2916 /* There doesn't seem to be a built-in timeout on connection. */
2917
2918 sigalrm_seen = FALSE;
2919 ALARM(ob->command_timeout);
2920 do
2921   rc = gnutls_handshake(state->session);
2922 while (rc == GNUTLS_E_AGAIN || rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen);
2923 ALARM_CLR(0);
2924
2925 if (rc != GNUTLS_E_SUCCESS)
2926   {
2927   if (sigalrm_seen)
2928     {
2929     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_USER_CANCELED);
2930     tls_error(US"gnutls_handshake", US"timed out", state->host, errstr);
2931     }
2932   else
2933     tls_error_gnu(US"gnutls_handshake", rc, state->host, errstr);
2934   return FALSE;
2935   }
2936
2937 DEBUG(D_tls) post_handshake_debug(state);
2938
2939 /* Verify late */
2940
2941 if (!verify_certificate(state, errstr))
2942   {
2943   tls_error(US"certificate verification failed", *errstr, state->host, errstr);
2944   return FALSE;
2945   }
2946
2947 #ifndef DISABLE_OCSP
2948 if (request_ocsp)
2949   {
2950   DEBUG(D_tls)
2951     {
2952     gnutls_datum_t stapling;
2953     gnutls_ocsp_resp_t resp;
2954     gnutls_datum_t printed;
2955     unsigned idx = 0;
2956
2957     for (;
2958 # ifdef GNUTLS_OCSP_STATUS_REQUEST_GET2
2959          (rc = gnutls_ocsp_status_request_get2(state->session, idx, &stapling)) == 0;
2960 #else
2961          (rc = gnutls_ocsp_status_request_get(state->session, &stapling)) == 0;
2962 #endif
2963          idx++)
2964       if (  (rc= gnutls_ocsp_resp_init(&resp)) == 0
2965          && (rc= gnutls_ocsp_resp_import(resp, &stapling)) == 0
2966          && (rc= gnutls_ocsp_resp_print(resp, GNUTLS_OCSP_PRINT_COMPACT, &printed)) == 0
2967          )
2968         {
2969         debug_printf("%.4096s", printed.data);
2970         gnutls_free(printed.data);
2971         }
2972       else
2973         (void) tls_error_gnu(US"ocsp decode", rc, state->host, errstr);
2974     if (idx == 0 && rc)
2975       (void) tls_error_gnu(US"ocsp decode", rc, state->host, errstr);
2976     }
2977
2978   if (gnutls_ocsp_status_request_is_checked(state->session, 0) == 0)
2979     {
2980     tlsp->ocsp = OCSP_FAILED;
2981     tls_error(US"certificate status check failed", NULL, state->host, errstr);
2982     if (require_ocsp)
2983       return FALSE;
2984     }
2985   else
2986     {
2987     DEBUG(D_tls) debug_printf("Passed OCSP checking\n");
2988     tlsp->ocsp = OCSP_VFIED;
2989     }
2990   }
2991 #endif
2992
2993 #ifdef EXPERIMENTAL_TLS_RESUME
2994 tls_client_resume_posthandshake(state, tlsp, host);
2995 #endif
2996
2997 /* Sets various Exim expansion variables; may need to adjust for ACL callouts */
2998
2999 extract_exim_vars_from_tls_state(state);
3000
3001 cctx->tls_ctx = state;
3002 return TRUE;
3003 }
3004
3005
3006
3007
3008 /*************************************************
3009 *         Close down a TLS session               *
3010 *************************************************/
3011
3012 /* This is also called from within a delivery subprocess forked from the
3013 daemon, to shut down the TLS library, without actually doing a shutdown (which
3014 would tamper with the TLS session in the parent process).
3015
3016 Arguments:
3017   ct_ctx        client context pointer, or NULL for the one global server context
3018   shutdown      1 if TLS close-alert is to be sent,
3019                 2 if also response to be waited for
3020
3021 Returns:     nothing
3022 */
3023
3024 void
3025 tls_close(void * ct_ctx, int shutdown)
3026 {
3027 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3028 tls_support * tlsp = state->tlsp;
3029
3030 if (!tlsp || tlsp->active.sock < 0) return;  /* TLS was not active */
3031
3032 if (shutdown)
3033   {
3034   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3035     shutdown > 1 ? " (with response-wait)" : "");
3036
3037   ALARM(2);
3038   gnutls_bye(state->session, shutdown > 1 ? GNUTLS_SHUT_RDWR : GNUTLS_SHUT_WR);
3039   ALARM_CLR(0);
3040   }
3041
3042 if (!ct_ctx)    /* server */
3043   {
3044   receive_getc =        smtp_getc;
3045   receive_getbuf =      smtp_getbuf;
3046   receive_get_cache =   smtp_get_cache;
3047   receive_ungetc =      smtp_ungetc;
3048   receive_feof =        smtp_feof;
3049   receive_ferror =      smtp_ferror;
3050   receive_smtp_buffered = smtp_buffered;
3051   }
3052
3053 gnutls_deinit(state->session);
3054 gnutls_certificate_free_credentials(state->x509_cred);
3055
3056 tlsp->active.sock = -1;
3057 tlsp->active.tls_ctx = NULL;
3058 /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
3059 tls_channelbinding_b64 = NULL;
3060
3061
3062 if (state->xfer_buffer) store_free(state->xfer_buffer);
3063 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
3064 }
3065
3066
3067
3068
3069 static BOOL
3070 tls_refill(unsigned lim)
3071 {
3072 exim_gnutls_state_st * state = &state_server;
3073 ssize_t inbytes;
3074
3075 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
3076   state->session, state->xfer_buffer, ssl_xfer_buffer_size);
3077
3078 sigalrm_seen = FALSE;
3079 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3080
3081 do
3082   inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
3083     MIN(ssl_xfer_buffer_size, lim));
3084 while (inbytes == GNUTLS_E_AGAIN);
3085
3086 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3087
3088 if (had_command_timeout)                /* set by signal handler */
3089   smtp_command_timeout_exit();          /* does not return */
3090 if (had_command_sigterm)
3091   smtp_command_sigterm_exit();
3092 if (had_data_timeout)
3093   smtp_data_timeout_exit();
3094 if (had_data_sigint)
3095   smtp_data_sigint_exit();
3096
3097 /* Timeouts do not get this far.  A zero-byte return appears to mean that the
3098 TLS session has been closed down, not that the socket itself has been closed
3099 down. Revert to non-TLS handling. */
3100
3101 if (sigalrm_seen)
3102   {
3103   DEBUG(D_tls) debug_printf("Got tls read timeout\n");
3104   state->xfer_error = TRUE;
3105   return FALSE;
3106   }
3107
3108 else if (inbytes == 0)
3109   {
3110   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
3111   tls_close(NULL, TLS_NO_SHUTDOWN);
3112   return FALSE;
3113   }
3114
3115 /* Handle genuine errors */
3116
3117 else if (inbytes < 0)
3118   {
3119   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
3120   record_io_error(state, (int) inbytes, US"recv", NULL);
3121   state->xfer_error = TRUE;
3122   return FALSE;
3123   }
3124 #ifndef DISABLE_DKIM
3125 dkim_exim_verify_feed(state->xfer_buffer, inbytes);
3126 #endif
3127 state->xfer_buffer_hwm = (int) inbytes;
3128 state->xfer_buffer_lwm = 0;
3129 return TRUE;
3130 }
3131
3132 /*************************************************
3133 *            TLS version of getc                 *
3134 *************************************************/
3135
3136 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3137 it refills the buffer via the GnuTLS reading function.
3138 Only used by the server-side TLS.
3139
3140 This feeds DKIM and should be used for all message-body reads.
3141
3142 Arguments:  lim         Maximum amount to read/buffer
3143 Returns:    the next character or EOF
3144 */
3145
3146 int
3147 tls_getc(unsigned lim)
3148 {
3149 exim_gnutls_state_st * state = &state_server;
3150
3151 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
3152   if (!tls_refill(lim))
3153     return state->xfer_error ? EOF : smtp_getc(lim);
3154
3155 /* Something in the buffer; return next uschar */
3156
3157 return state->xfer_buffer[state->xfer_buffer_lwm++];
3158 }
3159
3160 uschar *
3161 tls_getbuf(unsigned * len)
3162 {
3163 exim_gnutls_state_st * state = &state_server;
3164 unsigned size;
3165 uschar * buf;
3166
3167 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
3168   if (!tls_refill(*len))
3169     {
3170     if (!state->xfer_error) return smtp_getbuf(len);
3171     *len = 0;
3172     return NULL;
3173     }
3174
3175 if ((size = state->xfer_buffer_hwm - state->xfer_buffer_lwm) > *len)
3176   size = *len;
3177 buf = &state->xfer_buffer[state->xfer_buffer_lwm];
3178 state->xfer_buffer_lwm += size;
3179 *len = size;
3180 return buf;
3181 }
3182
3183
3184 void
3185 tls_get_cache()
3186 {
3187 #ifndef DISABLE_DKIM
3188 exim_gnutls_state_st * state = &state_server;
3189 int n = state->xfer_buffer_hwm - state->xfer_buffer_lwm;
3190 if (n > 0)
3191   dkim_exim_verify_feed(state->xfer_buffer+state->xfer_buffer_lwm, n);
3192 #endif
3193 }
3194
3195
3196 BOOL
3197 tls_could_read(void)
3198 {
3199 return state_server.xfer_buffer_lwm < state_server.xfer_buffer_hwm
3200  || gnutls_record_check_pending(state_server.session) > 0;
3201 }
3202
3203
3204
3205
3206 /*************************************************
3207 *          Read bytes from TLS channel           *
3208 *************************************************/
3209
3210 /* This does not feed DKIM, so if the caller uses this for reading message body,
3211 then the caller must feed DKIM.
3212
3213 Arguments:
3214   ct_ctx    client context pointer, or NULL for the one global server context
3215   buff      buffer of data
3216   len       size of buffer
3217
3218 Returns:    the number of bytes read
3219             -1 after a failed read, including EOF
3220 */
3221
3222 int
3223 tls_read(void * ct_ctx, uschar *buff, size_t len)
3224 {
3225 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3226 ssize_t inbytes;
3227
3228 if (len > INT_MAX)
3229   len = INT_MAX;
3230
3231 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
3232   DEBUG(D_tls)
3233     debug_printf("*** PROBABLY A BUG *** " \
3234         "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
3235         state->xfer_buffer_hwm - state->xfer_buffer_lwm);
3236
3237 DEBUG(D_tls)
3238   debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT ")\n",
3239       state->session, buff, len);
3240
3241 do
3242   inbytes = gnutls_record_recv(state->session, buff, len);
3243 while (inbytes == GNUTLS_E_AGAIN);
3244
3245 if (inbytes > 0) return inbytes;
3246 if (inbytes == 0)
3247   {
3248   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
3249   }
3250 else
3251   {
3252   DEBUG(D_tls) debug_printf("%s: err from gnutls_record_recv\n", __FUNCTION__);
3253   record_io_error(state, (int)inbytes, US"recv", NULL);
3254   }
3255
3256 return -1;
3257 }
3258
3259
3260
3261
3262 /*************************************************
3263 *         Write bytes down TLS channel           *
3264 *************************************************/
3265
3266 /*
3267 Arguments:
3268   ct_ctx    client context pointer, or NULL for the one global server context
3269   buff      buffer of data
3270   len       number of bytes
3271   more      more data expected soon
3272
3273 Returns:    the number of bytes after a successful write,
3274             -1 after a failed write
3275 */
3276
3277 int
3278 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
3279 {
3280 ssize_t outbytes;
3281 size_t left = len;
3282 exim_gnutls_state_st * state = ct_ctx ? ct_ctx : &state_server;
3283 #ifdef SUPPORT_CORK
3284 static BOOL corked = FALSE;
3285
3286 if (more && !corked) gnutls_record_cork(state->session);
3287 #endif
3288
3289 DEBUG(D_tls) debug_printf("%s(%p, " SIZE_T_FMT "%s)\n", __FUNCTION__,
3290   buff, left, more ? ", more" : "");
3291
3292 while (left > 0)
3293   {
3294   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT ")\n",
3295       buff, left);
3296
3297   do
3298     outbytes = gnutls_record_send(state->session, buff, left);
3299   while (outbytes == GNUTLS_E_AGAIN);
3300
3301   DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
3302   if (outbytes < 0)
3303     {
3304     DEBUG(D_tls) debug_printf("%s: gnutls_record_send err\n", __FUNCTION__);
3305     record_io_error(state, outbytes, US"send", NULL);
3306     return -1;
3307     }
3308   if (outbytes == 0)
3309     {
3310     record_io_error(state, 0, US"send", US"TLS channel closed on write");
3311     return -1;
3312     }
3313
3314   left -= outbytes;
3315   buff += outbytes;
3316   }
3317
3318 if (len > INT_MAX)
3319   {
3320   DEBUG(D_tls)
3321     debug_printf("Whoops!  Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
3322         len);
3323   len = INT_MAX;
3324   }
3325
3326 #ifdef SUPPORT_CORK
3327 if (more != corked)
3328   {
3329   if (!more) (void) gnutls_record_uncork(state->session, 0);
3330   corked = more;
3331   }
3332 #endif
3333
3334 return (int) len;
3335 }
3336
3337
3338
3339
3340 /*************************************************
3341 *            Random number generation            *
3342 *************************************************/
3343
3344 /* Pseudo-random number generation.  The result is not expected to be
3345 cryptographically strong but not so weak that someone will shoot themselves
3346 in the foot using it as a nonce in input in some email header scheme or
3347 whatever weirdness they'll twist this into.  The result should handle fork()
3348 and avoid repeating sequences.  OpenSSL handles that for us.
3349
3350 Arguments:
3351   max       range maximum
3352 Returns     a random number in range [0, max-1]
3353 */
3354
3355 #ifdef HAVE_GNUTLS_RND
3356 int
3357 vaguely_random_number(int max)
3358 {
3359 unsigned int r;
3360 int i, needed_len;
3361 uschar smallbuf[sizeof(r)];
3362
3363 if (max <= 1)
3364   return 0;
3365
3366 needed_len = sizeof(r);
3367 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3368 asked for a number less than 10. */
3369
3370 for (r = max, i = 0; r; ++i)
3371   r >>= 1;
3372 i = (i + 7) / 8;
3373 if (i < needed_len)
3374   needed_len = i;
3375
3376 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
3377 if (i < 0)
3378   {
3379   DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback.\n");
3380   return vaguely_random_number_fallback(max);
3381   }
3382 r = 0;
3383 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3384   r = r * 256 + *p;
3385
3386 /* We don't particularly care about weighted results; if someone wants
3387  * smooth distribution and cares enough then they should submit a patch then. */
3388 return r % max;
3389 }
3390 #else /* HAVE_GNUTLS_RND */
3391 int
3392 vaguely_random_number(int max)
3393 {
3394   return vaguely_random_number_fallback(max);
3395 }
3396 #endif /* HAVE_GNUTLS_RND */
3397
3398
3399
3400
3401 /*************************************************
3402 *  Let tls_require_ciphers be checked at startup *
3403 *************************************************/
3404
3405 /* The tls_require_ciphers option, if set, must be something which the
3406 library can parse.
3407
3408 Returns:     NULL on success, or error message
3409 */
3410
3411 uschar *
3412 tls_validate_require_cipher(void)
3413 {
3414 int rc;
3415 uschar *expciphers = NULL;
3416 gnutls_priority_t priority_cache;
3417 const char *errpos;
3418 uschar * dummy_errstr;
3419
3420 #define validate_check_rc(Label) do { \
3421   if (rc != GNUTLS_E_SUCCESS) { if (exim_gnutls_base_init_done) gnutls_global_deinit(); \
3422   return string_sprintf("%s failed: %s", (Label), gnutls_strerror(rc)); } } while (0)
3423 #define return_deinit(Label) do { gnutls_global_deinit(); return (Label); } while (0)
3424
3425 if (exim_gnutls_base_init_done)
3426   log_write(0, LOG_MAIN|LOG_PANIC,
3427       "already initialised GnuTLS, Exim developer bug");
3428
3429 #ifdef HAVE_GNUTLS_PKCS11
3430 if (!gnutls_allow_auto_pkcs11)
3431   {
3432   rc = gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_MANUAL, NULL);
3433   validate_check_rc(US"gnutls_pkcs11_init");
3434   }
3435 #endif
3436 rc = gnutls_global_init();
3437 validate_check_rc(US"gnutls_global_init()");
3438 exim_gnutls_base_init_done = TRUE;
3439
3440 if (!(tls_require_ciphers && *tls_require_ciphers))
3441   return_deinit(NULL);
3442
3443 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3444                   &dummy_errstr))
3445   return_deinit(US"failed to expand tls_require_ciphers");
3446
3447 if (!(expciphers && *expciphers))
3448   return_deinit(NULL);
3449
3450 DEBUG(D_tls)
3451   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3452
3453 rc = gnutls_priority_init(&priority_cache, CS expciphers, &errpos);
3454 validate_check_rc(string_sprintf(
3455       "gnutls_priority_init(%s) failed at offset %ld, \"%.8s..\"",
3456       expciphers, errpos - CS expciphers, errpos));
3457
3458 #undef return_deinit
3459 #undef validate_check_rc
3460 gnutls_global_deinit();
3461
3462 return NULL;
3463 }
3464
3465
3466
3467
3468 /*************************************************
3469 *         Report the library versions.           *
3470 *************************************************/
3471
3472 /* See a description in tls-openssl.c for an explanation of why this exists.
3473
3474 Arguments:   a FILE* to print the results to
3475 Returns:     nothing
3476 */
3477
3478 void
3479 tls_version_report(FILE *f)
3480 {
3481 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
3482            "                         Runtime: %s\n",
3483            LIBGNUTLS_VERSION,
3484            gnutls_check_version(NULL));
3485 }
3486
3487 #endif  /*!MACRO_PREDEF*/
3488 /* vi: aw ai sw=2
3489 */
3490 /* End of tls-gnu.c */