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