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