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