1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Copyright (c) Phil Pennock 2012 */
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.
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
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).
24 Keeping client and server variables more split than before and is currently
25 the norm, in anticipation of TLS in ACL callouts.
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.
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).
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>
46 gnutls_global_set_audit_log_function()
49 gnutls_certificate_verify_peers2(): is new, drop the 2 for old version
52 /* Local static variables for GnuTLS */
54 /* Values for verify_requirement */
56 enum peer_verify_requirement
{ VERIFY_NONE
, VERIFY_OPTIONAL
, VERIFY_REQUIRED
};
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.
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.
66 Not handled here: globals tls_active, tls_bits, tls_cipher, tls_peerdn,
67 tls_certificate_verified, tls_channelbinding_b64, tls_sni.
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
;
77 BOOL peer_cert_verified
;
78 BOOL trigger_sni_changes
;
79 const struct host_item
*host
;
83 const uschar
*tls_certificate
;
84 const uschar
*tls_privatekey
;
85 const uschar
*tls_sni
; /* client send only, not received */
86 const uschar
*tls_verify_certificates
;
87 const uschar
*tls_crl
;
88 const uschar
*tls_require_ciphers
;
89 uschar
*exp_tls_certificate
;
90 uschar
*exp_tls_privatekey
;
92 uschar
*exp_tls_verify_certificates
;
94 uschar
*exp_tls_require_ciphers
;
102 uschar cipherbuf
[256];
103 } exim_gnutls_state_st
;
105 static const exim_gnutls_state_st exim_gnutls_state_init
= {
106 NULL
, NULL
, NULL
, VERIFY_NONE
, -1, -1, FALSE
, FALSE
,
108 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
109 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
,
114 /* Not only do we have our own APIs which don't pass around state, assuming
115 it's held in globals, GnuTLS doesn't appear to let us register callback data
116 for callbacks, or as part of the session, so we have to keep a "this is the
117 context we're currently dealing with" pointer and rely upon being
118 single-threaded to keep from processing data on an inbound TLS connection while
119 talking to another TLS connection for an outbound check. This does mean that
120 there's no way for heart-beats to be responded to, for the duration of the
121 second connection. */
123 static exim_gnutls_state_st state_server
, state_client
;
124 static exim_gnutls_state_st
*current_global_tls_state
;
126 /* dh_params are initialised once within the lifetime of a process using TLS;
127 if we used TLS in a long-lived daemon, we'd have to reconsider this. But we
128 don't want to repeat this. */
130 static gnutls_dh_params_t dh_server_params
= NULL
;
132 /* No idea how this value was chosen; preserving it. Default is 3600. */
134 static const int ssl_session_timeout
= 200;
136 static const char * const exim_default_gnutls_priority
= "NORMAL";
138 /* Guard library core initialisation */
140 static BOOL exim_gnutls_base_init_done
= FALSE
;
143 /* ------------------------------------------------------------------------ */
146 #define MAX_HOST_LEN 255
148 /* Set this to control gnutls_global_set_log_level(); values 0 to 9 will setup
149 the library logging; a value less than 0 disables the calls to set up logging
151 #define EXIM_GNUTLS_LIBRARY_LOG_LEVEL -1
153 #define EXIM_CLIENT_DH_MIN_BITS 1024
155 /* With GnuTLS 2.12.x+ we have gnutls_sec_param_to_pk_bits() with which we
156 can ask for a bit-strength. Without that, we stick to the constant we had
158 #define EXIM_SERVER_DH_BITS_PRE2_12 1024
160 #define exim_gnutls_err_check(Label) do { \
161 if (rc != GNUTLS_E_SUCCESS) { return tls_error((Label), gnutls_strerror(rc), host); } } while (0)
163 #define expand_check_tlsvar(Varname) expand_check(state->Varname, US #Varname, &state->exp_##Varname)
165 #if GNUTLS_VERSION_NUMBER >= 0x020c00
166 #define HAVE_GNUTLS_SESSION_CHANNEL_BINDING
167 #define HAVE_GNUTLS_SEC_PARAM_CONSTANTS
168 #define HAVE_GNUTLS_RND
174 /* ------------------------------------------------------------------------ */
175 /* Callback declarations */
177 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
178 static void exim_gnutls_logger_cb(int level
, const char *message
);
181 static int exim_sni_handling_cb(gnutls_session_t session
);
186 /* ------------------------------------------------------------------------ */
187 /* Static functions */
189 /*************************************************
191 *************************************************/
193 /* Called from lots of places when errors occur before actually starting to do
194 the TLS handshake, that is, while the session is still in clear. Always returns
195 DEFER for a server and FAIL for a client so that most calls can use "return
196 tls_error(...)" to do this processing and then give an appropriate return. A
197 single function is used for both server and client, because it is called from
198 some shared functions.
201 prefix text to include in the logged error
202 msg additional error string (may be NULL)
203 usually obtained from gnutls_strerror()
204 host NULL if setting up a server;
205 the connected host if setting up a client
207 Returns: OK/DEFER/FAIL
211 tls_error(const uschar
*prefix
, const char *msg
, const host_item
*host
)
215 log_write(0, LOG_MAIN
, "TLS error on connection to %s [%s] (%s)%s%s",
216 host
->name
, host
->address
, prefix
, msg
? ": " : "", msg
? msg
: "");
221 uschar
*conn_info
= smtp_get_connection_info();
222 if (Ustrncmp(conn_info
, US
"SMTP ", 5) == 0)
224 log_write(0, LOG_MAIN
, "TLS error on %s (%s)%s%s",
225 conn_info
, prefix
, msg
? ": " : "", msg
? msg
: "");
233 /*************************************************
234 * Deal with logging errors during I/O *
235 *************************************************/
237 /* We have to get the identity of the peer from saved data.
240 state the current GnuTLS exim state container
241 rc the GnuTLS error code, or 0 if it's a local error
242 when text identifying read or write
243 text local error text when ec is 0
249 record_io_error(exim_gnutls_state_st
*state
, int rc
, uschar
*when
, uschar
*text
)
253 if (rc
== GNUTLS_E_FATAL_ALERT_RECEIVED
)
254 msg
= CS
string_sprintf("%s: %s", US
gnutls_strerror(rc
),
255 US
gnutls_alert_get_name(gnutls_alert_get(state
->session
)));
257 msg
= gnutls_strerror(rc
);
259 tls_error(when
, msg
, state
->host
);
265 /*************************************************
266 * Set various Exim expansion vars *
267 *************************************************/
269 /* We set various Exim global variables from the state, once a session has
270 been established. With TLS callouts, may need to change this to stack
271 variables, or just re-call it with the server state after client callout
274 Make sure anything set here is inset in tls_getc().
278 tls_bits strength indicator
279 tls_certificate_verified bool indicator
280 tls_channelbinding_b64 for some SASL mechanisms
283 tls_sni a (UTF-8) string
285 current_global_tls_state for API limitations
288 state the relevant exim_gnutls_state_st *
292 extract_exim_vars_from_tls_state(exim_gnutls_state_st
*state
)
294 gnutls_protocol_t protocol
;
295 gnutls_cipher_algorithm_t cipher
;
296 gnutls_kx_algorithm_t kx
;
297 gnutls_mac_algorithm_t mac
;
299 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
302 gnutls_datum_t channel
;
305 current_global_tls_state
= state
;
307 tls_active
= state
->fd_out
;
309 cipher
= gnutls_cipher_get(state
->session
);
310 /* returns size in "bytes" */
311 tls_bits
= gnutls_cipher_get_key_size(cipher
) * 8;
313 if (!*state
->cipherbuf
)
315 protocol
= gnutls_protocol_get_version(state
->session
);
316 mac
= gnutls_mac_get(state
->session
);
317 kx
= gnutls_kx_get(state
->session
);
319 string_format(state
->cipherbuf
, sizeof(state
->cipherbuf
),
321 gnutls_protocol_get_name(protocol
),
322 gnutls_cipher_suite_get_name(kx
, cipher
, mac
),
325 /* I don't see a way that spaces could occur, in the current GnuTLS
326 code base, but it was a concern in the old code and perhaps older GnuTLS
327 releases did return "TLS 1.0"; play it safe, just in case. */
328 for (p
= state
->cipherbuf
; *p
!= '\0'; ++p
)
332 tls_cipher
= state
->cipherbuf
;
334 DEBUG(D_tls
) debug_printf("cipher: %s\n", tls_cipher
);
336 tls_certificate_verified
= state
->peer_cert_verified
;
338 /* note that tls_channelbinding_b64 is not saved to the spool file, since it's
339 only available for use for authenticators while this TLS session is running. */
341 tls_channelbinding_b64
= NULL
;
342 #ifdef HAVE_GNUTLS_SESSION_CHANNEL_BINDING
345 rc
= gnutls_session_channel_binding(state
->session
, GNUTLS_CB_TLS_UNIQUE
, &channel
);
347 DEBUG(D_tls
) debug_printf("Channel binding error: %s\n", gnutls_strerror(rc
));
349 old_pool
= store_pool
;
350 store_pool
= POOL_PERM
;
351 tls_channelbinding_b64
= auth_b64encode(channel
.data
, (int)channel
.size
);
352 store_pool
= old_pool
;
353 DEBUG(D_tls
) debug_printf("Have channel bindings cached for possible auth usage.\n");
357 tls_peerdn
= state
->peerdn
;
359 tls_sni
= state
->received_sni
;
365 /*************************************************
366 * Setup up DH parameters *
367 *************************************************/
369 /* Generating the D-H parameters may take a long time. They only need to
370 be re-generated every so often, depending on security policy. What we do is to
371 keep these parameters in a file in the spool directory. If the file does not
372 exist, we generate them. This means that it is easy to cause a regeneration.
374 The new file is written as a temporary file and renamed, so that an incomplete
375 file is never present. If two processes both compute some new parameters, you
376 waste a bit of effort, but it doesn't seem worth messing around with locking to
380 host NULL for server, server for client (for error handling)
382 Returns: OK/DEFER/FAIL
389 unsigned int dh_bits
;
391 uschar filename
[PATH_MAX
];
393 host_item
*host
= NULL
; /* dummy for macros */
395 DEBUG(D_tls
) debug_printf("Initialising GnuTLS server params.\n");
397 rc
= gnutls_dh_params_init(&dh_server_params
);
398 exim_gnutls_err_check(US
"gnutls_dh_params_init");
400 #ifdef HAVE_GNUTLS_SEC_PARAM_CONSTANTS
401 /* If you change this constant, also change dh_param_fn_ext so that we can use a
402 different filename and ensure we have sufficient bits. */
403 dh_bits
= gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH
, GNUTLS_SEC_PARAM_NORMAL
);
405 return tls_error(US
"gnutls_sec_param_to_pk_bits() failed", NULL
, NULL
);
407 debug_printf("GnuTLS tells us that for D-H PK, NORMAL is %d bits.\n",
410 dh_bits
= EXIM_SERVER_DH_BITS_PRE2_12
;
412 debug_printf("GnuTLS lacks gnutls_sec_param_to_pk_bits(), using %d bits.\n",
416 if (!string_format(filename
, sizeof(filename
),
417 "%s/gnutls-params-%d", spool_directory
, dh_bits
))
418 return tls_error(US
"overlong filename", NULL
, NULL
);
420 /* Open the cache file for reading and if successful, read it and set up the
423 fd
= Uopen(filename
, O_RDONLY
, 0);
430 if (fstat(fd
, &statbuf
) < 0) /* EIO */
434 return tls_error(US
"TLS cache stat failed", strerror(saved_errno
), NULL
);
436 if (!S_ISREG(statbuf
.st_mode
))
439 return tls_error(US
"TLS cache not a file", NULL
, NULL
);
441 fp
= fdopen(fd
, "rb");
446 return tls_error(US
"fdopen(TLS cache stat fd) failed",
447 strerror(saved_errno
), NULL
);
450 m
.size
= statbuf
.st_size
;
451 m
.data
= malloc(m
.size
);
455 return tls_error(US
"malloc failed", strerror(errno
), NULL
);
457 sz
= fread(m
.data
, m
.size
, 1, fp
);
463 return tls_error(US
"fread failed", strerror(saved_errno
), NULL
);
467 rc
= gnutls_dh_params_import_pkcs3(dh_server_params
, &m
, GNUTLS_X509_FMT_PEM
);
469 exim_gnutls_err_check(US
"gnutls_dh_params_import_pkcs3");
470 DEBUG(D_tls
) debug_printf("read D-H parameters from file \"%s\"\n", filename
);
473 /* If the file does not exist, fall through to compute new data and cache it.
474 If there was any other opening error, it is serious. */
476 else if (errno
== ENOENT
)
480 debug_printf("D-H parameter cache file \"%s\" does not exist\n", filename
);
483 return tls_error(string_open_failed(errno
, "\"%s\" for reading", filename
),
486 /* If ret < 0, either the cache file does not exist, or the data it contains
487 is not useful. One particular case of this is when upgrading from an older
488 release of Exim in which the data was stored in a different format. We don't
489 try to be clever and support both formats; we just regenerate new data in this
496 if ((PATH_MAX
- Ustrlen(filename
)) < 10)
497 return tls_error(US
"Filename too long to generate replacement",
500 temp_fn
= string_copy(US
"%s.XXXXXXX");
501 fd
= mkstemp(CS temp_fn
); /* modifies temp_fn */
503 return tls_error(US
"Unable to open temp file", strerror(errno
), NULL
);
504 (void)fchown(fd
, exim_uid
, exim_gid
); /* Probably not necessary */
506 DEBUG(D_tls
) debug_printf("generating %d bits Diffie-Hellman key ...\n", dh_bits
);
507 rc
= gnutls_dh_params_generate2(dh_server_params
, dh_bits
);
508 exim_gnutls_err_check(US
"gnutls_dh_params_generate2");
510 /* gnutls_dh_params_export_pkcs3() will tell us the exact size, every time,
511 and I confirmed that a NULL call to get the size first is how the GnuTLS
512 sample apps handle this. */
516 rc
= gnutls_dh_params_export_pkcs3(dh_server_params
, GNUTLS_X509_FMT_PEM
,
518 if (rc
!= GNUTLS_E_SHORT_MEMORY_BUFFER
)
519 exim_gnutls_err_check(US
"gnutls_dh_params_export_pkcs3(NULL) sizing");
521 m
.data
= malloc(m
.size
);
523 return tls_error(US
"memory allocation failed", strerror(errno
), NULL
);
524 rc
= gnutls_dh_params_export_pkcs3(dh_server_params
, GNUTLS_X509_FMT_PEM
,
526 if (rc
!= GNUTLS_E_SUCCESS
)
529 exim_gnutls_err_check(US
"gnutls_dh_params_export_pkcs3() real");
532 sz
= write_to_fd_buf(fd
, m
.data
, (size_t) m
.size
);
536 return tls_error(US
"TLS cache write D-H params failed",
537 strerror(errno
), NULL
);
540 sz
= write_to_fd_buf(fd
, US
"\n", 1);
542 return tls_error(US
"TLS cache write D-H params final newline failed",
543 strerror(errno
), NULL
);
547 return tls_error(US
"TLS cache write close() failed",
548 strerror(errno
), NULL
);
550 if (Urename(temp_fn
, filename
) < 0)
551 return tls_error(string_sprintf("failed to rename \"%s\" as \"%s\"",
552 temp_fn
, filename
), strerror(errno
), NULL
);
554 DEBUG(D_tls
) debug_printf("wrote D-H parameters to file \"%s\"\n", filename
);
557 DEBUG(D_tls
) debug_printf("initialized server D-H parameters\n");
564 /*************************************************
565 * Variables re-expanded post-SNI *
566 *************************************************/
568 /* Called from both server and client code, via tls_init(), and also from
569 the SNI callback after receiving an SNI, if tls_certificate includes "tls_sni".
571 We can tell the two apart by state->received_sni being non-NULL in callback.
573 The callback should not call us unless state->trigger_sni_changes is true,
574 which we are responsible for setting on the first pass through.
577 state exim_gnutls_state_st *
579 Returns: OK/DEFER/FAIL
583 tls_expand_session_files(exim_gnutls_state_st
*state
)
587 const host_item
*host
= state
->host
; /* macro should be reconsidered? */
588 uschar
*saved_tls_certificate
= NULL
;
589 uschar
*saved_tls_privatekey
= NULL
;
590 uschar
*saved_tls_verify_certificates
= NULL
;
591 uschar
*saved_tls_crl
= NULL
;
594 /* We check for tls_sni *before* expansion. */
597 if (!state
->received_sni
)
599 if (Ustrstr(state
->tls_certificate
, US
"tls_sni"))
601 DEBUG(D_tls
) debug_printf("We will re-expand TLS session files if we receive SNI.\n");
602 state
->trigger_sni_changes
= TRUE
;
607 /* useful for debugging */
608 saved_tls_certificate
= state
->exp_tls_certificate
;
609 saved_tls_privatekey
= state
->exp_tls_privatekey
;
610 saved_tls_verify_certificates
= state
->exp_tls_verify_certificates
;
611 saved_tls_crl
= state
->exp_tls_crl
;
615 rc
= gnutls_certificate_allocate_credentials(&state
->x509_cred
);
616 exim_gnutls_err_check(US
"gnutls_certificate_allocate_credentials");
618 /* remember: expand_check_tlsvar() is expand_check() but fiddling with
619 state members, assuming consistent naming; and expand_check() returns
620 false if expansion failed, unless expansion was forced to fail. */
622 /* check if we at least have a certificate, before doing expensive
625 if (!expand_check_tlsvar(tls_certificate
))
628 /* certificate is mandatory in server, optional in client */
630 if ((state
->exp_tls_certificate
== NULL
) ||
631 (*state
->exp_tls_certificate
== '\0'))
633 if (state
->host
== NULL
)
634 return tls_error(US
"no TLS server certificate is specified", NULL
, NULL
);
636 DEBUG(D_tls
) debug_printf("TLS: no client certificate specified; okay\n");
639 if (state
->tls_privatekey
&& !expand_check_tlsvar(tls_privatekey
))
642 /* tls_privatekey is optional, defaulting to same file as certificate */
644 if (state
->tls_privatekey
== NULL
|| *state
->tls_privatekey
== '\0')
646 state
->tls_privatekey
= state
->tls_certificate
;
647 state
->exp_tls_privatekey
= state
->exp_tls_certificate
;
651 if (state
->exp_tls_certificate
&& *state
->exp_tls_certificate
)
653 DEBUG(D_tls
) debug_printf("certificate file = %s\nkey file = %s\n",
654 state
->exp_tls_certificate
, state
->exp_tls_privatekey
);
656 if (state
->received_sni
)
658 if ((Ustrcmp(state
->exp_tls_certificate
, saved_tls_certificate
) == 0) &&
659 (Ustrcmp(state
->exp_tls_privatekey
, saved_tls_privatekey
) == 0))
661 DEBUG(D_tls
) debug_printf("TLS SNI: cert and key unchanged\n");
665 DEBUG(D_tls
) debug_printf("TLS SNI: have a changed cert/key pair.\n");
669 rc
= gnutls_certificate_set_x509_key_file(state
->x509_cred
,
670 CS state
->exp_tls_certificate
, CS state
->exp_tls_privatekey
,
671 GNUTLS_X509_FMT_PEM
);
672 exim_gnutls_err_check(
673 string_sprintf("cert/key setup: cert=%s key=%s",
674 state
->exp_tls_certificate
, state
->exp_tls_privatekey
));
675 DEBUG(D_tls
) debug_printf("TLS: cert/key registered\n");
676 } /* tls_certificate */
678 /* Set the trusted CAs file if one is provided, and then add the CRL if one is
679 provided. Experiment shows that, if the certificate file is empty, an unhelpful
680 error message is provided. However, if we just refrain from setting anything up
681 in that case, certificate verification fails, which seems to be the correct
684 if (state
->tls_verify_certificates
&& *state
->tls_verify_certificates
)
686 if (!expand_check_tlsvar(tls_verify_certificates
))
688 if (state
->tls_crl
&& *state
->tls_crl
)
689 if (!expand_check_tlsvar(tls_crl
))
692 if (!(state
->exp_tls_verify_certificates
&&
693 *state
->exp_tls_verify_certificates
))
696 debug_printf("TLS: tls_verify_certificates expanded empty, ignoring\n");
697 /* With no tls_verify_certificates, we ignore tls_crl too */
704 debug_printf("TLS: tls_verify_certificates not set or empty, ignoring\n");
708 if (Ustat(state
->exp_tls_verify_certificates
, &statbuf
) < 0)
710 log_write(0, LOG_MAIN
|LOG_PANIC
, "could not stat %s "
711 "(tls_verify_certificates): %s", state
->exp_tls_verify_certificates
,
716 if (!S_ISREG(statbuf
.st_mode
))
719 debug_printf("verify certificates path is not a file: \"%s\"\n%s\n",
720 state
->exp_tls_verify_certificates
,
721 S_ISDIR(statbuf
.st_mode
)
722 ? " it's a directory, that's OpenSSL, this is GnuTLS"
723 : " (not a directory either)");
724 log_write(0, LOG_MAIN
|LOG_PANIC
,
725 "tls_verify_certificates \"%s\" is not a file",
726 state
->exp_tls_verify_certificates
);
730 DEBUG(D_tls
) debug_printf("verify certificates = %s size=" OFF_T_FMT
"\n",
731 state
->exp_tls_verify_certificates
, statbuf
.st_size
);
733 if (statbuf
.st_size
== 0)
736 debug_printf("cert file empty, no certs, no verification, ignoring any CRL\n");
740 cert_count
= gnutls_certificate_set_x509_trust_file(state
->x509_cred
,
741 CS state
->exp_tls_verify_certificates
, GNUTLS_X509_FMT_PEM
);
745 exim_gnutls_err_check(US
"gnutls_certificate_set_x509_trust_file");
747 DEBUG(D_tls
) debug_printf("Added %d certificate authorities.\n", cert_count
);
749 if (state
->tls_crl
&& *state
->tls_crl
)
751 if (state
->exp_tls_crl
&& *state
->exp_tls_crl
)
753 DEBUG(D_tls
) debug_printf("loading CRL file = %s\n", state
->exp_tls_crl
);
754 rc
= gnutls_certificate_set_x509_crl_file(state
->x509_cred
,
755 CS state
->exp_tls_crl
, GNUTLS_X509_FMT_PEM
);
756 exim_gnutls_err_check(US
"gnutls_certificate_set_x509_crl_file");
766 /*************************************************
767 * Set X.509 state variables *
768 *************************************************/
770 /* In GnuTLS, the registered cert/key are not replaced by a later
771 set of a cert/key, so for SNI support we need a whole new x509_cred
772 structure. Which means various other non-re-expanded pieces of state
773 need to be re-set in the new struct, so the setting logic is pulled
777 state exim_gnutls_state_st *
779 Returns: OK/DEFER/FAIL
783 tls_set_remaining_x509(exim_gnutls_state_st
*state
)
786 const host_item
*host
= state
->host
; /* macro should be reconsidered? */
788 /* Create D-H parameters, or read them from the cache file. This function does
789 its own SMTP error messaging. This only happens for the server, TLS D-H ignores
790 client-side params. */
794 if (!dh_server_params
)
796 rc
= init_server_dh();
797 if (rc
!= OK
) return rc
;
799 gnutls_certificate_set_dh_params(state
->x509_cred
, dh_server_params
);
802 /* Link the credentials to the session. */
804 rc
= gnutls_credentials_set(state
->session
, GNUTLS_CRD_CERTIFICATE
, state
->x509_cred
);
805 exim_gnutls_err_check(US
"gnutls_credentials_set");
810 /*************************************************
811 * Initialize for GnuTLS *
812 *************************************************/
814 /* Called from both server and client code. In the case of a server, errors
815 before actual TLS negotiation return DEFER.
818 host connected host, if client; NULL if server
819 certificate certificate file
820 privatekey private key file
821 sni TLS SNI to send, sometimes when client; else NULL
824 require_ciphers tls_require_ciphers setting
826 Returns: OK/DEFER/FAIL
831 const host_item
*host
,
832 const uschar
*certificate
,
833 const uschar
*privatekey
,
837 const uschar
*require_ciphers
,
838 exim_gnutls_state_st
**caller_state
)
840 exim_gnutls_state_st
*state
;
845 BOOL want_default_priorities
;
847 if (!exim_gnutls_base_init_done
)
849 DEBUG(D_tls
) debug_printf("GnuTLS global init required.\n");
851 rc
= gnutls_global_init();
852 exim_gnutls_err_check(US
"gnutls_global_init");
854 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
857 gnutls_global_set_log_function(exim_gnutls_logger_cb
);
858 /* arbitrarily chosen level; bump upto 9 for more */
859 gnutls_global_set_log_level(EXIM_GNUTLS_LIBRARY_LOG_LEVEL
);
863 exim_gnutls_base_init_done
= TRUE
;
868 state
= &state_client
;
869 memcpy(state
, &exim_gnutls_state_init
, sizeof(exim_gnutls_state_init
));
870 DEBUG(D_tls
) debug_printf("initialising GnuTLS client session\n");
871 rc
= gnutls_init(&state
->session
, GNUTLS_CLIENT
);
875 state
= &state_server
;
876 memcpy(state
, &exim_gnutls_state_init
, sizeof(exim_gnutls_state_init
));
877 DEBUG(D_tls
) debug_printf("initialising GnuTLS server session\n");
878 rc
= gnutls_init(&state
->session
, GNUTLS_SERVER
);
880 exim_gnutls_err_check(US
"gnutls_init");
884 state
->tls_certificate
= certificate
;
885 state
->tls_privatekey
= privatekey
;
886 state
->tls_sni
= sni
;
887 state
->tls_verify_certificates
= cas
;
888 state
->tls_crl
= crl
;
890 /* This handles the variables that might get re-expanded after TLS SNI;
891 that's tls_certificate, tls_privatekey, tls_verify_certificates, tls_crl */
894 debug_printf("Expanding various TLS configuration options for session credentials.\n");
895 rc
= tls_expand_session_files(state
);
896 if (rc
!= OK
) return rc
;
898 /* These are all other parts of the x509_cred handling, since SNI in GnuTLS
899 requires a new structure afterwards. */
901 rc
= tls_set_remaining_x509(state
);
902 if (rc
!= OK
) return rc
;
904 /* set SNI in client, only */
907 if (!expand_check_tlsvar(tls_sni
))
909 if (state
->exp_tls_sni
&& *state
->exp_tls_sni
)
912 debug_printf("Setting TLS client SNI to \"%s\"\n", state
->exp_tls_sni
);
913 sz
= Ustrlen(state
->exp_tls_sni
);
914 rc
= gnutls_server_name_set(state
->session
,
915 GNUTLS_NAME_DNS
, state
->exp_tls_sni
, sz
);
916 exim_gnutls_err_check(US
"gnutls_server_name_set");
919 else if (state
->tls_sni
)
920 DEBUG(D_tls
) debug_printf("*** PROBABLY A BUG *** " \
921 "have an SNI set for a client [%s]\n", state
->tls_sni
);
923 /* This is the priority string support,
924 http://www.gnu.org/software/gnutls/manual/html_node/Priority-Strings.html
925 and replaces gnutls_require_kx, gnutls_require_mac & gnutls_require_protocols.
926 This was backwards incompatible, but means Exim no longer needs to track
927 all algorithms and provide string forms for them. */
929 want_default_priorities
= TRUE
;
931 if (state
->tls_require_ciphers
&& *state
->tls_require_ciphers
)
933 if (!expand_check_tlsvar(tls_require_ciphers
))
935 if (state
->exp_tls_require_ciphers
&& *state
->exp_tls_require_ciphers
)
937 DEBUG(D_tls
) debug_printf("GnuTLS session cipher/priority \"%s\"\n",
938 state
->exp_tls_require_ciphers
);
940 rc
= gnutls_priority_init(&state
->priority_cache
,
941 CS state
->exp_tls_require_ciphers
, &errpos
);
942 want_default_priorities
= FALSE
;
943 p
= state
->exp_tls_require_ciphers
;
946 if (want_default_priorities
)
949 debug_printf("GnuTLS using default session cipher/priority \"%s\"\n",
950 exim_default_gnutls_priority
);
951 rc
= gnutls_priority_init(&state
->priority_cache
,
952 exim_default_gnutls_priority
, &errpos
);
953 p
= US exim_default_gnutls_priority
;
956 exim_gnutls_err_check(string_sprintf(
957 "gnutls_priority_init(%s) failed at offset %ld, \"%.6s..\"",
958 p
, errpos
- CS p
, errpos
));
960 rc
= gnutls_priority_set(state
->session
, state
->priority_cache
);
961 exim_gnutls_err_check(US
"gnutls_priority_set");
963 gnutls_db_set_cache_expiration(state
->session
, ssl_session_timeout
);
965 /* Reduce security in favour of increased compatibility, if the admin
966 decides to make that trade-off. */
967 if (gnutls_compat_mode
)
969 #if LIBGNUTLS_VERSION_NUMBER >= 0x020104
970 DEBUG(D_tls
) debug_printf("lowering GnuTLS security, compatibility mode\n");
971 gnutls_session_enable_compatibility_mode(state
->session
);
973 DEBUG(D_tls
) debug_printf("Unable to set gnutls_compat_mode - GnuTLS version too old\n");
977 *caller_state
= state
;
978 /* needs to happen before callbacks during handshake */
979 current_global_tls_state
= state
;
986 /*************************************************
987 * Extract peer information *
988 *************************************************/
990 /* Called from both server and client code.
991 Only this is allowed to set state->peerdn and we use that to detect double-calls.
994 state exim_gnutls_state_st *
996 Returns: OK/DEFER/FAIL
1000 peer_status(exim_gnutls_state_st
*state
)
1002 const gnutls_datum
*cert_list
;
1004 unsigned int cert_list_size
= 0;
1005 gnutls_certificate_type_t ct
;
1006 gnutls_x509_crt_t crt
;
1013 state
->peerdn
= US
"unknown";
1015 cert_list
= gnutls_certificate_get_peers(state
->session
, &cert_list_size
);
1017 if (cert_list
== NULL
|| cert_list_size
== 0)
1019 state
->peerdn
= US
"unknown (no certificate)";
1020 DEBUG(D_tls
) debug_printf("TLS: no certificate from peer (%p & %d)\n",
1021 cert_list
, cert_list_size
);
1022 if (state
->verify_requirement
== VERIFY_REQUIRED
)
1023 return tls_error(US
"certificate verification failed",
1024 "no certificate received from peer", state
->host
);
1028 ct
= gnutls_certificate_type_get(state
->session
);
1029 if (ct
!= GNUTLS_CRT_X509
)
1031 const char *ctn
= gnutls_certificate_type_get_name(ct
);
1032 state
->peerdn
= string_sprintf("unknown (type %s)", ctn
);
1034 debug_printf("TLS: peer cert not X.509 but instead \"%s\"\n", ctn
);
1035 if (state
->verify_requirement
== VERIFY_REQUIRED
)
1036 return tls_error(US
"certificate verification not possible, unhandled type",
1041 #define exim_gnutls_peer_err(Label) do { \
1042 if (rc != GNUTLS_E_SUCCESS) { \
1043 DEBUG(D_tls) debug_printf("TLS: peer cert problem: %s: %s\n", (Label), gnutls_strerror(rc)); \
1044 if (state->verify_requirement == VERIFY_REQUIRED) { return tls_error((Label), gnutls_strerror(rc), state->host); } \
1045 return OK; } } while (0)
1047 rc
= gnutls_x509_crt_init(&crt
);
1048 exim_gnutls_peer_err(US
"gnutls_x509_crt_init (crt)");
1050 rc
= gnutls_x509_crt_import(crt
, &cert_list
[0], GNUTLS_X509_FMT_DER
);
1051 exim_gnutls_peer_err(US
"failed to import certificate [gnutls_x509_crt_import(cert 0)]");
1053 rc
= gnutls_x509_crt_get_dn(crt
, NULL
, &sz
);
1054 if (rc
!= GNUTLS_E_SHORT_MEMORY_BUFFER
)
1056 exim_gnutls_peer_err(US
"getting size for cert DN failed");
1057 return FAIL
; /* should not happen */
1059 dn_buf
= store_get_perm(sz
);
1060 rc
= gnutls_x509_crt_get_dn(crt
, CS dn_buf
, &sz
);
1061 exim_gnutls_peer_err(US
"failed to extract certificate DN [gnutls_x509_crt_get_dn(cert 0)]");
1062 state
->peerdn
= dn_buf
;
1065 #undef exim_gnutls_peer_err
1071 /*************************************************
1072 * Verify peer certificate *
1073 *************************************************/
1075 /* Called from both server and client code.
1076 *Should* be using a callback registered with
1077 gnutls_certificate_set_verify_function() to fail the handshake if we dislike
1078 the peer information, but that's too new for some OSes.
1081 state exim_gnutls_state_st *
1082 error where to put an error message
1085 FALSE if the session should be rejected
1086 TRUE if the cert is okay or we just don't care
1090 verify_certificate(exim_gnutls_state_st
*state
, const char **error
)
1093 unsigned int verify
;
1097 rc
= peer_status(state
);
1100 verify
= GNUTLS_CERT_INVALID
;
1101 *error
= "not supplied";
1105 rc
= gnutls_certificate_verify_peers2(state
->session
, &verify
);
1108 /* Handle the result of verification. INVALID seems to be set as well
1109 as REVOKED, but leave the test for both. */
1111 if ((rc
< 0) || (verify
& (GNUTLS_CERT_INVALID
|GNUTLS_CERT_REVOKED
)) != 0)
1113 state
->peer_cert_verified
= FALSE
;
1115 *error
= ((verify
& GNUTLS_CERT_REVOKED
) != 0) ? "revoked" : "invalid";
1118 debug_printf("TLS certificate verification failed (%s): peerdn=%s\n",
1119 *error
, state
->peerdn
);
1121 if (state
->verify_requirement
== VERIFY_REQUIRED
)
1123 gnutls_alert_send(state
->session
, GNUTLS_AL_FATAL
, GNUTLS_A_BAD_CERTIFICATE
);
1127 debug_printf("TLS verify failure overriden (host in tls_try_verify_hosts)\n");
1131 state
->peer_cert_verified
= TRUE
;
1132 DEBUG(D_tls
) debug_printf("TLS certificate verified: peerdn=%s\n", state
->peerdn
);
1135 tls_peerdn
= state
->peerdn
;
1143 /* ------------------------------------------------------------------------ */
1146 /* Logging function which can be registered with
1147 * gnutls_global_set_log_function()
1148 * gnutls_global_set_log_level() 0..9
1150 #if EXIM_GNUTLS_LIBRARY_LOG_LEVEL >= 0
1152 exim_gnutls_logger_cb(int level
, const char *message
)
1154 DEBUG(D_tls
) debug_printf("GnuTLS<%d>: %s\n", level
, message
);
1159 /* Called after client hello, should handle SNI work.
1160 This will always set tls_sni (state->received_sni) if available,
1161 and may trigger presenting different certificates,
1162 if state->trigger_sni_changes is TRUE.
1164 Should be registered with
1165 gnutls_handshake_set_post_client_hello_function()
1167 "This callback must return 0 on success or a gnutls error code to terminate the
1170 For inability to get SNI information, we return 0.
1171 We only return non-zero if re-setup failed.
1175 exim_sni_handling_cb(gnutls_session_t session
)
1177 char sni_name
[MAX_HOST_LEN
];
1178 size_t data_len
= MAX_HOST_LEN
;
1179 exim_gnutls_state_st
*state
= current_global_tls_state
;
1180 unsigned int sni_type
;
1183 rc
= gnutls_server_name_get(session
, sni_name
, &data_len
, &sni_type
, 0);
1184 if (rc
!= GNUTLS_E_SUCCESS
)
1187 if (rc
== GNUTLS_E_REQUESTED_DATA_NOT_AVAILABLE
)
1188 debug_printf("TLS: no SNI presented in handshake.\n");
1190 debug_printf("TLS failure: gnutls_server_name_get(): %s [%d]\n",
1191 gnutls_strerror(rc
), rc
);
1196 if (sni_type
!= GNUTLS_NAME_DNS
)
1198 DEBUG(D_tls
) debug_printf("TLS: ignoring SNI of unhandled type %u\n", sni_type
);
1202 /* We now have a UTF-8 string in sni_name */
1203 old_pool
= store_pool
;
1204 store_pool
= POOL_PERM
;
1205 state
->received_sni
= string_copyn(US sni_name
, data_len
);
1206 store_pool
= old_pool
;
1208 /* We set this one now so that variable expansions below will work */
1209 tls_sni
= state
->received_sni
;
1211 DEBUG(D_tls
) debug_printf("Received TLS SNI \"%s\"%s\n", sni_name
,
1212 state
->trigger_sni_changes
? "" : " (unused for certificate selection)");
1214 if (!state
->trigger_sni_changes
)
1217 rc
= tls_expand_session_files(state
);
1220 /* If the setup of certs/etc failed before handshake, TLS would not have
1221 been offered. The best we can do now is abort. */
1222 return GNUTLS_E_APPLICATION_ERROR_MIN
;
1225 rc
= tls_set_remaining_x509(state
);
1226 if (rc
!= OK
) return GNUTLS_E_APPLICATION_ERROR_MIN
;
1234 /* ------------------------------------------------------------------------ */
1235 /* Exported functions */
1240 /*************************************************
1241 * Start a TLS session in a server *
1242 *************************************************/
1244 /* This is called when Exim is running as a server, after having received
1245 the STARTTLS command. It must respond to that command, and then negotiate
1249 require_ciphers list of allowed ciphers or NULL
1251 Returns: OK on success
1252 DEFER for errors before the start of the negotiation
1253 FAIL for errors during the negotation; the server can't
1258 tls_server_start(const uschar
*require_ciphers
)
1262 exim_gnutls_state_st
*state
= NULL
;
1264 /* Check for previous activation */
1265 /* nb: this will not be TLS callout safe, needs reworking as part of that. */
1267 if (tls_active
>= 0)
1269 tls_error(US
"STARTTLS received after TLS started", "", NULL
);
1270 smtp_printf("554 Already in TLS\r\n");
1274 /* Initialize the library. If it fails, it will already have logged the error
1275 and sent an SMTP response. */
1277 DEBUG(D_tls
) debug_printf("initialising GnuTLS as a server\n");
1279 rc
= tls_init(NULL
, tls_certificate
, tls_privatekey
,
1280 NULL
, tls_verify_certificates
, tls_crl
,
1281 require_ciphers
, &state
);
1282 if (rc
!= OK
) return rc
;
1284 /* If this is a host for which certificate verification is mandatory or
1285 optional, set up appropriately. */
1287 if (verify_check_host(&tls_verify_hosts
) == OK
)
1289 DEBUG(D_tls
) debug_printf("TLS: a client certificate will be required.\n");
1290 state
->verify_requirement
= VERIFY_REQUIRED
;
1291 gnutls_certificate_server_set_request(state
->session
, GNUTLS_CERT_REQUIRE
);
1293 else if (verify_check_host(&tls_try_verify_hosts
) == OK
)
1295 DEBUG(D_tls
) debug_printf("TLS: a client certificate will be requested but not required.\n");
1296 state
->verify_requirement
= VERIFY_OPTIONAL
;
1297 gnutls_certificate_server_set_request(state
->session
, GNUTLS_CERT_REQUEST
);
1301 DEBUG(D_tls
) debug_printf("TLS: a client certificate will not be requested.\n");
1302 state
->verify_requirement
= VERIFY_NONE
;
1303 gnutls_certificate_server_set_request(state
->session
, GNUTLS_CERT_IGNORE
);
1306 /* Register SNI handling; always, even if not in tls_certificate, so that the
1307 expansion variable $tls_sni is always available. */
1309 gnutls_handshake_set_post_client_hello_function(state
->session
,
1310 exim_sni_handling_cb
);
1312 /* Set context and tell client to go ahead, except in the case of TLS startup
1313 on connection, where outputting anything now upsets the clients and tends to
1314 make them disconnect. We need to have an explicit fflush() here, to force out
1315 the response. Other smtp_printf() calls do not need it, because in non-TLS
1316 mode, the fflush() happens when smtp_getc() is called. */
1318 if (!tls_on_connect
)
1320 smtp_printf("220 TLS go ahead\r\n");
1324 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1325 that the GnuTLS library doesn't. */
1327 gnutls_transport_set_ptr2(state
->session
,
1328 (gnutls_transport_ptr
)fileno(smtp_in
),
1329 (gnutls_transport_ptr
)fileno(smtp_out
));
1330 state
->fd_in
= fileno(smtp_in
);
1331 state
->fd_out
= fileno(smtp_out
);
1333 sigalrm_seen
= FALSE
;
1334 if (smtp_receive_timeout
> 0) alarm(smtp_receive_timeout
);
1337 rc
= gnutls_handshake(state
->session
);
1338 } while ((rc
== GNUTLS_E_AGAIN
) || (rc
== GNUTLS_E_INTERRUPTED
));
1341 if (rc
!= GNUTLS_E_SUCCESS
)
1343 tls_error(US
"gnutls_handshake",
1344 sigalrm_seen
? "timed out" : gnutls_strerror(rc
), NULL
);
1345 /* It seems that, except in the case of a timeout, we have to close the
1346 connection right here; otherwise if the other end is running OpenSSL it hangs
1347 until the server times out. */
1351 (void)fclose(smtp_out
);
1352 (void)fclose(smtp_in
);
1358 DEBUG(D_tls
) debug_printf("gnutls_handshake was successful\n");
1360 /* Verify after the fact */
1362 if (state
->verify_requirement
!= VERIFY_NONE
)
1364 if (!verify_certificate(state
, &error
))
1366 if (state
->verify_requirement
== VERIFY_OPTIONAL
)
1369 debug_printf("TLS: continuing on only because verification was optional, after: %s\n",
1374 tls_error(US
"certificate verification failed", error
, NULL
);
1380 /* Figure out peer DN, and if authenticated, etc. */
1382 rc
= peer_status(state
);
1383 if (rc
!= OK
) return rc
;
1385 /* Sets various Exim expansion variables; always safe within server */
1387 extract_exim_vars_from_tls_state(state
);
1389 /* TLS has been set up. Adjust the input functions to read via TLS,
1390 and initialize appropriately. */
1392 state
->xfer_buffer
= store_malloc(ssl_xfer_buffer_size
);
1394 receive_getc
= tls_getc
;
1395 receive_ungetc
= tls_ungetc
;
1396 receive_feof
= tls_feof
;
1397 receive_ferror
= tls_ferror
;
1398 receive_smtp_buffered
= tls_smtp_buffered
;
1406 /*************************************************
1407 * Start a TLS session in a client *
1408 *************************************************/
1410 /* Called from the smtp transport after STARTTLS has been accepted.
1413 fd the fd of the connection
1414 host connected host (for messages)
1415 addr the first address (not used)
1416 dhparam DH parameter file (ignored, we're a client)
1417 certificate certificate file
1418 privatekey private key file
1419 sni TLS SNI to send to remote host
1420 verify_certs file for certificate verify
1421 verify_crl CRL for verify
1422 require_ciphers list of allowed ciphers or NULL
1423 timeout startup timeout
1425 Returns: OK/DEFER/FAIL (because using common functions),
1426 but for a client, DEFER and FAIL have the same meaning
1430 tls_client_start(int fd
, host_item
*host
,
1431 address_item
*addr ARG_UNUSED
, uschar
*dhparam ARG_UNUSED
,
1432 uschar
*certificate
, uschar
*privatekey
, uschar
*sni
,
1433 uschar
*verify_certs
, uschar
*verify_crl
,
1434 uschar
*require_ciphers
, int timeout
)
1438 exim_gnutls_state_st
*state
= NULL
;
1440 DEBUG(D_tls
) debug_printf("initialising GnuTLS as a client on fd %d\n", fd
);
1442 rc
= tls_init(host
, certificate
, privatekey
,
1443 sni
, verify_certs
, verify_crl
, require_ciphers
, &state
);
1444 if (rc
!= OK
) return rc
;
1446 gnutls_dh_set_prime_bits(state
->session
, EXIM_CLIENT_DH_MIN_BITS
);
1448 if (verify_certs
== NULL
)
1450 DEBUG(D_tls
) debug_printf("TLS: server certificate verification not required\n");
1451 state
->verify_requirement
= VERIFY_NONE
;
1452 /* we still ask for it, to log it, etc */
1453 gnutls_certificate_server_set_request(state
->session
, GNUTLS_CERT_REQUEST
);
1457 DEBUG(D_tls
) debug_printf("TLS: server certificate verification required\n");
1458 state
->verify_requirement
= VERIFY_REQUIRED
;
1459 gnutls_certificate_server_set_request(state
->session
, GNUTLS_CERT_REQUIRE
);
1462 gnutls_transport_set_ptr(state
->session
, (gnutls_transport_ptr
)fd
);
1466 /* There doesn't seem to be a built-in timeout on connection. */
1468 sigalrm_seen
= FALSE
;
1472 rc
= gnutls_handshake(state
->session
);
1473 } while ((rc
== GNUTLS_E_AGAIN
) || (rc
== GNUTLS_E_INTERRUPTED
));
1476 DEBUG(D_tls
) debug_printf("gnutls_handshake was successful\n");
1480 if (state
->verify_requirement
!= VERIFY_NONE
&&
1481 !verify_certificate(state
, &error
))
1482 return tls_error(US
"certificate verification failed", error
, state
->host
);
1484 /* Figure out peer DN, and if authenticated, etc. */
1486 rc
= peer_status(state
);
1487 if (rc
!= OK
) return rc
;
1489 /* Sets various Exim expansion variables; always safe within server */
1491 extract_exim_vars_from_tls_state(state
);
1499 /*************************************************
1500 * Close down a TLS session *
1501 *************************************************/
1503 /* This is also called from within a delivery subprocess forked from the
1504 daemon, to shut down the TLS library, without actually doing a shutdown (which
1505 would tamper with the TLS session in the parent process).
1507 Arguments: TRUE if gnutls_bye is to be called
1512 tls_close(BOOL shutdown
)
1514 exim_gnutls_state_st
*state
= current_global_tls_state
;
1516 if (tls_active
< 0) return; /* TLS was not active */
1520 DEBUG(D_tls
) debug_printf("tls_close(): shutting down TLS\n");
1521 gnutls_bye(state
->session
, GNUTLS_SHUT_WR
);
1524 gnutls_deinit(state
->session
);
1526 memcpy(state
, &exim_gnutls_state_init
, sizeof(exim_gnutls_state_init
));
1528 if ((state_server
.session
== NULL
) && (state_client
.session
== NULL
))
1530 gnutls_global_deinit();
1531 exim_gnutls_base_init_done
= FALSE
;
1540 /*************************************************
1541 * TLS version of getc *
1542 *************************************************/
1544 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1545 it refills the buffer via the GnuTLS reading function.
1547 This feeds DKIM and should be used for all message-body reads.
1550 Returns: the next character or EOF
1556 exim_gnutls_state_st
*state
= current_global_tls_state
;
1557 if (state
->xfer_buffer_lwm
>= state
->xfer_buffer_hwm
)
1561 DEBUG(D_tls
) debug_printf("Calling gnutls_record_recv(%p, %p, %u)\n",
1562 state
->session
, state
->xfer_buffer
, ssl_xfer_buffer_size
);
1564 if (smtp_receive_timeout
> 0) alarm(smtp_receive_timeout
);
1565 inbytes
= gnutls_record_recv(state
->session
, state
->xfer_buffer
,
1566 ssl_xfer_buffer_size
);
1569 /* A zero-byte return appears to mean that the TLS session has been
1570 closed down, not that the socket itself has been closed down. Revert to
1571 non-TLS handling. */
1575 DEBUG(D_tls
) debug_printf("Got TLS_EOF\n");
1577 receive_getc
= smtp_getc
;
1578 receive_ungetc
= smtp_ungetc
;
1579 receive_feof
= smtp_feof
;
1580 receive_ferror
= smtp_ferror
;
1581 receive_smtp_buffered
= smtp_buffered
;
1583 gnutls_deinit(state
->session
);
1584 state
->session
= NULL
;
1587 tls_certificate_verified
= FALSE
;
1588 tls_channelbinding_b64
= NULL
;
1595 /* Handle genuine errors */
1597 else if (inbytes
< 0)
1599 record_io_error(state
, (int) inbytes
, US
"recv", NULL
);
1600 state
->xfer_error
= 1;
1603 #ifndef DISABLE_DKIM
1604 dkim_exim_verify_feed(state
->xfer_buffer
, inbytes
);
1606 state
->xfer_buffer_hwm
= (int) inbytes
;
1607 state
->xfer_buffer_lwm
= 0;
1610 /* Something in the buffer; return next uschar */
1612 return state
->xfer_buffer
[state
->xfer_buffer_lwm
++];
1618 /*************************************************
1619 * Read bytes from TLS channel *
1620 *************************************************/
1622 /* This does not feed DKIM, so if the caller uses this for reading message body,
1623 then the caller must feed DKIM.
1628 Returns: the number of bytes read
1629 -1 after a failed read
1633 tls_read(uschar
*buff
, size_t len
)
1635 exim_gnutls_state_st
*state
= current_global_tls_state
;
1641 if (state
->xfer_buffer_lwm
< state
->xfer_buffer_hwm
)
1643 debug_printf("*** PROBABLY A BUG *** " \
1644 "tls_read() called with data in the tls_getc() buffer, %d ignored\n",
1645 state
->xfer_buffer_hwm
- state
->xfer_buffer_lwm
);
1648 debug_printf("Calling gnutls_record_recv(%p, %p, " SIZE_T_FMT
")\n",
1649 state
->session
, buff
, len
);
1651 inbytes
= gnutls_record_recv(state
->session
, buff
, len
);
1652 if (inbytes
> 0) return inbytes
;
1655 DEBUG(D_tls
) debug_printf("Got TLS_EOF\n");
1657 else record_io_error(state
, (int)inbytes
, US
"recv", NULL
);
1665 /*************************************************
1666 * Write bytes down TLS channel *
1667 *************************************************/
1674 Returns: the number of bytes after a successful write,
1675 -1 after a failed write
1679 tls_write(const uschar
*buff
, size_t len
)
1683 exim_gnutls_state_st
*state
= current_global_tls_state
;
1685 DEBUG(D_tls
) debug_printf("tls_do_write(%p, " SIZE_T_FMT
")\n", buff
, left
);
1688 DEBUG(D_tls
) debug_printf("gnutls_record_send(SSL, %p, " SIZE_T_FMT
")\n",
1690 outbytes
= gnutls_record_send(state
->session
, buff
, left
);
1692 DEBUG(D_tls
) debug_printf("outbytes=" SSIZE_T_FMT
"\n", outbytes
);
1695 record_io_error(state
, outbytes
, US
"send", NULL
);
1700 record_io_error(state
, 0, US
"send", US
"TLS channel closed on write");
1711 debug_printf("Whoops! Wrote more bytes (" SIZE_T_FMT
") than INT_MAX\n",
1722 /*************************************************
1723 * Random number generation *
1724 *************************************************/
1726 /* Pseudo-random number generation. The result is not expected to be
1727 cryptographically strong but not so weak that someone will shoot themselves
1728 in the foot using it as a nonce in input in some email header scheme or
1729 whatever weirdness they'll twist this into. The result should handle fork()
1730 and avoid repeating sequences. OpenSSL handles that for us.
1734 Returns a random number in range [0, max-1]
1737 #ifdef HAVE_GNUTLS_RND
1739 vaguely_random_number(int max
)
1744 uschar smallbuf
[sizeof(r
)];
1749 needed_len
= sizeof(r
);
1750 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1751 * asked for a number less than 10. */
1752 for (r
= max
, i
= 0; r
; ++i
)
1758 i
= gnutls_rnd(GNUTLS_RND_NONCE
, smallbuf
, needed_len
);
1761 DEBUG(D_all
) debug_printf("gnutls_rnd() failed, using fallback.\n");
1762 return vaguely_random_number_fallback(max
);
1765 for (p
= smallbuf
; needed_len
; --needed_len
, ++p
)
1771 /* We don't particularly care about weighted results; if someone wants
1772 * smooth distribution and cares enough then they should submit a patch then. */
1775 #else /* HAVE_GNUTLS_RND */
1777 vaguely_random_number(int max
)
1779 return vaguely_random_number_fallback(max
);
1781 #endif /* HAVE_GNUTLS_RND */
1786 /*************************************************
1787 * Report the library versions. *
1788 *************************************************/
1790 /* See a description in tls-openssl.c for an explanation of why this exists.
1792 Arguments: a FILE* to print the results to
1797 tls_version_report(FILE *f
)
1799 fprintf(f
, "Library version: GnuTLS: Compile: %s\n"
1802 gnutls_check_version(NULL
));
1805 /* End of tls-gnu.c */