23f8bd6adb01815b338254c8967bcac49a60d05d
[users/jgh/exim.git] / src / src / tls-gnu.c
1 /* $Cambridge: exim/src/src/tls-gnu.c,v 1.24 2009/11/16 19:50:37 nm4 Exp $ */
2
3 /*************************************************
4 *     Exim - an Internet mail transport agent    *
5 *************************************************/
6
7 /* Copyright (c) University of Cambridge 1995 - 2009 */
8 /* See the file NOTICE for conditions of use and distribution. */
9
10 /* This module provides TLS (aka SSL) support for Exim using the GnuTLS
11 library. It is #included into tls.c when that library is used. The code herein
12 is based on a patch that was contributed by Nikos Mavroyanopoulos.
13
14 No cryptographic code is included in Exim. All this module does is to call
15 functions from the GnuTLS library. */
16
17
18 /* Heading stuff for GnuTLS */
19
20 #include <gnutls/gnutls.h>
21 #include <gnutls/x509.h>
22
23
24 #define UNKNOWN_NAME "unknown"
25 #define DH_BITS      1024
26 #define PARAM_SIZE 2*1024
27
28
29 /* Values for verify_requirment */
30
31 enum { VERIFY_NONE, VERIFY_OPTIONAL, VERIFY_REQUIRED };
32
33 /* Local static variables for GNUTLS */
34
35 static host_item *client_host;
36
37 static gnutls_dh_params dh_params = NULL;
38
39 static gnutls_certificate_server_credentials x509_cred = NULL;
40 static gnutls_session tls_session = NULL;
41
42 static char ssl_errstring[256];
43
44 static int  ssl_session_timeout = 200;
45 static int  verify_requirement;
46
47 /* Priorities for TLS algorithms to use. In each case there's a default table,
48 and space into which it can be copied and altered. */
49
50 static const int default_proto_priority[16] = {
51   GNUTLS_TLS1,
52   GNUTLS_SSL3,
53   0 };
54
55 static int proto_priority[16];
56
57 static const int default_kx_priority[16] = {
58   GNUTLS_KX_RSA,
59   GNUTLS_KX_DHE_DSS,
60   GNUTLS_KX_DHE_RSA,
61   0 };
62
63 static int kx_priority[16];
64
65 static int default_cipher_priority[16] = {
66   GNUTLS_CIPHER_AES_256_CBC,
67   GNUTLS_CIPHER_AES_128_CBC,
68   GNUTLS_CIPHER_3DES_CBC,
69   GNUTLS_CIPHER_ARCFOUR_128,
70   0 };
71
72 static int cipher_priority[16];
73
74 static const int default_mac_priority[16] = {
75   GNUTLS_MAC_SHA,
76   GNUTLS_MAC_MD5,
77   0 };
78
79 static int mac_priority[16];
80
81 /* These two are currently not changeable. */
82
83 static const int comp_priority[16] = { GNUTLS_COMP_NULL, 0 };
84 static const int cert_type_priority[16] = { GNUTLS_CRT_X509, 0 };
85
86 /* Tables of priority names and equivalent numbers */
87
88 typedef struct pri_item {
89   uschar *name;
90   int *values;
91 } pri_item;
92
93
94 static int tls1_codes[] = { GNUTLS_TLS1, 0 };
95 static int ssl3_codes[] = { GNUTLS_SSL3, 0 };
96
97 static pri_item proto_index[] = {
98   { US"TLS1", tls1_codes },
99   { US"SSL3", ssl3_codes }
100 };
101
102
103 static int kx_rsa_codes[]      = { GNUTLS_KX_RSA,
104                                    GNUTLS_KX_DHE_RSA, 0 };
105 static int kx_dhe_codes[]      = { GNUTLS_KX_DHE_DSS,
106                                    GNUTLS_KX_DHE_RSA, 0 };
107 static int kx_dhe_dss_codes[]  = { GNUTLS_KX_DHE_DSS, 0 };
108 static int kx_dhe_rsa_codes[]  = { GNUTLS_KX_DHE_RSA, 0 };
109
110 static pri_item kx_index[] = {
111   { US"DHE_DSS", kx_dhe_dss_codes },
112   { US"DHE_RSA", kx_dhe_rsa_codes },
113   { US"RSA", kx_rsa_codes },
114   { US"DHE", kx_dhe_codes }
115 };
116
117
118 static int arcfour_128_codes[] = { GNUTLS_CIPHER_ARCFOUR_128, 0 };
119 static int arcfour_40_codes[]  = { GNUTLS_CIPHER_ARCFOUR_40, 0 };
120 static int arcfour_codes[]     = { GNUTLS_CIPHER_ARCFOUR_128,
121                                    GNUTLS_CIPHER_ARCFOUR_40, 0 };
122 static int aes_256_codes[]     = { GNUTLS_CIPHER_AES_256_CBC, 0 };
123 static int aes_128_codes[]     = { GNUTLS_CIPHER_AES_128_CBC, 0 };
124 static int aes_codes[]         = { GNUTLS_CIPHER_AES_256_CBC,
125                                    GNUTLS_CIPHER_AES_128_CBC, 0 };
126 static int des3_codes[]        = { GNUTLS_CIPHER_3DES_CBC, 0 };
127
128 static pri_item cipher_index[] = {
129   { US"ARCFOUR_128", arcfour_128_codes },
130   { US"ARCFOUR_40", arcfour_40_codes },
131   { US"ARCFOUR", arcfour_codes },
132   { US"AES_256", aes_256_codes },
133   { US"AES_128", aes_128_codes },
134   { US"AES", aes_codes },
135   { US"3DES", des3_codes }
136 };
137
138
139 static int mac_sha_codes[]     = { GNUTLS_MAC_SHA, 0 };
140 static int mac_md5_codes[]     = { GNUTLS_MAC_MD5, 0 };
141
142 static pri_item mac_index[] = {
143   { US"SHA",  mac_sha_codes },
144   { US"SHA1", mac_sha_codes },
145   { US"MD5",  mac_md5_codes }
146 };
147
148
149
150 /*************************************************
151 *               Handle TLS error                 *
152 *************************************************/
153
154 /* Called from lots of places when errors occur before actually starting to do
155 the TLS handshake, that is, while the session is still in clear. Always returns
156 DEFER for a server and FAIL for a client so that most calls can use "return
157 tls_error(...)" to do this processing and then give an appropriate return. A
158 single function is used for both server and client, because it is called from
159 some shared functions.
160
161 Argument:
162   prefix    text to include in the logged error
163   host      NULL if setting up a server;
164             the connected host if setting up a client
165   msg       additional error string (may be NULL)
166             usually obtained from gnutls_strerror()
167
168 Returns:    OK/DEFER/FAIL
169 */
170
171 static int
172 tls_error(uschar *prefix, host_item *host, const char *msg)
173 {
174 if (host == NULL)
175   {
176   uschar *conn_info = smtp_get_connection_info();
177   if (strncmp(conn_info, "SMTP ", 5) == 0)
178     conn_info += 5;
179   log_write(0, LOG_MAIN, "TLS error on %s (%s)%s%s",
180     conn_info, prefix, msg ? ": " : "", msg ? msg : "");
181   return DEFER;
182   }
183 else
184   {
185   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s)%s%s",
186     host->name, host->address, prefix, msg ? ": " : "", msg ? msg : "");
187   return FAIL;
188   }
189 }
190
191
192
193 /*************************************************
194 *             Verify certificate                 *
195 *************************************************/
196
197 /* Called after a successful handshake, when certificate verification is
198 required or optional, for both server and client.
199
200 Arguments:
201   session    GNUTLS session
202   error      where to put text giving a reason for failure
203
204 Returns:     TRUE/FALSE
205 */
206
207 static BOOL
208 verify_certificate(gnutls_session session, const char **error)
209 {
210 int verify;
211 uschar *dn_string = US"";
212 const gnutls_datum *cert;
213 unsigned int cert_size = 0;
214
215 *error = NULL;
216
217 /* Get the peer's certificate. If it sent one, extract it's DN, and then
218 attempt to verify the certificate. If no certificate is supplied, verification
219 is forced to fail. */
220
221 cert = gnutls_certificate_get_peers(session, &cert_size);
222 if (cert != NULL)
223   {
224   uschar buff[1024];
225   gnutls_x509_crt gcert;
226
227   gnutls_x509_crt_init(&gcert);
228   dn_string = US"unknown";
229
230   if (gnutls_x509_crt_import(gcert, cert, GNUTLS_X509_FMT_DER) == 0)
231     {
232     size_t bufsize = sizeof(buff);
233     if (gnutls_x509_crt_get_dn(gcert, CS buff, &bufsize) >= 0)
234       dn_string = string_copy_malloc(buff);
235     }
236
237   verify = gnutls_certificate_verify_peers(session);
238   }
239 else
240   {
241   DEBUG(D_tls) debug_printf("no peer certificate supplied\n");
242   verify = GNUTLS_CERT_INVALID;
243   *error = "not supplied";
244   }
245
246 /* Handle the result of verification. INVALID seems to be set as well
247 as REVOKED, but leave the test for both. */
248
249 if ((verify & (GNUTLS_CERT_INVALID|GNUTLS_CERT_REVOKED)) != 0)
250   {
251   tls_certificate_verified = FALSE;
252   if (*error == NULL) *error = ((verify & GNUTLS_CERT_REVOKED) != 0)?
253     "revoked" : "invalid";
254   if (verify_requirement == VERIFY_REQUIRED)
255     {
256     DEBUG(D_tls) debug_printf("TLS certificate verification failed (%s): "
257       "peerdn=%s\n", *error, dn_string);
258     gnutls_alert_send(session, GNUTLS_AL_FATAL, GNUTLS_A_BAD_CERTIFICATE);
259     return FALSE;                       /* reject */
260     }
261   DEBUG(D_tls) debug_printf("TLS certificate verify failure (%s) overridden "
262       "(host in tls_try_verify_hosts): peerdn=%s\n", *error, dn_string);
263   }
264 else
265   {
266   tls_certificate_verified = TRUE;
267   DEBUG(D_tls) debug_printf("TLS certificate verified: peerdn=%s\n",
268     dn_string);
269   }
270
271 tls_peerdn = dn_string;
272 return TRUE;                            /* accept */
273 }
274
275
276
277 /*************************************************
278 *            Setup up DH parameters              *
279 *************************************************/
280
281 /* Generating the D-H parameters may take a long time. They only need to
282 be re-generated every so often, depending on security policy. What we do is to
283 keep these parameters in a file in the spool directory. If the file does not
284 exist, we generate them. This means that it is easy to cause a regeneration.
285
286 The new file is written as a temporary file and renamed, so that an incomplete
287 file is never present. If two processes both compute some new parameters, you
288 waste a bit of effort, but it doesn't seem worth messing around with locking to
289 prevent this.
290
291 Argument:
292   host       NULL for server, server for client (for error handling)
293
294 Returns:     OK/DEFER/FAIL
295 */
296
297 static int
298 init_dh(host_item *host)
299 {
300 int fd;
301 int ret;
302 gnutls_datum m;
303 uschar filename[200];
304
305 /* Initialize the data structures for holding the parameters */
306
307 ret = gnutls_dh_params_init(&dh_params);
308 if (ret < 0) return tls_error(US"init dh_params", host, gnutls_strerror(ret));
309
310 /* Set up the name of the cache file */
311
312 if (!string_format(filename, sizeof(filename), "%s/gnutls-params",
313       spool_directory))
314   return tls_error(US"overlong filename", host, NULL);
315
316 /* Open the cache file for reading and if successful, read it and set up the
317 parameters. */
318
319 fd = Uopen(filename, O_RDONLY, 0);
320 if (fd >= 0)
321   {
322   struct stat statbuf;
323   if (fstat(fd, &statbuf) < 0)
324     {
325     (void)close(fd);
326     return tls_error(US"TLS cache stat failed", host, strerror(errno));
327     }
328
329   m.size = statbuf.st_size;
330   m.data = malloc(m.size);
331   if (m.data == NULL)
332     return tls_error(US"memory allocation failed", host, strerror(errno));
333   errno = 0;
334   if (read(fd, m.data, m.size) != m.size)
335     return tls_error(US"TLS cache read failed", host, strerror(errno));
336   (void)close(fd);
337
338   ret = gnutls_dh_params_import_pkcs3(dh_params, &m, GNUTLS_X509_FMT_PEM);
339   if (ret < 0)
340     return tls_error(US"DH params import", host, gnutls_strerror(ret));
341   DEBUG(D_tls) debug_printf("read D-H parameters from file\n");
342
343   free(m.data);
344   }
345
346 /* If the file does not exist, fall through to compute new data and cache it.
347 If there was any other opening error, it is serious. */
348
349 else if (errno == ENOENT)
350   {
351   ret = -1;
352   DEBUG(D_tls)
353     debug_printf("parameter cache file %s does not exist\n", filename);
354   }
355 else
356   return tls_error(string_open_failed(errno, "%s for reading", filename),
357     host, NULL);
358
359 /* If ret < 0, either the cache file does not exist, or the data it contains
360 is not useful. One particular case of this is when upgrading from an older
361 release of Exim in which the data was stored in a different format. We don't
362 try to be clever and support both formats; we just regenerate new data in this
363 case. */
364
365 if (ret < 0)
366   {
367   uschar tempfilename[sizeof(filename) + 10];
368
369   DEBUG(D_tls) debug_printf("generating %d bit Diffie-Hellman key...\n",
370     DH_BITS);
371   ret = gnutls_dh_params_generate2(dh_params, DH_BITS);
372   if (ret < 0) return tls_error(US"D-H key generation", host, gnutls_strerror(ret));
373
374   /* Write the parameters to a file in the spool directory so that we
375   can use them from other Exim processes. */
376
377   sprintf(CS tempfilename, "%s-%d", filename, (int)getpid());
378   fd = Uopen(tempfilename, O_WRONLY|O_CREAT, 0400);
379   if (fd < 0)
380     return tls_error(string_open_failed(errno, "%s for writing", filename),
381       host, NULL);
382   (void)fchown(fd, exim_uid, exim_gid);   /* Probably not necessary */
383
384   /* export the parameters in a format that can be generated using GNUTLS'
385    * certtool or other programs.
386    *
387    * The commands for certtool are:
388    * $ certtool --generate-dh-params --bits 1024 > params
389    */
390
391   m.size = PARAM_SIZE;
392   m.data = malloc(m.size);
393   if (m.data == NULL)
394     return tls_error(US"memory allocation failed", host, strerror(errno));
395
396   m.size = PARAM_SIZE;
397   ret = gnutls_dh_params_export_pkcs3(dh_params, GNUTLS_X509_FMT_PEM, m.data,
398     &m.size);
399   if (ret < 0)
400     return tls_error(US"DH params export", host, gnutls_strerror(ret));
401
402   m.size = Ustrlen(m.data);
403   errno = 0;
404   if (write(fd, m.data, m.size) != m.size || write(fd, "\n", 1) != 1)
405     return tls_error(US"TLS cache write failed", host, strerror(errno));
406
407   free(m.data);
408   (void)close(fd);
409
410   if (rename(CS tempfilename, CS filename) < 0)
411     return tls_error(string_sprintf("failed to rename %s as %s",
412       tempfilename, filename), host, strerror(errno));
413
414   DEBUG(D_tls) debug_printf("wrote D-H parameters to file %s\n", filename);
415   }
416
417 DEBUG(D_tls) debug_printf("initialized D-H parameters\n");
418 return OK;
419 }
420
421
422
423
424 /*************************************************
425 *            Initialize for GnuTLS               *
426 *************************************************/
427
428 /* Called from both server and client code. In the case of a server, errors
429 before actual TLS negotiation return DEFER.
430
431 Arguments:
432   host            connected host, if client; NULL if server
433   certificate     certificate file
434   privatekey      private key file
435   cas             CA certs file
436   crl             CRL file
437
438 Returns:          OK/DEFER/FAIL
439 */
440
441 static int
442 tls_init(host_item *host, uschar *certificate, uschar *privatekey, uschar *cas,
443   uschar *crl)
444 {
445 int rc;
446 uschar *cert_expanded, *key_expanded, *cas_expanded, *crl_expanded;
447
448 client_host = host;
449
450 rc = gnutls_global_init();
451 if (rc < 0) return tls_error(US"tls-init", host, gnutls_strerror(rc));
452
453 /* Create D-H parameters, or read them from the cache file. This function does
454 its own SMTP error messaging. */
455
456 rc = init_dh(host);
457 if (rc != OK) return rc;
458
459 /* Create the credentials structure */
460
461 rc = gnutls_certificate_allocate_credentials(&x509_cred);
462 if (rc < 0)
463   return tls_error(US"certificate_allocate_credentials",
464     host, gnutls_strerror(rc));
465
466 /* This stuff must be done for each session, because different certificates
467 may be required for different sessions. */
468
469 if (!expand_check(certificate, US"tls_certificate", &cert_expanded))
470   return DEFER;
471
472 key_expanded = NULL;
473 if (privatekey != NULL)
474   {
475   if (!expand_check(privatekey, US"tls_privatekey", &key_expanded))
476     return DEFER;
477   }
478
479 /* If expansion was forced to fail, key_expanded will be NULL. If the result of
480 the expansion is an empty string, ignore it also, and assume that the private
481 key is in the same file as the certificate. */
482
483 if (key_expanded == NULL || *key_expanded == 0)
484   key_expanded = cert_expanded;
485
486 /* Set the certificate and private keys */
487
488 if (cert_expanded != NULL)
489   {
490   DEBUG(D_tls) debug_printf("certificate file = %s\nkey file = %s\n",
491     cert_expanded, key_expanded);
492   rc = gnutls_certificate_set_x509_key_file(x509_cred, CS cert_expanded,
493     CS key_expanded, GNUTLS_X509_FMT_PEM);
494   if (rc < 0)
495     {
496     uschar *msg = string_sprintf("cert/key setup: cert=%s key=%s",
497       cert_expanded, key_expanded);
498     return tls_error(msg, host, gnutls_strerror(rc));
499     }
500   }
501
502 /* A certificate is mandatory in a server, but not in a client */
503
504 else
505   {
506   if (host == NULL)
507     return tls_error(US"no TLS server certificate is specified", NULL, NULL);
508   DEBUG(D_tls) debug_printf("no TLS client certificate is specified\n");
509   }
510
511 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
512 provided. Experiment shows that, if the certificate file is empty, an unhelpful
513 error message is provided. However, if we just refrain from setting anything up
514 in that case, certificate verification fails, which seems to be the correct
515 behaviour. */
516
517 if (cas != NULL)
518   {
519   struct stat statbuf;
520
521   if (!expand_check(cas, US"tls_verify_certificates", &cas_expanded))
522     return DEFER;
523
524   if (stat(CS cas_expanded, &statbuf) < 0)
525     {
526     log_write(0, LOG_MAIN|LOG_PANIC, "could not stat %s "
527       "(tls_verify_certificates): %s", cas_expanded, strerror(errno));
528     return DEFER;
529     }
530
531   DEBUG(D_tls) debug_printf("verify certificates = %s size=" OFF_T_FMT "\n",
532     cas_expanded, statbuf.st_size);
533
534   /* If the cert file is empty, there's no point in loading the CRL file. */
535
536   if (statbuf.st_size > 0)
537     {
538     rc = gnutls_certificate_set_x509_trust_file(x509_cred, CS cas_expanded,
539       GNUTLS_X509_FMT_PEM);
540     if (rc < 0) return tls_error(US"setup_certs", host, gnutls_strerror(rc));
541
542     if (crl != NULL && *crl != 0)
543       {
544       if (!expand_check(crl, US"tls_crl", &crl_expanded))
545         return DEFER;
546       DEBUG(D_tls) debug_printf("loading CRL file = %s\n", crl_expanded);
547       rc = gnutls_certificate_set_x509_crl_file(x509_cred, CS crl_expanded,
548         GNUTLS_X509_FMT_PEM);
549       if (rc < 0) return tls_error(US"CRL setup", host, gnutls_strerror(rc));
550       }
551     }
552   }
553
554 /* Associate the parameters with the x509 credentials structure. */
555
556 gnutls_certificate_set_dh_params(x509_cred, dh_params);
557
558 DEBUG(D_tls) debug_printf("initialized certificate stuff\n");
559 return OK;
560 }
561
562
563
564
565 /*************************************************
566 *           Remove from a priority list          *
567 *************************************************/
568
569 /* Cautiously written so that it will remove duplicates if present.
570
571 Arguments:
572   list         a zero-terminated list
573   remove_list  a zero-terminated list to be removed
574
575 Returns:       nothing
576 */
577
578 static void
579 remove_priority(int *list, int *remove_list)
580 {
581 for (; *remove_list != 0; remove_list++)
582   {
583   int *p = list;
584   while (*p != 0)
585     {
586     if (*p == *remove_list)
587       {
588       int *pp = p;
589       do { pp[0] = pp[1]; pp++; } while (*pp != 0);
590       }
591     else p++;
592     }
593   }
594 }
595
596
597
598 /*************************************************
599 *            Add to a priority list              *
600 *************************************************/
601
602 /* Cautiously written to check the list size
603
604 Arguments:
605   list         a zero-terminated list
606   list_max     maximum offset in the list
607   add_list     a zero-terminated list to be added
608
609 Returns:       TRUE if OK; FALSE if list overflows
610 */
611
612 static BOOL
613 add_priority(int *list, int list_max, int *add_list)
614 {
615 int next = 0;
616 while (list[next] != 0) next++;
617 while (*add_list != 0)
618   {
619   if (next >= list_max) return FALSE;
620   list[next++] = *add_list++;
621   }
622 list[next] = 0;
623 return TRUE;
624 }
625
626
627
628 /*************************************************
629 *          Adjust a priority list                *
630 *************************************************/
631
632 /* This function is called to adjust the lists of cipher algorithms, MAC
633 algorithms, key-exchange methods, and protocols.
634
635 Arguments:
636   plist       the appropriate priority list
637   psize       the length of the list
638   s           the configuation string
639   index       the index of recognized strings
640   isize       the length of the index
641
642
643   which       text for an error message
644
645 Returns:      FALSE if the table overflows, else TRUE
646 */
647
648 static BOOL
649 set_priority(int *plist, int psize, uschar *s, pri_item *index, int isize,
650    uschar *which)
651 {
652 int sep = 0;
653 BOOL first = TRUE;
654 uschar *t;
655
656 while ((t = string_nextinlist(&s, &sep, big_buffer, big_buffer_size)) != NULL)
657   {
658   int i;
659   BOOL exclude = t[0] == '!';
660   if (first && !exclude) plist[0] = 0;
661   first = FALSE;
662   for (i = 0; i < isize; i++)
663     {
664     uschar *ss = strstric(t, index[i].name, FALSE);
665     if (ss != NULL)
666       {
667       uschar *endss = ss + Ustrlen(index[i].name);
668       if ((ss == t || !isalnum(ss[-1])) && !isalnum(*endss))
669         {
670         if (exclude)
671           remove_priority(plist, index[i].values);
672         else
673           {
674           if (!add_priority(plist, psize, index[i].values))
675             {
676             log_write(0, LOG_MAIN|LOG_PANIC, "GnuTLS init failed: %s "
677               "priority table overflow", which);
678             return FALSE;
679             }
680           }
681         }
682       }
683     }
684   }
685
686 DEBUG(D_tls)
687   {
688   int *ptr = plist;
689   debug_printf("adjusted %s priorities:", which);
690   while (*ptr != 0) debug_printf(" %d", *ptr++);
691   debug_printf("\n");
692   }
693
694 return TRUE;
695 }
696
697
698
699
700 /*************************************************
701 *        Initialize a single GNUTLS session      *
702 *************************************************/
703
704 /* Set the algorithm, the db backend, whether to request certificates etc.
705
706 TLS in Exim was first implemented using OpenSSL. This has a function to which
707 you pass a list of cipher suites that are permitted/not permitted. GnuTLS works
708 differently. It operates using priority lists for the different components of
709 cipher suites.
710
711 For compatibility of configuration, we scan a list of cipher suites and set
712 priorities therefrom. However, at the moment, we pay attention only to the bulk
713 cipher.
714
715 Arguments:
716   side         one of GNUTLS_SERVER, GNUTLS_CLIENT
717   expciphers   expanded ciphers list or NULL
718   expmac       expanded MAC list or NULL
719   expkx        expanded key-exchange list or NULL
720   expproto     expanded protocol list or NULL
721
722 Returns:  a gnutls_session, or NULL if there is a problem
723 */
724
725 static gnutls_session
726 tls_session_init(int side, uschar *expciphers, uschar *expmac, uschar *expkx,
727   uschar *expproto)
728 {
729 gnutls_session session;
730
731 gnutls_init(&session, side);
732
733 /* Initialize the lists of permitted protocols, key-exchange methods, ciphers,
734 and MACs. */
735
736 memcpy(cipher_priority, default_cipher_priority, sizeof(cipher_priority));
737 memcpy(mac_priority, default_mac_priority, sizeof(mac_priority));
738 memcpy(kx_priority, default_kx_priority, sizeof(kx_priority));
739 memcpy(proto_priority, default_proto_priority, sizeof(proto_priority));
740
741 /* The names OpenSSL uses in tls_require_ciphers are of the form DES-CBC3-SHA,
742 using hyphen separators. GnuTLS uses underscore separators. So that I can use
743 either form for tls_require_ciphers in my tests, and also for general
744 convenience, we turn hyphens into underscores before scanning the list. */
745
746 if (expciphers != NULL)
747   {
748   uschar *s = expciphers;
749   while (*s != 0) { if (*s == '-') *s = '_'; s++; }
750   }
751
752 if ((expciphers != NULL &&
753       !set_priority(cipher_priority, sizeof(cipher_priority)/sizeof(int),
754         expciphers, cipher_index, sizeof(cipher_index)/sizeof(pri_item),
755         US"cipher")) ||
756     (expmac != NULL &&
757       !set_priority(mac_priority, sizeof(mac_priority)/sizeof(int),
758         expmac, mac_index, sizeof(mac_index)/sizeof(pri_item),
759         US"MAC")) ||
760     (expkx != NULL &&
761       !set_priority(kx_priority, sizeof(kx_priority)/sizeof(int),
762         expkx, kx_index, sizeof(kx_index)/sizeof(pri_item),
763         US"key-exchange")) ||
764     (expproto != NULL &&
765       !set_priority(proto_priority, sizeof(proto_priority)/sizeof(int),
766         expproto, proto_index, sizeof(proto_index)/sizeof(pri_item),
767         US"protocol")))
768   {
769   gnutls_deinit(session);
770   return NULL;
771   }
772
773 /* Define the various priorities */
774
775 gnutls_cipher_set_priority(session, cipher_priority);
776 gnutls_compression_set_priority(session, comp_priority);
777 gnutls_kx_set_priority(session, kx_priority);
778 gnutls_protocol_set_priority(session, proto_priority);
779 gnutls_mac_set_priority(session, mac_priority);
780
781 gnutls_cred_set(session, GNUTLS_CRD_CERTIFICATE, x509_cred);
782
783 gnutls_dh_set_prime_bits(session, DH_BITS);
784
785 /* Request or demand a certificate of the peer, as configured. This will
786 happen only in a server. */
787
788 if (verify_requirement != VERIFY_NONE)
789   gnutls_certificate_server_set_request(session,
790     (verify_requirement == VERIFY_OPTIONAL)?
791       GNUTLS_CERT_REQUEST : GNUTLS_CERT_REQUIRE);
792
793 gnutls_db_set_cache_expiration(session, ssl_session_timeout);
794
795 /* Reduce security in favour of increased compatibility, if the admin
796 decides to make that trade-off. */
797 if (gnutls_compat_mode)
798   {
799 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
800   DEBUG(D_tls) debug_printf("lowering GnuTLS security, compatibility mode\n");
801   gnutls_session_enable_compatibility_mode(session);
802 #else
803   DEBUG(D_tls) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
804 #endif
805   }
806
807 DEBUG(D_tls) debug_printf("initialized GnuTLS session\n");
808 return session;
809 }
810
811
812
813 /*************************************************
814 *           Get name of cipher in use            *
815 *************************************************/
816
817 /* The answer is left in a static buffer, and tls_cipher is set to point
818 to it.
819
820 Argument:   pointer to a GnuTLS session
821 Returns:    nothing
822 */
823
824 static void
825 construct_cipher_name(gnutls_session session)
826 {
827 static uschar cipherbuf[256];
828 uschar *ver;
829 int bits, c, kx, mac;
830
831 ver = string_copy(
832   US gnutls_protocol_get_name(gnutls_protocol_get_version(session)));
833 if (Ustrncmp(ver, "TLS ", 4) == 0) ver[3] = '-';   /* Don't want space */
834
835 c = gnutls_cipher_get(session);
836 bits = gnutls_cipher_get_key_size(c);
837
838 mac = gnutls_mac_get(session);
839 kx = gnutls_kx_get(session);
840
841 string_format(cipherbuf, sizeof(cipherbuf), "%s:%s:%u", ver,
842   gnutls_cipher_suite_get_name(kx, c, mac), bits);
843 tls_cipher = cipherbuf;
844
845 DEBUG(D_tls) debug_printf("cipher: %s\n", cipherbuf);
846 }
847
848
849
850 /*************************************************
851 *       Start a TLS session in a server          *
852 *************************************************/
853
854 /* This is called when Exim is running as a server, after having received
855 the STARTTLS command. It must respond to that command, and then negotiate
856 a TLS session.
857
858 Arguments:
859   require_ciphers  list of allowed ciphers or NULL
860   require_mac      list of allowed MACs or NULL
861   require_kx       list of allowed key_exchange methods or NULL
862   require_proto    list of allowed protocols or NULL
863
864 Returns:           OK on success
865                    DEFER for errors before the start of the negotiation
866                    FAIL for errors during the negotation; the server can't
867                      continue running.
868 */
869
870 int
871 tls_server_start(uschar *require_ciphers, uschar *require_mac,
872   uschar *require_kx, uschar *require_proto)
873 {
874 int rc;
875 const char *error;
876 uschar *expciphers = NULL;
877 uschar *expmac = NULL;
878 uschar *expkx = NULL;
879 uschar *expproto = NULL;
880
881 /* Check for previous activation */
882
883 if (tls_active >= 0)
884   {
885   tls_error("STARTTLS received after TLS started", NULL, "");
886   smtp_printf("554 Already in TLS\r\n");
887   return FAIL;
888   }
889
890 /* Initialize the library. If it fails, it will already have logged the error
891 and sent an SMTP response. */
892
893 DEBUG(D_tls) debug_printf("initializing GnuTLS as a server\n");
894
895 rc = tls_init(NULL, tls_certificate, tls_privatekey, tls_verify_certificates,
896   tls_crl);
897 if (rc != OK) return rc;
898
899 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers) ||
900     !expand_check(require_mac, US"gnutls_require_mac", &expmac) ||
901     !expand_check(require_kx, US"gnutls_require_kx", &expkx) ||
902     !expand_check(require_proto, US"gnutls_require_proto", &expproto))
903   return FAIL;
904
905 /* If this is a host for which certificate verification is mandatory or
906 optional, set up appropriately. */
907
908 tls_certificate_verified = FALSE;
909 verify_requirement = VERIFY_NONE;
910
911 if (verify_check_host(&tls_verify_hosts) == OK)
912   verify_requirement = VERIFY_REQUIRED;
913 else if (verify_check_host(&tls_try_verify_hosts) == OK)
914   verify_requirement = VERIFY_OPTIONAL;
915
916 /* Prepare for new connection */
917
918 tls_session = tls_session_init(GNUTLS_SERVER, expciphers, expmac, expkx,
919   expproto);
920 if (tls_session == NULL)
921   return tls_error(US"tls_session_init", NULL,
922     gnutls_strerror(GNUTLS_E_MEMORY_ERROR));
923
924 /* Set context and tell client to go ahead, except in the case of TLS startup
925 on connection, where outputting anything now upsets the clients and tends to
926 make them disconnect. We need to have an explicit fflush() here, to force out
927 the response. Other smtp_printf() calls do not need it, because in non-TLS
928 mode, the fflush() happens when smtp_getc() is called. */
929
930 if (!tls_on_connect)
931   {
932   smtp_printf("220 TLS go ahead\r\n");
933   fflush(smtp_out);
934   }
935
936 /* Now negotiate the TLS session. We put our own timer on it, since it seems
937 that the GnuTLS library doesn't. */
938
939 gnutls_transport_set_ptr2(tls_session, (gnutls_transport_ptr)fileno(smtp_in),
940                                        (gnutls_transport_ptr)fileno(smtp_out));
941
942 sigalrm_seen = FALSE;
943 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
944 rc = gnutls_handshake(tls_session);
945 alarm(0);
946
947 if (rc < 0)
948   {
949   tls_error(US"gnutls_handshake", NULL,
950     sigalrm_seen ? "timed out" : gnutls_strerror(rc));
951
952   /* It seems that, except in the case of a timeout, we have to close the
953   connection right here; otherwise if the other end is running OpenSSL it hangs
954   until the server times out. */
955
956   if (!sigalrm_seen)
957     {
958     (void)fclose(smtp_out);
959     (void)fclose(smtp_in);
960     }
961
962   return FAIL;
963   }
964
965 DEBUG(D_tls) debug_printf("gnutls_handshake was successful\n");
966
967 if (verify_requirement != VERIFY_NONE &&
968      !verify_certificate(tls_session, &error))
969   {
970   tls_error(US"certificate verification failed", NULL, error);
971   return FAIL;
972   }
973
974 construct_cipher_name(tls_session);
975
976 /* TLS has been set up. Adjust the input functions to read via TLS,
977 and initialize appropriately. */
978
979 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
980 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
981 ssl_xfer_eof = ssl_xfer_error = 0;
982
983 receive_getc = tls_getc;
984 receive_ungetc = tls_ungetc;
985 receive_feof = tls_feof;
986 receive_ferror = tls_ferror;
987 receive_smtp_buffered = tls_smtp_buffered;
988
989 tls_active = fileno(smtp_out);
990
991 return OK;
992 }
993
994
995
996
997 /*************************************************
998 *    Start a TLS session in a client             *
999 *************************************************/
1000
1001 /* Called from the smtp transport after STARTTLS has been accepted.
1002
1003 Arguments:
1004   fd                the fd of the connection
1005   host              connected host (for messages)
1006   addr              the first address (not used)
1007   dhparam           DH parameter file
1008   certificate       certificate file
1009   privatekey        private key file
1010   verify_certs      file for certificate verify
1011   verify_crl        CRL for verify
1012   require_ciphers   list of allowed ciphers or NULL
1013   require_mac       list of allowed MACs or NULL
1014   require_kx        list of allowed key_exchange methods or NULL
1015   require_proto     list of allowed protocols or NULL
1016   timeout           startup timeout
1017
1018 Returns:            OK/DEFER/FAIL (because using common functions),
1019                     but for a client, DEFER and FAIL have the same meaning
1020 */
1021
1022 int
1023 tls_client_start(int fd, host_item *host, address_item *addr, uschar *dhparam,
1024   uschar *certificate, uschar *privatekey, uschar *verify_certs,
1025   uschar *verify_crl, uschar *require_ciphers, uschar *require_mac,
1026   uschar *require_kx, uschar *require_proto, int timeout)
1027 {
1028 const gnutls_datum *server_certs;
1029 uschar *expciphers = NULL;
1030 uschar *expmac = NULL;
1031 uschar *expkx = NULL;
1032 uschar *expproto = NULL;
1033 const char *error;
1034 unsigned int server_certs_size;
1035 int rc;
1036
1037 DEBUG(D_tls) debug_printf("initializing GnuTLS as a client\n");
1038
1039 verify_requirement = (verify_certs == NULL)? VERIFY_NONE : VERIFY_REQUIRED;
1040 rc = tls_init(host, certificate, privatekey, verify_certs, verify_crl);
1041 if (rc != OK) return rc;
1042
1043 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers) ||
1044     !expand_check(require_mac, US"gnutls_require_mac", &expmac) ||
1045     !expand_check(require_kx, US"gnutls_require_kx", &expkx) ||
1046     !expand_check(require_proto, US"gnutls_require_proto", &expproto))
1047   return FAIL;
1048
1049 tls_session = tls_session_init(GNUTLS_CLIENT, expciphers, expmac, expkx,
1050   expproto);
1051
1052 if (tls_session == NULL)
1053   return tls_error(US "tls_session_init", host,
1054     gnutls_strerror(GNUTLS_E_MEMORY_ERROR));
1055
1056 gnutls_transport_set_ptr(tls_session, (gnutls_transport_ptr)fd);
1057
1058 /* There doesn't seem to be a built-in timeout on connection. */
1059
1060 sigalrm_seen = FALSE;
1061 alarm(timeout);
1062 rc = gnutls_handshake(tls_session);
1063 alarm(0);
1064
1065 if (rc < 0)
1066   return tls_error(US "gnutls_handshake", host,
1067     sigalrm_seen ? "timed out" : gnutls_strerror(rc));
1068
1069 server_certs = gnutls_certificate_get_peers(tls_session, &server_certs_size);
1070
1071 if (server_certs != NULL)
1072   {
1073   uschar buff[1024];
1074   gnutls_x509_crt gcert;
1075
1076   gnutls_x509_crt_init(&gcert);
1077   tls_peerdn = US"unknown";
1078
1079   if (gnutls_x509_crt_import(gcert, server_certs, GNUTLS_X509_FMT_DER) == 0)
1080     {
1081     size_t bufsize = sizeof(buff);
1082     if (gnutls_x509_crt_get_dn(gcert, CS buff, &bufsize) >= 0)
1083       tls_peerdn = string_copy_malloc(buff);
1084     }
1085   }
1086
1087 /* Should we also verify the hostname here? */
1088
1089 if (verify_requirement != VERIFY_NONE &&
1090       !verify_certificate(tls_session, &error))
1091   return tls_error(US"certificate verification failed", host, error);
1092
1093 construct_cipher_name(tls_session);    /* Sets tls_cipher */
1094 tls_active = fd;
1095 return OK;
1096 }
1097
1098
1099
1100 /*************************************************
1101 *    Deal with logging errors during I/O         *
1102 *************************************************/
1103
1104 /* We have to get the identity of the peer from saved data.
1105
1106 Argument:
1107   ec       the GnuTLS error code, or 0 if it's a local error
1108   when     text identifying read or write
1109   text     local error text when ec is 0
1110
1111 Returns:   nothing
1112 */
1113
1114 static void
1115 record_io_error(int ec, uschar *when, uschar *text)
1116 {
1117 const char *msg;
1118
1119 if (ec == GNUTLS_E_FATAL_ALERT_RECEIVED)
1120   msg = string_sprintf("%s: %s", gnutls_strerror(ec),
1121     gnutls_alert_get_name(gnutls_alert_get(tls_session)));
1122 else
1123   msg = gnutls_strerror(ec);
1124
1125 tls_error(when, client_host, msg);
1126 }
1127
1128
1129
1130 /*************************************************
1131 *            TLS version of getc                 *
1132 *************************************************/
1133
1134 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1135 it refills the buffer via the GnuTLS reading function.
1136
1137 Arguments:  none
1138 Returns:    the next character or EOF
1139 */
1140
1141 int
1142 tls_getc(void)
1143 {
1144 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
1145   {
1146   int inbytes;
1147
1148   DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%lx, %lx, %u)\n",
1149     (long) tls_session, (long) ssl_xfer_buffer, ssl_xfer_buffer_size);
1150
1151   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1152   inbytes = gnutls_record_recv(tls_session, CS ssl_xfer_buffer,
1153     ssl_xfer_buffer_size);
1154   alarm(0);
1155
1156   /* A zero-byte return appears to mean that the TLS session has been
1157      closed down, not that the socket itself has been closed down. Revert to
1158      non-TLS handling. */
1159
1160   if (inbytes == 0)
1161     {
1162     DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1163
1164     receive_getc = smtp_getc;
1165     receive_ungetc = smtp_ungetc;
1166     receive_feof = smtp_feof;
1167     receive_ferror = smtp_ferror;
1168     receive_smtp_buffered = smtp_buffered;
1169
1170     gnutls_deinit(tls_session);
1171     tls_session = NULL;
1172     tls_active = -1;
1173     tls_cipher = NULL;
1174     tls_peerdn = NULL;
1175
1176     return smtp_getc();
1177     }
1178
1179   /* Handle genuine errors */
1180
1181   else if (inbytes < 0)
1182     {
1183     record_io_error(inbytes, US"recv", NULL);
1184     ssl_xfer_error = 1;
1185     return EOF;
1186     }
1187 #ifndef DISABLE_DKIM
1188   dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
1189 #endif
1190   ssl_xfer_buffer_hwm = inbytes;
1191   ssl_xfer_buffer_lwm = 0;
1192   }
1193
1194
1195 /* Something in the buffer; return next uschar */
1196
1197 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
1198 }
1199
1200
1201
1202 /*************************************************
1203 *          Read bytes from TLS channel           *
1204 *************************************************/
1205
1206 /*
1207 Arguments:
1208   buff      buffer of data
1209   len       size of buffer
1210
1211 Returns:    the number of bytes read
1212             -1 after a failed read
1213 */
1214
1215 int
1216 tls_read(uschar *buff, size_t len)
1217 {
1218 int inbytes;
1219
1220 DEBUG(D_tls) debug_printf("Calling gnutls_record_recv(%lx, %lx, %u)\n",
1221   (long) tls_session, (long) buff, len);
1222
1223 inbytes = gnutls_record_recv(tls_session, CS buff, len);
1224 if (inbytes > 0) return inbytes;
1225 if (inbytes == 0)
1226   {
1227   DEBUG(D_tls) debug_printf("Got TLS_EOF\n");
1228   }
1229 else record_io_error(inbytes, US"recv", NULL);
1230
1231 return -1;
1232 }
1233
1234
1235
1236 /*************************************************
1237 *         Write bytes down TLS channel           *
1238 *************************************************/
1239
1240 /*
1241 Arguments:
1242   buff      buffer of data
1243   len       number of bytes
1244
1245 Returns:    the number of bytes after a successful write,
1246             -1 after a failed write
1247 */
1248
1249 int
1250 tls_write(const uschar *buff, size_t len)
1251 {
1252 int outbytes;
1253 int left = len;
1254
1255 DEBUG(D_tls) debug_printf("tls_do_write(%lx, %d)\n", (long) buff, left);
1256 while (left > 0)
1257   {
1258   DEBUG(D_tls) debug_printf("gnutls_record_send(SSL, %lx, %d)\n", (long)buff,
1259     left);
1260   outbytes = gnutls_record_send(tls_session, CS buff, left);
1261
1262   DEBUG(D_tls) debug_printf("outbytes=%d\n", outbytes);
1263   if (outbytes < 0)
1264     {
1265     record_io_error(outbytes, US"send", NULL);
1266     return -1;
1267     }
1268   if (outbytes == 0)
1269     {
1270     record_io_error(0, US"send", US"TLS channel closed on write");
1271     return -1;
1272     }
1273
1274   left -= outbytes;
1275   buff += outbytes;
1276   }
1277
1278 return len;
1279 }
1280
1281
1282
1283 /*************************************************
1284 *         Close down a TLS session               *
1285 *************************************************/
1286
1287 /* This is also called from within a delivery subprocess forked from the
1288 daemon, to shut down the TLS library, without actually doing a shutdown (which
1289 would tamper with the TLS session in the parent process).
1290
1291 Arguments:   TRUE if gnutls_bye is to be called
1292 Returns:     nothing
1293 */
1294
1295 void
1296 tls_close(BOOL shutdown)
1297 {
1298 if (tls_active < 0) return;  /* TLS was not active */
1299
1300 if (shutdown)
1301   {
1302   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS\n");
1303   gnutls_bye(tls_session, GNUTLS_SHUT_WR);
1304   }
1305
1306 gnutls_deinit(tls_session);
1307 tls_session = NULL;
1308 gnutls_global_deinit();
1309
1310 tls_active = -1;
1311 }
1312
1313
1314
1315
1316 /*************************************************
1317 *         Report the library versions.           *
1318 *************************************************/
1319
1320 /* See a description in tls-openssl.c for an explanation of why this exists.
1321
1322 Arguments:   a FILE* to print the results to
1323 Returns:     nothing
1324 */
1325
1326 void
1327 tls_version_report(FILE *f)
1328 {
1329 fprintf(f, "Library version: GnuTLS: Compile: %s\n"
1330            "                         Runtime: %s\n",
1331            LIBGNUTLS_VERSION,
1332            gnutls_check_version(NULL));
1333 }
1334
1335 /* End of tls-gnu.c */