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