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