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