Document new dane_require_tls_ciphers
[exim.git] / src / src / tls-openssl.c
CommitLineData
059ec3d9
PH
1/*************************************************
2* Exim - an Internet mail transport agent *
3*************************************************/
4
f9ba5e22 5/* Copyright (c) University of Cambridge 1995 - 2018 */
059ec3d9
PH
6/* See the file NOTICE for conditions of use and distribution. */
7
f5d78688
JH
8/* Portions Copyright (c) The OpenSSL Project 1999 */
9
059ec3d9
PH
10/* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
11library. It is #included into the tls.c file when that library is used. The
12code herein is based on a patch that was originally contributed by Steve
13Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
14
15No cryptographic code is included in Exim. All this module does is to call
16functions from the OpenSSL library. */
17
18
19/* Heading stuff */
20
21#include <openssl/lhash.h>
22#include <openssl/ssl.h>
23#include <openssl/err.h>
24#include <openssl/rand.h>
10ca4f1c
JH
25#ifndef OPENSSL_NO_ECDH
26# include <openssl/ec.h>
27#endif
f2de3a33 28#ifndef DISABLE_OCSP
e51c7be2 29# include <openssl/ocsp.h>
3f7eeb86 30#endif
c0635b6d 31#ifdef SUPPORT_DANE
05e796ad 32# include "danessl.h"
85098ee7
JH
33#endif
34
3f7eeb86 35
f2de3a33
JH
36#ifndef DISABLE_OCSP
37# define EXIM_OCSP_SKEW_SECONDS (300L)
38# define EXIM_OCSP_MAX_AGE (-1L)
3f7eeb86 39#endif
059ec3d9 40
3bcbbbe2 41#if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
e51c7be2 42# define EXIM_HAVE_OPENSSL_TLSEXT
3bcbbbe2 43#endif
c8dfb21d
JH
44#if OPENSSL_VERSION_NUMBER >= 0x00908000L
45# define EXIM_HAVE_RSA_GENKEY_EX
46#endif
47#if OPENSSL_VERSION_NUMBER >= 0x10100000L
48# define EXIM_HAVE_OCSP_RESP_COUNT
49#else
50# define EXIM_HAVE_EPHEM_RSA_KEX
51# define EXIM_HAVE_RAND_PSEUDO
52#endif
53#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
260958d6 54# define EXIM_HAVE_SHA256 /*MMMM*/
c8dfb21d 55#endif
34e3241d
PP
56
57/*
58 * X509_check_host provides sane certificate hostname checking, but was added
59 * to OpenSSL late, after other projects forked off the code-base. So in
60 * addition to guarding against the base version number, beware that LibreSSL
61 * does not (at this time) support this function.
62 *
63 * If LibreSSL gains a different API, perhaps via libtls, then we'll probably
64 * opt to disentangle and ask a LibreSSL user to provide glue for a third
65 * crypto provider for libtls instead of continuing to tie the OpenSSL glue
66 * into even twistier knots. If LibreSSL gains the same API, we can just
67 * change this guard and punt the issue for a while longer.
68 */
69#ifndef LIBRESSL_VERSION_NUMBER
70# if OPENSSL_VERSION_NUMBER >= 0x010100000L
71# define EXIM_HAVE_OPENSSL_CHECKHOST
8420742d 72# define EXIM_HAVE_OPENSSL_DH_BITS
34e3241d
PP
73# endif
74# if OPENSSL_VERSION_NUMBER >= 0x010000000L \
2dfb468b 75 && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
34e3241d
PP
76# define EXIM_HAVE_OPENSSL_CHECKHOST
77# endif
11aa88b0 78#endif
10ca4f1c 79
11aa88b0
RA
80#if !defined(LIBRESSL_VERSION_NUMBER) \
81 || LIBRESSL_VERSION_NUMBER >= 0x20010000L
10ca4f1c
JH
82# if !defined(OPENSSL_NO_ECDH)
83# if OPENSSL_VERSION_NUMBER >= 0x0090800fL
260958d6 84# define EXIM_HAVE_ECDH /*MMMM*/
10ca4f1c
JH
85# endif
86# if OPENSSL_VERSION_NUMBER >= 0x10002000L
10ca4f1c
JH
87# define EXIM_HAVE_OPENSSL_EC_NIST2NID
88# endif
89# endif
2dfb468b 90#endif
3bcbbbe2 91
67791ce4
JH
92#if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
93# warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
94# define DISABLE_OCSP
95#endif
96
a6510420
JH
97#ifdef EXIM_HAVE_OPENSSL_CHECKHOST
98# include <openssl/x509v3.h>
99#endif
100
059ec3d9
PH
101/* Structure for collecting random data for seeding. */
102
103typedef struct randstuff {
9e3331ea
TK
104 struct timeval tv;
105 pid_t p;
059ec3d9
PH
106} randstuff;
107
108/* Local static variables */
109
a2ff477a
JH
110static BOOL client_verify_callback_called = FALSE;
111static BOOL server_verify_callback_called = FALSE;
059ec3d9
PH
112static const uschar *sid_ctx = US"exim";
113
d4f09789
PP
114/* We have three different contexts to care about.
115
116Simple case: client, `client_ctx`
117 As a client, we can be doing a callout or cut-through delivery while receiving
118 a message. So we have a client context, which should have options initialised
119 from the SMTP Transport.
120
121Server:
122 There are two cases: with and without ServerNameIndication from the client.
123 Given TLS SNI, we can be using different keys, certs and various other
124 configuration settings, because they're re-expanded with $tls_sni set. This
125 allows vhosting with TLS. This SNI is sent in the handshake.
126 A client might not send SNI, so we need a fallback, and an initial setup too.
127 So as a server, we start out using `server_ctx`.
128 If SNI is sent by the client, then we as server, mid-negotiation, try to clone
129 `server_sni` from `server_ctx` and then initialise settings by re-expanding
130 configuration.
131*/
132
817d9f57
JH
133static SSL_CTX *client_ctx = NULL;
134static SSL_CTX *server_ctx = NULL;
135static SSL *client_ssl = NULL;
136static SSL *server_ssl = NULL;
389ca47a 137
35731706 138#ifdef EXIM_HAVE_OPENSSL_TLSEXT
817d9f57 139static SSL_CTX *server_sni = NULL;
35731706 140#endif
059ec3d9
PH
141
142static char ssl_errstring[256];
143
144static int ssl_session_timeout = 200;
a2ff477a
JH
145static BOOL client_verify_optional = FALSE;
146static BOOL server_verify_optional = FALSE;
059ec3d9 147
f5d78688 148static BOOL reexpand_tls_files_for_sni = FALSE;
059ec3d9
PH
149
150
7be682ca
PP
151typedef struct tls_ext_ctx_cb {
152 uschar *certificate;
153 uschar *privatekey;
f5d78688 154 BOOL is_server;
a6510420 155#ifndef DISABLE_OCSP
c3033f13 156 STACK_OF(X509) *verify_stack; /* chain for verifying the proof */
f5d78688
JH
157 union {
158 struct {
159 uschar *file;
160 uschar *file_expanded;
161 OCSP_RESPONSE *response;
162 } server;
163 struct {
44662487
JH
164 X509_STORE *verify_store; /* non-null if status requested */
165 BOOL verify_required;
f5d78688
JH
166 } client;
167 } u_ocsp;
3f7eeb86 168#endif
7be682ca
PP
169 uschar *dhparam;
170 /* these are cached from first expand */
171 uschar *server_cipher_list;
172 /* only passed down to tls_error: */
173 host_item *host;
55414b25 174 const uschar * verify_cert_hostnames;
0cbf2b82 175#ifndef DISABLE_EVENT
a7538db1
JH
176 uschar * event_action;
177#endif
7be682ca
PP
178} tls_ext_ctx_cb;
179
180/* should figure out a cleanup of API to handle state preserved per
181implementation, for various reasons, which can be void * in the APIs.
182For now, we hack around it. */
817d9f57
JH
183tls_ext_ctx_cb *client_static_cbinfo = NULL;
184tls_ext_ctx_cb *server_static_cbinfo = NULL;
7be682ca
PP
185
186static int
983207c1 187setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
cf0c6164 188 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
059ec3d9 189
3f7eeb86 190/* Callbacks */
3bcbbbe2 191#ifdef EXIM_HAVE_OPENSSL_TLSEXT
3f7eeb86 192static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
3bcbbbe2 193#endif
f2de3a33 194#ifndef DISABLE_OCSP
f5d78688 195static int tls_server_stapling_cb(SSL *s, void *arg);
3f7eeb86
PP
196#endif
197
059ec3d9
PH
198
199/*************************************************
200* Handle TLS error *
201*************************************************/
202
203/* Called from lots of places when errors occur before actually starting to do
204the TLS handshake, that is, while the session is still in clear. Always returns
205DEFER for a server and FAIL for a client so that most calls can use "return
206tls_error(...)" to do this processing and then give an appropriate return. A
207single function is used for both server and client, because it is called from
208some shared functions.
209
210Argument:
211 prefix text to include in the logged error
212 host NULL if setting up a server;
213 the connected host if setting up a client
7199e1ee 214 msg error message or NULL if we should ask OpenSSL
cf0c6164 215 errstr pointer to output error message
059ec3d9
PH
216
217Returns: OK/DEFER/FAIL
218*/
219
220static int
cf0c6164 221tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
059ec3d9 222{
c562fd30 223if (!msg)
7199e1ee
TF
224 {
225 ERR_error_string(ERR_get_error(), ssl_errstring);
cf0c6164 226 msg = US ssl_errstring;
7199e1ee
TF
227 }
228
cf0c6164
JH
229if (errstr) *errstr = string_sprintf("(%s): %s", prefix, msg);
230return host ? FAIL : DEFER;
059ec3d9
PH
231}
232
233
234
235/*************************************************
236* Callback to generate RSA key *
237*************************************************/
238
239/*
240Arguments:
3ae79556 241 s SSL connection (not used)
059ec3d9
PH
242 export not used
243 keylength keylength
244
245Returns: pointer to generated key
246*/
247
248static RSA *
249rsa_callback(SSL *s, int export, int keylength)
250{
251RSA *rsa_key;
c8dfb21d
JH
252#ifdef EXIM_HAVE_RSA_GENKEY_EX
253BIGNUM *bn = BN_new();
254#endif
255
059ec3d9
PH
256export = export; /* Shut picky compilers up */
257DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
c8dfb21d
JH
258
259#ifdef EXIM_HAVE_RSA_GENKEY_EX
260if ( !BN_set_word(bn, (unsigned long)RSA_F4)
f2cb6292 261 || !(rsa_key = RSA_new())
c8dfb21d
JH
262 || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
263 )
264#else
23bb6982 265if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
c8dfb21d
JH
266#endif
267
059ec3d9
PH
268 {
269 ERR_error_string(ERR_get_error(), ssl_errstring);
270 log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
271 ssl_errstring);
272 return NULL;
273 }
274return rsa_key;
275}
276
277
278
f5d78688 279/* Extreme debug
f2de3a33 280#ifndef DISABLE_OCSP
f5d78688
JH
281void
282x509_store_dump_cert_s_names(X509_STORE * store)
283{
284STACK_OF(X509_OBJECT) * roots= store->objs;
285int i;
286static uschar name[256];
287
288for(i= 0; i<sk_X509_OBJECT_num(roots); i++)
289 {
290 X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
291 if(tmp_obj->type == X509_LU_X509)
292 {
293 X509 * current_cert= tmp_obj->data.x509;
294 X509_NAME_oneline(X509_get_subject_name(current_cert), CS name, sizeof(name));
f69979cf 295 name[sizeof(name)-1] = '\0';
f5d78688
JH
296 debug_printf(" %s\n", name);
297 }
298 }
299}
300#endif
301*/
302
059ec3d9 303
0cbf2b82 304#ifndef DISABLE_EVENT
f69979cf
JH
305static int
306verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
307 BOOL *calledp, const BOOL *optionalp, const uschar * what)
308{
309uschar * ev;
310uschar * yield;
311X509 * old_cert;
312
313ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
314if (ev)
315 {
aaba7d03 316 DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
f69979cf
JH
317 old_cert = tlsp->peercert;
318 tlsp->peercert = X509_dup(cert);
319 /* NB we do not bother setting peerdn */
320 if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
321 {
322 log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
323 "depth=%d cert=%s: %s",
324 tlsp == &tls_out ? deliver_host_address : sender_host_address,
325 what, depth, dn, yield);
326 *calledp = TRUE;
327 if (!*optionalp)
328 {
329 if (old_cert) tlsp->peercert = old_cert; /* restore 1st failing cert */
330 return 1; /* reject (leaving peercert set) */
331 }
332 DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
333 "(host in tls_try_verify_hosts)\n");
334 }
335 X509_free(tlsp->peercert);
336 tlsp->peercert = old_cert;
337 }
338return 0;
339}
340#endif
341
059ec3d9
PH
342/*************************************************
343* Callback for verification *
344*************************************************/
345
346/* The SSL library does certificate verification if set up to do so. This
347callback has the current yes/no state is in "state". If verification succeeded,
f69979cf
JH
348we set the certificate-verified flag. If verification failed, what happens
349depends on whether the client is required to present a verifiable certificate
350or not.
059ec3d9
PH
351
352If verification is optional, we change the state to yes, but still log the
353verification error. For some reason (it really would help to have proper
354documentation of OpenSSL), this callback function then gets called again, this
f69979cf
JH
355time with state = 1. We must take care not to set the private verified flag on
356the second time through.
059ec3d9
PH
357
358Note: this function is not called if the client fails to present a certificate
359when asked. We get here only if a certificate has been received. Handling of
360optional verification for this case is done when requesting SSL to verify, by
361setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
362
a7538db1
JH
363May be called multiple times for different issues with a certificate, even
364for a given "depth" in the certificate chain.
365
059ec3d9 366Arguments:
f2f2c91b
JH
367 preverify_ok current yes/no state as 1/0
368 x509ctx certificate information.
369 tlsp per-direction (client vs. server) support data
370 calledp has-been-called flag
371 optionalp verification-is-optional flag
059ec3d9 372
f2f2c91b 373Returns: 0 if verification should fail, otherwise 1
059ec3d9
PH
374*/
375
376static int
f2f2c91b 377verify_callback(int preverify_ok, X509_STORE_CTX *x509ctx,
421aff85 378 tls_support *tlsp, BOOL *calledp, BOOL *optionalp)
059ec3d9 379{
421aff85 380X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
a7538db1 381int depth = X509_STORE_CTX_get_error_depth(x509ctx);
f69979cf 382uschar dn[256];
059ec3d9 383
f69979cf
JH
384X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn));
385dn[sizeof(dn)-1] = '\0';
059ec3d9 386
f2f2c91b 387if (preverify_ok == 0)
059ec3d9 388 {
f77197ae
JH
389 uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
390 *verify_mode, sender_host_address)
391 : US"";
392 log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
393 tlsp == &tls_out ? deliver_host_address : sender_host_address,
394 extra, depth,
395 X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
a2ff477a 396 *calledp = TRUE;
9d1c15ef
JH
397 if (!*optionalp)
398 {
f69979cf
JH
399 if (!tlsp->peercert)
400 tlsp->peercert = X509_dup(cert); /* record failing cert */
401 return 0; /* reject */
9d1c15ef 402 }
059ec3d9
PH
403 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
404 "tls_try_verify_hosts)\n");
059ec3d9
PH
405 }
406
a7538db1 407else if (depth != 0)
059ec3d9 408 {
f69979cf 409 DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
f2de3a33 410#ifndef DISABLE_OCSP
f5d78688
JH
411 if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
412 { /* client, wanting stapling */
413 /* Add the server cert's signing chain as the one
414 for the verification of the OCSP stapled information. */
94431adb 415
f5d78688 416 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
421aff85 417 cert))
f5d78688 418 ERR_clear_error();
c3033f13 419 sk_X509_push(client_static_cbinfo->verify_stack, cert);
f5d78688
JH
420 }
421#endif
0cbf2b82 422#ifndef DISABLE_EVENT
f69979cf
JH
423 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
424 return 0; /* reject, with peercert set */
a7538db1 425#endif
059ec3d9
PH
426 }
427else
428 {
55414b25 429 const uschar * verify_cert_hostnames;
e51c7be2 430
e51c7be2
JH
431 if ( tlsp == &tls_out
432 && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
433 /* client, wanting hostname check */
e51c7be2 434 {
f69979cf 435
740f36d4 436#ifdef EXIM_HAVE_OPENSSL_CHECKHOST
f69979cf
JH
437# ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
438# define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
439# endif
440# ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
441# define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
442# endif
e51c7be2 443 int sep = 0;
55414b25 444 const uschar * list = verify_cert_hostnames;
e51c7be2 445 uschar * name;
d8e7834a
JH
446 int rc;
447 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
f40d5be3 448 if ((rc = X509_check_host(cert, CCS name, 0,
8d692470 449 X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
740f36d4
JH
450 | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
451 NULL)))
d8e7834a
JH
452 {
453 if (rc < 0)
454 {
93a6fce2 455 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
f77197ae 456 tlsp == &tls_out ? deliver_host_address : sender_host_address);
d8e7834a
JH
457 name = NULL;
458 }
e51c7be2 459 break;
d8e7834a 460 }
e51c7be2 461 if (!name)
f69979cf 462#else
e51c7be2 463 if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
f69979cf 464#endif
e51c7be2 465 {
f77197ae
JH
466 uschar * extra = verify_mode
467 ? string_sprintf(" (during %c-verify for [%s])",
468 *verify_mode, sender_host_address)
469 : US"";
e51c7be2 470 log_write(0, LOG_MAIN,
f77197ae
JH
471 "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
472 tlsp == &tls_out ? deliver_host_address : sender_host_address,
473 extra, dn, verify_cert_hostnames);
a3ef7310
JH
474 *calledp = TRUE;
475 if (!*optionalp)
f69979cf
JH
476 {
477 if (!tlsp->peercert)
478 tlsp->peercert = X509_dup(cert); /* record failing cert */
479 return 0; /* reject */
480 }
a3ef7310
JH
481 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
482 "tls_try_verify_hosts)\n");
e51c7be2 483 }
f69979cf 484 }
e51c7be2 485
0cbf2b82 486#ifndef DISABLE_EVENT
f69979cf
JH
487 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
488 return 0; /* reject, with peercert set */
e51c7be2
JH
489#endif
490
93dcb1c2 491 DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
f69979cf 492 *calledp ? "" : " authenticated", dn);
93dcb1c2
JH
493 if (!*calledp) tlsp->certificate_verified = TRUE;
494 *calledp = TRUE;
059ec3d9
PH
495 }
496
a7538db1 497return 1; /* accept, at least for this level */
059ec3d9
PH
498}
499
a2ff477a 500static int
f2f2c91b 501verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
a2ff477a 502{
f2f2c91b
JH
503return verify_callback(preverify_ok, x509ctx, &tls_out,
504 &client_verify_callback_called, &client_verify_optional);
a2ff477a
JH
505}
506
507static int
f2f2c91b 508verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
a2ff477a 509{
f2f2c91b
JH
510return verify_callback(preverify_ok, x509ctx, &tls_in,
511 &server_verify_callback_called, &server_verify_optional);
a2ff477a
JH
512}
513
059ec3d9 514
c0635b6d 515#ifdef SUPPORT_DANE
53a7196b 516
e5cccda9
JH
517/* This gets called *by* the dane library verify callback, which interposes
518itself.
519*/
520static int
f2f2c91b 521verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
e5cccda9
JH
522{
523X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
f69979cf 524uschar dn[256];
83b27293 525int depth = X509_STORE_CTX_get_error_depth(x509ctx);
5c75db2e 526#ifndef DISABLE_EVENT
f69979cf 527BOOL dummy_called, optional = FALSE;
83b27293 528#endif
e5cccda9 529
f69979cf
JH
530X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn));
531dn[sizeof(dn)-1] = '\0';
e5cccda9 532
f2f2c91b
JH
533DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
534 preverify_ok ? "ok":"BAD", depth, dn);
e5cccda9 535
0cbf2b82 536#ifndef DISABLE_EVENT
f69979cf
JH
537 if (verify_event(&tls_out, cert, depth, dn,
538 &dummy_called, &optional, US"DANE"))
539 return 0; /* reject, with peercert set */
83b27293
JH
540#endif
541
f2f2c91b 542if (preverify_ok == 1)
6fbf3599
JH
543 {
544 tls_out.dane_verified = tls_out.certificate_verified = TRUE;
545#ifndef DISABLE_OCSP
546 if (client_static_cbinfo->u_ocsp.client.verify_store)
547 { /* client, wanting stapling */
548 /* Add the server cert's signing chain as the one
549 for the verification of the OCSP stapled information. */
550
551 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
552 cert))
553 ERR_clear_error();
554 sk_X509_push(client_static_cbinfo->verify_stack, cert);
555 }
556#endif
557 }
f2f2c91b
JH
558else
559 {
560 int err = X509_STORE_CTX_get_error(x509ctx);
561 DEBUG(D_tls)
562 debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
3c51463e 563 if (err == X509_V_ERR_APPLICATION_VERIFICATION)
f2f2c91b
JH
564 preverify_ok = 1;
565 }
566return preverify_ok;
e5cccda9 567}
53a7196b 568
c0635b6d 569#endif /*SUPPORT_DANE*/
e5cccda9 570
059ec3d9
PH
571
572/*************************************************
573* Information callback *
574*************************************************/
575
576/* The SSL library functions call this from time to time to indicate what they
7be682ca
PP
577are doing. We copy the string to the debugging output when TLS debugging has
578been requested.
059ec3d9
PH
579
580Arguments:
581 s the SSL connection
582 where
583 ret
584
585Returns: nothing
586*/
587
588static void
589info_callback(SSL *s, int where, int ret)
590{
591where = where;
592ret = ret;
593DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
594}
595
596
597
598/*************************************************
599* Initialize for DH *
600*************************************************/
601
602/* If dhparam is set, expand it, and load up the parameters for DH encryption.
603
604Arguments:
038597d2 605 sctx The current SSL CTX (inbound or outbound)
a799883d 606 dhparam DH parameter file or fixed parameter identity string
7199e1ee 607 host connected host, if client; NULL if server
cf0c6164 608 errstr error string pointer
059ec3d9
PH
609
610Returns: TRUE if OK (nothing to set up, or setup worked)
611*/
612
613static BOOL
cf0c6164 614init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
059ec3d9 615{
059ec3d9
PH
616BIO *bio;
617DH *dh;
618uschar *dhexpanded;
a799883d 619const char *pem;
6600985a 620int dh_bitsize;
059ec3d9 621
cf0c6164 622if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
059ec3d9
PH
623 return FALSE;
624
0df4ab80 625if (!dhexpanded || !*dhexpanded)
a799883d 626 bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
a799883d 627else if (dhexpanded[0] == '/')
059ec3d9 628 {
0df4ab80 629 if (!(bio = BIO_new_file(CS dhexpanded, "r")))
059ec3d9 630 {
7199e1ee 631 tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
cf0c6164 632 host, US strerror(errno), errstr);
a799883d 633 return FALSE;
059ec3d9 634 }
a799883d
PP
635 }
636else
637 {
638 if (Ustrcmp(dhexpanded, "none") == 0)
059ec3d9 639 {
a799883d
PP
640 DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
641 return TRUE;
059ec3d9 642 }
a799883d 643
0df4ab80 644 if (!(pem = std_dh_prime_named(dhexpanded)))
a799883d
PP
645 {
646 tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
cf0c6164 647 host, US strerror(errno), errstr);
a799883d
PP
648 return FALSE;
649 }
650 bio = BIO_new_mem_buf(CS pem, -1);
651 }
652
0df4ab80 653if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
a799883d 654 {
059ec3d9 655 BIO_free(bio);
a799883d 656 tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
cf0c6164 657 host, NULL, errstr);
a799883d
PP
658 return FALSE;
659 }
660
6600985a
PP
661/* note: our default limit of 2236 is not a multiple of 8; the limit comes from
662 * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
663 * 2236. But older OpenSSL can only report in bytes (octets), not bits.
664 * If someone wants to dance at the edge, then they can raise the limit or use
665 * current libraries. */
666#ifdef EXIM_HAVE_OPENSSL_DH_BITS
667/* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
668 * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
669dh_bitsize = DH_bits(dh);
670#else
671dh_bitsize = 8 * DH_size(dh);
672#endif
673
a799883d
PP
674/* Even if it is larger, we silently return success rather than cause things
675 * to fail out, so that a too-large DH will not knock out all TLS; it's a
676 * debatable choice. */
6600985a 677if (dh_bitsize > tls_dh_max_bits)
a799883d
PP
678 {
679 DEBUG(D_tls)
170f4904 680 debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
6600985a 681 dh_bitsize, tls_dh_max_bits);
a799883d
PP
682 }
683else
684 {
685 SSL_CTX_set_tmp_dh(sctx, dh);
686 DEBUG(D_tls)
687 debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
6600985a 688 dhexpanded ? dhexpanded : US"default", dh_bitsize);
059ec3d9
PH
689 }
690
a799883d
PP
691DH_free(dh);
692BIO_free(bio);
693
694return TRUE;
059ec3d9
PH
695}
696
697
698
699
038597d2
PP
700/*************************************************
701* Initialize for ECDH *
702*************************************************/
703
704/* Load parameters for ECDH encryption.
705
706For now, we stick to NIST P-256 because: it's simple and easy to configure;
707it avoids any patent issues that might bite redistributors; despite events in
708the news and concerns over curve choices, we're not cryptographers, we're not
709pretending to be, and this is "good enough" to be better than no support,
710protecting against most adversaries. Given another year or two, there might
711be sufficient clarity about a "right" way forward to let us make an informed
712decision, instead of a knee-jerk reaction.
713
714Longer-term, we should look at supporting both various named curves and
715external files generated with "openssl ecparam", much as we do for init_dh().
716We should also support "none" as a value, to explicitly avoid initialisation.
717
718Patches welcome.
719
720Arguments:
721 sctx The current SSL CTX (inbound or outbound)
722 host connected host, if client; NULL if server
cf0c6164 723 errstr error string pointer
038597d2
PP
724
725Returns: TRUE if OK (nothing to set up, or setup worked)
726*/
727
728static BOOL
cf0c6164 729init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
038597d2 730{
63f0dbe0
JH
731#ifdef OPENSSL_NO_ECDH
732return TRUE;
733#else
734
10ca4f1c
JH
735EC_KEY * ecdh;
736uschar * exp_curve;
737int nid;
738BOOL rv;
739
038597d2
PP
740if (host) /* No ECDH setup for clients, only for servers */
741 return TRUE;
742
10ca4f1c 743# ifndef EXIM_HAVE_ECDH
038597d2
PP
744DEBUG(D_tls)
745 debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
746return TRUE;
038597d2 747# else
10ca4f1c 748
cf0c6164 749if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
10ca4f1c
JH
750 return FALSE;
751if (!exp_curve || !*exp_curve)
752 return TRUE;
753
8e53a4fc 754/* "auto" needs to be handled carefully.
4c04137d 755 * OpenSSL < 1.0.2: we do not select anything, but fallback to prime256v1
8e53a4fc 756 * OpenSSL < 1.1.0: we have to call SSL_CTX_set_ecdh_auto
4c04137d 757 * (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
8e53a4fc
HSHR
758 * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
759 * https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
760 */
10ca4f1c 761if (Ustrcmp(exp_curve, "auto") == 0)
038597d2 762 {
8e53a4fc 763#if OPENSSL_VERSION_NUMBER < 0x10002000L
10ca4f1c 764 DEBUG(D_tls) debug_printf(
8e53a4fc 765 "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
78a3bbd5 766 exp_curve = US"prime256v1";
8e53a4fc
HSHR
767#else
768# if defined SSL_CTRL_SET_ECDH_AUTO
769 DEBUG(D_tls) debug_printf(
770 "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
10ca4f1c
JH
771 SSL_CTX_set_ecdh_auto(sctx, 1);
772 return TRUE;
8e53a4fc
HSHR
773# else
774 DEBUG(D_tls) debug_printf(
775 "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
776 return TRUE;
777# endif
778#endif
10ca4f1c 779 }
038597d2 780
10ca4f1c
JH
781DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
782if ( (nid = OBJ_sn2nid (CCS exp_curve)) == NID_undef
783# ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
784 && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
785# endif
786 )
787 {
cf0c6164
JH
788 tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
789 host, NULL, errstr);
10ca4f1c
JH
790 return FALSE;
791 }
038597d2 792
10ca4f1c
JH
793if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
794 {
cf0c6164 795 tls_error(US"Unable to create ec curve", host, NULL, errstr);
10ca4f1c 796 return FALSE;
038597d2 797 }
10ca4f1c
JH
798
799/* The "tmp" in the name here refers to setting a temporary key
800not to the stability of the interface. */
801
802if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
cf0c6164 803 tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
10ca4f1c
JH
804else
805 DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
806
807EC_KEY_free(ecdh);
808return !rv;
809
810# endif /*EXIM_HAVE_ECDH*/
811#endif /*OPENSSL_NO_ECDH*/
038597d2
PP
812}
813
814
815
816
f2de3a33 817#ifndef DISABLE_OCSP
3f7eeb86
PP
818/*************************************************
819* Load OCSP information into state *
820*************************************************/
f5d78688 821/* Called to load the server OCSP response from the given file into memory, once
3f7eeb86
PP
822caller has determined this is needed. Checks validity. Debugs a message
823if invalid.
824
825ASSUMES: single response, for single cert.
826
827Arguments:
828 sctx the SSL_CTX* to update
829 cbinfo various parts of session state
830 expanded the filename putatively holding an OCSP response
831
832*/
833
834static void
f5d78688 835ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
3f7eeb86 836{
ee5b1e28
JH
837BIO * bio;
838OCSP_RESPONSE * resp;
839OCSP_BASICRESP * basic_response;
840OCSP_SINGLERESP * single_response;
841ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
ee5b1e28 842STACK_OF(X509) * sk;
3f7eeb86
PP
843unsigned long verify_flags;
844int status, reason, i;
845
f5d78688
JH
846cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
847if (cbinfo->u_ocsp.server.response)
3f7eeb86 848 {
f5d78688
JH
849 OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
850 cbinfo->u_ocsp.server.response = NULL;
3f7eeb86
PP
851 }
852
ee5b1e28 853if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
3f7eeb86
PP
854 {
855 DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
f5d78688 856 cbinfo->u_ocsp.server.file_expanded);
3f7eeb86
PP
857 return;
858 }
859
860resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
861BIO_free(bio);
862if (!resp)
863 {
864 DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
865 return;
866 }
867
ee5b1e28 868if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
3f7eeb86
PP
869 {
870 DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
871 OCSP_response_status_str(status), status);
f5d78688 872 goto bad;
3f7eeb86
PP
873 }
874
ee5b1e28 875if (!(basic_response = OCSP_response_get1_basic(resp)))
3f7eeb86
PP
876 {
877 DEBUG(D_tls)
878 debug_printf("OCSP response parse error: unable to extract basic response.\n");
f5d78688 879 goto bad;
3f7eeb86
PP
880 }
881
c3033f13 882sk = cbinfo->verify_stack;
3f7eeb86
PP
883verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
884
885/* May need to expose ability to adjust those flags?
886OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
887OCSP_TRUSTOTHER OCSP_NOINTERN */
888
4c04137d 889/* This does a full verify on the OCSP proof before we load it for serving
ee5b1e28
JH
890up; possibly overkill - just date-checks might be nice enough.
891
892OCSP_basic_verify takes a "store" arg, but does not
893use it for the chain verification, which is all we do
894when OCSP_NOVERIFY is set. The content from the wire
895"basic_response" and a cert-stack "sk" are all that is used.
896
c3033f13
JH
897We have a stack, loaded in setup_certs() if tls_verify_certificates
898was a file (not a directory, or "system"). It is unfortunate we
899cannot used the connection context store, as that would neatly
900handle the "system" case too, but there seems to be no library
901function for getting a stack from a store.
e3555426 902[ In OpenSSL 1.1 - ? X509_STORE_CTX_get0_chain(ctx) ? ]
c3033f13
JH
903We do not free the stack since it could be needed a second time for
904SNI handling.
905
4c04137d 906Separately we might try to replace using OCSP_basic_verify() - which seems to not
ee5b1e28
JH
907be a public interface into the OpenSSL library (there's no manual entry) -
908But what with? We also use OCSP_basic_verify in the client stapling callback.
4c04137d 909And there we NEED it; we must verify that status... unless the
ee5b1e28
JH
910library does it for us anyway? */
911
912if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
3f7eeb86 913 {
ee5b1e28
JH
914 DEBUG(D_tls)
915 {
3f7eeb86
PP
916 ERR_error_string(ERR_get_error(), ssl_errstring);
917 debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
f5d78688
JH
918 }
919 goto bad;
3f7eeb86
PP
920 }
921
922/* Here's the simplifying assumption: there's only one response, for the
923one certificate we use, and nothing for anything else in a chain. If this
924proves false, we need to extract a cert id from our issued cert
925(tls_certificate) and use that for OCSP_resp_find_status() (which finds the
926right cert in the stack and then calls OCSP_single_get0_status()).
927
928I'm hoping to avoid reworking a bunch more of how we handle state here. */
ee5b1e28
JH
929
930if (!(single_response = OCSP_resp_get0(basic_response, 0)))
3f7eeb86
PP
931 {
932 DEBUG(D_tls)
933 debug_printf("Unable to get first response from OCSP basic response.\n");
f5d78688 934 goto bad;
3f7eeb86
PP
935 }
936
937status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
f5d78688 938if (status != V_OCSP_CERTSTATUS_GOOD)
3f7eeb86 939 {
f5d78688
JH
940 DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
941 OCSP_cert_status_str(status), status,
942 OCSP_crl_reason_str(reason), reason);
943 goto bad;
3f7eeb86
PP
944 }
945
946if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
947 {
948 DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
f5d78688 949 goto bad;
3f7eeb86
PP
950 }
951
f5d78688 952supply_response:
47195144 953 cbinfo->u_ocsp.server.response = resp; /*XXX stack?*/
f5d78688
JH
954return;
955
956bad:
018058b2
JH
957 if (running_in_test_harness)
958 {
959 extern char ** environ;
960 uschar ** p;
47195144 961 if (environ) for (p = USS environ; *p; p++)
018058b2
JH
962 if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
963 {
964 DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
965 goto supply_response;
966 }
967 }
f5d78688 968return;
3f7eeb86 969}
f2de3a33 970#endif /*!DISABLE_OCSP*/
3f7eeb86
PP
971
972
973
974
23bb6982
JH
975/* Create and install a selfsigned certificate, for use in server mode */
976
977static int
cf0c6164 978tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
23bb6982
JH
979{
980X509 * x509 = NULL;
981EVP_PKEY * pkey;
982RSA * rsa;
983X509_NAME * name;
984uschar * where;
985
986where = US"allocating pkey";
987if (!(pkey = EVP_PKEY_new()))
988 goto err;
989
990where = US"allocating cert";
991if (!(x509 = X509_new()))
992 goto err;
993
994where = US"generating pkey";
3ae79556 995if (!(rsa = rsa_callback(NULL, 0, 1024)))
23bb6982
JH
996 goto err;
997
4c04137d 998where = US"assigning pkey";
23bb6982
JH
999if (!EVP_PKEY_assign_RSA(pkey, rsa))
1000 goto err;
1001
1002X509_set_version(x509, 2); /* N+1 - version 3 */
1003ASN1_INTEGER_set(X509_get_serialNumber(x509), 0);
1004X509_gmtime_adj(X509_get_notBefore(x509), 0);
1005X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60); /* 1 hour */
1006X509_set_pubkey(x509, pkey);
1007
1008name = X509_get_subject_name(x509);
1009X509_NAME_add_entry_by_txt(name, "C",
4dc2379a 1010 MBSTRING_ASC, CUS "UK", -1, -1, 0);
23bb6982 1011X509_NAME_add_entry_by_txt(name, "O",
4dc2379a 1012 MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
23bb6982 1013X509_NAME_add_entry_by_txt(name, "CN",
4dc2379a 1014 MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
23bb6982
JH
1015X509_set_issuer_name(x509, name);
1016
1017where = US"signing cert";
1018if (!X509_sign(x509, pkey, EVP_md5()))
1019 goto err;
1020
1021where = US"installing selfsign cert";
1022if (!SSL_CTX_use_certificate(sctx, x509))
1023 goto err;
1024
1025where = US"installing selfsign key";
1026if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1027 goto err;
1028
1029return OK;
1030
1031err:
cf0c6164 1032 (void) tls_error(where, NULL, NULL, errstr);
23bb6982
JH
1033 if (x509) X509_free(x509);
1034 if (pkey) EVP_PKEY_free(pkey);
1035 return DEFER;
1036}
1037
1038
1039
1040
ba86e143
JH
1041static int
1042tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1043 uschar ** errstr)
1044{
1045DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1046if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1047 return tls_error(string_sprintf(
1048 "SSL_CTX_use_certificate_chain_file file=%s", file),
1049 cbinfo->host, NULL, errstr);
1050return 0;
1051}
1052
1053static int
1054tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1055 uschar ** errstr)
1056{
1057DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1058if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1059 return tls_error(string_sprintf(
1060 "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1061return 0;
1062}
1063
1064
059ec3d9 1065/*************************************************
7be682ca
PP
1066* Expand key and cert file specs *
1067*************************************************/
1068
f5d78688 1069/* Called once during tls_init and possibly again during TLS setup, for a
7be682ca
PP
1070new context, if Server Name Indication was used and tls_sni was seen in
1071the certificate string.
1072
1073Arguments:
1074 sctx the SSL_CTX* to update
1075 cbinfo various parts of session state
cf0c6164 1076 errstr error string pointer
7be682ca
PP
1077
1078Returns: OK/DEFER/FAIL
1079*/
1080
1081static int
cf0c6164
JH
1082tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1083 uschar ** errstr)
7be682ca
PP
1084{
1085uschar *expanded;
1086
23bb6982 1087if (!cbinfo->certificate)
7be682ca 1088 {
ba86e143 1089 if (!cbinfo->is_server) /* client */
23bb6982
JH
1090 return OK;
1091 /* server */
cf0c6164 1092 if (tls_install_selfsign(sctx, errstr) != OK)
23bb6982 1093 return DEFER;
7be682ca 1094 }
23bb6982
JH
1095else
1096 {
ba86e143
JH
1097 int err;
1098
23bb6982
JH
1099 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1100 Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1101 Ustrstr(cbinfo->certificate, US"tls_out_sni")
1102 )
1103 reexpand_tls_files_for_sni = TRUE;
7be682ca 1104
cf0c6164 1105 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
23bb6982
JH
1106 return DEFER;
1107
ba86e143
JH
1108 if (expanded)
1109 if (cbinfo->is_server)
1110 {
1111 const uschar * file_list = expanded;
1112 int sep = 0;
1113 uschar * file;
1114
1115 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1116 if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1117 return err;
1118 }
1119 else /* would there ever be a need for multiple client certs? */
1120 if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1121 return err;
7be682ca 1122
23bb6982 1123 if (cbinfo->privatekey != NULL &&
cf0c6164 1124 !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
23bb6982 1125 return DEFER;
7be682ca 1126
23bb6982
JH
1127 /* If expansion was forced to fail, key_expanded will be NULL. If the result
1128 of the expansion is an empty string, ignore it also, and assume the private
1129 key is in the same file as the certificate. */
1130
1131 if (expanded && *expanded)
ba86e143
JH
1132 if (cbinfo->is_server)
1133 {
1134 const uschar * file_list = expanded;
1135 int sep = 0;
1136 uschar * file;
1137
1138 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1139 if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1140 return err;
1141 }
1142 else /* would there ever be a need for multiple client certs? */
1143 if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1144 return err;
7be682ca
PP
1145 }
1146
f2de3a33 1147#ifndef DISABLE_OCSP
f40d5be3 1148if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
3f7eeb86 1149 {
47195144 1150 /*XXX stack*/
cf0c6164 1151 if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
3f7eeb86
PP
1152 return DEFER;
1153
f40d5be3 1154 if (expanded && *expanded)
3f7eeb86
PP
1155 {
1156 DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
f40d5be3
JH
1157 if ( cbinfo->u_ocsp.server.file_expanded
1158 && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
3f7eeb86 1159 {
f40d5be3
JH
1160 DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1161 }
1162 else
f40d5be3 1163 ocsp_load_response(sctx, cbinfo, expanded);
3f7eeb86
PP
1164 }
1165 }
1166#endif
1167
7be682ca
PP
1168return OK;
1169}
1170
1171
1172
1173
1174/*************************************************
1175* Callback to handle SNI *
1176*************************************************/
1177
1178/* Called when acting as server during the TLS session setup if a Server Name
1179Indication extension was sent by the client.
1180
1181API documentation is OpenSSL s_server.c implementation.
1182
1183Arguments:
1184 s SSL* of the current session
1185 ad unknown (part of OpenSSL API) (unused)
1186 arg Callback of "our" registered data
1187
1188Returns: SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1189*/
1190
3bcbbbe2 1191#ifdef EXIM_HAVE_OPENSSL_TLSEXT
7be682ca 1192static int
7be682ca
PP
1193tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1194{
1195const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
3f7eeb86 1196tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
7be682ca 1197int rc;
3f0945ff 1198int old_pool = store_pool;
cf0c6164 1199uschar * dummy_errstr;
7be682ca
PP
1200
1201if (!servername)
1202 return SSL_TLSEXT_ERR_OK;
1203
3f0945ff 1204DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
7be682ca
PP
1205 reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1206
1207/* Make the extension value available for expansion */
3f0945ff 1208store_pool = POOL_PERM;
817d9f57 1209tls_in.sni = string_copy(US servername);
3f0945ff 1210store_pool = old_pool;
7be682ca
PP
1211
1212if (!reexpand_tls_files_for_sni)
1213 return SSL_TLSEXT_ERR_OK;
1214
1215/* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1216not confident that memcpy wouldn't break some internal reference counting.
1217Especially since there's a references struct member, which would be off. */
1218
0df4ab80 1219if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
7be682ca
PP
1220 {
1221 ERR_error_string(ERR_get_error(), ssl_errstring);
1222 DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1223 return SSL_TLSEXT_ERR_NOACK;
1224 }
1225
1226/* Not sure how many of these are actually needed, since SSL object
1227already exists. Might even need this selfsame callback, for reneg? */
1228
817d9f57
JH
1229SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1230SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1231SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1232SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1233SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1234SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
038597d2 1235
cf0c6164
JH
1236if ( !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1237 || !init_ecdh(server_sni, NULL, &dummy_errstr)
038597d2
PP
1238 )
1239 return SSL_TLSEXT_ERR_NOACK;
1240
7be682ca 1241if (cbinfo->server_cipher_list)
817d9f57 1242 SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list);
f2de3a33 1243#ifndef DISABLE_OCSP
f5d78688 1244if (cbinfo->u_ocsp.server.file)
3f7eeb86 1245 {
f5d78688 1246 SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
14c7b357 1247 SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
3f7eeb86
PP
1248 }
1249#endif
7be682ca 1250
c3033f13 1251if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
cf0c6164 1252 verify_callback_server, &dummy_errstr)) != OK)
c3033f13 1253 return SSL_TLSEXT_ERR_NOACK;
7be682ca 1254
3f7eeb86
PP
1255/* do this after setup_certs, because this can require the certs for verifying
1256OCSP information. */
cf0c6164 1257if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
0df4ab80 1258 return SSL_TLSEXT_ERR_NOACK;
a799883d 1259
7be682ca 1260DEBUG(D_tls) debug_printf("Switching SSL context.\n");
817d9f57 1261SSL_set_SSL_CTX(s, server_sni);
7be682ca
PP
1262
1263return SSL_TLSEXT_ERR_OK;
1264}
3bcbbbe2 1265#endif /* EXIM_HAVE_OPENSSL_TLSEXT */
7be682ca
PP
1266
1267
1268
1269
f2de3a33 1270#ifndef DISABLE_OCSP
f5d78688 1271
3f7eeb86
PP
1272/*************************************************
1273* Callback to handle OCSP Stapling *
1274*************************************************/
1275
1276/* Called when acting as server during the TLS session setup if the client
1277requests OCSP information with a Certificate Status Request.
1278
1279Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1280project.
1281
1282*/
1283
1284static int
f5d78688 1285tls_server_stapling_cb(SSL *s, void *arg)
3f7eeb86
PP
1286{
1287const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
47195144 1288uschar *response_der; /*XXX blob */
3f7eeb86
PP
1289int response_der_len;
1290
47195144
JH
1291/*XXX stack: use SSL_get_certificate() to see which cert; from that work
1292out which ocsp blob to send. Unfortunately, SSL_get_certificate is known
1293buggy in current OpenSSL; it returns the last cert loaded always rather than
1294the one actually presented. So we can't support a stack of OCSP proofs at
1295this time. */
1296
af4a1bca 1297DEBUG(D_tls)
b3ef41c9 1298 debug_printf("Received TLS status request (OCSP stapling); %s response\n",
f5d78688
JH
1299 cbinfo->u_ocsp.server.response ? "have" : "lack");
1300
44662487 1301tls_in.ocsp = OCSP_NOT_RESP;
f5d78688 1302if (!cbinfo->u_ocsp.server.response)
3f7eeb86
PP
1303 return SSL_TLSEXT_ERR_NOACK;
1304
1305response_der = NULL;
47195144 1306response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response, /*XXX stack*/
44662487 1307 &response_der);
3f7eeb86
PP
1308if (response_der_len <= 0)
1309 return SSL_TLSEXT_ERR_NOACK;
1310
5e55c7a9 1311SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
44662487 1312tls_in.ocsp = OCSP_VFIED;
3f7eeb86
PP
1313return SSL_TLSEXT_ERR_OK;
1314}
1315
3f7eeb86 1316
f5d78688
JH
1317static void
1318time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1319{
1320BIO_printf(bp, "\t%s: ", str);
1321ASN1_GENERALIZEDTIME_print(bp, time);
1322BIO_puts(bp, "\n");
1323}
1324
1325static int
1326tls_client_stapling_cb(SSL *s, void *arg)
1327{
1328tls_ext_ctx_cb * cbinfo = arg;
1329const unsigned char * p;
1330int len;
1331OCSP_RESPONSE * rsp;
1332OCSP_BASICRESP * bs;
1333int i;
1334
1335DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1336len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1337if(!p)
1338 {
44662487 1339 /* Expect this when we requested ocsp but got none */
6c6d6e48 1340 if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
44662487 1341 log_write(0, LOG_MAIN, "Received TLS status callback, null content");
f5d78688
JH
1342 else
1343 DEBUG(D_tls) debug_printf(" null\n");
44662487 1344 return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
f5d78688 1345 }
018058b2 1346
f5d78688
JH
1347if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1348 {
018058b2 1349 tls_out.ocsp = OCSP_FAILED;
6c6d6e48 1350 if (LOGGING(tls_cipher))
1eca31ca 1351 log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
f5d78688
JH
1352 else
1353 DEBUG(D_tls) debug_printf(" parse error\n");
1354 return 0;
1355 }
1356
1357if(!(bs = OCSP_response_get1_basic(rsp)))
1358 {
018058b2 1359 tls_out.ocsp = OCSP_FAILED;
6c6d6e48 1360 if (LOGGING(tls_cipher))
1eca31ca 1361 log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
f5d78688
JH
1362 else
1363 DEBUG(D_tls) debug_printf(" error parsing response\n");
1364 OCSP_RESPONSE_free(rsp);
1365 return 0;
1366 }
1367
1368/* We'd check the nonce here if we'd put one in the request. */
1369/* However that would defeat cacheability on the server so we don't. */
1370
f5d78688
JH
1371/* This section of code reworked from OpenSSL apps source;
1372 The OpenSSL Project retains copyright:
1373 Copyright (c) 1999 The OpenSSL Project. All rights reserved.
1374*/
1375 {
1376 BIO * bp = NULL;
f5d78688
JH
1377 int status, reason;
1378 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1379
57887ecc 1380 DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
f5d78688
JH
1381
1382 /*OCSP_RESPONSE_print(bp, rsp, 0); extreme debug: stapling content */
1383
1384 /* Use the chain that verified the server cert to verify the stapled info */
1385 /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1386
c3033f13 1387 if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
44662487 1388 cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
f5d78688 1389 {
018058b2 1390 tls_out.ocsp = OCSP_FAILED;
57887ecc
JH
1391 if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1392 "Received TLS cert status response, itself unverifiable: %s",
1393 ERR_reason_error_string(ERR_peek_error()));
f5d78688
JH
1394 BIO_printf(bp, "OCSP response verify failure\n");
1395 ERR_print_errors(bp);
57887ecc 1396 OCSP_RESPONSE_print(bp, rsp, 0);
c8dfb21d 1397 goto failed;
f5d78688
JH
1398 }
1399
1400 BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1401
c8dfb21d
JH
1402 /*XXX So we have a good stapled OCSP status. How do we know
1403 it is for the cert of interest? OpenSSL 1.1.0 has a routine
1404 OCSP_resp_find_status() which matches on a cert id, which presumably
1405 we should use. Making an id needs OCSP_cert_id_new(), which takes
1406 issuerName, issuerKey, serialNumber. Are they all in the cert?
1407
1408 For now, carry on blindly accepting the resp. */
1409
f5d78688 1410 {
f5d78688
JH
1411 OCSP_SINGLERESP * single;
1412
c8dfb21d
JH
1413#ifdef EXIM_HAVE_OCSP_RESP_COUNT
1414 if (OCSP_resp_count(bs) != 1)
1415#else
1416 STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
f5d78688 1417 if (sk_OCSP_SINGLERESP_num(sresp) != 1)
c8dfb21d 1418#endif
f5d78688 1419 {
018058b2 1420 tls_out.ocsp = OCSP_FAILED;
44662487
JH
1421 log_write(0, LOG_MAIN, "OCSP stapling "
1422 "with multiple responses not handled");
c8dfb21d 1423 goto failed;
f5d78688
JH
1424 }
1425 single = OCSP_resp_get0(bs, 0);
44662487
JH
1426 status = OCSP_single_get0_status(single, &reason, &rev,
1427 &thisupd, &nextupd);
f5d78688
JH
1428 }
1429
f5d78688
JH
1430 DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1431 DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
44662487
JH
1432 if (!OCSP_check_validity(thisupd, nextupd,
1433 EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
f5d78688 1434 {
018058b2 1435 tls_out.ocsp = OCSP_FAILED;
f5d78688
JH
1436 DEBUG(D_tls) ERR_print_errors(bp);
1437 log_write(0, LOG_MAIN, "Server OSCP dates invalid");
f5d78688 1438 }
44662487 1439 else
f5d78688 1440 {
44662487
JH
1441 DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1442 OCSP_cert_status_str(status));
1443 switch(status)
1444 {
1445 case V_OCSP_CERTSTATUS_GOOD:
44662487 1446 tls_out.ocsp = OCSP_VFIED;
018058b2 1447 i = 1;
c8dfb21d 1448 goto good;
44662487 1449 case V_OCSP_CERTSTATUS_REVOKED:
018058b2 1450 tls_out.ocsp = OCSP_FAILED;
44662487
JH
1451 log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1452 reason != -1 ? "; reason: " : "",
1453 reason != -1 ? OCSP_crl_reason_str(reason) : "");
1454 DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
44662487
JH
1455 break;
1456 default:
018058b2 1457 tls_out.ocsp = OCSP_FAILED;
44662487
JH
1458 log_write(0, LOG_MAIN,
1459 "Server certificate status unknown, in OCSP stapling");
44662487
JH
1460 break;
1461 }
f5d78688 1462 }
c8dfb21d
JH
1463 failed:
1464 i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1465 good:
f5d78688
JH
1466 BIO_free(bp);
1467 }
1468
1469OCSP_RESPONSE_free(rsp);
1470return i;
1471}
f2de3a33 1472#endif /*!DISABLE_OCSP*/
3f7eeb86
PP
1473
1474
7be682ca 1475/*************************************************
059ec3d9
PH
1476* Initialize for TLS *
1477*************************************************/
1478
e51c7be2
JH
1479/* Called from both server and client code, to do preliminary initialization
1480of the library. We allocate and return a context structure.
059ec3d9
PH
1481
1482Arguments:
946ecbe0 1483 ctxp returned SSL context
059ec3d9
PH
1484 host connected host, if client; NULL if server
1485 dhparam DH parameter file
1486 certificate certificate file
1487 privatekey private key
f5d78688 1488 ocsp_file file of stapling info (server); flag for require ocsp (client)
059ec3d9 1489 addr address if client; NULL if server (for some randomness)
946ecbe0 1490 cbp place to put allocated callback context
cf0c6164 1491 errstr error string pointer
059ec3d9
PH
1492
1493Returns: OK/DEFER/FAIL
1494*/
1495
1496static int
817d9f57 1497tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
3f7eeb86 1498 uschar *privatekey,
f2de3a33 1499#ifndef DISABLE_OCSP
47195144 1500 uschar *ocsp_file, /*XXX stack, in server*/
3f7eeb86 1501#endif
cf0c6164 1502 address_item *addr, tls_ext_ctx_cb ** cbp, uschar ** errstr)
059ec3d9 1503{
7006ee24 1504SSL_CTX * ctx;
77bb000f 1505long init_options;
7be682ca 1506int rc;
a7538db1 1507tls_ext_ctx_cb * cbinfo;
7be682ca
PP
1508
1509cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1510cbinfo->certificate = certificate;
1511cbinfo->privatekey = privatekey;
a6510420 1512cbinfo->is_server = host==NULL;
f2de3a33 1513#ifndef DISABLE_OCSP
c3033f13 1514cbinfo->verify_stack = NULL;
a6510420 1515if (!host)
f5d78688
JH
1516 {
1517 cbinfo->u_ocsp.server.file = ocsp_file;
1518 cbinfo->u_ocsp.server.file_expanded = NULL;
1519 cbinfo->u_ocsp.server.response = NULL;
1520 }
1521else
1522 cbinfo->u_ocsp.client.verify_store = NULL;
3f7eeb86 1523#endif
7be682ca 1524cbinfo->dhparam = dhparam;
0df4ab80 1525cbinfo->server_cipher_list = NULL;
7be682ca 1526cbinfo->host = host;
0cbf2b82 1527#ifndef DISABLE_EVENT
a7538db1
JH
1528cbinfo->event_action = NULL;
1529#endif
77bb000f 1530
059ec3d9
PH
1531SSL_load_error_strings(); /* basic set up */
1532OpenSSL_add_ssl_algorithms();
1533
c8dfb21d 1534#ifdef EXIM_HAVE_SHA256
77bb000f 1535/* SHA256 is becoming ever more popular. This makes sure it gets added to the
a0475b69
TK
1536list of available digests. */
1537EVP_add_digest(EVP_sha256());
cf1ef1a9 1538#endif
a0475b69 1539
f0f5a555
PP
1540/* Create a context.
1541The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1542negotiation in the different methods; as far as I can tell, the only
1543*_{server,client}_method which allows negotiation is SSLv23, which exists even
1544when OpenSSL is built without SSLv2 support.
1545By disabling with openssl_options, we can let admins re-enable with the
1546existing knob. */
059ec3d9 1547
7006ee24
JH
1548if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1549 return tls_error(US"SSL_CTX_new", host, NULL, errstr);
059ec3d9
PH
1550
1551/* It turns out that we need to seed the random number generator this early in
1552order to get the full complement of ciphers to work. It took me roughly a day
1553of work to discover this by experiment.
1554
1555On systems that have /dev/urandom, SSL may automatically seed itself from
1556there. Otherwise, we have to make something up as best we can. Double check
1557afterwards. */
1558
1559if (!RAND_status())
1560 {
1561 randstuff r;
9e3331ea 1562 gettimeofday(&r.tv, NULL);
059ec3d9
PH
1563 r.p = getpid();
1564
5903c6ff
JH
1565 RAND_seed(US (&r), sizeof(r));
1566 RAND_seed(US big_buffer, big_buffer_size);
1567 if (addr != NULL) RAND_seed(US addr, sizeof(addr));
059ec3d9
PH
1568
1569 if (!RAND_status())
7199e1ee 1570 return tls_error(US"RAND_status", host,
cf0c6164 1571 US"unable to seed random number generator", errstr);
059ec3d9
PH
1572 }
1573
1574/* Set up the information callback, which outputs if debugging is at a suitable
1575level. */
1576
7006ee24 1577DEBUG(D_tls) SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
059ec3d9 1578
c80c5570 1579/* Automatically re-try reads/writes after renegotiation. */
7006ee24 1580(void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
c80c5570 1581
77bb000f
PP
1582/* Apply administrator-supplied work-arounds.
1583Historically we applied just one requested option,
1584SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1585moved to an administrator-controlled list of options to specify and
1586grandfathered in the first one as the default value for "openssl_options".
059ec3d9 1587
77bb000f
PP
1588No OpenSSL version number checks: the options we accept depend upon the
1589availability of the option value macros from OpenSSL. */
059ec3d9 1590
7006ee24 1591if (!tls_openssl_options_parse(openssl_options, &init_options))
cf0c6164 1592 return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
77bb000f
PP
1593
1594if (init_options)
1595 {
1596 DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
7006ee24 1597 if (!(SSL_CTX_set_options(ctx, init_options)))
77bb000f 1598 return tls_error(string_sprintf(
cf0c6164 1599 "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
77bb000f
PP
1600 }
1601else
1602 DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
059ec3d9 1603
7006ee24
JH
1604/* Disable session cache unconditionally */
1605
1606(void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1607
059ec3d9 1608/* Initialize with DH parameters if supplied */
10ca4f1c 1609/* Initialize ECDH temp key parameter selection */
059ec3d9 1610
7006ee24
JH
1611if ( !init_dh(ctx, dhparam, host, errstr)
1612 || !init_ecdh(ctx, host, errstr)
038597d2
PP
1613 )
1614 return DEFER;
059ec3d9 1615
3f7eeb86 1616/* Set up certificate and key (and perhaps OCSP info) */
059ec3d9 1617
7006ee24 1618if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
23bb6982 1619 return rc;
c91535f3 1620
c3033f13
JH
1621/* If we need to handle SNI or OCSP, do so */
1622
3bcbbbe2 1623#ifdef EXIM_HAVE_OPENSSL_TLSEXT
c3033f13
JH
1624# ifndef DISABLE_OCSP
1625 if (!(cbinfo->verify_stack = sk_X509_new_null()))
1626 {
1627 DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
1628 return FAIL;
1629 }
1630# endif
1631
f5d78688 1632if (host == NULL) /* server */
3f0945ff 1633 {
f2de3a33 1634# ifndef DISABLE_OCSP
f5d78688 1635 /* We check u_ocsp.server.file, not server.response, because we care about if
3f7eeb86
PP
1636 the option exists, not what the current expansion might be, as SNI might
1637 change the certificate and OCSP file in use between now and the time the
1638 callback is invoked. */
f5d78688 1639 if (cbinfo->u_ocsp.server.file)
3f7eeb86 1640 {
7006ee24
JH
1641 SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
1642 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
3f7eeb86 1643 }
f5d78688 1644# endif
3f0945ff
PP
1645 /* We always do this, so that $tls_sni is available even if not used in
1646 tls_certificate */
7006ee24
JH
1647 SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
1648 SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
3f0945ff 1649 }
f2de3a33 1650# ifndef DISABLE_OCSP
f5d78688
JH
1651else /* client */
1652 if(ocsp_file) /* wanting stapling */
1653 {
1654 if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
1655 {
1656 DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
1657 return FAIL;
1658 }
7006ee24
JH
1659 SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
1660 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
f5d78688
JH
1661 }
1662# endif
7be682ca 1663#endif
059ec3d9 1664
e51c7be2 1665cbinfo->verify_cert_hostnames = NULL;
e51c7be2 1666
c8dfb21d 1667#ifdef EXIM_HAVE_EPHEM_RSA_KEX
059ec3d9 1668/* Set up the RSA callback */
7006ee24 1669SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
c8dfb21d 1670#endif
059ec3d9
PH
1671
1672/* Finally, set the timeout, and we are done */
1673
7006ee24 1674SSL_CTX_set_timeout(ctx, ssl_session_timeout);
059ec3d9 1675DEBUG(D_tls) debug_printf("Initialized TLS\n");
7be682ca 1676
817d9f57 1677*cbp = cbinfo;
7006ee24 1678*ctxp = ctx;
7be682ca 1679
059ec3d9
PH
1680return OK;
1681}
1682
1683
1684
1685
1686/*************************************************
1687* Get name of cipher in use *
1688*************************************************/
1689
817d9f57 1690/*
059ec3d9 1691Argument: pointer to an SSL structure for the connection
817d9f57
JH
1692 buffer to use for answer
1693 size of buffer
1694 pointer to number of bits for cipher
059ec3d9
PH
1695Returns: nothing
1696*/
1697
1698static void
817d9f57 1699construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
059ec3d9 1700{
57b3a7f5
PP
1701/* With OpenSSL 1.0.0a, this needs to be const but the documentation doesn't
1702yet reflect that. It should be a safe change anyway, even 0.9.8 versions have
1703the accessor functions use const in the prototype. */
1704const SSL_CIPHER *c;
d9784128 1705const uschar *ver;
059ec3d9 1706
d9784128 1707ver = (const uschar *)SSL_get_version(ssl);
059ec3d9 1708
57b3a7f5 1709c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
817d9f57 1710SSL_CIPHER_get_bits(c, bits);
059ec3d9 1711
817d9f57
JH
1712string_format(cipherbuf, bsize, "%s:%s:%u", ver,
1713 SSL_CIPHER_get_name(c), *bits);
059ec3d9
PH
1714
1715DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
1716}
1717
1718
f69979cf
JH
1719static void
1720peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned bsize)
1721{
1722/*XXX we might consider a list-of-certs variable for the cert chain.
1723SSL_get_peer_cert_chain(SSL*). We'd need a new variable type and support
1724in list-handling functions, also consider the difference between the entire
1725chain and the elements sent by the peer. */
1726
1727/* Will have already noted peercert on a verify fail; possibly not the leaf */
1728if (!tlsp->peercert)
1729 tlsp->peercert = SSL_get_peer_certificate(ssl);
1730/* Beware anonymous ciphers which lead to server_cert being NULL */
1731if (tlsp->peercert)
1732 {
1733 X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, bsize);
1734 peerdn[bsize-1] = '\0';
1735 tlsp->peerdn = peerdn; /*XXX a static buffer... */
1736 }
1737else
1738 tlsp->peerdn = NULL;
1739}
1740
1741
059ec3d9
PH
1742
1743
1744
1745/*************************************************
1746* Set up for verifying certificates *
1747*************************************************/
1748
c3033f13
JH
1749/* Load certs from file, return TRUE on success */
1750
1751static BOOL
1752chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
1753{
1754BIO * bp;
1755X509 * x;
1756
dec766a1
WB
1757while (sk_X509_num(verify_stack) > 0)
1758 X509_free(sk_X509_pop(verify_stack));
1759
c3033f13
JH
1760if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
1761while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
1762 sk_X509_push(verify_stack, x);
1763BIO_free(bp);
1764return TRUE;
1765}
1766
1767
1768
dec766a1
WB
1769/* Called by both client and server startup; on the server possibly
1770repeated after a Server Name Indication.
059ec3d9
PH
1771
1772Arguments:
7be682ca 1773 sctx SSL_CTX* to initialise
059ec3d9
PH
1774 certs certs file or NULL
1775 crl CRL file or NULL
1776 host NULL in a server; the remote host in a client
1777 optional TRUE if called from a server for a host in tls_try_verify_hosts;
1778 otherwise passed as FALSE
983207c1 1779 cert_vfy_cb Callback function for certificate verification
cf0c6164 1780 errstr error string pointer
059ec3d9
PH
1781
1782Returns: OK/DEFER/FAIL
1783*/
1784
1785static int
983207c1 1786setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
cf0c6164 1787 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
059ec3d9
PH
1788{
1789uschar *expcerts, *expcrl;
1790
cf0c6164 1791if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
059ec3d9 1792 return DEFER;
57cc2785 1793DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
059ec3d9 1794
10a831a3 1795if (expcerts && *expcerts)
059ec3d9 1796 {
10a831a3
JH
1797 /* Tell the library to use its compiled-in location for the system default
1798 CA bundle. Then add the ones specified in the config, if any. */
cb1d7830 1799
10a831a3 1800 if (!SSL_CTX_set_default_verify_paths(sctx))
cf0c6164 1801 return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
10a831a3
JH
1802
1803 if (Ustrcmp(expcerts, "system") != 0)
059ec3d9 1804 {
cb1d7830
JH
1805 struct stat statbuf;
1806
cb1d7830
JH
1807 if (Ustat(expcerts, &statbuf) < 0)
1808 {
1809 log_write(0, LOG_MAIN|LOG_PANIC,
1810 "failed to stat %s for certificates", expcerts);
1811 return DEFER;
1812 }
059ec3d9 1813 else
059ec3d9 1814 {
cb1d7830
JH
1815 uschar *file, *dir;
1816 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1817 { file = NULL; dir = expcerts; }
1818 else
c3033f13
JH
1819 {
1820 file = expcerts; dir = NULL;
1821#ifndef DISABLE_OCSP
1822 /* In the server if we will be offering an OCSP proof, load chain from
1823 file for verifying the OCSP proof at load time. */
1824
1825 if ( !host
1826 && statbuf.st_size > 0
1827 && server_static_cbinfo->u_ocsp.server.file
1828 && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
1829 )
1830 {
1831 log_write(0, LOG_MAIN|LOG_PANIC,
57887ecc 1832 "failed to load cert chain from %s", file);
c3033f13
JH
1833 return DEFER;
1834 }
1835#endif
1836 }
cb1d7830
JH
1837
1838 /* If a certificate file is empty, the next function fails with an
1839 unhelpful error message. If we skip it, we get the correct behaviour (no
1840 certificates are recognized, but the error message is still misleading (it
c3033f13 1841 says no certificate was supplied). But this is better. */
cb1d7830 1842
f2f2c91b
JH
1843 if ( (!file || statbuf.st_size > 0)
1844 && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
cf0c6164 1845 return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
cb1d7830
JH
1846
1847 /* Load the list of CAs for which we will accept certs, for sending
1848 to the client. This is only for the one-file tls_verify_certificates
1849 variant.
1850 If a list isn't loaded into the server, but
1851 some verify locations are set, the server end appears to make
4c04137d 1852 a wildcard request for client certs.
10a831a3 1853 Meanwhile, the client library as default behaviour *ignores* the list
cb1d7830
JH
1854 we send over the wire - see man SSL_CTX_set_client_cert_cb.
1855 Because of this, and that the dir variant is likely only used for
1856 the public-CA bundle (not for a private CA), not worth fixing.
1857 */
f2f2c91b 1858 if (file)
cb1d7830 1859 {
2009ecca 1860 STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
dec766a1
WB
1861
1862 SSL_CTX_set_client_CA_list(sctx, names);
f2f2c91b 1863 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
cb1d7830 1864 sk_X509_NAME_num(names));
cb1d7830 1865 }
059ec3d9
PH
1866 }
1867 }
1868
1869 /* Handle a certificate revocation list. */
1870
10a831a3 1871#if OPENSSL_VERSION_NUMBER > 0x00907000L
059ec3d9 1872
8b417f2c 1873 /* This bit of code is now the version supplied by Lars Mainka. (I have
10a831a3 1874 merely reformatted it into the Exim code style.)
8b417f2c 1875
10a831a3
JH
1876 "From here I changed the code to add support for multiple crl's
1877 in pem format in one file or to support hashed directory entries in
1878 pem format instead of a file. This method now uses the library function
1879 X509_STORE_load_locations to add the CRL location to the SSL context.
1880 OpenSSL will then handle the verify against CA certs and CRLs by
1881 itself in the verify callback." */
8b417f2c 1882
cf0c6164 1883 if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
10a831a3 1884 if (expcrl && *expcrl)
059ec3d9 1885 {
8b417f2c
PH
1886 struct stat statbufcrl;
1887 if (Ustat(expcrl, &statbufcrl) < 0)
1888 {
1889 log_write(0, LOG_MAIN|LOG_PANIC,
1890 "failed to stat %s for certificates revocation lists", expcrl);
1891 return DEFER;
1892 }
1893 else
059ec3d9 1894 {
8b417f2c
PH
1895 /* is it a file or directory? */
1896 uschar *file, *dir;
7be682ca 1897 X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
8b417f2c 1898 if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
059ec3d9 1899 {
8b417f2c
PH
1900 file = NULL;
1901 dir = expcrl;
1902 DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
059ec3d9
PH
1903 }
1904 else
1905 {
8b417f2c
PH
1906 file = expcrl;
1907 dir = NULL;
1908 DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
059ec3d9 1909 }
8b417f2c 1910 if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
cf0c6164 1911 return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
8b417f2c
PH
1912
1913 /* setting the flags to check against the complete crl chain */
1914
1915 X509_STORE_set_flags(cvstore,
1916 X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
059ec3d9 1917 }
059ec3d9
PH
1918 }
1919
10a831a3 1920#endif /* OPENSSL_VERSION_NUMBER > 0x00907000L */
059ec3d9
PH
1921
1922 /* If verification is optional, don't fail if no certificate */
1923
7be682ca 1924 SSL_CTX_set_verify(sctx,
059ec3d9 1925 SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
983207c1 1926 cert_vfy_cb);
059ec3d9
PH
1927 }
1928
1929return OK;
1930}
1931
1932
1933
1934/*************************************************
1935* Start a TLS session in a server *
1936*************************************************/
1937
1938/* This is called when Exim is running as a server, after having received
1939the STARTTLS command. It must respond to that command, and then negotiate
1940a TLS session.
1941
1942Arguments:
1943 require_ciphers allowed ciphers
cf0c6164 1944 errstr pointer to error message
059ec3d9
PH
1945
1946Returns: OK on success
1947 DEFER for errors before the start of the negotiation
4c04137d 1948 FAIL for errors during the negotiation; the server can't
059ec3d9
PH
1949 continue running.
1950*/
1951
1952int
cf0c6164 1953tls_server_start(const uschar * require_ciphers, uschar ** errstr)
059ec3d9
PH
1954{
1955int rc;
cf0c6164
JH
1956uschar * expciphers;
1957tls_ext_ctx_cb * cbinfo;
f69979cf 1958static uschar peerdn[256];
817d9f57 1959static uschar cipherbuf[256];
059ec3d9
PH
1960
1961/* Check for previous activation */
1962
817d9f57 1963if (tls_in.active >= 0)
059ec3d9 1964 {
cf0c6164 1965 tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
925ac8e4 1966 smtp_printf("554 Already in TLS\r\n", FALSE);
059ec3d9
PH
1967 return FAIL;
1968 }
1969
1970/* Initialize the SSL library. If it fails, it will already have logged
1971the error. */
1972
817d9f57 1973rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
f2de3a33 1974#ifndef DISABLE_OCSP
47195144 1975 tls_ocsp_file, /*XXX stack*/
3f7eeb86 1976#endif
cf0c6164 1977 NULL, &server_static_cbinfo, errstr);
059ec3d9 1978if (rc != OK) return rc;
817d9f57 1979cbinfo = server_static_cbinfo;
059ec3d9 1980
cf0c6164 1981if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
059ec3d9
PH
1982 return FAIL;
1983
1984/* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
17c76198
PP
1985were historically separated by underscores. So that I can use either form in my
1986tests, and also for general convenience, we turn underscores into hyphens here.
1987*/
059ec3d9 1988
c3033f13 1989if (expciphers)
059ec3d9 1990 {
c3033f13 1991 uschar * s = expciphers;
059ec3d9
PH
1992 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1993 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
817d9f57 1994 if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
cf0c6164 1995 return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
7be682ca 1996 cbinfo->server_cipher_list = expciphers;
059ec3d9
PH
1997 }
1998
1999/* If this is a host for which certificate verification is mandatory or
2000optional, set up appropriately. */
2001
817d9f57 2002tls_in.certificate_verified = FALSE;
c0635b6d 2003#ifdef SUPPORT_DANE
53a7196b
JH
2004tls_in.dane_verified = FALSE;
2005#endif
a2ff477a 2006server_verify_callback_called = FALSE;
059ec3d9
PH
2007
2008if (verify_check_host(&tls_verify_hosts) == OK)
2009 {
983207c1 2010 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
cf0c6164 2011 FALSE, verify_callback_server, errstr);
059ec3d9 2012 if (rc != OK) return rc;
a2ff477a 2013 server_verify_optional = FALSE;
059ec3d9
PH
2014 }
2015else if (verify_check_host(&tls_try_verify_hosts) == OK)
2016 {
983207c1 2017 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
cf0c6164 2018 TRUE, verify_callback_server, errstr);
059ec3d9 2019 if (rc != OK) return rc;
a2ff477a 2020 server_verify_optional = TRUE;
059ec3d9
PH
2021 }
2022
2023/* Prepare for new connection */
2024
cf0c6164
JH
2025if (!(server_ssl = SSL_new(server_ctx)))
2026 return tls_error(US"SSL_new", NULL, NULL, errstr);
da3ad30d
PP
2027
2028/* Warning: we used to SSL_clear(ssl) here, it was removed.
2029 *
2030 * With the SSL_clear(), we get strange interoperability bugs with
2031 * OpenSSL 1.0.1b and TLS1.1/1.2. It looks as though this may be a bug in
2032 * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2033 *
2034 * The SSL_clear() call is to let an existing SSL* be reused, typically after
2035 * session shutdown. In this case, we have a brand new object and there's no
2036 * obvious reason to immediately clear it. I'm guessing that this was
2037 * originally added because of incomplete initialisation which the clear fixed,
2038 * in some historic release.
2039 */
059ec3d9
PH
2040
2041/* Set context and tell client to go ahead, except in the case of TLS startup
2042on connection, where outputting anything now upsets the clients and tends to
2043make them disconnect. We need to have an explicit fflush() here, to force out
2044the response. Other smtp_printf() calls do not need it, because in non-TLS
2045mode, the fflush() happens when smtp_getc() is called. */
2046
817d9f57
JH
2047SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2048if (!tls_in.on_connect)
059ec3d9 2049 {
925ac8e4 2050 smtp_printf("220 TLS go ahead\r\n", FALSE);
059ec3d9
PH
2051 fflush(smtp_out);
2052 }
2053
2054/* Now negotiate the TLS session. We put our own timer on it, since it seems
2055that the OpenSSL library doesn't. */
2056
817d9f57
JH
2057SSL_set_wfd(server_ssl, fileno(smtp_out));
2058SSL_set_rfd(server_ssl, fileno(smtp_in));
2059SSL_set_accept_state(server_ssl);
059ec3d9
PH
2060
2061DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2062
2063sigalrm_seen = FALSE;
2064if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
817d9f57 2065rc = SSL_accept(server_ssl);
059ec3d9
PH
2066alarm(0);
2067
2068if (rc <= 0)
2069 {
cf0c6164 2070 (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
059ec3d9
PH
2071 return FAIL;
2072 }
2073
2074DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2075
2076/* TLS has been set up. Adjust the input functions to read via TLS,
2077and initialize things. */
2078
f69979cf
JH
2079peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2080
817d9f57
JH
2081construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
2082tls_in.cipher = cipherbuf;
059ec3d9
PH
2083
2084DEBUG(D_tls)
2085 {
2086 uschar buf[2048];
817d9f57 2087 if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
059ec3d9
PH
2088 debug_printf("Shared ciphers: %s\n", buf);
2089 }
2090
9d1c15ef
JH
2091/* Record the certificate we presented */
2092 {
2093 X509 * crt = SSL_get_certificate(server_ssl);
2094 tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2095 }
059ec3d9 2096
817d9f57
JH
2097/* Only used by the server-side tls (tls_in), including tls_getc.
2098 Client-side (tls_out) reads (seem to?) go via
2099 smtp_read_response()/ip_recv().
2100 Hence no need to duplicate for _in and _out.
2101 */
b808677c 2102if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
059ec3d9 2103ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
8b77d27a 2104ssl_xfer_eof = ssl_xfer_error = FALSE;
059ec3d9
PH
2105
2106receive_getc = tls_getc;
0d81dabc 2107receive_getbuf = tls_getbuf;
584e96c6 2108receive_get_cache = tls_get_cache;
059ec3d9
PH
2109receive_ungetc = tls_ungetc;
2110receive_feof = tls_feof;
2111receive_ferror = tls_ferror;
58eb016e 2112receive_smtp_buffered = tls_smtp_buffered;
059ec3d9 2113
817d9f57 2114tls_in.active = fileno(smtp_out);
059ec3d9
PH
2115return OK;
2116}
2117
2118
2119
2120
043b1248
JH
2121static int
2122tls_client_basic_ctx_init(SSL_CTX * ctx,
cf0c6164
JH
2123 host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2124 uschar ** errstr)
043b1248
JH
2125{
2126int rc;
94431adb 2127/* stick to the old behaviour for compatibility if tls_verify_certificates is
043b1248
JH
2128 set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2129 the specified host patterns if one of them is defined */
2130
610ff438
JH
2131if ( ( !ob->tls_verify_hosts
2132 && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2133 )
5130845b 2134 || (verify_check_given_host(&ob->tls_verify_hosts, host) == OK)
aa2a70ba 2135 )
043b1248 2136 client_verify_optional = FALSE;
5130845b 2137else if (verify_check_given_host(&ob->tls_try_verify_hosts, host) == OK)
aa2a70ba
JH
2138 client_verify_optional = TRUE;
2139else
2140 return OK;
2141
2142if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
cf0c6164
JH
2143 ob->tls_crl, host, client_verify_optional, verify_callback_client,
2144 errstr)) != OK)
aa2a70ba 2145 return rc;
043b1248 2146
5130845b 2147if (verify_check_given_host(&ob->tls_verify_cert_hostnames, host) == OK)
043b1248 2148 {
4af0d74a 2149 cbinfo->verify_cert_hostnames =
8c5d388a 2150#ifdef SUPPORT_I18N
4af0d74a
JH
2151 string_domain_utf8_to_alabel(host->name, NULL);
2152#else
2153 host->name;
2154#endif
aa2a70ba
JH
2155 DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2156 cbinfo->verify_cert_hostnames);
043b1248 2157 }
043b1248
JH
2158return OK;
2159}
059ec3d9 2160
fde080a4 2161
c0635b6d 2162#ifdef SUPPORT_DANE
fde080a4 2163static int
cf0c6164 2164dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
fde080a4
JH
2165{
2166dns_record * rr;
2167dns_scan dnss;
2168const char * hostnames[2] = { CS host->name, NULL };
2169int found = 0;
2170
2171if (DANESSL_init(ssl, NULL, hostnames) != 1)
cf0c6164 2172 return tls_error(US"hostnames load", host, NULL, errstr);
fde080a4
JH
2173
2174for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2175 rr;
2176 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2177 ) if (rr->type == T_TLSA)
2178 {
c3033f13 2179 const uschar * p = rr->data;
fde080a4
JH
2180 uint8_t usage, selector, mtype;
2181 const char * mdname;
2182
fde080a4 2183 usage = *p++;
133d2546
JH
2184
2185 /* Only DANE-TA(2) and DANE-EE(3) are supported */
2186 if (usage != 2 && usage != 3) continue;
2187
fde080a4
JH
2188 selector = *p++;
2189 mtype = *p++;
2190
2191 switch (mtype)
2192 {
133d2546
JH
2193 default: continue; /* Only match-types 0, 1, 2 are supported */
2194 case 0: mdname = NULL; break;
2195 case 1: mdname = "sha256"; break;
2196 case 2: mdname = "sha512"; break;
fde080a4
JH
2197 }
2198
133d2546 2199 found++;
fde080a4
JH
2200 switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2201 {
2202 default:
cf0c6164 2203 return tls_error(US"tlsa load", host, NULL, errstr);
c035b645 2204 case 0: /* action not taken */
fde080a4
JH
2205 case 1: break;
2206 }
594706ea
JH
2207
2208 tls_out.tlsa_usage |= 1<<usage;
fde080a4
JH
2209 }
2210
2211if (found)
2212 return OK;
2213
133d2546 2214log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
6ebd79ec 2215return DEFER;
fde080a4 2216}
c0635b6d 2217#endif /*SUPPORT_DANE*/
fde080a4
JH
2218
2219
2220
059ec3d9
PH
2221/*************************************************
2222* Start a TLS session in a client *
2223*************************************************/
2224
2225/* Called from the smtp transport after STARTTLS has been accepted.
2226
2227Argument:
2228 fd the fd of the connection
2229 host connected host (for messages)
83da1223 2230 addr the first address
a7538db1 2231 tb transport (always smtp)
0e66b3b6 2232 tlsa_dnsa tlsa lookup, if DANE, else null
cf0c6164 2233 errstr error string pointer
059ec3d9
PH
2234
2235Returns: OK on success
2236 FAIL otherwise - note that tls_error() will not give DEFER
2237 because this is not a server
2238*/
2239
2240int
f5d78688 2241tls_client_start(int fd, host_item *host, address_item *addr,
cf0c6164 2242 transport_instance * tb,
c0635b6d 2243#ifdef SUPPORT_DANE
cf0c6164 2244 dns_answer * tlsa_dnsa,
0e66b3b6 2245#endif
cf0c6164 2246 uschar ** errstr)
059ec3d9 2247{
a7538db1
JH
2248smtp_transport_options_block * ob =
2249 (smtp_transport_options_block *)tb->options_block;
f69979cf 2250static uschar peerdn[256];
868f5672 2251uschar * expciphers;
059ec3d9 2252int rc;
817d9f57 2253static uschar cipherbuf[256];
043b1248
JH
2254
2255#ifndef DISABLE_OCSP
043b1248 2256BOOL request_ocsp = FALSE;
6634ac8d 2257BOOL require_ocsp = FALSE;
043b1248 2258#endif
043b1248 2259
c0635b6d 2260#ifdef SUPPORT_DANE
594706ea 2261tls_out.tlsa_usage = 0;
043b1248
JH
2262#endif
2263
f2de3a33 2264#ifndef DISABLE_OCSP
043b1248 2265 {
c0635b6d 2266# ifdef SUPPORT_DANE
4f59c424
JH
2267 if ( tlsa_dnsa
2268 && ob->hosts_request_ocsp[0] == '*'
2269 && ob->hosts_request_ocsp[1] == '\0'
2270 )
2271 {
2272 /* Unchanged from default. Use a safer one under DANE */
2273 request_ocsp = TRUE;
2274 ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2275 " {= {4}{$tls_out_tlsa_usage}} } "
2276 " {*}{}}";
2277 }
2278# endif
2279
5130845b
JH
2280 if ((require_ocsp =
2281 verify_check_given_host(&ob->hosts_require_ocsp, host) == OK))
fca41d5a
JH
2282 request_ocsp = TRUE;
2283 else
c0635b6d 2284# ifdef SUPPORT_DANE
4f59c424 2285 if (!request_ocsp)
fca41d5a 2286# endif
5130845b
JH
2287 request_ocsp =
2288 verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
043b1248 2289 }
f5d78688 2290#endif
059ec3d9 2291
65867078
JH
2292rc = tls_init(&client_ctx, host, NULL,
2293 ob->tls_certificate, ob->tls_privatekey,
f2de3a33 2294#ifndef DISABLE_OCSP
44662487 2295 (void *)(long)request_ocsp,
3f7eeb86 2296#endif
cf0c6164 2297 addr, &client_static_cbinfo, errstr);
059ec3d9
PH
2298if (rc != OK) return rc;
2299
817d9f57 2300tls_out.certificate_verified = FALSE;
a2ff477a 2301client_verify_callback_called = FALSE;
059ec3d9 2302
65867078 2303if (!expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
cf0c6164 2304 &expciphers, errstr))
059ec3d9
PH
2305 return FAIL;
2306
2307/* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2308are separated by underscores. So that I can use either form in my tests, and
2309also for general convenience, we turn underscores into hyphens here. */
2310
cf0c6164 2311if (expciphers)
059ec3d9
PH
2312 {
2313 uschar *s = expciphers;
cf0c6164 2314 while (*s) { if (*s == '_') *s = '-'; s++; }
059ec3d9 2315 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
817d9f57 2316 if (!SSL_CTX_set_cipher_list(client_ctx, CS expciphers))
cf0c6164 2317 return tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
059ec3d9
PH
2318 }
2319
c0635b6d 2320#ifdef SUPPORT_DANE
0e66b3b6 2321if (tlsa_dnsa)
a63be306 2322 {
02af313d
JH
2323 SSL_CTX_set_verify(client_ctx,
2324 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2325 verify_callback_client_dane);
e5cccda9 2326
043b1248 2327 if (!DANESSL_library_init())
cf0c6164 2328 return tls_error(US"library init", host, NULL, errstr);
043b1248 2329 if (DANESSL_CTX_init(client_ctx) <= 0)
cf0c6164 2330 return tls_error(US"context init", host, NULL, errstr);
043b1248
JH
2331 }
2332else
e51c7be2 2333
043b1248
JH
2334#endif
2335
cf0c6164
JH
2336 if ((rc = tls_client_basic_ctx_init(client_ctx, host, ob,
2337 client_static_cbinfo, errstr)) != OK)
65867078 2338 return rc;
059ec3d9 2339
65867078 2340if ((client_ssl = SSL_new(client_ctx)) == NULL)
cf0c6164 2341 return tls_error(US"SSL_new", host, NULL, errstr);
817d9f57
JH
2342SSL_set_session_id_context(client_ssl, sid_ctx, Ustrlen(sid_ctx));
2343SSL_set_fd(client_ssl, fd);
2344SSL_set_connect_state(client_ssl);
059ec3d9 2345
65867078 2346if (ob->tls_sni)
3f0945ff 2347 {
cf0c6164 2348 if (!expand_check(ob->tls_sni, US"tls_sni", &tls_out.sni, errstr))
3f0945ff 2349 return FAIL;
cf0c6164 2350 if (!tls_out.sni)
2c9a0e86
PP
2351 {
2352 DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
2353 }
ec4b68e5 2354 else if (!Ustrlen(tls_out.sni))
817d9f57 2355 tls_out.sni = NULL;
3f0945ff
PP
2356 else
2357 {
35731706 2358#ifdef EXIM_HAVE_OPENSSL_TLSEXT
817d9f57
JH
2359 DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_out.sni);
2360 SSL_set_tlsext_host_name(client_ssl, tls_out.sni);
35731706 2361#else
66802652 2362 log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
02d9264f 2363 tls_out.sni);
35731706 2364#endif
3f0945ff
PP
2365 }
2366 }
2367
c0635b6d 2368#ifdef SUPPORT_DANE
0e66b3b6 2369if (tlsa_dnsa)
cf0c6164 2370 if ((rc = dane_tlsa_load(client_ssl, host, tlsa_dnsa, errstr)) != OK)
594706ea
JH
2371 return rc;
2372#endif
2373
f2de3a33 2374#ifndef DISABLE_OCSP
f5d78688
JH
2375/* Request certificate status at connection-time. If the server
2376does OCSP stapling we will get the callback (set in tls_init()) */
c0635b6d 2377# ifdef SUPPORT_DANE
44662487
JH
2378if (request_ocsp)
2379 {
594706ea 2380 const uschar * s;
41afb5cb
JH
2381 if ( ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2382 || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
594706ea
JH
2383 )
2384 { /* Re-eval now $tls_out_tlsa_usage is populated. If
2385 this means we avoid the OCSP request, we wasted the setup
2386 cost in tls_init(). */
5130845b
JH
2387 require_ocsp = verify_check_given_host(&ob->hosts_require_ocsp, host) == OK;
2388 request_ocsp = require_ocsp
2389 || verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
594706ea
JH
2390 }
2391 }
b50c8b84
JH
2392# endif
2393
594706ea
JH
2394if (request_ocsp)
2395 {
f5d78688 2396 SSL_set_tlsext_status_type(client_ssl, TLSEXT_STATUSTYPE_ocsp);
44662487
JH
2397 client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
2398 tls_out.ocsp = OCSP_NOT_RESP;
2399 }
f5d78688
JH
2400#endif
2401
0cbf2b82 2402#ifndef DISABLE_EVENT
774ef2d7 2403client_static_cbinfo->event_action = tb->event_action;
a7538db1 2404#endif
043b1248 2405
059ec3d9
PH
2406/* There doesn't seem to be a built-in timeout on connection. */
2407
2408DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
2409sigalrm_seen = FALSE;
65867078 2410alarm(ob->command_timeout);
817d9f57 2411rc = SSL_connect(client_ssl);
059ec3d9
PH
2412alarm(0);
2413
c0635b6d 2414#ifdef SUPPORT_DANE
0e66b3b6 2415if (tlsa_dnsa)
fde080a4 2416 DANESSL_cleanup(client_ssl);
043b1248
JH
2417#endif
2418
059ec3d9 2419if (rc <= 0)
cf0c6164
JH
2420 return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL,
2421 errstr);
059ec3d9
PH
2422
2423DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
2424
f69979cf 2425peer_cert(client_ssl, &tls_out, peerdn, sizeof(peerdn));
059ec3d9 2426
817d9f57
JH
2427construct_cipher_name(client_ssl, cipherbuf, sizeof(cipherbuf), &tls_out.bits);
2428tls_out.cipher = cipherbuf;
059ec3d9 2429
9d1c15ef
JH
2430/* Record the certificate we presented */
2431 {
2432 X509 * crt = SSL_get_certificate(client_ssl);
2433 tls_out.ourcert = crt ? X509_dup(crt) : NULL;
2434 }
2435
817d9f57 2436tls_out.active = fd;
059ec3d9
PH
2437return OK;
2438}
2439
2440
2441
2442
2443
0d81dabc
JH
2444static BOOL
2445tls_refill(unsigned lim)
2446{
2447int error;
2448int inbytes;
2449
2450DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2451 ssl_xfer_buffer, ssl_xfer_buffer_size);
2452
2453if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2454inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
2455 MIN(ssl_xfer_buffer_size, lim));
2456error = SSL_get_error(server_ssl, inbytes);
2457alarm(0);
2458
2459/* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2460closed down, not that the socket itself has been closed down. Revert to
2461non-SSL handling. */
2462
2463if (error == SSL_ERROR_ZERO_RETURN)
2464 {
2465 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2466
2467 receive_getc = smtp_getc;
2468 receive_getbuf = smtp_getbuf;
2469 receive_get_cache = smtp_get_cache;
2470 receive_ungetc = smtp_ungetc;
2471 receive_feof = smtp_feof;
2472 receive_ferror = smtp_ferror;
2473 receive_smtp_buffered = smtp_buffered;
2474
dec766a1
WB
2475 if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2476 SSL_shutdown(server_ssl);
2477
2478 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
0d81dabc 2479 SSL_free(server_ssl);
dec766a1
WB
2480 SSL_CTX_free(server_ctx);
2481 server_static_cbinfo->verify_stack = NULL;
dec766a1 2482 server_ctx = NULL;
0d81dabc
JH
2483 server_ssl = NULL;
2484 tls_in.active = -1;
2485 tls_in.bits = 0;
2486 tls_in.cipher = NULL;
2487 tls_in.peerdn = NULL;
2488 tls_in.sni = NULL;
2489
2490 return FALSE;
2491 }
2492
2493/* Handle genuine errors */
2494
2495else if (error == SSL_ERROR_SSL)
2496 {
2497 ERR_error_string(ERR_get_error(), ssl_errstring);
2498 log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
8b77d27a 2499 ssl_xfer_error = TRUE;
0d81dabc
JH
2500 return FALSE;
2501 }
2502
2503else if (error != SSL_ERROR_NONE)
2504 {
2505 DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
8b77d27a 2506 ssl_xfer_error = TRUE;
0d81dabc
JH
2507 return FALSE;
2508 }
2509
2510#ifndef DISABLE_DKIM
2511dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2512#endif
2513ssl_xfer_buffer_hwm = inbytes;
2514ssl_xfer_buffer_lwm = 0;
2515return TRUE;
2516}
2517
2518
059ec3d9
PH
2519/*************************************************
2520* TLS version of getc *
2521*************************************************/
2522
2523/* This gets the next byte from the TLS input buffer. If the buffer is empty,
2524it refills the buffer via the SSL reading function.
2525
bd8fbe36 2526Arguments: lim Maximum amount to read/buffer
059ec3d9 2527Returns: the next character or EOF
817d9f57
JH
2528
2529Only used by the server-side TLS.
059ec3d9
PH
2530*/
2531
2532int
bd8fbe36 2533tls_getc(unsigned lim)
059ec3d9
PH
2534{
2535if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
0d81dabc
JH
2536 if (!tls_refill(lim))
2537 return ssl_xfer_error ? EOF : smtp_getc(lim);
059ec3d9 2538
0d81dabc 2539/* Something in the buffer; return next uschar */
059ec3d9 2540
0d81dabc
JH
2541return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2542}
059ec3d9 2543
0d81dabc
JH
2544uschar *
2545tls_getbuf(unsigned * len)
2546{
2547unsigned size;
2548uschar * buf;
ba084640 2549
0d81dabc
JH
2550if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2551 if (!tls_refill(*len))
059ec3d9 2552 {
0d81dabc
JH
2553 if (!ssl_xfer_error) return smtp_getbuf(len);
2554 *len = 0;
2555 return NULL;
059ec3d9 2556 }
c80c5570 2557
0d81dabc
JH
2558if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
2559 size = *len;
2560buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
2561ssl_xfer_buffer_lwm += size;
2562*len = size;
2563return buf;
059ec3d9
PH
2564}
2565
0d81dabc 2566
584e96c6
JH
2567void
2568tls_get_cache()
2569{
9960d1e5 2570#ifndef DISABLE_DKIM
584e96c6
JH
2571int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
2572if (n > 0)
2573 dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
584e96c6 2574#endif
9960d1e5 2575}
584e96c6 2576
059ec3d9 2577
925ac8e4
JH
2578BOOL
2579tls_could_read(void)
2580{
a5ffa9b4 2581return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
925ac8e4
JH
2582}
2583
059ec3d9
PH
2584
2585/*************************************************
2586* Read bytes from TLS channel *
2587*************************************************/
2588
2589/*
2590Arguments:
2591 buff buffer of data
2592 len size of buffer
2593
2594Returns: the number of bytes read
2595 -1 after a failed read
817d9f57
JH
2596
2597Only used by the client-side TLS.
059ec3d9
PH
2598*/
2599
2600int
389ca47a 2601tls_read(BOOL is_server, uschar *buff, size_t len)
059ec3d9 2602{
389ca47a 2603SSL *ssl = is_server ? server_ssl : client_ssl;
059ec3d9
PH
2604int inbytes;
2605int error;
2606
389ca47a 2607DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
c80c5570 2608 buff, (unsigned int)len);
059ec3d9 2609
389ca47a
JH
2610inbytes = SSL_read(ssl, CS buff, len);
2611error = SSL_get_error(ssl, inbytes);
059ec3d9
PH
2612
2613if (error == SSL_ERROR_ZERO_RETURN)
2614 {
2615 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2616 return -1;
2617 }
2618else if (error != SSL_ERROR_NONE)
059ec3d9 2619 return -1;
059ec3d9
PH
2620
2621return inbytes;
2622}
2623
2624
2625
2626
2627
2628/*************************************************
2629* Write bytes down TLS channel *
2630*************************************************/
2631
2632/*
2633Arguments:
817d9f57 2634 is_server channel specifier
059ec3d9
PH
2635 buff buffer of data
2636 len number of bytes
925ac8e4 2637 more further data expected soon
059ec3d9
PH
2638
2639Returns: the number of bytes after a successful write,
2640 -1 after a failed write
817d9f57
JH
2641
2642Used by both server-side and client-side TLS.
059ec3d9
PH
2643*/
2644
2645int
925ac8e4 2646tls_write(BOOL is_server, const uschar *buff, size_t len, BOOL more)
059ec3d9 2647{
a5ffa9b4 2648int outbytes, error, left;
817d9f57 2649SSL *ssl = is_server ? server_ssl : client_ssl;
acec9514 2650static gstring * corked = NULL;
a5ffa9b4 2651
ef698bf6 2652DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
b93be52e 2653 buff, (unsigned long)len, more ? ", more" : "");
a5ffa9b4
JH
2654
2655/* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
2656"more" is notified. This hack is only ok if small amounts are involved AND only
2657one stream does it, in one context (i.e. no store reset). Currently it is used
2658for the responses to the received SMTP MAIL , RCPT, DATA sequence, only. */
2659
2660if (is_server && (more || corked))
2661 {
acec9514 2662 corked = string_catn(corked, buff, len);
a5ffa9b4
JH
2663 if (more)
2664 return len;
acec9514
JH
2665 buff = CUS corked->s;
2666 len = corked->ptr;
2667 corked = NULL;
a5ffa9b4 2668 }
059ec3d9 2669
a5ffa9b4 2670for (left = len; left > 0;)
059ec3d9 2671 {
c80c5570 2672 DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
059ec3d9
PH
2673 outbytes = SSL_write(ssl, CS buff, left);
2674 error = SSL_get_error(ssl, outbytes);
2675 DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2676 switch (error)
2677 {
2678 case SSL_ERROR_SSL:
96f5fe4c
JH
2679 ERR_error_string(ERR_get_error(), ssl_errstring);
2680 log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2681 return -1;
059ec3d9
PH
2682
2683 case SSL_ERROR_NONE:
96f5fe4c
JH
2684 left -= outbytes;
2685 buff += outbytes;
2686 break;
059ec3d9
PH
2687
2688 case SSL_ERROR_ZERO_RETURN:
96f5fe4c
JH
2689 log_write(0, LOG_MAIN, "SSL channel closed on write");
2690 return -1;
059ec3d9 2691
817d9f57 2692 case SSL_ERROR_SYSCALL:
96f5fe4c
JH
2693 log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2694 sender_fullhost ? sender_fullhost : US"<unknown>",
2695 strerror(errno));
2696 return -1;
817d9f57 2697
059ec3d9 2698 default:
96f5fe4c
JH
2699 log_write(0, LOG_MAIN, "SSL_write error %d", error);
2700 return -1;
059ec3d9
PH
2701 }
2702 }
2703return len;
2704}
2705
2706
2707
2708/*************************************************
2709* Close down a TLS session *
2710*************************************************/
2711
2712/* This is also called from within a delivery subprocess forked from the
2713daemon, to shut down the TLS library, without actually doing a shutdown (which
2714would tamper with the SSL session in the parent process).
2715
dec766a1
WB
2716Arguments:
2717 shutdown 1 if TLS close-alert is to be sent,
2718 2 if also response to be waited for
2719
059ec3d9 2720Returns: nothing
817d9f57
JH
2721
2722Used by both server-side and client-side TLS.
059ec3d9
PH
2723*/
2724
2725void
dec766a1 2726tls_close(BOOL is_server, int shutdown)
059ec3d9 2727{
dec766a1 2728SSL_CTX **ctxp = is_server ? &server_ctx : &client_ctx;
817d9f57 2729SSL **sslp = is_server ? &server_ssl : &client_ssl;
389ca47a 2730int *fdp = is_server ? &tls_in.active : &tls_out.active;
817d9f57
JH
2731
2732if (*fdp < 0) return; /* TLS was not active */
059ec3d9
PH
2733
2734if (shutdown)
2735 {
dec766a1
WB
2736 int rc;
2737 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
2738 shutdown > 1 ? " (with response-wait)" : "");
2739
2740 if ( (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
2741 && shutdown > 1)
2742 {
2743 alarm(2);
2744 rc = SSL_shutdown(*sslp); /* wait for response */
2745 alarm(0);
2746 }
2747
2748 if (rc < 0) DEBUG(D_tls)
2749 {
2750 ERR_error_string(ERR_get_error(), ssl_errstring);
2751 debug_printf("SSL_shutdown: %s\n", ssl_errstring);
2752 }
2753 }
2754
2755if (is_server)
2756 {
2757 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
dec766a1 2758 server_static_cbinfo->verify_stack = NULL;
059ec3d9
PH
2759 }
2760
dec766a1 2761SSL_CTX_free(*ctxp);
817d9f57 2762SSL_free(*sslp);
dec766a1 2763*ctxp = NULL;
817d9f57 2764*sslp = NULL;
817d9f57 2765*fdp = -1;
059ec3d9
PH
2766}
2767
36f12725
NM
2768
2769
2770
2771/*************************************************
3375e053
PP
2772* Let tls_require_ciphers be checked at startup *
2773*************************************************/
2774
2775/* The tls_require_ciphers option, if set, must be something which the
2776library can parse.
2777
2778Returns: NULL on success, or error message
2779*/
2780
2781uschar *
2782tls_validate_require_cipher(void)
2783{
2784SSL_CTX *ctx;
2785uschar *s, *expciphers, *err;
2786
2787/* this duplicates from tls_init(), we need a better "init just global
2788state, for no specific purpose" singleton function of our own */
2789
2790SSL_load_error_strings();
2791OpenSSL_add_ssl_algorithms();
2792#if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
2793/* SHA256 is becoming ever more popular. This makes sure it gets added to the
2794list of available digests. */
2795EVP_add_digest(EVP_sha256());
2796#endif
2797
2798if (!(tls_require_ciphers && *tls_require_ciphers))
2799 return NULL;
2800
cf0c6164
JH
2801if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
2802 &err))
3375e053
PP
2803 return US"failed to expand tls_require_ciphers";
2804
2805if (!(expciphers && *expciphers))
2806 return NULL;
2807
2808/* normalisation ripped from above */
2809s = expciphers;
2810while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2811
2812err = NULL;
2813
2814ctx = SSL_CTX_new(SSLv23_server_method());
2815if (!ctx)
2816 {
2817 ERR_error_string(ERR_get_error(), ssl_errstring);
2818 return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
2819 }
2820
2821DEBUG(D_tls)
2822 debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
2823
2824if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
2825 {
2826 ERR_error_string(ERR_get_error(), ssl_errstring);
cf0c6164
JH
2827 err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
2828 expciphers, ssl_errstring);
3375e053
PP
2829 }
2830
2831SSL_CTX_free(ctx);
2832
2833return err;
2834}
2835
2836
2837
2838
2839/*************************************************
36f12725
NM
2840* Report the library versions. *
2841*************************************************/
2842
2843/* There have historically been some issues with binary compatibility in
2844OpenSSL libraries; if Exim (like many other applications) is built against
2845one version of OpenSSL but the run-time linker picks up another version,
2846it can result in serious failures, including crashing with a SIGSEGV. So
2847report the version found by the compiler and the run-time version.
2848
f64a1e23
PP
2849Note: some OS vendors backport security fixes without changing the version
2850number/string, and the version date remains unchanged. The _build_ date
2851will change, so we can more usefully assist with version diagnosis by also
2852reporting the build date.
2853
36f12725
NM
2854Arguments: a FILE* to print the results to
2855Returns: nothing
2856*/
2857
2858void
2859tls_version_report(FILE *f)
2860{
754a0503 2861fprintf(f, "Library version: OpenSSL: Compile: %s\n"
f64a1e23
PP
2862 " Runtime: %s\n"
2863 " : %s\n",
754a0503 2864 OPENSSL_VERSION_TEXT,
f64a1e23
PP
2865 SSLeay_version(SSLEAY_VERSION),
2866 SSLeay_version(SSLEAY_BUILT_ON));
2867/* third line is 38 characters for the %s and the line is 73 chars long;
2868the OpenSSL output includes a "built on: " prefix already. */
36f12725
NM
2869}
2870
9e3331ea
TK
2871
2872
2873
2874/*************************************************
17c76198 2875* Random number generation *
9e3331ea
TK
2876*************************************************/
2877
2878/* Pseudo-random number generation. The result is not expected to be
2879cryptographically strong but not so weak that someone will shoot themselves
2880in the foot using it as a nonce in input in some email header scheme or
2881whatever weirdness they'll twist this into. The result should handle fork()
2882and avoid repeating sequences. OpenSSL handles that for us.
2883
2884Arguments:
2885 max range maximum
2886Returns a random number in range [0, max-1]
2887*/
2888
2889int
17c76198 2890vaguely_random_number(int max)
9e3331ea
TK
2891{
2892unsigned int r;
2893int i, needed_len;
de6135a0
PP
2894static pid_t pidlast = 0;
2895pid_t pidnow;
9e3331ea
TK
2896uschar *p;
2897uschar smallbuf[sizeof(r)];
2898
2899if (max <= 1)
2900 return 0;
2901
de6135a0
PP
2902pidnow = getpid();
2903if (pidnow != pidlast)
2904 {
2905 /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
2906 is unique for each thread", this doesn't apparently apply across processes,
2907 so our own warning from vaguely_random_number_fallback() applies here too.
2908 Fix per PostgreSQL. */
2909 if (pidlast != 0)
2910 RAND_cleanup();
2911 pidlast = pidnow;
2912 }
2913
9e3331ea
TK
2914/* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
2915if (!RAND_status())
2916 {
2917 randstuff r;
2918 gettimeofday(&r.tv, NULL);
2919 r.p = getpid();
2920
5903c6ff 2921 RAND_seed(US (&r), sizeof(r));
9e3331ea
TK
2922 }
2923/* We're after pseudo-random, not random; if we still don't have enough data
2924in the internal PRNG then our options are limited. We could sleep and hope
2925for entropy to come along (prayer technique) but if the system is so depleted
2926in the first place then something is likely to just keep taking it. Instead,
2927we'll just take whatever little bit of pseudo-random we can still manage to
2928get. */
2929
2930needed_len = sizeof(r);
2931/* Don't take 8 times more entropy than needed if int is 8 octets and we were
2932asked for a number less than 10. */
2933for (r = max, i = 0; r; ++i)
2934 r >>= 1;
2935i = (i + 7) / 8;
2936if (i < needed_len)
2937 needed_len = i;
2938
c8dfb21d 2939#ifdef EXIM_HAVE_RAND_PSEUDO
9e3331ea 2940/* We do not care if crypto-strong */
17c76198 2941i = RAND_pseudo_bytes(smallbuf, needed_len);
c8dfb21d
JH
2942#else
2943i = RAND_bytes(smallbuf, needed_len);
2944#endif
2945
17c76198
PP
2946if (i < 0)
2947 {
2948 DEBUG(D_all)
2949 debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
2950 return vaguely_random_number_fallback(max);
2951 }
2952
9e3331ea
TK
2953r = 0;
2954for (p = smallbuf; needed_len; --needed_len, ++p)
2955 {
2956 r *= 256;
2957 r += *p;
2958 }
2959
2960/* We don't particularly care about weighted results; if someone wants
2961smooth distribution and cares enough then they should submit a patch then. */
2962return r % max;
2963}
2964
77bb000f
PP
2965
2966
2967
2968/*************************************************
2969* OpenSSL option parse *
2970*************************************************/
2971
2972/* Parse one option for tls_openssl_options_parse below
2973
2974Arguments:
2975 name one option name
2976 value place to store a value for it
2977Returns success or failure in parsing
2978*/
2979
2980struct exim_openssl_option {
2981 uschar *name;
2982 long value;
2983};
2984/* We could use a macro to expand, but we need the ifdef and not all the
2985options document which version they were introduced in. Policylet: include
2986all options unless explicitly for DTLS, let the administrator choose which
2987to apply.
2988
2989This list is current as of:
e2fbf4a2
PP
2990 ==> 1.0.1b <==
2991Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
2992*/
77bb000f
PP
2993static struct exim_openssl_option exim_openssl_options[] = {
2994/* KEEP SORTED ALPHABETICALLY! */
2995#ifdef SSL_OP_ALL
73a46702 2996 { US"all", SSL_OP_ALL },
77bb000f
PP
2997#endif
2998#ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
73a46702 2999 { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
77bb000f
PP
3000#endif
3001#ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
73a46702 3002 { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
77bb000f
PP
3003#endif
3004#ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
73a46702 3005 { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
77bb000f
PP
3006#endif
3007#ifdef SSL_OP_EPHEMERAL_RSA
73a46702 3008 { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
77bb000f
PP
3009#endif
3010#ifdef SSL_OP_LEGACY_SERVER_CONNECT
73a46702 3011 { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
77bb000f
PP
3012#endif
3013#ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
73a46702 3014 { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
77bb000f
PP
3015#endif
3016#ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
73a46702 3017 { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
77bb000f
PP
3018#endif
3019#ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
73a46702 3020 { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
77bb000f
PP
3021#endif
3022#ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
73a46702 3023 { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
77bb000f
PP
3024#endif
3025#ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
73a46702 3026 { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
77bb000f 3027#endif
c80c5570
PP
3028#ifdef SSL_OP_NO_COMPRESSION
3029 { US"no_compression", SSL_OP_NO_COMPRESSION },
3030#endif
77bb000f 3031#ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
73a46702 3032 { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
77bb000f 3033#endif
c0c7b2da
PP
3034#ifdef SSL_OP_NO_SSLv2
3035 { US"no_sslv2", SSL_OP_NO_SSLv2 },
3036#endif
3037#ifdef SSL_OP_NO_SSLv3
3038 { US"no_sslv3", SSL_OP_NO_SSLv3 },
3039#endif
3040#ifdef SSL_OP_NO_TICKET
3041 { US"no_ticket", SSL_OP_NO_TICKET },
3042#endif
3043#ifdef SSL_OP_NO_TLSv1
3044 { US"no_tlsv1", SSL_OP_NO_TLSv1 },
3045#endif
c80c5570
PP
3046#ifdef SSL_OP_NO_TLSv1_1
3047#if SSL_OP_NO_TLSv1_1 == 0x00000400L
3048 /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
3049#warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
3050#else
3051 { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
3052#endif
3053#endif
3054#ifdef SSL_OP_NO_TLSv1_2
3055 { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
3056#endif
e2fbf4a2
PP
3057#ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
3058 { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
3059#endif
77bb000f 3060#ifdef SSL_OP_SINGLE_DH_USE
73a46702 3061 { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
77bb000f
PP
3062#endif
3063#ifdef SSL_OP_SINGLE_ECDH_USE
73a46702 3064 { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
77bb000f
PP
3065#endif
3066#ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
73a46702 3067 { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
77bb000f
PP
3068#endif
3069#ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
73a46702 3070 { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
77bb000f
PP
3071#endif
3072#ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
73a46702 3073 { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
77bb000f
PP
3074#endif
3075#ifdef SSL_OP_TLS_D5_BUG
73a46702 3076 { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
77bb000f
PP
3077#endif
3078#ifdef SSL_OP_TLS_ROLLBACK_BUG
73a46702 3079 { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
77bb000f
PP
3080#endif
3081};
3082static int exim_openssl_options_size =
3083 sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
3084
c80c5570 3085
77bb000f
PP
3086static BOOL
3087tls_openssl_one_option_parse(uschar *name, long *value)
3088{
3089int first = 0;
3090int last = exim_openssl_options_size;
3091while (last > first)
3092 {
3093 int middle = (first + last)/2;
3094 int c = Ustrcmp(name, exim_openssl_options[middle].name);
3095 if (c == 0)
3096 {
3097 *value = exim_openssl_options[middle].value;
3098 return TRUE;
3099 }
3100 else if (c > 0)
3101 first = middle + 1;
3102 else
3103 last = middle;
3104 }
3105return FALSE;
3106}
3107
3108
3109
3110
3111/*************************************************
3112* OpenSSL option parsing logic *
3113*************************************************/
3114
3115/* OpenSSL has a number of compatibility options which an administrator might
3116reasonably wish to set. Interpret a list similarly to decode_bits(), so that
3117we look like log_selector.
3118
3119Arguments:
3120 option_spec the administrator-supplied string of options
3121 results ptr to long storage for the options bitmap
3122Returns success or failure
3123*/
3124
3125BOOL
3126tls_openssl_options_parse(uschar *option_spec, long *results)
3127{
3128long result, item;
3129uschar *s, *end;
3130uschar keep_c;
3131BOOL adding, item_parsed;
3132
7006ee24 3133result = SSL_OP_NO_TICKET;
b1770b6e 3134/* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
da3ad30d 3135 * from default because it increases BEAST susceptibility. */
f0f5a555
PP
3136#ifdef SSL_OP_NO_SSLv2
3137result |= SSL_OP_NO_SSLv2;
3138#endif
a57b6200
JH
3139#ifdef SSL_OP_SINGLE_DH_USE
3140result |= SSL_OP_SINGLE_DH_USE;
3141#endif
77bb000f 3142
7006ee24 3143if (!option_spec)
77bb000f
PP
3144 {
3145 *results = result;
3146 return TRUE;
3147 }
3148
3149for (s=option_spec; *s != '\0'; /**/)
3150 {
3151 while (isspace(*s)) ++s;
3152 if (*s == '\0')
3153 break;
3154 if (*s != '+' && *s != '-')
3155 {
3156 DEBUG(D_tls) debug_printf("malformed openssl option setting: "
0e944a0d 3157 "+ or - expected but found \"%s\"\n", s);
77bb000f
PP
3158 return FALSE;
3159 }
3160 adding = *s++ == '+';
3161 for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3162 keep_c = *end;
3163 *end = '\0';
3164 item_parsed = tls_openssl_one_option_parse(s, &item);
96f5fe4c 3165 *end = keep_c;
77bb000f
PP
3166 if (!item_parsed)
3167 {
0e944a0d 3168 DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
77bb000f
PP
3169 return FALSE;
3170 }
3171 DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
3172 adding ? "adding" : "removing", result, item, s);
3173 if (adding)
3174 result |= item;
3175 else
3176 result &= ~item;
77bb000f
PP
3177 s = end;
3178 }
3179
3180*results = result;
3181return TRUE;
3182}
3183
9d1c15ef
JH
3184/* vi: aw ai sw=2
3185*/
059ec3d9 3186/* End of tls-openssl.c */