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