214007e5f744046a87c72debccbdbf5a9051859f
[exim.git] / src / src / tls-gnu.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
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 Mavroyanopoulos.  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 /* GnuTLS 2 vs 3
44
45 GnuTLS 3 only:
46   gnutls_global_set_audit_log_function()
47
48 Changes:
49   gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
50 */
51
52 /* Local static variables for GnuTLS */
53
54 /* Values for verify_requirement */
55
56 enum peer_verify_requirement { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED };
57
58 /* This holds most state for server or client; with this, we can set up an
59 outbound TLS-enabled connection in an ACL callout, while not stomping all
60 over the TLS variables available for expansion.
61
62 Some of these correspond to variables in globals.c; those variables will
63 be set to point to content in one of these instances, as appropriate for
64 the stage of the process lifetime.
65
66 Not handled here: globals tls_active, tls_bits, tls_cipher, tls_peerdn,
67 tls_certificate_verified, tls_channelbinding_b64, tls_sni.
68 */
69
70 typedef struct exim_gnutls_state {
71   gnutls_session_t session;
72   gnutls_certificate_credentials_t x509_cred;
73   gnutls_priority_t priority_cache;
74   enum peer_verify_requirement verify_requirement;
75   int fd_in;
76   int fd_out;
77   BOOL peer_cert_verified;
78   BOOL trigger_sni_changes;
79   BOOL have_set_peerdn;
80   const struct host_item *host;
81   uschar *peerdn;
82   uschar *ciphersuite;
83   uschar *received_sni;
84
85   const uschar *tls_certificate;
86   const uschar *tls_privatekey;
87   const uschar *tls_sni; /* client send only, not received */
88   const uschar *tls_verify_certificates;
89   const uschar *tls_crl;
90   const uschar *tls_require_ciphers;
91   uschar *exp_tls_certificate;
92   uschar *exp_tls_privatekey;
93   uschar *exp_tls_sni;
94   uschar *exp_tls_verify_certificates;
95   uschar *exp_tls_crl;
96   uschar *exp_tls_require_ciphers;
97
98   uschar *xfer_buffer;
99   int xfer_buffer_lwm;
100   int xfer_buffer_hwm;
101   int xfer_eof;
102   int xfer_error;
103 } exim_gnutls_state_st;
104
105 static const exim_gnutls_state_st exim_gnutls_state_init = {
106   NULL, NULL, NULL, VERIFY_NONE, -1, -1, FALSE, FALSE, FALSE,
107   NULL, NULL, NULL, NULL,
108   NULL, NULL, NULL, NULL, NULL, NULL,
109   NULL, NULL, NULL, NULL, NULL, NULL,
110   NULL, 0, 0, 0, 0,
111 };
112
113 /* Not only do we have our own APIs which don't pass around state, assuming
114 it's held in globals, GnuTLS doesn't appear to let us register callback data
115 for callbacks, or as part of the session, so we have to keep a "this is the
116 context we're currently dealing with" pointer and rely upon being
117 single-threaded to keep from processing data on an inbound TLS connection while
118 talking to another TLS connection for an outbound check.  This does mean that
119 there's no way for heart-beats to be responded to, for the duration of the
120 second connection. */
121
122 static exim_gnutls_state_st state_server, state_client;
123 static exim_gnutls_state_st *current_global_tls_state;
124
125 /* dh_params are initialised once within the lifetime of a process using TLS;
126 if we used TLS in a long-lived daemon, we'd have to reconsider this.  But we
127 don't want to repeat this. */
128
129 static gnutls_dh_params_t dh_server_params = NULL;
130
131 /* No idea how this value was chosen; preserving it.  Default is 3600. */
132
133 static const int ssl_session_timeout = 200;
134
135 static const char * const exim_default_gnutls_priority = "NORMAL";
136
137 /* Guard library core initialisation */
138
139 static BOOL exim_gnutls_base_init_done = FALSE;
140
141
142 /* ------------------------------------------------------------------------ */
143 /* macros */
144
145 #define MAX_HOST_LEN 255
146
147 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
148 the library logging; a value less than 0 disables the calls to set up logging
149 callbacks. */
150 #ifndef EXIM_GNUTLS_LIBRARY_LOG_LEVEL
151 #define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
152 #endif
153
154 #ifndef EXIM_CLIENT_DH_MIN_BITS
155 #define EXIM_CLIENT_DH_MIN_BITS 1024
156 #endif
157
158 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
159 can ask for a bit-strength.  Without that, we stick to the constant we had
160 before, for now. */
161 #ifndef EXIM_SERVER_DH_BITS_PRE2_12
162 #define EXIM_SERVER_DH_BITS_PRE2_12 1024
163 #endif
164
165 #define exim_gnutls_err_check(Label) do { \
166   if (rc != GNUTLS_E_SUCCESS) { return tls_error((Label), gnutls_strerror(rc), host); } } while (0)
167
168 #define expand_check_tlsvar(Varname) expand_check(state->Varname, US #Varname, &state->exp_##Varname)
169
170 #if GNUTLS_VERSION_NUMBER >= 0x020c00
171 #define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
172 #define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
173 #define HAVE_GNUTLS_RND
174 #endif
175
176
177
178
179 /* ------------------------------------------------------------------------ */
180 /* Callback declarations */
181
182 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
183 static void exim_gnutls_logger_cb(int level, const char *message);
184 #endif
185
186 static int exim_sni_handling_cb(gnutls_session_t session);
187
188
189
190
191 /* ------------------------------------------------------------------------ */
192 /* Static functions */
193
194 /*************************************************
195 *               Handle TLS error                 *
196 *************************************************/
197
198 /* Called from lots of places when errors occur before actually starting to do
199 the TLS handshake, that is, while the session is still in clear. Always returns
200 DEFER for a server and FAIL for a client so that most calls can use "return
201 tls_error(...)" to do this processing and then give an appropriate return. A
202 single function is used for both server and client, because it is called from
203 some shared functions.
204
205 Argument:
206   prefix    text to include in the logged error
207   msg       additional error string (may be NULL)
208             usually obtained from gnutls_strerror()
209   host      NULL if setting up a server;
210             the connected host if setting up a client
211
212 Returns:    OK/DEFER/FAIL
213 */
214
215 static int
216 tls_error(const uschar *prefix, const char *msg, const host_item *host)
217 {
218 if (host)
219   {
220   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s)%s%s",
221       host->name, host->address, prefix, msg ? ": " : "", msg ? msg : "");
222   return FAIL;
223   }
224 else
225   {
226   uschar *conn_info = smtp_get_connection_info();
227   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
228     conn_info += 5;
229   log_write(0, LOG_MAIN, "TLS error on %s (%s)%s%s",
230       conn_info, prefix, msg ? ": " : "", msg ? msg : "");
231   return DEFER;
232   }
233 }
234
235
236
237
238 /*************************************************
239 *    Deal with logging errors during I/O         *
240 *************************************************/
241
242 /* We have to get the identity of the peer from saved data.
243
244 Argument:
245   state    the current GnuTLS exim state container
246   rc       the GnuTLS error code, or 0 if it's a local error
247   when     text identifying read or write
248   text     local error text when ec is 0
249
250 Returns:   nothing
251 */
252
253 static void
254 record_io_error(exim_gnutls_state_st *state, int rc, uschar *when, uschar *text)
255 {
256 const char *msg;
257
258 if (rc == GNUTLS_E_FATAL_ALERT_RECEIVED)
259   msg = CS string_sprintf("%s: %s", US gnutls_strerror(rc),
260     US gnutls_alert_get_name(gnutls_alert_get(state->session)));
261 else
262   msg = gnutls_strerror(rc);
263
264 tls_error(when, msg, state->host);
265 }
266
267
268
269
270 /*************************************************
271 *        Set various Exim expansion vars         *
272 *************************************************/
273
274 /* We set various Exim global variables from the state, once a session has
275 been established.  With TLS callouts, may need to change this to stack
276 variables, or just re-call it with the server state after client callout
277 has finished.
278
279 Make sure anything set here is inset in tls_getc().
280
281 Sets:
282   tls_active                fd
283   tls_bits                  strength indicator
284   tls_certificate_verified  bool indicator
285   tls_channelbinding_b64    for some SASL mechanisms
286   tls_cipher                a string
287   tls_peerdn                a string
288   tls_sni                   a (UTF-8) string
289 Also:
290   current_global_tls_state  for API limitations
291
292 Argument:
293   state      the relevant exim_gnutls_state_st *
294 */
295
296 static void
297 extract_exim_vars_from_tls_state(exim_gnutls_state_st *state)
298 {
299 gnutls_cipher_algorithm_t cipher;
300 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
301 int old_pool;
302 int rc;
303 gnutls_datum_t channel;
304 #endif
305
306 current_global_tls_state = state;
307
308 tls_active = state->fd_out;
309
310 cipher = gnutls_cipher_get(state->session);
311 /* returns size in "bytes" */
312 tls_bits = gnutls_cipher_get_key_size(cipher) * 8;
313
314 tls_cipher = state->ciphersuite;
315
316 DEBUG(D_tls) debug_printf("cipher: %s\n", tls_cipher);
317
318 tls_certificate_verified = state->peer_cert_verified;
319
320 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
321 only available for use for authenticators while this TLS session is running. */
322
323 tls_channelbinding_b64 = NULL;
324 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
325 channel.data = NULL;
326 channel.size = 0;
327 rc = gnutls_session_channel_binding(state->session, GNUTLS_CB_TLS_UNIQUE, &channel);
328 if (rc) {
329   DEBUG(D_tls) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc));
330 } else {
331   old_pool = store_pool;
332   store_pool = POOL_PERM;
333   tls_channelbinding_b64 = auth_b64encode(channel.data, (int)channel.size);
334   store_pool = old_pool;
335   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage.\n");
336 }
337 #endif
338
339 tls_peerdn = state->peerdn;
340
341 tls_sni = state->received_sni;
342 }
343
344
345
346
347 /*************************************************
348 *            Setup up DH parameters              *
349 *************************************************/
350
351 /* Generating the D-H parameters may take a long time. They only need to
352 be re-generated every so often, depending on security policy. What we do is to
353 keep these parameters in a file in the spool directory. If the file does not
354 exist, we generate them. This means that it is easy to cause a regeneration.
355
356 The new file is written as a temporary file and renamed, so that an incomplete
357 file is never present. If two processes both compute some new parameters, you
358 waste a bit of effort, but it doesn't seem worth messing around with locking to
359 prevent this.
360
361 Argument:
362   host       NULL for server, server for client (for error handling)
363
364 Returns:     OK/DEFER/FAIL
365 */
366
367 static int
368 init_server_dh(void)
369 {
370 int fd, rc;
371 unsigned int dh_bits;
372 gnutls_datum m;
373 uschar filename[PATH_MAX];
374 size_t sz;
375 host_item *host = NULL; /* dummy for macros */
376
377 DEBUG(D_tls) debug_printf("Initialising GnuTLS server params.\n");
378
379 rc = gnutls_dh_params_init(&dh_server_params);
380 exim_gnutls_err_check(US"gnutls_dh_params_init");
381
382 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
383 /* If you change this constant, also change dh_param_fn_ext so that we can use a
384 different filename and ensure we have sufficient bits. */
385 dh_bits = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, GNUTLS_SEC_PARAM_NORMAL);
386 if (!dh_bits)
387   return tls_error(US"gnutls_sec_param_to_pk_bits() failed", NULL, NULL);
388 DEBUG(D_tls)
389   debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits.\n",
390       dh_bits);
391 #else
392 dh_bits = EXIM_SERVER_DH_BITS_PRE2_12;
393 DEBUG(D_tls)
394   debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits.\n",
395       dh_bits);
396 #endif
397
398 /* Some clients have hard-coded limits. */
399 if (dh_bits > tls_dh_max_bits)
400   {
401   DEBUG(D_tls)
402     debug_printf("tls_dh_max_bits clamping override, using %d bits instead.\n",
403         tls_dh_max_bits);
404   dh_bits = tls_dh_max_bits;
405   }
406
407 if (!string_format(filename, sizeof(filename),
408       "%s/gnutls-params-%d", spool_directory, dh_bits))
409   return tls_error(US"overlong filename", NULL, NULL);
410
411 /* Open the cache file for reading and if successful, read it and set up the
412 parameters. */
413
414 fd = Uopen(filename, O_RDONLY, 0);
415 if (fd >= 0)
416   {
417   struct stat statbuf;
418   FILE *fp;
419   int saved_errno;
420
421   if (fstat(fd, &statbuf) < 0)  /* EIO */
422     {
423     saved_errno = errno;
424     (void)close(fd);
425     return tls_error(US"TLS cache stat failed", strerror(saved_errno), NULL);
426     }
427   if (!S_ISREG(statbuf.st_mode))
428     {
429     (void)close(fd);
430     return tls_error(US"TLS cache not a file", NULL, NULL);
431     }
432   fp = fdopen(fd, "rb");
433   if (!fp)
434     {
435     saved_errno = errno;
436     (void)close(fd);
437     return tls_error(US"fdopen(TLS cache stat fd) failed",
438         strerror(saved_errno), NULL);
439     }
440
441   m.size = statbuf.st_size;
442   m.data = malloc(m.size);
443   if (m.data == NULL)
444     {
445     fclose(fp);
446     return tls_error(US"malloc failed", strerror(errno), NULL);
447     }
448   sz = fread(m.data, m.size, 1, fp);
449   if (!sz)
450     {
451     saved_errno = errno;
452     fclose(fp);
453     free(m.data);
454     return tls_error(US"fread failed", strerror(saved_errno), NULL);
455     }
456   fclose(fp);
457
458   rc = gnutls_dh_params_import_pkcs3(dh_server_params, &m, GNUTLS_X509_FMT_PEM);
459   free(m.data);
460   exim_gnutls_err_check(US"gnutls_dh_params_import_pkcs3");
461   DEBUG(D_tls) debug_printf("read D-H parameters from file \"%s\"\n", filename);
462   }
463
464 /* If the file does not exist, fall through to compute new data and cache it.
465 If there was any other opening error, it is serious. */
466
467 else if (errno == ENOENT)
468   {
469   rc = -1;
470   DEBUG(D_tls)
471     debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename);
472   }
473 else
474   return tls_error(string_open_failed(errno, "\"%s\" for reading", filename),
475       NULL, NULL);
476
477 /* If ret < 0, either the cache file does not exist, or the data it contains
478 is not useful. One particular case of this is when upgrading from an older
479 release of Exim in which the data was stored in a different format. We don't
480 try to be clever and support both formats; we just regenerate new data in this
481 case. */
482
483 if (rc < 0)
484   {
485   uschar *temp_fn;
486   unsigned int dh_bits_gen = dh_bits;
487
488   if ((PATH_MAX - Ustrlen(filename)) < 10)
489     return tls_error(US"Filename too long to generate replacement",
490         CS filename, NULL);
491
492   temp_fn = string_copy(US "%s.XXXXXXX");
493   fd = mkstemp(CS temp_fn); /* modifies temp_fn */
494   if (fd < 0)
495     return tls_error(US"Unable to open temp file", strerror(errno), NULL);
496   (void)fchown(fd, exim_uid, exim_gid);   /* Probably not necessary */
497
498   /* GnuTLS overshoots!
499    * If we ask for 2236, we might get 2237 or more.
500    * But there's no way to ask GnuTLS how many bits there really are.
501    * We can ask how many bits were used in a TLS session, but that's it!
502    * The prime itself is hidden behind too much abstraction.
503    * So we ask for less, and proceed on a wing and a prayer.
504    * First attempt, subtracted 3 for 2233 and got 2240.
505    */
506   if (dh_bits > EXIM_CLIENT_DH_MIN_BITS + 10)
507     {
508     dh_bits_gen = dh_bits - 10;
509     DEBUG(D_tls)
510       debug_printf("being paranoid about DH generation, make it '%d' bits'\n",
511           dh_bits_gen);
512     }
513
514   DEBUG(D_tls)
515     debug_printf("requesting generation of %d bit Diffie-Hellman prime ...\n",
516         dh_bits_gen);
517   rc = gnutls_dh_params_generate2(dh_server_params, dh_bits_gen);
518   exim_gnutls_err_check(US"gnutls_dh_params_generate2");
519
520   /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
521   and I confirmed that a NULL call to get the size first is how the GnuTLS
522   sample apps handle this. */
523
524   sz = 0;
525   m.data = NULL;
526   rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
527       m.data, &sz);
528   if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
529     exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3(NULL) sizing");
530   m.size = sz;
531   m.data = malloc(m.size);
532   if (m.data == NULL)
533     return tls_error(US"memory allocation failed", strerror(errno), NULL);
534   /* this will return a size 1 less than the allocation size above */
535   rc = gnutls_dh_params_export_pkcs3(dh_server_params, GNUTLS_X509_FMT_PEM,
536       m.data, &sz);
537   if (rc != GNUTLS_E_SUCCESS)
538     {
539     free(m.data);
540     exim_gnutls_err_check(US"gnutls_dh_params_export_pkcs3() real");
541     }
542   m.size = sz; /* shrink by 1, probably */
543
544   sz = write_to_fd_buf(fd, m.data, (size_t) m.size);
545   if (sz != m.size)
546     {
547     free(m.data);
548     return tls_error(US"TLS cache write D-H params failed",
549         strerror(errno), NULL);
550     }
551   free(m.data);
552   sz = write_to_fd_buf(fd, US"\n", 1);
553   if (sz != 1)
554     return tls_error(US"TLS cache write D-H params final newline failed",
555         strerror(errno), NULL);
556
557   rc = close(fd);
558   if (rc)
559     return tls_error(US"TLS cache write close() failed",
560         strerror(errno), NULL);
561
562   if (Urename(temp_fn, filename) < 0)
563     return tls_error(string_sprintf("failed to rename \"%s\" as \"%s\"",
564           temp_fn, filename), strerror(errno), NULL);
565
566   DEBUG(D_tls) debug_printf("wrote D-H parameters to file \"%s\"\n", filename);
567   }
568
569 DEBUG(D_tls) debug_printf("initialized server D-H parameters\n");
570 return OK;
571 }
572
573
574
575
576 /*************************************************
577 *       Variables re-expanded post-SNI           *
578 *************************************************/
579
580 /* Called from both server and client code, via tls_init(), and also from
581 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
582
583 We can tell the two apart by state->received_sni being non-NULL in callback.
584
585 The callback should not call us unless state->trigger_sni_changes is true,
586 which we are responsible for setting on the first pass through.
587
588 Arguments:
589   state           exim_gnutls_state_st *
590
591 Returns:          OK/DEFER/FAIL
592 */
593
594 static int
595 tls_expand_session_files(exim_gnutls_state_st *state)
596 {
597 struct stat statbuf;
598 int rc;
599 const host_item *host = state->host;  /* macro should be reconsidered? */
600 uschar *saved_tls_certificate = NULL;
601 uschar *saved_tls_privatekey = NULL;
602 uschar *saved_tls_verify_certificates = NULL;
603 uschar *saved_tls_crl = NULL;
604 int cert_count;
605
606 /* We check for tls_sni *before* expansion. */
607 if (!state->host)
608   {
609   if (!state->received_sni)
610     {
611     if (state->tls_certificate && Ustrstr(state->tls_certificate, US"tls_sni"))
612       {
613       DEBUG(D_tls) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
614       state->trigger_sni_changes = TRUE;
615       }
616     }
617   else
618     {
619     /* useful for debugging */
620     saved_tls_certificate = state->exp_tls_certificate;
621     saved_tls_privatekey = state->exp_tls_privatekey;
622     saved_tls_verify_certificates = state->exp_tls_verify_certificates;
623     saved_tls_crl = state->exp_tls_crl;
624     }
625   }
626
627 rc = gnutls_certificate_allocate_credentials(&state->x509_cred);
628 exim_gnutls_err_check(US"gnutls_certificate_allocate_credentials");
629
630 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
631 state members, assuming consistent naming; and expand_check() returns
632 false if expansion failed, unless expansion was forced to fail. */
633
634 /* check if we at least have a certificate, before doing expensive
635 D-H generation. */
636
637 if (!expand_check_tlsvar(tls_certificate))
638   return DEFER;
639
640 /* certificate is mandatory in server, optional in client */
641
642 if ((state->exp_tls_certificate == NULL) ||
643     (*state->exp_tls_certificate == '\0'))
644   {
645   if (state->host == NULL)
646     return tls_error(US"no TLS server certificate is specified", NULL, NULL);
647   else
648     DEBUG(D_tls) debug_printf("TLS: no client certificate specified; okay\n");
649   }
650
651 if (state->tls_privatekey && !expand_check_tlsvar(tls_privatekey))
652   return DEFER;
653
654 /* tls_privatekey is optional, defaulting to same file as certificate */
655
656 if (state->tls_privatekey == NULL || *state->tls_privatekey == '\0')
657   {
658   state->tls_privatekey = state->tls_certificate;
659   state->exp_tls_privatekey = state->exp_tls_certificate;
660   }
661
662
663 if (state->exp_tls_certificate && *state->exp_tls_certificate)
664   {
665   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
666       state->exp_tls_certificate, state->exp_tls_privatekey);
667
668   if (state->received_sni)
669     {
670     if ((Ustrcmp(state->exp_tls_certificate, saved_tls_certificate) == 0) &&
671         (Ustrcmp(state->exp_tls_privatekey, saved_tls_privatekey) == 0))
672       {
673       DEBUG(D_tls) debug_printf("TLS SNI: cert and key unchanged\n");
674       }
675     else
676       {
677       DEBUG(D_tls) debug_printf("TLS SNI: have a changed cert/key pair.\n");
678       }
679     }
680
681   rc = gnutls_certificate_set_x509_key_file(state->x509_cred,
682       CS state->exp_tls_certificate, CS state->exp_tls_privatekey,
683       GNUTLS_X509_FMT_PEM);
684   exim_gnutls_err_check(
685       string_sprintf("cert/key setup: cert=%s key=%s",
686         state->exp_tls_certificate, state->exp_tls_privatekey));
687   DEBUG(D_tls) debug_printf("TLS: cert/key registered\n");
688   } /* tls_certificate */
689
690 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
691 provided. Experiment shows that, if the certificate file is empty, an unhelpful
692 error message is provided. However, if we just refrain from setting anything up
693 in that case, certificate verification fails, which seems to be the correct
694 behaviour. */
695
696 if (state->tls_verify_certificates && *state->tls_verify_certificates)
697   {
698   if (!expand_check_tlsvar(tls_verify_certificates))
699     return DEFER;
700   if (state->tls_crl && *state->tls_crl)
701     if (!expand_check_tlsvar(tls_crl))
702       return DEFER;
703
704   if (!(state->exp_tls_verify_certificates &&
705         *state->exp_tls_verify_certificates))
706     {
707     DEBUG(D_tls)
708       debug_printf("TLS: tls_verify_certificates expanded empty, ignoring\n");
709     /* With no tls_verify_certificates, we ignore tls_crl too */
710     return OK;
711     }
712   }
713 else
714   {
715   DEBUG(D_tls)
716     debug_printf("TLS: tls_verify_certificates not set or empty, ignoring\n");
717   return OK;
718   }
719
720 if (Ustat(state->exp_tls_verify_certificates, &statbuf) < 0)
721   {
722   log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
723       "(tls_verify_certificates): %s", state->exp_tls_verify_certificates,
724       strerror(errno));
725   return DEFER;
726   }
727
728 /* The test suite passes in /dev/null; we could check for that path explicitly,
729 but who knows if someone has some weird FIFO which always dumps some certs, or
730 other weirdness.  The thing we really want to check is that it's not a
731 directory, since while OpenSSL supports that, GnuTLS does not.
732 So s/!S_ISREG/S_ISDIR/ and change some messsaging ... */
733 if (S_ISDIR(statbuf.st_mode))
734   {
735   DEBUG(D_tls)
736     debug_printf("verify certificates path is a dir: \"%s\"\n",
737         state->exp_tls_verify_certificates);
738   log_write(0, LOG_MAIN|LOG_PANIC,
739       "tls_verify_certificates \"%s\" is a directory",
740       state->exp_tls_verify_certificates);
741   return DEFER;
742   }
743
744 DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
745         state->exp_tls_verify_certificates, statbuf.st_size);
746
747 if (statbuf.st_size == 0)
748   {
749   DEBUG(D_tls)
750     debug_printf("cert file empty, no certs, no verification, ignoring any CRL\n");
751   return OK;
752   }
753
754 cert_count = gnutls_certificate_set_x509_trust_file(state->x509_cred,
755     CS state->exp_tls_verify_certificates, GNUTLS_X509_FMT_PEM);
756 if (cert_count < 0)
757   {
758   rc = cert_count;
759   exim_gnutls_err_check(US"gnutls_certificate_set_x509_trust_file");
760   }
761 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n", cert_count);
762
763 if (state->tls_crl && *state->tls_crl &&
764     state->exp_tls_crl && *state->exp_tls_crl)
765   {
766   DEBUG(D_tls) debug_printf("loading CRL file = %s\n", state->exp_tls_crl);
767   cert_count = gnutls_certificate_set_x509_crl_file(state->x509_cred,
768       CS state->exp_tls_crl, GNUTLS_X509_FMT_PEM);
769   if (cert_count < 0)
770     {
771     rc = cert_count;
772     exim_gnutls_err_check(US"gnutls_certificate_set_x509_crl_file");
773     }
774   DEBUG(D_tls) debug_printf("Processed %d CRLs.\n", cert_count);
775   }
776
777 return OK;
778 }
779
780
781
782
783 /*************************************************
784 *          Set X.509 state variables             *
785 *************************************************/
786
787 /* In GnuTLS, the registered cert/key are not replaced by a later
788 set of a cert/key, so for SNI support we need a whole new x509_cred
789 structure.  Which means various other non-re-expanded pieces of state
790 need to be re-set in the new struct, so the setting logic is pulled
791 out to this.
792
793 Arguments:
794   state           exim_gnutls_state_st *
795
796 Returns:          OK/DEFER/FAIL
797 */
798
799 static int
800 tls_set_remaining_x509(exim_gnutls_state_st *state)
801 {
802 int rc;
803 const host_item *host = state->host;  /* macro should be reconsidered? */
804
805 /* Create D-H parameters, or read them from the cache file. This function does
806 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
807 client-side params. */
808
809 if (!state->host)
810   {
811   if (!dh_server_params)
812     {
813     rc = init_server_dh();
814     if (rc != OK) return rc;
815     }
816   gnutls_certificate_set_dh_params(state->x509_cred, dh_server_params);
817   }
818
819 /* Link the credentials to the session. */
820
821 rc = gnutls_credentials_set(state->session, GNUTLS_CRD_CERTIFICATE, state->x509_cred);
822 exim_gnutls_err_check(US"gnutls_credentials_set");
823
824 return OK;
825 }
826
827 /*************************************************
828 *            Initialize for GnuTLS               *
829 *************************************************/
830
831 /* Called from both server and client code. In the case of a server, errors
832 before actual TLS negotiation return DEFER.
833
834 Arguments:
835   host            connected host, if client; NULL if server
836   certificate     certificate file
837   privatekey      private key file
838   sni             TLS SNI to send, sometimes when client; else NULL
839   cas             CA certs file
840   crl             CRL file
841   require_ciphers tls_require_ciphers setting
842
843 Returns:          OK/DEFER/FAIL
844 */
845
846 static int
847 tls_init(
848     const host_item *host,
849     const uschar *certificate,
850     const uschar *privatekey,
851     const uschar *sni,
852     const uschar *cas,
853     const uschar *crl,
854     const uschar *require_ciphers,
855     exim_gnutls_state_st **caller_state)
856 {
857 exim_gnutls_state_st *state;
858 int rc;
859 size_t sz;
860 const char *errpos;
861 uschar *p;
862 BOOL want_default_priorities;
863
864 if (!exim_gnutls_base_init_done)
865   {
866   DEBUG(D_tls) debug_printf("GnuTLS global init required.\n");
867
868   rc = gnutls_global_init();
869   exim_gnutls_err_check(US"gnutls_global_init");
870
871 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
872   DEBUG(D_tls)
873     {
874     gnutls_global_set_log_function(exim_gnutls_logger_cb);
875     /* arbitrarily chosen level; bump upto 9 for more */
876     gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL);
877     }
878 #endif
879
880   exim_gnutls_base_init_done = TRUE;
881   }
882
883 if (host)
884   {
885   state = &state_client;
886   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
887   DEBUG(D_tls) debug_printf("initialising GnuTLS client session\n");
888   rc = gnutls_init(&state->session, GNUTLS_CLIENT);
889   }
890 else
891   {
892   state = &state_server;
893   memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
894   DEBUG(D_tls) debug_printf("initialising GnuTLS server session\n");
895   rc = gnutls_init(&state->session, GNUTLS_SERVER);
896   }
897 exim_gnutls_err_check(US"gnutls_init");
898
899 state->host = host;
900
901 state->tls_certificate = certificate;
902 state->tls_privatekey = privatekey;
903 state->tls_require_ciphers = require_ciphers;
904 state->tls_sni = sni;
905 state->tls_verify_certificates = cas;
906 state->tls_crl = crl;
907
908 /* This handles the variables that might get re-expanded after TLS SNI;
909 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
910
911 DEBUG(D_tls)
912   debug_printf("Expanding various TLS configuration options for session credentials.\n");
913 rc = tls_expand_session_files(state);
914 if (rc != OK) return rc;
915
916 /* These are all other parts of the x509_cred handling, since SNI in GnuTLS
917 requires a new structure afterwards. */
918
919 rc = tls_set_remaining_x509(state);
920 if (rc != OK) return rc;
921
922 /* set SNI in client, only */
923 if (host)
924   {
925   if (!expand_check_tlsvar(tls_sni))
926     return DEFER;
927   if (state->exp_tls_sni && *state->exp_tls_sni)
928     {
929     DEBUG(D_tls)
930       debug_printf("Setting TLS client SNI to \"%s\"\n", state->exp_tls_sni);
931     sz = Ustrlen(state->exp_tls_sni);
932     rc = gnutls_server_name_set(state->session,
933         GNUTLS_NAME_DNS, state->exp_tls_sni, sz);
934     exim_gnutls_err_check(US"gnutls_server_name_set");
935     }
936   }
937 else if (state->tls_sni)
938   DEBUG(D_tls) debug_printf("*** PROBABLY A BUG *** " \
939       "have an SNI set for a client [%s]\n", state->tls_sni);
940
941 /* This is the priority string support,
942 http://www.gnu.org/software/gnutls/manual/html_node/Priority-Strings.html
943 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
944 This was backwards incompatible, but means Exim no longer needs to track
945 all algorithms and provide string forms for them. */
946
947 want_default_priorities = TRUE;
948
949 if (state->tls_require_ciphers && *state->tls_require_ciphers)
950   {
951   if (!expand_check_tlsvar(tls_require_ciphers))
952     return DEFER;
953   if (state->exp_tls_require_ciphers && *state->exp_tls_require_ciphers)
954     {
955     DEBUG(D_tls) debug_printf("GnuTLS session cipher/priority \"%s\"\n",
956         state->exp_tls_require_ciphers);
957
958     rc = gnutls_priority_init(&state->priority_cache,
959         CS state->exp_tls_require_ciphers, &errpos);
960     want_default_priorities = FALSE;
961     p = state->exp_tls_require_ciphers;
962     }
963   }
964 if (want_default_priorities)
965   {
966   DEBUG(D_tls)
967     debug_printf("GnuTLS using default session cipher/priority \"%s\"\n",
968         exim_default_gnutls_priority);
969   rc = gnutls_priority_init(&state->priority_cache,
970       exim_default_gnutls_priority, &errpos);
971   p = US exim_default_gnutls_priority;
972   }
973
974 exim_gnutls_err_check(string_sprintf(
975       "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
976       p, errpos - CS p, errpos));
977
978 rc = gnutls_priority_set(state->session, state->priority_cache);
979 exim_gnutls_err_check(US"gnutls_priority_set");
980
981 gnutls_db_set_cache_expiration(state->session, ssl_session_timeout);
982
983 /* Reduce security in favour of increased compatibility, if the admin
984 decides to make that trade-off. */
985 if (gnutls_compat_mode)
986   {
987 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
988   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
989   gnutls_session_enable_compatibility_mode(state->session);
990 #else
991   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
992 #endif
993   }
994
995 *caller_state = state;
996 /* needs to happen before callbacks during handshake */
997 current_global_tls_state = state;
998 return OK;
999 }
1000
1001
1002
1003
1004 /*************************************************
1005 *            Extract peer information            *
1006 *************************************************/
1007
1008 /* Called from both server and client code.
1009 Only this is allowed to set state->peerdn and state->have_set_peerdn
1010 and we use that to detect double-calls.
1011
1012 NOTE: the state blocks last while the TLS connection is up, which is fine
1013 for logging in the server side, but for the client side, we log after teardown
1014 in src/deliver.c.  While the session is up, we can twist about states and
1015 repoint tls_* globals, but those variables used for logging or other variable
1016 expansion that happens _after_ delivery need to have a longer life-time.
1017
1018 So for those, we get the data from POOL_PERM; the re-invoke guard keeps us from
1019 doing this more than once per generation of a state context.  We set them in
1020 the state context, and repoint tls_* to them.  After the state goes away, the
1021 tls_* copies of the pointers remain valid and client delivery logging is happy.
1022
1023 tls_certificate_verified is a BOOL, so the tls_peerdn and tls_cipher issues
1024 don't apply.
1025
1026 Arguments:
1027   state           exim_gnutls_state_st *
1028
1029 Returns:          OK/DEFER/FAIL
1030 */
1031
1032 static int
1033 peer_status(exim_gnutls_state_st *state)
1034 {
1035 uschar cipherbuf[256];
1036 const gnutls_datum *cert_list;
1037 int old_pool, rc;
1038 unsigned int cert_list_size = 0;
1039 gnutls_protocol_t protocol;
1040 gnutls_cipher_algorithm_t cipher;
1041 gnutls_kx_algorithm_t kx;
1042 gnutls_mac_algorithm_t mac;
1043 gnutls_certificate_type_t ct;
1044 gnutls_x509_crt_t crt;
1045 uschar *p, *dn_buf;
1046 size_t sz;
1047
1048 if (state->have_set_peerdn)
1049   return OK;
1050 state->have_set_peerdn = TRUE;
1051
1052 state->peerdn = NULL;
1053
1054 /* tls_cipher */
1055 cipher = gnutls_cipher_get(state->session);
1056 protocol = gnutls_protocol_get_version(state->session);
1057 mac = gnutls_mac_get(state->session);
1058 kx = gnutls_kx_get(state->session);
1059
1060 string_format(cipherbuf, sizeof(cipherbuf),
1061     "%s:%s:%d",
1062     gnutls_protocol_get_name(protocol),
1063     gnutls_cipher_suite_get_name(kx, cipher, mac),
1064     (int) gnutls_cipher_get_key_size(cipher) * 8);
1065
1066 /* I don't see a way that spaces could occur, in the current GnuTLS
1067 code base, but it was a concern in the old code and perhaps older GnuTLS
1068 releases did return "TLS 1.0"; play it safe, just in case. */
1069 for (p = cipherbuf; *p != '\0'; ++p)
1070   if (isspace(*p))
1071     *p = '-';
1072 old_pool = store_pool;
1073 store_pool = POOL_PERM;
1074 state->ciphersuite = string_copy(cipherbuf);
1075 store_pool = old_pool;
1076 tls_cipher = state->ciphersuite;
1077
1078 /* tls_peerdn */
1079 cert_list = gnutls_certificate_get_peers(state->session, &cert_list_size);
1080
1081 if (cert_list == NULL || cert_list_size == 0)
1082   {
1083   DEBUG(D_tls) debug_printf("TLS: no certificate from peer (%p & %d)\n",
1084       cert_list, cert_list_size);
1085   if (state->verify_requirement == VERIFY_REQUIRED)
1086     return tls_error(US"certificate verification failed",
1087         "no certificate received from peer", state->host);
1088   return OK;
1089   }
1090
1091 ct = gnutls_certificate_type_get(state->session);
1092 if (ct != GNUTLS_CRT_X509)
1093   {
1094   const char *ctn = gnutls_certificate_type_get_name(ct);
1095   DEBUG(D_tls)
1096     debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn);
1097   if (state->verify_requirement == VERIFY_REQUIRED)
1098     return tls_error(US"certificate verification not possible, unhandled type",
1099         ctn, state->host);
1100   return OK;
1101   }
1102
1103 #define exim_gnutls_peer_err(Label) do { \
1104   if (rc != GNUTLS_E_SUCCESS) { \
1105     DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", (Label), gnutls_strerror(rc)); \
1106     if (state->verify_requirement == VERIFY_REQUIRED) { return tls_error((Label), gnutls_strerror(rc), state->host); } \
1107     return OK; } } while (0)
1108
1109 rc = gnutls_x509_crt_init(&crt);
1110 exim_gnutls_peer_err(US"gnutls_x509_crt_init (crt)");
1111
1112 rc = gnutls_x509_crt_import(crt, &cert_list[0], GNUTLS_X509_FMT_DER);
1113 exim_gnutls_peer_err(US"failed to import certificate [gnutls_x509_crt_import(cert 0)]");
1114 sz = 0;
1115 rc = gnutls_x509_crt_get_dn(crt, NULL, &sz);
1116 if (rc != GNUTLS_E_SHORT_MEMORY_BUFFER)
1117   {
1118   exim_gnutls_peer_err(US"getting size for cert DN failed");
1119   return FAIL; /* should not happen */
1120   }
1121 dn_buf = store_get_perm(sz);
1122 rc = gnutls_x509_crt_get_dn(crt, CS dn_buf, &sz);
1123 exim_gnutls_peer_err(US"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1124 state->peerdn = dn_buf;
1125
1126 return OK;
1127 #undef exim_gnutls_peer_err
1128 }
1129
1130
1131
1132
1133 /*************************************************
1134 *            Verify peer certificate             *
1135 *************************************************/
1136
1137 /* Called from both server and client code.
1138 *Should* be using a callback registered with
1139 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1140 the peer information, but that's too new for some OSes.
1141
1142 Arguments:
1143   state           exim_gnutls_state_st *
1144   error           where to put an error message
1145
1146 Returns:
1147   FALSE     if the session should be rejected
1148   TRUE      if the cert is okay or we just don't care
1149 */
1150
1151 static BOOL
1152 verify_certificate(exim_gnutls_state_st *state, const char **error)
1153 {
1154 int rc;
1155 unsigned int verify;
1156
1157 *error = NULL;
1158
1159 rc = peer_status(state);
1160 if (rc != OK)
1161   {
1162   verify = GNUTLS_CERT_INVALID;
1163   *error = "not supplied";
1164   }
1165 else
1166   {
1167   rc = gnutls_certificate_verify_peers2(state->session, &verify);
1168   }
1169
1170 /* Handle the result of verification. INVALID seems to be set as well
1171 as REVOKED, but leave the test for both. */
1172
1173 if ((rc < 0) || (verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED)) != 0)
1174   {
1175   state->peer_cert_verified = FALSE;
1176   if (*error == NULL)
1177     *error = ((verify & GNUTLS_CERT_REVOKED) != 0) ? "revoked" : "invalid";
1178
1179   DEBUG(D_tls)
1180     debug_printf("TLS certificate verification failed (%s): peerdn=%s\n",
1181         *error, state->peerdn ? state->peerdn : US"<unset>");
1182
1183   if (state->verify_requirement == VERIFY_REQUIRED)
1184     {
1185     gnutls_alert_send(state->session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
1186     return FALSE;
1187     }
1188   DEBUG(D_tls)
1189     debug_printf("TLS verify failure overriden (host in tls_try_verify_hosts)\n");
1190   }
1191 else
1192   {
1193   state->peer_cert_verified = TRUE;
1194   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=%s\n",
1195       state->peerdn ? state->peerdn : US"<unset>");
1196   }
1197
1198 tls_peerdn = state->peerdn;
1199
1200 return TRUE;
1201 }
1202
1203
1204
1205
1206 /* ------------------------------------------------------------------------ */
1207 /* Callbacks */
1208
1209 /* Logging function which can be registered with
1210  *   gnutls_global_set_log_function()
1211  *   gnutls_global_set_log_level() 0..9
1212  */
1213 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1214 static void
1215 exim_gnutls_logger_cb(int level, const char *message)
1216 {
1217   size_t len = strlen(message);
1218   if (len < 1)
1219     {
1220     DEBUG(D_tls) debug_printf("GnuTLS<%d> empty debug message\n", level);
1221     return;
1222     }
1223   DEBUG(D_tls) debug_printf("GnuTLS<%d>: %s%s", level, message,
1224       message[len-1] == '\n' ? "" : "\n");
1225 }
1226 #endif
1227
1228
1229 /* Called after client hello, should handle SNI work.
1230 This will always set tls_sni (state->received_sni) if available,
1231 and may trigger presenting different certificates,
1232 if state->trigger_sni_changes is TRUE.
1233
1234 Should be registered with
1235   gnutls_handshake_set_post_client_hello_function()
1236
1237 "This callback must return 0 on success or a gnutls error code to terminate the
1238 handshake.".
1239
1240 For inability to get SNI information, we return 0.
1241 We only return non-zero if re-setup failed.
1242 */
1243
1244 static int
1245 exim_sni_handling_cb(gnutls_session_t session)
1246 {
1247 char sni_name[MAX_HOST_LEN];
1248 size_t data_len = MAX_HOST_LEN;
1249 exim_gnutls_state_st *state = current_global_tls_state;
1250 unsigned int sni_type;
1251 int rc, old_pool;
1252
1253 rc = gnutls_server_name_get(session, sni_name, &data_len, &sni_type, 0);
1254 if (rc != GNUTLS_E_SUCCESS)
1255   {
1256   DEBUG(D_tls) {
1257     if (rc == GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE)
1258       debug_printf("TLS: no SNI presented in handshake.\n");
1259     else
1260       debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
1261         gnutls_strerror(rc), rc);
1262   };
1263   return 0;
1264   }
1265
1266 if (sni_type != GNUTLS_NAME_DNS)
1267   {
1268   DEBUG(D_tls) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type);
1269   return 0;
1270   }
1271
1272 /* We now have a UTF-8 string in sni_name */
1273 old_pool = store_pool;
1274 store_pool = POOL_PERM;
1275 state->received_sni = string_copyn(US sni_name, data_len);
1276 store_pool = old_pool;
1277
1278 /* We set this one now so that variable expansions below will work */
1279 tls_sni = state->received_sni;
1280
1281 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name,
1282     state->trigger_sni_changes ? "" : " (unused for certificate selection)");
1283
1284 if (!state->trigger_sni_changes)
1285   return 0;
1286
1287 rc = tls_expand_session_files(state);
1288 if (rc != OK)
1289   {
1290   /* If the setup of certs/etc failed before handshake, TLS would not have
1291   been offered.  The best we can do now is abort. */
1292   return GNUTLS_E_APPLICATION_ERROR_MIN;
1293   }
1294
1295 rc = tls_set_remaining_x509(state);
1296 if (rc != OK) return GNUTLS_E_APPLICATION_ERROR_MIN;
1297
1298 return 0;
1299 }
1300
1301
1302
1303
1304 /* ------------------------------------------------------------------------ */
1305 /* Exported functions */
1306
1307
1308
1309
1310 /*************************************************
1311 *       Start a TLS session in a server          *
1312 *************************************************/
1313
1314 /* This is called when Exim is running as a server, after having received
1315 the STARTTLS command. It must respond to that command, and then negotiate
1316 a TLS session.
1317
1318 Arguments:
1319   require_ciphers  list of allowed ciphers or NULL
1320
1321 Returns:           OK on success
1322                    DEFER for errors before the start of the negotiation
1323                    FAIL for errors during the negotation; the server can't
1324                      continue running.
1325 */
1326
1327 int
1328 tls_server_start(const uschar *require_ciphers)
1329 {
1330 int rc;
1331 const char *error;
1332 exim_gnutls_state_st *state = NULL;
1333
1334 /* Check for previous activation */
1335 /* nb: this will not be TLS callout safe, needs reworking as part of that. */
1336
1337 if (tls_active >= 0)
1338   {
1339   tls_error(US"STARTTLS received after TLS started", "", NULL);
1340   smtp_printf("554 Already in TLS\r\n");
1341   return FAIL;
1342   }
1343
1344 /* Initialize the library. If it fails, it will already have logged the error
1345 and sent an SMTP response. */
1346
1347 DEBUG(D_tls) debug_printf("initialising GnuTLS as a server\n");
1348
1349 rc = tls_init(NULL, tls_certificate, tls_privatekey,
1350     NULL, tls_verify_certificates, tls_crl,
1351     require_ciphers, &state);
1352 if (rc != OK) return rc;
1353
1354 /* If this is a host for which certificate verification is mandatory or
1355 optional, set up appropriately. */
1356
1357 if (verify_check_host(&tls_verify_hosts) == OK)
1358   {
1359   DEBUG(D_tls) debug_printf("TLS: a client certificate will be required.\n");
1360   state->verify_requirement = VERIFY_REQUIRED;
1361   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1362   }
1363 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1364   {
1365   DEBUG(D_tls) debug_printf("TLS: a client certificate will be requested but not required.\n");
1366   state->verify_requirement = VERIFY_OPTIONAL;
1367   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1368   }
1369 else
1370   {
1371   DEBUG(D_tls) debug_printf("TLS: a client certificate will not be requested.\n");
1372   state->verify_requirement = VERIFY_NONE;
1373   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_IGNORE);
1374   }
1375
1376 /* Register SNI handling; always, even if not in tls_certificate, so that the
1377 expansion variable $tls_sni is always available. */
1378
1379 gnutls_handshake_set_post_client_hello_function(state->session,
1380     exim_sni_handling_cb);
1381
1382 /* Set context and tell client to go ahead, except in the case of TLS startup
1383 on connection, where outputting anything now upsets the clients and tends to
1384 make them disconnect. We need to have an explicit fflush() here, to force out
1385 the response. Other smtp_printf() calls do not need it, because in non-TLS
1386 mode, the fflush() happens when smtp_getc() is called. */
1387
1388 if (!tls_on_connect)
1389   {
1390   smtp_printf("220 TLS go ahead\r\n");
1391   fflush(smtp_out);
1392   }
1393
1394 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1395 that the GnuTLS library doesn't. */
1396
1397 gnutls_transport_set_ptr2(state->session,
1398     (gnutls_transport_ptr)fileno(smtp_in),
1399     (gnutls_transport_ptr)fileno(smtp_out));
1400 state->fd_in = fileno(smtp_in);
1401 state->fd_out = fileno(smtp_out);
1402
1403 sigalrm_seen = FALSE;
1404 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1405 do
1406   {
1407   rc = gnutls_handshake(state->session);
1408   } while ((rc == GNUTLS_E_AGAIN) ||
1409       (rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen));
1410 alarm(0);
1411
1412 if (rc != GNUTLS_E_SUCCESS)
1413   {
1414   tls_error(US"gnutls_handshake",
1415       sigalrm_seen ? "timed out" : gnutls_strerror(rc), NULL);
1416   /* It seems that, except in the case of a timeout, we have to close the
1417   connection right here; otherwise if the other end is running OpenSSL it hangs
1418   until the server times out. */
1419
1420   if (!sigalrm_seen)
1421     {
1422     (void)fclose(smtp_out);
1423     (void)fclose(smtp_in);
1424     }
1425
1426   return FAIL;
1427   }
1428
1429 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1430
1431 /* Verify after the fact */
1432
1433 if (state->verify_requirement != VERIFY_NONE)
1434   {
1435   if (!verify_certificate(state, &error))
1436     {
1437     if (state->verify_requirement == VERIFY_OPTIONAL)
1438       {
1439       DEBUG(D_tls)
1440         debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
1441             error);
1442       }
1443     else
1444       {
1445       tls_error(US"certificate verification failed", error, NULL);
1446       return FAIL;
1447       }
1448     }
1449   }
1450
1451 /* Figure out peer DN, and if authenticated, etc. */
1452
1453 rc = peer_status(state);
1454 if (rc != OK) return rc;
1455
1456 /* Sets various Exim expansion variables; always safe within server */
1457
1458 extract_exim_vars_from_tls_state(state);
1459
1460 /* TLS has been set up. Adjust the input functions to read via TLS,
1461 and initialize appropriately. */
1462
1463 state->xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1464
1465 receive_getc = tls_getc;
1466 receive_ungetc = tls_ungetc;
1467 receive_feof = tls_feof;
1468 receive_ferror = tls_ferror;
1469 receive_smtp_buffered = tls_smtp_buffered;
1470
1471 return OK;
1472 }
1473
1474
1475
1476
1477 /*************************************************
1478 *    Start a TLS session in a client             *
1479 *************************************************/
1480
1481 /* Called from the smtp transport after STARTTLS has been accepted.
1482
1483 Arguments:
1484   fd                the fd of the connection
1485   host              connected host (for messages)
1486   addr              the first address (not used)
1487   dhparam           DH parameter file (ignored, we're a client)
1488   certificate       certificate file
1489   privatekey        private key file
1490   sni               TLS SNI to send to remote host
1491   verify_certs      file for certificate verify
1492   verify_crl        CRL for verify
1493   require_ciphers   list of allowed ciphers or NULL
1494   timeout           startup timeout
1495
1496 Returns:            OK/DEFER/FAIL (because using common functions),
1497                     but for a client, DEFER and FAIL have the same meaning
1498 */
1499
1500 int
1501 tls_client_start(int fd, host_item *host,
1502     address_item *addr ARG_UNUSED, uschar *dhparam ARG_UNUSED,
1503     uschar *certificate, uschar *privatekey, uschar *sni,
1504     uschar *verify_certs, uschar *verify_crl,
1505     uschar *require_ciphers, int timeout)
1506 {
1507 int rc;
1508 const char *error;
1509 exim_gnutls_state_st *state = NULL;
1510
1511 DEBUG(D_tls) debug_printf("initialising GnuTLS as a client on fd %d\n", fd);
1512
1513 rc = tls_init(host, certificate, privatekey,
1514     sni, verify_certs, verify_crl, require_ciphers, &state);
1515 if (rc != OK) return rc;
1516
1517 gnutls_dh_set_prime_bits(state->session, EXIM_CLIENT_DH_MIN_BITS);
1518
1519 if (verify_certs == NULL)
1520   {
1521   DEBUG(D_tls) debug_printf("TLS: server certificate verification not required\n");
1522   state->verify_requirement = VERIFY_NONE;
1523   /* we still ask for it, to log it, etc */
1524   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUEST);
1525   }
1526 else
1527   {
1528   DEBUG(D_tls) debug_printf("TLS: server certificate verification required\n");
1529   state->verify_requirement = VERIFY_REQUIRED;
1530   gnutls_certificate_server_set_request(state->session, GNUTLS_CERT_REQUIRE);
1531   }
1532
1533 gnutls_transport_set_ptr(state->session, (gnutls_transport_ptr)fd);
1534 state->fd_in = fd;
1535 state->fd_out = fd;
1536
1537 /* There doesn't seem to be a built-in timeout on connection. */
1538
1539 sigalrm_seen = FALSE;
1540 alarm(timeout);
1541 do
1542   {
1543   rc = gnutls_handshake(state->session);
1544   } while ((rc == GNUTLS_E_AGAIN) ||
1545       (rc == GNUTLS_E_INTERRUPTED && !sigalrm_seen));
1546 alarm(0);
1547
1548 if (rc != GNUTLS_E_SUCCESS)
1549   return tls_error(US"gnutls_handshake",
1550       sigalrm_seen ? "timed out" : gnutls_strerror(rc), state->host);
1551
1552 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
1553
1554 /* Verify late */
1555
1556 if (state->verify_requirement != VERIFY_NONE &&
1557     !verify_certificate(state, &error))
1558   return tls_error(US"certificate verification failed", error, state->host);
1559
1560 /* Figure out peer DN, and if authenticated, etc. */
1561
1562 rc = peer_status(state);
1563 if (rc != OK) return rc;
1564
1565 /* Sets various Exim expansion variables; may need to adjust for ACL callouts */
1566
1567 extract_exim_vars_from_tls_state(state);
1568
1569 return OK;
1570 }
1571
1572
1573
1574
1575 /*************************************************
1576 *         Close down a TLS session               *
1577 *************************************************/
1578
1579 /* This is also called from within a delivery subprocess forked from the
1580 daemon, to shut down the TLS library, without actually doing a shutdown (which
1581 would tamper with the TLS session in the parent process).
1582
1583 Arguments:   TRUE if gnutls_bye is to be called
1584 Returns:     nothing
1585 */
1586
1587 void
1588 tls_close(BOOL shutdown)
1589 {
1590 exim_gnutls_state_st *state = current_global_tls_state;
1591
1592 if (tls_active < 0) return;  /* TLS was not active */
1593
1594 if (shutdown)
1595   {
1596   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS\n");
1597   gnutls_bye(state->session, GNUTLS_SHUT_WR);
1598   }
1599
1600 gnutls_deinit(state->session);
1601
1602 memcpy(state, &exim_gnutls_state_init, sizeof(exim_gnutls_state_init));
1603
1604 if ((state_server.session == NULL) && (state_client.session == NULL))
1605   {
1606   gnutls_global_deinit();
1607   exim_gnutls_base_init_done = FALSE;
1608   }
1609
1610 tls_active = -1;
1611 }
1612
1613
1614
1615
1616 /*************************************************
1617 *            TLS version of getc                 *
1618 *************************************************/
1619
1620 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1621 it refills the buffer via the GnuTLS reading function.
1622
1623 This feeds DKIM and should be used for all message-body reads.
1624
1625 Arguments:  none
1626 Returns:    the next character or EOF
1627 */
1628
1629 int
1630 tls_getc(void)
1631 {
1632 exim_gnutls_state_st *state = current_global_tls_state;
1633 if (state->xfer_buffer_lwm >= state->xfer_buffer_hwm)
1634   {
1635   ssize_t inbytes;
1636
1637   DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
1638     state->session, state->xfer_buffer, ssl_xfer_buffer_size);
1639
1640   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1641   inbytes = gnutls_record_recv(state->session, state->xfer_buffer,
1642     ssl_xfer_buffer_size);
1643   alarm(0);
1644
1645   /* A zero-byte return appears to mean that the TLS session has been
1646      closed down, not that the socket itself has been closed down. Revert to
1647      non-TLS handling. */
1648
1649   if (inbytes == 0)
1650     {
1651     DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1652
1653     receive_getc = smtp_getc;
1654     receive_ungetc = smtp_ungetc;
1655     receive_feof = smtp_feof;
1656     receive_ferror = smtp_ferror;
1657     receive_smtp_buffered = smtp_buffered;
1658
1659     gnutls_deinit(state->session);
1660     state->session = NULL;
1661     tls_active = -1;
1662     tls_bits = 0;
1663     tls_certificate_verified = FALSE;
1664     tls_channelbinding_b64 = NULL;
1665     tls_cipher = NULL;
1666     tls_peerdn = NULL;
1667
1668     return smtp_getc();
1669     }
1670
1671   /* Handle genuine errors */
1672
1673   else if (inbytes < 0)
1674     {
1675     record_io_error(state, (int) inbytes, US"recv", NULL);
1676     state->xfer_error = 1;
1677     return EOF;
1678     }
1679 #ifndef DISABLE_DKIM
1680   dkim_exim_verify_feed(state->xfer_buffer, inbytes);
1681 #endif
1682   state->xfer_buffer_hwm = (int) inbytes;
1683   state->xfer_buffer_lwm = 0;
1684   }
1685
1686 /* Something in the buffer; return next uschar */
1687
1688 return state->xfer_buffer[state->xfer_buffer_lwm++];
1689 }
1690
1691
1692
1693
1694 /*************************************************
1695 *          Read bytes from TLS channel           *
1696 *************************************************/
1697
1698 /* This does not feed DKIM, so if the caller uses this for reading message body,
1699 then the caller must feed DKIM.
1700 Arguments:
1701   buff      buffer of data
1702   len       size of buffer
1703
1704 Returns:    the number of bytes read
1705             -1 after a failed read
1706 */
1707
1708 int
1709 tls_read(uschar *buff, size_t len)
1710 {
1711 exim_gnutls_state_st *state = current_global_tls_state;
1712 ssize_t inbytes;
1713
1714 if (len > INT_MAX)
1715   len = INT_MAX;
1716
1717 if (state->xfer_buffer_lwm < state->xfer_buffer_hwm)
1718   DEBUG(D_tls)
1719     debug_printf("*** PROBABLY A BUG *** " \
1720         "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
1721         state->xfer_buffer_hwm - state->xfer_buffer_lwm);
1722
1723 DEBUG(D_tls)
1724   debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT ")\n",
1725       state->session, buff, len);
1726
1727 inbytes = gnutls_record_recv(state->session, buff, len);
1728 if (inbytes > 0) return inbytes;
1729 if (inbytes == 0)
1730   {
1731   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1732   }
1733 else record_io_error(state, (int)inbytes, US"recv", NULL);
1734
1735 return -1;
1736 }
1737
1738
1739
1740
1741 /*************************************************
1742 *         Write bytes down TLS channel           *
1743 *************************************************/
1744
1745 /*
1746 Arguments:
1747   buff      buffer of data
1748   len       number of bytes
1749
1750 Returns:    the number of bytes after a successful write,
1751             -1 after a failed write
1752 */
1753
1754 int
1755 tls_write(const uschar *buff, size_t len)
1756 {
1757 ssize_t outbytes;
1758 size_t left = len;
1759 exim_gnutls_state_st *state = current_global_tls_state;
1760
1761 DEBUG(D_tls) debug_printf("tls_do_write(%p, " SIZE_T_FMT ")\n", buff, left);
1762 while (left > 0)
1763   {
1764   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT ")\n",
1765       buff, left);
1766   outbytes = gnutls_record_send(state->session, buff, left);
1767
1768   DEBUG(D_tls) debug_printf("outbytes=" SSIZE_T_FMT "\n", outbytes);
1769   if (outbytes < 0)
1770     {
1771     record_io_error(state, outbytes, US"send", NULL);
1772     return -1;
1773     }
1774   if (outbytes == 0)
1775     {
1776     record_io_error(state, 0, US"send", US"TLS channel closed on write");
1777     return -1;
1778     }
1779
1780   left -= outbytes;
1781   buff += outbytes;
1782   }
1783
1784 if (len > INT_MAX)
1785   {
1786   DEBUG(D_tls)
1787     debug_printf("Whoops!  Wrote more bytes (" SIZE_T_FMT ") than INT_MAX\n",
1788         len);
1789   len = INT_MAX;
1790   }
1791
1792 return (int) len;
1793 }
1794
1795
1796
1797
1798 /*************************************************
1799 *            Random number generation            *
1800 *************************************************/
1801
1802 /* Pseudo-random number generation.  The result is not expected to be
1803 cryptographically strong but not so weak that someone will shoot themselves
1804 in the foot using it as a nonce in input in some email header scheme or
1805 whatever weirdness they'll twist this into.  The result should handle fork()
1806 and avoid repeating sequences.  OpenSSL handles that for us.
1807
1808 Arguments:
1809   max       range maximum
1810 Returns     a random number in range [0, max-1]
1811 */
1812
1813 #ifdef HAVE_GNUTLS_RND
1814 int
1815 vaguely_random_number(int max)
1816 {
1817 unsigned int r;
1818 int i, needed_len;
1819 uschar *p;
1820 uschar smallbuf[sizeof(r)];
1821
1822 if (max <= 1)
1823   return 0;
1824
1825 needed_len = sizeof(r);
1826 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1827  * asked for a number less than 10. */
1828 for (r = max, i = 0; r; ++i)
1829   r >>= 1;
1830 i = (i + 7) / 8;
1831 if (i < needed_len)
1832   needed_len = i;
1833
1834 i = gnutls_rnd(GNUTLS_RND_NONCE, smallbuf, needed_len);
1835 if (i < 0)
1836   {
1837   DEBUG(D_all) debug_printf("gnutls_rnd() failed, using fallback.\n");
1838   return vaguely_random_number_fallback(max);
1839   }
1840 r = 0;
1841 for (p = smallbuf; needed_len; --needed_len, ++p)
1842   {
1843   r *= 256;
1844   r += *p;
1845   }
1846
1847 /* We don't particularly care about weighted results; if someone wants
1848  * smooth distribution and cares enough then they should submit a patch then. */
1849 return r % max;
1850 }
1851 #else /* HAVE_GNUTLS_RND */
1852 int
1853 vaguely_random_number(int max)
1854 {
1855   return vaguely_random_number_fallback(max);
1856 }
1857 #endif /* HAVE_GNUTLS_RND */
1858
1859
1860
1861
1862 /*************************************************
1863 *  Let tls_require_ciphers be checked at startup *
1864 *************************************************/
1865
1866 /* The tls_require_ciphers option, if set, must be something which the
1867 library can parse.
1868
1869 Returns:     NULL on success, or error message
1870 */
1871
1872 uschar *
1873 tls_validate_require_cipher(void)
1874 {
1875 int rc;
1876 uschar *expciphers = NULL;
1877 gnutls_priority_t priority_cache;
1878 const char *errpos;
1879
1880 #define validate_check_rc(Label) do { \
1881   if (rc != GNUTLS_E_SUCCESS) { if (exim_gnutls_base_init_done) gnutls_global_deinit(); \
1882   return string_sprintf("%s failed: %s", (Label), gnutls_strerror(rc)); } } while (0)
1883 #define return_deinit(Label) do { gnutls_global_deinit(); return (Label); } while (0)
1884
1885 if (exim_gnutls_base_init_done)
1886   log_write(0, LOG_MAIN|LOG_PANIC,
1887       "already initialised GnuTLS, Exim developer bug");
1888
1889 rc = gnutls_global_init();
1890 validate_check_rc(US"gnutls_global_init()");
1891 exim_gnutls_base_init_done = TRUE;
1892
1893 if (!(tls_require_ciphers && *tls_require_ciphers))
1894   return_deinit(NULL);
1895
1896 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers))
1897   return_deinit(US"failed to expand tls_require_ciphers");
1898
1899 if (!(expciphers && *expciphers))
1900   return_deinit(NULL);
1901
1902 DEBUG(D_tls)
1903   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
1904
1905 rc = gnutls_priority_init(&priority_cache, CS expciphers, &errpos);
1906 validate_check_rc(string_sprintf(
1907       "gnutls_priority_init(%s) failed at offset %ld, \"%.8s..\"",
1908       expciphers, errpos - CS expciphers, errpos));
1909
1910 #undef return_deinit
1911 #undef validate_check_rc
1912 gnutls_global_deinit();
1913
1914 return NULL;
1915 }
1916
1917
1918
1919
1920 /*************************************************
1921 *         Report the library versions.           *
1922 *************************************************/
1923
1924 /* See a description in tls-openssl.c for an explanation of why this exists.
1925
1926 Arguments:   a FILE* to print the results to
1927 Returns:     nothing
1928 */
1929
1930 void
1931 tls_version_report(FILE *f)
1932 {
1933 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
1934            "                         Runtime: %s\n",
1935            LIBGNUTLS_VERSION,
1936            gnutls_check_version(NULL));
1937 }
1938
1939 /* End of tls-gnu.c */