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