blob: 376e624115eb85c473b6c35f7e139f30c4d3e6c6 [file] [log] [blame]
yanbzhu08ce6ab2015-12-02 13:01:29 -05001
Emeric Brun46591952012-05-18 15:47:34 +02002/*
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02003 * SSL/TLS transport layer over SOCK_STREAM sockets
Emeric Brun46591952012-05-18 15:47:34 +02004 *
5 * Copyright (C) 2012 EXCELIANCE, Emeric Brun <ebrun@exceliance.fr>
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
Willy Tarreau69845df2012-09-10 09:43:09 +020012 * Acknowledgement:
13 * We'd like to specially thank the Stud project authors for a very clean
14 * and well documented code which helped us understand how the OpenSSL API
15 * ought to be used in non-blocking mode. This is one difficult part which
16 * is not easy to get from the OpenSSL doc, and reading the Stud code made
17 * it much more obvious than the examples in the OpenSSL package. Keep up
18 * the good works, guys !
19 *
20 * Stud is an extremely efficient and scalable SSL/TLS proxy which combines
21 * particularly well with haproxy. For more info about this project, visit :
22 * https://github.com/bumptech/stud
23 *
Emeric Brun46591952012-05-18 15:47:34 +020024 */
25
Willy Tarreau8d164dc2019-05-10 09:35:00 +020026/* Note: do NOT include openssl/xxx.h here, do it in openssl-compat.h */
Emeric Brun46591952012-05-18 15:47:34 +020027#define _GNU_SOURCE
Emeric Brunfc0421f2012-09-07 17:30:07 +020028#include <ctype.h>
29#include <dirent.h>
Emeric Brun46591952012-05-18 15:47:34 +020030#include <errno.h>
31#include <fcntl.h>
32#include <stdio.h>
33#include <stdlib.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020034#include <string.h>
35#include <unistd.h>
Emeric Brun46591952012-05-18 15:47:34 +020036
37#include <sys/socket.h>
38#include <sys/stat.h>
39#include <sys/types.h>
Christopher Faulet31af49d2015-06-09 17:29:50 +020040#include <netdb.h>
Emeric Brun46591952012-05-18 15:47:34 +020041#include <netinet/tcp.h>
42
Christopher Faulet31af49d2015-06-09 17:29:50 +020043#include <import/lru.h>
44#include <import/xxhash.h>
45
Emeric Brun46591952012-05-18 15:47:34 +020046#include <common/buffer.h>
Willy Tarreau843b7cb2018-07-13 10:54:26 +020047#include <common/chunk.h>
Emeric Brun46591952012-05-18 15:47:34 +020048#include <common/compat.h>
49#include <common/config.h>
50#include <common/debug.h>
Willy Tarreau79eeafa2012-09-14 07:53:05 +020051#include <common/errors.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010052#include <common/initcall.h>
Willy Tarreau55994562019-05-09 14:52:44 +020053#include <common/openssl-compat.h>
Emeric Brun46591952012-05-18 15:47:34 +020054#include <common/standard.h>
55#include <common/ticks.h>
56#include <common/time.h>
Emeric Brun2c86cbf2014-10-30 15:56:50 +010057#include <common/cfgparse.h>
Nenad Merdanovic05552d42015-02-27 19:56:49 +010058#include <common/base64.h>
Emeric Brun46591952012-05-18 15:47:34 +020059
William Lallemand2954c472020-03-06 21:54:13 +010060#include <ebpttree.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020061#include <ebsttree.h>
62
William Lallemand32af2032016-10-29 18:09:35 +020063#include <types/applet.h>
64#include <types/cli.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020065#include <types/global.h>
66#include <types/ssl_sock.h>
William Lallemand32af2032016-10-29 18:09:35 +020067#include <types/stats.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020068
Willy Tarreau7875d092012-09-10 08:20:03 +020069#include <proto/acl.h>
70#include <proto/arg.h>
William Lallemand32af2032016-10-29 18:09:35 +020071#include <proto/channel.h>
Emeric Brun46591952012-05-18 15:47:34 +020072#include <proto/connection.h>
William Lallemand32af2032016-10-29 18:09:35 +020073#include <proto/cli.h>
Emeric Brun46591952012-05-18 15:47:34 +020074#include <proto/fd.h>
75#include <proto/freq_ctr.h>
76#include <proto/frontend.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020077#include <proto/http_rules.h>
Willy Tarreau79eeafa2012-09-14 07:53:05 +020078#include <proto/listener.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010079#include <proto/pattern.h>
Christopher Faulet31af49d2015-06-09 17:29:50 +020080#include <proto/proto_tcp.h>
Christopher Fauletfc9cfe42019-07-16 14:54:53 +020081#include <proto/http_ana.h>
Willy Tarreau92faadf2012-10-10 23:04:25 +020082#include <proto/server.h>
William Lallemand32af2032016-10-29 18:09:35 +020083#include <proto/stream_interface.h>
Emeric Brun46591952012-05-18 15:47:34 +020084#include <proto/log.h>
Emeric Brun94324a42012-10-11 14:00:19 +020085#include <proto/proxy.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020086#include <proto/shctx.h>
Emeric Brun46591952012-05-18 15:47:34 +020087#include <proto/ssl_sock.h>
Willy Tarreau9ad7bd42015-04-03 19:19:59 +020088#include <proto/stream.h>
Emeric Brun46591952012-05-18 15:47:34 +020089#include <proto/task.h>
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010090#include <proto/vars.h>
Emeric Brun46591952012-05-18 15:47:34 +020091
Willy Tarreau9356dac2019-05-10 09:22:53 +020092/* ***** READ THIS before adding code here! *****
93 *
94 * Due to API incompatibilities between multiple OpenSSL versions and their
95 * derivatives, it's often tempting to add macros to (re-)define certain
96 * symbols. Please do not do this here, and do it in common/openssl-compat.h
97 * exclusively so that the whole code consistently uses the same macros.
98 *
99 * Whenever possible if a macro is missing in certain versions, it's better
100 * to conditionally define it in openssl-compat.h than using lots of ifdefs.
101 */
102
Willy Tarreau518cedd2014-02-17 15:43:01 +0100103/* Warning, these are bits, not integers! */
Emeric Brune64aef12012-09-21 13:15:06 +0200104#define SSL_SOCK_ST_FL_VERIFY_DONE 0x00000001
Emeric Brund8b2bb52014-01-28 15:43:53 +0100105#define SSL_SOCK_ST_FL_16K_WBFSIZE 0x00000002
Willy Tarreau518cedd2014-02-17 15:43:01 +0100106#define SSL_SOCK_SEND_UNLIMITED 0x00000004
Emeric Brun29f037d2014-04-25 19:05:36 +0200107#define SSL_SOCK_RECV_HEARTBEAT 0x00000008
108
Emeric Brunf282a812012-09-21 15:27:54 +0200109/* bits 0xFFFF0000 are reserved to store verify errors */
110
111/* Verify errors macros */
112#define SSL_SOCK_CA_ERROR_TO_ST(e) (((e > 63) ? 63 : e) << (16))
113#define SSL_SOCK_CAEDEPTH_TO_ST(d) (((d > 15) ? 15 : d) << (6+16))
114#define SSL_SOCK_CRTERROR_TO_ST(e) (((e > 63) ? 63 : e) << (4+6+16))
115
116#define SSL_SOCK_ST_TO_CA_ERROR(s) ((s >> (16)) & 63)
117#define SSL_SOCK_ST_TO_CAEDEPTH(s) ((s >> (6+16)) & 15)
118#define SSL_SOCK_ST_TO_CRTERROR(s) ((s >> (4+6+16)) & 63)
Emeric Brune64aef12012-09-21 13:15:06 +0200119
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200120/* ssl_methods flags for ssl options */
121#define MC_SSL_O_ALL 0x0000
122#define MC_SSL_O_NO_SSLV3 0x0001 /* disable SSLv3 */
123#define MC_SSL_O_NO_TLSV10 0x0002 /* disable TLSv10 */
124#define MC_SSL_O_NO_TLSV11 0x0004 /* disable TLSv11 */
125#define MC_SSL_O_NO_TLSV12 0x0008 /* disable TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +0200126#define MC_SSL_O_NO_TLSV13 0x0010 /* disable TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200127
William Lallemand3af48e72020-02-03 17:15:52 +0100128/* file to guess during file loading */
129#define SSL_GF_NONE 0x00000000 /* Don't guess any file, only open the files specified in the configuration files */
130#define SSL_GF_BUNDLE 0x00000001 /* try to open the bundles */
131#define SSL_GF_SCTL 0x00000002 /* try to open the .sctl file */
132#define SSL_GF_OCSP 0x00000004 /* try to open the .ocsp file */
133#define SSL_GF_OCSP_ISSUER 0x00000008 /* try to open the .issuer file if an OCSP file was loaded */
William Lallemand4c5adbf2020-02-24 14:23:22 +0100134#define SSL_GF_KEY 0x00000010 /* try to open the .key file to load a private key */
William Lallemand3af48e72020-02-03 17:15:52 +0100135
William Lallemand4c5adbf2020-02-24 14:23:22 +0100136#define SSL_GF_ALL (SSL_GF_BUNDLE|SSL_GF_SCTL|SSL_GF_OCSP|SSL_GF_OCSP_ISSUER|SSL_GF_KEY)
William Lallemand3af48e72020-02-03 17:15:52 +0100137
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200138/* ssl_methods versions */
139enum {
140 CONF_TLSV_NONE = 0,
141 CONF_TLSV_MIN = 1,
142 CONF_SSLV3 = 1,
143 CONF_TLSV10 = 2,
144 CONF_TLSV11 = 3,
145 CONF_TLSV12 = 4,
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +0200146 CONF_TLSV13 = 5,
147 CONF_TLSV_MAX = 5,
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200148};
149
Emeric Brun850efd52014-01-29 12:24:34 +0100150/* server and bind verify method, it uses a global value as default */
151enum {
152 SSL_SOCK_VERIFY_DEFAULT = 0,
153 SSL_SOCK_VERIFY_REQUIRED = 1,
154 SSL_SOCK_VERIFY_OPTIONAL = 2,
155 SSL_SOCK_VERIFY_NONE = 3,
156};
157
Willy Tarreau71b734c2014-01-28 15:19:44 +0100158int sslconns = 0;
159int totalsslconns = 0;
Willy Tarreaud9f5cca2016-12-22 21:08:52 +0100160static struct xprt_ops ssl_sock;
Emeric Brunece0c332017-12-06 13:51:49 +0100161int nb_engines = 0;
Emeric Brune1f38db2012-09-03 20:36:47 +0200162
William Lallemande0f3fd52020-02-25 14:53:06 +0100163static struct eb_root cert_issuer_tree = EB_ROOT; /* issuers tree from "issuers-chain-path" */
Emmanuel Hocdetef87e0a2020-03-23 11:29:11 +0100164static struct issuer_chain* ssl_get0_issuer_chain(X509 *cert);
William Lallemande0f3fd52020-02-25 14:53:06 +0100165
Willy Tarreauef934602016-12-22 23:12:01 +0100166static struct {
167 char *crt_base; /* base directory path for certificates */
168 char *ca_base; /* base directory path for CAs and CRLs */
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +0100169 char *issuers_chain_path; /* from "issuers-chain-path" */
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +0100170
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000171 int async; /* whether we use ssl async mode */
Willy Tarreauef934602016-12-22 23:12:01 +0100172
173 char *listen_default_ciphers;
174 char *connect_default_ciphers;
Emmanuel Hocdet839af572019-05-14 16:27:35 +0200175#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +0200176 char *listen_default_ciphersuites;
177 char *connect_default_ciphersuites;
178#endif
Willy Tarreauef934602016-12-22 23:12:01 +0100179 int listen_default_ssloptions;
180 int connect_default_ssloptions;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200181 struct tls_version_filter listen_default_sslmethods;
182 struct tls_version_filter connect_default_sslmethods;
Willy Tarreauef934602016-12-22 23:12:01 +0100183
184 int private_cache; /* Force to use a private session cache even if nbproc > 1 */
185 unsigned int life_time; /* SSL session lifetime in seconds */
186 unsigned int max_record; /* SSL max record size */
187 unsigned int default_dh_param; /* SSL maximum DH parameter size */
188 int ctx_cache; /* max number of entries in the ssl_ctx cache. */
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100189 int capture_cipherlist; /* Size of the cipherlist buffer. */
William Lallemand3af48e72020-02-03 17:15:52 +0100190 int extra_files; /* which files not defined in the configuration file are we looking for */
Willy Tarreauef934602016-12-22 23:12:01 +0100191} global_ssl = {
192#ifdef LISTEN_DEFAULT_CIPHERS
193 .listen_default_ciphers = LISTEN_DEFAULT_CIPHERS,
194#endif
195#ifdef CONNECT_DEFAULT_CIPHERS
196 .connect_default_ciphers = CONNECT_DEFAULT_CIPHERS,
197#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +0200198#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +0200199#ifdef LISTEN_DEFAULT_CIPHERSUITES
200 .listen_default_ciphersuites = LISTEN_DEFAULT_CIPHERSUITES,
201#endif
202#ifdef CONNECT_DEFAULT_CIPHERSUITES
203 .connect_default_ciphersuites = CONNECT_DEFAULT_CIPHERSUITES,
204#endif
205#endif
Willy Tarreauef934602016-12-22 23:12:01 +0100206 .listen_default_ssloptions = BC_SSL_O_NONE,
207 .connect_default_ssloptions = SRV_SSL_O_NONE,
208
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200209 .listen_default_sslmethods.flags = MC_SSL_O_ALL,
210 .listen_default_sslmethods.min = CONF_TLSV_NONE,
211 .listen_default_sslmethods.max = CONF_TLSV_NONE,
212 .connect_default_sslmethods.flags = MC_SSL_O_ALL,
213 .connect_default_sslmethods.min = CONF_TLSV_NONE,
214 .connect_default_sslmethods.max = CONF_TLSV_NONE,
215
Willy Tarreauef934602016-12-22 23:12:01 +0100216#ifdef DEFAULT_SSL_MAX_RECORD
217 .max_record = DEFAULT_SSL_MAX_RECORD,
218#endif
219 .default_dh_param = SSL_DEFAULT_DH_PARAM,
220 .ctx_cache = DEFAULT_SSL_CTX_CACHE,
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100221 .capture_cipherlist = 0,
William Lallemand3af48e72020-02-03 17:15:52 +0100222 .extra_files = SSL_GF_ALL,
Willy Tarreauef934602016-12-22 23:12:01 +0100223};
224
Olivier Houcharda8955d52019-04-07 22:00:38 +0200225static BIO_METHOD *ha_meth;
226
Olivier Houchard66ab4982019-02-26 18:37:15 +0100227struct ssl_sock_ctx {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200228 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +0100229 SSL *ssl;
Olivier Houcharda8955d52019-04-07 22:00:38 +0200230 BIO *bio;
Olivier Houchard5149b592019-05-23 17:47:36 +0200231 const struct xprt_ops *xprt;
Olivier Houchard66ab4982019-02-26 18:37:15 +0100232 void *xprt_ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +0200233 struct wait_event wait_event;
Willy Tarreau113d52b2020-01-10 09:20:26 +0100234 struct wait_event *subs;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +0100235 int xprt_st; /* transport layer state, initialized to zero */
Olivier Houchard54907bb2019-12-19 15:02:39 +0100236 struct buffer early_buf; /* buffer to store the early data received */
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +0100237 int sent_early_data; /* Amount of early data we sent so far */
238
Olivier Houchard66ab4982019-02-26 18:37:15 +0100239};
240
241DECLARE_STATIC_POOL(ssl_sock_ctx_pool, "ssl_sock_ctx_pool", sizeof(struct ssl_sock_ctx));
242
Olivier Houchardea8dd942019-05-20 14:02:16 +0200243static struct task *ssl_sock_io_cb(struct task *, void *, unsigned short);
Olivier Houchard000694c2019-05-23 14:45:12 +0200244static int ssl_sock_handshake(struct connection *conn, unsigned int flag);
Olivier Houchardea8dd942019-05-20 14:02:16 +0200245
Olivier Houcharda8955d52019-04-07 22:00:38 +0200246/* Methods to implement OpenSSL BIO */
247static int ha_ssl_write(BIO *h, const char *buf, int num)
248{
249 struct buffer tmpbuf;
250 struct ssl_sock_ctx *ctx;
251 int ret;
252
253 ctx = BIO_get_data(h);
254 tmpbuf.size = num;
255 tmpbuf.area = (void *)(uintptr_t)buf;
256 tmpbuf.data = num;
257 tmpbuf.head = 0;
258 ret = ctx->xprt->snd_buf(ctx->conn, ctx->xprt_ctx, &tmpbuf, num, 0);
Olivier Houchardb51937e2019-05-01 17:24:36 +0200259 if (ret == 0 && !(ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_WR_SH))) {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200260 BIO_set_retry_write(h);
Olivier Houcharda28454e2019-04-24 12:04:36 +0200261 ret = -1;
Olivier Houchardb51937e2019-05-01 17:24:36 +0200262 } else if (ret == 0)
263 BIO_clear_retry_flags(h);
Olivier Houcharda8955d52019-04-07 22:00:38 +0200264 return ret;
265}
266
267static int ha_ssl_gets(BIO *h, char *buf, int size)
268{
269
270 return 0;
271}
272
273static int ha_ssl_puts(BIO *h, const char *str)
274{
275
276 return ha_ssl_write(h, str, strlen(str));
277}
278
279static int ha_ssl_read(BIO *h, char *buf, int size)
280{
281 struct buffer tmpbuf;
282 struct ssl_sock_ctx *ctx;
283 int ret;
284
285 ctx = BIO_get_data(h);
286 tmpbuf.size = size;
287 tmpbuf.area = buf;
288 tmpbuf.data = 0;
289 tmpbuf.head = 0;
290 ret = ctx->xprt->rcv_buf(ctx->conn, ctx->xprt_ctx, &tmpbuf, size, 0);
Olivier Houchardb51937e2019-05-01 17:24:36 +0200291 if (ret == 0 && !(ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH))) {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200292 BIO_set_retry_read(h);
Olivier Houcharda28454e2019-04-24 12:04:36 +0200293 ret = -1;
Olivier Houchardb51937e2019-05-01 17:24:36 +0200294 } else if (ret == 0)
295 BIO_clear_retry_flags(h);
Olivier Houcharda8955d52019-04-07 22:00:38 +0200296
297 return ret;
298}
299
300static long ha_ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2)
301{
302 int ret = 0;
303 switch (cmd) {
304 case BIO_CTRL_DUP:
305 case BIO_CTRL_FLUSH:
306 ret = 1;
307 break;
308 }
309 return ret;
310}
311
312static int ha_ssl_new(BIO *h)
313{
314 BIO_set_init(h, 1);
315 BIO_set_data(h, NULL);
316 BIO_clear_flags(h, ~0);
317 return 1;
318}
319
320static int ha_ssl_free(BIO *data)
321{
322
323 return 1;
324}
325
326
Willy Tarreau5db847a2019-05-09 14:13:35 +0200327#if defined(USE_THREAD) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Christopher Faulet9dcf9b62017-11-13 10:34:01 +0100328
Emeric Brun821bb9b2017-06-15 16:37:39 +0200329static HA_RWLOCK_T *ssl_rwlocks;
330
331
332unsigned long ssl_id_function(void)
333{
334 return (unsigned long)tid;
335}
336
337void ssl_locking_function(int mode, int n, const char * file, int line)
338{
339 if (mode & CRYPTO_LOCK) {
340 if (mode & CRYPTO_READ)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100341 HA_RWLOCK_RDLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200342 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100343 HA_RWLOCK_WRLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200344 }
345 else {
346 if (mode & CRYPTO_READ)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100347 HA_RWLOCK_RDUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200348 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100349 HA_RWLOCK_WRUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200350 }
351}
352
353static int ssl_locking_init(void)
354{
355 int i;
356
357 ssl_rwlocks = malloc(sizeof(HA_RWLOCK_T)*CRYPTO_num_locks());
358 if (!ssl_rwlocks)
359 return -1;
360
361 for (i = 0 ; i < CRYPTO_num_locks() ; i++)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100362 HA_RWLOCK_INIT(&ssl_rwlocks[i]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200363
364 CRYPTO_set_id_callback(ssl_id_function);
365 CRYPTO_set_locking_callback(ssl_locking_function);
366
367 return 0;
368}
Christopher Faulet9dcf9b62017-11-13 10:34:01 +0100369
Emeric Brun821bb9b2017-06-15 16:37:39 +0200370#endif
371
William Lallemand150bfa82019-09-19 17:12:49 +0200372__decl_hathreads(HA_SPINLOCK_T ckch_lock);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200373
William Lallemandbc6ca7c2019-10-29 23:48:19 +0100374/* Uncommitted CKCH transaction */
375
376static struct {
377 struct ckch_store *new_ckchs;
378 struct ckch_store *old_ckchs;
379 char *path;
380} ckchs_transaction;
381
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +0200382/*
Emmanuel Hocdetb270e812019-11-21 19:09:31 +0100383 * deduplicate cafile (and crlfile)
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +0200384 */
385struct cafile_entry {
386 X509_STORE *ca_store;
Emmanuel Hocdet129d3282019-10-24 18:08:51 +0200387 STACK_OF(X509_NAME) *ca_list;
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +0200388 struct ebmb_node node;
389 char path[0];
390};
391
392static struct eb_root cafile_tree = EB_ROOT_UNIQUE;
393
394static X509_STORE* ssl_store_get0_locations_file(char *path)
395{
396 struct ebmb_node *eb;
397
398 eb = ebst_lookup(&cafile_tree, path);
399 if (eb) {
400 struct cafile_entry *ca_e;
401 ca_e = ebmb_entry(eb, struct cafile_entry, node);
402 return ca_e->ca_store;
403 }
404 return NULL;
405}
406
407static int ssl_store_load_locations_file(char *path)
408{
409 if (ssl_store_get0_locations_file(path) == NULL) {
410 struct cafile_entry *ca_e;
411 X509_STORE *store = X509_STORE_new();
412 if (X509_STORE_load_locations(store, path, NULL)) {
413 int pathlen;
414 pathlen = strlen(path);
415 ca_e = calloc(1, sizeof(*ca_e) + pathlen + 1);
416 if (ca_e) {
417 memcpy(ca_e->path, path, pathlen + 1);
418 ca_e->ca_store = store;
419 ebst_insert(&cafile_tree, &ca_e->node);
420 return 1;
421 }
422 }
423 X509_STORE_free(store);
424 return 0;
425 }
426 return 1;
427}
428
429/* mimic what X509_STORE_load_locations do with store_ctx */
430static int ssl_set_cert_crl_file(X509_STORE *store_ctx, char *path)
431{
432 X509_STORE *store;
433 store = ssl_store_get0_locations_file(path);
434 if (store_ctx && store) {
435 int i;
436 X509_OBJECT *obj;
437 STACK_OF(X509_OBJECT) *objs = X509_STORE_get0_objects(store);
438 for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
439 obj = sk_X509_OBJECT_value(objs, i);
440 switch (X509_OBJECT_get_type(obj)) {
441 case X509_LU_X509:
442 X509_STORE_add_cert(store_ctx, X509_OBJECT_get0_X509(obj));
443 break;
444 case X509_LU_CRL:
445 X509_STORE_add_crl(store_ctx, X509_OBJECT_get0_X509_CRL(obj));
446 break;
447 default:
448 break;
449 }
450 }
451 return 1;
452 }
453 return 0;
454}
455
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +0500456/* SSL_CTX_load_verify_locations substitute, internally call X509_STORE_load_locations */
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +0200457static int ssl_set_verify_locations_file(SSL_CTX *ctx, char *path)
458{
459 X509_STORE *store_ctx = SSL_CTX_get_cert_store(ctx);
460 return ssl_set_cert_crl_file(store_ctx, path);
461}
462
Emmanuel Hocdet129d3282019-10-24 18:08:51 +0200463/*
464 Extract CA_list from CA_file already in tree.
465 Duplicate ca_name is tracking with ebtree. It's simplify openssl compatibility.
466 Return a shared ca_list: SSL_dup_CA_list must be used before set it on SSL_CTX.
467*/
468static STACK_OF(X509_NAME)* ssl_get_client_ca_file(char *path)
469{
470 struct ebmb_node *eb;
471 struct cafile_entry *ca_e;
472
473 eb = ebst_lookup(&cafile_tree, path);
474 if (!eb)
475 return NULL;
476 ca_e = ebmb_entry(eb, struct cafile_entry, node);
477
478 if (ca_e->ca_list == NULL) {
479 int i;
480 unsigned long key;
481 struct eb_root ca_name_tree = EB_ROOT;
482 struct eb64_node *node, *back;
483 struct {
484 struct eb64_node node;
485 X509_NAME *xname;
486 } *ca_name;
487 STACK_OF(X509_OBJECT) *objs;
488 STACK_OF(X509_NAME) *skn;
489 X509 *x;
490 X509_NAME *xn;
491
492 skn = sk_X509_NAME_new_null();
493 /* take x509 from cafile_tree */
494 objs = X509_STORE_get0_objects(ca_e->ca_store);
495 for (i = 0; i < sk_X509_OBJECT_num(objs); i++) {
496 x = X509_OBJECT_get0_X509(sk_X509_OBJECT_value(objs, i));
497 if (!x)
498 continue;
499 xn = X509_get_subject_name(x);
500 if (!xn)
501 continue;
502 /* Check for duplicates. */
503 key = X509_NAME_hash(xn);
504 for (node = eb64_lookup(&ca_name_tree, key), ca_name = NULL;
505 node && ca_name == NULL;
506 node = eb64_next(node)) {
507 ca_name = container_of(node, typeof(*ca_name), node);
508 if (X509_NAME_cmp(xn, ca_name->xname) != 0)
509 ca_name = NULL;
510 }
511 /* find a duplicate */
512 if (ca_name)
513 continue;
514 ca_name = calloc(1, sizeof *ca_name);
515 xn = X509_NAME_dup(xn);
516 if (!ca_name ||
517 !xn ||
518 !sk_X509_NAME_push(skn, xn)) {
519 free(ca_name);
520 X509_NAME_free(xn);
521 sk_X509_NAME_pop_free(skn, X509_NAME_free);
522 sk_X509_NAME_free(skn);
523 skn = NULL;
524 break;
525 }
526 ca_name->node.key = key;
527 ca_name->xname = xn;
528 eb64_insert(&ca_name_tree, &ca_name->node);
529 }
530 ca_e->ca_list = skn;
531 /* remove temporary ca_name tree */
532 node = eb64_first(&ca_name_tree);
533 while (node) {
534 ca_name = container_of(node, typeof(*ca_name), node);
535 back = eb64_next(node);
536 eb64_delete(node);
537 free(ca_name);
538 node = back;
539 }
540 }
541 return ca_e->ca_list;
542}
543
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +0100544/* This memory pool is used for capturing clienthello parameters. */
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100545struct ssl_capture {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100546 unsigned long long int xxh64;
547 unsigned char ciphersuite_len;
548 char ciphersuite[0];
549};
Willy Tarreaubafbe012017-11-24 17:34:44 +0100550struct pool_head *pool_head_ssl_capture = NULL;
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +0100551static int ssl_capture_ptr_index = -1;
Thierry FOURNIER28962c92018-06-17 21:37:05 +0200552static int ssl_app_data_index = -1;
Willy Tarreauef934602016-12-22 23:12:01 +0100553
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +0200554#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
555struct list tlskeys_reference = LIST_HEAD_INIT(tlskeys_reference);
556#endif
557
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200558#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +0000559static unsigned int openssl_engines_initialized;
560struct list openssl_engines = LIST_HEAD_INIT(openssl_engines);
561struct ssl_engine_list {
562 struct list list;
563 ENGINE *e;
564};
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200565#endif
Grant Zhang872f9c22017-01-21 01:10:18 +0000566
Remi Gacogne8de54152014-07-15 11:36:40 +0200567#ifndef OPENSSL_NO_DH
Remi Gacogne4f902b82015-05-28 16:23:00 +0200568static int ssl_dh_ptr_index = -1;
Remi Gacogne47783ef2015-05-29 15:53:22 +0200569static DH *global_dh = NULL;
Remi Gacogne8de54152014-07-15 11:36:40 +0200570static DH *local_dh_1024 = NULL;
571static DH *local_dh_2048 = NULL;
572static DH *local_dh_4096 = NULL;
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +0100573static DH *ssl_get_tmp_dh(SSL *ssl, int export, int keylen);
Remi Gacogne8de54152014-07-15 11:36:40 +0200574#endif /* OPENSSL_NO_DH */
575
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100576#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Christopher Faulet31af49d2015-06-09 17:29:50 +0200577/* X509V3 Extensions that will be added on generated certificates */
578#define X509V3_EXT_SIZE 5
579static char *x509v3_ext_names[X509V3_EXT_SIZE] = {
580 "basicConstraints",
581 "nsComment",
582 "subjectKeyIdentifier",
583 "authorityKeyIdentifier",
584 "keyUsage",
585};
586static char *x509v3_ext_values[X509V3_EXT_SIZE] = {
587 "CA:FALSE",
588 "\"OpenSSL Generated Certificate\"",
589 "hash",
590 "keyid,issuer:always",
591 "nonRepudiation,digitalSignature,keyEncipherment"
592};
Christopher Faulet31af49d2015-06-09 17:29:50 +0200593/* LRU cache to store generated certificate */
594static struct lru64_head *ssl_ctx_lru_tree = NULL;
595static unsigned int ssl_ctx_lru_seed = 0;
Emeric Brun821bb9b2017-06-15 16:37:39 +0200596static unsigned int ssl_ctx_serial;
Willy Tarreau86abe442018-11-25 20:12:18 +0100597__decl_rwlock(ssl_ctx_lru_rwlock);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200598
Willy Tarreauc8ad3be2015-06-17 15:48:26 +0200599#endif // SSL_CTRL_SET_TLSEXT_HOSTNAME
600
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100601static struct ssl_bind_kw ssl_bind_kws[];
602
Willy Tarreau9a1ab082019-05-09 13:26:41 +0200603#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhube2774d2015-12-10 15:07:30 -0500604/* The order here matters for picking a default context,
605 * keep the most common keytype at the bottom of the list
606 */
607const char *SSL_SOCK_KEYTYPE_NAMES[] = {
608 "dsa",
609 "ecdsa",
610 "rsa"
611};
612#define SSL_SOCK_NUM_KEYTYPES 3
Willy Tarreau30da7ad2015-12-14 11:28:33 +0100613#else
614#define SSL_SOCK_NUM_KEYTYPES 1
yanbzhube2774d2015-12-10 15:07:30 -0500615#endif
616
William Lallemandc3cd35f2017-11-28 11:04:43 +0100617static struct shared_context *ssl_shctx = NULL; /* ssl shared session cache */
William Lallemand4f45bb92017-10-30 20:08:51 +0100618static struct eb_root *sh_ssl_sess_tree; /* ssl shared session tree */
619
620#define sh_ssl_sess_tree_delete(s) ebmb_delete(&(s)->key);
621
622#define sh_ssl_sess_tree_insert(s) (struct sh_ssl_sess_hdr *)ebmb_insert(sh_ssl_sess_tree, \
623 &(s)->key, SSL_MAX_SSL_SESSION_ID_LENGTH);
624
625#define sh_ssl_sess_tree_lookup(k) (struct sh_ssl_sess_hdr *)ebmb_lookup(sh_ssl_sess_tree, \
626 (k), SSL_MAX_SSL_SESSION_ID_LENGTH);
William Lallemand3f85c9a2017-10-09 16:30:50 +0200627
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100628/*
629 * This function gives the detail of the SSL error. It is used only
630 * if the debug mode and the verbose mode are activated. It dump all
631 * the SSL error until the stack was empty.
632 */
633static forceinline void ssl_sock_dump_errors(struct connection *conn)
634{
635 unsigned long ret;
636
637 if (unlikely(global.mode & MODE_DEBUG)) {
638 while(1) {
639 ret = ERR_get_error();
640 if (ret == 0)
641 return;
642 fprintf(stderr, "fd[%04x] OpenSSL error[0x%lx] %s: %s\n",
Willy Tarreau585744b2017-08-24 14:31:19 +0200643 (unsigned short)conn->handle.fd, ret,
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100644 ERR_func_error_string(ret), ERR_reason_error_string(ret));
645 }
646 }
647}
648
yanbzhube2774d2015-12-10 15:07:30 -0500649
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200650#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +0000651static int ssl_init_single_engine(const char *engine_id, const char *def_algorithms)
652{
653 int err_code = ERR_ABORT;
654 ENGINE *engine;
655 struct ssl_engine_list *el;
656
657 /* grab the structural reference to the engine */
658 engine = ENGINE_by_id(engine_id);
659 if (engine == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100660 ha_alert("ssl-engine %s: failed to get structural reference\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000661 goto fail_get;
662 }
663
664 if (!ENGINE_init(engine)) {
665 /* the engine couldn't initialise, release it */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100666 ha_alert("ssl-engine %s: failed to initialize\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000667 goto fail_init;
668 }
669
670 if (ENGINE_set_default_string(engine, def_algorithms) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100671 ha_alert("ssl-engine %s: failed on ENGINE_set_default_string\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000672 goto fail_set_method;
673 }
674
675 el = calloc(1, sizeof(*el));
676 el->e = engine;
677 LIST_ADD(&openssl_engines, &el->list);
Emeric Brunece0c332017-12-06 13:51:49 +0100678 nb_engines++;
679 if (global_ssl.async)
680 global.ssl_used_async_engines = nb_engines;
Grant Zhang872f9c22017-01-21 01:10:18 +0000681 return 0;
682
683fail_set_method:
684 /* release the functional reference from ENGINE_init() */
685 ENGINE_finish(engine);
686
687fail_init:
688 /* release the structural reference from ENGINE_by_id() */
689 ENGINE_free(engine);
690
691fail_get:
692 return err_code;
693}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200694#endif
Grant Zhang872f9c22017-01-21 01:10:18 +0000695
Willy Tarreau5db847a2019-05-09 14:13:35 +0200696#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brun3854e012017-05-17 20:42:48 +0200697/*
698 * openssl async fd handler
699 */
Emeric Brund0e095c2019-04-19 17:15:28 +0200700void ssl_async_fd_handler(int fd)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000701{
Olivier Houchardea8dd942019-05-20 14:02:16 +0200702 struct ssl_sock_ctx *ctx = fdtab[fd].owner;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000703
Emeric Brun3854e012017-05-17 20:42:48 +0200704 /* fd is an async enfine fd, we must stop
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000705 * to poll this fd until it is requested
706 */
Emeric Brunbbc16542017-06-02 15:54:06 +0000707 fd_stop_recv(fd);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000708 fd_cant_recv(fd);
709
710 /* crypto engine is available, let's notify the associated
711 * connection that it can pursue its processing.
712 */
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200713 ssl_sock_io_cb(NULL, ctx, 0);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000714}
715
Emeric Brun3854e012017-05-17 20:42:48 +0200716/*
717 * openssl async delayed SSL_free handler
718 */
Emeric Brund0e095c2019-04-19 17:15:28 +0200719void ssl_async_fd_free(int fd)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000720{
721 SSL *ssl = fdtab[fd].owner;
Emeric Brun3854e012017-05-17 20:42:48 +0200722 OSSL_ASYNC_FD all_fd[32];
723 size_t num_all_fds = 0;
724 int i;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000725
Emeric Brun3854e012017-05-17 20:42:48 +0200726 /* We suppose that the async job for a same SSL *
727 * are serialized. So if we are awake it is
728 * because the running job has just finished
729 * and we can remove all async fds safely
730 */
731 SSL_get_all_async_fds(ssl, NULL, &num_all_fds);
732 if (num_all_fds > 32) {
733 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
734 return;
735 }
736
737 SSL_get_all_async_fds(ssl, all_fd, &num_all_fds);
738 for (i=0 ; i < num_all_fds ; i++)
739 fd_remove(all_fd[i]);
740
741 /* Now we can safely call SSL_free, no more pending job in engines */
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000742 SSL_free(ssl);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +0100743 _HA_ATOMIC_SUB(&sslconns, 1);
744 _HA_ATOMIC_SUB(&jobs, 1);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000745}
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000746/*
Emeric Brun3854e012017-05-17 20:42:48 +0200747 * function used to manage a returned SSL_ERROR_WANT_ASYNC
748 * and enable/disable polling for async fds
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000749 */
Olivier Houchardea8dd942019-05-20 14:02:16 +0200750static inline void ssl_async_process_fds(struct ssl_sock_ctx *ctx)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000751{
Willy Tarreaua9786b62018-01-25 07:22:13 +0100752 OSSL_ASYNC_FD add_fd[32];
Emeric Brun3854e012017-05-17 20:42:48 +0200753 OSSL_ASYNC_FD del_fd[32];
Olivier Houchardea8dd942019-05-20 14:02:16 +0200754 SSL *ssl = ctx->ssl;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000755 size_t num_add_fds = 0;
756 size_t num_del_fds = 0;
Emeric Brun3854e012017-05-17 20:42:48 +0200757 int i;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000758
759 SSL_get_changed_async_fds(ssl, NULL, &num_add_fds, NULL,
760 &num_del_fds);
Emeric Brun3854e012017-05-17 20:42:48 +0200761 if (num_add_fds > 32 || num_del_fds > 32) {
762 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000763 return;
764 }
765
Emeric Brun3854e012017-05-17 20:42:48 +0200766 SSL_get_changed_async_fds(ssl, add_fd, &num_add_fds, del_fd, &num_del_fds);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000767
Emeric Brun3854e012017-05-17 20:42:48 +0200768 /* We remove unused fds from the fdtab */
769 for (i=0 ; i < num_del_fds ; i++)
770 fd_remove(del_fd[i]);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000771
Emeric Brun3854e012017-05-17 20:42:48 +0200772 /* We add new fds to the fdtab */
773 for (i=0 ; i < num_add_fds ; i++) {
Olivier Houchardea8dd942019-05-20 14:02:16 +0200774 fd_insert(add_fd[i], ctx, ssl_async_fd_handler, tid_bit);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000775 }
776
Emeric Brun3854e012017-05-17 20:42:48 +0200777 num_add_fds = 0;
778 SSL_get_all_async_fds(ssl, NULL, &num_add_fds);
779 if (num_add_fds > 32) {
780 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
781 return;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000782 }
Emeric Brun3854e012017-05-17 20:42:48 +0200783
784 /* We activate the polling for all known async fds */
785 SSL_get_all_async_fds(ssl, add_fd, &num_add_fds);
Emeric Brunce9e01c2017-05-31 10:02:53 +0000786 for (i=0 ; i < num_add_fds ; i++) {
Emeric Brun3854e012017-05-17 20:42:48 +0200787 fd_want_recv(add_fd[i]);
Emeric Brunce9e01c2017-05-31 10:02:53 +0000788 /* To ensure that the fd cache won't be used
789 * We'll prefer to catch a real RD event
790 * because handling an EAGAIN on this fd will
791 * result in a context switch and also
792 * some engines uses a fd in blocking mode.
793 */
794 fd_cant_recv(add_fd[i]);
795 }
Emeric Brun3854e012017-05-17 20:42:48 +0200796
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000797}
798#endif
799
William Lallemand104a7a62019-10-14 14:14:59 +0200800#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
Emeric Brun4f3c87a2014-06-20 15:46:13 +0200801/*
802 * This function returns the number of seconds elapsed
803 * since the Epoch, 1970-01-01 00:00:00 +0000 (UTC) and the
804 * date presented un ASN1_GENERALIZEDTIME.
805 *
806 * In parsing error case, it returns -1.
807 */
808static long asn1_generalizedtime_to_epoch(ASN1_GENERALIZEDTIME *d)
809{
810 long epoch;
811 char *p, *end;
812 const unsigned short month_offset[12] = {
813 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
814 };
815 int year, month;
816
817 if (!d || (d->type != V_ASN1_GENERALIZEDTIME)) return -1;
818
819 p = (char *)d->data;
820 end = p + d->length;
821
822 if (end - p < 4) return -1;
823 year = 1000 * (p[0] - '0') + 100 * (p[1] - '0') + 10 * (p[2] - '0') + p[3] - '0';
824 p += 4;
825 if (end - p < 2) return -1;
826 month = 10 * (p[0] - '0') + p[1] - '0';
827 if (month < 1 || month > 12) return -1;
828 /* Compute the number of seconds since 1 jan 1970 and the beginning of current month
829 We consider leap years and the current month (<marsh or not) */
830 epoch = ( ((year - 1970) * 365)
831 + ((year - (month < 3)) / 4 - (year - (month < 3)) / 100 + (year - (month < 3)) / 400)
832 - ((1970 - 1) / 4 - (1970 - 1) / 100 + (1970 - 1) / 400)
833 + month_offset[month-1]
834 ) * 24 * 60 * 60;
835 p += 2;
836 if (end - p < 2) return -1;
837 /* Add the number of seconds of completed days of current month */
838 epoch += (10 * (p[0] - '0') + p[1] - '0' - 1) * 24 * 60 * 60;
839 p += 2;
840 if (end - p < 2) return -1;
841 /* Add the completed hours of the current day */
842 epoch += (10 * (p[0] - '0') + p[1] - '0') * 60 * 60;
843 p += 2;
844 if (end - p < 2) return -1;
845 /* Add the completed minutes of the current hour */
846 epoch += (10 * (p[0] - '0') + p[1] - '0') * 60;
847 p += 2;
848 if (p == end) return -1;
849 /* Test if there is available seconds */
850 if (p[0] < '0' || p[0] > '9')
851 goto nosec;
852 if (end - p < 2) return -1;
853 /* Add the seconds of the current minute */
854 epoch += 10 * (p[0] - '0') + p[1] - '0';
855 p += 2;
856 if (p == end) return -1;
857 /* Ignore seconds float part if present */
858 if (p[0] == '.') {
859 do {
860 if (++p == end) return -1;
861 } while (p[0] >= '0' && p[0] <= '9');
862 }
863
864nosec:
865 if (p[0] == 'Z') {
866 if (end - p != 1) return -1;
867 return epoch;
868 }
869 else if (p[0] == '+') {
870 if (end - p != 5) return -1;
871 /* Apply timezone offset */
Frederik Deweerdt953917a2017-10-16 07:37:31 -0700872 return epoch - ((10 * (p[1] - '0') + p[2] - '0') * 60 * 60 + (10 * (p[3] - '0') + p[4] - '0')) * 60;
Emeric Brun4f3c87a2014-06-20 15:46:13 +0200873 }
874 else if (p[0] == '-') {
875 if (end - p != 5) return -1;
876 /* Apply timezone offset */
Frederik Deweerdt953917a2017-10-16 07:37:31 -0700877 return epoch + ((10 * (p[1] - '0') + p[2] - '0') * 60 * 60 + (10 * (p[3] - '0') + p[4] - '0')) * 60;
Emeric Brun4f3c87a2014-06-20 15:46:13 +0200878 }
879
880 return -1;
881}
882
William Lallemand104a7a62019-10-14 14:14:59 +0200883/*
884 * struct alignment works here such that the key.key is the same as key_data
885 * Do not change the placement of key_data
886 */
887struct certificate_ocsp {
888 struct ebmb_node key;
889 unsigned char key_data[OCSP_MAX_CERTID_ASN1_LENGTH];
890 struct buffer response;
891 long expire;
892};
893
894struct ocsp_cbk_arg {
895 int is_single;
896 int single_kt;
897 union {
898 struct certificate_ocsp *s_ocsp;
899 /*
900 * m_ocsp will have multiple entries dependent on key type
901 * Entry 0 - DSA
902 * Entry 1 - ECDSA
903 * Entry 2 - RSA
904 */
905 struct certificate_ocsp *m_ocsp[SSL_SOCK_NUM_KEYTYPES];
906 };
907};
908
Emeric Brun1d3865b2014-06-20 15:37:32 +0200909static struct eb_root cert_ocsp_tree = EB_ROOT_UNIQUE;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200910
911/* This function starts to check if the OCSP response (in DER format) contained
912 * in chunk 'ocsp_response' is valid (else exits on error).
913 * If 'cid' is not NULL, it will be compared to the OCSP certificate ID
914 * contained in the OCSP Response and exits on error if no match.
915 * If it's a valid OCSP Response:
916 * If 'ocsp' is not NULL, the chunk is copied in the OCSP response's container
917 * pointed by 'ocsp'.
918 * If 'ocsp' is NULL, the function looks up into the OCSP response's
919 * containers tree (using as index the ASN1 form of the OCSP Certificate ID extracted
920 * from the response) and exits on error if not found. Finally, If an OCSP response is
921 * already present in the container, it will be overwritten.
922 *
923 * Note: OCSP response containing more than one OCSP Single response is not
924 * considered valid.
925 *
926 * Returns 0 on success, 1 in error case.
927 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200928static int ssl_sock_load_ocsp_response(struct buffer *ocsp_response,
929 struct certificate_ocsp *ocsp,
930 OCSP_CERTID *cid, char **err)
Emeric Brun4147b2e2014-06-16 18:36:30 +0200931{
932 OCSP_RESPONSE *resp;
933 OCSP_BASICRESP *bs = NULL;
934 OCSP_SINGLERESP *sr;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200935 OCSP_CERTID *id;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200936 unsigned char *p = (unsigned char *) ocsp_response->area;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200937 int rc , count_sr;
Emeric Brun13a6b482014-06-20 15:44:34 +0200938 ASN1_GENERALIZEDTIME *revtime, *thisupd, *nextupd = NULL;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200939 int reason;
940 int ret = 1;
941
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200942 resp = d2i_OCSP_RESPONSE(NULL, (const unsigned char **)&p,
943 ocsp_response->data);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200944 if (!resp) {
945 memprintf(err, "Unable to parse OCSP response");
946 goto out;
947 }
948
949 rc = OCSP_response_status(resp);
950 if (rc != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
951 memprintf(err, "OCSP response status not successful");
952 goto out;
953 }
954
955 bs = OCSP_response_get1_basic(resp);
956 if (!bs) {
957 memprintf(err, "Failed to get basic response from OCSP Response");
958 goto out;
959 }
960
961 count_sr = OCSP_resp_count(bs);
962 if (count_sr > 1) {
963 memprintf(err, "OCSP response ignored because contains multiple single responses (%d)", count_sr);
964 goto out;
965 }
966
967 sr = OCSP_resp_get0(bs, 0);
968 if (!sr) {
969 memprintf(err, "Failed to get OCSP single response");
970 goto out;
971 }
972
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200973 id = (OCSP_CERTID*)OCSP_SINGLERESP_get0_id(sr);
974
Emeric Brun4147b2e2014-06-16 18:36:30 +0200975 rc = OCSP_single_get0_status(sr, &reason, &revtime, &thisupd, &nextupd);
Emmanuel Hocdetef607052017-10-24 14:57:16 +0200976 if (rc != V_OCSP_CERTSTATUS_GOOD && rc != V_OCSP_CERTSTATUS_REVOKED) {
Emmanuel Hocdet872085c2017-10-10 15:18:52 +0200977 memprintf(err, "OCSP single response: certificate status is unknown");
Emeric Brun4147b2e2014-06-16 18:36:30 +0200978 goto out;
979 }
980
Emeric Brun13a6b482014-06-20 15:44:34 +0200981 if (!nextupd) {
982 memprintf(err, "OCSP single response: missing nextupdate");
983 goto out;
984 }
985
Emeric Brunc8b27b62014-06-19 14:16:17 +0200986 rc = OCSP_check_validity(thisupd, nextupd, OCSP_MAX_RESPONSE_TIME_SKEW, -1);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200987 if (!rc) {
988 memprintf(err, "OCSP single response: no longer valid.");
989 goto out;
990 }
991
992 if (cid) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200993 if (OCSP_id_cmp(id, cid)) {
Emeric Brun4147b2e2014-06-16 18:36:30 +0200994 memprintf(err, "OCSP single response: Certificate ID does not match certificate and issuer");
995 goto out;
996 }
997 }
998
999 if (!ocsp) {
1000 unsigned char key[OCSP_MAX_CERTID_ASN1_LENGTH];
1001 unsigned char *p;
1002
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001003 rc = i2d_OCSP_CERTID(id, NULL);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001004 if (!rc) {
1005 memprintf(err, "OCSP single response: Unable to encode Certificate ID");
1006 goto out;
1007 }
1008
1009 if (rc > OCSP_MAX_CERTID_ASN1_LENGTH) {
1010 memprintf(err, "OCSP single response: Certificate ID too long");
1011 goto out;
1012 }
1013
1014 p = key;
1015 memset(key, 0, OCSP_MAX_CERTID_ASN1_LENGTH);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001016 i2d_OCSP_CERTID(id, &p);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001017 ocsp = (struct certificate_ocsp *)ebmb_lookup(&cert_ocsp_tree, key, OCSP_MAX_CERTID_ASN1_LENGTH);
1018 if (!ocsp) {
1019 memprintf(err, "OCSP single response: Certificate ID does not match any certificate or issuer");
1020 goto out;
1021 }
1022 }
1023
1024 /* According to comments on "chunk_dup", the
1025 previous chunk buffer will be freed */
1026 if (!chunk_dup(&ocsp->response, ocsp_response)) {
1027 memprintf(err, "OCSP response: Memory allocation error");
1028 goto out;
1029 }
1030
Emeric Brun4f3c87a2014-06-20 15:46:13 +02001031 ocsp->expire = asn1_generalizedtime_to_epoch(nextupd) - OCSP_MAX_RESPONSE_TIME_SKEW;
1032
Emeric Brun4147b2e2014-06-16 18:36:30 +02001033 ret = 0;
1034out:
Janusz Dziemidowicz8d710492017-03-08 16:59:41 +01001035 ERR_clear_error();
1036
Emeric Brun4147b2e2014-06-16 18:36:30 +02001037 if (bs)
1038 OCSP_BASICRESP_free(bs);
1039
1040 if (resp)
1041 OCSP_RESPONSE_free(resp);
1042
1043 return ret;
1044}
1045/*
1046 * External function use to update the OCSP response in the OCSP response's
1047 * containers tree. The chunk 'ocsp_response' must contain the OCSP response
1048 * to update in DER format.
1049 *
1050 * Returns 0 on success, 1 in error case.
1051 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001052int ssl_sock_update_ocsp_response(struct buffer *ocsp_response, char **err)
Emeric Brun4147b2e2014-06-16 18:36:30 +02001053{
1054 return ssl_sock_load_ocsp_response(ocsp_response, NULL, NULL, err);
1055}
1056
William Lallemand4a660132019-10-14 14:51:41 +02001057#endif
1058
1059#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
Emeric Brun4147b2e2014-06-16 18:36:30 +02001060/*
1061 * This function load the OCSP Resonse in DER format contained in file at
William Lallemand3b5f3602019-10-16 18:05:05 +02001062 * path 'ocsp_path' or base64 in a buffer <buf>
Emeric Brun4147b2e2014-06-16 18:36:30 +02001063 *
1064 * Returns 0 on success, 1 in error case.
1065 */
William Lallemand3b5f3602019-10-16 18:05:05 +02001066static int ssl_sock_load_ocsp_response_from_file(const char *ocsp_path, char *buf, struct cert_key_and_chain *ckch, char **err)
Emeric Brun4147b2e2014-06-16 18:36:30 +02001067{
1068 int fd = -1;
1069 int r = 0;
1070 int ret = 1;
William Lallemand3b5f3602019-10-16 18:05:05 +02001071 struct buffer *ocsp_response;
1072 struct buffer *src = NULL;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001073
William Lallemand3b5f3602019-10-16 18:05:05 +02001074 if (buf) {
1075 int i, j;
1076 /* if it's from a buffer it will be base64 */
Emeric Brun4147b2e2014-06-16 18:36:30 +02001077
William Lallemand3b5f3602019-10-16 18:05:05 +02001078 /* remove \r and \n from the payload */
1079 for (i = 0, j = 0; buf[i]; i++) {
1080 if (buf[i] == '\r' || buf[i] == '\n')
Emeric Brun4147b2e2014-06-16 18:36:30 +02001081 continue;
William Lallemand3b5f3602019-10-16 18:05:05 +02001082 buf[j++] = buf[i];
1083 }
1084 buf[j] = 0;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001085
William Lallemand3b5f3602019-10-16 18:05:05 +02001086 ret = base64dec(buf, j, trash.area, trash.size);
1087 if (ret < 0) {
1088 memprintf(err, "Error reading OCSP response in base64 format");
Emeric Brun4147b2e2014-06-16 18:36:30 +02001089 goto end;
1090 }
William Lallemand3b5f3602019-10-16 18:05:05 +02001091 trash.data = ret;
1092 src = &trash;
1093 } else {
1094 fd = open(ocsp_path, O_RDONLY);
1095 if (fd == -1) {
1096 memprintf(err, "Error opening OCSP response file");
1097 goto end;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001098 }
William Lallemand3b5f3602019-10-16 18:05:05 +02001099
1100 trash.data = 0;
1101 while (trash.data < trash.size) {
1102 r = read(fd, trash.area + trash.data, trash.size - trash.data);
1103 if (r < 0) {
1104 if (errno == EINTR)
1105 continue;
1106
1107 memprintf(err, "Error reading OCSP response from file");
1108 goto end;
1109 }
1110 else if (r == 0) {
1111 break;
1112 }
1113 trash.data += r;
1114 }
1115 close(fd);
1116 fd = -1;
1117 src = &trash;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001118 }
1119
William Lallemand3b5f3602019-10-16 18:05:05 +02001120 ocsp_response = calloc(1, sizeof(*ocsp_response));
1121 if (!chunk_dup(ocsp_response, src)) {
1122 free(ocsp_response);
1123 ocsp_response = NULL;
William Lallemand246c0242019-10-11 08:59:13 +02001124 goto end;
1125 }
Emmanuel Hocdet0667fae2020-01-16 14:41:36 +01001126 /* no error, fill ckch with new context, old context must be free */
1127 if (ckch->ocsp_response) {
1128 free(ckch->ocsp_response->area);
1129 ckch->ocsp_response->area = NULL;
1130 free(ckch->ocsp_response);
1131 }
William Lallemand3b5f3602019-10-16 18:05:05 +02001132 ckch->ocsp_response = ocsp_response;
William Lallemande0f48ae2019-10-15 13:44:57 +02001133 ret = 0;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001134end:
1135 if (fd != -1)
1136 close(fd);
1137
1138 return ret;
1139}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01001140#endif
Emeric Brun4147b2e2014-06-16 18:36:30 +02001141
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001142#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
1143static int ssl_tlsext_ticket_key_cb(SSL *s, unsigned char key_name[16], unsigned char *iv, EVP_CIPHER_CTX *ectx, HMAC_CTX *hctx, int enc)
1144{
Christopher Faulet16f45c82018-02-16 11:23:49 +01001145 struct tls_keys_ref *ref;
Emeric Brun9e754772019-01-10 17:51:55 +01001146 union tls_sess_key *keys;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001147 struct connection *conn;
1148 int head;
1149 int i;
Christopher Faulet16f45c82018-02-16 11:23:49 +01001150 int ret = -1; /* error by default */
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001151
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001152 conn = SSL_get_ex_data(s, ssl_app_data_index);
Willy Tarreau07d94e42018-09-20 10:57:52 +02001153 ref = __objt_listener(conn->target)->bind_conf->keys_ref;
Christopher Faulet16f45c82018-02-16 11:23:49 +01001154 HA_RWLOCK_RDLOCK(TLSKEYS_REF_LOCK, &ref->lock);
1155
1156 keys = ref->tlskeys;
1157 head = ref->tls_ticket_enc_index;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001158
1159 if (enc) {
1160 memcpy(key_name, keys[head].name, 16);
1161
1162 if(!RAND_pseudo_bytes(iv, EVP_MAX_IV_LENGTH))
Christopher Faulet16f45c82018-02-16 11:23:49 +01001163 goto end;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001164
Emeric Brun9e754772019-01-10 17:51:55 +01001165 if (ref->key_size_bits == 128) {
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001166
Emeric Brun9e754772019-01-10 17:51:55 +01001167 if(!EVP_EncryptInit_ex(ectx, EVP_aes_128_cbc(), NULL, keys[head].key_128.aes_key, iv))
1168 goto end;
1169
Willy Tarreau9356dac2019-05-10 09:22:53 +02001170 HMAC_Init_ex(hctx, keys[head].key_128.hmac_key, 16, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +01001171 ret = 1;
1172 }
1173 else if (ref->key_size_bits == 256 ) {
1174
1175 if(!EVP_EncryptInit_ex(ectx, EVP_aes_256_cbc(), NULL, keys[head].key_256.aes_key, iv))
1176 goto end;
1177
Willy Tarreau9356dac2019-05-10 09:22:53 +02001178 HMAC_Init_ex(hctx, keys[head].key_256.hmac_key, 32, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +01001179 ret = 1;
1180 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001181 } else {
1182 for (i = 0; i < TLS_TICKETS_NO; i++) {
1183 if (!memcmp(key_name, keys[(head + i) % TLS_TICKETS_NO].name, 16))
1184 goto found;
1185 }
Christopher Faulet16f45c82018-02-16 11:23:49 +01001186 ret = 0;
1187 goto end;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001188
Christopher Faulet16f45c82018-02-16 11:23:49 +01001189 found:
Emeric Brun9e754772019-01-10 17:51:55 +01001190 if (ref->key_size_bits == 128) {
Willy Tarreau9356dac2019-05-10 09:22:53 +02001191 HMAC_Init_ex(hctx, keys[(head + i) % TLS_TICKETS_NO].key_128.hmac_key, 16, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +01001192 if(!EVP_DecryptInit_ex(ectx, EVP_aes_128_cbc(), NULL, keys[(head + i) % TLS_TICKETS_NO].key_128.aes_key, iv))
1193 goto end;
1194 /* 2 for key renewal, 1 if current key is still valid */
1195 ret = i ? 2 : 1;
1196 }
1197 else if (ref->key_size_bits == 256) {
Willy Tarreau9356dac2019-05-10 09:22:53 +02001198 HMAC_Init_ex(hctx, keys[(head + i) % TLS_TICKETS_NO].key_256.hmac_key, 32, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +01001199 if(!EVP_DecryptInit_ex(ectx, EVP_aes_256_cbc(), NULL, keys[(head + i) % TLS_TICKETS_NO].key_256.aes_key, iv))
1200 goto end;
1201 /* 2 for key renewal, 1 if current key is still valid */
1202 ret = i ? 2 : 1;
1203 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001204 }
Emeric Brun9e754772019-01-10 17:51:55 +01001205
Christopher Faulet16f45c82018-02-16 11:23:49 +01001206 end:
1207 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
1208 return ret;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001209}
1210
1211struct tls_keys_ref *tlskeys_ref_lookup(const char *filename)
1212{
1213 struct tls_keys_ref *ref;
1214
1215 list_for_each_entry(ref, &tlskeys_reference, list)
1216 if (ref->filename && strcmp(filename, ref->filename) == 0)
1217 return ref;
1218 return NULL;
1219}
1220
1221struct tls_keys_ref *tlskeys_ref_lookupid(int unique_id)
1222{
1223 struct tls_keys_ref *ref;
1224
1225 list_for_each_entry(ref, &tlskeys_reference, list)
1226 if (ref->unique_id == unique_id)
1227 return ref;
1228 return NULL;
1229}
1230
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001231/* Update the key into ref: if keysize doesn't
Emeric Brun9e754772019-01-10 17:51:55 +01001232 * match existing ones, this function returns -1
1233 * else it returns 0 on success.
1234 */
1235int ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref,
Willy Tarreau83061a82018-07-13 11:56:34 +02001236 struct buffer *tlskey)
Christopher Faulet16f45c82018-02-16 11:23:49 +01001237{
Emeric Brun9e754772019-01-10 17:51:55 +01001238 if (ref->key_size_bits == 128) {
1239 if (tlskey->data != sizeof(struct tls_sess_key_128))
1240 return -1;
1241 }
1242 else if (ref->key_size_bits == 256) {
1243 if (tlskey->data != sizeof(struct tls_sess_key_256))
1244 return -1;
1245 }
1246 else
1247 return -1;
1248
Christopher Faulet16f45c82018-02-16 11:23:49 +01001249 HA_RWLOCK_WRLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001250 memcpy((char *) (ref->tlskeys + ((ref->tls_ticket_enc_index + 2) % TLS_TICKETS_NO)),
1251 tlskey->area, tlskey->data);
Christopher Faulet16f45c82018-02-16 11:23:49 +01001252 ref->tls_ticket_enc_index = (ref->tls_ticket_enc_index + 1) % TLS_TICKETS_NO;
1253 HA_RWLOCK_WRUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Emeric Brun9e754772019-01-10 17:51:55 +01001254
1255 return 0;
Christopher Faulet16f45c82018-02-16 11:23:49 +01001256}
1257
Willy Tarreau83061a82018-07-13 11:56:34 +02001258int ssl_sock_update_tlskey(char *filename, struct buffer *tlskey, char **err)
Christopher Faulet16f45c82018-02-16 11:23:49 +01001259{
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001260 struct tls_keys_ref *ref = tlskeys_ref_lookup(filename);
1261
1262 if(!ref) {
1263 memprintf(err, "Unable to locate the referenced filename: %s", filename);
1264 return 1;
1265 }
Emeric Brun9e754772019-01-10 17:51:55 +01001266 if (ssl_sock_update_tlskey_ref(ref, tlskey) < 0) {
1267 memprintf(err, "Invalid key size");
1268 return 1;
1269 }
1270
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001271 return 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001272}
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001273
1274/* This function finalize the configuration parsing. Its set all the
Willy Tarreaud1c57502016-12-22 22:46:15 +01001275 * automatic ids. It's called just after the basic checks. It returns
1276 * 0 on success otherwise ERR_*.
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001277 */
Willy Tarreaud1c57502016-12-22 22:46:15 +01001278static int tlskeys_finalize_config(void)
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001279{
1280 int i = 0;
1281 struct tls_keys_ref *ref, *ref2, *ref3;
1282 struct list tkr = LIST_HEAD_INIT(tkr);
1283
1284 list_for_each_entry(ref, &tlskeys_reference, list) {
1285 if (ref->unique_id == -1) {
1286 /* Look for the first free id. */
1287 while (1) {
1288 list_for_each_entry(ref2, &tlskeys_reference, list) {
1289 if (ref2->unique_id == i) {
1290 i++;
1291 break;
1292 }
1293 }
1294 if (&ref2->list == &tlskeys_reference)
1295 break;
1296 }
1297
1298 /* Uses the unique id and increment it for the next entry. */
1299 ref->unique_id = i;
1300 i++;
1301 }
1302 }
1303
1304 /* This sort the reference list by id. */
1305 list_for_each_entry_safe(ref, ref2, &tlskeys_reference, list) {
1306 LIST_DEL(&ref->list);
1307 list_for_each_entry(ref3, &tkr, list) {
1308 if (ref->unique_id < ref3->unique_id) {
1309 LIST_ADDQ(&ref3->list, &ref->list);
1310 break;
1311 }
1312 }
1313 if (&ref3->list == &tkr)
1314 LIST_ADDQ(&tkr, &ref->list);
1315 }
1316
1317 /* swap root */
1318 LIST_ADD(&tkr, &tlskeys_reference);
1319 LIST_DEL(&tkr);
Willy Tarreaud1c57502016-12-22 22:46:15 +01001320 return 0;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001321}
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001322#endif /* SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB */
1323
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01001324#ifndef OPENSSL_NO_OCSP
yanbzhube2774d2015-12-10 15:07:30 -05001325int ssl_sock_get_ocsp_arg_kt_index(int evp_keytype)
1326{
1327 switch (evp_keytype) {
1328 case EVP_PKEY_RSA:
1329 return 2;
1330 case EVP_PKEY_DSA:
1331 return 0;
1332 case EVP_PKEY_EC:
1333 return 1;
1334 }
1335
1336 return -1;
1337}
1338
Emeric Brun4147b2e2014-06-16 18:36:30 +02001339/*
1340 * Callback used to set OCSP status extension content in server hello.
1341 */
1342int ssl_sock_ocsp_stapling_cbk(SSL *ssl, void *arg)
1343{
yanbzhube2774d2015-12-10 15:07:30 -05001344 struct certificate_ocsp *ocsp;
1345 struct ocsp_cbk_arg *ocsp_arg;
1346 char *ssl_buf;
1347 EVP_PKEY *ssl_pkey;
1348 int key_type;
1349 int index;
1350
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001351 ocsp_arg = arg;
yanbzhube2774d2015-12-10 15:07:30 -05001352
1353 ssl_pkey = SSL_get_privatekey(ssl);
1354 if (!ssl_pkey)
1355 return SSL_TLSEXT_ERR_NOACK;
1356
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001357 key_type = EVP_PKEY_base_id(ssl_pkey);
yanbzhube2774d2015-12-10 15:07:30 -05001358
1359 if (ocsp_arg->is_single && ocsp_arg->single_kt == key_type)
1360 ocsp = ocsp_arg->s_ocsp;
1361 else {
1362 /* For multiple certs per context, we have to find the correct OCSP response based on
1363 * the certificate type
1364 */
1365 index = ssl_sock_get_ocsp_arg_kt_index(key_type);
1366
1367 if (index < 0)
1368 return SSL_TLSEXT_ERR_NOACK;
1369
1370 ocsp = ocsp_arg->m_ocsp[index];
1371
1372 }
Emeric Brun4147b2e2014-06-16 18:36:30 +02001373
1374 if (!ocsp ||
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001375 !ocsp->response.area ||
1376 !ocsp->response.data ||
Emeric Brun4f3c87a2014-06-20 15:46:13 +02001377 (ocsp->expire < now.tv_sec))
Emeric Brun4147b2e2014-06-16 18:36:30 +02001378 return SSL_TLSEXT_ERR_NOACK;
1379
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001380 ssl_buf = OPENSSL_malloc(ocsp->response.data);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001381 if (!ssl_buf)
1382 return SSL_TLSEXT_ERR_NOACK;
1383
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001384 memcpy(ssl_buf, ocsp->response.area, ocsp->response.data);
1385 SSL_set_tlsext_status_ocsp_resp(ssl, ssl_buf, ocsp->response.data);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001386
1387 return SSL_TLSEXT_ERR_OK;
1388}
1389
William Lallemand4a660132019-10-14 14:51:41 +02001390#endif
1391
1392#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
Emeric Brun4147b2e2014-06-16 18:36:30 +02001393/*
1394 * This function enables the handling of OCSP status extension on 'ctx' if a
William Lallemand246c0242019-10-11 08:59:13 +02001395 * ocsp_response buffer was found in the cert_key_and_chain. To enable OCSP
1396 * status extension, the issuer's certificate is mandatory. It should be
1397 * present in ckch->ocsp_issuer.
Emeric Brun4147b2e2014-06-16 18:36:30 +02001398 *
William Lallemand246c0242019-10-11 08:59:13 +02001399 * In addition, the ckch->ocsp_reponse buffer is loaded as a DER format of an
1400 * OCSP response. If file is empty or content is not a valid OCSP response,
1401 * OCSP status extension is enabled but OCSP response is ignored (a warning is
1402 * displayed).
Emeric Brun4147b2e2014-06-16 18:36:30 +02001403 *
1404 * Returns 1 if no ".ocsp" file found, 0 if OCSP status extension is
Joseph Herlant017b3da2018-11-15 09:07:59 -08001405 * successfully enabled, or -1 in other error case.
Emeric Brun4147b2e2014-06-16 18:36:30 +02001406 */
William Lallemand4a660132019-10-14 14:51:41 +02001407#ifndef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet6f507c72020-02-18 15:56:39 +01001408static int ssl_sock_load_ocsp(SSL_CTX *ctx, const struct cert_key_and_chain *ckch, STACK_OF(X509) *chain)
Emeric Brun4147b2e2014-06-16 18:36:30 +02001409{
Emmanuel Hocdet6f507c72020-02-18 15:56:39 +01001410 X509 *x, *issuer;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001411 OCSP_CERTID *cid = NULL;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001412 int i, ret = -1;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001413 struct certificate_ocsp *ocsp = NULL, *iocsp;
1414 char *warn = NULL;
1415 unsigned char *p;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001416 void (*callback) (void);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001417
Emeric Brun4147b2e2014-06-16 18:36:30 +02001418
William Lallemand246c0242019-10-11 08:59:13 +02001419 x = ckch->cert;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001420 if (!x)
1421 goto out;
1422
William Lallemand246c0242019-10-11 08:59:13 +02001423 issuer = ckch->ocsp_issuer;
Emmanuel Hocdet6f507c72020-02-18 15:56:39 +01001424 /* take issuer from chain over ocsp_issuer, is what is done historicaly */
1425 if (chain) {
1426 /* check if one of the certificate of the chain is the issuer */
1427 for (i = 0; i < sk_X509_num(chain); i++) {
1428 X509 *ti = sk_X509_value(chain, i);
1429 if (X509_check_issued(ti, x) == X509_V_OK) {
1430 issuer = ti;
1431 break;
1432 }
1433 }
1434 }
William Lallemand246c0242019-10-11 08:59:13 +02001435 if (!issuer)
1436 goto out;
Emeric Brun4147b2e2014-06-16 18:36:30 +02001437
1438 cid = OCSP_cert_to_id(0, x, issuer);
1439 if (!cid)
1440 goto out;
1441
1442 i = i2d_OCSP_CERTID(cid, NULL);
1443 if (!i || (i > OCSP_MAX_CERTID_ASN1_LENGTH))
1444 goto out;
1445
Vincent Bernat02779b62016-04-03 13:48:43 +02001446 ocsp = calloc(1, sizeof(*ocsp));
Emeric Brun4147b2e2014-06-16 18:36:30 +02001447 if (!ocsp)
1448 goto out;
1449
1450 p = ocsp->key_data;
1451 i2d_OCSP_CERTID(cid, &p);
1452
1453 iocsp = (struct certificate_ocsp *)ebmb_insert(&cert_ocsp_tree, &ocsp->key, OCSP_MAX_CERTID_ASN1_LENGTH);
1454 if (iocsp == ocsp)
1455 ocsp = NULL;
1456
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001457#ifndef SSL_CTX_get_tlsext_status_cb
1458# define SSL_CTX_get_tlsext_status_cb(ctx, cb) \
1459 *cb = (void (*) (void))ctx->tlsext_status_cb;
1460#endif
1461 SSL_CTX_get_tlsext_status_cb(ctx, &callback);
1462
1463 if (!callback) {
Vincent Bernat02779b62016-04-03 13:48:43 +02001464 struct ocsp_cbk_arg *cb_arg = calloc(1, sizeof(*cb_arg));
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001465 EVP_PKEY *pkey;
yanbzhube2774d2015-12-10 15:07:30 -05001466
1467 cb_arg->is_single = 1;
1468 cb_arg->s_ocsp = iocsp;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001469
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001470 pkey = X509_get_pubkey(x);
1471 cb_arg->single_kt = EVP_PKEY_base_id(pkey);
1472 EVP_PKEY_free(pkey);
yanbzhube2774d2015-12-10 15:07:30 -05001473
1474 SSL_CTX_set_tlsext_status_cb(ctx, ssl_sock_ocsp_stapling_cbk);
1475 SSL_CTX_set_tlsext_status_arg(ctx, cb_arg);
1476 } else {
1477 /*
1478 * If the ctx has a status CB, then we have previously set an OCSP staple for this ctx
1479 * Update that cb_arg with the new cert's staple
1480 */
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001481 struct ocsp_cbk_arg *cb_arg;
yanbzhube2774d2015-12-10 15:07:30 -05001482 struct certificate_ocsp *tmp_ocsp;
1483 int index;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001484 int key_type;
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001485 EVP_PKEY *pkey;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001486
1487#ifdef SSL_CTX_get_tlsext_status_arg
1488 SSL_CTX_ctrl(ctx, SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG, 0, &cb_arg);
1489#else
1490 cb_arg = ctx->tlsext_status_arg;
1491#endif
yanbzhube2774d2015-12-10 15:07:30 -05001492
1493 /*
1494 * The following few lines will convert cb_arg from a single ocsp to multi ocsp
1495 * the order of operations below matter, take care when changing it
1496 */
1497 tmp_ocsp = cb_arg->s_ocsp;
1498 index = ssl_sock_get_ocsp_arg_kt_index(cb_arg->single_kt);
1499 cb_arg->s_ocsp = NULL;
1500 cb_arg->m_ocsp[index] = tmp_ocsp;
1501 cb_arg->is_single = 0;
1502 cb_arg->single_kt = 0;
1503
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001504 pkey = X509_get_pubkey(x);
1505 key_type = EVP_PKEY_base_id(pkey);
1506 EVP_PKEY_free(pkey);
1507
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001508 index = ssl_sock_get_ocsp_arg_kt_index(key_type);
yanbzhube2774d2015-12-10 15:07:30 -05001509 if (index >= 0 && !cb_arg->m_ocsp[index])
1510 cb_arg->m_ocsp[index] = iocsp;
1511
1512 }
Emeric Brun4147b2e2014-06-16 18:36:30 +02001513
1514 ret = 0;
1515
1516 warn = NULL;
William Lallemand246c0242019-10-11 08:59:13 +02001517 if (ssl_sock_load_ocsp_response(ckch->ocsp_response, ocsp, cid, &warn)) {
William Lallemand3b5f3602019-10-16 18:05:05 +02001518 memprintf(&warn, "Loading: %s. Content will be ignored", warn ? warn : "failure");
Christopher Faulet767a84b2017-11-24 16:50:31 +01001519 ha_warning("%s.\n", warn);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001520 }
1521
1522out:
Emeric Brun4147b2e2014-06-16 18:36:30 +02001523 if (cid)
1524 OCSP_CERTID_free(cid);
1525
1526 if (ocsp)
1527 free(ocsp);
1528
1529 if (warn)
1530 free(warn);
1531
Emeric Brun4147b2e2014-06-16 18:36:30 +02001532 return ret;
1533}
William Lallemand4a660132019-10-14 14:51:41 +02001534#else /* OPENSSL_IS_BORINGSSL */
Emmanuel Hocdet6f507c72020-02-18 15:56:39 +01001535static int ssl_sock_load_ocsp(SSL_CTX *ctx, const struct cert_key_and_chain *ckch, STACK_OF(X509) *chain)
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001536{
William Lallemand4a660132019-10-14 14:51:41 +02001537 return SSL_CTX_set_ocsp_response(ctx, (const uint8_t *)ckch->ocsp_response->area, ckch->ocsp_response->data);
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001538}
1539#endif
1540
William Lallemand4a660132019-10-14 14:51:41 +02001541#endif
1542
1543
Willy Tarreau5db847a2019-05-09 14:13:35 +02001544#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001545
1546#define CT_EXTENSION_TYPE 18
1547
1548static int sctl_ex_index = -1;
1549
1550/*
1551 * Try to parse Signed Certificate Timestamp List structure. This function
1552 * makes only basic test if the data seems like SCTL. No signature validation
1553 * is performed.
1554 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001555static int ssl_sock_parse_sctl(struct buffer *sctl)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001556{
1557 int ret = 1;
1558 int len, pos, sct_len;
1559 unsigned char *data;
1560
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001561 if (sctl->data < 2)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001562 goto out;
1563
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001564 data = (unsigned char *) sctl->area;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001565 len = (data[0] << 8) | data[1];
1566
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001567 if (len + 2 != sctl->data)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001568 goto out;
1569
1570 data = data + 2;
1571 pos = 0;
1572 while (pos < len) {
1573 if (len - pos < 2)
1574 goto out;
1575
1576 sct_len = (data[pos] << 8) | data[pos + 1];
1577 if (pos + sct_len + 2 > len)
1578 goto out;
1579
1580 pos += sct_len + 2;
1581 }
1582
1583 ret = 0;
1584
1585out:
1586 return ret;
1587}
1588
William Lallemand0dfae6c2019-10-16 18:06:58 +02001589/* Try to load a sctl from a buffer <buf> if not NULL, or read the file <sctl_path>
1590 * It fills the ckch->sctl buffer
1591 * return 0 on success or != 0 on failure */
1592static int ssl_sock_load_sctl_from_file(const char *sctl_path, char *buf, struct cert_key_and_chain *ckch, char **err)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001593{
1594 int fd = -1;
1595 int r = 0;
1596 int ret = 1;
William Lallemand0dfae6c2019-10-16 18:06:58 +02001597 struct buffer tmp;
1598 struct buffer *src;
1599 struct buffer *sctl;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001600
William Lallemand0dfae6c2019-10-16 18:06:58 +02001601 if (buf) {
1602 tmp.area = buf;
1603 tmp.data = strlen(buf);
1604 tmp.size = tmp.data + 1;
1605 src = &tmp;
1606 } else {
1607 fd = open(sctl_path, O_RDONLY);
1608 if (fd == -1)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001609 goto end;
William Lallemand0dfae6c2019-10-16 18:06:58 +02001610
1611 trash.data = 0;
1612 while (trash.data < trash.size) {
1613 r = read(fd, trash.area + trash.data, trash.size - trash.data);
1614 if (r < 0) {
1615 if (errno == EINTR)
1616 continue;
1617 goto end;
1618 }
1619 else if (r == 0) {
1620 break;
1621 }
1622 trash.data += r;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001623 }
William Lallemand0dfae6c2019-10-16 18:06:58 +02001624 src = &trash;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001625 }
1626
William Lallemand0dfae6c2019-10-16 18:06:58 +02001627 ret = ssl_sock_parse_sctl(src);
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001628 if (ret)
1629 goto end;
1630
William Lallemand0dfae6c2019-10-16 18:06:58 +02001631 sctl = calloc(1, sizeof(*sctl));
1632 if (!chunk_dup(sctl, src)) {
1633 free(sctl);
1634 sctl = NULL;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001635 goto end;
1636 }
Emmanuel Hocdet224a0872020-01-16 15:15:49 +01001637 /* no error, fill ckch with new context, old context must be free */
1638 if (ckch->sctl) {
1639 free(ckch->sctl->area);
1640 ckch->sctl->area = NULL;
1641 free(ckch->sctl);
1642 }
William Lallemand0dfae6c2019-10-16 18:06:58 +02001643 ckch->sctl = sctl;
Emmanuel Hocdet224a0872020-01-16 15:15:49 +01001644 ret = 0;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001645end:
1646 if (fd != -1)
1647 close(fd);
1648
1649 return ret;
1650}
1651
1652int ssl_sock_sctl_add_cbk(SSL *ssl, unsigned ext_type, const unsigned char **out, size_t *outlen, int *al, void *add_arg)
1653{
Willy Tarreau83061a82018-07-13 11:56:34 +02001654 struct buffer *sctl = add_arg;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001655
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001656 *out = (unsigned char *) sctl->area;
1657 *outlen = sctl->data;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001658
1659 return 1;
1660}
1661
1662int ssl_sock_sctl_parse_cbk(SSL *s, unsigned int ext_type, const unsigned char *in, size_t inlen, int *al, void *parse_arg)
1663{
1664 return 1;
1665}
1666
William Lallemanda17f4112019-10-10 15:16:44 +02001667static int ssl_sock_load_sctl(SSL_CTX *ctx, struct buffer *sctl)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001668{
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001669 int ret = -1;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001670
William Lallemanda17f4112019-10-10 15:16:44 +02001671 if (!SSL_CTX_add_server_custom_ext(ctx, CT_EXTENSION_TYPE, ssl_sock_sctl_add_cbk, NULL, sctl, ssl_sock_sctl_parse_cbk, NULL))
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001672 goto out;
1673
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001674 SSL_CTX_set_ex_data(ctx, sctl_ex_index, sctl);
1675
1676 ret = 0;
1677
1678out:
1679 return ret;
1680}
1681
1682#endif
1683
Emeric Brune1f38db2012-09-03 20:36:47 +02001684void ssl_sock_infocbk(const SSL *ssl, int where, int ret)
1685{
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001686 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001687 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Emeric Brund8b2bb52014-01-28 15:43:53 +01001688 BIO *write_bio;
Willy Tarreau622317d2015-02-27 16:36:16 +01001689 (void)ret; /* shut gcc stupid warning */
Emeric Brune1f38db2012-09-03 20:36:47 +02001690
Dirkjan Bussink526894f2019-01-21 09:35:03 -08001691#ifndef SSL_OP_NO_RENEGOTIATION
1692 /* Please note that BoringSSL defines this macro to zero so don't
1693 * change this to #if and do not assign a default value to this macro!
1694 */
Emeric Brune1f38db2012-09-03 20:36:47 +02001695 if (where & SSL_CB_HANDSHAKE_START) {
1696 /* Disable renegotiation (CVE-2009-3555) */
Willy Tarreauc192b0a2020-01-23 09:11:58 +01001697 if ((conn->flags & (CO_FL_WAIT_L6_CONN | CO_FL_EARLY_SSL_HS | CO_FL_EARLY_DATA)) == 0) {
Emeric Brune1f38db2012-09-03 20:36:47 +02001698 conn->flags |= CO_FL_ERROR;
Willy Tarreau20879a02012-12-03 16:32:10 +01001699 conn->err_code = CO_ER_SSL_RENEG;
1700 }
Emeric Brune1f38db2012-09-03 20:36:47 +02001701 }
Dirkjan Bussink526894f2019-01-21 09:35:03 -08001702#endif
Emeric Brund8b2bb52014-01-28 15:43:53 +01001703
1704 if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001705 if (!(ctx->xprt_st & SSL_SOCK_ST_FL_16K_WBFSIZE)) {
Emeric Brund8b2bb52014-01-28 15:43:53 +01001706 /* Long certificate chains optimz
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001707 If write and read bios are different, we
Emeric Brund8b2bb52014-01-28 15:43:53 +01001708 consider that the buffering was activated,
1709 so we rise the output buffer size from 4k
1710 to 16k */
1711 write_bio = SSL_get_wbio(ssl);
1712 if (write_bio != SSL_get_rbio(ssl)) {
1713 BIO_set_write_buffer_size(write_bio, 16384);
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001714 ctx->xprt_st |= SSL_SOCK_ST_FL_16K_WBFSIZE;
Emeric Brund8b2bb52014-01-28 15:43:53 +01001715 }
1716 }
1717 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02001718}
1719
Emeric Brune64aef12012-09-21 13:15:06 +02001720/* Callback is called for each certificate of the chain during a verify
1721 ok is set to 1 if preverify detect no error on current certificate.
1722 Returns 0 to break the handshake, 1 otherwise. */
Evan Broderbe554312013-06-27 00:05:25 -07001723int ssl_sock_bind_verifycbk(int ok, X509_STORE_CTX *x_store)
Emeric Brune64aef12012-09-21 13:15:06 +02001724{
1725 SSL *ssl;
1726 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001727 struct ssl_sock_ctx *ctx;
Emeric Brun81c00f02012-09-21 14:31:21 +02001728 int err, depth;
Emeric Brune64aef12012-09-21 13:15:06 +02001729
1730 ssl = X509_STORE_CTX_get_ex_data(x_store, SSL_get_ex_data_X509_STORE_CTX_idx());
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001731 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Emeric Brune64aef12012-09-21 13:15:06 +02001732
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001733 ctx = conn->xprt_ctx;
1734
1735 ctx->xprt_st |= SSL_SOCK_ST_FL_VERIFY_DONE;
Emeric Brune64aef12012-09-21 13:15:06 +02001736
Emeric Brun81c00f02012-09-21 14:31:21 +02001737 if (ok) /* no errors */
1738 return ok;
1739
1740 depth = X509_STORE_CTX_get_error_depth(x_store);
1741 err = X509_STORE_CTX_get_error(x_store);
1742
1743 /* check if CA error needs to be ignored */
1744 if (depth > 0) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001745 if (!SSL_SOCK_ST_TO_CA_ERROR(ctx->xprt_st)) {
1746 ctx->xprt_st |= SSL_SOCK_CA_ERROR_TO_ST(err);
1747 ctx->xprt_st |= SSL_SOCK_CAEDEPTH_TO_ST(depth);
Emeric Brunf282a812012-09-21 15:27:54 +02001748 }
1749
Willy Tarreau731248f2020-02-04 14:02:02 +01001750 if (err < 64 && __objt_listener(conn->target)->bind_conf->ca_ignerr & (1ULL << err)) {
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02001751 ssl_sock_dump_errors(conn);
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001752 ERR_clear_error();
Emeric Brun81c00f02012-09-21 14:31:21 +02001753 return 1;
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001754 }
Emeric Brun81c00f02012-09-21 14:31:21 +02001755
Willy Tarreau20879a02012-12-03 16:32:10 +01001756 conn->err_code = CO_ER_SSL_CA_FAIL;
Emeric Brun81c00f02012-09-21 14:31:21 +02001757 return 0;
1758 }
1759
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001760 if (!SSL_SOCK_ST_TO_CRTERROR(ctx->xprt_st))
1761 ctx->xprt_st |= SSL_SOCK_CRTERROR_TO_ST(err);
Emeric Brunf282a812012-09-21 15:27:54 +02001762
Emeric Brun81c00f02012-09-21 14:31:21 +02001763 /* check if certificate error needs to be ignored */
Willy Tarreau731248f2020-02-04 14:02:02 +01001764 if (err < 64 && __objt_listener(conn->target)->bind_conf->crt_ignerr & (1ULL << err)) {
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02001765 ssl_sock_dump_errors(conn);
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001766 ERR_clear_error();
Emeric Brun81c00f02012-09-21 14:31:21 +02001767 return 1;
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001768 }
Emeric Brun81c00f02012-09-21 14:31:21 +02001769
Willy Tarreau20879a02012-12-03 16:32:10 +01001770 conn->err_code = CO_ER_SSL_CRT_FAIL;
Emeric Brun81c00f02012-09-21 14:31:21 +02001771 return 0;
Emeric Brune64aef12012-09-21 13:15:06 +02001772}
1773
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001774static inline
1775void ssl_sock_parse_clienthello(int write_p, int version, int content_type,
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001776 const void *buf, size_t len, SSL *ssl)
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001777{
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001778 struct ssl_capture *capture;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001779 unsigned char *msg;
1780 unsigned char *end;
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001781 size_t rec_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001782
1783 /* This function is called for "from client" and "to server"
1784 * connections. The combination of write_p == 0 and content_type == 22
Joseph Herlant017b3da2018-11-15 09:07:59 -08001785 * is only available during "from client" connection.
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001786 */
1787
1788 /* "write_p" is set to 0 is the bytes are received messages,
1789 * otherwise it is set to 1.
1790 */
1791 if (write_p != 0)
1792 return;
1793
1794 /* content_type contains the type of message received or sent
1795 * according with the SSL/TLS protocol spec. This message is
1796 * encoded with one byte. The value 256 (two bytes) is used
1797 * for designing the SSL/TLS record layer. According with the
1798 * rfc6101, the expected message (other than 256) are:
1799 * - change_cipher_spec(20)
1800 * - alert(21)
1801 * - handshake(22)
1802 * - application_data(23)
1803 * - (255)
1804 * We are interessed by the handshake and specially the client
1805 * hello.
1806 */
1807 if (content_type != 22)
1808 return;
1809
1810 /* The message length is at least 4 bytes, containing the
1811 * message type and the message length.
1812 */
1813 if (len < 4)
1814 return;
1815
1816 /* First byte of the handshake message id the type of
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001817 * message. The known types are:
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001818 * - hello_request(0)
1819 * - client_hello(1)
1820 * - server_hello(2)
1821 * - certificate(11)
1822 * - server_key_exchange (12)
1823 * - certificate_request(13)
1824 * - server_hello_done(14)
1825 * We are interested by the client hello.
1826 */
1827 msg = (unsigned char *)buf;
1828 if (msg[0] != 1)
1829 return;
1830
1831 /* Next three bytes are the length of the message. The total length
1832 * must be this decoded length + 4. If the length given as argument
1833 * is not the same, we abort the protocol dissector.
1834 */
1835 rec_len = (msg[1] << 16) + (msg[2] << 8) + msg[3];
1836 if (len < rec_len + 4)
1837 return;
1838 msg += 4;
1839 end = msg + rec_len;
1840 if (end < msg)
1841 return;
1842
1843 /* Expect 2 bytes for protocol version (1 byte for major and 1 byte
1844 * for minor, the random, composed by 4 bytes for the unix time and
Baptiste Assmann6be139f2018-11-28 15:20:25 +01001845 * 28 bytes for unix payload. So we jump 1 + 1 + 4 + 28.
1846 */
1847 msg += 1 + 1 + 4 + 28;
1848 if (msg > end)
1849 return;
1850
1851 /* Next, is session id:
1852 * if present, we have to jump by length + 1 for the size information
1853 * if not present, we have to jump by 1 only
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001854 */
Baptiste Assmann6be139f2018-11-28 15:20:25 +01001855 if (msg[0] > 0)
1856 msg += msg[0];
1857 msg += 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001858 if (msg > end)
1859 return;
1860
1861 /* Next two bytes are the ciphersuite length. */
1862 if (msg + 2 > end)
1863 return;
1864 rec_len = (msg[0] << 8) + msg[1];
1865 msg += 2;
1866 if (msg + rec_len > end || msg + rec_len < msg)
1867 return;
1868
Willy Tarreaubafbe012017-11-24 17:34:44 +01001869 capture = pool_alloc_dirty(pool_head_ssl_capture);
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001870 if (!capture)
1871 return;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001872 /* Compute the xxh64 of the ciphersuite. */
1873 capture->xxh64 = XXH64(msg, rec_len, 0);
1874
1875 /* Capture the ciphersuite. */
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001876 capture->ciphersuite_len = (global_ssl.capture_cipherlist < rec_len) ?
1877 global_ssl.capture_cipherlist : rec_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001878 memcpy(capture->ciphersuite, msg, capture->ciphersuite_len);
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001879
1880 SSL_set_ex_data(ssl, ssl_capture_ptr_index, capture);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001881}
1882
Emeric Brun29f037d2014-04-25 19:05:36 +02001883/* Callback is called for ssl protocol analyse */
1884void ssl_sock_msgcbk(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)
1885{
Emeric Brun29f037d2014-04-25 19:05:36 +02001886#ifdef TLS1_RT_HEARTBEAT
1887 /* test heartbeat received (write_p is set to 0
1888 for a received record) */
Willy Tarreauf51c6982014-04-25 20:02:39 +02001889 if ((content_type == TLS1_RT_HEARTBEAT) && (write_p == 0)) {
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001890 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
William Lallemand7e1770b2019-05-13 14:31:34 +02001891 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001892 const unsigned char *p = buf;
1893 unsigned int payload;
1894
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001895 ctx->xprt_st |= SSL_SOCK_RECV_HEARTBEAT;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001896
1897 /* Check if this is a CVE-2014-0160 exploitation attempt. */
1898 if (*p != TLS1_HB_REQUEST)
1899 return;
1900
Willy Tarreauaeed6722014-04-25 23:59:58 +02001901 if (len < 1 + 2 + 16) /* 1 type + 2 size + 0 payload + 16 padding */
Willy Tarreauf51c6982014-04-25 20:02:39 +02001902 goto kill_it;
1903
1904 payload = (p[1] * 256) + p[2];
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001905 if (3 + payload + 16 <= len)
Willy Tarreauf51c6982014-04-25 20:02:39 +02001906 return; /* OK no problem */
Willy Tarreauaeed6722014-04-25 23:59:58 +02001907 kill_it:
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001908 /* We have a clear heartbleed attack (CVE-2014-0160), the
1909 * advertised payload is larger than the advertised packet
1910 * length, so we have garbage in the buffer between the
1911 * payload and the end of the buffer (p+len). We can't know
1912 * if the SSL stack is patched, and we don't know if we can
1913 * safely wipe out the area between p+3+len and payload.
1914 * So instead, we prevent the response from being sent by
1915 * setting the max_send_fragment to 0 and we report an SSL
1916 * error, which will kill this connection. It will be reported
1917 * above as SSL_ERROR_SSL while an other handshake failure with
Willy Tarreauf51c6982014-04-25 20:02:39 +02001918 * a heartbeat message will be reported as SSL_ERROR_SYSCALL.
1919 */
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001920 ssl->max_send_fragment = 0;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001921 SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_SSL_HANDSHAKE_FAILURE);
1922 return;
1923 }
Emeric Brun29f037d2014-04-25 19:05:36 +02001924#endif
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001925 if (global_ssl.capture_cipherlist > 0)
1926 ssl_sock_parse_clienthello(write_p, version, content_type, buf, len, ssl);
Emeric Brun29f037d2014-04-25 19:05:36 +02001927}
1928
Bernard Spil13c53f82018-02-15 13:34:58 +01001929#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houchardc7566002018-11-20 23:33:50 +01001930static int ssl_sock_srv_select_protos(SSL *s, unsigned char **out, unsigned char *outlen,
1931 const unsigned char *in, unsigned int inlen,
1932 void *arg)
1933{
1934 struct server *srv = arg;
1935
1936 if (SSL_select_next_proto(out, outlen, in, inlen, (unsigned char *)srv->ssl_ctx.npn_str,
1937 srv->ssl_ctx.npn_len) == OPENSSL_NPN_NEGOTIATED)
1938 return SSL_TLSEXT_ERR_OK;
1939 return SSL_TLSEXT_ERR_NOACK;
1940}
1941#endif
1942
1943#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02001944/* This callback is used so that the server advertises the list of
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001945 * negotiable protocols for NPN.
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02001946 */
1947static int ssl_sock_advertise_npn_protos(SSL *s, const unsigned char **data,
1948 unsigned int *len, void *arg)
1949{
Emmanuel Hocdet98263292016-12-29 18:26:15 +01001950 struct ssl_bind_conf *conf = arg;
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02001951
1952 *data = (const unsigned char *)conf->npn_str;
1953 *len = conf->npn_len;
1954 return SSL_TLSEXT_ERR_OK;
1955}
1956#endif
1957
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001958#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02001959/* This callback is used so that the server advertises the list of
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05001960 * negotiable protocols for ALPN.
Willy Tarreauab861d32013-04-02 02:30:41 +02001961 */
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001962static int ssl_sock_advertise_alpn_protos(SSL *s, const unsigned char **out,
1963 unsigned char *outlen,
1964 const unsigned char *server,
1965 unsigned int server_len, void *arg)
Willy Tarreauab861d32013-04-02 02:30:41 +02001966{
Emmanuel Hocdet98263292016-12-29 18:26:15 +01001967 struct ssl_bind_conf *conf = arg;
Willy Tarreauab861d32013-04-02 02:30:41 +02001968
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001969 if (SSL_select_next_proto((unsigned char**) out, outlen, (const unsigned char *)conf->alpn_str,
1970 conf->alpn_len, server, server_len) != OPENSSL_NPN_NEGOTIATED) {
1971 return SSL_TLSEXT_ERR_NOACK;
1972 }
Willy Tarreauab861d32013-04-02 02:30:41 +02001973 return SSL_TLSEXT_ERR_OK;
1974}
1975#endif
1976
Willy Tarreauc8ad3be2015-06-17 15:48:26 +02001977#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01001978#ifndef SSL_NO_GENERATE_CERTIFICATES
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02001979
Christopher Faulet30548802015-06-11 13:39:32 +02001980/* Create a X509 certificate with the specified servername and serial. This
1981 * function returns a SSL_CTX object or NULL if an error occurs. */
Christopher Faulet7969a332015-10-09 11:15:03 +02001982static SSL_CTX *
Christopher Faulet635c0ad2015-11-12 11:35:51 +01001983ssl_sock_do_create_cert(const char *servername, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet31af49d2015-06-09 17:29:50 +02001984{
Christopher Faulet7969a332015-10-09 11:15:03 +02001985 X509 *cacert = bind_conf->ca_sign_cert;
1986 EVP_PKEY *capkey = bind_conf->ca_sign_pkey;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001987 SSL_CTX *ssl_ctx = NULL;
1988 X509 *newcrt = NULL;
1989 EVP_PKEY *pkey = NULL;
Emmanuel Hocdet15969292017-08-11 10:56:00 +02001990 SSL *tmp_ssl = NULL;
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02001991 CONF *ctmp = NULL;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001992 X509_NAME *name;
1993 const EVP_MD *digest;
1994 X509V3_CTX ctx;
1995 unsigned int i;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001996 int key_type;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001997
Christopher Faulet48a83322017-07-28 16:56:09 +02001998 /* Get the private key of the default certificate and use it */
Willy Tarreau5db847a2019-05-09 14:13:35 +02001999#if (HA_OPENSSL_VERSION_NUMBER >= 0x10002000L)
Emmanuel Hocdet15969292017-08-11 10:56:00 +02002000 pkey = SSL_CTX_get0_privatekey(bind_conf->default_ctx);
2001#else
2002 tmp_ssl = SSL_new(bind_conf->default_ctx);
2003 if (tmp_ssl)
2004 pkey = SSL_get_privatekey(tmp_ssl);
2005#endif
2006 if (!pkey)
Christopher Faulet31af49d2015-06-09 17:29:50 +02002007 goto mkcert_error;
2008
2009 /* Create the certificate */
2010 if (!(newcrt = X509_new()))
2011 goto mkcert_error;
2012
2013 /* Set version number for the certificate (X509v3) and the serial
2014 * number */
2015 if (X509_set_version(newcrt, 2L) != 1)
2016 goto mkcert_error;
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01002017 ASN1_INTEGER_set(X509_get_serialNumber(newcrt), _HA_ATOMIC_ADD(&ssl_ctx_serial, 1));
Christopher Faulet31af49d2015-06-09 17:29:50 +02002018
2019 /* Set duration for the certificate */
Rosen Penev68185952018-12-14 08:47:02 -08002020 if (!X509_gmtime_adj(X509_getm_notBefore(newcrt), (long)-60*60*24) ||
2021 !X509_gmtime_adj(X509_getm_notAfter(newcrt),(long)60*60*24*365))
Christopher Faulet31af49d2015-06-09 17:29:50 +02002022 goto mkcert_error;
2023
2024 /* set public key in the certificate */
2025 if (X509_set_pubkey(newcrt, pkey) != 1)
2026 goto mkcert_error;
2027
2028 /* Set issuer name from the CA */
2029 if (!(name = X509_get_subject_name(cacert)))
2030 goto mkcert_error;
2031 if (X509_set_issuer_name(newcrt, name) != 1)
2032 goto mkcert_error;
2033
2034 /* Set the subject name using the same, but the CN */
2035 name = X509_NAME_dup(name);
2036 if (X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
2037 (const unsigned char *)servername,
2038 -1, -1, 0) != 1) {
2039 X509_NAME_free(name);
2040 goto mkcert_error;
2041 }
2042 if (X509_set_subject_name(newcrt, name) != 1) {
2043 X509_NAME_free(name);
2044 goto mkcert_error;
2045 }
2046 X509_NAME_free(name);
2047
2048 /* Add x509v3 extensions as specified */
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02002049 ctmp = NCONF_new(NULL);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002050 X509V3_set_ctx(&ctx, cacert, newcrt, NULL, NULL, 0);
2051 for (i = 0; i < X509V3_EXT_SIZE; i++) {
2052 X509_EXTENSION *ext;
2053
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02002054 if (!(ext = X509V3_EXT_nconf(ctmp, &ctx, x509v3_ext_names[i], x509v3_ext_values[i])))
Christopher Faulet31af49d2015-06-09 17:29:50 +02002055 goto mkcert_error;
2056 if (!X509_add_ext(newcrt, ext, -1)) {
2057 X509_EXTENSION_free(ext);
2058 goto mkcert_error;
2059 }
2060 X509_EXTENSION_free(ext);
2061 }
2062
2063 /* Sign the certificate with the CA private key */
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002064
2065 key_type = EVP_PKEY_base_id(capkey);
2066
2067 if (key_type == EVP_PKEY_DSA)
2068 digest = EVP_sha1();
2069 else if (key_type == EVP_PKEY_RSA)
Christopher Faulet31af49d2015-06-09 17:29:50 +02002070 digest = EVP_sha256();
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002071 else if (key_type == EVP_PKEY_EC)
Christopher Faulet7969a332015-10-09 11:15:03 +02002072 digest = EVP_sha256();
2073 else {
Willy Tarreau9a1ab082019-05-09 13:26:41 +02002074#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000000fL) && !defined(OPENSSL_IS_BORINGSSL)
Christopher Faulet7969a332015-10-09 11:15:03 +02002075 int nid;
2076
2077 if (EVP_PKEY_get_default_digest_nid(capkey, &nid) <= 0)
2078 goto mkcert_error;
2079 if (!(digest = EVP_get_digestbynid(nid)))
2080 goto mkcert_error;
Christopher Faulete7db2162015-10-19 13:59:24 +02002081#else
2082 goto mkcert_error;
2083#endif
Christopher Faulet7969a332015-10-09 11:15:03 +02002084 }
2085
Christopher Faulet31af49d2015-06-09 17:29:50 +02002086 if (!(X509_sign(newcrt, capkey, digest)))
2087 goto mkcert_error;
2088
2089 /* Create and set the new SSL_CTX */
2090 if (!(ssl_ctx = SSL_CTX_new(SSLv23_server_method())))
2091 goto mkcert_error;
2092 if (!SSL_CTX_use_PrivateKey(ssl_ctx, pkey))
2093 goto mkcert_error;
2094 if (!SSL_CTX_use_certificate(ssl_ctx, newcrt))
2095 goto mkcert_error;
2096 if (!SSL_CTX_check_private_key(ssl_ctx))
2097 goto mkcert_error;
2098
2099 if (newcrt) X509_free(newcrt);
Christopher Faulet7969a332015-10-09 11:15:03 +02002100
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01002101#ifndef OPENSSL_NO_DH
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02002102 SSL_CTX_set_tmp_dh_callback(ssl_ctx, ssl_get_tmp_dh);
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01002103#endif
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02002104#if defined(SSL_CTX_set_tmp_ecdh) && !defined(OPENSSL_NO_ECDH)
2105 {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01002106 const char *ecdhe = (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe : ECDHE_DEFAULT_CURVE);
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02002107 EC_KEY *ecc;
2108 int nid;
2109
2110 if ((nid = OBJ_sn2nid(ecdhe)) == NID_undef)
2111 goto end;
2112 if (!(ecc = EC_KEY_new_by_curve_name(nid)))
2113 goto end;
2114 SSL_CTX_set_tmp_ecdh(ssl_ctx, ecc);
2115 EC_KEY_free(ecc);
2116 }
2117#endif
2118 end:
Christopher Faulet31af49d2015-06-09 17:29:50 +02002119 return ssl_ctx;
2120
2121 mkcert_error:
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02002122 if (ctmp) NCONF_free(ctmp);
Emmanuel Hocdet15969292017-08-11 10:56:00 +02002123 if (tmp_ssl) SSL_free(tmp_ssl);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002124 if (ssl_ctx) SSL_CTX_free(ssl_ctx);
2125 if (newcrt) X509_free(newcrt);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002126 return NULL;
2127}
2128
Christopher Faulet7969a332015-10-09 11:15:03 +02002129SSL_CTX *
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002130ssl_sock_create_cert(struct connection *conn, const char *servername, unsigned int key)
Christopher Faulet7969a332015-10-09 11:15:03 +02002131{
Willy Tarreau07d94e42018-09-20 10:57:52 +02002132 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
Olivier Houchard66ab4982019-02-26 18:37:15 +01002133 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002134
Olivier Houchard66ab4982019-02-26 18:37:15 +01002135 return ssl_sock_do_create_cert(servername, bind_conf, ctx->ssl);
Christopher Faulet7969a332015-10-09 11:15:03 +02002136}
2137
Christopher Faulet30548802015-06-11 13:39:32 +02002138/* Do a lookup for a certificate in the LRU cache used to store generated
Emeric Brun821bb9b2017-06-15 16:37:39 +02002139 * certificates and immediately assign it to the SSL session if not null. */
Christopher Faulet30548802015-06-11 13:39:32 +02002140SSL_CTX *
Emeric Brun821bb9b2017-06-15 16:37:39 +02002141ssl_sock_assign_generated_cert(unsigned int key, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet30548802015-06-11 13:39:32 +02002142{
2143 struct lru64 *lru = NULL;
2144
2145 if (ssl_ctx_lru_tree) {
Willy Tarreau03f4ec42018-05-17 10:56:47 +02002146 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002147 lru = lru64_lookup(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
Emeric Brun821bb9b2017-06-15 16:37:39 +02002148 if (lru && lru->domain) {
2149 if (ssl)
2150 SSL_set_SSL_CTX(ssl, (SSL_CTX *)lru->data);
Willy Tarreau03f4ec42018-05-17 10:56:47 +02002151 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet30548802015-06-11 13:39:32 +02002152 return (SSL_CTX *)lru->data;
Emeric Brun821bb9b2017-06-15 16:37:39 +02002153 }
Willy Tarreau03f4ec42018-05-17 10:56:47 +02002154 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet30548802015-06-11 13:39:32 +02002155 }
2156 return NULL;
2157}
2158
Emeric Brun821bb9b2017-06-15 16:37:39 +02002159/* Same as <ssl_sock_assign_generated_cert> but without SSL session. This
2160 * function is not thread-safe, it should only be used to check if a certificate
2161 * exists in the lru cache (with no warranty it will not be removed by another
2162 * thread). It is kept for backward compatibility. */
2163SSL_CTX *
2164ssl_sock_get_generated_cert(unsigned int key, struct bind_conf *bind_conf)
2165{
2166 return ssl_sock_assign_generated_cert(key, bind_conf, NULL);
2167}
2168
Christopher Fauletd2cab922015-07-28 16:03:47 +02002169/* Set a certificate int the LRU cache used to store generated
2170 * certificate. Return 0 on success, otherwise -1 */
2171int
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002172ssl_sock_set_generated_cert(SSL_CTX *ssl_ctx, unsigned int key, struct bind_conf *bind_conf)
Christopher Faulet30548802015-06-11 13:39:32 +02002173{
2174 struct lru64 *lru = NULL;
2175
2176 if (ssl_ctx_lru_tree) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002177 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002178 lru = lru64_get(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
Emeric Brun821bb9b2017-06-15 16:37:39 +02002179 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002180 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002181 return -1;
Emeric Brun821bb9b2017-06-15 16:37:39 +02002182 }
Christopher Faulet30548802015-06-11 13:39:32 +02002183 if (lru->domain && lru->data)
2184 lru->free((SSL_CTX *)lru->data);
Christopher Faulet7969a332015-10-09 11:15:03 +02002185 lru64_commit(lru, ssl_ctx, bind_conf->ca_sign_cert, 0, (void (*)(void *))SSL_CTX_free);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002186 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002187 return 0;
Christopher Faulet30548802015-06-11 13:39:32 +02002188 }
Christopher Fauletd2cab922015-07-28 16:03:47 +02002189 return -1;
Christopher Faulet30548802015-06-11 13:39:32 +02002190}
2191
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002192/* Compute the key of the certificate. */
Christopher Faulet30548802015-06-11 13:39:32 +02002193unsigned int
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002194ssl_sock_generated_cert_key(const void *data, size_t len)
Christopher Faulet30548802015-06-11 13:39:32 +02002195{
2196 return XXH32(data, len, ssl_ctx_lru_seed);
2197}
2198
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002199/* Generate a cert and immediately assign it to the SSL session so that the cert's
2200 * refcount is maintained regardless of the cert's presence in the LRU cache.
2201 */
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002202static int
Christopher Faulet7969a332015-10-09 11:15:03 +02002203ssl_sock_generate_certificate(const char *servername, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet31af49d2015-06-09 17:29:50 +02002204{
2205 X509 *cacert = bind_conf->ca_sign_cert;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002206 SSL_CTX *ssl_ctx = NULL;
2207 struct lru64 *lru = NULL;
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002208 unsigned int key;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002209
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002210 key = ssl_sock_generated_cert_key(servername, strlen(servername));
Christopher Faulet31af49d2015-06-09 17:29:50 +02002211 if (ssl_ctx_lru_tree) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002212 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002213 lru = lru64_get(key, ssl_ctx_lru_tree, cacert, 0);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002214 if (lru && lru->domain)
2215 ssl_ctx = (SSL_CTX *)lru->data;
Christopher Fauletd2cab922015-07-28 16:03:47 +02002216 if (!ssl_ctx && lru) {
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002217 ssl_ctx = ssl_sock_do_create_cert(servername, bind_conf, ssl);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002218 lru64_commit(lru, ssl_ctx, cacert, 0, (void (*)(void *))SSL_CTX_free);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002219 }
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002220 SSL_set_SSL_CTX(ssl, ssl_ctx);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002221 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002222 return 1;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002223 }
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002224 else {
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002225 ssl_ctx = ssl_sock_do_create_cert(servername, bind_conf, ssl);
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002226 SSL_set_SSL_CTX(ssl, ssl_ctx);
2227 /* No LRU cache, this CTX will be released as soon as the session dies */
2228 SSL_CTX_free(ssl_ctx);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002229 return 1;
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002230 }
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002231 return 0;
2232}
2233static int
2234ssl_sock_generate_certificate_from_conn(struct bind_conf *bind_conf, SSL *ssl)
2235{
2236 unsigned int key;
Thierry FOURNIER28962c92018-06-17 21:37:05 +02002237 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002238
Willy Tarreauf5bdb642019-07-17 11:29:32 +02002239 if (conn_get_dst(conn)) {
Willy Tarreau085a1512019-07-17 14:47:35 +02002240 key = ssl_sock_generated_cert_key(conn->dst, get_addr_len(conn->dst));
Emeric Brun821bb9b2017-06-15 16:37:39 +02002241 if (ssl_sock_assign_generated_cert(key, bind_conf, ssl))
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002242 return 1;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002243 }
2244 return 0;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002245}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002246#endif /* !defined SSL_NO_GENERATE_CERTIFICATES */
Christopher Faulet31af49d2015-06-09 17:29:50 +02002247
Willy Tarreau9a1ab082019-05-09 13:26:41 +02002248#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002249typedef enum { SET_CLIENT, SET_SERVER } set_context_func;
2250
2251static void ctx_set_SSLv3_func(SSL_CTX *ctx, set_context_func c)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002252{
Emmanuel Hocdet23877ab2017-07-12 12:53:02 +02002253#if SSL_OP_NO_SSLv3
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002254 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, SSLv3_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002255 : SSL_CTX_set_ssl_version(ctx, SSLv3_client_method());
2256#endif
2257}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002258static void ctx_set_TLSv10_func(SSL_CTX *ctx, set_context_func c) {
2259 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002260 : SSL_CTX_set_ssl_version(ctx, TLSv1_client_method());
2261}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002262static void ctx_set_TLSv11_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002263#if SSL_OP_NO_TLSv1_1
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002264 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_1_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002265 : SSL_CTX_set_ssl_version(ctx, TLSv1_1_client_method());
2266#endif
2267}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002268static void ctx_set_TLSv12_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002269#if SSL_OP_NO_TLSv1_2
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002270 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_2_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002271 : SSL_CTX_set_ssl_version(ctx, TLSv1_2_client_method());
2272#endif
2273}
Bertrand Jacquina25282b2018-08-14 00:56:13 +01002274/* TLSv1.2 is the last supported version in this context. */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002275static void ctx_set_TLSv13_func(SSL_CTX *ctx, set_context_func c) {}
2276/* Unusable in this context. */
2277static void ssl_set_SSLv3_func(SSL *ssl, set_context_func c) {}
2278static void ssl_set_TLSv10_func(SSL *ssl, set_context_func c) {}
2279static void ssl_set_TLSv11_func(SSL *ssl, set_context_func c) {}
2280static void ssl_set_TLSv12_func(SSL *ssl, set_context_func c) {}
2281static void ssl_set_TLSv13_func(SSL *ssl, set_context_func c) {}
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002282#else /* openssl >= 1.1.0 */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002283typedef enum { SET_MIN, SET_MAX } set_context_func;
2284
2285static void ctx_set_SSLv3_func(SSL_CTX *ctx, set_context_func c) {
2286 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, SSL3_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002287 : SSL_CTX_set_min_proto_version(ctx, SSL3_VERSION);
2288}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002289static void ssl_set_SSLv3_func(SSL *ssl, set_context_func c) {
2290 c == SET_MAX ? SSL_set_max_proto_version(ssl, SSL3_VERSION)
2291 : SSL_set_min_proto_version(ssl, SSL3_VERSION);
2292}
2293static void ctx_set_TLSv10_func(SSL_CTX *ctx, set_context_func c) {
2294 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002295 : SSL_CTX_set_min_proto_version(ctx, TLS1_VERSION);
2296}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002297static void ssl_set_TLSv10_func(SSL *ssl, set_context_func c) {
2298 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_VERSION)
2299 : SSL_set_min_proto_version(ssl, TLS1_VERSION);
2300}
2301static void ctx_set_TLSv11_func(SSL_CTX *ctx, set_context_func c) {
2302 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_1_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002303 : SSL_CTX_set_min_proto_version(ctx, TLS1_1_VERSION);
2304}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002305static void ssl_set_TLSv11_func(SSL *ssl, set_context_func c) {
2306 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_1_VERSION)
2307 : SSL_set_min_proto_version(ssl, TLS1_1_VERSION);
2308}
2309static void ctx_set_TLSv12_func(SSL_CTX *ctx, set_context_func c) {
2310 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_2_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002311 : SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
2312}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002313static void ssl_set_TLSv12_func(SSL *ssl, set_context_func c) {
2314 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_2_VERSION)
2315 : SSL_set_min_proto_version(ssl, TLS1_2_VERSION);
2316}
2317static void ctx_set_TLSv13_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002318#if SSL_OP_NO_TLSv1_3
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002319 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002320 : SSL_CTX_set_min_proto_version(ctx, TLS1_3_VERSION);
2321#endif
2322}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002323static void ssl_set_TLSv13_func(SSL *ssl, set_context_func c) {
2324#if SSL_OP_NO_TLSv1_3
2325 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_3_VERSION)
2326 : SSL_set_min_proto_version(ssl, TLS1_3_VERSION);
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002327#endif
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002328}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002329#endif
2330static void ctx_set_None_func(SSL_CTX *ctx, set_context_func c) { }
2331static void ssl_set_None_func(SSL *ssl, set_context_func c) { }
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002332
2333static struct {
2334 int option;
2335 uint16_t flag;
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002336 void (*ctx_set_version)(SSL_CTX *, set_context_func);
2337 void (*ssl_set_version)(SSL *, set_context_func);
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002338 const char *name;
2339} methodVersions[] = {
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002340 {0, 0, ctx_set_None_func, ssl_set_None_func, "NONE"}, /* CONF_TLSV_NONE */
2341 {SSL_OP_NO_SSLv3, MC_SSL_O_NO_SSLV3, ctx_set_SSLv3_func, ssl_set_SSLv3_func, "SSLv3"}, /* CONF_SSLV3 */
2342 {SSL_OP_NO_TLSv1, MC_SSL_O_NO_TLSV10, ctx_set_TLSv10_func, ssl_set_TLSv10_func, "TLSv1.0"}, /* CONF_TLSV10 */
2343 {SSL_OP_NO_TLSv1_1, MC_SSL_O_NO_TLSV11, ctx_set_TLSv11_func, ssl_set_TLSv11_func, "TLSv1.1"}, /* CONF_TLSV11 */
2344 {SSL_OP_NO_TLSv1_2, MC_SSL_O_NO_TLSV12, ctx_set_TLSv12_func, ssl_set_TLSv12_func, "TLSv1.2"}, /* CONF_TLSV12 */
2345 {SSL_OP_NO_TLSv1_3, MC_SSL_O_NO_TLSV13, ctx_set_TLSv13_func, ssl_set_TLSv13_func, "TLSv1.3"}, /* CONF_TLSV13 */
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002346};
2347
Emmanuel Hocdet530141f2017-03-01 18:54:56 +01002348static void ssl_sock_switchctx_set(SSL *ssl, SSL_CTX *ctx)
2349{
2350 SSL_set_verify(ssl, SSL_CTX_get_verify_mode(ctx), ssl_sock_bind_verifycbk);
2351 SSL_set_client_CA_list(ssl, SSL_dup_CA_list(SSL_CTX_get_client_CA_list(ctx)));
2352 SSL_set_SSL_CTX(ssl, ctx);
2353}
2354
Willy Tarreau5db847a2019-05-09 14:13:35 +02002355#if ((HA_OPENSSL_VERSION_NUMBER >= 0x10101000L) || defined(OPENSSL_IS_BORINGSSL))
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002356
2357static int ssl_sock_switchctx_err_cbk(SSL *ssl, int *al, void *priv)
2358{
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002359 struct bind_conf *s = priv;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002360 (void)al; /* shut gcc stupid warning */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002361
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002362 if (SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name) || s->generate_certs)
2363 return SSL_TLSEXT_ERR_OK;
2364 return SSL_TLSEXT_ERR_NOACK;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002365}
2366
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002367#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002368static int ssl_sock_switchctx_cbk(const struct ssl_early_callback_ctx *ctx)
2369{
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002370 SSL *ssl = ctx->ssl;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002371#else
2372static int ssl_sock_switchctx_cbk(SSL *ssl, int *al, void *arg)
2373{
2374#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002375 struct connection *conn;
2376 struct bind_conf *s;
2377 const uint8_t *extension_data;
2378 size_t extension_len;
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002379 int has_rsa_sig = 0, has_ecdsa_sig = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002380
2381 char *wildp = NULL;
2382 const uint8_t *servername;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002383 size_t servername_len;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002384 struct ebmb_node *node, *n, *node_ecdsa = NULL, *node_rsa = NULL, *node_anonymous = NULL;
Olivier Houchardc2aae742017-09-22 18:26:28 +02002385 int allow_early = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002386 int i;
2387
Thierry FOURNIER28962c92018-06-17 21:37:05 +02002388 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Willy Tarreaua8825522018-10-15 13:20:07 +02002389 s = __objt_listener(conn->target)->bind_conf;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002390
Olivier Houchard9679ac92017-10-27 14:58:08 +02002391 if (s->ssl_conf.early_data)
Olivier Houchardc2aae742017-09-22 18:26:28 +02002392 allow_early = 1;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002393#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002394 if (SSL_early_callback_ctx_extension_get(ctx, TLSEXT_TYPE_server_name,
2395 &extension_data, &extension_len)) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002396#else
2397 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_server_name, &extension_data, &extension_len)) {
2398#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002399 /*
2400 * The server_name extension was given too much extensibility when it
2401 * was written, so parsing the normal case is a bit complex.
2402 */
2403 size_t len;
2404 if (extension_len <= 2)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002405 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002406 /* Extract the length of the supplied list of names. */
2407 len = (*extension_data++) << 8;
2408 len |= *extension_data++;
2409 if (len + 2 != extension_len)
2410 goto abort;
2411 /*
2412 * The list in practice only has a single element, so we only consider
2413 * the first one.
2414 */
2415 if (len == 0 || *extension_data++ != TLSEXT_NAMETYPE_host_name)
2416 goto abort;
2417 extension_len = len - 1;
2418 /* Now we can finally pull out the byte array with the actual hostname. */
2419 if (extension_len <= 2)
2420 goto abort;
2421 len = (*extension_data++) << 8;
2422 len |= *extension_data++;
2423 if (len == 0 || len + 2 > extension_len || len > TLSEXT_MAXLEN_host_name
2424 || memchr(extension_data, 0, len) != NULL)
2425 goto abort;
2426 servername = extension_data;
2427 servername_len = len;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002428 } else {
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002429#if (!defined SSL_NO_GENERATE_CERTIFICATES)
2430 if (s->generate_certs && ssl_sock_generate_certificate_from_conn(s, ssl)) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02002431 goto allow_early;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002432 }
2433#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002434 /* without SNI extension, is the default_ctx (need SSL_TLSEXT_ERR_NOACK) */
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002435 if (!s->strict_sni) {
William Lallemand21724f02019-11-04 17:56:13 +01002436 HA_RWLOCK_RDLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002437 ssl_sock_switchctx_set(ssl, s->default_ctx);
William Lallemand21724f02019-11-04 17:56:13 +01002438 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Olivier Houchardc2aae742017-09-22 18:26:28 +02002439 goto allow_early;
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002440 }
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002441 goto abort;
2442 }
2443
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05002444 /* extract/check clientHello information */
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002445#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002446 if (SSL_early_callback_ctx_extension_get(ctx, TLSEXT_TYPE_signature_algorithms, &extension_data, &extension_len)) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002447#else
2448 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_signature_algorithms, &extension_data, &extension_len)) {
2449#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002450 uint8_t sign;
2451 size_t len;
2452 if (extension_len < 2)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002453 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002454 len = (*extension_data++) << 8;
2455 len |= *extension_data++;
2456 if (len + 2 != extension_len)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002457 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002458 if (len % 2 != 0)
2459 goto abort;
2460 for (; len > 0; len -= 2) {
2461 extension_data++; /* hash */
2462 sign = *extension_data++;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002463 switch (sign) {
2464 case TLSEXT_signature_rsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002465 has_rsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002466 break;
2467 case TLSEXT_signature_ecdsa:
2468 has_ecdsa_sig = 1;
2469 break;
2470 default:
2471 continue;
2472 }
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002473 if (has_ecdsa_sig && has_rsa_sig)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002474 break;
2475 }
2476 } else {
Bertrand Jacquina25282b2018-08-14 00:56:13 +01002477 /* without TLSEXT_TYPE_signature_algorithms extension (< TLSv1.2) */
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002478 has_rsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002479 }
2480 if (has_ecdsa_sig) { /* in very rare case: has ecdsa sign but not a ECDSA cipher */
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002481 const SSL_CIPHER *cipher;
2482 size_t len;
2483 const uint8_t *cipher_suites;
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002484 has_ecdsa_sig = 0;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002485#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002486 len = ctx->cipher_suites_len;
2487 cipher_suites = ctx->cipher_suites;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002488#else
2489 len = SSL_client_hello_get0_ciphers(ssl, &cipher_suites);
2490#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002491 if (len % 2 != 0)
2492 goto abort;
2493 for (; len != 0; len -= 2, cipher_suites += 2) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002494#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002495 uint16_t cipher_suite = (cipher_suites[0] << 8) | cipher_suites[1];
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002496 cipher = SSL_get_cipher_by_value(cipher_suite);
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002497#else
2498 cipher = SSL_CIPHER_find(ssl, cipher_suites);
2499#endif
Emmanuel Hocdet019f9b12017-10-02 17:12:06 +02002500 if (cipher && SSL_CIPHER_get_auth_nid(cipher) == NID_auth_ecdsa) {
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002501 has_ecdsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002502 break;
2503 }
2504 }
2505 }
2506
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002507 for (i = 0; i < trash.size && i < servername_len; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002508 trash.area[i] = tolower(servername[i]);
2509 if (!wildp && (trash.area[i] == '.'))
2510 wildp = &trash.area[i];
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002511 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002512 trash.area[i] = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002513
William Lallemand150bfa82019-09-19 17:12:49 +02002514 HA_RWLOCK_RDLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002515
Emmanuel Hocdet3777e3a2019-11-06 16:05:34 +01002516 for (i = 0; i < 2; i++) {
2517 if (i == 0) /* lookup in full qualified names */
2518 node = ebst_lookup(&s->sni_ctx, trash.area);
2519 else if (i == 1 && wildp) /* lookup in wildcards names */
2520 node = ebst_lookup(&s->sni_w_ctx, wildp);
2521 else
2522 break;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002523 for (n = node; n; n = ebmb_next_dup(n)) {
Emmanuel Hocdet3777e3a2019-11-06 16:05:34 +01002524 /* lookup a not neg filter */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002525 if (!container_of(n, struct sni_ctx, name)->neg) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002526 switch(container_of(n, struct sni_ctx, name)->kinfo.sig) {
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002527 case TLSEXT_signature_ecdsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002528 if (!node_ecdsa)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002529 node_ecdsa = n;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002530 break;
2531 case TLSEXT_signature_rsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002532 if (!node_rsa)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002533 node_rsa = n;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002534 break;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002535 default: /* TLSEXT_signature_anonymous|dsa */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002536 if (!node_anonymous)
2537 node_anonymous = n;
2538 break;
2539 }
2540 }
2541 }
Emmanuel Hocdet3777e3a2019-11-06 16:05:34 +01002542 /* select by key_signature priority order */
2543 node = (has_ecdsa_sig && node_ecdsa) ? node_ecdsa
2544 : ((has_rsa_sig && node_rsa) ? node_rsa
2545 : (node_anonymous ? node_anonymous
2546 : (node_ecdsa ? node_ecdsa /* no ecdsa signature case (< TLSv1.2) */
2547 : node_rsa /* no rsa signature case (far far away) */
2548 )));
2549 if (node) {
2550 /* switch ctx */
2551 struct ssl_bind_conf *conf = container_of(node, struct sni_ctx, name)->conf;
2552 ssl_sock_switchctx_set(ssl, container_of(node, struct sni_ctx, name)->ctx);
Olivier Houchard35a63cc2017-11-02 19:04:38 +01002553 if (conf) {
2554 methodVersions[conf->ssl_methods.min].ssl_set_version(ssl, SET_MIN);
2555 methodVersions[conf->ssl_methods.max].ssl_set_version(ssl, SET_MAX);
2556 if (conf->early_data)
2557 allow_early = 1;
2558 }
William Lallemand02010472019-10-18 11:02:19 +02002559 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Olivier Houchard35a63cc2017-11-02 19:04:38 +01002560 goto allow_early;
Emmanuel Hocdet3777e3a2019-11-06 16:05:34 +01002561 }
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002562 }
William Lallemand150bfa82019-09-19 17:12:49 +02002563
William Lallemand02010472019-10-18 11:02:19 +02002564 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002565#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002566 if (s->generate_certs && ssl_sock_generate_certificate(trash.area, s, ssl)) {
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002567 /* switch ctx done in ssl_sock_generate_certificate */
Olivier Houchardc2aae742017-09-22 18:26:28 +02002568 goto allow_early;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002569 }
2570#endif
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002571 if (!s->strict_sni) {
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002572 /* no certificate match, is the default_ctx */
William Lallemand21724f02019-11-04 17:56:13 +01002573 HA_RWLOCK_RDLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002574 ssl_sock_switchctx_set(ssl, s->default_ctx);
William Lallemand21724f02019-11-04 17:56:13 +01002575 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002576 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02002577allow_early:
2578#ifdef OPENSSL_IS_BORINGSSL
2579 if (allow_early)
2580 SSL_set_early_data_enabled(ssl, 1);
2581#else
2582 if (!allow_early)
2583 SSL_set_max_early_data(ssl, 0);
2584#endif
2585 return 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002586 abort:
2587 /* abort handshake (was SSL_TLSEXT_ERR_ALERT_FATAL) */
2588 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002589#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002590 return ssl_select_cert_error;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002591#else
2592 *al = SSL_AD_UNRECOGNIZED_NAME;
2593 return 0;
2594#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002595}
2596
2597#else /* OPENSSL_IS_BORINGSSL */
2598
Emeric Brunfc0421f2012-09-07 17:30:07 +02002599/* Sets the SSL ctx of <ssl> to match the advertised server name. Returns a
2600 * warning when no match is found, which implies the default (first) cert
2601 * will keep being used.
2602 */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002603static int ssl_sock_switchctx_cbk(SSL *ssl, int *al, void *priv)
Emeric Brunfc0421f2012-09-07 17:30:07 +02002604{
2605 const char *servername;
2606 const char *wildp = NULL;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002607 struct ebmb_node *node, *n;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002608 struct bind_conf *s = priv;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002609 int i;
2610 (void)al; /* shut gcc stupid warning */
2611
2612 servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002613 if (!servername) {
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002614#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002615 if (s->generate_certs && ssl_sock_generate_certificate_from_conn(s, ssl))
2616 return SSL_TLSEXT_ERR_OK;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002617#endif
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002618 if (s->strict_sni)
2619 return SSL_TLSEXT_ERR_ALERT_FATAL;
William Lallemand21724f02019-11-04 17:56:13 +01002620 HA_RWLOCK_RDLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002621 ssl_sock_switchctx_set(ssl, s->default_ctx);
William Lallemand21724f02019-11-04 17:56:13 +01002622 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002623 return SSL_TLSEXT_ERR_NOACK;
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002624 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02002625
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002626 for (i = 0; i < trash.size; i++) {
Emeric Brunfc0421f2012-09-07 17:30:07 +02002627 if (!servername[i])
2628 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002629 trash.area[i] = tolower(servername[i]);
2630 if (!wildp && (trash.area[i] == '.'))
2631 wildp = &trash.area[i];
Emeric Brunfc0421f2012-09-07 17:30:07 +02002632 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002633 trash.area[i] = 0;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002634
William Lallemand150bfa82019-09-19 17:12:49 +02002635 HA_RWLOCK_RDLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetc5fdf0f2019-11-04 15:49:46 +01002636 node = NULL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002637 /* lookup in full qualified names */
Emmanuel Hocdetc5fdf0f2019-11-04 15:49:46 +01002638 for (n = ebst_lookup(&s->sni_ctx, trash.area); n; n = ebmb_next_dup(n)) {
2639 /* lookup a not neg filter */
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002640 if (!container_of(n, struct sni_ctx, name)->neg) {
2641 node = n;
2642 break;
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002643 }
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002644 }
2645 if (!node && wildp) {
2646 /* lookup in wildcards names */
Emmanuel Hocdetc5fdf0f2019-11-04 15:49:46 +01002647 for (n = ebst_lookup(&s->sni_w_ctx, wildp); n; n = ebmb_next_dup(n)) {
2648 /* lookup a not neg filter */
2649 if (!container_of(n, struct sni_ctx, name)->neg) {
2650 node = n;
2651 break;
2652 }
2653 }
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002654 }
Emmanuel Hocdetc5fdf0f2019-11-04 15:49:46 +01002655 if (!node) {
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002656#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002657 if (s->generate_certs && ssl_sock_generate_certificate(servername, s, ssl)) {
2658 /* switch ctx done in ssl_sock_generate_certificate */
William Lallemand150bfa82019-09-19 17:12:49 +02002659 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002660 return SSL_TLSEXT_ERR_OK;
2661 }
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002662#endif
William Lallemand21724f02019-11-04 17:56:13 +01002663 if (s->strict_sni) {
2664 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002665 return SSL_TLSEXT_ERR_ALERT_FATAL;
William Lallemand21724f02019-11-04 17:56:13 +01002666 }
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002667 ssl_sock_switchctx_set(ssl, s->default_ctx);
William Lallemand21724f02019-11-04 17:56:13 +01002668 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002669 return SSL_TLSEXT_ERR_OK;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002670 }
2671
2672 /* switch ctx */
Emmanuel Hocdet530141f2017-03-01 18:54:56 +01002673 ssl_sock_switchctx_set(ssl, container_of(node, struct sni_ctx, name)->ctx);
William Lallemand150bfa82019-09-19 17:12:49 +02002674 HA_RWLOCK_RDUNLOCK(SNI_LOCK, &s->sni_lock);
Emeric Brunfc0421f2012-09-07 17:30:07 +02002675 return SSL_TLSEXT_ERR_OK;
2676}
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002677#endif /* (!) OPENSSL_IS_BORINGSSL */
Emeric Brunfc0421f2012-09-07 17:30:07 +02002678#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
2679
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002680#ifndef OPENSSL_NO_DH
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002681
2682static DH * ssl_get_dh_1024(void)
2683{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002684 static unsigned char dh1024_p[]={
2685 0xFA,0xF9,0x2A,0x22,0x2A,0xA7,0x7F,0xE1,0x67,0x4E,0x53,0xF7,
2686 0x56,0x13,0xC3,0xB1,0xE3,0x29,0x6B,0x66,0x31,0x6A,0x7F,0xB3,
2687 0xC2,0x68,0x6B,0xCB,0x1D,0x57,0x39,0x1D,0x1F,0xFF,0x1C,0xC9,
2688 0xA6,0xA4,0x98,0x82,0x31,0x5D,0x25,0xFF,0x8A,0xE0,0x73,0x96,
2689 0x81,0xC8,0x83,0x79,0xC1,0x5A,0x04,0xF8,0x37,0x0D,0xA8,0x3D,
2690 0xAE,0x74,0xBC,0xDB,0xB6,0xA4,0x75,0xD9,0x71,0x8A,0xA0,0x17,
2691 0x9E,0x2D,0xC8,0xA8,0xDF,0x2C,0x5F,0x82,0x95,0xF8,0x92,0x9B,
2692 0xA7,0x33,0x5F,0x89,0x71,0xC8,0x2D,0x6B,0x18,0x86,0xC4,0x94,
2693 0x22,0xA5,0x52,0x8D,0xF6,0xF6,0xD2,0x37,0x92,0x0F,0xA5,0xCC,
2694 0xDB,0x7B,0x1D,0x3D,0xA1,0x31,0xB7,0x80,0x8F,0x0B,0x67,0x5E,
2695 0x36,0xA5,0x60,0x0C,0xF1,0x95,0x33,0x8B,
2696 };
2697 static unsigned char dh1024_g[]={
2698 0x02,
2699 };
2700
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002701 BIGNUM *p;
2702 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002703 DH *dh = DH_new();
2704 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002705 p = BN_bin2bn(dh1024_p, sizeof dh1024_p, NULL);
2706 g = BN_bin2bn(dh1024_g, sizeof dh1024_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002707
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002708 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002709 DH_free(dh);
2710 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002711 } else {
2712 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002713 }
2714 }
2715 return dh;
2716}
2717
2718static DH *ssl_get_dh_2048(void)
2719{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002720 static unsigned char dh2048_p[]={
2721 0xEC,0x86,0xF8,0x70,0xA0,0x33,0x16,0xEC,0x05,0x1A,0x73,0x59,
2722 0xCD,0x1F,0x8B,0xF8,0x29,0xE4,0xD2,0xCF,0x52,0xDD,0xC2,0x24,
2723 0x8D,0xB5,0x38,0x9A,0xFB,0x5C,0xA4,0xE4,0xB2,0xDA,0xCE,0x66,
2724 0x50,0x74,0xA6,0x85,0x4D,0x4B,0x1D,0x30,0xB8,0x2B,0xF3,0x10,
2725 0xE9,0xA7,0x2D,0x05,0x71,0xE7,0x81,0xDF,0x8B,0x59,0x52,0x3B,
2726 0x5F,0x43,0x0B,0x68,0xF1,0xDB,0x07,0xBE,0x08,0x6B,0x1B,0x23,
2727 0xEE,0x4D,0xCC,0x9E,0x0E,0x43,0xA0,0x1E,0xDF,0x43,0x8C,0xEC,
2728 0xBE,0xBE,0x90,0xB4,0x51,0x54,0xB9,0x2F,0x7B,0x64,0x76,0x4E,
2729 0x5D,0xD4,0x2E,0xAE,0xC2,0x9E,0xAE,0x51,0x43,0x59,0xC7,0x77,
2730 0x9C,0x50,0x3C,0x0E,0xED,0x73,0x04,0x5F,0xF1,0x4C,0x76,0x2A,
2731 0xD8,0xF8,0xCF,0xFC,0x34,0x40,0xD1,0xB4,0x42,0x61,0x84,0x66,
2732 0x42,0x39,0x04,0xF8,0x68,0xB2,0x62,0xD7,0x55,0xED,0x1B,0x74,
2733 0x75,0x91,0xE0,0xC5,0x69,0xC1,0x31,0x5C,0xDB,0x7B,0x44,0x2E,
2734 0xCE,0x84,0x58,0x0D,0x1E,0x66,0x0C,0xC8,0x44,0x9E,0xFD,0x40,
2735 0x08,0x67,0x5D,0xFB,0xA7,0x76,0x8F,0x00,0x11,0x87,0xE9,0x93,
2736 0xF9,0x7D,0xC4,0xBC,0x74,0x55,0x20,0xD4,0x4A,0x41,0x2F,0x43,
2737 0x42,0x1A,0xC1,0xF2,0x97,0x17,0x49,0x27,0x37,0x6B,0x2F,0x88,
2738 0x7E,0x1C,0xA0,0xA1,0x89,0x92,0x27,0xD9,0x56,0x5A,0x71,0xC1,
2739 0x56,0x37,0x7E,0x3A,0x9D,0x05,0xE7,0xEE,0x5D,0x8F,0x82,0x17,
2740 0xBC,0xE9,0xC2,0x93,0x30,0x82,0xF9,0xF4,0xC9,0xAE,0x49,0xDB,
2741 0xD0,0x54,0xB4,0xD9,0x75,0x4D,0xFA,0x06,0xB8,0xD6,0x38,0x41,
2742 0xB7,0x1F,0x77,0xF3,
2743 };
2744 static unsigned char dh2048_g[]={
2745 0x02,
2746 };
2747
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002748 BIGNUM *p;
2749 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002750 DH *dh = DH_new();
2751 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002752 p = BN_bin2bn(dh2048_p, sizeof dh2048_p, NULL);
2753 g = BN_bin2bn(dh2048_g, sizeof dh2048_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002754
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002755 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002756 DH_free(dh);
2757 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002758 } else {
2759 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002760 }
2761 }
2762 return dh;
2763}
2764
2765static DH *ssl_get_dh_4096(void)
2766{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002767 static unsigned char dh4096_p[]={
2768 0xDE,0x16,0x94,0xCD,0x99,0x58,0x07,0xF1,0xF7,0x32,0x96,0x11,
2769 0x04,0x82,0xD4,0x84,0x72,0x80,0x99,0x06,0xCA,0xF0,0xA3,0x68,
2770 0x07,0xCE,0x64,0x50,0xE7,0x74,0x45,0x20,0x80,0x5E,0x4D,0xAD,
2771 0xA5,0xB6,0xED,0xFA,0x80,0x6C,0x3B,0x35,0xC4,0x9A,0x14,0x6B,
2772 0x32,0xBB,0xFD,0x1F,0x17,0x8E,0xB7,0x1F,0xD6,0xFA,0x3F,0x7B,
2773 0xEE,0x16,0xA5,0x62,0x33,0x0D,0xED,0xBC,0x4E,0x58,0xE5,0x47,
2774 0x4D,0xE9,0xAB,0x8E,0x38,0xD3,0x6E,0x90,0x57,0xE3,0x22,0x15,
2775 0x33,0xBD,0xF6,0x43,0x45,0xB5,0x10,0x0A,0xBE,0x2C,0xB4,0x35,
2776 0xB8,0x53,0x8D,0xAD,0xFB,0xA7,0x1F,0x85,0x58,0x41,0x7A,0x79,
2777 0x20,0x68,0xB3,0xE1,0x3D,0x08,0x76,0xBF,0x86,0x0D,0x49,0xE3,
2778 0x82,0x71,0x8C,0xB4,0x8D,0x81,0x84,0xD4,0xE7,0xBE,0x91,0xDC,
2779 0x26,0x39,0x48,0x0F,0x35,0xC4,0xCA,0x65,0xE3,0x40,0x93,0x52,
2780 0x76,0x58,0x7D,0xDD,0x51,0x75,0xDC,0x69,0x61,0xBF,0x47,0x2C,
2781 0x16,0x68,0x2D,0xC9,0x29,0xD3,0xE6,0xC0,0x99,0x48,0xA0,0x9A,
2782 0xC8,0x78,0xC0,0x6D,0x81,0x67,0x12,0x61,0x3F,0x71,0xBA,0x41,
2783 0x1F,0x6C,0x89,0x44,0x03,0xBA,0x3B,0x39,0x60,0xAA,0x28,0x55,
2784 0x59,0xAE,0xB8,0xFA,0xCB,0x6F,0xA5,0x1A,0xF7,0x2B,0xDD,0x52,
2785 0x8A,0x8B,0xE2,0x71,0xA6,0x5E,0x7E,0xD8,0x2E,0x18,0xE0,0x66,
2786 0xDF,0xDD,0x22,0x21,0x99,0x52,0x73,0xA6,0x33,0x20,0x65,0x0E,
2787 0x53,0xE7,0x6B,0x9B,0xC5,0xA3,0x2F,0x97,0x65,0x76,0xD3,0x47,
2788 0x23,0x77,0x12,0xB6,0x11,0x7B,0x24,0xED,0xF1,0xEF,0xC0,0xE2,
2789 0xA3,0x7E,0x67,0x05,0x3E,0x96,0x4D,0x45,0xC2,0x18,0xD1,0x73,
2790 0x9E,0x07,0xF3,0x81,0x6E,0x52,0x63,0xF6,0x20,0x76,0xB9,0x13,
2791 0xD2,0x65,0x30,0x18,0x16,0x09,0x16,0x9E,0x8F,0xF1,0xD2,0x10,
2792 0x5A,0xD3,0xD4,0xAF,0x16,0x61,0xDA,0x55,0x2E,0x18,0x5E,0x14,
2793 0x08,0x54,0x2E,0x2A,0x25,0xA2,0x1A,0x9B,0x8B,0x32,0xA9,0xFD,
2794 0xC2,0x48,0x96,0xE1,0x80,0xCA,0xE9,0x22,0x17,0xBB,0xCE,0x3E,
2795 0x9E,0xED,0xC7,0xF1,0x1F,0xEC,0x17,0x21,0xDC,0x7B,0x82,0x48,
2796 0x8E,0xBB,0x4B,0x9D,0x5B,0x04,0x04,0xDA,0xDB,0x39,0xDF,0x01,
2797 0x40,0xC3,0xAA,0x26,0x23,0x89,0x75,0xC6,0x0B,0xD0,0xA2,0x60,
2798 0x6A,0xF1,0xCC,0x65,0x18,0x98,0x1B,0x52,0xD2,0x74,0x61,0xCC,
2799 0xBD,0x60,0xAE,0xA3,0xA0,0x66,0x6A,0x16,0x34,0x92,0x3F,0x41,
2800 0x40,0x31,0x29,0xC0,0x2C,0x63,0xB2,0x07,0x8D,0xEB,0x94,0xB8,
2801 0xE8,0x47,0x92,0x52,0x93,0x6A,0x1B,0x7E,0x1A,0x61,0xB3,0x1B,
2802 0xF0,0xD6,0x72,0x9B,0xF1,0xB0,0xAF,0xBF,0x3E,0x65,0xEF,0x23,
2803 0x1D,0x6F,0xFF,0x70,0xCD,0x8A,0x4C,0x8A,0xA0,0x72,0x9D,0xBE,
2804 0xD4,0xBB,0x24,0x47,0x4A,0x68,0xB5,0xF5,0xC6,0xD5,0x7A,0xCD,
2805 0xCA,0x06,0x41,0x07,0xAD,0xC2,0x1E,0xE6,0x54,0xA7,0xAD,0x03,
2806 0xD9,0x12,0xC1,0x9C,0x13,0xB1,0xC9,0x0A,0x43,0x8E,0x1E,0x08,
2807 0xCE,0x50,0x82,0x73,0x5F,0xA7,0x55,0x1D,0xD9,0x59,0xAC,0xB5,
2808 0xEA,0x02,0x7F,0x6C,0x5B,0x74,0x96,0x98,0x67,0x24,0xA3,0x0F,
2809 0x15,0xFC,0xA9,0x7D,0x3E,0x67,0xD1,0x70,0xF8,0x97,0xF3,0x67,
2810 0xC5,0x8C,0x88,0x44,0x08,0x02,0xC7,0x2B,
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002811 };
Remi Gacogned3a341a2015-05-29 16:26:17 +02002812 static unsigned char dh4096_g[]={
2813 0x02,
2814 };
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002815
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002816 BIGNUM *p;
2817 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002818 DH *dh = DH_new();
2819 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002820 p = BN_bin2bn(dh4096_p, sizeof dh4096_p, NULL);
2821 g = BN_bin2bn(dh4096_g, sizeof dh4096_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002822
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002823 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002824 DH_free(dh);
2825 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002826 } else {
2827 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002828 }
2829 }
2830 return dh;
2831}
2832
2833/* Returns Diffie-Hellman parameters matching the private key length
Willy Tarreauef934602016-12-22 23:12:01 +01002834 but not exceeding global_ssl.default_dh_param */
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002835static DH *ssl_get_tmp_dh(SSL *ssl, int export, int keylen)
2836{
2837 DH *dh = NULL;
2838 EVP_PKEY *pkey = SSL_get_privatekey(ssl);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002839 int type;
2840
2841 type = pkey ? EVP_PKEY_base_id(pkey) : EVP_PKEY_NONE;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002842
2843 /* The keylen supplied by OpenSSL can only be 512 or 1024.
2844 See ssl3_send_server_key_exchange() in ssl/s3_srvr.c
2845 */
2846 if (type == EVP_PKEY_RSA || type == EVP_PKEY_DSA) {
2847 keylen = EVP_PKEY_bits(pkey);
2848 }
2849
Willy Tarreauef934602016-12-22 23:12:01 +01002850 if (keylen > global_ssl.default_dh_param) {
2851 keylen = global_ssl.default_dh_param;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002852 }
2853
Remi Gacogned3a341a2015-05-29 16:26:17 +02002854 if (keylen >= 4096) {
Remi Gacogne8de54152014-07-15 11:36:40 +02002855 dh = local_dh_4096;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002856 }
2857 else if (keylen >= 2048) {
Remi Gacogne8de54152014-07-15 11:36:40 +02002858 dh = local_dh_2048;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002859 }
2860 else {
Remi Gacogne8de54152014-07-15 11:36:40 +02002861 dh = local_dh_1024;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002862 }
2863
2864 return dh;
2865}
2866
Remi Gacogne47783ef2015-05-29 15:53:22 +02002867static DH * ssl_sock_get_dh_from_file(const char *filename)
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002868{
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002869 DH *dh = NULL;
Remi Gacogne47783ef2015-05-29 15:53:22 +02002870 BIO *in = BIO_new(BIO_s_file());
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002871
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002872 if (in == NULL)
2873 goto end;
2874
Remi Gacogne47783ef2015-05-29 15:53:22 +02002875 if (BIO_read_filename(in, filename) <= 0)
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002876 goto end;
2877
Remi Gacogne47783ef2015-05-29 15:53:22 +02002878 dh = PEM_read_bio_DHparams(in, NULL, NULL, NULL);
2879
2880end:
2881 if (in)
2882 BIO_free(in);
2883
Emeric Brune1b4ed42018-08-16 15:14:12 +02002884 ERR_clear_error();
2885
Remi Gacogne47783ef2015-05-29 15:53:22 +02002886 return dh;
2887}
2888
2889int ssl_sock_load_global_dh_param_from_file(const char *filename)
2890{
2891 global_dh = ssl_sock_get_dh_from_file(filename);
2892
2893 if (global_dh) {
2894 return 0;
2895 }
2896
2897 return -1;
2898}
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002899#endif
2900
William Lallemand82b21bb2020-04-10 10:26:27 +02002901/* release ssl bind conf */
2902void ssl_sock_free_ssl_conf(struct ssl_bind_conf *conf)
2903{
2904 if (conf) {
2905#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
2906 free(conf->npn_str);
2907 conf->npn_str = NULL;
2908#endif
2909#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
2910 free(conf->alpn_str);
2911 conf->alpn_str = NULL;
2912#endif
2913 free(conf->ca_file);
2914 conf->ca_file = NULL;
2915 free(conf->ca_verify_file);
2916 conf->ca_verify_file = NULL;
2917 free(conf->crl_file);
2918 conf->crl_file = NULL;
2919 free(conf->ciphers);
2920 conf->ciphers = NULL;
2921#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
2922 free(conf->ciphersuites);
2923 conf->ciphersuites = NULL;
2924#endif
2925 free(conf->curves);
2926 conf->curves = NULL;
2927 free(conf->ecdhe);
2928 conf->ecdhe = NULL;
2929 }
2930}
2931
William Lallemandd9d5d1b2020-04-09 16:31:05 +02002932/* unlink a ckch_inst, free all SNIs, free the ckch_inst */
2933/* The caller must use the lock of the bind_conf if used with inserted SNIs */
2934static void ckch_inst_free(struct ckch_inst *inst)
2935{
2936 struct sni_ctx *sni, *sni_s;
2937
2938 if (inst == NULL)
2939 return;
2940
2941 list_for_each_entry_safe(sni, sni_s, &inst->sni_ctx, by_ckch_inst) {
2942 SSL_CTX_free(sni->ctx);
2943 LIST_DEL(&sni->by_ckch_inst);
2944 ebmb_delete(&sni->name);
2945 free(sni);
2946 }
2947 LIST_DEL(&inst->by_ckchs);
2948 LIST_DEL(&inst->by_crtlist_entry);
2949 free(inst);
2950}
2951
William Lallemand9117de92019-10-04 00:29:42 +02002952/* Alloc and init a ckch_inst */
2953static struct ckch_inst *ckch_inst_new()
2954{
2955 struct ckch_inst *ckch_inst;
2956
2957 ckch_inst = calloc(1, sizeof *ckch_inst);
William Lallemand9cef2e22020-04-09 16:25:10 +02002958 if (!ckch_inst)
2959 return NULL;
2960
2961 LIST_INIT(&ckch_inst->sni_ctx);
2962 LIST_INIT(&ckch_inst->by_ckchs);
2963 LIST_INIT(&ckch_inst->by_crtlist_entry);
William Lallemand9117de92019-10-04 00:29:42 +02002964
2965 return ckch_inst;
2966}
2967
William Lallemand82b21bb2020-04-10 10:26:27 +02002968/* free sni filters */
2969static void crtlist_free_filters(char **args)
2970{
2971 int i;
2972
2973 if (!args)
2974 return;
2975
2976 for (i = 0; args[i]; i++)
2977 free(args[i]);
2978
2979 free(args);
2980}
2981
2982/* Alloc and duplicate a char ** array */
2983static char **crtlist_dup_filters(char **args, int fcount)
2984{
2985 char **dst;
2986 int i;
2987
2988 if (fcount == 0)
2989 return NULL;
2990
2991 dst = calloc(fcount + 1, sizeof(*dst));
2992 if (!dst)
2993 return NULL;
2994
2995 for (i = 0; i < fcount; i++) {
2996 dst[i] = strdup(args[i]);
2997 if (!dst[i])
2998 goto error;
2999 }
3000 return dst;
3001
3002error:
3003 crtlist_free_filters(dst);
3004 return NULL;
3005}
3006
William Lallemande718dfb2020-04-10 11:09:25 +02003007/*
3008 * Detach and free a crtlist_entry.
3009 * Free the filters, the ssl_conf and call ckch_inst_free() for each ckch_inst
3010 */
3011static void crtlist_entry_free(struct crtlist_entry *entry)
3012{
3013 struct ckch_inst *inst, *inst_s;
3014
3015 if (entry == NULL)
3016 return;
3017
3018 ebpt_delete(&entry->node);
3019 LIST_DEL(&entry->by_crtlist);
3020 LIST_DEL(&entry->by_ckch_store);
3021 crtlist_free_filters(entry->filters);
3022 ssl_sock_free_ssl_conf(entry->ssl_conf);
3023 free(entry->ssl_conf);
3024 list_for_each_entry_safe(inst, inst_s, &entry->ckch_inst, by_crtlist_entry) {
3025 ckch_inst_free(inst);
3026 }
3027 free(entry);
3028}
3029
3030/*
3031 * Allocate and initialize a crtlist_entry
3032 */
3033static struct crtlist_entry *crtlist_entry_new()
3034{
3035 struct crtlist_entry *entry;
3036
3037 entry = calloc(1, sizeof(*entry));
3038 if (entry == NULL)
3039 return NULL;
3040
3041 LIST_INIT(&entry->ckch_inst);
3042
3043 /* initialize the nodes so we can LIST_DEL in any cases */
3044 LIST_INIT(&entry->by_crtlist);
3045 LIST_INIT(&entry->by_ckch_store);
3046
3047 return entry;
3048}
3049
William Lallemand82b21bb2020-04-10 10:26:27 +02003050/* Free a crtlist, from the crt_entry to the content of the ssl_conf */
3051static void crtlist_free(struct crtlist *crtlist)
3052{
3053 struct crtlist_entry *entry, *s_entry;
3054
3055 if (crtlist == NULL)
3056 return;
3057
3058 list_for_each_entry_safe(entry, s_entry, &crtlist->ord_entries, by_crtlist) {
3059 crtlist_entry_free(entry);
3060 }
3061 ebmb_delete(&crtlist->node);
3062 free(crtlist);
3063}
3064
3065/* Alloc and initialize a struct crtlist
3066 * <filename> is the key of the ebmb_node
3067 * <unique> initialize the list of entries to be unique (1) or not (0)
3068 */
3069static struct crtlist *crtlist_new(const char *filename, int unique)
3070{
3071 struct crtlist *newlist;
3072
3073 newlist = calloc(1, sizeof(*newlist) + strlen(filename) + 1);
3074 if (newlist == NULL)
3075 return NULL;
3076
3077 memcpy(newlist->node.key, filename, strlen(filename) + 1);
3078 if (unique)
3079 newlist->entries = EB_ROOT_UNIQUE;
3080 else
3081 newlist->entries = EB_ROOT;
3082
3083 LIST_INIT(&newlist->ord_entries);
3084
3085 return newlist;
3086}
William Lallemand9117de92019-10-04 00:29:42 +02003087
3088/* This function allocates a sni_ctx and adds it to the ckch_inst */
William Lallemand1d29c742019-10-04 00:53:29 +02003089static int ckch_inst_add_cert_sni(SSL_CTX *ctx, struct ckch_inst *ckch_inst,
William Lallemand9117de92019-10-04 00:29:42 +02003090 struct bind_conf *s, struct ssl_bind_conf *conf,
3091 struct pkey_info kinfo, char *name, int order)
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003092{
3093 struct sni_ctx *sc;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02003094 int wild = 0, neg = 0;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003095
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02003096 if (*name == '!') {
3097 neg = 1;
3098 name++;
3099 }
3100 if (*name == '*') {
3101 wild = 1;
3102 name++;
3103 }
3104 /* !* filter is a nop */
3105 if (neg && wild)
3106 return order;
3107 if (*name) {
3108 int j, len;
3109 len = strlen(name);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02003110 for (j = 0; j < len && j < trash.size; j++)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003111 trash.area[j] = tolower(name[j]);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02003112 if (j >= trash.size)
William Lallemandfe49bb32019-10-03 23:46:33 +02003113 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003114 trash.area[j] = 0;
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02003115
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003116 sc = malloc(sizeof(struct sni_ctx) + len + 1);
Thierry FOURNIER / OZON.IO7a3bd3b2016-10-06 10:35:29 +02003117 if (!sc)
William Lallemandfe49bb32019-10-03 23:46:33 +02003118 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003119 memcpy(sc->name.key, trash.area, len + 1);
William Lallemand02e19a52020-04-08 16:11:26 +02003120 SSL_CTX_up_ref(ctx);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003121 sc->ctx = ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003122 sc->conf = conf;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003123 sc->kinfo = kinfo;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02003124 sc->order = order++;
3125 sc->neg = neg;
William Lallemand1d29c742019-10-04 00:53:29 +02003126 sc->wild = wild;
3127 sc->name.node.leaf_p = NULL;
William Lallemandcfca1422020-03-05 10:17:47 +01003128 sc->ckch_inst = ckch_inst;
William Lallemand1d29c742019-10-04 00:53:29 +02003129 LIST_ADDQ(&ckch_inst->sni_ctx, &sc->by_ckch_inst);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003130 }
3131 return order;
3132}
3133
William Lallemand6af03992019-07-23 15:00:54 +02003134/*
William Lallemand1d29c742019-10-04 00:53:29 +02003135 * Insert the sni_ctxs that are listed in the ckch_inst, in the bind_conf's sni_ctx tree
3136 * This function can't return an error.
3137 *
3138 * *CAUTION*: The caller must lock the sni tree if called in multithreading mode
3139 */
3140static void ssl_sock_load_cert_sni(struct ckch_inst *ckch_inst, struct bind_conf *bind_conf)
3141{
3142
3143 struct sni_ctx *sc0, *sc0b, *sc1;
3144 struct ebmb_node *node;
William Lallemand21724f02019-11-04 17:56:13 +01003145 int def = 0;
William Lallemand1d29c742019-10-04 00:53:29 +02003146
3147 list_for_each_entry_safe(sc0, sc0b, &ckch_inst->sni_ctx, by_ckch_inst) {
3148
3149 /* ignore if sc0 was already inserted in a tree */
3150 if (sc0->name.node.leaf_p)
3151 continue;
3152
3153 /* Check for duplicates. */
3154 if (sc0->wild)
3155 node = ebst_lookup(&bind_conf->sni_w_ctx, (char *)sc0->name.key);
3156 else
3157 node = ebst_lookup(&bind_conf->sni_ctx, (char *)sc0->name.key);
3158
3159 for (; node; node = ebmb_next_dup(node)) {
3160 sc1 = ebmb_entry(node, struct sni_ctx, name);
3161 if (sc1->ctx == sc0->ctx && sc1->conf == sc0->conf
3162 && sc1->neg == sc0->neg && sc1->wild == sc0->wild) {
3163 /* it's a duplicate, we should remove and free it */
3164 LIST_DEL(&sc0->by_ckch_inst);
William Lallemand02e19a52020-04-08 16:11:26 +02003165 SSL_CTX_free(sc0->ctx);
William Lallemand1d29c742019-10-04 00:53:29 +02003166 free(sc0);
3167 sc0 = NULL;
William Lallemande15029b2019-10-14 10:46:58 +02003168 break;
William Lallemand1d29c742019-10-04 00:53:29 +02003169 }
3170 }
3171
3172 /* if duplicate, ignore the insertion */
3173 if (!sc0)
3174 continue;
3175
3176 if (sc0->wild)
3177 ebst_insert(&bind_conf->sni_w_ctx, &sc0->name);
3178 else
3179 ebst_insert(&bind_conf->sni_ctx, &sc0->name);
William Lallemand21724f02019-11-04 17:56:13 +01003180
3181 /* replace the default_ctx if required with the first ctx */
3182 if (ckch_inst->is_default && !def) {
William Lallemand02e19a52020-04-08 16:11:26 +02003183 SSL_CTX_free(bind_conf->default_ctx);
3184 SSL_CTX_up_ref(sc0->ctx);
William Lallemand21724f02019-11-04 17:56:13 +01003185 bind_conf->default_ctx = sc0->ctx;
3186 def = 1;
3187 }
William Lallemand1d29c742019-10-04 00:53:29 +02003188 }
3189}
3190
3191/*
William Lallemande3af8fb2019-10-08 11:36:53 +02003192 * tree used to store the ckchs ordered by filename/bundle name
William Lallemand6af03992019-07-23 15:00:54 +02003193 */
William Lallemande3af8fb2019-10-08 11:36:53 +02003194struct eb_root ckchs_tree = EB_ROOT_UNIQUE;
William Lallemand6af03992019-07-23 15:00:54 +02003195
William Lallemand2954c472020-03-06 21:54:13 +01003196/* tree of crtlist (crt-list/directory) */
3197static struct eb_root crtlists_tree = EB_ROOT_UNIQUE;
William Lallemandfa892222019-07-23 16:06:08 +02003198
Emeric Brun7a883362019-10-17 13:27:40 +02003199/* Loads Diffie-Hellman parameter from a ckchs to an SSL_CTX.
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05003200 * If there is no DH parameter available in the ckchs, the global
Emeric Brun7a883362019-10-17 13:27:40 +02003201 * DH parameter is loaded into the SSL_CTX and if there is no
3202 * DH parameter available in ckchs nor in global, the default
3203 * DH parameters are applied on the SSL_CTX.
3204 * Returns a bitfield containing the flags:
3205 * ERR_FATAL in any fatal error case
3206 * ERR_ALERT if a reason of the error is availabine in err
3207 * ERR_WARN if a warning is available into err
3208 * The value 0 means there is no error nor warning and
3209 * the operation succeed.
3210 */
William Lallemandfa892222019-07-23 16:06:08 +02003211#ifndef OPENSSL_NO_DH
Emeric Brun7a883362019-10-17 13:27:40 +02003212static int ssl_sock_load_dh_params(SSL_CTX *ctx, const struct cert_key_and_chain *ckch,
3213 const char *path, char **err)
William Lallemandfa892222019-07-23 16:06:08 +02003214{
Emeric Brun7a883362019-10-17 13:27:40 +02003215 int ret = 0;
William Lallemandfa892222019-07-23 16:06:08 +02003216 DH *dh = NULL;
3217
William Lallemanda8c73742019-07-31 18:31:34 +02003218 if (ckch && ckch->dh) {
William Lallemandfa892222019-07-23 16:06:08 +02003219 dh = ckch->dh;
Emeric Bruna9363eb2019-10-17 14:53:03 +02003220 if (!SSL_CTX_set_tmp_dh(ctx, dh)) {
3221 memprintf(err, "%sunable to load the DH parameter specified in '%s'",
3222 err && *err ? *err : "", path);
3223#if defined(SSL_CTX_set_dh_auto)
3224 SSL_CTX_set_dh_auto(ctx, 1);
3225 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
3226 err && *err ? *err : "");
3227#else
3228 memprintf(err, "%s, DH ciphers won't be available.\n",
3229 err && *err ? *err : "");
3230#endif
3231 ret |= ERR_WARN;
3232 goto end;
3233 }
William Lallemandfa892222019-07-23 16:06:08 +02003234
3235 if (ssl_dh_ptr_index >= 0) {
3236 /* store a pointer to the DH params to avoid complaining about
3237 ssl-default-dh-param not being set for this SSL_CTX */
3238 SSL_CTX_set_ex_data(ctx, ssl_dh_ptr_index, dh);
3239 }
3240 }
3241 else if (global_dh) {
Emeric Bruna9363eb2019-10-17 14:53:03 +02003242 if (!SSL_CTX_set_tmp_dh(ctx, global_dh)) {
3243 memprintf(err, "%sunable to use the global DH parameter for certificate '%s'",
3244 err && *err ? *err : "", path);
3245#if defined(SSL_CTX_set_dh_auto)
3246 SSL_CTX_set_dh_auto(ctx, 1);
3247 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
3248 err && *err ? *err : "");
3249#else
3250 memprintf(err, "%s, DH ciphers won't be available.\n",
3251 err && *err ? *err : "");
3252#endif
3253 ret |= ERR_WARN;
3254 goto end;
3255 }
William Lallemandfa892222019-07-23 16:06:08 +02003256 }
3257 else {
3258 /* Clear openssl global errors stack */
3259 ERR_clear_error();
3260
3261 if (global_ssl.default_dh_param <= 1024) {
3262 /* we are limited to DH parameter of 1024 bits anyway */
3263 if (local_dh_1024 == NULL)
3264 local_dh_1024 = ssl_get_dh_1024();
3265
Emeric Brun7a883362019-10-17 13:27:40 +02003266 if (local_dh_1024 == NULL) {
3267 memprintf(err, "%sunable to load default 1024 bits DH parameter for certificate '%s'.\n",
3268 err && *err ? *err : "", path);
3269 ret |= ERR_ALERT | ERR_FATAL;
William Lallemandfa892222019-07-23 16:06:08 +02003270 goto end;
Emeric Brun7a883362019-10-17 13:27:40 +02003271 }
William Lallemandfa892222019-07-23 16:06:08 +02003272
Emeric Bruna9363eb2019-10-17 14:53:03 +02003273 if (!SSL_CTX_set_tmp_dh(ctx, local_dh_1024)) {
3274 memprintf(err, "%sunable to load default 1024 bits DH parameter for certificate '%s'.\n",
3275 err && *err ? *err : "", path);
3276#if defined(SSL_CTX_set_dh_auto)
3277 SSL_CTX_set_dh_auto(ctx, 1);
3278 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
3279 err && *err ? *err : "");
3280#else
3281 memprintf(err, "%s, DH ciphers won't be available.\n",
3282 err && *err ? *err : "");
3283#endif
3284 ret |= ERR_WARN;
3285 goto end;
3286 }
William Lallemandfa892222019-07-23 16:06:08 +02003287 }
3288 else {
3289 SSL_CTX_set_tmp_dh_callback(ctx, ssl_get_tmp_dh);
3290 }
William Lallemandfa892222019-07-23 16:06:08 +02003291 }
3292
3293end:
William Lallemand4dd145a2020-02-05 11:46:33 +01003294 ERR_clear_error();
William Lallemandfa892222019-07-23 16:06:08 +02003295 return ret;
3296}
3297#endif
yanbzhu08ce6ab2015-12-02 13:01:29 -05003298
yanbzhu488a4d22015-12-01 15:16:07 -05003299/* Frees the contents of a cert_key_and_chain
3300 */
3301static void ssl_sock_free_cert_key_and_chain_contents(struct cert_key_and_chain *ckch)
3302{
yanbzhu488a4d22015-12-01 15:16:07 -05003303 if (!ckch)
3304 return;
3305
3306 /* Free the certificate and set pointer to NULL */
3307 if (ckch->cert)
3308 X509_free(ckch->cert);
3309 ckch->cert = NULL;
3310
3311 /* Free the key and set pointer to NULL */
3312 if (ckch->key)
3313 EVP_PKEY_free(ckch->key);
3314 ckch->key = NULL;
3315
3316 /* Free each certificate in the chain */
Emmanuel Hocdet9246f8b2018-11-30 16:00:21 +01003317 if (ckch->chain)
3318 sk_X509_pop_free(ckch->chain, X509_free);
3319 ckch->chain = NULL;
yanbzhu488a4d22015-12-01 15:16:07 -05003320
William Lallemand455af502019-10-17 18:04:45 +02003321 if (ckch->dh)
3322 DH_free(ckch->dh);
3323 ckch->dh = NULL;
3324
3325 if (ckch->sctl) {
3326 free(ckch->sctl->area);
3327 ckch->sctl->area = NULL;
3328 free(ckch->sctl);
3329 ckch->sctl = NULL;
3330 }
3331
3332 if (ckch->ocsp_response) {
3333 free(ckch->ocsp_response->area);
3334 ckch->ocsp_response->area = NULL;
3335 free(ckch->ocsp_response);
3336 ckch->ocsp_response = NULL;
3337 }
William Lallemand5c3c96f2020-01-23 11:53:13 +01003338
3339 if (ckch->ocsp_issuer)
William Lallemanddad239d2020-01-23 11:59:02 +01003340 X509_free(ckch->ocsp_issuer);
William Lallemand5c3c96f2020-01-23 11:53:13 +01003341 ckch->ocsp_issuer = NULL;
yanbzhu488a4d22015-12-01 15:16:07 -05003342}
3343
William Lallemand8d0f8932019-10-17 18:03:58 +02003344/*
3345 *
3346 * This function copy a cert_key_and_chain in memory
3347 *
3348 * It's used to try to apply changes on a ckch before committing them, because
3349 * most of the time it's not possible to revert those changes
3350 *
3351 * Return a the dst or NULL
3352 */
3353static struct cert_key_and_chain *ssl_sock_copy_cert_key_and_chain(struct cert_key_and_chain *src,
3354 struct cert_key_and_chain *dst)
3355{
3356 if (src->cert) {
3357 dst->cert = src->cert;
3358 X509_up_ref(src->cert);
3359 }
3360
3361 if (src->key) {
3362 dst->key = src->key;
3363 EVP_PKEY_up_ref(src->key);
3364 }
3365
3366 if (src->chain) {
3367 dst->chain = X509_chain_up_ref(src->chain);
3368 }
3369
3370 if (src->dh) {
3371 DH_up_ref(src->dh);
3372 dst->dh = src->dh;
3373 }
3374
3375 if (src->sctl) {
3376 struct buffer *sctl;
3377
3378 sctl = calloc(1, sizeof(*sctl));
3379 if (!chunk_dup(sctl, src->sctl)) {
3380 free(sctl);
3381 sctl = NULL;
3382 goto error;
3383 }
3384 dst->sctl = sctl;
3385 }
3386
3387 if (src->ocsp_response) {
3388 struct buffer *ocsp_response;
3389
3390 ocsp_response = calloc(1, sizeof(*ocsp_response));
3391 if (!chunk_dup(ocsp_response, src->ocsp_response)) {
3392 free(ocsp_response);
3393 ocsp_response = NULL;
3394 goto error;
3395 }
3396 dst->ocsp_response = ocsp_response;
3397 }
3398
3399 if (src->ocsp_issuer) {
3400 X509_up_ref(src->ocsp_issuer);
3401 dst->ocsp_issuer = src->ocsp_issuer;
3402 }
3403
3404 return dst;
3405
3406error:
3407
3408 /* free everything */
3409 ssl_sock_free_cert_key_and_chain_contents(dst);
3410
3411 return NULL;
3412}
3413
3414
yanbzhu488a4d22015-12-01 15:16:07 -05003415/* checks if a key and cert exists in the ckch
3416 */
William Lallemand1633e392019-09-30 12:58:13 +02003417#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu488a4d22015-12-01 15:16:07 -05003418static int ssl_sock_is_ckch_valid(struct cert_key_and_chain *ckch)
3419{
3420 return (ckch->cert != NULL && ckch->key != NULL);
3421}
William Lallemand1633e392019-09-30 12:58:13 +02003422#endif
yanbzhu488a4d22015-12-01 15:16:07 -05003423
William Lallemandf9568fc2019-10-16 18:27:58 +02003424/*
3425 * return 0 on success or != 0 on failure
3426 */
3427static int ssl_sock_load_issuer_file_into_ckch(const char *path, char *buf, struct cert_key_and_chain *ckch, char **err)
3428{
3429 int ret = 1;
3430 BIO *in = NULL;
3431 X509 *issuer;
3432
3433 if (buf) {
3434 /* reading from a buffer */
3435 in = BIO_new_mem_buf(buf, -1);
3436 if (in == NULL) {
3437 memprintf(err, "%sCan't allocate memory\n", err && *err ? *err : "");
3438 goto end;
3439 }
3440
3441 } else {
3442 /* reading from a file */
3443 in = BIO_new(BIO_s_file());
3444 if (in == NULL)
3445 goto end;
3446
3447 if (BIO_read_filename(in, path) <= 0)
3448 goto end;
3449 }
3450
3451 issuer = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
3452 if (!issuer) {
3453 memprintf(err, "%s'%s' cannot be read or parsed'.\n",
Tim Duesterhus93128532019-11-23 23:45:10 +01003454 err && *err ? *err : "", path);
William Lallemandf9568fc2019-10-16 18:27:58 +02003455 goto end;
3456 }
Emmanuel Hocdeteb73dc32020-01-16 14:45:00 +01003457 /* no error, fill ckch with new context, old context must be free */
3458 if (ckch->ocsp_issuer)
3459 X509_free(ckch->ocsp_issuer);
William Lallemandf9568fc2019-10-16 18:27:58 +02003460 ckch->ocsp_issuer = issuer;
Emmanuel Hocdeteb73dc32020-01-16 14:45:00 +01003461 ret = 0;
William Lallemandf9568fc2019-10-16 18:27:58 +02003462
3463end:
3464
3465 ERR_clear_error();
3466 if (in)
3467 BIO_free(in);
3468
3469 return ret;
3470}
3471
William Lallemand96a9c972019-10-17 11:56:17 +02003472
3473/*
3474 * Try to load a PEM file from a <path> or a buffer <buf>
William Lallemand4c5adbf2020-02-24 14:23:22 +01003475 * The PEM must contain at least a Certificate,
3476 * It could contain a DH, a certificate chain and a PrivateKey.
yanbzhu488a4d22015-12-01 15:16:07 -05003477 *
William Lallemand96a9c972019-10-17 11:56:17 +02003478 * If it failed you should not attempt to use the ckch but free it.
3479 *
3480 * Return 0 on success or != 0 on failure
yanbzhu488a4d22015-12-01 15:16:07 -05003481 */
William Lallemand96a9c972019-10-17 11:56:17 +02003482static int ssl_sock_load_pem_into_ckch(const char *path, char *buf, struct cert_key_and_chain *ckch , char **err)
yanbzhu488a4d22015-12-01 15:16:07 -05003483{
William Lallemandf11365b2019-09-19 14:25:58 +02003484 BIO *in = NULL;
yanbzhu488a4d22015-12-01 15:16:07 -05003485 int ret = 1;
Emmanuel Hocdet83cbd3c2019-10-25 11:55:03 +02003486 X509 *ca;
William Lallemand96a9c972019-10-17 11:56:17 +02003487 X509 *cert = NULL;
3488 EVP_PKEY *key = NULL;
Emmanuel Hocdet6b5b44e2019-12-20 17:47:12 +01003489 DH *dh = NULL;
3490 STACK_OF(X509) *chain = NULL;
William Lallemand96a9c972019-10-17 11:56:17 +02003491
3492 if (buf) {
3493 /* reading from a buffer */
3494 in = BIO_new_mem_buf(buf, -1);
3495 if (in == NULL) {
3496 memprintf(err, "%sCan't allocate memory\n", err && *err ? *err : "");
3497 goto end;
3498 }
yanbzhu488a4d22015-12-01 15:16:07 -05003499
William Lallemand96a9c972019-10-17 11:56:17 +02003500 } else {
3501 /* reading from a file */
William Lallemandf11365b2019-09-19 14:25:58 +02003502 in = BIO_new(BIO_s_file());
William Lallemand7fd01b32020-04-07 14:16:32 +02003503 if (in == NULL) {
3504 memprintf(err, "%sCan't allocate memory\n", err && *err ? *err : "");
William Lallemandf11365b2019-09-19 14:25:58 +02003505 goto end;
William Lallemand7fd01b32020-04-07 14:16:32 +02003506 }
yanbzhu488a4d22015-12-01 15:16:07 -05003507
William Lallemand7fd01b32020-04-07 14:16:32 +02003508 if (BIO_read_filename(in, path) <= 0) {
3509 memprintf(err, "%scannot open the file '%s'.\n",
3510 err && *err ? *err : "", path);
William Lallemandf11365b2019-09-19 14:25:58 +02003511 goto end;
William Lallemand7fd01b32020-04-07 14:16:32 +02003512 }
William Lallemandf11365b2019-09-19 14:25:58 +02003513 }
yanbzhu488a4d22015-12-01 15:16:07 -05003514
yanbzhu488a4d22015-12-01 15:16:07 -05003515 /* Read Private Key */
William Lallemand96a9c972019-10-17 11:56:17 +02003516 key = PEM_read_bio_PrivateKey(in, NULL, NULL, NULL);
William Lallemand4c5adbf2020-02-24 14:23:22 +01003517 /* no need to check for errors here, because the private key could be loaded later */
yanbzhu488a4d22015-12-01 15:16:07 -05003518
Emmanuel Hocdet54227d82019-07-30 17:04:01 +02003519#ifndef OPENSSL_NO_DH
William Lallemandfa892222019-07-23 16:06:08 +02003520 /* Seek back to beginning of file */
3521 if (BIO_reset(in) == -1) {
3522 memprintf(err, "%san error occurred while reading the file '%s'.\n",
3523 err && *err ? *err : "", path);
3524 goto end;
3525 }
3526
William Lallemand96a9c972019-10-17 11:56:17 +02003527 dh = PEM_read_bio_DHparams(in, NULL, NULL, NULL);
3528 /* no need to return an error there, dh is not mandatory */
Emmanuel Hocdet54227d82019-07-30 17:04:01 +02003529#endif
William Lallemandfa892222019-07-23 16:06:08 +02003530
Willy Tarreaubb137a82016-04-06 19:02:38 +02003531 /* Seek back to beginning of file */
Thierry FOURNIER / OZON.IOd44ea3f2016-10-14 00:49:21 +02003532 if (BIO_reset(in) == -1) {
3533 memprintf(err, "%san error occurred while reading the file '%s'.\n",
3534 err && *err ? *err : "", path);
3535 goto end;
3536 }
Willy Tarreaubb137a82016-04-06 19:02:38 +02003537
3538 /* Read Certificate */
William Lallemand96a9c972019-10-17 11:56:17 +02003539 cert = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
3540 if (cert == NULL) {
Willy Tarreaubb137a82016-04-06 19:02:38 +02003541 memprintf(err, "%sunable to load certificate from file '%s'.\n",
William Lallemand96a9c972019-10-17 11:56:17 +02003542 err && *err ? *err : "", path);
Willy Tarreaubb137a82016-04-06 19:02:38 +02003543 goto end;
3544 }
3545
William Lallemand96a9c972019-10-17 11:56:17 +02003546 /* Look for a Certificate Chain */
Emmanuel Hocdet6b5b44e2019-12-20 17:47:12 +01003547 while ((ca = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
3548 if (chain == NULL)
3549 chain = sk_X509_new_null();
3550 if (!sk_X509_push(chain, ca)) {
William Lallemand96a9c972019-10-17 11:56:17 +02003551 X509_free(ca);
3552 goto end;
3553 }
3554 }
Emmanuel Hocdeted17f472019-10-24 18:28:33 +02003555
yanbzhu488a4d22015-12-01 15:16:07 -05003556 ret = ERR_get_error();
3557 if (ret && (ERR_GET_LIB(ret) != ERR_LIB_PEM && ERR_GET_REASON(ret) != PEM_R_NO_START_LINE)) {
3558 memprintf(err, "%sunable to load certificate chain from file '%s'.\n",
William Lallemand96a9c972019-10-17 11:56:17 +02003559 err && *err ? *err : "", path);
yanbzhu488a4d22015-12-01 15:16:07 -05003560 goto end;
William Lallemand246c0242019-10-11 08:59:13 +02003561 }
3562
William Lallemand75b15f72020-01-23 10:56:05 +01003563 /* once it loaded the PEM, it should remove everything else in the ckch */
3564 if (ckch->ocsp_response) {
3565 free(ckch->ocsp_response->area);
3566 ckch->ocsp_response->area = NULL;
3567 free(ckch->ocsp_response);
3568 ckch->ocsp_response = NULL;
3569 }
3570
3571 if (ckch->sctl) {
3572 free(ckch->sctl->area);
3573 ckch->sctl->area = NULL;
3574 free(ckch->sctl);
3575 ckch->sctl = NULL;
3576 }
3577
3578 if (ckch->ocsp_issuer) {
3579 X509_free(ckch->ocsp_issuer);
3580 ckch->ocsp_issuer = NULL;
3581 }
3582
Emmanuel Hocdet6b5b44e2019-12-20 17:47:12 +01003583 /* no error, fill ckch with new context, old context will be free at end: */
3584 SWAP(ckch->key, key);
3585 SWAP(ckch->dh, dh);
3586 SWAP(ckch->cert, cert);
3587 SWAP(ckch->chain, chain);
3588
William Lallemand246c0242019-10-11 08:59:13 +02003589 ret = 0;
3590
William Lallemand96a9c972019-10-17 11:56:17 +02003591end:
William Lallemand246c0242019-10-11 08:59:13 +02003592
3593 ERR_clear_error();
William Lallemand96a9c972019-10-17 11:56:17 +02003594 if (in)
William Lallemand246c0242019-10-11 08:59:13 +02003595 BIO_free(in);
Emmanuel Hocdet83cbd3c2019-10-25 11:55:03 +02003596 if (key)
3597 EVP_PKEY_free(key);
Emmanuel Hocdet6b5b44e2019-12-20 17:47:12 +01003598 if (dh)
3599 DH_free(dh);
Emmanuel Hocdet83cbd3c2019-10-25 11:55:03 +02003600 if (cert)
3601 X509_free(cert);
Emmanuel Hocdet6b5b44e2019-12-20 17:47:12 +01003602 if (chain)
3603 sk_X509_pop_free(chain, X509_free);
William Lallemanda17f4112019-10-10 15:16:44 +02003604
William Lallemand96a9c972019-10-17 11:56:17 +02003605 return ret;
3606}
3607
3608/*
William Lallemand4c5adbf2020-02-24 14:23:22 +01003609 * Try to load a private key file from a <path> or a buffer <buf>
3610 *
3611 * If it failed you should not attempt to use the ckch but free it.
3612 *
3613 * Return 0 on success or != 0 on failure
3614 */
3615static int ssl_sock_load_key_into_ckch(const char *path, char *buf, struct cert_key_and_chain *ckch , char **err)
3616{
3617 BIO *in = NULL;
3618 int ret = 1;
3619 EVP_PKEY *key = NULL;
3620
3621 if (buf) {
3622 /* reading from a buffer */
3623 in = BIO_new_mem_buf(buf, -1);
3624 if (in == NULL) {
3625 memprintf(err, "%sCan't allocate memory\n", err && *err ? *err : "");
3626 goto end;
3627 }
3628
3629 } else {
3630 /* reading from a file */
3631 in = BIO_new(BIO_s_file());
3632 if (in == NULL)
3633 goto end;
3634
3635 if (BIO_read_filename(in, path) <= 0)
3636 goto end;
3637 }
3638
3639 /* Read Private Key */
3640 key = PEM_read_bio_PrivateKey(in, NULL, NULL, NULL);
3641 if (key == NULL) {
3642 memprintf(err, "%sunable to load private key from file '%s'.\n",
3643 err && *err ? *err : "", path);
3644 goto end;
3645 }
3646
3647 ret = 0;
3648
3649 SWAP(ckch->key, key);
3650
3651end:
3652
3653 ERR_clear_error();
3654 if (in)
3655 BIO_free(in);
3656 if (key)
3657 EVP_PKEY_free(key);
3658
3659 return ret;
3660}
3661
3662/*
William Lallemand96a9c972019-10-17 11:56:17 +02003663 * Try to load in a ckch every files related to a ckch.
3664 * (PEM, sctl, ocsp, issuer etc.)
3665 *
3666 * This function is only used to load files during the configuration parsing,
3667 * it is not used with the CLI.
3668 *
3669 * This allows us to carry the contents of the file without having to read the
3670 * file multiple times. The caller must call
3671 * ssl_sock_free_cert_key_and_chain_contents.
3672 *
3673 * returns:
3674 * 0 on Success
3675 * 1 on SSL Failure
3676 */
3677static int ssl_sock_load_files_into_ckch(const char *path, struct cert_key_and_chain *ckch, char **err)
3678{
3679 int ret = 1;
3680
3681 /* try to load the PEM */
3682 if (ssl_sock_load_pem_into_ckch(path, NULL, ckch , err) != 0) {
3683 goto end;
3684 }
3685
William Lallemand4c5adbf2020-02-24 14:23:22 +01003686 /* try to load an external private key if it wasn't in the PEM */
3687 if ((ckch->key == NULL) && (global_ssl.extra_files & SSL_GF_KEY)) {
3688 char fp[MAXPATHLEN+1];
3689 struct stat st;
3690
3691 snprintf(fp, MAXPATHLEN+1, "%s.key", path);
3692 if (stat(fp, &st) == 0) {
3693 if (ssl_sock_load_key_into_ckch(fp, NULL, ckch, err)) {
3694 memprintf(err, "%s '%s' is present but cannot be read or parsed'.\n",
3695 err && *err ? *err : "", fp);
3696 goto end;
3697 }
3698 }
3699 }
3700
3701 if (ckch->key == NULL) {
3702 memprintf(err, "%sNo Private Key found in '%s' or '%s.key'.\n", err && *err ? *err : "", path, path);
3703 goto end;
3704 }
3705
3706 if (!X509_check_private_key(ckch->cert, ckch->key)) {
3707 memprintf(err, "%sinconsistencies between private key and certificate loaded '%s'.\n",
3708 err && *err ? *err : "", path);
3709 goto end;
3710 }
3711
William Lallemanda17f4112019-10-10 15:16:44 +02003712#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
3713 /* try to load the sctl file */
William Lallemand3af48e72020-02-03 17:15:52 +01003714 if (global_ssl.extra_files & SSL_GF_SCTL) {
William Lallemanda17f4112019-10-10 15:16:44 +02003715 char fp[MAXPATHLEN+1];
3716 struct stat st;
3717
3718 snprintf(fp, MAXPATHLEN+1, "%s.sctl", path);
3719 if (stat(fp, &st) == 0) {
William Lallemand0dfae6c2019-10-16 18:06:58 +02003720 if (ssl_sock_load_sctl_from_file(fp, NULL, ckch, err)) {
William Lallemanda17f4112019-10-10 15:16:44 +02003721 memprintf(err, "%s '%s.sctl' is present but cannot be read or parsed'.\n",
Tim Duesterhus93128532019-11-23 23:45:10 +01003722 err && *err ? *err : "", fp);
William Lallemanda17f4112019-10-10 15:16:44 +02003723 ret = 1;
3724 goto end;
3725 }
3726 }
3727 }
3728#endif
yanbzhu488a4d22015-12-01 15:16:07 -05003729
William Lallemand246c0242019-10-11 08:59:13 +02003730 /* try to load an ocsp response file */
William Lallemand3af48e72020-02-03 17:15:52 +01003731 if (global_ssl.extra_files & SSL_GF_OCSP) {
William Lallemand246c0242019-10-11 08:59:13 +02003732 char fp[MAXPATHLEN+1];
3733 struct stat st;
3734
3735 snprintf(fp, MAXPATHLEN+1, "%s.ocsp", path);
3736 if (stat(fp, &st) == 0) {
William Lallemand3b5f3602019-10-16 18:05:05 +02003737 if (ssl_sock_load_ocsp_response_from_file(fp, NULL, ckch, err)) {
William Lallemand246c0242019-10-11 08:59:13 +02003738 ret = 1;
3739 goto end;
3740 }
3741 }
3742 }
3743
Emmanuel Hocdeteaad5cc2019-10-25 12:19:00 +02003744#ifndef OPENSSL_IS_BORINGSSL /* Useless for BoringSSL */
William Lallemand3af48e72020-02-03 17:15:52 +01003745 if (ckch->ocsp_response && (global_ssl.extra_files & SSL_GF_OCSP_ISSUER)) {
William Lallemand246c0242019-10-11 08:59:13 +02003746 /* if no issuer was found, try to load an issuer from the .issuer */
Emmanuel Hocdet078156d2020-01-22 17:02:53 +01003747 if (!ckch->ocsp_issuer) {
William Lallemand246c0242019-10-11 08:59:13 +02003748 struct stat st;
3749 char fp[MAXPATHLEN+1];
3750
3751 snprintf(fp, MAXPATHLEN+1, "%s.issuer", path);
3752 if (stat(fp, &st) == 0) {
William Lallemandf9568fc2019-10-16 18:27:58 +02003753 if (ssl_sock_load_issuer_file_into_ckch(fp, NULL, ckch, err)) {
William Lallemand246c0242019-10-11 08:59:13 +02003754 ret = 1;
3755 goto end;
3756 }
3757
3758 if (X509_check_issued(ckch->ocsp_issuer, ckch->cert) != X509_V_OK) {
William Lallemand786188f2019-10-15 10:05:37 +02003759 memprintf(err, "%s '%s' is not an issuer'.\n",
Tim Duesterhus93128532019-11-23 23:45:10 +01003760 err && *err ? *err : "", fp);
William Lallemand246c0242019-10-11 08:59:13 +02003761 ret = 1;
3762 goto end;
3763 }
William Lallemand246c0242019-10-11 08:59:13 +02003764 }
3765 }
3766 }
Emmanuel Hocdeteaad5cc2019-10-25 12:19:00 +02003767#endif
William Lallemand246c0242019-10-11 08:59:13 +02003768
yanbzhu488a4d22015-12-01 15:16:07 -05003769 ret = 0;
3770
3771end:
3772
3773 ERR_clear_error();
yanbzhu488a4d22015-12-01 15:16:07 -05003774
3775 /* Something went wrong in one of the reads */
3776 if (ret != 0)
3777 ssl_sock_free_cert_key_and_chain_contents(ckch);
3778
3779 return ret;
3780}
3781
3782/* Loads the info in ckch into ctx
Emeric Bruna96b5822019-10-17 13:25:14 +02003783 * Returns a bitfield containing the flags:
3784 * ERR_FATAL in any fatal error case
3785 * ERR_ALERT if the reason of the error is available in err
3786 * ERR_WARN if a warning is available into err
3787 * The value 0 means there is no error nor warning and
3788 * the operation succeed.
yanbzhu488a4d22015-12-01 15:16:07 -05003789 */
3790static int ssl_sock_put_ckch_into_ctx(const char *path, const struct cert_key_and_chain *ckch, SSL_CTX *ctx, char **err)
3791{
Emeric Bruna96b5822019-10-17 13:25:14 +02003792 int errcode = 0;
Emmanuel Hocdetb90d2cb2020-02-18 15:27:32 +01003793 STACK_OF(X509) *find_chain = NULL;
Emeric Bruna96b5822019-10-17 13:25:14 +02003794
yanbzhu488a4d22015-12-01 15:16:07 -05003795 if (SSL_CTX_use_PrivateKey(ctx, ckch->key) <= 0) {
3796 memprintf(err, "%sunable to load SSL private key into SSL Context '%s'.\n",
3797 err && *err ? *err : "", path);
Emeric Bruna96b5822019-10-17 13:25:14 +02003798 errcode |= ERR_ALERT | ERR_FATAL;
3799 return errcode;
yanbzhu488a4d22015-12-01 15:16:07 -05003800 }
3801
3802 if (!SSL_CTX_use_certificate(ctx, ckch->cert)) {
3803 memprintf(err, "%sunable to load SSL certificate into SSL Context '%s'.\n",
3804 err && *err ? *err : "", path);
Emeric Bruna96b5822019-10-17 13:25:14 +02003805 errcode |= ERR_ALERT | ERR_FATAL;
3806 goto end;
yanbzhu488a4d22015-12-01 15:16:07 -05003807 }
3808
Emmanuel Hocdetb90d2cb2020-02-18 15:27:32 +01003809 if (ckch->chain) {
3810 find_chain = ckch->chain;
3811 } else {
3812 /* Find Certificate Chain in global */
3813 struct issuer_chain *issuer;
Emmanuel Hocdetef87e0a2020-03-23 11:29:11 +01003814 issuer = ssl_get0_issuer_chain(ckch->cert);
Emmanuel Hocdetb90d2cb2020-02-18 15:27:32 +01003815 if (issuer)
3816 find_chain = issuer->chain;
3817 }
William Lallemand85888572020-02-27 14:48:35 +01003818
Emmanuel Hocdet16739772020-02-28 16:00:34 +01003819 /* Load all certs from chain, except Root, in the ssl_ctx */
Emmanuel Hocdet4fed93e2020-02-28 16:00:34 +01003820 if (find_chain) {
3821 int i;
3822 X509 *ca;
3823 for (i = 0; i < sk_X509_num(find_chain); i++) {
3824 ca = sk_X509_value(find_chain, i);
Emmanuel Hocdet16739772020-02-28 16:00:34 +01003825 /* skip self issued (Root CA) */
3826 if (!X509_NAME_cmp(X509_get_subject_name(ca), X509_get_issuer_name(ca)))
3827 continue;
Emmanuel Hocdet4fed93e2020-02-28 16:00:34 +01003828 /*
3829 SSL_CTX_add1_chain_cert could be used with openssl >= 1.0.2
3830 Used SSL_CTX_add_extra_chain_cert for compat (aka SSL_CTX_add0_chain_cert)
3831 */
3832 X509_up_ref(ca);
3833 if (!SSL_CTX_add_extra_chain_cert(ctx, ca)) {
3834 X509_free(ca);
3835 memprintf(err, "%sunable to load chain certificate into SSL Context '%s'.\n",
3836 err && *err ? *err : "", path);
3837 errcode |= ERR_ALERT | ERR_FATAL;
3838 goto end;
3839 }
Emmanuel Hocdetf4f14ea2020-03-23 10:31:47 +01003840 }
Emmanuel Hocdet4fed93e2020-02-28 16:00:34 +01003841 }
yanbzhu488a4d22015-12-01 15:16:07 -05003842
William Lallemandfa892222019-07-23 16:06:08 +02003843#ifndef OPENSSL_NO_DH
3844 /* store a NULL pointer to indicate we have not yet loaded
3845 a custom DH param file */
3846 if (ssl_dh_ptr_index >= 0) {
3847 SSL_CTX_set_ex_data(ctx, ssl_dh_ptr_index, NULL);
3848 }
3849
Emeric Brun7a883362019-10-17 13:27:40 +02003850 errcode |= ssl_sock_load_dh_params(ctx, ckch, path, err);
3851 if (errcode & ERR_CODE) {
William Lallemandfa892222019-07-23 16:06:08 +02003852 memprintf(err, "%sunable to load DH parameters from file '%s'.\n",
3853 err && *err ? *err : "", path);
Emeric Bruna96b5822019-10-17 13:25:14 +02003854 goto end;
William Lallemandfa892222019-07-23 16:06:08 +02003855 }
3856#endif
3857
William Lallemanda17f4112019-10-10 15:16:44 +02003858#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
3859 if (sctl_ex_index >= 0 && ckch->sctl) {
3860 if (ssl_sock_load_sctl(ctx, ckch->sctl) < 0) {
3861 memprintf(err, "%s '%s.sctl' is present but cannot be read or parsed'.\n",
Tim Duesterhus93128532019-11-23 23:45:10 +01003862 err && *err ? *err : "", path);
Emeric Bruna96b5822019-10-17 13:25:14 +02003863 errcode |= ERR_ALERT | ERR_FATAL;
3864 goto end;
William Lallemanda17f4112019-10-10 15:16:44 +02003865 }
3866 }
3867#endif
3868
William Lallemand4a660132019-10-14 14:51:41 +02003869#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
William Lallemand246c0242019-10-11 08:59:13 +02003870 /* Load OCSP Info into context */
3871 if (ckch->ocsp_response) {
Emmanuel Hocdet6f507c72020-02-18 15:56:39 +01003872 if (ssl_sock_load_ocsp(ctx, ckch, find_chain) < 0) {
Tim Duesterhus93128532019-11-23 23:45:10 +01003873 memprintf(err, "%s '%s.ocsp' is present and activates OCSP but it is impossible to compute the OCSP certificate ID (maybe the issuer could not be found)'.\n",
3874 err && *err ? *err : "", path);
Emeric Bruna96b5822019-10-17 13:25:14 +02003875 errcode |= ERR_ALERT | ERR_FATAL;
3876 goto end;
William Lallemand246c0242019-10-11 08:59:13 +02003877 }
3878 }
William Lallemand246c0242019-10-11 08:59:13 +02003879#endif
3880
Emeric Bruna96b5822019-10-17 13:25:14 +02003881 end:
3882 return errcode;
yanbzhu488a4d22015-12-01 15:16:07 -05003883}
3884
William Lallemandc4ecddf2019-07-31 16:50:08 +02003885#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu08ce6ab2015-12-02 13:01:29 -05003886
William Lallemand28a8fce2019-10-04 17:36:55 +02003887static int ssl_sock_populate_sni_keytypes_hplr(const char *str, struct eb_root *sni_keytypes, int key_index)
yanbzhu08ce6ab2015-12-02 13:01:29 -05003888{
3889 struct sni_keytype *s_kt = NULL;
3890 struct ebmb_node *node;
3891 int i;
3892
3893 for (i = 0; i < trash.size; i++) {
3894 if (!str[i])
3895 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003896 trash.area[i] = tolower(str[i]);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003897 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003898 trash.area[i] = 0;
3899 node = ebst_lookup(sni_keytypes, trash.area);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003900 if (!node) {
3901 /* CN not found in tree */
3902 s_kt = malloc(sizeof(struct sni_keytype) + i + 1);
3903 /* Using memcpy here instead of strncpy.
3904 * strncpy will cause sig_abrt errors under certain versions of gcc with -O2
3905 * See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60792
3906 */
William Lallemand28a8fce2019-10-04 17:36:55 +02003907 if (!s_kt)
3908 return -1;
3909
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003910 memcpy(s_kt->name.key, trash.area, i+1);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003911 s_kt->keytypes = 0;
3912 ebst_insert(sni_keytypes, &s_kt->name);
3913 } else {
3914 /* CN found in tree */
3915 s_kt = container_of(node, struct sni_keytype, name);
3916 }
3917
3918 /* Mark that this CN has the keytype of key_index via keytypes mask */
3919 s_kt->keytypes |= 1<<key_index;
3920
William Lallemand28a8fce2019-10-04 17:36:55 +02003921 return 0;
3922
yanbzhu08ce6ab2015-12-02 13:01:29 -05003923}
3924
William Lallemandc4ecddf2019-07-31 16:50:08 +02003925#endif
William Lallemand8c1cdde2019-10-18 10:58:14 +02003926/*
William Lallemandba1c33f2020-04-08 17:55:45 +02003927 * Free a ckch_store, its ckch, its instances and remove it from the ebtree
William Lallemand8c1cdde2019-10-18 10:58:14 +02003928 */
William Lallemandba1c33f2020-04-08 17:55:45 +02003929static void ckch_store_free(struct ckch_store *store)
William Lallemand8c1cdde2019-10-18 10:58:14 +02003930{
William Lallemandba1c33f2020-04-08 17:55:45 +02003931 struct ckch_inst *inst, *inst_s;
3932
3933 if (!store)
William Lallemand8c1cdde2019-10-18 10:58:14 +02003934 return;
3935
William Lallemandba1c33f2020-04-08 17:55:45 +02003936#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200L
3937 if (store->multi) {
William Lallemand8c1cdde2019-10-18 10:58:14 +02003938 int n;
3939
William Lallemandba1c33f2020-04-08 17:55:45 +02003940 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++)
3941 ssl_sock_free_cert_key_and_chain_contents(&store->ckch[n]);
William Lallemand8c1cdde2019-10-18 10:58:14 +02003942 } else
3943#endif
3944 {
William Lallemandba1c33f2020-04-08 17:55:45 +02003945 ssl_sock_free_cert_key_and_chain_contents(store->ckch);
William Lallemand8c1cdde2019-10-18 10:58:14 +02003946 }
3947
William Lallemandba1c33f2020-04-08 17:55:45 +02003948 free(store->ckch);
3949 store->ckch = NULL;
3950
3951 list_for_each_entry_safe(inst, inst_s, &store->ckch_inst, by_ckchs) {
3952 ckch_inst_free(inst);
3953 }
3954 ebmb_delete(&store->node);
3955 free(store);
William Lallemand8c1cdde2019-10-18 10:58:14 +02003956}
3957
William Lallemand8a874e42020-04-09 10:32:53 +02003958/*
3959 * create and initialize a ckch_store
3960 * <path> is the key name
3961 * <nmemb> is the number of store->ckch objects to allocate
3962 *
3963 * Return a ckch_store or NULL upon failure.
3964 */
3965static struct ckch_store *ckch_store_new(const char *filename, int nmemb)
William Lallemand8c1cdde2019-10-18 10:58:14 +02003966{
William Lallemand8a874e42020-04-09 10:32:53 +02003967 struct ckch_store *store;
William Lallemand8c1cdde2019-10-18 10:58:14 +02003968 int pathlen;
3969
William Lallemand8a874e42020-04-09 10:32:53 +02003970 pathlen = strlen(filename);
3971 store = calloc(1, sizeof(*store) + pathlen + 1);
3972 if (!store)
William Lallemand8c1cdde2019-10-18 10:58:14 +02003973 return NULL;
William Lallemand8a874e42020-04-09 10:32:53 +02003974
3975 if (nmemb > 1)
3976 store->multi = 1;
3977 else
3978 store->multi = 0;
3979
3980 memcpy(store->path, filename, pathlen + 1);
3981
3982 LIST_INIT(&store->ckch_inst);
3983 LIST_INIT(&store->crtlist_entry);
William Lallemand8c1cdde2019-10-18 10:58:14 +02003984
William Lallemand8a874e42020-04-09 10:32:53 +02003985 store->ckch = calloc(nmemb, sizeof(*store->ckch));
3986 if (!store->ckch)
William Lallemand8c1cdde2019-10-18 10:58:14 +02003987 goto error;
3988
William Lallemand8a874e42020-04-09 10:32:53 +02003989 return store;
3990error:
3991 ckch_store_free(store);
3992 return NULL;
3993}
3994
3995/* allocate and duplicate a ckch_store
3996 * Return a new ckch_store or NULL */
3997static struct ckch_store *ckchs_dup(const struct ckch_store *src)
3998{
3999 struct ckch_store *dst;
4000
4001 dst = ckch_store_new(src->path, src->multi ? SSL_SOCK_NUM_KEYTYPES : 1);
4002
William Lallemand8c1cdde2019-10-18 10:58:14 +02004003#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
4004 if (src->multi) {
4005 int n;
4006
4007 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
4008 if (&src->ckch[n]) {
4009 if (!ssl_sock_copy_cert_key_and_chain(&src->ckch[n], &dst->ckch[n]))
4010 goto error;
4011 }
4012 }
4013 } else
4014#endif
4015 {
4016 if (!ssl_sock_copy_cert_key_and_chain(src->ckch, dst->ckch))
4017 goto error;
4018 }
4019
4020 return dst;
4021
4022error:
William Lallemandba1c33f2020-04-08 17:55:45 +02004023 ckch_store_free(dst);
William Lallemand8c1cdde2019-10-18 10:58:14 +02004024
4025 return NULL;
4026}
William Lallemandc4ecddf2019-07-31 16:50:08 +02004027
William Lallemand36b84632019-07-18 19:28:17 +02004028/*
William Lallemande3af8fb2019-10-08 11:36:53 +02004029 * lookup a path into the ckchs tree.
William Lallemand6af03992019-07-23 15:00:54 +02004030 */
William Lallemande3af8fb2019-10-08 11:36:53 +02004031static inline struct ckch_store *ckchs_lookup(char *path)
William Lallemand6af03992019-07-23 15:00:54 +02004032{
4033 struct ebmb_node *eb;
4034
William Lallemande3af8fb2019-10-08 11:36:53 +02004035 eb = ebst_lookup(&ckchs_tree, path);
William Lallemand6af03992019-07-23 15:00:54 +02004036 if (!eb)
4037 return NULL;
4038
William Lallemande3af8fb2019-10-08 11:36:53 +02004039 return ebmb_entry(eb, struct ckch_store, node);
William Lallemand6af03992019-07-23 15:00:54 +02004040}
4041
4042/*
William Lallemande3af8fb2019-10-08 11:36:53 +02004043 * This function allocate a ckch_store and populate it with certificates from files.
William Lallemand36b84632019-07-18 19:28:17 +02004044 */
William Lallemande3af8fb2019-10-08 11:36:53 +02004045static struct ckch_store *ckchs_load_cert_file(char *path, int multi, char **err)
William Lallemand36b84632019-07-18 19:28:17 +02004046{
William Lallemande3af8fb2019-10-08 11:36:53 +02004047 struct ckch_store *ckchs;
William Lallemand36b84632019-07-18 19:28:17 +02004048
William Lallemand8a874e42020-04-09 10:32:53 +02004049 ckchs = ckch_store_new(path, multi ? SSL_SOCK_NUM_KEYTYPES : 1);
William Lallemande3af8fb2019-10-08 11:36:53 +02004050 if (!ckchs) {
William Lallemand36b84632019-07-18 19:28:17 +02004051 memprintf(err, "%sunable to allocate memory.\n", err && *err ? *err : "");
4052 goto end;
4053 }
William Lallemand36b84632019-07-18 19:28:17 +02004054 if (!multi) {
4055
William Lallemand96a9c972019-10-17 11:56:17 +02004056 if (ssl_sock_load_files_into_ckch(path, ckchs->ckch, err) == 1)
William Lallemand36b84632019-07-18 19:28:17 +02004057 goto end;
4058
William Lallemande3af8fb2019-10-08 11:36:53 +02004059 /* insert into the ckchs tree */
4060 memcpy(ckchs->path, path, strlen(path) + 1);
4061 ebst_insert(&ckchs_tree, &ckchs->node);
William Lallemand36b84632019-07-18 19:28:17 +02004062 } else {
4063 int found = 0;
William Lallemandc4ecddf2019-07-31 16:50:08 +02004064#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
4065 char fp[MAXPATHLEN+1] = {0};
4066 int n = 0;
William Lallemand36b84632019-07-18 19:28:17 +02004067
4068 /* Load all possible certs and keys */
4069 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
4070 struct stat buf;
4071 snprintf(fp, sizeof(fp), "%s.%s", path, SSL_SOCK_KEYTYPE_NAMES[n]);
4072 if (stat(fp, &buf) == 0) {
William Lallemand96a9c972019-10-17 11:56:17 +02004073 if (ssl_sock_load_files_into_ckch(fp, &ckchs->ckch[n], err) == 1)
William Lallemand36b84632019-07-18 19:28:17 +02004074 goto end;
4075 found = 1;
William Lallemande3af8fb2019-10-08 11:36:53 +02004076 ckchs->multi = 1;
William Lallemand36b84632019-07-18 19:28:17 +02004077 }
4078 }
William Lallemandc4ecddf2019-07-31 16:50:08 +02004079#endif
William Lallemand36b84632019-07-18 19:28:17 +02004080
4081 if (!found) {
William Lallemand6e5f2ce2019-08-01 14:43:20 +02004082 memprintf(err, "%sDidn't find any certificate for bundle '%s'.\n", err && *err ? *err : "", path);
William Lallemand36b84632019-07-18 19:28:17 +02004083 goto end;
4084 }
William Lallemande3af8fb2019-10-08 11:36:53 +02004085 /* insert into the ckchs tree */
4086 memcpy(ckchs->path, path, strlen(path) + 1);
4087 ebst_insert(&ckchs_tree, &ckchs->node);
William Lallemand36b84632019-07-18 19:28:17 +02004088 }
William Lallemande3af8fb2019-10-08 11:36:53 +02004089 return ckchs;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004090
William Lallemand36b84632019-07-18 19:28:17 +02004091end:
William Lallemandba1c33f2020-04-08 17:55:45 +02004092 ckch_store_free(ckchs);
William Lallemand36b84632019-07-18 19:28:17 +02004093
4094 return NULL;
4095}
4096
William Lallemandc4ecddf2019-07-31 16:50:08 +02004097#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
4098
William Lallemand36b84632019-07-18 19:28:17 +02004099/*
William Lallemande3af8fb2019-10-08 11:36:53 +02004100 * Take a ckch_store which contains a multi-certificate bundle.
William Lallemand36b84632019-07-18 19:28:17 +02004101 * Group these certificates into a set of SSL_CTX*
yanbzhu08ce6ab2015-12-02 13:01:29 -05004102 * based on shared and unique CN and SAN entries. Add these SSL_CTX* to the SNI tree.
4103 *
Joseph Herlant017b3da2018-11-15 09:07:59 -08004104 * This will allow the user to explicitly group multiple cert/keys for a single purpose
yanbzhu08ce6ab2015-12-02 13:01:29 -05004105 *
Emeric Brun054563d2019-10-17 13:16:58 +02004106 * Returns a bitfield containing the flags:
4107 * ERR_FATAL in any fatal error case
4108 * ERR_ALERT if the reason of the error is available in err
4109 * ERR_WARN if a warning is available into err
William Lallemand36b84632019-07-18 19:28:17 +02004110 *
yanbzhu08ce6ab2015-12-02 13:01:29 -05004111 */
Emeric Brun054563d2019-10-17 13:16:58 +02004112static int ckch_inst_new_load_multi_store(const char *path, struct ckch_store *ckchs,
4113 struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
4114 char **sni_filter, int fcount, struct ckch_inst **ckchi, char **err)
yanbzhu08ce6ab2015-12-02 13:01:29 -05004115{
William Lallemand36b84632019-07-18 19:28:17 +02004116 int i = 0, n = 0;
4117 struct cert_key_and_chain *certs_and_keys;
William Lallemand4b989f22019-10-04 18:36:55 +02004118 struct eb_root sni_keytypes_map = EB_ROOT;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004119 struct ebmb_node *node;
4120 struct ebmb_node *next;
4121 /* Array of SSL_CTX pointers corresponding to each possible combo
4122 * of keytypes
4123 */
4124 struct key_combo_ctx key_combos[SSL_SOCK_POSSIBLE_KT_COMBOS] = { {0} };
Emeric Brun054563d2019-10-17 13:16:58 +02004125 int errcode = 0;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004126 X509_NAME *xname = NULL;
4127 char *str = NULL;
4128#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
4129 STACK_OF(GENERAL_NAME) *names = NULL;
4130#endif
William Lallemand614ca0d2019-10-07 13:52:11 +02004131 struct ckch_inst *ckch_inst;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004132
Emeric Brun054563d2019-10-17 13:16:58 +02004133 *ckchi = NULL;
4134
William Lallemande3af8fb2019-10-08 11:36:53 +02004135 if (!ckchs || !ckchs->ckch || !ckchs->multi) {
William Lallemand36b84632019-07-18 19:28:17 +02004136 memprintf(err, "%sunable to load SSL certificate file '%s' file does not exist.\n",
4137 err && *err ? *err : "", path);
Emeric Brun054563d2019-10-17 13:16:58 +02004138 return ERR_ALERT | ERR_FATAL;
William Lallemand614ca0d2019-10-07 13:52:11 +02004139 }
4140
4141 ckch_inst = ckch_inst_new();
4142 if (!ckch_inst) {
4143 memprintf(err, "%sunable to allocate SSL context for cert '%s'.\n",
4144 err && *err ? *err : "", path);
Emeric Brun054563d2019-10-17 13:16:58 +02004145 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand614ca0d2019-10-07 13:52:11 +02004146 goto end;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004147 }
4148
William Lallemande3af8fb2019-10-08 11:36:53 +02004149 certs_and_keys = ckchs->ckch;
William Lallemand36b84632019-07-18 19:28:17 +02004150
yanbzhu08ce6ab2015-12-02 13:01:29 -05004151 /* Process each ckch and update keytypes for each CN/SAN
4152 * for example, if CN/SAN www.a.com is associated with
4153 * certs with keytype 0 and 2, then at the end of the loop,
4154 * www.a.com will have:
4155 * keyindex = 0 | 1 | 4 = 5
4156 */
4157 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
William Lallemand28a8fce2019-10-04 17:36:55 +02004158 int ret;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004159
4160 if (!ssl_sock_is_ckch_valid(&certs_and_keys[n]))
4161 continue;
4162
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004163 if (fcount) {
William Lallemand28a8fce2019-10-04 17:36:55 +02004164 for (i = 0; i < fcount; i++) {
4165 ret = ssl_sock_populate_sni_keytypes_hplr(sni_filter[i], &sni_keytypes_map, n);
4166 if (ret < 0) {
4167 memprintf(err, "%sunable to allocate SSL context.\n",
4168 err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004169 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand28a8fce2019-10-04 17:36:55 +02004170 goto end;
4171 }
4172 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004173 } else {
4174 /* A lot of the following code is OpenSSL boilerplate for processing CN's and SAN's,
4175 * so the line that contains logic is marked via comments
4176 */
4177 xname = X509_get_subject_name(certs_and_keys[n].cert);
4178 i = -1;
4179 while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
4180 X509_NAME_ENTRY *entry = X509_NAME_get_entry(xname, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02004181 ASN1_STRING *value;
4182 value = X509_NAME_ENTRY_get_data(entry);
4183 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004184 /* Important line is here */
William Lallemand28a8fce2019-10-04 17:36:55 +02004185 ret = ssl_sock_populate_sni_keytypes_hplr(str, &sni_keytypes_map, n);
yanbzhu08ce6ab2015-12-02 13:01:29 -05004186
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004187 OPENSSL_free(str);
4188 str = NULL;
William Lallemand28a8fce2019-10-04 17:36:55 +02004189 if (ret < 0) {
4190 memprintf(err, "%sunable to allocate SSL context.\n",
4191 err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004192 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand28a8fce2019-10-04 17:36:55 +02004193 goto end;
4194 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004195 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05004196 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05004197
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004198 /* Do the above logic for each SAN */
yanbzhu08ce6ab2015-12-02 13:01:29 -05004199#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004200 names = X509_get_ext_d2i(certs_and_keys[n].cert, NID_subject_alt_name, NULL, NULL);
4201 if (names) {
4202 for (i = 0; i < sk_GENERAL_NAME_num(names); i++) {
4203 GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
yanbzhu08ce6ab2015-12-02 13:01:29 -05004204
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004205 if (name->type == GEN_DNS) {
4206 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
4207 /* Important line is here */
William Lallemand28a8fce2019-10-04 17:36:55 +02004208 ret = ssl_sock_populate_sni_keytypes_hplr(str, &sni_keytypes_map, n);
yanbzhu08ce6ab2015-12-02 13:01:29 -05004209
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004210 OPENSSL_free(str);
4211 str = NULL;
William Lallemand28a8fce2019-10-04 17:36:55 +02004212 if (ret < 0) {
4213 memprintf(err, "%sunable to allocate SSL context.\n",
4214 err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004215 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand28a8fce2019-10-04 17:36:55 +02004216 goto end;
4217 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02004218 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05004219 }
4220 }
4221 }
4222 }
4223#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
4224 }
4225
4226 /* If no files found, return error */
4227 if (eb_is_empty(&sni_keytypes_map)) {
4228 memprintf(err, "%sunable to load SSL certificate file '%s' file does not exist.\n",
4229 err && *err ? *err : "", path);
Emeric Brun054563d2019-10-17 13:16:58 +02004230 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004231 goto end;
4232 }
4233
4234 /* We now have a map of CN/SAN to keytypes that are loaded in
4235 * Iterate through the map to create the SSL_CTX's (if needed)
4236 * and add each CTX to the SNI tree
4237 *
4238 * Some math here:
Joseph Herlant017b3da2018-11-15 09:07:59 -08004239 * There are 2^n - 1 possible combinations, each unique
yanbzhu08ce6ab2015-12-02 13:01:29 -05004240 * combination is denoted by the key in the map. Each key
4241 * has a value between 1 and 2^n - 1. Conveniently, the array
4242 * of SSL_CTX* is sized 2^n. So, we can simply use the i'th
4243 * entry in the array to correspond to the unique combo (key)
4244 * associated with i. This unique key combo (i) will be associated
4245 * with combos[i-1]
4246 */
4247
4248 node = ebmb_first(&sni_keytypes_map);
4249 while (node) {
4250 SSL_CTX *cur_ctx;
Bertrand Jacquin33423092016-11-13 16:37:13 +00004251 char cur_file[MAXPATHLEN+1];
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02004252 const struct pkey_info kinfo = { .sig = TLSEXT_signature_anonymous, .bits = 0 };
yanbzhu08ce6ab2015-12-02 13:01:29 -05004253
4254 str = (char *)container_of(node, struct sni_keytype, name)->name.key;
4255 i = container_of(node, struct sni_keytype, name)->keytypes;
4256 cur_ctx = key_combos[i-1].ctx;
4257
4258 if (cur_ctx == NULL) {
4259 /* need to create SSL_CTX */
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004260 cur_ctx = SSL_CTX_new(SSLv23_server_method());
yanbzhu08ce6ab2015-12-02 13:01:29 -05004261 if (cur_ctx == NULL) {
4262 memprintf(err, "%sunable to allocate SSL context.\n",
4263 err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004264 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004265 goto end;
4266 }
4267
yanbzhube2774d2015-12-10 15:07:30 -05004268 /* Load all required certs/keys/chains/OCSPs info into SSL_CTX */
yanbzhu08ce6ab2015-12-02 13:01:29 -05004269 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
4270 if (i & (1<<n)) {
4271 /* Key combo contains ckch[n] */
Bertrand Jacquin33423092016-11-13 16:37:13 +00004272 snprintf(cur_file, MAXPATHLEN+1, "%s.%s", path, SSL_SOCK_KEYTYPE_NAMES[n]);
Emeric Bruna96b5822019-10-17 13:25:14 +02004273 errcode |= ssl_sock_put_ckch_into_ctx(cur_file, &certs_and_keys[n], cur_ctx, err);
4274 if (errcode & ERR_CODE)
yanbzhu08ce6ab2015-12-02 13:01:29 -05004275 goto end;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004276 }
4277 }
4278
yanbzhu08ce6ab2015-12-02 13:01:29 -05004279 /* Update key_combos */
4280 key_combos[i-1].ctx = cur_ctx;
4281 }
4282
4283 /* Update SNI Tree */
William Lallemand9117de92019-10-04 00:29:42 +02004284
William Lallemand1d29c742019-10-04 00:53:29 +02004285 key_combos[i-1].order = ckch_inst_add_cert_sni(cur_ctx, ckch_inst, bind_conf, ssl_conf,
William Lallemandfe49bb32019-10-03 23:46:33 +02004286 kinfo, str, key_combos[i-1].order);
4287 if (key_combos[i-1].order < 0) {
4288 memprintf(err, "%sunable to create a sni context.\n", err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004289 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandfe49bb32019-10-03 23:46:33 +02004290 goto end;
4291 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05004292 node = ebmb_next(node);
4293 }
4294
4295
4296 /* Mark a default context if none exists, using the ctx that has the most shared keys */
4297 if (!bind_conf->default_ctx) {
4298 for (i = SSL_SOCK_POSSIBLE_KT_COMBOS - 1; i >= 0; i--) {
4299 if (key_combos[i].ctx) {
4300 bind_conf->default_ctx = key_combos[i].ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004301 bind_conf->default_ssl_conf = ssl_conf;
William Lallemand21724f02019-11-04 17:56:13 +01004302 ckch_inst->is_default = 1;
William Lallemand02e19a52020-04-08 16:11:26 +02004303 SSL_CTX_up_ref(bind_conf->default_ctx);
yanbzhu08ce6ab2015-12-02 13:01:29 -05004304 break;
4305 }
4306 }
4307 }
4308
William Lallemand614ca0d2019-10-07 13:52:11 +02004309 ckch_inst->bind_conf = bind_conf;
William Lallemand150bfa82019-09-19 17:12:49 +02004310 ckch_inst->ssl_conf = ssl_conf;
William Lallemandcfca1422020-03-05 10:17:47 +01004311 ckch_inst->ckch_store = ckchs;
William Lallemand02e19a52020-04-08 16:11:26 +02004312
yanbzhu08ce6ab2015-12-02 13:01:29 -05004313end:
4314
4315 if (names)
4316 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
4317
yanbzhu08ce6ab2015-12-02 13:01:29 -05004318 node = ebmb_first(&sni_keytypes_map);
4319 while (node) {
4320 next = ebmb_next(node);
4321 ebmb_delete(node);
William Lallemand8ed5b962019-10-04 17:24:39 +02004322 free(ebmb_entry(node, struct sni_keytype, name));
yanbzhu08ce6ab2015-12-02 13:01:29 -05004323 node = next;
4324 }
4325
William Lallemand02e19a52020-04-08 16:11:26 +02004326 /* we need to free the ctx since we incremented the refcount where it's used */
4327 for (i = 0; i < SSL_SOCK_POSSIBLE_KT_COMBOS; i++) {
4328 if (key_combos[i].ctx)
4329 SSL_CTX_free(key_combos[i].ctx);
4330 }
4331
Emeric Brun054563d2019-10-17 13:16:58 +02004332 if (errcode & ERR_CODE && ckch_inst) {
William Lallemand02e19a52020-04-08 16:11:26 +02004333 if (ckch_inst->is_default) {
4334 SSL_CTX_free(bind_conf->default_ctx);
4335 bind_conf->default_ctx = NULL;
4336 }
4337
William Lallemandd9d5d1b2020-04-09 16:31:05 +02004338 ckch_inst_free(ckch_inst);
William Lallemand614ca0d2019-10-07 13:52:11 +02004339 ckch_inst = NULL;
William Lallemand0c6d12f2019-10-04 18:38:51 +02004340 }
4341
Emeric Brun054563d2019-10-17 13:16:58 +02004342 *ckchi = ckch_inst;
4343 return errcode;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004344}
4345#else
4346/* This is a dummy, that just logs an error and returns error */
Emeric Brun054563d2019-10-17 13:16:58 +02004347static int ckch_inst_new_load_multi_store(const char *path, struct ckch_store *ckchs,
4348 struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
4349 char **sni_filter, int fcount, struct ckch_inst **ckchi, char **err)
yanbzhu08ce6ab2015-12-02 13:01:29 -05004350{
4351 memprintf(err, "%sunable to stat SSL certificate from file '%s' : %s.\n",
4352 err && *err ? *err : "", path, strerror(errno));
Emeric Brun054563d2019-10-17 13:16:58 +02004353 return ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05004354}
4355
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004356#endif /* #if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL: Support for loading multiple certs into a single SSL_CTX */
yanbzhu488a4d22015-12-01 15:16:07 -05004357
William Lallemand614ca0d2019-10-07 13:52:11 +02004358/*
4359 * This function allocate a ckch_inst and create its snis
Emeric Brun054563d2019-10-17 13:16:58 +02004360 *
4361 * Returns a bitfield containing the flags:
4362 * ERR_FATAL in any fatal error case
4363 * ERR_ALERT if the reason of the error is available in err
4364 * ERR_WARN if a warning is available into err
William Lallemand614ca0d2019-10-07 13:52:11 +02004365 */
Emeric Brun054563d2019-10-17 13:16:58 +02004366static int ckch_inst_new_load_store(const char *path, struct ckch_store *ckchs, struct bind_conf *bind_conf,
4367 struct ssl_bind_conf *ssl_conf, char **sni_filter, int fcount, struct ckch_inst **ckchi, char **err)
Emeric Brunfc0421f2012-09-07 17:30:07 +02004368{
William Lallemandc9402072019-05-15 15:33:54 +02004369 SSL_CTX *ctx;
William Lallemandc9402072019-05-15 15:33:54 +02004370 int i;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004371 int order = 0;
4372 X509_NAME *xname;
4373 char *str;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01004374 EVP_PKEY *pkey;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02004375 struct pkey_info kinfo = { .sig = TLSEXT_signature_anonymous, .bits = 0 };
Emeric Brunfc0421f2012-09-07 17:30:07 +02004376#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
4377 STACK_OF(GENERAL_NAME) *names;
4378#endif
William Lallemand36b84632019-07-18 19:28:17 +02004379 struct cert_key_and_chain *ckch;
William Lallemand614ca0d2019-10-07 13:52:11 +02004380 struct ckch_inst *ckch_inst = NULL;
Emeric Brun054563d2019-10-17 13:16:58 +02004381 int errcode = 0;
4382
4383 *ckchi = NULL;
William Lallemanda59191b2019-05-15 16:08:56 +02004384
William Lallemande3af8fb2019-10-08 11:36:53 +02004385 if (!ckchs || !ckchs->ckch)
Emeric Brun054563d2019-10-17 13:16:58 +02004386 return ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004387
William Lallemande3af8fb2019-10-08 11:36:53 +02004388 ckch = ckchs->ckch;
William Lallemand36b84632019-07-18 19:28:17 +02004389
William Lallemandc9402072019-05-15 15:33:54 +02004390 ctx = SSL_CTX_new(SSLv23_server_method());
4391 if (!ctx) {
4392 memprintf(err, "%sunable to allocate SSL context for cert '%s'.\n",
4393 err && *err ? *err : "", path);
Emeric Brun054563d2019-10-17 13:16:58 +02004394 errcode |= ERR_ALERT | ERR_FATAL;
4395 goto error;
William Lallemandc9402072019-05-15 15:33:54 +02004396 }
4397
Emeric Bruna96b5822019-10-17 13:25:14 +02004398 errcode |= ssl_sock_put_ckch_into_ctx(path, ckch, ctx, err);
4399 if (errcode & ERR_CODE)
William Lallemand614ca0d2019-10-07 13:52:11 +02004400 goto error;
William Lallemand614ca0d2019-10-07 13:52:11 +02004401
4402 ckch_inst = ckch_inst_new();
4403 if (!ckch_inst) {
4404 memprintf(err, "%sunable to allocate SSL context for cert '%s'.\n",
4405 err && *err ? *err : "", path);
Emeric Brun054563d2019-10-17 13:16:58 +02004406 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandd9199372019-10-04 15:37:05 +02004407 goto error;
William Lallemandc9402072019-05-15 15:33:54 +02004408 }
4409
William Lallemand36b84632019-07-18 19:28:17 +02004410 pkey = X509_get_pubkey(ckch->cert);
Emmanuel Hocdet05942112017-02-20 16:11:50 +01004411 if (pkey) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02004412 kinfo.bits = EVP_PKEY_bits(pkey);
Emmanuel Hocdet05942112017-02-20 16:11:50 +01004413 switch(EVP_PKEY_base_id(pkey)) {
4414 case EVP_PKEY_RSA:
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02004415 kinfo.sig = TLSEXT_signature_rsa;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01004416 break;
4417 case EVP_PKEY_EC:
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02004418 kinfo.sig = TLSEXT_signature_ecdsa;
4419 break;
4420 case EVP_PKEY_DSA:
4421 kinfo.sig = TLSEXT_signature_dsa;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01004422 break;
4423 }
4424 EVP_PKEY_free(pkey);
4425 }
4426
Emeric Brun50bcecc2013-04-22 13:05:23 +02004427 if (fcount) {
William Lallemandfe49bb32019-10-03 23:46:33 +02004428 while (fcount--) {
William Lallemand1d29c742019-10-04 00:53:29 +02004429 order = ckch_inst_add_cert_sni(ctx, ckch_inst, bind_conf, ssl_conf, kinfo, sni_filter[fcount], order);
William Lallemandfe49bb32019-10-03 23:46:33 +02004430 if (order < 0) {
4431 memprintf(err, "%sunable to create a sni context.\n", err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004432 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandd9199372019-10-04 15:37:05 +02004433 goto error;
William Lallemandfe49bb32019-10-03 23:46:33 +02004434 }
4435 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004436 }
4437 else {
Emeric Brunfc0421f2012-09-07 17:30:07 +02004438#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
William Lallemand36b84632019-07-18 19:28:17 +02004439 names = X509_get_ext_d2i(ckch->cert, NID_subject_alt_name, NULL, NULL);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004440 if (names) {
4441 for (i = 0; i < sk_GENERAL_NAME_num(names); i++) {
4442 GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
4443 if (name->type == GEN_DNS) {
4444 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
William Lallemand1d29c742019-10-04 00:53:29 +02004445 order = ckch_inst_add_cert_sni(ctx, ckch_inst, bind_conf, ssl_conf, kinfo, str, order);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004446 OPENSSL_free(str);
William Lallemandfe49bb32019-10-03 23:46:33 +02004447 if (order < 0) {
4448 memprintf(err, "%sunable to create a sni context.\n", err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004449 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandd9199372019-10-04 15:37:05 +02004450 goto error;
William Lallemandfe49bb32019-10-03 23:46:33 +02004451 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004452 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004453 }
4454 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004455 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004456 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004457#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
William Lallemand36b84632019-07-18 19:28:17 +02004458 xname = X509_get_subject_name(ckch->cert);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004459 i = -1;
4460 while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
4461 X509_NAME_ENTRY *entry = X509_NAME_get_entry(xname, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02004462 ASN1_STRING *value;
4463
4464 value = X509_NAME_ENTRY_get_data(entry);
4465 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
William Lallemand1d29c742019-10-04 00:53:29 +02004466 order = ckch_inst_add_cert_sni(ctx, ckch_inst, bind_conf, ssl_conf, kinfo, str, order);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004467 OPENSSL_free(str);
William Lallemandfe49bb32019-10-03 23:46:33 +02004468 if (order < 0) {
4469 memprintf(err, "%sunable to create a sni context.\n", err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004470 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandd9199372019-10-04 15:37:05 +02004471 goto error;
William Lallemandfe49bb32019-10-03 23:46:33 +02004472 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004473 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004474 }
4475 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004476 /* we must not free the SSL_CTX anymore below, since it's already in
4477 * the tree, so it will be discovered and cleaned in time.
4478 */
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02004479
Emeric Brunfc0421f2012-09-07 17:30:07 +02004480#ifndef SSL_CTRL_SET_TLSEXT_HOSTNAME
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004481 if (bind_conf->default_ctx) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02004482 memprintf(err, "%sthis version of openssl cannot load multiple SSL certificates.\n",
4483 err && *err ? *err : "");
Emeric Brun054563d2019-10-17 13:16:58 +02004484 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemandd9199372019-10-04 15:37:05 +02004485 goto error;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004486 }
4487#endif
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004488 if (!bind_conf->default_ctx) {
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004489 bind_conf->default_ctx = ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004490 bind_conf->default_ssl_conf = ssl_conf;
William Lallemand21724f02019-11-04 17:56:13 +01004491 ckch_inst->is_default = 1;
William Lallemand02e19a52020-04-08 16:11:26 +02004492 SSL_CTX_up_ref(ctx);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004493 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02004494
William Lallemand9117de92019-10-04 00:29:42 +02004495 /* everything succeed, the ckch instance can be used */
4496 ckch_inst->bind_conf = bind_conf;
William Lallemand150bfa82019-09-19 17:12:49 +02004497 ckch_inst->ssl_conf = ssl_conf;
William Lallemandcfca1422020-03-05 10:17:47 +01004498 ckch_inst->ckch_store = ckchs;
William Lallemand9117de92019-10-04 00:29:42 +02004499
William Lallemand02e19a52020-04-08 16:11:26 +02004500 SSL_CTX_free(ctx); /* we need to free the ctx since we incremented the refcount where it's used */
4501
Emeric Brun054563d2019-10-17 13:16:58 +02004502 *ckchi = ckch_inst;
4503 return errcode;
William Lallemandd9199372019-10-04 15:37:05 +02004504
4505error:
4506 /* free the allocated sni_ctxs */
William Lallemand614ca0d2019-10-07 13:52:11 +02004507 if (ckch_inst) {
William Lallemand02e19a52020-04-08 16:11:26 +02004508 if (ckch_inst->is_default)
4509 SSL_CTX_free(ctx);
4510
William Lallemandd9d5d1b2020-04-09 16:31:05 +02004511 ckch_inst_free(ckch_inst);
William Lallemand614ca0d2019-10-07 13:52:11 +02004512 ckch_inst = NULL;
William Lallemandd9199372019-10-04 15:37:05 +02004513 }
William Lallemandd9199372019-10-04 15:37:05 +02004514 SSL_CTX_free(ctx);
4515
Emeric Brun054563d2019-10-17 13:16:58 +02004516 return errcode;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004517}
4518
Willy Tarreau8c5414a2019-10-16 17:06:25 +02004519/* Returns a set of ERR_* flags possibly with an error in <err>. */
William Lallemand614ca0d2019-10-07 13:52:11 +02004520static int ssl_sock_load_ckchs(const char *path, struct ckch_store *ckchs,
4521 struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
William Lallemand24bde432020-03-09 16:48:43 +01004522 char **sni_filter, int fcount, struct ckch_inst **ckch_inst, char **err)
William Lallemand614ca0d2019-10-07 13:52:11 +02004523{
Emeric Brun054563d2019-10-17 13:16:58 +02004524 int errcode = 0;
William Lallemand614ca0d2019-10-07 13:52:11 +02004525
4526 /* we found the ckchs in the tree, we can use it directly */
4527 if (ckchs->multi)
William Lallemand24bde432020-03-09 16:48:43 +01004528 errcode |= ckch_inst_new_load_multi_store(path, ckchs, bind_conf, ssl_conf, sni_filter, fcount, ckch_inst, err);
William Lallemand614ca0d2019-10-07 13:52:11 +02004529 else
William Lallemand24bde432020-03-09 16:48:43 +01004530 errcode |= ckch_inst_new_load_store(path, ckchs, bind_conf, ssl_conf, sni_filter, fcount, ckch_inst, err);
William Lallemand614ca0d2019-10-07 13:52:11 +02004531
Emeric Brun054563d2019-10-17 13:16:58 +02004532 if (errcode & ERR_CODE)
4533 return errcode;
William Lallemand614ca0d2019-10-07 13:52:11 +02004534
William Lallemand24bde432020-03-09 16:48:43 +01004535 ssl_sock_load_cert_sni(*ckch_inst, bind_conf);
William Lallemand614ca0d2019-10-07 13:52:11 +02004536
4537 /* succeed, add the instance to the ckch_store's list of instance */
William Lallemand24bde432020-03-09 16:48:43 +01004538 LIST_ADDQ(&ckchs->ckch_inst, &((*ckch_inst)->by_ckchs));
Emeric Brun054563d2019-10-17 13:16:58 +02004539 return errcode;
William Lallemand614ca0d2019-10-07 13:52:11 +02004540}
4541
William Lallemand6be66ec2020-03-06 22:26:32 +01004542
William Lallemand4c68bba2020-03-30 18:45:10 +02004543
4544
4545/* Make sure openssl opens /dev/urandom before the chroot. The work is only
4546 * done once. Zero is returned if the operation fails. No error is returned
4547 * if the random is said as not implemented, because we expect that openssl
4548 * will use another method once needed.
4549 */
4550static int ssl_initialize_random()
4551{
4552 unsigned char random;
4553 static int random_initialized = 0;
4554
4555 if (!random_initialized && RAND_bytes(&random, 1) != 0)
4556 random_initialized = 1;
4557
4558 return random_initialized;
4559}
4560
William Lallemandec2d4932020-04-09 13:44:21 +02004561
William Lallemand6be66ec2020-03-06 22:26:32 +01004562/* This function reads a directory and stores it in a struct crtlist, each file is a crtlist_entry structure
4563 * Fill the <crtlist> argument with a pointer to a new crtlist struct
4564 *
4565 * This function tries to open and store certificate files.
4566 */
4567static int crtlist_load_cert_dir(char *path, struct bind_conf *bind_conf, struct crtlist **crtlist, char **err)
Emeric Brunfc0421f2012-09-07 17:30:07 +02004568{
William Lallemand6be66ec2020-03-06 22:26:32 +01004569 struct crtlist *dir;
Cyril Bonté3180f7b2015-01-25 00:16:08 +01004570 struct dirent **de_list;
4571 int i, n;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004572 struct stat buf;
Willy Tarreauee2663b2012-12-06 11:36:59 +01004573 char *end;
4574 char fp[MAXPATHLEN+1];
Emeric Brunfc0421f2012-09-07 17:30:07 +02004575 int cfgerr = 0;
William Lallemande3af8fb2019-10-08 11:36:53 +02004576 struct ckch_store *ckchs;
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004577#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu63ea8462015-12-09 13:35:14 -05004578 int is_bundle;
4579 int j;
4580#endif
Willy Tarreaubbc91962019-10-16 16:42:19 +02004581
William Lallemandec2d4932020-04-09 13:44:21 +02004582 dir = crtlist_new(path, 1);
William Lallemand6be66ec2020-03-06 22:26:32 +01004583 if (dir == NULL) {
4584 memprintf(err, "not enough memory");
4585 return ERR_ALERT | ERR_FATAL;
4586 }
William Lallemand6be66ec2020-03-06 22:26:32 +01004587
William Lallemand2d232c22020-03-06 22:12:35 +01004588 n = scandir(path, &de_list, 0, alphasort);
4589 if (n < 0) {
4590 memprintf(err, "%sunable to scan directory '%s' : %s.\n",
4591 err && *err ? *err : "", path, strerror(errno));
4592 cfgerr |= ERR_ALERT | ERR_FATAL;
4593 }
4594 else {
4595 for (i = 0; i < n; i++) {
William Lallemand6be66ec2020-03-06 22:26:32 +01004596 struct crtlist_entry *entry;
William Lallemand2d232c22020-03-06 22:12:35 +01004597 struct dirent *de = de_list[i];
Emeric Brun2aab7222014-06-18 18:15:09 +02004598
William Lallemand2d232c22020-03-06 22:12:35 +01004599 end = strrchr(de->d_name, '.');
4600 if (end && (!strcmp(end, ".issuer") || !strcmp(end, ".ocsp") || !strcmp(end, ".sctl") || !strcmp(end, ".key")))
4601 goto ignore_entry;
Cyril Bonté3180f7b2015-01-25 00:16:08 +01004602
William Lallemanda64593c2020-03-17 20:11:41 +01004603 snprintf(fp, sizeof(fp), "%s/%s", path, de->d_name);
4604 if (stat(fp, &buf) != 0) {
4605 memprintf(err, "%sunable to stat SSL certificate from file '%s' : %s.\n",
4606 err && *err ? *err : "", fp, strerror(errno));
4607 cfgerr |= ERR_ALERT | ERR_FATAL;
4608 goto ignore_entry;
4609 }
4610 if (!S_ISREG(buf.st_mode))
4611 goto ignore_entry;
4612
William Lallemande718dfb2020-04-10 11:09:25 +02004613 entry = crtlist_entry_new();
William Lallemand6be66ec2020-03-06 22:26:32 +01004614 if (entry == NULL) {
4615 memprintf(err, "not enough memory '%s'", fp);
4616 cfgerr |= ERR_ALERT | ERR_FATAL;
4617 goto ignore_entry;
4618 }
4619
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004620#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
William Lallemand2d232c22020-03-06 22:12:35 +01004621 is_bundle = 0;
4622 /* Check if current entry in directory is part of a multi-cert bundle */
yanbzhu63ea8462015-12-09 13:35:14 -05004623
William Lallemand2d232c22020-03-06 22:12:35 +01004624 if ((global_ssl.extra_files & SSL_GF_BUNDLE) && end) {
4625 for (j = 0; j < SSL_SOCK_NUM_KEYTYPES; j++) {
4626 if (!strcmp(end + 1, SSL_SOCK_KEYTYPE_NAMES[j])) {
4627 is_bundle = 1;
4628 break;
yanbzhu63ea8462015-12-09 13:35:14 -05004629 }
William Lallemand2d232c22020-03-06 22:12:35 +01004630 }
yanbzhu63ea8462015-12-09 13:35:14 -05004631
William Lallemand2d232c22020-03-06 22:12:35 +01004632 if (is_bundle) {
4633 int dp_len;
yanbzhu63ea8462015-12-09 13:35:14 -05004634
William Lallemand2d232c22020-03-06 22:12:35 +01004635 dp_len = end - de->d_name;
yanbzhu63ea8462015-12-09 13:35:14 -05004636
William Lallemand2d232c22020-03-06 22:12:35 +01004637 /* increment i and free de until we get to a non-bundle cert
4638 * Note here that we look at de_list[i + 1] before freeing de
4639 * this is important since ignore_entry will free de. This also
4640 * guarantees that de->d_name continues to hold the same prefix.
4641 */
4642 while (i + 1 < n && !strncmp(de_list[i + 1]->d_name, de->d_name, dp_len)) {
4643 free(de);
4644 i++;
4645 de = de_list[i];
yanbzhu63ea8462015-12-09 13:35:14 -05004646 }
William Lallemand2d232c22020-03-06 22:12:35 +01004647
4648 snprintf(fp, sizeof(fp), "%s/%.*s", path, dp_len, de->d_name);
William Lallemand6be66ec2020-03-06 22:26:32 +01004649 ckchs = ckchs_lookup(fp);
4650 if (ckchs == NULL)
4651 ckchs = ckchs_load_cert_file(fp, 1, err);
4652 if (ckchs == NULL) {
4653 free(de);
4654 free(entry);
William Lallemand2d232c22020-03-06 22:12:35 +01004655 cfgerr |= ERR_ALERT | ERR_FATAL;
William Lallemand6be66ec2020-03-06 22:26:32 +01004656 goto end;
4657 }
William Lallemand6be66ec2020-03-06 22:26:32 +01004658 entry->node.key = ckchs;
William Lallemandfa8cf0c2020-03-30 19:59:57 +02004659 entry->crtlist = dir;
William Lallemand23d61c02020-03-30 18:27:58 +02004660 LIST_ADDQ(&ckchs->crtlist_entry, &entry->by_ckch_store);
William Lallemand83918e22020-03-16 17:21:51 +01004661 LIST_ADDQ(&dir->ord_entries, &entry->by_crtlist);
William Lallemand6be66ec2020-03-06 22:26:32 +01004662 ebpt_insert(&dir->entries, &entry->node);
4663
William Lallemand2d232c22020-03-06 22:12:35 +01004664 /* Successfully processed the bundle */
4665 goto ignore_entry;
yanbzhu63ea8462015-12-09 13:35:14 -05004666 }
William Lallemand2d232c22020-03-06 22:12:35 +01004667 }
yanbzhu63ea8462015-12-09 13:35:14 -05004668
4669#endif
William Lallemand6be66ec2020-03-06 22:26:32 +01004670 ckchs = ckchs_lookup(fp);
4671 if (ckchs == NULL)
4672 ckchs = ckchs_load_cert_file(fp, 0, err);
4673 if (ckchs == NULL) {
4674 free(de);
4675 free(entry);
William Lallemand2d232c22020-03-06 22:12:35 +01004676 cfgerr |= ERR_ALERT | ERR_FATAL;
William Lallemand6be66ec2020-03-06 22:26:32 +01004677 goto end;
4678 }
4679 entry->node.key = ckchs;
William Lallemandfa8cf0c2020-03-30 19:59:57 +02004680 entry->crtlist = dir;
William Lallemand23d61c02020-03-30 18:27:58 +02004681 LIST_ADDQ(&ckchs->crtlist_entry, &entry->by_ckch_store);
William Lallemand83918e22020-03-16 17:21:51 +01004682 LIST_ADDQ(&dir->ord_entries, &entry->by_crtlist);
William Lallemand6be66ec2020-03-06 22:26:32 +01004683 ebpt_insert(&dir->entries, &entry->node);
William Lallemand36b84632019-07-18 19:28:17 +02004684
yanbzhu08ce6ab2015-12-02 13:01:29 -05004685ignore_entry:
William Lallemand2d232c22020-03-06 22:12:35 +01004686 free(de);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004687 }
William Lallemand6be66ec2020-03-06 22:26:32 +01004688end:
William Lallemand2d232c22020-03-06 22:12:35 +01004689 free(de_list);
4690 }
William Lallemand6be66ec2020-03-06 22:26:32 +01004691
4692 if (cfgerr & ERR_CODE) {
4693 /* free the dir and entries on error */
William Lallemand09bd5a02020-03-30 18:19:43 +02004694 crtlist_free(dir);
William Lallemand83918e22020-03-16 17:21:51 +01004695 } else {
4696 *crtlist = dir;
William Lallemand6be66ec2020-03-06 22:26:32 +01004697 }
William Lallemand2d232c22020-03-06 22:12:35 +01004698 return cfgerr;
William Lallemand6be66ec2020-03-06 22:26:32 +01004699
William Lallemand2d232c22020-03-06 22:12:35 +01004700}
yanbzhu08ce6ab2015-12-02 13:01:29 -05004701
William Lallemand97b08102020-04-01 10:14:00 +02004702/*
4703 * Read a single crt-list line. /!\ alter the <line> string.
4704 * Fill <crt_path> and <crtlist_entry>
4705 * <crtlist_entry> must be alloc and free by the caller
4706 * <crtlist_entry->ssl_conf> is alloc by the function
4707 * <crtlist_entry->filters> is alloc by the function
4708 * <crt_path> is a ptr in <line>
4709 * Return an error code
4710 */
4711static int crtlist_parse_line(char *line, char **crt_path, struct crtlist_entry *entry, const char *file, int linenum, char **err)
4712{
4713 int cfgerr = 0;
4714 int arg, newarg, cur_arg, i, ssl_b = 0, ssl_e = 0;
4715 char *end;
4716 char *args[MAX_CRT_ARGS + 1];
4717 struct ssl_bind_conf *ssl_conf = NULL;
4718
4719 if (!line || !crt_path || !entry)
4720 return ERR_ALERT | ERR_FATAL;
4721
4722 end = line + strlen(line);
4723 if (end-line >= CRT_LINESIZE-1 && *(end-1) != '\n') {
4724 /* Check if we reached the limit and the last char is not \n.
4725 * Watch out for the last line without the terminating '\n'!
4726 */
4727 memprintf(err, "line %d too long in file '%s', limit is %d characters",
4728 linenum, file, CRT_LINESIZE-1);
4729 cfgerr |= ERR_ALERT | ERR_FATAL;
4730 goto error;
4731 }
4732 arg = 0;
4733 newarg = 1;
4734 while (*line) {
4735 if (isspace((unsigned char)*line)) {
4736 newarg = 1;
4737 *line = 0;
4738 } else if (*line == '[') {
4739 if (ssl_b) {
4740 memprintf(err, "too many '[' on line %d in file '%s'.", linenum, file);
4741 cfgerr |= ERR_ALERT | ERR_FATAL;
4742 goto error;
4743 }
4744 if (!arg) {
4745 memprintf(err, "file must start with a cert on line %d in file '%s'", linenum, file);
4746 cfgerr |= ERR_ALERT | ERR_FATAL;
4747 goto error;
4748 }
4749 ssl_b = arg;
4750 newarg = 1;
4751 *line = 0;
4752 } else if (*line == ']') {
4753 if (ssl_e) {
4754 memprintf(err, "too many ']' on line %d in file '%s'.", linenum, file);
4755 cfgerr |= ERR_ALERT | ERR_FATAL;
4756 goto error;
4757 }
4758 if (!ssl_b) {
4759 memprintf(err, "missing '[' in line %d in file '%s'.", linenum, file);
4760 cfgerr |= ERR_ALERT | ERR_FATAL;
4761 goto error;
4762 }
4763 ssl_e = arg;
4764 newarg = 1;
4765 *line = 0;
4766 } else if (newarg) {
4767 if (arg == MAX_CRT_ARGS) {
4768 memprintf(err, "too many args on line %d in file '%s'.", linenum, file);
4769 cfgerr |= ERR_ALERT | ERR_FATAL;
4770 goto error;
4771 }
4772 newarg = 0;
4773 args[arg++] = line;
4774 }
4775 line++;
4776 }
4777 args[arg++] = line;
4778
4779 /* empty line */
4780 if (!*args[0]) {
4781 cfgerr |= ERR_NONE;
4782 goto error;
4783 }
4784
4785 *crt_path = args[0];
4786
William Lallemand1b2988b2020-04-10 17:20:45 +02004787 if (ssl_b) {
4788 ssl_conf = calloc(1, sizeof *ssl_conf);
4789 if (!ssl_conf) {
4790 memprintf(err, "not enough memory!");
4791 cfgerr |= ERR_ALERT | ERR_FATAL;
4792 goto error;
4793 }
William Lallemand97b08102020-04-01 10:14:00 +02004794 }
4795 cur_arg = ssl_b ? ssl_b : 1;
4796 while (cur_arg < ssl_e) {
4797 newarg = 0;
4798 for (i = 0; ssl_bind_kws[i].kw != NULL; i++) {
4799 if (strcmp(ssl_bind_kws[i].kw, args[cur_arg]) == 0) {
4800 newarg = 1;
4801 cfgerr |= ssl_bind_kws[i].parse(args, cur_arg, NULL, ssl_conf, err);
4802 if (cur_arg + 1 + ssl_bind_kws[i].skip > ssl_e) {
4803 memprintf(err, "ssl args out of '[]' for %s on line %d in file '%s'",
4804 args[cur_arg], linenum, file);
4805 cfgerr |= ERR_ALERT | ERR_FATAL;
4806 goto error;
4807 }
4808 cur_arg += 1 + ssl_bind_kws[i].skip;
4809 break;
4810 }
4811 }
4812 if (!cfgerr && !newarg) {
4813 memprintf(err, "unknown ssl keyword %s on line %d in file '%s'.",
4814 args[cur_arg], linenum, file);
4815 cfgerr |= ERR_ALERT | ERR_FATAL;
4816 goto error;
4817 }
4818 }
William Lallemandc69f02d2020-04-06 19:07:03 +02004819 entry->linenum = linenum;
William Lallemand97b08102020-04-01 10:14:00 +02004820 entry->ssl_conf = ssl_conf;
4821 entry->filters = crtlist_dup_filters(&args[cur_arg], arg - cur_arg - 1);
4822 entry->fcount = arg - cur_arg - 1;
4823
4824 return cfgerr;
4825
4826error:
4827 crtlist_free_filters(entry->filters);
4828 entry->filters = NULL;
4829 ssl_sock_free_ssl_conf(entry->ssl_conf);
4830 free(entry->ssl_conf);
4831 entry->ssl_conf = NULL;
4832 return cfgerr;
4833}
4834
William Lallemand2954c472020-03-06 21:54:13 +01004835/* This function parse a crt-list file and store it in a struct crtlist, each line is a crtlist_entry structure
4836 * Fill the <crtlist> argument with a pointer to a new crtlist struct
4837 *
4838 * This function tries to open and store certificate files.
4839 */
4840static int crtlist_parse_file(char *file, struct bind_conf *bind_conf, struct proxy *curproxy, struct crtlist **crtlist, char **err)
4841{
4842 struct crtlist *newlist;
William Lallemand97b08102020-04-01 10:14:00 +02004843 struct crtlist_entry *entry = NULL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004844 char thisline[CRT_LINESIZE];
4845 char path[MAXPATHLEN+1];
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004846 FILE *f;
yanbzhu1b04e5b2015-12-02 13:54:14 -05004847 struct stat buf;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004848 int linenum = 0;
4849 int cfgerr = 0;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004850
Willy Tarreauad1731d2013-04-02 17:35:58 +02004851 if ((f = fopen(file, "r")) == NULL) {
4852 memprintf(err, "cannot open file '%s' : %s", file, strerror(errno));
Willy Tarreaubbc91962019-10-16 16:42:19 +02004853 return ERR_ALERT | ERR_FATAL;
Willy Tarreauad1731d2013-04-02 17:35:58 +02004854 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004855
William Lallemandec2d4932020-04-09 13:44:21 +02004856 newlist = crtlist_new(file, 0);
William Lallemand2954c472020-03-06 21:54:13 +01004857 if (newlist == NULL) {
4858 memprintf(err, "Not enough memory!");
4859 cfgerr |= ERR_ALERT | ERR_FATAL;
4860 goto error;
4861 }
William Lallemand2954c472020-03-06 21:54:13 +01004862
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004863 while (fgets(thisline, sizeof(thisline), f) != NULL) {
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004864 char *end;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004865 char *line = thisline;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004866 char *crt_path;
William Lallemand2954c472020-03-06 21:54:13 +01004867 struct ckch_store *ckchs;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004868
4869 linenum++;
4870 end = line + strlen(line);
4871 if (end-line == sizeof(thisline)-1 && *(end-1) != '\n') {
4872 /* Check if we reached the limit and the last char is not \n.
4873 * Watch out for the last line without the terminating '\n'!
4874 */
Willy Tarreauad1731d2013-04-02 17:35:58 +02004875 memprintf(err, "line %d too long in file '%s', limit is %d characters",
4876 linenum, file, (int)sizeof(thisline)-1);
Willy Tarreaubbc91962019-10-16 16:42:19 +02004877 cfgerr |= ERR_ALERT | ERR_FATAL;
Willy Tarreauad1731d2013-04-02 17:35:58 +02004878 break;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004879 }
William Lallemand97b08102020-04-01 10:14:00 +02004880
4881 if (*line == '#' || *line == '\n' || *line == '\r')
4882 continue;
4883
William Lallemande718dfb2020-04-10 11:09:25 +02004884 entry = crtlist_entry_new();
William Lallemand97b08102020-04-01 10:14:00 +02004885 if (entry == NULL) {
4886 memprintf(err, "Not enough memory!");
4887 cfgerr |= ERR_ALERT | ERR_FATAL;
4888 goto error;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004889 }
William Lallemand97b08102020-04-01 10:14:00 +02004890
4891 *(end - 1) = '\0'; /* line parser mustn't receive any \n */
4892 cfgerr |= crtlist_parse_line(thisline, &crt_path, entry, file, linenum, err);
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02004893 if (cfgerr)
William Lallemand97b08102020-04-01 10:14:00 +02004894 goto error;
Willy Tarreauad1731d2013-04-02 17:35:58 +02004895
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004896 /* empty line */
William Lallemand97b08102020-04-01 10:14:00 +02004897 if (!crt_path || !*crt_path) {
William Lallemande718dfb2020-04-10 11:09:25 +02004898 crtlist_entry_free(entry);
William Lallemand97b08102020-04-01 10:14:00 +02004899 entry = NULL;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004900 continue;
William Lallemand97b08102020-04-01 10:14:00 +02004901 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004902
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004903 if (*crt_path != '/' && global_ssl.crt_base) {
4904 if ((strlen(global_ssl.crt_base) + 1 + strlen(crt_path)) > MAXPATHLEN) {
4905 memprintf(err, "'%s' : path too long on line %d in file '%s'",
4906 crt_path, linenum, file);
Willy Tarreaubbc91962019-10-16 16:42:19 +02004907 cfgerr |= ERR_ALERT | ERR_FATAL;
William Lallemand97b08102020-04-01 10:14:00 +02004908 goto error;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004909 }
4910 snprintf(path, sizeof(path), "%s/%s", global_ssl.crt_base, crt_path);
4911 crt_path = path;
4912 }
4913
William Lallemand2954c472020-03-06 21:54:13 +01004914 /* Look for a ckch_store or create one */
4915 ckchs = ckchs_lookup(crt_path);
4916 if (ckchs == NULL) {
William Lallemandeed4bf22019-10-10 11:38:13 +02004917 if (stat(crt_path, &buf) == 0)
William Lallemande3af8fb2019-10-08 11:36:53 +02004918 ckchs = ckchs_load_cert_file(crt_path, 0, err);
Emmanuel Hocdet1503e052019-07-31 18:30:33 +02004919 else
William Lallemande3af8fb2019-10-08 11:36:53 +02004920 ckchs = ckchs_load_cert_file(crt_path, 1, err);
yanbzhu1b04e5b2015-12-02 13:54:14 -05004921 }
William Lallemand909086e2020-03-17 16:53:27 +01004922 if (ckchs == NULL)
William Lallemand2954c472020-03-06 21:54:13 +01004923 cfgerr |= ERR_ALERT | ERR_FATAL;
William Lallemandeed4bf22019-10-10 11:38:13 +02004924
William Lallemand97b08102020-04-01 10:14:00 +02004925 if (cfgerr & ERR_CODE)
William Lallemand2954c472020-03-06 21:54:13 +01004926 goto error;
William Lallemand97b08102020-04-01 10:14:00 +02004927
William Lallemand2954c472020-03-06 21:54:13 +01004928 entry->node.key = ckchs;
William Lallemandfa8cf0c2020-03-30 19:59:57 +02004929 entry->crtlist = newlist;
William Lallemand2954c472020-03-06 21:54:13 +01004930 ebpt_insert(&newlist->entries, &entry->node);
4931 LIST_ADDQ(&newlist->ord_entries, &entry->by_crtlist);
William Lallemand23d61c02020-03-30 18:27:58 +02004932 LIST_ADDQ(&ckchs->crtlist_entry, &entry->by_ckch_store);
William Lallemand97b08102020-04-01 10:14:00 +02004933
4934 entry = NULL;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004935 }
William Lallemand2954c472020-03-06 21:54:13 +01004936 if (cfgerr & ERR_CODE)
4937 goto error;
4938
William Lallemandc69f02d2020-04-06 19:07:03 +02004939 newlist->linecount = linenum;
4940
William Lallemand2954c472020-03-06 21:54:13 +01004941 fclose(f);
4942 *crtlist = newlist;
4943
4944 return cfgerr;
4945error:
William Lallemande718dfb2020-04-10 11:09:25 +02004946 crtlist_entry_free(entry);
William Lallemand97b08102020-04-01 10:14:00 +02004947
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01004948 fclose(f);
William Lallemand2954c472020-03-06 21:54:13 +01004949 crtlist_free(newlist);
4950 return cfgerr;
4951}
4952
4953/* Load a crt-list file, this is done in 2 parts:
4954 * - store the content of the file in a crtlist structure with crtlist_entry structures
4955 * - generate the instances by iterating on entries in the crtlist struct
4956 *
4957 * Nothing is locked there, this function is used in the configuration parser.
4958 *
4959 * Returns a set of ERR_* flags possibly with an error in <err>.
4960 */
William Lallemand6be66ec2020-03-06 22:26:32 +01004961int ssl_sock_load_cert_list_file(char *file, int dir, struct bind_conf *bind_conf, struct proxy *curproxy, char **err)
William Lallemand2954c472020-03-06 21:54:13 +01004962{
4963 struct crtlist *crtlist = NULL;
4964 struct ebmb_node *eb;
William Lallemand49398312020-03-30 17:01:33 +02004965 struct crtlist_entry *entry = NULL;
William Lallemand79d31ec2020-03-25 15:10:49 +01004966 struct bind_conf_list *bind_conf_node = NULL;
William Lallemand2954c472020-03-06 21:54:13 +01004967 int cfgerr = 0;
William Lallemand41ca9302020-04-08 13:15:18 +02004968 char *end;
William Lallemand2954c472020-03-06 21:54:13 +01004969
William Lallemand79d31ec2020-03-25 15:10:49 +01004970 bind_conf_node = malloc(sizeof(*bind_conf_node));
4971 if (!bind_conf_node) {
4972 memprintf(err, "%sCan't alloc memory!\n", err && *err ? *err : "");
4973 cfgerr |= ERR_FATAL | ERR_ALERT;
4974 goto error;
4975 }
4976 bind_conf_node->next = NULL;
4977 bind_conf_node->bind_conf = bind_conf;
4978
William Lallemand41ca9302020-04-08 13:15:18 +02004979 /* strip trailing slashes, including first one */
4980 for (end = file + strlen(file) - 1; end >= file && *end == '/'; end--)
4981 *end = 0;
4982
William Lallemand2954c472020-03-06 21:54:13 +01004983 /* look for an existing crtlist or create one */
4984 eb = ebst_lookup(&crtlists_tree, file);
4985 if (eb) {
4986 crtlist = ebmb_entry(eb, struct crtlist, node);
4987 } else {
William Lallemand6be66ec2020-03-06 22:26:32 +01004988 /* load a crt-list OR a directory */
4989 if (dir)
4990 cfgerr |= crtlist_load_cert_dir(file, bind_conf, &crtlist, err);
4991 else
4992 cfgerr |= crtlist_parse_file(file, bind_conf, curproxy, &crtlist, err);
4993
William Lallemand2954c472020-03-06 21:54:13 +01004994 if (!(cfgerr & ERR_CODE))
4995 ebst_insert(&crtlists_tree, &crtlist->node);
4996 }
4997
4998 if (cfgerr & ERR_CODE) {
4999 cfgerr |= ERR_FATAL | ERR_ALERT;
5000 goto error;
5001 }
5002
5003 /* generates ckch instance from the crtlist_entry */
5004 list_for_each_entry(entry, &crtlist->ord_entries, by_crtlist) {
5005 struct ckch_store *store;
5006 struct ckch_inst *ckch_inst = NULL;
5007
5008 store = entry->node.key;
5009 cfgerr |= ssl_sock_load_ckchs(store->path, store, bind_conf, entry->ssl_conf, entry->filters, entry->fcount, &ckch_inst, err);
5010 if (cfgerr & ERR_CODE) {
5011 memprintf(err, "error processing line %d in file '%s' : %s", entry->linenum, file, *err);
5012 goto error;
5013 }
William Lallemand49398312020-03-30 17:01:33 +02005014 LIST_ADDQ(&entry->ckch_inst, &ckch_inst->by_crtlist_entry);
William Lallemandcaa16192020-04-08 16:29:15 +02005015 ckch_inst->crtlist_entry = entry;
William Lallemand2954c472020-03-06 21:54:13 +01005016 }
William Lallemand2954c472020-03-06 21:54:13 +01005017
William Lallemand79d31ec2020-03-25 15:10:49 +01005018 /* add the bind_conf to the list */
5019 bind_conf_node->next = crtlist->bind_conf;
5020 crtlist->bind_conf = bind_conf_node;
5021
William Lallemand2954c472020-03-06 21:54:13 +01005022 return cfgerr;
5023error:
5024 {
William Lallemand49398312020-03-30 17:01:33 +02005025 struct crtlist_entry *lastentry;
William Lallemand2954c472020-03-06 21:54:13 +01005026 struct ckch_inst *inst, *s_inst;
5027
William Lallemand49398312020-03-30 17:01:33 +02005028 lastentry = entry; /* which entry we tried to generate last */
5029 if (lastentry) {
5030 list_for_each_entry(entry, &crtlist->ord_entries, by_crtlist) {
5031 if (entry == lastentry) /* last entry we tried to generate, no need to go further */
5032 break;
5033
5034 list_for_each_entry_safe(inst, s_inst, &entry->ckch_inst, by_crtlist_entry) {
William Lallemand2954c472020-03-06 21:54:13 +01005035
William Lallemand49398312020-03-30 17:01:33 +02005036 /* this was not generated for this bind_conf, skip */
5037 if (inst->bind_conf != bind_conf)
5038 continue;
5039
William Lallemandd9d5d1b2020-04-09 16:31:05 +02005040 /* free the sni_ctx and instance */
5041 ckch_inst_free(inst);
William Lallemand49398312020-03-30 17:01:33 +02005042 }
William Lallemand2954c472020-03-06 21:54:13 +01005043 }
William Lallemand2954c472020-03-06 21:54:13 +01005044 }
William Lallemand79d31ec2020-03-25 15:10:49 +01005045 free(bind_conf_node);
William Lallemand2954c472020-03-06 21:54:13 +01005046 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01005047 return cfgerr;
5048}
5049
William Lallemand06b22a82020-03-16 14:45:55 +01005050/* Returns a set of ERR_* flags possibly with an error in <err>. */
5051int ssl_sock_load_cert(char *path, struct bind_conf *bind_conf, char **err)
5052{
5053 struct stat buf;
5054 char fp[MAXPATHLEN+1];
5055 int cfgerr = 0;
5056 struct ckch_store *ckchs;
William Lallemand24bde432020-03-09 16:48:43 +01005057 struct ckch_inst *ckch_inst = NULL;
William Lallemand06b22a82020-03-16 14:45:55 +01005058
5059 if ((ckchs = ckchs_lookup(path))) {
5060 /* we found the ckchs in the tree, we can use it directly */
William Lallemand24bde432020-03-09 16:48:43 +01005061 return ssl_sock_load_ckchs(path, ckchs, bind_conf, NULL, NULL, 0, &ckch_inst, err);
William Lallemand06b22a82020-03-16 14:45:55 +01005062 }
5063 if (stat(path, &buf) == 0) {
5064 if (S_ISDIR(buf.st_mode) == 0) {
5065 ckchs = ckchs_load_cert_file(path, 0, err);
5066 if (!ckchs)
5067 return ERR_ALERT | ERR_FATAL;
5068
William Lallemand24bde432020-03-09 16:48:43 +01005069 return ssl_sock_load_ckchs(path, ckchs, bind_conf, NULL, NULL, 0, &ckch_inst, err);
William Lallemand06b22a82020-03-16 14:45:55 +01005070 } else {
William Lallemand6be66ec2020-03-06 22:26:32 +01005071 return ssl_sock_load_cert_list_file(path, 1, bind_conf, bind_conf->frontend, err);
William Lallemand06b22a82020-03-16 14:45:55 +01005072 }
5073 } else {
5074 /* stat failed, could be a bundle */
5075 if (global_ssl.extra_files & SSL_GF_BUNDLE) {
5076 /* try to load a bundle if it is permitted */
5077 ckchs = ckchs_load_cert_file(path, 1, err);
5078 if (!ckchs)
5079 return ERR_ALERT | ERR_FATAL;
William Lallemand24bde432020-03-09 16:48:43 +01005080 cfgerr |= ssl_sock_load_ckchs(path, ckchs, bind_conf, NULL, NULL, 0, &ckch_inst, err);
William Lallemand06b22a82020-03-16 14:45:55 +01005081 } else {
5082 memprintf(err, "%sunable to stat SSL certificate from file '%s' : %s.\n",
5083 err && *err ? *err : "", fp, strerror(errno));
5084 cfgerr |= ERR_ALERT | ERR_FATAL;
5085 }
5086 }
5087
5088 return cfgerr;
5089}
5090
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005091/* Create an initial CTX used to start the SSL connection before switchctx */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005092static int
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005093ssl_sock_initial_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02005094{
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005095 SSL_CTX *ctx = NULL;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005096 long options =
Emeric Brunfc0421f2012-09-07 17:30:07 +02005097 SSL_OP_ALL | /* all known workarounds for bugs */
5098 SSL_OP_NO_SSLv2 |
5099 SSL_OP_NO_COMPRESSION |
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02005100 SSL_OP_SINGLE_DH_USE |
Emeric Brun2b58d042012-09-20 17:10:03 +02005101 SSL_OP_SINGLE_ECDH_USE |
Emeric Brun3c4bc6e2012-10-04 18:44:19 +02005102 SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION |
Lukas Tribus926594f2018-05-18 17:55:57 +02005103 SSL_OP_PRIORITIZE_CHACHA |
Emeric Brun3c4bc6e2012-10-04 18:44:19 +02005104 SSL_OP_CIPHER_SERVER_PREFERENCE;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005105 long mode =
Emeric Brunfc0421f2012-09-07 17:30:07 +02005106 SSL_MODE_ENABLE_PARTIAL_WRITE |
5107 SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
Willy Tarreau396a1862014-11-13 14:06:52 +01005108 SSL_MODE_RELEASE_BUFFERS |
5109 SSL_MODE_SMALL_BUFFERS;
Emmanuel Hocdet43664762017-08-09 18:26:20 +02005110 struct tls_version_filter *conf_ssl_methods = &bind_conf->ssl_conf.ssl_methods;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005111 int i, min, max, hole;
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005112 int flags = MC_SSL_O_ALL;
5113 int cfgerr = 0;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005114
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005115 ctx = SSL_CTX_new(SSLv23_server_method());
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005116 bind_conf->initial_ctx = ctx;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005117
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005118 if (conf_ssl_methods->flags && (conf_ssl_methods->min || conf_ssl_methods->max))
Christopher Faulet767a84b2017-11-24 16:50:31 +01005119 ha_warning("Proxy '%s': no-sslv3/no-tlsv1x are ignored for bind '%s' at [%s:%d]. "
5120 "Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
5121 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005122 else
5123 flags = conf_ssl_methods->flags;
5124
Emmanuel Hocdetbd695fe2017-05-15 15:53:41 +02005125 min = conf_ssl_methods->min;
5126 max = conf_ssl_methods->max;
5127 /* start with TLSv10 to remove SSLv3 per default */
5128 if (!min && (!max || max >= CONF_TLSV10))
5129 min = CONF_TLSV10;
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005130 /* Real min and max should be determinate with configuration and openssl's capabilities */
Emmanuel Hocdetbd695fe2017-05-15 15:53:41 +02005131 if (min)
5132 flags |= (methodVersions[min].flag - 1);
5133 if (max)
5134 flags |= ~((methodVersions[max].flag << 1) - 1);
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005135 /* find min, max and holes */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005136 min = max = CONF_TLSV_NONE;
5137 hole = 0;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005138 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005139 /* version is in openssl && version not disable in configuration */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005140 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005141 if (min) {
5142 if (hole) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005143 ha_warning("Proxy '%s': SSL/TLS versions range not contiguous for bind '%s' at [%s:%d]. "
5144 "Hole find for %s. Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
5145 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line,
5146 methodVersions[hole].name);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005147 hole = 0;
5148 }
5149 max = i;
5150 }
5151 else {
5152 min = max = i;
5153 }
5154 }
5155 else {
5156 if (min)
5157 hole = i;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005158 }
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005159 if (!min) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005160 ha_alert("Proxy '%s': all SSL/TLS versions are disabled for bind '%s' at [%s:%d].\n",
5161 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005162 cfgerr += 1;
5163 }
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02005164 /* save real min/max in bind_conf */
5165 conf_ssl_methods->min = min;
5166 conf_ssl_methods->max = max;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005167
Willy Tarreau9a1ab082019-05-09 13:26:41 +02005168#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005169 /* Keep force-xxx implementation as it is in older haproxy. It's a
Joseph Herlant017b3da2018-11-15 09:07:59 -08005170 precautionary measure to avoid any surprise with older openssl version. */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005171 if (min == max)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005172 methodVersions[min].ctx_set_version(ctx, SET_SERVER);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005173 else
5174 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
5175 if (flags & methodVersions[i].flag)
5176 options |= methodVersions[i].option;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005177#else /* openssl >= 1.1.0 */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005178 /* set the max_version is required to cap TLS version or activate new TLS (v1.3) */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005179 methodVersions[min].ctx_set_version(ctx, SET_MIN);
5180 methodVersions[max].ctx_set_version(ctx, SET_MAX);
Emeric Brunfa5c5c82017-04-28 16:19:51 +02005181#endif
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005182
5183 if (bind_conf->ssl_options & BC_SSL_O_NO_TLS_TICKETS)
5184 options |= SSL_OP_NO_TICKET;
5185 if (bind_conf->ssl_options & BC_SSL_O_PREF_CLIE_CIPH)
5186 options &= ~SSL_OP_CIPHER_SERVER_PREFERENCE;
Dirkjan Bussink526894f2019-01-21 09:35:03 -08005187
5188#ifdef SSL_OP_NO_RENEGOTIATION
5189 options |= SSL_OP_NO_RENEGOTIATION;
5190#endif
5191
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005192 SSL_CTX_set_options(ctx, options);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005193
Willy Tarreau5db847a2019-05-09 14:13:35 +02005194#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005195 if (global_ssl.async)
5196 mode |= SSL_MODE_ASYNC;
5197#endif
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005198 SSL_CTX_set_mode(ctx, mode);
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005199 if (global_ssl.life_time)
5200 SSL_CTX_set_timeout(ctx, global_ssl.life_time);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005201
5202#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
5203#ifdef OPENSSL_IS_BORINGSSL
5204 SSL_CTX_set_select_certificate_cb(ctx, ssl_sock_switchctx_cbk);
5205 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_err_cbk);
Ilya Shipitsine9ff8992020-01-19 12:20:14 +05005206#elif defined(SSL_OP_NO_ANTI_REPLAY)
Olivier Houchard545989f2019-12-17 15:39:54 +01005207 if (bind_conf->ssl_conf.early_data)
Olivier Houchard51088ce2019-01-02 18:46:41 +01005208 SSL_CTX_set_options(ctx, SSL_OP_NO_ANTI_REPLAY);
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02005209 SSL_CTX_set_client_hello_cb(ctx, ssl_sock_switchctx_cbk, NULL);
5210 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_err_cbk);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005211#else
5212 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_cbk);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005213#endif
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02005214 SSL_CTX_set_tlsext_servername_arg(ctx, bind_conf);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005215#endif
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005216 return cfgerr;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005217}
5218
William Lallemand4f45bb92017-10-30 20:08:51 +01005219
5220static inline void sh_ssl_sess_free_blocks(struct shared_block *first, struct shared_block *block)
5221{
5222 if (first == block) {
5223 struct sh_ssl_sess_hdr *sh_ssl_sess = (struct sh_ssl_sess_hdr *)first->data;
5224 if (first->len > 0)
5225 sh_ssl_sess_tree_delete(sh_ssl_sess);
5226 }
5227}
5228
5229/* return first block from sh_ssl_sess */
5230static inline struct shared_block *sh_ssl_sess_first_block(struct sh_ssl_sess_hdr *sh_ssl_sess)
5231{
5232 return (struct shared_block *)((unsigned char *)sh_ssl_sess - ((struct shared_block *)NULL)->data);
5233
5234}
5235
5236/* store a session into the cache
5237 * s_id : session id padded with zero to SSL_MAX_SSL_SESSION_ID_LENGTH
5238 * data: asn1 encoded session
5239 * data_len: asn1 encoded session length
5240 * Returns 1 id session was stored (else 0)
5241 */
5242static int sh_ssl_sess_store(unsigned char *s_id, unsigned char *data, int data_len)
5243{
5244 struct shared_block *first;
5245 struct sh_ssl_sess_hdr *sh_ssl_sess, *oldsh_ssl_sess;
5246
Frédéric Lécaille0bec8072018-10-22 17:55:57 +02005247 first = shctx_row_reserve_hot(ssl_shctx, NULL, data_len + sizeof(struct sh_ssl_sess_hdr));
William Lallemand4f45bb92017-10-30 20:08:51 +01005248 if (!first) {
5249 /* Could not retrieve enough free blocks to store that session */
5250 return 0;
5251 }
5252
5253 /* STORE the key in the first elem */
5254 sh_ssl_sess = (struct sh_ssl_sess_hdr *)first->data;
5255 memcpy(sh_ssl_sess->key_data, s_id, SSL_MAX_SSL_SESSION_ID_LENGTH);
5256 first->len = sizeof(struct sh_ssl_sess_hdr);
5257
5258 /* it returns the already existing node
5259 or current node if none, never returns null */
5260 oldsh_ssl_sess = sh_ssl_sess_tree_insert(sh_ssl_sess);
5261 if (oldsh_ssl_sess != sh_ssl_sess) {
5262 /* NOTE: Row couldn't be in use because we lock read & write function */
5263 /* release the reserved row */
5264 shctx_row_dec_hot(ssl_shctx, first);
5265 /* replace the previous session already in the tree */
5266 sh_ssl_sess = oldsh_ssl_sess;
5267 /* ignore the previous session data, only use the header */
5268 first = sh_ssl_sess_first_block(sh_ssl_sess);
5269 shctx_row_inc_hot(ssl_shctx, first);
5270 first->len = sizeof(struct sh_ssl_sess_hdr);
5271 }
5272
Frédéric Lécaille0bec8072018-10-22 17:55:57 +02005273 if (shctx_row_data_append(ssl_shctx, first, NULL, data, data_len) < 0) {
William Lallemand99b90af2018-01-03 19:15:51 +01005274 shctx_row_dec_hot(ssl_shctx, first);
William Lallemand4f45bb92017-10-30 20:08:51 +01005275 return 0;
William Lallemand99b90af2018-01-03 19:15:51 +01005276 }
5277
5278 shctx_row_dec_hot(ssl_shctx, first);
William Lallemand4f45bb92017-10-30 20:08:51 +01005279
5280 return 1;
5281}
William Lallemanded0b5ad2017-10-30 19:36:36 +01005282
Olivier Houchardbd84ac82017-11-03 13:43:35 +01005283/* SSL callback used when a new session is created while connecting to a server */
5284static int ssl_sess_new_srv_cb(SSL *ssl, SSL_SESSION *sess)
5285{
Thierry FOURNIER28962c92018-06-17 21:37:05 +02005286 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houcharde6060c52017-11-16 17:42:52 +01005287 struct server *s;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01005288
Willy Tarreau07d94e42018-09-20 10:57:52 +02005289 s = __objt_server(conn->target);
Olivier Houchardbd84ac82017-11-03 13:43:35 +01005290
Olivier Houcharde6060c52017-11-16 17:42:52 +01005291 if (!(s->ssl_ctx.options & SRV_SSL_O_NO_REUSE)) {
5292 int len;
5293 unsigned char *ptr;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01005294
Olivier Houcharde6060c52017-11-16 17:42:52 +01005295 len = i2d_SSL_SESSION(sess, NULL);
5296 if (s->ssl_ctx.reused_sess[tid].ptr && s->ssl_ctx.reused_sess[tid].allocated_size >= len) {
5297 ptr = s->ssl_ctx.reused_sess[tid].ptr;
5298 } else {
5299 free(s->ssl_ctx.reused_sess[tid].ptr);
5300 ptr = s->ssl_ctx.reused_sess[tid].ptr = malloc(len);
5301 s->ssl_ctx.reused_sess[tid].allocated_size = len;
5302 }
5303 if (s->ssl_ctx.reused_sess[tid].ptr) {
5304 s->ssl_ctx.reused_sess[tid].size = i2d_SSL_SESSION(sess,
5305 &ptr);
5306 }
5307 } else {
5308 free(s->ssl_ctx.reused_sess[tid].ptr);
5309 s->ssl_ctx.reused_sess[tid].ptr = NULL;
5310 }
5311
5312 return 0;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01005313}
5314
Olivier Houcharde6060c52017-11-16 17:42:52 +01005315
William Lallemanded0b5ad2017-10-30 19:36:36 +01005316/* SSL callback used on new session creation */
William Lallemand4f45bb92017-10-30 20:08:51 +01005317int sh_ssl_sess_new_cb(SSL *ssl, SSL_SESSION *sess)
William Lallemanded0b5ad2017-10-30 19:36:36 +01005318{
5319 unsigned char encsess[SHSESS_MAX_DATA_LEN]; /* encoded session */
5320 unsigned char encid[SSL_MAX_SSL_SESSION_ID_LENGTH]; /* encoded id */
5321 unsigned char *p;
5322 int data_len;
Emeric Bruneb469652019-10-08 18:27:37 +02005323 unsigned int sid_length;
William Lallemanded0b5ad2017-10-30 19:36:36 +01005324 const unsigned char *sid_data;
William Lallemanded0b5ad2017-10-30 19:36:36 +01005325
5326 /* Session id is already stored in to key and session id is known
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05005327 * so we don't store it to keep size.
Emeric Bruneb469652019-10-08 18:27:37 +02005328 * note: SSL_SESSION_set1_id is using
5329 * a memcpy so we need to use a different pointer
5330 * than sid_data or sid_ctx_data to avoid valgrind
5331 * complaining.
William Lallemanded0b5ad2017-10-30 19:36:36 +01005332 */
5333
5334 sid_data = SSL_SESSION_get_id(sess, &sid_length);
Emeric Bruneb469652019-10-08 18:27:37 +02005335
5336 /* copy value in an other buffer */
5337 memcpy(encid, sid_data, sid_length);
5338
5339 /* pad with 0 */
5340 if (sid_length < SSL_MAX_SSL_SESSION_ID_LENGTH)
5341 memset(encid + sid_length, 0, SSL_MAX_SSL_SESSION_ID_LENGTH-sid_length);
5342
5343 /* force length to zero to avoid ASN1 encoding */
5344 SSL_SESSION_set1_id(sess, encid, 0);
5345
5346 /* force length to zero to avoid ASN1 encoding */
5347 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, 0);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005348
5349 /* check if buffer is large enough for the ASN1 encoded session */
5350 data_len = i2d_SSL_SESSION(sess, NULL);
5351 if (data_len > SHSESS_MAX_DATA_LEN)
5352 goto err;
5353
5354 p = encsess;
5355
5356 /* process ASN1 session encoding before the lock */
5357 i2d_SSL_SESSION(sess, &p);
5358
William Lallemanded0b5ad2017-10-30 19:36:36 +01005359
William Lallemanda3c77cf2017-10-30 23:44:40 +01005360 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005361 /* store to cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01005362 sh_ssl_sess_store(encid, encsess, data_len);
William Lallemanda3c77cf2017-10-30 23:44:40 +01005363 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005364err:
5365 /* reset original length values */
Emeric Bruneb469652019-10-08 18:27:37 +02005366 SSL_SESSION_set1_id(sess, encid, sid_length);
5367 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
William Lallemanded0b5ad2017-10-30 19:36:36 +01005368
5369 return 0; /* do not increment session reference count */
5370}
5371
5372/* SSL callback used on lookup an existing session cause none found in internal cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01005373SSL_SESSION *sh_ssl_sess_get_cb(SSL *ssl, __OPENSSL_110_CONST__ unsigned char *key, int key_len, int *do_copy)
William Lallemanded0b5ad2017-10-30 19:36:36 +01005374{
William Lallemand4f45bb92017-10-30 20:08:51 +01005375 struct sh_ssl_sess_hdr *sh_ssl_sess;
William Lallemanded0b5ad2017-10-30 19:36:36 +01005376 unsigned char data[SHSESS_MAX_DATA_LEN], *p;
5377 unsigned char tmpkey[SSL_MAX_SSL_SESSION_ID_LENGTH];
William Lallemanded0b5ad2017-10-30 19:36:36 +01005378 SSL_SESSION *sess;
William Lallemand4f45bb92017-10-30 20:08:51 +01005379 struct shared_block *first;
William Lallemanded0b5ad2017-10-30 19:36:36 +01005380
5381 global.shctx_lookups++;
5382
5383 /* allow the session to be freed automatically by openssl */
5384 *do_copy = 0;
5385
5386 /* tree key is zeros padded sessionid */
5387 if (key_len < SSL_MAX_SSL_SESSION_ID_LENGTH) {
5388 memcpy(tmpkey, key, key_len);
5389 memset(tmpkey + key_len, 0, SSL_MAX_SSL_SESSION_ID_LENGTH - key_len);
5390 key = tmpkey;
5391 }
5392
5393 /* lock cache */
William Lallemanda3c77cf2017-10-30 23:44:40 +01005394 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005395
5396 /* lookup for session */
William Lallemand4f45bb92017-10-30 20:08:51 +01005397 sh_ssl_sess = sh_ssl_sess_tree_lookup(key);
5398 if (!sh_ssl_sess) {
William Lallemanded0b5ad2017-10-30 19:36:36 +01005399 /* no session found: unlock cache and exit */
William Lallemanda3c77cf2017-10-30 23:44:40 +01005400 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005401 global.shctx_misses++;
5402 return NULL;
5403 }
5404
William Lallemand4f45bb92017-10-30 20:08:51 +01005405 /* sh_ssl_sess (shared_block->data) is at the end of shared_block */
5406 first = sh_ssl_sess_first_block(sh_ssl_sess);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005407
William Lallemand4f45bb92017-10-30 20:08:51 +01005408 shctx_row_data_get(ssl_shctx, first, data, sizeof(struct sh_ssl_sess_hdr), first->len-sizeof(struct sh_ssl_sess_hdr));
William Lallemanded0b5ad2017-10-30 19:36:36 +01005409
William Lallemanda3c77cf2017-10-30 23:44:40 +01005410 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005411
5412 /* decode ASN1 session */
5413 p = data;
William Lallemand4f45bb92017-10-30 20:08:51 +01005414 sess = d2i_SSL_SESSION(NULL, (const unsigned char **)&p, first->len-sizeof(struct sh_ssl_sess_hdr));
William Lallemanded0b5ad2017-10-30 19:36:36 +01005415 /* Reset session id and session id contenxt */
5416 if (sess) {
5417 SSL_SESSION_set1_id(sess, key, key_len);
5418 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
5419 }
5420
5421 return sess;
5422}
5423
William Lallemand4f45bb92017-10-30 20:08:51 +01005424
William Lallemanded0b5ad2017-10-30 19:36:36 +01005425/* SSL callback used to signal session is no more used in internal cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01005426void sh_ssl_sess_remove_cb(SSL_CTX *ctx, SSL_SESSION *sess)
William Lallemanded0b5ad2017-10-30 19:36:36 +01005427{
William Lallemand4f45bb92017-10-30 20:08:51 +01005428 struct sh_ssl_sess_hdr *sh_ssl_sess;
William Lallemanded0b5ad2017-10-30 19:36:36 +01005429 unsigned char tmpkey[SSL_MAX_SSL_SESSION_ID_LENGTH];
5430 unsigned int sid_length;
5431 const unsigned char *sid_data;
5432 (void)ctx;
5433
5434 sid_data = SSL_SESSION_get_id(sess, &sid_length);
5435 /* tree key is zeros padded sessionid */
5436 if (sid_length < SSL_MAX_SSL_SESSION_ID_LENGTH) {
5437 memcpy(tmpkey, sid_data, sid_length);
5438 memset(tmpkey+sid_length, 0, SSL_MAX_SSL_SESSION_ID_LENGTH - sid_length);
5439 sid_data = tmpkey;
5440 }
5441
William Lallemanda3c77cf2017-10-30 23:44:40 +01005442 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005443
5444 /* lookup for session */
William Lallemand4f45bb92017-10-30 20:08:51 +01005445 sh_ssl_sess = sh_ssl_sess_tree_lookup(sid_data);
5446 if (sh_ssl_sess) {
William Lallemanded0b5ad2017-10-30 19:36:36 +01005447 /* free session */
William Lallemand4f45bb92017-10-30 20:08:51 +01005448 sh_ssl_sess_tree_delete(sh_ssl_sess);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005449 }
5450
5451 /* unlock cache */
William Lallemanda3c77cf2017-10-30 23:44:40 +01005452 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005453}
5454
5455/* Set session cache mode to server and disable openssl internal cache.
5456 * Set shared cache callbacks on an ssl context.
5457 * Shared context MUST be firstly initialized */
William Lallemand4f45bb92017-10-30 20:08:51 +01005458void ssl_set_shctx(SSL_CTX *ctx)
William Lallemanded0b5ad2017-10-30 19:36:36 +01005459{
5460 SSL_CTX_set_session_id_context(ctx, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
5461
5462 if (!ssl_shctx) {
5463 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
5464 return;
5465 }
5466
5467 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_SERVER |
5468 SSL_SESS_CACHE_NO_INTERNAL |
5469 SSL_SESS_CACHE_NO_AUTO_CLEAR);
5470
5471 /* Set callbacks */
William Lallemand4f45bb92017-10-30 20:08:51 +01005472 SSL_CTX_sess_set_new_cb(ctx, sh_ssl_sess_new_cb);
5473 SSL_CTX_sess_set_get_cb(ctx, sh_ssl_sess_get_cb);
5474 SSL_CTX_sess_set_remove_cb(ctx, sh_ssl_sess_remove_cb);
William Lallemanded0b5ad2017-10-30 19:36:36 +01005475}
5476
William Lallemand8b453912019-11-21 15:48:10 +01005477/*
5478 * This function applies the SSL configuration on a SSL_CTX
5479 * It returns an error code and fills the <err> buffer
5480 */
5481int ssl_sock_prepare_ctx(struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf, SSL_CTX *ctx, char **err)
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005482{
5483 struct proxy *curproxy = bind_conf->frontend;
5484 int cfgerr = 0;
5485 int verify = SSL_VERIFY_NONE;
Willy Tarreau5d4cafb2018-01-04 18:55:19 +01005486 struct ssl_bind_conf __maybe_unused *ssl_conf_cur;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005487 const char *conf_ciphers;
Emmanuel Hocdet839af572019-05-14 16:27:35 +02005488#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02005489 const char *conf_ciphersuites;
5490#endif
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01005491 const char *conf_curves = NULL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02005492
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02005493 if (ssl_conf) {
5494 struct tls_version_filter *conf_ssl_methods = &ssl_conf->ssl_methods;
5495 int i, min, max;
5496 int flags = MC_SSL_O_ALL;
5497
5498 /* Real min and max should be determinate with configuration and openssl's capabilities */
Emmanuel Hocdet43664762017-08-09 18:26:20 +02005499 min = conf_ssl_methods->min ? conf_ssl_methods->min : bind_conf->ssl_conf.ssl_methods.min;
5500 max = conf_ssl_methods->max ? conf_ssl_methods->max : bind_conf->ssl_conf.ssl_methods.max;
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02005501 if (min)
5502 flags |= (methodVersions[min].flag - 1);
5503 if (max)
5504 flags |= ~((methodVersions[max].flag << 1) - 1);
5505 min = max = CONF_TLSV_NONE;
5506 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
5507 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
5508 if (min)
5509 max = i;
5510 else
5511 min = max = i;
5512 }
5513 /* save real min/max */
5514 conf_ssl_methods->min = min;
5515 conf_ssl_methods->max = max;
5516 if (!min) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005517 memprintf(err, "%sProxy '%s': all SSL/TLS versions are disabled for bind '%s' at [%s:%d].\n",
5518 err && *err ? *err : "", bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005519 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02005520 }
5521 }
5522
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005523 switch ((ssl_conf && ssl_conf->verify) ? ssl_conf->verify : bind_conf->ssl_conf.verify) {
Emeric Brun850efd52014-01-29 12:24:34 +01005524 case SSL_SOCK_VERIFY_NONE:
5525 verify = SSL_VERIFY_NONE;
5526 break;
5527 case SSL_SOCK_VERIFY_OPTIONAL:
5528 verify = SSL_VERIFY_PEER;
5529 break;
5530 case SSL_SOCK_VERIFY_REQUIRED:
5531 verify = SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
5532 break;
5533 }
5534 SSL_CTX_set_verify(ctx, verify, ssl_sock_bind_verifycbk);
5535 if (verify & SSL_VERIFY_PEER) {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005536 char *ca_file = (ssl_conf && ssl_conf->ca_file) ? ssl_conf->ca_file : bind_conf->ssl_conf.ca_file;
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01005537 char *ca_verify_file = (ssl_conf && ssl_conf->ca_verify_file) ? ssl_conf->ca_verify_file : bind_conf->ssl_conf.ca_verify_file;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005538 char *crl_file = (ssl_conf && ssl_conf->crl_file) ? ssl_conf->crl_file : bind_conf->ssl_conf.crl_file;
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01005539 if (ca_file || ca_verify_file) {
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +02005540 /* set CAfile to verify */
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01005541 if (ca_file && !ssl_set_verify_locations_file(ctx, ca_file)) {
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +02005542 memprintf(err, "%sProxy '%s': unable to set CA file '%s' for bind '%s' at [%s:%d].\n",
Tim Duesterhus93128532019-11-23 23:45:10 +01005543 err && *err ? *err : "", curproxy->id, ca_file, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005544 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brund94b3fe2012-09-20 18:23:56 +02005545 }
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01005546 if (ca_verify_file && !ssl_set_verify_locations_file(ctx, ca_verify_file)) {
5547 memprintf(err, "%sProxy '%s': unable to set CA-no-names file '%s' for bind '%s' at [%s:%d].\n",
5548 err && *err ? *err : "", curproxy->id, ca_verify_file, bind_conf->arg, bind_conf->file, bind_conf->line);
5549 cfgerr |= ERR_ALERT | ERR_FATAL;
5550 }
5551 if (ca_file && !((ssl_conf && ssl_conf->no_ca_names) || bind_conf->ssl_conf.no_ca_names)) {
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02005552 /* set CA names for client cert request, function returns void */
Emmanuel Hocdet129d3282019-10-24 18:08:51 +02005553 SSL_CTX_set_client_CA_list(ctx, SSL_dup_CA_list(ssl_get_client_ca_file(ca_file)));
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02005554 }
Emeric Brund94b3fe2012-09-20 18:23:56 +02005555 }
Emeric Brun850efd52014-01-29 12:24:34 +01005556 else {
Tim Duesterhus93128532019-11-23 23:45:10 +01005557 memprintf(err, "%sProxy '%s': verify is enabled but no CA file specified for bind '%s' at [%s:%d].\n",
5558 err && *err ? *err : "", curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005559 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brun850efd52014-01-29 12:24:34 +01005560 }
Emeric Brun051cdab2012-10-02 19:25:50 +02005561#ifdef X509_V_FLAG_CRL_CHECK
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005562 if (crl_file) {
Emeric Brund94b3fe2012-09-20 18:23:56 +02005563 X509_STORE *store = SSL_CTX_get_cert_store(ctx);
5564
Emmanuel Hocdetb270e812019-11-21 19:09:31 +01005565 if (!ssl_set_cert_crl_file(store, crl_file)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005566 memprintf(err, "%sProxy '%s': unable to configure CRL file '%s' for bind '%s' at [%s:%d].\n",
5567 err && *err ? *err : "", curproxy->id, crl_file, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005568 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brund94b3fe2012-09-20 18:23:56 +02005569 }
Emeric Brun561e5742012-10-02 15:20:55 +02005570 else {
5571 X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
5572 }
Emeric Brund94b3fe2012-09-20 18:23:56 +02005573 }
Emeric Brun051cdab2012-10-02 19:25:50 +02005574#endif
Emeric Brun644cde02012-12-14 11:21:13 +01005575 ERR_clear_error();
Emeric Brund94b3fe2012-09-20 18:23:56 +02005576 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01005577#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
Nenad Merdanovic146defa2015-05-09 08:46:00 +02005578 if(bind_conf->keys_ref) {
Nenad Merdanovic05552d42015-02-27 19:56:49 +01005579 if (!SSL_CTX_set_tlsext_ticket_key_cb(ctx, ssl_tlsext_ticket_key_cb)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005580 memprintf(err, "%sProxy '%s': unable to set callback for TLS ticket validation for bind '%s' at [%s:%d].\n",
5581 err && *err ? *err : "", curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005582 cfgerr |= ERR_ALERT | ERR_FATAL;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01005583 }
5584 }
5585#endif
5586
William Lallemand4f45bb92017-10-30 20:08:51 +01005587 ssl_set_shctx(ctx);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005588 conf_ciphers = (ssl_conf && ssl_conf->ciphers) ? ssl_conf->ciphers : bind_conf->ssl_conf.ciphers;
5589 if (conf_ciphers &&
5590 !SSL_CTX_set_cipher_list(ctx, conf_ciphers)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005591 memprintf(err, "%sProxy '%s': unable to set SSL cipher list to '%s' for bind '%s' at [%s:%d].\n",
5592 err && *err ? *err : "", curproxy->id, conf_ciphers, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005593 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02005594 }
5595
Emmanuel Hocdet839af572019-05-14 16:27:35 +02005596#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02005597 conf_ciphersuites = (ssl_conf && ssl_conf->ciphersuites) ? ssl_conf->ciphersuites : bind_conf->ssl_conf.ciphersuites;
5598 if (conf_ciphersuites &&
5599 !SSL_CTX_set_ciphersuites(ctx, conf_ciphersuites)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005600 memprintf(err, "%sProxy '%s': unable to set TLS 1.3 cipher suites to '%s' for bind '%s' at [%s:%d].\n",
5601 err && *err ? *err : "", curproxy->id, conf_ciphersuites, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005602 cfgerr |= ERR_ALERT | ERR_FATAL;
Dirkjan Bussink415150f2018-09-14 11:14:21 +02005603 }
5604#endif
5605
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01005606#ifndef OPENSSL_NO_DH
Remi Gacogne47783ef2015-05-29 15:53:22 +02005607 /* If tune.ssl.default-dh-param has not been set,
5608 neither has ssl-default-dh-file and no static DH
5609 params were in the certificate file. */
Willy Tarreauef934602016-12-22 23:12:01 +01005610 if (global_ssl.default_dh_param == 0 &&
Remi Gacogne47783ef2015-05-29 15:53:22 +02005611 global_dh == NULL &&
Remi Gacogne4f902b82015-05-28 16:23:00 +02005612 (ssl_dh_ptr_index == -1 ||
5613 SSL_CTX_get_ex_data(ctx, ssl_dh_ptr_index) == NULL)) {
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01005614 STACK_OF(SSL_CIPHER) * ciphers = NULL;
5615 const SSL_CIPHER * cipher = NULL;
5616 char cipher_description[128];
5617 /* The description of ciphers using an Ephemeral Diffie Hellman key exchange
5618 contains " Kx=DH " or " Kx=DH(". Beware of " Kx=DH/",
5619 which is not ephemeral DH. */
5620 const char dhe_description[] = " Kx=DH ";
5621 const char dhe_export_description[] = " Kx=DH(";
5622 int idx = 0;
5623 int dhe_found = 0;
5624 SSL *ssl = NULL;
Lukas Tribus90132722014-08-18 00:56:33 +02005625
Remi Gacogne23d5d372014-10-10 17:04:26 +02005626 ssl = SSL_new(ctx);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005627
Remi Gacogne23d5d372014-10-10 17:04:26 +02005628 if (ssl) {
5629 ciphers = SSL_get_ciphers(ssl);
5630
5631 if (ciphers) {
5632 for (idx = 0; idx < sk_SSL_CIPHER_num(ciphers); idx++) {
5633 cipher = sk_SSL_CIPHER_value(ciphers, idx);
5634 if (SSL_CIPHER_description(cipher, cipher_description, sizeof (cipher_description)) == cipher_description) {
5635 if (strstr(cipher_description, dhe_description) != NULL ||
5636 strstr(cipher_description, dhe_export_description) != NULL) {
5637 dhe_found = 1;
5638 break;
5639 }
Remi Gacognec1eab8c2014-06-12 18:20:11 +02005640 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005641 }
5642 }
Remi Gacogne23d5d372014-10-10 17:04:26 +02005643 SSL_free(ssl);
5644 ssl = NULL;
Lukas Tribus90132722014-08-18 00:56:33 +02005645 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005646
Lukas Tribus90132722014-08-18 00:56:33 +02005647 if (dhe_found) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005648 memprintf(err, "%sSetting tune.ssl.default-dh-param to 1024 by default, if your workload permits it you should set it to at least 2048. Please set a value >= 1024 to make this warning disappear.\n",
5649 err && *err ? *err : "");
William Lallemand8b453912019-11-21 15:48:10 +01005650 cfgerr |= ERR_WARN;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005651 }
5652
Willy Tarreauef934602016-12-22 23:12:01 +01005653 global_ssl.default_dh_param = 1024;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005654 }
Remi Gacogne8de54152014-07-15 11:36:40 +02005655
Willy Tarreauef934602016-12-22 23:12:01 +01005656 if (global_ssl.default_dh_param >= 1024) {
Remi Gacogne8de54152014-07-15 11:36:40 +02005657 if (local_dh_1024 == NULL) {
5658 local_dh_1024 = ssl_get_dh_1024();
5659 }
Willy Tarreauef934602016-12-22 23:12:01 +01005660 if (global_ssl.default_dh_param >= 2048) {
Remi Gacogne8de54152014-07-15 11:36:40 +02005661 if (local_dh_2048 == NULL) {
5662 local_dh_2048 = ssl_get_dh_2048();
5663 }
Willy Tarreauef934602016-12-22 23:12:01 +01005664 if (global_ssl.default_dh_param >= 4096) {
Remi Gacogne8de54152014-07-15 11:36:40 +02005665 if (local_dh_4096 == NULL) {
5666 local_dh_4096 = ssl_get_dh_4096();
5667 }
Remi Gacogne8de54152014-07-15 11:36:40 +02005668 }
5669 }
5670 }
5671#endif /* OPENSSL_NO_DH */
Remi Gacognef46cd6e2014-06-12 14:58:40 +02005672
Emeric Brunfc0421f2012-09-07 17:30:07 +02005673 SSL_CTX_set_info_callback(ctx, ssl_sock_infocbk);
Willy Tarreau9a1ab082019-05-09 13:26:41 +02005674#if HA_OPENSSL_VERSION_NUMBER >= 0x00907000L
Emeric Brun29f037d2014-04-25 19:05:36 +02005675 SSL_CTX_set_msg_callback(ctx, ssl_sock_msgcbk);
Willy Tarreau5cbe4ef2014-05-08 22:45:11 +02005676#endif
Emeric Brun29f037d2014-04-25 19:05:36 +02005677
Bernard Spil13c53f82018-02-15 13:34:58 +01005678#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005679 ssl_conf_cur = NULL;
5680 if (ssl_conf && ssl_conf->npn_str)
5681 ssl_conf_cur = ssl_conf;
5682 else if (bind_conf->ssl_conf.npn_str)
5683 ssl_conf_cur = &bind_conf->ssl_conf;
5684 if (ssl_conf_cur)
5685 SSL_CTX_set_next_protos_advertised_cb(ctx, ssl_sock_advertise_npn_protos, ssl_conf_cur);
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02005686#endif
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01005687#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005688 ssl_conf_cur = NULL;
5689 if (ssl_conf && ssl_conf->alpn_str)
5690 ssl_conf_cur = ssl_conf;
5691 else if (bind_conf->ssl_conf.alpn_str)
5692 ssl_conf_cur = &bind_conf->ssl_conf;
5693 if (ssl_conf_cur)
5694 SSL_CTX_set_alpn_select_cb(ctx, ssl_sock_advertise_alpn_protos, ssl_conf_cur);
Willy Tarreauab861d32013-04-02 02:30:41 +02005695#endif
Lukas Tribusd14b49c2019-11-24 18:20:40 +01005696#if ((HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL) || defined(LIBRESSL_VERSION_NUMBER))
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01005697 conf_curves = (ssl_conf && ssl_conf->curves) ? ssl_conf->curves : bind_conf->ssl_conf.curves;
5698 if (conf_curves) {
5699 if (!SSL_CTX_set1_curves_list(ctx, conf_curves)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005700 memprintf(err, "%sProxy '%s': unable to set SSL curves list to '%s' for bind '%s' at [%s:%d].\n",
5701 err && *err ? *err : "", curproxy->id, conf_curves, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005702 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01005703 }
Emmanuel Hocdeta52bb152017-03-20 11:11:49 +01005704 (void)SSL_CTX_set_ecdh_auto(ctx, 1);
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01005705 }
5706#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02005707#if defined(SSL_CTX_set_tmp_ecdh) && !defined(OPENSSL_NO_ECDH)
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01005708 if (!conf_curves) {
Emeric Brun2b58d042012-09-20 17:10:03 +02005709 int i;
5710 EC_KEY *ecdh;
Willy Tarreau9a1ab082019-05-09 13:26:41 +02005711#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005712 const char *ecdhe = (ssl_conf && ssl_conf->ecdhe) ? ssl_conf->ecdhe :
Olivier Houchardc2aae742017-09-22 18:26:28 +02005713 (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe :
5714 NULL);
5715
5716 if (ecdhe == NULL) {
Eric Salama3c8bde82019-11-20 11:33:40 +01005717 (void)SSL_CTX_set_ecdh_auto(ctx, 1);
Olivier Houchardc2aae742017-09-22 18:26:28 +02005718 return cfgerr;
5719 }
5720#else
5721 const char *ecdhe = (ssl_conf && ssl_conf->ecdhe) ? ssl_conf->ecdhe :
5722 (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe :
5723 ECDHE_DEFAULT_CURVE);
5724#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02005725
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005726 i = OBJ_sn2nid(ecdhe);
Emeric Brun2b58d042012-09-20 17:10:03 +02005727 if (!i || ((ecdh = EC_KEY_new_by_curve_name(i)) == NULL)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01005728 memprintf(err, "%sProxy '%s': unable to set elliptic named curve to '%s' for bind '%s' at [%s:%d].\n",
5729 err && *err ? *err : "", curproxy->id, ecdhe, bind_conf->arg, bind_conf->file, bind_conf->line);
William Lallemand8b453912019-11-21 15:48:10 +01005730 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brun2b58d042012-09-20 17:10:03 +02005731 }
5732 else {
5733 SSL_CTX_set_tmp_ecdh(ctx, ecdh);
5734 EC_KEY_free(ecdh);
5735 }
5736 }
5737#endif
5738
Emeric Brunfc0421f2012-09-07 17:30:07 +02005739 return cfgerr;
5740}
5741
Evan Broderbe554312013-06-27 00:05:25 -07005742static int ssl_sock_srv_hostcheck(const char *pattern, const char *hostname)
5743{
5744 const char *pattern_wildcard, *pattern_left_label_end, *hostname_left_label_end;
5745 size_t prefixlen, suffixlen;
5746
5747 /* Trivial case */
5748 if (strcmp(pattern, hostname) == 0)
5749 return 1;
5750
Evan Broderbe554312013-06-27 00:05:25 -07005751 /* The rest of this logic is based on RFC 6125, section 6.4.3
5752 * (http://tools.ietf.org/html/rfc6125#section-6.4.3) */
5753
Emeric Bruna848dae2013-10-08 11:27:28 +02005754 pattern_wildcard = NULL;
5755 pattern_left_label_end = pattern;
5756 while (*pattern_left_label_end != '.') {
5757 switch (*pattern_left_label_end) {
5758 case 0:
5759 /* End of label not found */
5760 return 0;
5761 case '*':
5762 /* If there is more than one wildcards */
5763 if (pattern_wildcard)
5764 return 0;
5765 pattern_wildcard = pattern_left_label_end;
5766 break;
5767 }
5768 pattern_left_label_end++;
5769 }
5770
5771 /* If it's not trivial and there is no wildcard, it can't
5772 * match */
5773 if (!pattern_wildcard)
Evan Broderbe554312013-06-27 00:05:25 -07005774 return 0;
5775
5776 /* Make sure all labels match except the leftmost */
5777 hostname_left_label_end = strchr(hostname, '.');
5778 if (!hostname_left_label_end
5779 || strcmp(pattern_left_label_end, hostname_left_label_end) != 0)
5780 return 0;
5781
5782 /* Make sure the leftmost label of the hostname is long enough
5783 * that the wildcard can match */
Emeric Brun369da852013-10-08 11:39:35 +02005784 if (hostname_left_label_end - hostname < (pattern_left_label_end - pattern) - 1)
Evan Broderbe554312013-06-27 00:05:25 -07005785 return 0;
5786
5787 /* Finally compare the string on either side of the
5788 * wildcard */
5789 prefixlen = pattern_wildcard - pattern;
5790 suffixlen = pattern_left_label_end - (pattern_wildcard + 1);
Emeric Bruna848dae2013-10-08 11:27:28 +02005791 if ((prefixlen && (memcmp(pattern, hostname, prefixlen) != 0))
5792 || (suffixlen && (memcmp(pattern_wildcard + 1, hostname_left_label_end - suffixlen, suffixlen) != 0)))
Evan Broderbe554312013-06-27 00:05:25 -07005793 return 0;
5794
5795 return 1;
5796}
5797
5798static int ssl_sock_srv_verifycbk(int ok, X509_STORE_CTX *ctx)
5799{
5800 SSL *ssl;
5801 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005802 struct ssl_sock_ctx *ssl_ctx;
Willy Tarreau2ab88672017-07-05 18:23:03 +02005803 const char *servername;
Willy Tarreau71d058c2017-07-26 20:09:56 +02005804 const char *sni;
Evan Broderbe554312013-06-27 00:05:25 -07005805
5806 int depth;
5807 X509 *cert;
5808 STACK_OF(GENERAL_NAME) *alt_names;
5809 int i;
5810 X509_NAME *cert_subject;
5811 char *str;
5812
5813 if (ok == 0)
5814 return ok;
5815
5816 ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
Thierry FOURNIER28962c92018-06-17 21:37:05 +02005817 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houchard66ab4982019-02-26 18:37:15 +01005818 ssl_ctx = conn->xprt_ctx;
Evan Broderbe554312013-06-27 00:05:25 -07005819
Willy Tarreauad92a9a2017-07-28 11:38:41 +02005820 /* We're checking if the provided hostnames match the desired one. The
5821 * desired hostname comes from the SNI we presented if any, or if not
5822 * provided then it may have been explicitly stated using a "verifyhost"
5823 * directive. If neither is set, we don't care about the name so the
5824 * verification is OK.
Willy Tarreau2ab88672017-07-05 18:23:03 +02005825 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005826 servername = SSL_get_servername(ssl_ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau71d058c2017-07-26 20:09:56 +02005827 sni = servername;
Willy Tarreau2ab88672017-07-05 18:23:03 +02005828 if (!servername) {
Willy Tarreau07d94e42018-09-20 10:57:52 +02005829 servername = __objt_server(conn->target)->ssl_ctx.verify_host;
Willy Tarreau2ab88672017-07-05 18:23:03 +02005830 if (!servername)
5831 return ok;
5832 }
Evan Broderbe554312013-06-27 00:05:25 -07005833
5834 /* We only need to verify the CN on the actual server cert,
5835 * not the indirect CAs */
5836 depth = X509_STORE_CTX_get_error_depth(ctx);
5837 if (depth != 0)
5838 return ok;
5839
5840 /* At this point, the cert is *not* OK unless we can find a
5841 * hostname match */
5842 ok = 0;
5843
5844 cert = X509_STORE_CTX_get_current_cert(ctx);
5845 /* It seems like this might happen if verify peer isn't set */
5846 if (!cert)
5847 return ok;
5848
5849 alt_names = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
5850 if (alt_names) {
5851 for (i = 0; !ok && i < sk_GENERAL_NAME_num(alt_names); i++) {
5852 GENERAL_NAME *name = sk_GENERAL_NAME_value(alt_names, i);
5853 if (name->type == GEN_DNS) {
Willy Tarreau9a1ab082019-05-09 13:26:41 +02005854#if HA_OPENSSL_VERSION_NUMBER < 0x00907000L
Emeric Bruna33410c2013-09-17 15:47:48 +02005855 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.ia5) >= 0) {
5856#else
Evan Broderbe554312013-06-27 00:05:25 -07005857 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
Emeric Bruna33410c2013-09-17 15:47:48 +02005858#endif
Evan Broderbe554312013-06-27 00:05:25 -07005859 ok = ssl_sock_srv_hostcheck(str, servername);
5860 OPENSSL_free(str);
5861 }
5862 }
5863 }
Emeric Brun4ad50a42013-09-17 15:19:54 +02005864 sk_GENERAL_NAME_pop_free(alt_names, GENERAL_NAME_free);
Evan Broderbe554312013-06-27 00:05:25 -07005865 }
5866
5867 cert_subject = X509_get_subject_name(cert);
5868 i = -1;
5869 while (!ok && (i = X509_NAME_get_index_by_NID(cert_subject, NID_commonName, i)) != -1) {
5870 X509_NAME_ENTRY *entry = X509_NAME_get_entry(cert_subject, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005871 ASN1_STRING *value;
5872 value = X509_NAME_ENTRY_get_data(entry);
5873 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
Evan Broderbe554312013-06-27 00:05:25 -07005874 ok = ssl_sock_srv_hostcheck(str, servername);
5875 OPENSSL_free(str);
5876 }
5877 }
5878
Willy Tarreau71d058c2017-07-26 20:09:56 +02005879 /* report the mismatch and indicate if SNI was used or not */
5880 if (!ok && !conn->err_code)
5881 conn->err_code = sni ? CO_ER_SSL_MISMATCH_SNI : CO_ER_SSL_MISMATCH;
Evan Broderbe554312013-06-27 00:05:25 -07005882 return ok;
5883}
5884
Emeric Brun94324a42012-10-11 14:00:19 +02005885/* prepare ssl context from servers options. Returns an error count */
Willy Tarreau03209342016-12-22 17:08:28 +01005886int ssl_sock_prepare_srv_ctx(struct server *srv)
Emeric Brun94324a42012-10-11 14:00:19 +02005887{
Willy Tarreau03209342016-12-22 17:08:28 +01005888 struct proxy *curproxy = srv->proxy;
Emeric Brun94324a42012-10-11 14:00:19 +02005889 int cfgerr = 0;
Remi Gacogneaf5c3da2014-05-19 10:29:58 +02005890 long options =
Emeric Brun94324a42012-10-11 14:00:19 +02005891 SSL_OP_ALL | /* all known workarounds for bugs */
5892 SSL_OP_NO_SSLv2 |
5893 SSL_OP_NO_COMPRESSION;
Remi Gacogneaf5c3da2014-05-19 10:29:58 +02005894 long mode =
Emeric Brun94324a42012-10-11 14:00:19 +02005895 SSL_MODE_ENABLE_PARTIAL_WRITE |
5896 SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
Willy Tarreau396a1862014-11-13 14:06:52 +01005897 SSL_MODE_RELEASE_BUFFERS |
5898 SSL_MODE_SMALL_BUFFERS;
Emeric Brun850efd52014-01-29 12:24:34 +01005899 int verify = SSL_VERIFY_NONE;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005900 SSL_CTX *ctx = NULL;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005901 struct tls_version_filter *conf_ssl_methods = &srv->ssl_ctx.methods;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005902 int i, min, max, hole;
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005903 int flags = MC_SSL_O_ALL;
Emeric Brun94324a42012-10-11 14:00:19 +02005904
Thierry Fournier383085f2013-01-24 14:15:43 +01005905 /* Make sure openssl opens /dev/urandom before the chroot */
5906 if (!ssl_initialize_random()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005907 ha_alert("OpenSSL random data generator initialization failed.\n");
Thierry Fournier383085f2013-01-24 14:15:43 +01005908 cfgerr++;
5909 }
5910
Willy Tarreaufce03112015-01-15 21:32:40 +01005911 /* Automatic memory computations need to know we use SSL there */
5912 global.ssl_used_backend = 1;
5913
5914 /* Initiate SSL context for current server */
Emeric Brun821bb9b2017-06-15 16:37:39 +02005915 if (!srv->ssl_ctx.reused_sess) {
Olivier Houcharde6060c52017-11-16 17:42:52 +01005916 if ((srv->ssl_ctx.reused_sess = calloc(1, global.nbthread*sizeof(*srv->ssl_ctx.reused_sess))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005917 ha_alert("Proxy '%s', server '%s' [%s:%d] out of memory.\n",
5918 curproxy->id, srv->id,
5919 srv->conf.file, srv->conf.line);
Emeric Brun821bb9b2017-06-15 16:37:39 +02005920 cfgerr++;
5921 return cfgerr;
5922 }
5923 }
Emeric Brun94324a42012-10-11 14:00:19 +02005924 if (srv->use_ssl)
5925 srv->xprt = &ssl_sock;
5926 if (srv->check.use_ssl)
Cyril Bonté9ce13112014-11-15 22:41:27 +01005927 srv->check.xprt = &ssl_sock;
Emeric Brun94324a42012-10-11 14:00:19 +02005928
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005929 ctx = SSL_CTX_new(SSLv23_client_method());
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005930 if (!ctx) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005931 ha_alert("config : %s '%s', server '%s': unable to allocate ssl context.\n",
5932 proxy_type_str(curproxy), curproxy->id,
5933 srv->id);
Emeric Brun94324a42012-10-11 14:00:19 +02005934 cfgerr++;
5935 return cfgerr;
5936 }
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005937
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005938 if (conf_ssl_methods->flags && (conf_ssl_methods->min || conf_ssl_methods->max))
Christopher Faulet767a84b2017-11-24 16:50:31 +01005939 ha_warning("config : %s '%s': no-sslv3/no-tlsv1x are ignored for server '%s'. "
5940 "Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
5941 proxy_type_str(curproxy), curproxy->id, srv->id);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005942 else
5943 flags = conf_ssl_methods->flags;
5944
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005945 /* Real min and max should be determinate with configuration and openssl's capabilities */
5946 if (conf_ssl_methods->min)
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005947 flags |= (methodVersions[conf_ssl_methods->min].flag - 1);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005948 if (conf_ssl_methods->max)
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005949 flags |= ~((methodVersions[conf_ssl_methods->max].flag << 1) - 1);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005950
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005951 /* find min, max and holes */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005952 min = max = CONF_TLSV_NONE;
5953 hole = 0;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005954 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005955 /* version is in openssl && version not disable in configuration */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005956 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005957 if (min) {
5958 if (hole) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005959 ha_warning("config : %s '%s': SSL/TLS versions range not contiguous for server '%s'. "
5960 "Hole find for %s. Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
5961 proxy_type_str(curproxy), curproxy->id, srv->id,
5962 methodVersions[hole].name);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005963 hole = 0;
5964 }
5965 max = i;
5966 }
5967 else {
5968 min = max = i;
5969 }
5970 }
5971 else {
5972 if (min)
5973 hole = i;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005974 }
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005975 if (!min) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005976 ha_alert("config : %s '%s': all SSL/TLS versions are disabled for server '%s'.\n",
5977 proxy_type_str(curproxy), curproxy->id, srv->id);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005978 cfgerr += 1;
5979 }
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005980
Willy Tarreau9a1ab082019-05-09 13:26:41 +02005981#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005982 /* Keep force-xxx implementation as it is in older haproxy. It's a
Joseph Herlant017b3da2018-11-15 09:07:59 -08005983 precautionary measure to avoid any surprise with older openssl version. */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005984 if (min == max)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005985 methodVersions[min].ctx_set_version(ctx, SET_CLIENT);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02005986 else
5987 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
5988 if (flags & methodVersions[i].flag)
5989 options |= methodVersions[i].option;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005990#else /* openssl >= 1.1.0 */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02005991 /* set the max_version is required to cap TLS version or activate new TLS (v1.3) */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02005992 methodVersions[min].ctx_set_version(ctx, SET_MIN);
5993 methodVersions[max].ctx_set_version(ctx, SET_MAX);
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02005994#endif
5995
5996 if (srv->ssl_ctx.options & SRV_SSL_O_NO_TLS_TICKETS)
5997 options |= SSL_OP_NO_TICKET;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01005998 SSL_CTX_set_options(ctx, options);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005999
Willy Tarreau5db847a2019-05-09 14:13:35 +02006000#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006001 if (global_ssl.async)
6002 mode |= SSL_MODE_ASYNC;
6003#endif
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01006004 SSL_CTX_set_mode(ctx, mode);
6005 srv->ssl_ctx.ctx = ctx;
6006
Emeric Bruna7aa3092012-10-26 12:58:00 +02006007 if (srv->ssl_ctx.client_crt) {
6008 if (SSL_CTX_use_PrivateKey_file(srv->ssl_ctx.ctx, srv->ssl_ctx.client_crt, SSL_FILETYPE_PEM) <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006009 ha_alert("config : %s '%s', server '%s': unable to load SSL private key from PEM file '%s'.\n",
6010 proxy_type_str(curproxy), curproxy->id,
6011 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02006012 cfgerr++;
6013 }
6014 else if (SSL_CTX_use_certificate_chain_file(srv->ssl_ctx.ctx, srv->ssl_ctx.client_crt) <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006015 ha_alert("config : %s '%s', server '%s': unable to load ssl certificate from PEM file '%s'.\n",
6016 proxy_type_str(curproxy), curproxy->id,
6017 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02006018 cfgerr++;
6019 }
6020 else if (SSL_CTX_check_private_key(srv->ssl_ctx.ctx) <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006021 ha_alert("config : %s '%s', server '%s': inconsistencies between private key and certificate loaded from PEM file '%s'.\n",
6022 proxy_type_str(curproxy), curproxy->id,
6023 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02006024 cfgerr++;
6025 }
6026 }
Emeric Brun94324a42012-10-11 14:00:19 +02006027
Emeric Brun850efd52014-01-29 12:24:34 +01006028 if (global.ssl_server_verify == SSL_SERVER_VERIFY_REQUIRED)
6029 verify = SSL_VERIFY_PEER;
Emeric Brun850efd52014-01-29 12:24:34 +01006030 switch (srv->ssl_ctx.verify) {
6031 case SSL_SOCK_VERIFY_NONE:
6032 verify = SSL_VERIFY_NONE;
6033 break;
6034 case SSL_SOCK_VERIFY_REQUIRED:
6035 verify = SSL_VERIFY_PEER;
6036 break;
6037 }
Evan Broderbe554312013-06-27 00:05:25 -07006038 SSL_CTX_set_verify(srv->ssl_ctx.ctx,
Emeric Brun850efd52014-01-29 12:24:34 +01006039 verify,
Willy Tarreau2ab88672017-07-05 18:23:03 +02006040 (srv->ssl_ctx.verify_host || (verify & SSL_VERIFY_PEER)) ? ssl_sock_srv_verifycbk : NULL);
Emeric Brun850efd52014-01-29 12:24:34 +01006041 if (verify & SSL_VERIFY_PEER) {
Emeric Brunef42d922012-10-11 16:11:36 +02006042 if (srv->ssl_ctx.ca_file) {
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +02006043 /* set CAfile to verify */
6044 if (!ssl_set_verify_locations_file(srv->ssl_ctx.ctx, srv->ssl_ctx.ca_file)) {
6045 ha_alert("Proxy '%s', server '%s' [%s:%d] unable to set CA file '%s'.\n",
Christopher Faulet767a84b2017-11-24 16:50:31 +01006046 curproxy->id, srv->id,
6047 srv->conf.file, srv->conf.line, srv->ssl_ctx.ca_file);
Emeric Brunef42d922012-10-11 16:11:36 +02006048 cfgerr++;
6049 }
6050 }
Emeric Brun850efd52014-01-29 12:24:34 +01006051 else {
6052 if (global.ssl_server_verify == SSL_SERVER_VERIFY_REQUIRED)
Christopher Faulet767a84b2017-11-24 16:50:31 +01006053 ha_alert("Proxy '%s', server '%s' [%s:%d] verify is enabled by default but no CA file specified. If you're running on a LAN where you're certain to trust the server's certificate, please set an explicit 'verify none' statement on the 'server' line, or use 'ssl-server-verify none' in the global section to disable server-side verifications by default.\n",
6054 curproxy->id, srv->id,
6055 srv->conf.file, srv->conf.line);
Emeric Brun850efd52014-01-29 12:24:34 +01006056 else
Christopher Faulet767a84b2017-11-24 16:50:31 +01006057 ha_alert("Proxy '%s', server '%s' [%s:%d] verify is enabled but no CA file specified.\n",
6058 curproxy->id, srv->id,
6059 srv->conf.file, srv->conf.line);
Emeric Brun850efd52014-01-29 12:24:34 +01006060 cfgerr++;
6061 }
Emeric Brunef42d922012-10-11 16:11:36 +02006062#ifdef X509_V_FLAG_CRL_CHECK
6063 if (srv->ssl_ctx.crl_file) {
6064 X509_STORE *store = SSL_CTX_get_cert_store(srv->ssl_ctx.ctx);
6065
Emmanuel Hocdetb270e812019-11-21 19:09:31 +01006066 if (!ssl_set_cert_crl_file(store, srv->ssl_ctx.crl_file)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006067 ha_alert("Proxy '%s', server '%s' [%s:%d] unable to configure CRL file '%s'.\n",
6068 curproxy->id, srv->id,
6069 srv->conf.file, srv->conf.line, srv->ssl_ctx.crl_file);
Emeric Brunef42d922012-10-11 16:11:36 +02006070 cfgerr++;
6071 }
6072 else {
6073 X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
6074 }
6075 }
6076#endif
6077 }
6078
Olivier Houchardbd84ac82017-11-03 13:43:35 +01006079 SSL_CTX_set_session_cache_mode(srv->ssl_ctx.ctx, SSL_SESS_CACHE_CLIENT |
6080 SSL_SESS_CACHE_NO_INTERNAL_STORE);
6081 SSL_CTX_sess_set_new_cb(srv->ssl_ctx.ctx, ssl_sess_new_srv_cb);
Emeric Brun94324a42012-10-11 14:00:19 +02006082 if (srv->ssl_ctx.ciphers &&
6083 !SSL_CTX_set_cipher_list(srv->ssl_ctx.ctx, srv->ssl_ctx.ciphers)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006084 ha_alert("Proxy '%s', server '%s' [%s:%d] : unable to set SSL cipher list to '%s'.\n",
6085 curproxy->id, srv->id,
6086 srv->conf.file, srv->conf.line, srv->ssl_ctx.ciphers);
Emeric Brun94324a42012-10-11 14:00:19 +02006087 cfgerr++;
6088 }
Dirkjan Bussink415150f2018-09-14 11:14:21 +02006089
Emmanuel Hocdet839af572019-05-14 16:27:35 +02006090#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02006091 if (srv->ssl_ctx.ciphersuites &&
Pierre Cheynierbc34cd12019-03-21 16:15:47 +00006092 !SSL_CTX_set_ciphersuites(srv->ssl_ctx.ctx, srv->ssl_ctx.ciphersuites)) {
Dirkjan Bussink415150f2018-09-14 11:14:21 +02006093 ha_alert("Proxy '%s', server '%s' [%s:%d] : unable to set TLS 1.3 cipher suites to '%s'.\n",
6094 curproxy->id, srv->id,
6095 srv->conf.file, srv->conf.line, srv->ssl_ctx.ciphersuites);
6096 cfgerr++;
6097 }
6098#endif
Olivier Houchardc7566002018-11-20 23:33:50 +01006099#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
6100 if (srv->ssl_ctx.npn_str)
6101 SSL_CTX_set_next_proto_select_cb(ctx, ssl_sock_srv_select_protos, srv);
6102#endif
6103#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
6104 if (srv->ssl_ctx.alpn_str)
6105 SSL_CTX_set_alpn_protos(ctx, (unsigned char *)srv->ssl_ctx.alpn_str, srv->ssl_ctx.alpn_len);
6106#endif
6107
Emeric Brun94324a42012-10-11 14:00:19 +02006108
6109 return cfgerr;
6110}
6111
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006112/* Walks down the two trees in bind_conf and prepares all certs. The pointer may
Emeric Brunfc0421f2012-09-07 17:30:07 +02006113 * be NULL, in which case nothing is done. Returns the number of errors
6114 * encountered.
6115 */
Willy Tarreau03209342016-12-22 17:08:28 +01006116int ssl_sock_prepare_all_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02006117{
6118 struct ebmb_node *node;
6119 struct sni_ctx *sni;
6120 int err = 0;
William Lallemand8b453912019-11-21 15:48:10 +01006121 int errcode = 0;
6122 char *errmsg = NULL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02006123
Willy Tarreaufce03112015-01-15 21:32:40 +01006124 /* Automatic memory computations need to know we use SSL there */
6125 global.ssl_used_frontend = 1;
6126
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01006127 /* Make sure openssl opens /dev/urandom before the chroot */
6128 if (!ssl_initialize_random()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006129 ha_alert("OpenSSL random data generator initialization failed.\n");
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01006130 err++;
6131 }
6132 /* Create initial_ctx used to start the ssl connection before do switchctx */
6133 if (!bind_conf->initial_ctx) {
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02006134 err += ssl_sock_initial_ctx(bind_conf);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01006135 /* It should not be necessary to call this function, but it's
6136 necessary first to check and move all initialisation related
6137 to initial_ctx in ssl_sock_initial_ctx. */
William Lallemand8b453912019-11-21 15:48:10 +01006138 errcode |= ssl_sock_prepare_ctx(bind_conf, NULL, bind_conf->initial_ctx, &errmsg);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01006139 }
Emeric Brun0bed9942014-10-30 19:25:24 +01006140 if (bind_conf->default_ctx)
William Lallemand8b453912019-11-21 15:48:10 +01006141 errcode |= ssl_sock_prepare_ctx(bind_conf, bind_conf->default_ssl_conf, bind_conf->default_ctx, &errmsg);
Emeric Brun0bed9942014-10-30 19:25:24 +01006142
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006143 node = ebmb_first(&bind_conf->sni_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006144 while (node) {
6145 sni = ebmb_entry(node, struct sni_ctx, name);
Emeric Brun0bed9942014-10-30 19:25:24 +01006146 if (!sni->order && sni->ctx != bind_conf->default_ctx)
6147 /* only initialize the CTX on its first occurrence and
6148 if it is not the default_ctx */
William Lallemand8b453912019-11-21 15:48:10 +01006149 errcode |= ssl_sock_prepare_ctx(bind_conf, sni->conf, sni->ctx, &errmsg);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006150 node = ebmb_next(node);
6151 }
6152
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006153 node = ebmb_first(&bind_conf->sni_w_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006154 while (node) {
6155 sni = ebmb_entry(node, struct sni_ctx, name);
William Lallemand8b453912019-11-21 15:48:10 +01006156 if (!sni->order && sni->ctx != bind_conf->default_ctx) {
Emeric Brun0bed9942014-10-30 19:25:24 +01006157 /* only initialize the CTX on its first occurrence and
6158 if it is not the default_ctx */
William Lallemand8b453912019-11-21 15:48:10 +01006159 errcode |= ssl_sock_prepare_ctx(bind_conf, sni->conf, sni->ctx, &errmsg);
6160 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02006161 node = ebmb_next(node);
6162 }
William Lallemand8b453912019-11-21 15:48:10 +01006163
6164 if (errcode & ERR_WARN) {
Tim Duesterhusc0e820c2019-11-23 23:52:30 +01006165 ha_warning("%s", errmsg);
William Lallemand8b453912019-11-21 15:48:10 +01006166 } else if (errcode & ERR_CODE) {
Tim Duesterhusc0e820c2019-11-23 23:52:30 +01006167 ha_alert("%s", errmsg);
William Lallemand8b453912019-11-21 15:48:10 +01006168 err++;
6169 }
6170
6171 free(errmsg);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006172 return err;
6173}
6174
Willy Tarreau55d37912016-12-21 23:38:39 +01006175/* Prepares all the contexts for a bind_conf and allocates the shared SSL
6176 * context if needed. Returns < 0 on error, 0 on success. The warnings and
6177 * alerts are directly emitted since the rest of the stack does it below.
6178 */
6179int ssl_sock_prepare_bind_conf(struct bind_conf *bind_conf)
6180{
6181 struct proxy *px = bind_conf->frontend;
6182 int alloc_ctx;
6183 int err;
6184
6185 if (!bind_conf->is_ssl) {
6186 if (bind_conf->default_ctx) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006187 ha_warning("Proxy '%s': A certificate was specified but SSL was not enabled on bind '%s' at [%s:%d] (use 'ssl').\n",
6188 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreau55d37912016-12-21 23:38:39 +01006189 }
6190 return 0;
6191 }
6192 if (!bind_conf->default_ctx) {
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02006193 if (bind_conf->strict_sni && !bind_conf->generate_certs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006194 ha_warning("Proxy '%s': no SSL certificate specified for bind '%s' at [%s:%d], ssl connections will fail (use 'crt').\n",
6195 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02006196 }
6197 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006198 ha_alert("Proxy '%s': no SSL certificate specified for bind '%s' at [%s:%d] (use 'crt').\n",
6199 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02006200 return -1;
6201 }
Willy Tarreau55d37912016-12-21 23:38:39 +01006202 }
William Lallemandc61c0b32017-12-04 18:46:39 +01006203 if (!ssl_shctx && global.tune.sslcachesize) {
William Lallemandc3cd35f2017-11-28 11:04:43 +01006204 alloc_ctx = shctx_init(&ssl_shctx, global.tune.sslcachesize,
Frédéric Lécailleb7838af2018-10-22 16:21:39 +02006205 sizeof(struct sh_ssl_sess_hdr) + SHSESS_BLOCK_MIN_SIZE, -1,
William Lallemandc3cd35f2017-11-28 11:04:43 +01006206 sizeof(*sh_ssl_sess_tree),
6207 ((global.nbthread > 1) || (!global_ssl.private_cache && (global.nbproc > 1))) ? 1 : 0);
Frédéric Lécaille4c8aa112018-10-25 20:22:46 +02006208 if (alloc_ctx <= 0) {
William Lallemandc3cd35f2017-11-28 11:04:43 +01006209 if (alloc_ctx == SHCTX_E_INIT_LOCK)
6210 ha_alert("Unable to initialize the lock for the shared SSL session cache. You can retry using the global statement 'tune.ssl.force-private-cache' but it could increase CPU usage due to renegotiations if nbproc > 1.\n");
6211 else
6212 ha_alert("Unable to allocate SSL session cache.\n");
6213 return -1;
6214 }
6215 /* free block callback */
6216 ssl_shctx->free_block = sh_ssl_sess_free_blocks;
6217 /* init the root tree within the extra space */
6218 sh_ssl_sess_tree = (void *)ssl_shctx + sizeof(struct shared_context);
6219 *sh_ssl_sess_tree = EB_ROOT_UNIQUE;
Willy Tarreau55d37912016-12-21 23:38:39 +01006220 }
Willy Tarreau55d37912016-12-21 23:38:39 +01006221 err = 0;
6222 /* initialize all certificate contexts */
6223 err += ssl_sock_prepare_all_ctx(bind_conf);
6224
6225 /* initialize CA variables if the certificates generation is enabled */
6226 err += ssl_sock_load_ca(bind_conf);
6227
6228 return -err;
6229}
Christopher Faulet77fe80c2015-07-29 13:02:40 +02006230
6231/* release ssl context allocated for servers. */
6232void ssl_sock_free_srv_ctx(struct server *srv)
6233{
Olivier Houchardc7566002018-11-20 23:33:50 +01006234#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
6235 if (srv->ssl_ctx.alpn_str)
6236 free(srv->ssl_ctx.alpn_str);
6237#endif
Lukas Tribusda95fd92018-11-25 13:21:27 +01006238#ifdef OPENSSL_NPN_NEGOTIATED
Olivier Houchardc7566002018-11-20 23:33:50 +01006239 if (srv->ssl_ctx.npn_str)
6240 free(srv->ssl_ctx.npn_str);
Lukas Tribus7706b852018-11-26 22:57:17 +01006241#endif
Christopher Faulet77fe80c2015-07-29 13:02:40 +02006242 if (srv->ssl_ctx.ctx)
6243 SSL_CTX_free(srv->ssl_ctx.ctx);
6244}
6245
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006246/* Walks down the two trees in bind_conf and frees all the certs. The pointer may
Emeric Brunfc0421f2012-09-07 17:30:07 +02006247 * be NULL, in which case nothing is done. The default_ctx is nullified too.
6248 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006249void ssl_sock_free_all_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02006250{
6251 struct ebmb_node *node, *back;
6252 struct sni_ctx *sni;
6253
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006254 node = ebmb_first(&bind_conf->sni_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006255 while (node) {
6256 sni = ebmb_entry(node, struct sni_ctx, name);
6257 back = ebmb_next(node);
6258 ebmb_delete(node);
William Lallemand02e19a52020-04-08 16:11:26 +02006259 SSL_CTX_free(sni->ctx);
6260 if (!sni->order) { /* only free the CTX conf on its first occurrence */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01006261 ssl_sock_free_ssl_conf(sni->conf);
6262 free(sni->conf);
6263 sni->conf = NULL;
6264 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02006265 free(sni);
6266 node = back;
6267 }
6268
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006269 node = ebmb_first(&bind_conf->sni_w_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02006270 while (node) {
6271 sni = ebmb_entry(node, struct sni_ctx, name);
6272 back = ebmb_next(node);
6273 ebmb_delete(node);
William Lallemand02e19a52020-04-08 16:11:26 +02006274 SSL_CTX_free(sni->ctx);
6275 if (!sni->order) { /* only free the SSL conf its first occurrence */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01006276 ssl_sock_free_ssl_conf(sni->conf);
6277 free(sni->conf);
6278 sni->conf = NULL;
6279 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02006280 free(sni);
6281 node = back;
6282 }
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01006283 SSL_CTX_free(bind_conf->initial_ctx);
6284 bind_conf->initial_ctx = NULL;
William Lallemand02e19a52020-04-08 16:11:26 +02006285 SSL_CTX_free(bind_conf->default_ctx);
Willy Tarreau2a65ff02012-09-13 17:54:29 +02006286 bind_conf->default_ctx = NULL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01006287 bind_conf->default_ssl_conf = NULL;
Emeric Brune1f38db2012-09-03 20:36:47 +02006288}
6289
Willy Tarreau795cdab2016-12-22 17:30:54 +01006290/* Destroys all the contexts for a bind_conf. This is used during deinit(). */
6291void ssl_sock_destroy_bind_conf(struct bind_conf *bind_conf)
6292{
6293 ssl_sock_free_ca(bind_conf);
6294 ssl_sock_free_all_ctx(bind_conf);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01006295 ssl_sock_free_ssl_conf(&bind_conf->ssl_conf);
Willy Tarreau795cdab2016-12-22 17:30:54 +01006296 free(bind_conf->ca_sign_file);
6297 free(bind_conf->ca_sign_pass);
Willy Tarreau17b4aa12018-07-17 10:05:32 +02006298 if (bind_conf->keys_ref && !--bind_conf->keys_ref->refcount) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01006299 free(bind_conf->keys_ref->filename);
6300 free(bind_conf->keys_ref->tlskeys);
6301 LIST_DEL(&bind_conf->keys_ref->list);
6302 free(bind_conf->keys_ref);
6303 }
6304 bind_conf->keys_ref = NULL;
Willy Tarreau795cdab2016-12-22 17:30:54 +01006305 bind_conf->ca_sign_pass = NULL;
6306 bind_conf->ca_sign_file = NULL;
Willy Tarreau795cdab2016-12-22 17:30:54 +01006307}
6308
Christopher Faulet31af49d2015-06-09 17:29:50 +02006309/* Load CA cert file and private key used to generate certificates */
6310int
Willy Tarreau03209342016-12-22 17:08:28 +01006311ssl_sock_load_ca(struct bind_conf *bind_conf)
Christopher Faulet31af49d2015-06-09 17:29:50 +02006312{
Willy Tarreau03209342016-12-22 17:08:28 +01006313 struct proxy *px = bind_conf->frontend;
Christopher Faulet31af49d2015-06-09 17:29:50 +02006314 FILE *fp;
6315 X509 *cacert = NULL;
6316 EVP_PKEY *capkey = NULL;
6317 int err = 0;
6318
Christopher Fauletf8bb0ce2017-09-15 09:52:49 +02006319 if (!bind_conf->generate_certs)
Christopher Faulet31af49d2015-06-09 17:29:50 +02006320 return err;
6321
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006322#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Emeric Brun821bb9b2017-06-15 16:37:39 +02006323 if (global_ssl.ctx_cache) {
Willy Tarreauef934602016-12-22 23:12:01 +01006324 ssl_ctx_lru_tree = lru64_new(global_ssl.ctx_cache);
Emeric Brun821bb9b2017-06-15 16:37:39 +02006325 }
Christopher Fauletd2cab922015-07-28 16:03:47 +02006326 ssl_ctx_lru_seed = (unsigned int)time(NULL);
Emeric Brun821bb9b2017-06-15 16:37:39 +02006327 ssl_ctx_serial = now_ms;
Willy Tarreaua84c2672015-10-09 12:10:13 +02006328#endif
Christopher Fauletd2cab922015-07-28 16:03:47 +02006329
Christopher Faulet31af49d2015-06-09 17:29:50 +02006330 if (!bind_conf->ca_sign_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006331 ha_alert("Proxy '%s': cannot enable certificate generation, "
6332 "no CA certificate File configured at [%s:%d].\n",
6333 px->id, bind_conf->file, bind_conf->line);
Christopher Faulet31af49d2015-06-09 17:29:50 +02006334 goto load_error;
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006335 }
Christopher Faulet31af49d2015-06-09 17:29:50 +02006336
6337 /* read in the CA certificate */
6338 if (!(fp = fopen(bind_conf->ca_sign_file, "r"))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006339 ha_alert("Proxy '%s': Failed to read CA certificate file '%s' at [%s:%d].\n",
6340 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Faulet31af49d2015-06-09 17:29:50 +02006341 goto load_error;
6342 }
6343 if (!(cacert = PEM_read_X509(fp, NULL, NULL, NULL))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006344 ha_alert("Proxy '%s': Failed to read CA certificate file '%s' at [%s:%d].\n",
6345 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006346 goto read_error;
Christopher Faulet31af49d2015-06-09 17:29:50 +02006347 }
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006348 rewind(fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02006349 if (!(capkey = PEM_read_PrivateKey(fp, NULL, NULL, bind_conf->ca_sign_pass))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01006350 ha_alert("Proxy '%s': Failed to read CA private key file '%s' at [%s:%d].\n",
6351 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006352 goto read_error;
Christopher Faulet31af49d2015-06-09 17:29:50 +02006353 }
Christopher Faulet31af49d2015-06-09 17:29:50 +02006354
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006355 fclose (fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02006356 bind_conf->ca_sign_cert = cacert;
6357 bind_conf->ca_sign_pkey = capkey;
6358 return err;
6359
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006360 read_error:
6361 fclose (fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02006362 if (capkey) EVP_PKEY_free(capkey);
6363 if (cacert) X509_free(cacert);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02006364 load_error:
6365 bind_conf->generate_certs = 0;
6366 err++;
Christopher Faulet31af49d2015-06-09 17:29:50 +02006367 return err;
6368}
6369
6370/* Release CA cert and private key used to generate certificated */
6371void
6372ssl_sock_free_ca(struct bind_conf *bind_conf)
6373{
Christopher Faulet31af49d2015-06-09 17:29:50 +02006374 if (bind_conf->ca_sign_pkey)
6375 EVP_PKEY_free(bind_conf->ca_sign_pkey);
6376 if (bind_conf->ca_sign_cert)
6377 X509_free(bind_conf->ca_sign_cert);
Willy Tarreau94ff03a2016-12-22 17:57:46 +01006378 bind_conf->ca_sign_pkey = NULL;
6379 bind_conf->ca_sign_cert = NULL;
Christopher Faulet31af49d2015-06-09 17:29:50 +02006380}
6381
Emeric Brun46591952012-05-18 15:47:34 +02006382/*
6383 * This function is called if SSL * context is not yet allocated. The function
6384 * is designed to be called before any other data-layer operation and sets the
6385 * handshake flag on the connection. It is safe to call it multiple times.
6386 * It returns 0 on success and -1 in error case.
6387 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006388static int ssl_sock_init(struct connection *conn, void **xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02006389{
Olivier Houchard66ab4982019-02-26 18:37:15 +01006390 struct ssl_sock_ctx *ctx;
Emeric Brun46591952012-05-18 15:47:34 +02006391 /* already initialized */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006392 if (*xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02006393 return 0;
6394
Willy Tarreau3c728722014-01-23 13:50:42 +01006395 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +02006396 return 0;
6397
Olivier Houchard66ab4982019-02-26 18:37:15 +01006398 ctx = pool_alloc(ssl_sock_ctx_pool);
6399 if (!ctx) {
6400 conn->err_code = CO_ER_SSL_NO_MEM;
6401 return -1;
6402 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006403 ctx->wait_event.tasklet = tasklet_new();
6404 if (!ctx->wait_event.tasklet) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02006405 conn->err_code = CO_ER_SSL_NO_MEM;
6406 pool_free(ssl_sock_ctx_pool, ctx);
6407 return -1;
6408 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006409 ctx->wait_event.tasklet->process = ssl_sock_io_cb;
6410 ctx->wait_event.tasklet->context = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006411 ctx->wait_event.events = 0;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006412 ctx->sent_early_data = 0;
Olivier Houchard54907bb2019-12-19 15:02:39 +01006413 ctx->early_buf = BUF_NULL;
Olivier Houcharda8955d52019-04-07 22:00:38 +02006414 ctx->conn = conn;
Willy Tarreau113d52b2020-01-10 09:20:26 +01006415 ctx->subs = NULL;
Emeric Brun5762a0d2019-09-06 15:36:02 +02006416 ctx->xprt_st = 0;
6417 ctx->xprt_ctx = NULL;
Olivier Houcharda8955d52019-04-07 22:00:38 +02006418
6419 /* Only work with sockets for now, this should be adapted when we'll
6420 * add QUIC support.
6421 */
6422 ctx->xprt = xprt_get(XPRT_RAW);
Olivier Houchard19afb272019-05-23 18:24:07 +02006423 if (ctx->xprt->init) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02006424 if (ctx->xprt->init(conn, &ctx->xprt_ctx) != 0)
6425 goto err;
Olivier Houchard19afb272019-05-23 18:24:07 +02006426 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01006427
Willy Tarreau20879a02012-12-03 16:32:10 +01006428 if (global.maxsslconn && sslconns >= global.maxsslconn) {
6429 conn->err_code = CO_ER_SSL_TOO_MANY;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006430 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01006431 }
Willy Tarreau403edff2012-09-06 11:58:37 +02006432
Emeric Brun46591952012-05-18 15:47:34 +02006433 /* If it is in client mode initiate SSL session
6434 in connect state otherwise accept state */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01006435 if (objt_server(conn->target)) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006436 int may_retry = 1;
6437
6438 retry_connect:
Emeric Brun46591952012-05-18 15:47:34 +02006439 /* Alloc a new SSL session ctx */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006440 ctx->ssl = SSL_new(__objt_server(conn->target)->ssl_ctx.ctx);
6441 if (!ctx->ssl) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006442 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006443 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006444 goto retry_connect;
6445 }
Willy Tarreau20879a02012-12-03 16:32:10 +01006446 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006447 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01006448 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02006449 ctx->bio = BIO_new(ha_meth);
6450 if (!ctx->bio) {
Olivier Houchardefe5e8e2020-01-24 15:17:38 +01006451 SSL_free(ctx->ssl);
6452 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006453 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006454 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006455 goto retry_connect;
6456 }
Emeric Brun55476152014-11-12 17:35:37 +01006457 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006458 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01006459 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02006460 BIO_set_data(ctx->bio, ctx);
Olivier Houcharda8955d52019-04-07 22:00:38 +02006461 SSL_set_bio(ctx->ssl, ctx->bio, ctx->bio);
Emeric Brun46591952012-05-18 15:47:34 +02006462
Evan Broderbe554312013-06-27 00:05:25 -07006463 /* set connection pointer */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006464 if (!SSL_set_ex_data(ctx->ssl, ssl_app_data_index, conn)) {
6465 SSL_free(ctx->ssl);
6466 ctx->ssl = NULL;
Emeric Brun55476152014-11-12 17:35:37 +01006467 conn->xprt_ctx = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006468 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006469 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006470 goto retry_connect;
6471 }
Emeric Brun55476152014-11-12 17:35:37 +01006472 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006473 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01006474 }
6475
Olivier Houchard66ab4982019-02-26 18:37:15 +01006476 SSL_set_connect_state(ctx->ssl);
Willy Tarreau07d94e42018-09-20 10:57:52 +02006477 if (__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr) {
6478 const unsigned char *ptr = __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr;
6479 SSL_SESSION *sess = d2i_SSL_SESSION(NULL, &ptr, __objt_server(conn->target)->ssl_ctx.reused_sess[tid].size);
Olivier Houchard66ab4982019-02-26 18:37:15 +01006480 if (sess && !SSL_set_session(ctx->ssl, sess)) {
Olivier Houcharde6060c52017-11-16 17:42:52 +01006481 SSL_SESSION_free(sess);
Willy Tarreau07d94e42018-09-20 10:57:52 +02006482 free(__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr);
6483 __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr = NULL;
Olivier Houcharde6060c52017-11-16 17:42:52 +01006484 } else if (sess) {
6485 SSL_SESSION_free(sess);
Emeric Brun55476152014-11-12 17:35:37 +01006486 }
6487 }
Evan Broderbe554312013-06-27 00:05:25 -07006488
Emeric Brun46591952012-05-18 15:47:34 +02006489 /* leave init state and start handshake */
Willy Tarreau05737472012-09-04 08:03:39 +02006490 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Willy Tarreau403edff2012-09-06 11:58:37 +02006491
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01006492 _HA_ATOMIC_ADD(&sslconns, 1);
6493 _HA_ATOMIC_ADD(&totalsslconns, 1);
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006494 *xprt_ctx = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006495 /* Start the handshake */
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006496 tasklet_wakeup(ctx->wait_event.tasklet);
Emeric Brun46591952012-05-18 15:47:34 +02006497 return 0;
6498 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +01006499 else if (objt_listener(conn->target)) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006500 int may_retry = 1;
6501
6502 retry_accept:
Emeric Brun46591952012-05-18 15:47:34 +02006503 /* Alloc a new SSL session ctx */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006504 ctx->ssl = SSL_new(__objt_listener(conn->target)->bind_conf->initial_ctx);
6505 if (!ctx->ssl) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006506 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006507 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006508 goto retry_accept;
6509 }
Willy Tarreau20879a02012-12-03 16:32:10 +01006510 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006511 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01006512 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02006513 ctx->bio = BIO_new(ha_meth);
6514 if (!ctx->bio) {
Olivier Houchardefe5e8e2020-01-24 15:17:38 +01006515 SSL_free(ctx->ssl);
6516 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006517 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006518 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006519 goto retry_accept;
6520 }
Emeric Brun55476152014-11-12 17:35:37 +01006521 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006522 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01006523 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02006524 BIO_set_data(ctx->bio, ctx);
Olivier Houcharda8955d52019-04-07 22:00:38 +02006525 SSL_set_bio(ctx->ssl, ctx->bio, ctx->bio);
Emeric Brun46591952012-05-18 15:47:34 +02006526
Emeric Brune1f38db2012-09-03 20:36:47 +02006527 /* set connection pointer */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006528 if (!SSL_set_ex_data(ctx->ssl, ssl_app_data_index, conn)) {
6529 SSL_free(ctx->ssl);
6530 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006531 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01006532 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01006533 goto retry_accept;
6534 }
Emeric Brun55476152014-11-12 17:35:37 +01006535 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006536 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01006537 }
6538
Frédéric Lécaille3139c1b2020-01-24 14:56:18 +01006539#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
6540 if (__objt_listener(conn->target)->bind_conf->ssl_conf.early_data) {
6541 b_alloc(&ctx->early_buf);
6542 SSL_set_max_early_data(ctx->ssl,
6543 /* Only allow early data if we managed to allocate
6544 * a buffer.
6545 */
6546 (!b_is_null(&ctx->early_buf)) ?
6547 global.tune.bufsize - global.tune.maxrewrite : 0);
6548 }
6549#endif
6550
Olivier Houchard66ab4982019-02-26 18:37:15 +01006551 SSL_set_accept_state(ctx->ssl);
Emeric Brune1f38db2012-09-03 20:36:47 +02006552
Emeric Brun46591952012-05-18 15:47:34 +02006553 /* leave init state and start handshake */
Willy Tarreau05737472012-09-04 08:03:39 +02006554 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Emmanuel Hocdetf967c312019-08-05 18:04:16 +02006555#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchardc2aae742017-09-22 18:26:28 +02006556 conn->flags |= CO_FL_EARLY_SSL_HS;
6557#endif
Willy Tarreau403edff2012-09-06 11:58:37 +02006558
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01006559 _HA_ATOMIC_ADD(&sslconns, 1);
6560 _HA_ATOMIC_ADD(&totalsslconns, 1);
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006561 *xprt_ctx = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006562 /* Start the handshake */
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006563 tasklet_wakeup(ctx->wait_event.tasklet);
Emeric Brun46591952012-05-18 15:47:34 +02006564 return 0;
6565 }
6566 /* don't know how to handle such a target */
Willy Tarreau20879a02012-12-03 16:32:10 +01006567 conn->err_code = CO_ER_SSL_NO_TARGET;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006568err:
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006569 if (ctx && ctx->wait_event.tasklet)
6570 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01006571 pool_free(ssl_sock_ctx_pool, ctx);
Emeric Brun46591952012-05-18 15:47:34 +02006572 return -1;
6573}
6574
6575
6576/* This is the callback which is used when an SSL handshake is pending. It
6577 * updates the FD status if it wants some polling before being called again.
6578 * It returns 0 if it fails in a fatal way or needs to poll to go further,
6579 * otherwise it returns non-zero and removes itself from the connection's
6580 * flags (the bit is provided in <flag> by the caller).
6581 */
Olivier Houchard000694c2019-05-23 14:45:12 +02006582static int ssl_sock_handshake(struct connection *conn, unsigned int flag)
Emeric Brun46591952012-05-18 15:47:34 +02006583{
Olivier Houchard66ab4982019-02-26 18:37:15 +01006584 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Emeric Brun46591952012-05-18 15:47:34 +02006585 int ret;
6586
Willy Tarreau3c728722014-01-23 13:50:42 +01006587 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +02006588 return 0;
6589
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02006590 if (!conn->xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02006591 goto out_error;
6592
Willy Tarreau5db847a2019-05-09 14:13:35 +02006593#if HA_OPENSSL_VERSION_NUMBER >= 0x10101000L
Olivier Houchardc2aae742017-09-22 18:26:28 +02006594 /*
6595 * Check if we have early data. If we do, we have to read them
6596 * before SSL_do_handshake() is called, And there's no way to
6597 * detect early data, except to try to read them
6598 */
6599 if (conn->flags & CO_FL_EARLY_SSL_HS) {
Olivier Houchard54907bb2019-12-19 15:02:39 +01006600 size_t read_data = 0;
Olivier Houchardc2aae742017-09-22 18:26:28 +02006601
Olivier Houchard54907bb2019-12-19 15:02:39 +01006602 while (1) {
6603 ret = SSL_read_early_data(ctx->ssl,
6604 b_tail(&ctx->early_buf), b_room(&ctx->early_buf),
6605 &read_data);
6606 if (ret == SSL_READ_EARLY_DATA_ERROR)
6607 goto check_error;
6608 if (read_data > 0) {
6609 conn->flags |= CO_FL_EARLY_DATA;
6610 b_add(&ctx->early_buf, read_data);
6611 }
6612 if (ret == SSL_READ_EARLY_DATA_FINISH) {
6613 conn->flags &= ~CO_FL_EARLY_SSL_HS;
6614 if (!b_data(&ctx->early_buf))
6615 b_free(&ctx->early_buf);
6616 break;
6617 }
6618 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02006619 }
6620#endif
Emeric Brun674b7432012-11-08 19:21:55 +01006621 /* If we use SSL_do_handshake to process a reneg initiated by
6622 * the remote peer, it sometimes returns SSL_ERROR_SSL.
6623 * Usually SSL_write and SSL_read are used and process implicitly
6624 * the reneg handshake.
6625 * Here we use SSL_peek as a workaround for reneg.
6626 */
Willy Tarreauc192b0a2020-01-23 09:11:58 +01006627 if (!(conn->flags & CO_FL_WAIT_L6_CONN) && SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun674b7432012-11-08 19:21:55 +01006628 char c;
6629
Olivier Houchard66ab4982019-02-26 18:37:15 +01006630 ret = SSL_peek(ctx->ssl, &c, 1);
Emeric Brun674b7432012-11-08 19:21:55 +01006631 if (ret <= 0) {
6632 /* handshake may have not been completed, let's find why */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006633 ret = SSL_get_error(ctx->ssl, ret);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006634
Emeric Brun674b7432012-11-08 19:21:55 +01006635 if (ret == SSL_ERROR_WANT_WRITE) {
6636 /* SSL handshake needs to write, L4 connection may not be ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02006637 if (!(ctx->wait_event.events & SUB_RETRY_SEND))
Olivier Houchardea8dd942019-05-20 14:02:16 +02006638 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Emeric Brun674b7432012-11-08 19:21:55 +01006639 return 0;
6640 }
6641 else if (ret == SSL_ERROR_WANT_READ) {
6642 /* handshake may have been completed but we have
6643 * no more data to read.
6644 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006645 if (!SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun674b7432012-11-08 19:21:55 +01006646 ret = 1;
6647 goto reneg_ok;
6648 }
6649 /* SSL handshake needs to read, L4 connection is ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02006650 if (!(ctx->wait_event.events & SUB_RETRY_RECV))
Olivier Houchardea8dd942019-05-20 14:02:16 +02006651 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Emeric Brun674b7432012-11-08 19:21:55 +01006652 return 0;
6653 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02006654#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006655 else if (ret == SSL_ERROR_WANT_ASYNC) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02006656 ssl_async_process_fds(ctx);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006657 return 0;
6658 }
6659#endif
Emeric Brun674b7432012-11-08 19:21:55 +01006660 else if (ret == SSL_ERROR_SYSCALL) {
6661 /* if errno is null, then connection was successfully established */
6662 if (!errno && conn->flags & CO_FL_WAIT_L4_CONN)
6663 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau20879a02012-12-03 16:32:10 +01006664 if (!conn->err_code) {
Lukas Tribus49799162019-07-08 14:29:15 +02006665#if defined(OPENSSL_IS_BORINGSSL) || defined(LIBRESSL_VERSION_NUMBER)
6666 /* do not handle empty handshakes in BoringSSL or LibreSSL */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006667 conn->err_code = CO_ER_SSL_HANDSHAKE;
6668#else
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006669 int empty_handshake;
Willy Tarreau5db847a2019-05-09 14:13:35 +02006670#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL)
Lukas Tribus49799162019-07-08 14:29:15 +02006671 /* use SSL_get_state() in OpenSSL >= 1.1.0; SSL_state() is broken */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006672 OSSL_HANDSHAKE_STATE state = SSL_get_state((SSL *)ctx->ssl);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006673 empty_handshake = state == TLS_ST_BEFORE;
6674#else
Lukas Tribus49799162019-07-08 14:29:15 +02006675 /* access packet_length directly in OpenSSL <= 1.0.2; SSL_state() is broken */
6676 empty_handshake = !ctx->ssl->packet_length;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006677#endif
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006678 if (empty_handshake) {
Emeric Brun29f037d2014-04-25 19:05:36 +02006679 if (!errno) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006680 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02006681 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
6682 else
6683 conn->err_code = CO_ER_SSL_EMPTY;
6684 }
6685 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006686 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02006687 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
6688 else
6689 conn->err_code = CO_ER_SSL_ABORT;
6690 }
6691 }
6692 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006693 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02006694 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
Willy Tarreau20879a02012-12-03 16:32:10 +01006695 else
Emeric Brun29f037d2014-04-25 19:05:36 +02006696 conn->err_code = CO_ER_SSL_HANDSHAKE;
6697 }
Lukas Tribus49799162019-07-08 14:29:15 +02006698#endif /* BoringSSL or LibreSSL */
Willy Tarreau20879a02012-12-03 16:32:10 +01006699 }
Emeric Brun674b7432012-11-08 19:21:55 +01006700 goto out_error;
6701 }
6702 else {
6703 /* Fail on all other handshake errors */
6704 /* Note: OpenSSL may leave unread bytes in the socket's
6705 * buffer, causing an RST to be emitted upon close() on
6706 * TCP sockets. We first try to drain possibly pending
6707 * data to avoid this as much as possible.
6708 */
Willy Tarreaud85c4852015-03-13 00:40:28 +01006709 conn_sock_drain(conn);
Willy Tarreau20879a02012-12-03 16:32:10 +01006710 if (!conn->err_code)
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006711 conn->err_code = (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ?
Willy Tarreauf51c6982014-04-25 20:02:39 +02006712 CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE;
Emeric Brun674b7432012-11-08 19:21:55 +01006713 goto out_error;
6714 }
6715 }
6716 /* read some data: consider handshake completed */
6717 goto reneg_ok;
6718 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01006719 ret = SSL_do_handshake(ctx->ssl);
Olivier Houchardc2aae742017-09-22 18:26:28 +02006720check_error:
Emeric Brun46591952012-05-18 15:47:34 +02006721 if (ret != 1) {
6722 /* handshake did not complete, let's find why */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006723 ret = SSL_get_error(ctx->ssl, ret);
Emeric Brun46591952012-05-18 15:47:34 +02006724
6725 if (ret == SSL_ERROR_WANT_WRITE) {
6726 /* SSL handshake needs to write, L4 connection may not be ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02006727 if (!(ctx->wait_event.events & SUB_RETRY_SEND))
Olivier Houchardea8dd942019-05-20 14:02:16 +02006728 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Emeric Brun46591952012-05-18 15:47:34 +02006729 return 0;
6730 }
6731 else if (ret == SSL_ERROR_WANT_READ) {
6732 /* SSL handshake needs to read, L4 connection is ready */
Olivier Houchardea8dd942019-05-20 14:02:16 +02006733 if (!(ctx->wait_event.events & SUB_RETRY_RECV))
Olivier Houchardea8dd942019-05-20 14:02:16 +02006734 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
6735 SUB_RETRY_RECV, &ctx->wait_event);
Emeric Brun46591952012-05-18 15:47:34 +02006736 return 0;
6737 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02006738#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006739 else if (ret == SSL_ERROR_WANT_ASYNC) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02006740 ssl_async_process_fds(ctx);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006741 return 0;
6742 }
6743#endif
Willy Tarreau89230192012-09-28 20:22:13 +02006744 else if (ret == SSL_ERROR_SYSCALL) {
6745 /* if errno is null, then connection was successfully established */
6746 if (!errno && conn->flags & CO_FL_WAIT_L4_CONN)
6747 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006748 if (!conn->err_code) {
Lukas Tribus49799162019-07-08 14:29:15 +02006749#if defined(OPENSSL_IS_BORINGSSL) || defined(LIBRESSL_VERSION_NUMBER)
6750 /* do not handle empty handshakes in BoringSSL or LibreSSL */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006751 conn->err_code = CO_ER_SSL_HANDSHAKE;
6752#else
6753 int empty_handshake;
Willy Tarreau5db847a2019-05-09 14:13:35 +02006754#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL)
Lukas Tribus49799162019-07-08 14:29:15 +02006755 /* use SSL_get_state() in OpenSSL >= 1.1.0; SSL_state() is broken */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006756 OSSL_HANDSHAKE_STATE state = SSL_get_state(ctx->ssl);
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006757 empty_handshake = state == TLS_ST_BEFORE;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006758#else
Lukas Tribus49799162019-07-08 14:29:15 +02006759 /* access packet_length directly in OpenSSL <= 1.0.2; SSL_state() is broken */
6760 empty_handshake = !ctx->ssl->packet_length;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006761#endif
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006762 if (empty_handshake) {
6763 if (!errno) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006764 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006765 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
6766 else
6767 conn->err_code = CO_ER_SSL_EMPTY;
6768 }
6769 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006770 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006771 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
6772 else
6773 conn->err_code = CO_ER_SSL_ABORT;
6774 }
Emeric Brun29f037d2014-04-25 19:05:36 +02006775 }
6776 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006777 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02006778 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
6779 else
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01006780 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emeric Brun29f037d2014-04-25 19:05:36 +02006781 }
Lukas Tribus49799162019-07-08 14:29:15 +02006782#endif /* BoringSSL or LibreSSL */
Emeric Brun29f037d2014-04-25 19:05:36 +02006783 }
Willy Tarreau89230192012-09-28 20:22:13 +02006784 goto out_error;
6785 }
Emeric Brun46591952012-05-18 15:47:34 +02006786 else {
6787 /* Fail on all other handshake errors */
Willy Tarreau566dc552012-10-19 20:52:18 +02006788 /* Note: OpenSSL may leave unread bytes in the socket's
6789 * buffer, causing an RST to be emitted upon close() on
6790 * TCP sockets. We first try to drain possibly pending
6791 * data to avoid this as much as possible.
6792 */
Willy Tarreaud85c4852015-03-13 00:40:28 +01006793 conn_sock_drain(conn);
Willy Tarreau20879a02012-12-03 16:32:10 +01006794 if (!conn->err_code)
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006795 conn->err_code = (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ?
Willy Tarreauf51c6982014-04-25 20:02:39 +02006796 CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE;
Emeric Brun46591952012-05-18 15:47:34 +02006797 goto out_error;
6798 }
6799 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02006800#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchard522eea72017-11-03 16:27:47 +01006801 else {
6802 /*
6803 * If the server refused the early data, we have to send a
6804 * 425 to the client, as we no longer have the data to sent
6805 * them again.
6806 */
6807 if ((conn->flags & CO_FL_EARLY_DATA) && (objt_server(conn->target))) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01006808 if (SSL_get_early_data_status(ctx->ssl) == SSL_EARLY_DATA_REJECTED) {
Olivier Houchard522eea72017-11-03 16:27:47 +01006809 conn->err_code = CO_ER_SSL_EARLY_FAILED;
6810 goto out_error;
6811 }
6812 }
6813 }
6814#endif
6815
Emeric Brun46591952012-05-18 15:47:34 +02006816
Emeric Brun674b7432012-11-08 19:21:55 +01006817reneg_ok:
Emeric Brunb5e42a82017-06-06 12:35:14 +00006818
Willy Tarreau5db847a2019-05-09 14:13:35 +02006819#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00006820 /* ASYNC engine API doesn't support moving read/write
6821 * buffers. So we disable ASYNC mode right after
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05006822 * the handshake to avoid buffer overflow.
Emeric Brunb5e42a82017-06-06 12:35:14 +00006823 */
6824 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006825 SSL_clear_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00006826#endif
Emeric Brun46591952012-05-18 15:47:34 +02006827 /* Handshake succeeded */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006828 if (!SSL_session_reused(ctx->ssl)) {
Willy Tarreau0c9c2722014-05-28 12:28:58 +02006829 if (objt_server(conn->target)) {
6830 update_freq_ctr(&global.ssl_be_keys_per_sec, 1);
6831 if (global.ssl_be_keys_per_sec.curr_ctr > global.ssl_be_keys_max)
6832 global.ssl_be_keys_max = global.ssl_be_keys_per_sec.curr_ctr;
Emeric Brun46591952012-05-18 15:47:34 +02006833 }
Willy Tarreau0c9c2722014-05-28 12:28:58 +02006834 else {
6835 update_freq_ctr(&global.ssl_fe_keys_per_sec, 1);
6836 if (global.ssl_fe_keys_per_sec.curr_ctr > global.ssl_fe_keys_max)
6837 global.ssl_fe_keys_max = global.ssl_fe_keys_per_sec.curr_ctr;
6838 }
Emeric Brun46591952012-05-18 15:47:34 +02006839 }
6840
6841 /* The connection is now established at both layers, it's time to leave */
6842 conn->flags &= ~(flag | CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN);
6843 return 1;
6844
6845 out_error:
Emeric Brun644cde02012-12-14 11:21:13 +01006846 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02006847 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01006848 ERR_clear_error();
6849
Emeric Brun9fa89732012-10-04 17:09:56 +02006850 /* free resumed session if exists */
Willy Tarreau07d94e42018-09-20 10:57:52 +02006851 if (objt_server(conn->target) && __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr) {
6852 free(__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr);
6853 __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr = NULL;
Emeric Brun9fa89732012-10-04 17:09:56 +02006854 }
6855
Emeric Brun46591952012-05-18 15:47:34 +02006856 /* Fail on all other handshake errors */
6857 conn->flags |= CO_FL_ERROR;
Willy Tarreau20879a02012-12-03 16:32:10 +01006858 if (!conn->err_code)
6859 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emeric Brun46591952012-05-18 15:47:34 +02006860 return 0;
6861}
6862
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006863/* Called from the upper layer, to subscribe <es> to events <event_type>. The
6864 * event subscriber <es> is not allowed to change from a previous call as long
6865 * as at least one event is still subscribed. The <event_type> must only be a
6866 * combination of SUB_RETRY_RECV and SUB_RETRY_SEND. It always returns 0,
6867 * unless the transport layer was already released.
6868 */
6869static int ssl_subscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houcharddf357842019-03-21 16:30:07 +01006870{
Olivier Houchardea8dd942019-05-20 14:02:16 +02006871 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006872
Olivier Houchard0ff28652019-06-24 18:57:39 +02006873 if (!ctx)
6874 return -1;
6875
Willy Tarreau113d52b2020-01-10 09:20:26 +01006876 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006877 BUG_ON(ctx->subs && ctx->subs != es);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006878
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006879 ctx->subs = es;
6880 es->events |= event_type;
Willy Tarreau113d52b2020-01-10 09:20:26 +01006881
6882 /* we may have to subscribe to lower layers for new events */
6883 event_type &= ~ctx->wait_event.events;
6884 if (event_type && !(conn->flags & CO_FL_SSL_WAIT_HS))
6885 ctx->xprt->subscribe(conn, ctx->xprt_ctx, event_type, &ctx->wait_event);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006886 return 0;
Olivier Houcharddf357842019-03-21 16:30:07 +01006887}
6888
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006889/* Called from the upper layer, to unsubscribe <es> from events <event_type>.
6890 * The <es> pointer is not allowed to differ from the one passed to the
6891 * subscribe() call. It always returns zero.
6892 */
6893static int ssl_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, struct wait_event *es)
Olivier Houcharddf357842019-03-21 16:30:07 +01006894{
Olivier Houchardea8dd942019-05-20 14:02:16 +02006895 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006896
Willy Tarreau113d52b2020-01-10 09:20:26 +01006897 BUG_ON(event_type & ~(SUB_RETRY_SEND|SUB_RETRY_RECV));
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006898 BUG_ON(ctx->subs && ctx->subs != es);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006899
Willy Tarreauee1a6fc2020-01-17 07:52:13 +01006900 es->events &= ~event_type;
6901 if (!es->events)
Willy Tarreau113d52b2020-01-10 09:20:26 +01006902 ctx->subs = NULL;
6903
6904 /* If we subscribed, and we're not doing the handshake,
6905 * then we subscribed because the upper layer asked for it,
6906 * as the upper layer is no longer interested, we can
6907 * unsubscribe too.
6908 */
6909 event_type &= ctx->wait_event.events;
6910 if (event_type && !(ctx->conn->flags & CO_FL_SSL_WAIT_HS))
6911 conn_unsubscribe(conn, ctx->xprt_ctx, event_type, &ctx->wait_event);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006912
6913 return 0;
Olivier Houcharddf357842019-03-21 16:30:07 +01006914}
6915
Olivier Houchard2e055482019-05-27 19:50:12 +02006916/* Use the provided XPRT as an underlying XPRT, and provide the old one.
6917 * Returns 0 on success, and non-zero on failure.
6918 */
6919static int ssl_add_xprt(struct connection *conn, void *xprt_ctx, void *toadd_ctx, const struct xprt_ops *toadd_ops, void **oldxprt_ctx, const struct xprt_ops **oldxprt_ops)
6920{
6921 struct ssl_sock_ctx *ctx = xprt_ctx;
6922
6923 if (oldxprt_ops != NULL)
6924 *oldxprt_ops = ctx->xprt;
6925 if (oldxprt_ctx != NULL)
6926 *oldxprt_ctx = ctx->xprt_ctx;
6927 ctx->xprt = toadd_ops;
6928 ctx->xprt_ctx = toadd_ctx;
6929 return 0;
6930}
6931
Olivier Houchard5149b592019-05-23 17:47:36 +02006932/* Remove the specified xprt. If if it our underlying XPRT, remove it and
6933 * return 0, otherwise just call the remove_xprt method from the underlying
6934 * XPRT.
6935 */
6936static int ssl_remove_xprt(struct connection *conn, void *xprt_ctx, void *toremove_ctx, const struct xprt_ops *newops, void *newctx)
6937{
6938 struct ssl_sock_ctx *ctx = xprt_ctx;
6939
6940 if (ctx->xprt_ctx == toremove_ctx) {
6941 ctx->xprt_ctx = newctx;
6942 ctx->xprt = newops;
6943 return 0;
6944 }
6945 return (ctx->xprt->remove_xprt(conn, ctx->xprt_ctx, toremove_ctx, newops, newctx));
6946}
6947
Olivier Houchardea8dd942019-05-20 14:02:16 +02006948static struct task *ssl_sock_io_cb(struct task *t, void *context, unsigned short state)
6949{
6950 struct ssl_sock_ctx *ctx = context;
6951
6952 /* First if we're doing an handshake, try that */
6953 if (ctx->conn->flags & CO_FL_SSL_WAIT_HS)
6954 ssl_sock_handshake(ctx->conn, CO_FL_SSL_WAIT_HS);
6955 /* If we had an error, or the handshake is done and I/O is available,
6956 * let the upper layer know.
Olivier Houchard477902b2020-01-22 18:08:48 +01006957 * If no mux was set up yet, then call conn_create_mux()
Olivier Houchardea8dd942019-05-20 14:02:16 +02006958 * we can't be sure conn_fd_handler() will be called again.
6959 */
6960 if ((ctx->conn->flags & CO_FL_ERROR) ||
6961 !(ctx->conn->flags & CO_FL_SSL_WAIT_HS)) {
6962 int ret = 0;
6963 int woke = 0;
6964
6965 /* On error, wake any waiter */
Willy Tarreau113d52b2020-01-10 09:20:26 +01006966 if (ctx->subs) {
6967 tasklet_wakeup(ctx->subs->tasklet);
6968 ctx->subs->events = 0;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006969 woke = 1;
Willy Tarreau113d52b2020-01-10 09:20:26 +01006970 ctx->subs = NULL;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006971 }
Willy Tarreau113d52b2020-01-10 09:20:26 +01006972
Olivier Houchardea8dd942019-05-20 14:02:16 +02006973 /* If we're the first xprt for the connection, let the
Olivier Houchard477902b2020-01-22 18:08:48 +01006974 * upper layers know. If we have no mux, create it,
6975 * and once we have a mux, call its wake method if we didn't
6976 * woke a tasklet already.
Olivier Houchardea8dd942019-05-20 14:02:16 +02006977 */
6978 if (ctx->conn->xprt_ctx == ctx) {
Olivier Houchard477902b2020-01-22 18:08:48 +01006979 if (!ctx->conn->mux)
6980 ret = conn_create_mux(ctx->conn);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006981 if (ret >= 0 && !woke && ctx->conn->mux && ctx->conn->mux->wake)
6982 ctx->conn->mux->wake(ctx->conn);
6983 return NULL;
6984 }
6985 }
Olivier Houchard54907bb2019-12-19 15:02:39 +01006986#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
6987 /* If we have early data and somebody wants to receive, let them */
Willy Tarreau113d52b2020-01-10 09:20:26 +01006988 else if (b_data(&ctx->early_buf) && ctx->subs &&
6989 ctx->subs->events & SUB_RETRY_RECV) {
6990 tasklet_wakeup(ctx->subs->tasklet);
6991 ctx->subs->events &= ~SUB_RETRY_RECV;
6992 if (!ctx->subs->events)
6993 ctx->subs = NULL;
Olivier Houchard54907bb2019-12-19 15:02:39 +01006994 }
6995#endif
Olivier Houchardea8dd942019-05-20 14:02:16 +02006996 return NULL;
6997}
6998
Emeric Brun46591952012-05-18 15:47:34 +02006999/* Receive up to <count> bytes from connection <conn>'s socket and store them
Willy Tarreauabf08d92014-01-14 11:31:27 +01007000 * into buffer <buf>. Only one call to recv() is performed, unless the
Emeric Brun46591952012-05-18 15:47:34 +02007001 * buffer wraps, in which case a second call may be performed. The connection's
7002 * flags are updated with whatever special event is detected (error, read0,
7003 * empty). The caller is responsible for taking care of those events and
7004 * avoiding the call if inappropriate. The function does not call the
7005 * connection's polling update function, so the caller is responsible for this.
7006 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007007static size_t ssl_sock_to_buf(struct connection *conn, void *xprt_ctx, struct buffer *buf, size_t count, int flags)
Emeric Brun46591952012-05-18 15:47:34 +02007008{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007009 struct ssl_sock_ctx *ctx = xprt_ctx;
Willy Tarreaubfc4d772018-07-18 11:22:03 +02007010 ssize_t ret;
7011 size_t try, done = 0;
Emeric Brun46591952012-05-18 15:47:34 +02007012
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007013 if (!ctx)
Emeric Brun46591952012-05-18 15:47:34 +02007014 goto out_error;
7015
Olivier Houchard54907bb2019-12-19 15:02:39 +01007016#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
7017 if (b_data(&ctx->early_buf)) {
7018 try = b_contig_space(buf);
7019 if (try > b_data(&ctx->early_buf))
7020 try = b_data(&ctx->early_buf);
7021 memcpy(b_tail(buf), b_head(&ctx->early_buf), try);
7022 b_add(buf, try);
7023 b_del(&ctx->early_buf, try);
7024 if (b_data(&ctx->early_buf) == 0)
7025 b_free(&ctx->early_buf);
7026 return try;
7027 }
7028#endif
7029
Willy Tarreau911db9b2020-01-23 16:27:54 +01007030 if (conn->flags & (CO_FL_WAIT_XPRT | CO_FL_SSL_WAIT_HS))
Emeric Brun46591952012-05-18 15:47:34 +02007031 /* a handshake was requested */
7032 return 0;
7033
Emeric Brun46591952012-05-18 15:47:34 +02007034 /* read the largest possible block. For this, we perform only one call
7035 * to recv() unless the buffer wraps and we exactly fill the first hunk,
7036 * in which case we accept to do it once again. A new attempt is made on
7037 * EINTR too.
7038 */
Willy Tarreau00b0fb92014-01-17 11:09:40 +01007039 while (count > 0) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02007040
Willy Tarreau591d4452018-06-15 17:21:00 +02007041 try = b_contig_space(buf);
7042 if (!try)
7043 break;
7044
Willy Tarreauabf08d92014-01-14 11:31:27 +01007045 if (try > count)
7046 try = count;
Willy Tarreau591d4452018-06-15 17:21:00 +02007047
Olivier Houchard66ab4982019-02-26 18:37:15 +01007048 ret = SSL_read(ctx->ssl, b_tail(buf), try);
Emmanuel Hocdetf967c312019-08-05 18:04:16 +02007049
Emeric Brune1f38db2012-09-03 20:36:47 +02007050 if (conn->flags & CO_FL_ERROR) {
7051 /* CO_FL_ERROR may be set by ssl_sock_infocbk */
Emeric Brun644cde02012-12-14 11:21:13 +01007052 goto out_error;
Emeric Brune1f38db2012-09-03 20:36:47 +02007053 }
Emeric Brun46591952012-05-18 15:47:34 +02007054 if (ret > 0) {
Olivier Houchardacd14032018-06-28 18:17:23 +02007055 b_add(buf, ret);
Emeric Brun46591952012-05-18 15:47:34 +02007056 done += ret;
Emeric Brun46591952012-05-18 15:47:34 +02007057 count -= ret;
Emeric Brun46591952012-05-18 15:47:34 +02007058 }
Emeric Brun46591952012-05-18 15:47:34 +02007059 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01007060 ret = SSL_get_error(ctx->ssl, ret);
Emeric Brun46591952012-05-18 15:47:34 +02007061 if (ret == SSL_ERROR_WANT_WRITE) {
Emeric Brun8af8dd12012-11-08 17:56:20 +01007062 /* handshake is running, and it needs to enable write */
Emeric Brun46591952012-05-18 15:47:34 +02007063 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02007064 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02007065#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00007066 /* Async mode can be re-enabled, because we're leaving data state.*/
7067 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007068 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00007069#endif
Emeric Brun46591952012-05-18 15:47:34 +02007070 break;
7071 }
7072 else if (ret == SSL_ERROR_WANT_READ) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01007073 if (SSL_renegotiate_pending(ctx->ssl)) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02007074 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
7075 SUB_RETRY_RECV,
7076 &ctx->wait_event);
Emeric Brun282a76a2012-11-08 18:02:56 +01007077 /* handshake is running, and it may need to re-enable read */
7078 conn->flags |= CO_FL_SSL_WAIT_HS;
Willy Tarreau5db847a2019-05-09 14:13:35 +02007079#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00007080 /* Async mode can be re-enabled, because we're leaving data state.*/
7081 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007082 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00007083#endif
Emeric Brun282a76a2012-11-08 18:02:56 +01007084 break;
7085 }
Emeric Brun46591952012-05-18 15:47:34 +02007086 break;
Olivier Houchardc2aae742017-09-22 18:26:28 +02007087 } else if (ret == SSL_ERROR_ZERO_RETURN)
7088 goto read0;
Christopher Faulet4ac77a92018-02-19 14:25:15 +01007089 /* For SSL_ERROR_SYSCALL, make sure to clear the error
7090 * stack before shutting down the connection for
7091 * reading. */
Olivier Houchard7e2e5052018-02-13 15:17:23 +01007092 if (ret == SSL_ERROR_SYSCALL && (!errno || errno == EAGAIN))
7093 goto clear_ssl_error;
Emeric Brun46591952012-05-18 15:47:34 +02007094 /* otherwise it's a real error */
7095 goto out_error;
7096 }
7097 }
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02007098 leave:
Emeric Brun46591952012-05-18 15:47:34 +02007099 return done;
7100
Christopher Faulet4ac77a92018-02-19 14:25:15 +01007101 clear_ssl_error:
7102 /* Clear openssl global errors stack */
7103 ssl_sock_dump_errors(conn);
7104 ERR_clear_error();
Emeric Brun46591952012-05-18 15:47:34 +02007105 read0:
7106 conn_sock_read0(conn);
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02007107 goto leave;
Christopher Faulet4ac77a92018-02-19 14:25:15 +01007108
Emeric Brun46591952012-05-18 15:47:34 +02007109 out_error:
Olivier Houchard7e2e5052018-02-13 15:17:23 +01007110 conn->flags |= CO_FL_ERROR;
Emeric Brun644cde02012-12-14 11:21:13 +01007111 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02007112 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01007113 ERR_clear_error();
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02007114 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +02007115}
7116
7117
Willy Tarreau787db9a2018-06-14 18:31:46 +02007118/* Send up to <count> pending bytes from buffer <buf> to connection <conn>'s
7119 * socket. <flags> may contain some CO_SFL_* flags to hint the system about
7120 * other pending data for example, but this flag is ignored at the moment.
Emeric Brun46591952012-05-18 15:47:34 +02007121 * Only one call to send() is performed, unless the buffer wraps, in which case
7122 * a second call may be performed. The connection's flags are updated with
7123 * whatever special event is detected (error, empty). The caller is responsible
7124 * for taking care of those events and avoiding the call if inappropriate. The
7125 * function does not call the connection's polling update function, so the caller
Willy Tarreau787db9a2018-06-14 18:31:46 +02007126 * is responsible for this. The buffer's output is not adjusted, it's up to the
7127 * caller to take care of this. It's up to the caller to update the buffer's
7128 * contents based on the return value.
Emeric Brun46591952012-05-18 15:47:34 +02007129 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007130static size_t ssl_sock_from_buf(struct connection *conn, void *xprt_ctx, const struct buffer *buf, size_t count, int flags)
Emeric Brun46591952012-05-18 15:47:34 +02007131{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007132 struct ssl_sock_ctx *ctx = xprt_ctx;
Willy Tarreau787db9a2018-06-14 18:31:46 +02007133 ssize_t ret;
7134 size_t try, done;
Emeric Brun46591952012-05-18 15:47:34 +02007135
7136 done = 0;
7137
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007138 if (!ctx)
Emeric Brun46591952012-05-18 15:47:34 +02007139 goto out_error;
7140
Willy Tarreau911db9b2020-01-23 16:27:54 +01007141 if (conn->flags & (CO_FL_WAIT_XPRT | CO_FL_SSL_WAIT_HS | CO_FL_EARLY_SSL_HS))
Emeric Brun46591952012-05-18 15:47:34 +02007142 /* a handshake was requested */
7143 return 0;
7144
7145 /* send the largest possible block. For this we perform only one call
7146 * to send() unless the buffer wraps and we exactly fill the first hunk,
7147 * in which case we accept to do it once again.
7148 */
Willy Tarreau787db9a2018-06-14 18:31:46 +02007149 while (count) {
Willy Tarreau5db847a2019-05-09 14:13:35 +02007150#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchardc2aae742017-09-22 18:26:28 +02007151 size_t written_data;
7152#endif
7153
Willy Tarreau787db9a2018-06-14 18:31:46 +02007154 try = b_contig_data(buf, done);
7155 if (try > count)
7156 try = count;
Willy Tarreaubfd59462013-02-21 07:46:09 +01007157
Willy Tarreau7bed9452014-02-02 02:00:24 +01007158 if (!(flags & CO_SFL_STREAMER) &&
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007159 !(ctx->xprt_st & SSL_SOCK_SEND_UNLIMITED) &&
Willy Tarreauef934602016-12-22 23:12:01 +01007160 global_ssl.max_record && try > global_ssl.max_record) {
7161 try = global_ssl.max_record;
Willy Tarreau518cedd2014-02-17 15:43:01 +01007162 }
7163 else {
7164 /* we need to keep the information about the fact that
7165 * we're not limiting the upcoming send(), because if it
7166 * fails, we'll have to retry with at least as many data.
7167 */
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007168 ctx->xprt_st |= SSL_SOCK_SEND_UNLIMITED;
Willy Tarreau518cedd2014-02-17 15:43:01 +01007169 }
Willy Tarreaubfd59462013-02-21 07:46:09 +01007170
Willy Tarreau5db847a2019-05-09 14:13:35 +02007171#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchard010941f2019-05-03 20:56:19 +02007172 if (!SSL_is_init_finished(ctx->ssl) && conn_is_back(conn)) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02007173 unsigned int max_early;
7174
Olivier Houchard522eea72017-11-03 16:27:47 +01007175 if (objt_listener(conn->target))
Olivier Houchard66ab4982019-02-26 18:37:15 +01007176 max_early = SSL_get_max_early_data(ctx->ssl);
Olivier Houchard522eea72017-11-03 16:27:47 +01007177 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01007178 if (SSL_get0_session(ctx->ssl))
7179 max_early = SSL_SESSION_get_max_early_data(SSL_get0_session(ctx->ssl));
Olivier Houchard522eea72017-11-03 16:27:47 +01007180 else
7181 max_early = 0;
7182 }
7183
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007184 if (try + ctx->sent_early_data > max_early) {
7185 try -= (try + ctx->sent_early_data) - max_early;
Olivier Houchard522eea72017-11-03 16:27:47 +01007186 if (try <= 0) {
Olivier Houchard010941f2019-05-03 20:56:19 +02007187 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Olivier Houchard965e84e2019-06-15 20:59:30 +02007188 tasklet_wakeup(ctx->wait_event.tasklet);
Olivier Houchardc2aae742017-09-22 18:26:28 +02007189 break;
Olivier Houchard522eea72017-11-03 16:27:47 +01007190 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02007191 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01007192 ret = SSL_write_early_data(ctx->ssl, b_peek(buf, done), try, &written_data);
Olivier Houchardc2aae742017-09-22 18:26:28 +02007193 if (ret == 1) {
7194 ret = written_data;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007195 ctx->sent_early_data += ret;
Olivier Houchard965e84e2019-06-15 20:59:30 +02007196 if (objt_server(conn->target)) {
Olivier Houchard522eea72017-11-03 16:27:47 +01007197 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN | CO_FL_EARLY_DATA;
Olivier Houchard965e84e2019-06-15 20:59:30 +02007198 /* Initiate the handshake, now */
7199 tasklet_wakeup(ctx->wait_event.tasklet);
7200 }
Olivier Houchard522eea72017-11-03 16:27:47 +01007201
Olivier Houchardc2aae742017-09-22 18:26:28 +02007202 }
7203
7204 } else
7205#endif
Olivier Houchard66ab4982019-02-26 18:37:15 +01007206 ret = SSL_write(ctx->ssl, b_peek(buf, done), try);
Willy Tarreau518cedd2014-02-17 15:43:01 +01007207
Emeric Brune1f38db2012-09-03 20:36:47 +02007208 if (conn->flags & CO_FL_ERROR) {
7209 /* CO_FL_ERROR may be set by ssl_sock_infocbk */
Emeric Brun644cde02012-12-14 11:21:13 +01007210 goto out_error;
Emeric Brune1f38db2012-09-03 20:36:47 +02007211 }
Emeric Brun46591952012-05-18 15:47:34 +02007212 if (ret > 0) {
Willy Tarreauc192b0a2020-01-23 09:11:58 +01007213 /* A send succeeded, so we can consider ourself connected */
7214 conn->flags &= ~CO_FL_WAIT_L4L6;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007215 ctx->xprt_st &= ~SSL_SOCK_SEND_UNLIMITED;
Willy Tarreau787db9a2018-06-14 18:31:46 +02007216 count -= ret;
Emeric Brun46591952012-05-18 15:47:34 +02007217 done += ret;
Emeric Brun46591952012-05-18 15:47:34 +02007218 }
7219 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01007220 ret = SSL_get_error(ctx->ssl, ret);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00007221
Emeric Brun46591952012-05-18 15:47:34 +02007222 if (ret == SSL_ERROR_WANT_WRITE) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01007223 if (SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun282a76a2012-11-08 18:02:56 +01007224 /* handshake is running, and it may need to re-enable write */
7225 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02007226 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02007227#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00007228 /* Async mode can be re-enabled, because we're leaving data state.*/
7229 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007230 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00007231#endif
Emeric Brun282a76a2012-11-08 18:02:56 +01007232 break;
7233 }
Olivier Houchardea8dd942019-05-20 14:02:16 +02007234
Emeric Brun46591952012-05-18 15:47:34 +02007235 break;
7236 }
7237 else if (ret == SSL_ERROR_WANT_READ) {
Emeric Brun8af8dd12012-11-08 17:56:20 +01007238 /* handshake is running, and it needs to enable read */
Emeric Brun46591952012-05-18 15:47:34 +02007239 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02007240 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
7241 SUB_RETRY_RECV,
7242 &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02007243#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00007244 /* Async mode can be re-enabled, because we're leaving data state.*/
7245 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007246 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00007247#endif
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00007248 break;
7249 }
Emeric Brun46591952012-05-18 15:47:34 +02007250 goto out_error;
7251 }
7252 }
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02007253 leave:
Emeric Brun46591952012-05-18 15:47:34 +02007254 return done;
7255
7256 out_error:
Emeric Brun644cde02012-12-14 11:21:13 +01007257 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02007258 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01007259 ERR_clear_error();
7260
Emeric Brun46591952012-05-18 15:47:34 +02007261 conn->flags |= CO_FL_ERROR;
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02007262 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +02007263}
7264
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007265static void ssl_sock_close(struct connection *conn, void *xprt_ctx) {
Emeric Brun46591952012-05-18 15:47:34 +02007266
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007267 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007268
Olivier Houchardea8dd942019-05-20 14:02:16 +02007269
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007270 if (ctx) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02007271 if (ctx->wait_event.events != 0)
7272 ctx->xprt->unsubscribe(ctx->conn, ctx->xprt_ctx,
7273 ctx->wait_event.events,
7274 &ctx->wait_event);
Willy Tarreau113d52b2020-01-10 09:20:26 +01007275 if (ctx->subs) {
7276 ctx->subs->events = 0;
7277 tasklet_wakeup(ctx->subs->tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02007278 }
Willy Tarreau113d52b2020-01-10 09:20:26 +01007279
Olivier Houchard692c1d02019-05-23 18:41:47 +02007280 if (ctx->xprt->close)
7281 ctx->xprt->close(conn, ctx->xprt_ctx);
Willy Tarreau5db847a2019-05-09 14:13:35 +02007282#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brun3854e012017-05-17 20:42:48 +02007283 if (global_ssl.async) {
7284 OSSL_ASYNC_FD all_fd[32], afd;
7285 size_t num_all_fds = 0;
7286 int i;
7287
Olivier Houchard66ab4982019-02-26 18:37:15 +01007288 SSL_get_all_async_fds(ctx->ssl, NULL, &num_all_fds);
Emeric Brun3854e012017-05-17 20:42:48 +02007289 if (num_all_fds > 32) {
7290 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
7291 return;
7292 }
7293
Olivier Houchard66ab4982019-02-26 18:37:15 +01007294 SSL_get_all_async_fds(ctx->ssl, all_fd, &num_all_fds);
Emeric Brun3854e012017-05-17 20:42:48 +02007295
7296 /* If an async job is pending, we must try to
7297 to catch the end using polling before calling
7298 SSL_free */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007299 if (num_all_fds && SSL_waiting_for_async(ctx->ssl)) {
Emeric Brun3854e012017-05-17 20:42:48 +02007300 for (i=0 ; i < num_all_fds ; i++) {
7301 /* switch on an handler designed to
7302 * handle the SSL_free
7303 */
7304 afd = all_fd[i];
7305 fdtab[afd].iocb = ssl_async_fd_free;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007306 fdtab[afd].owner = ctx->ssl;
Emeric Brun3854e012017-05-17 20:42:48 +02007307 fd_want_recv(afd);
Emeric Brunce9e01c2017-05-31 10:02:53 +00007308 /* To ensure that the fd cache won't be used
7309 * and we'll catch a real RD event.
7310 */
7311 fd_cant_recv(afd);
Emeric Brun3854e012017-05-17 20:42:48 +02007312 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02007313 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01007314 pool_free(ssl_sock_ctx_pool, ctx);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01007315 _HA_ATOMIC_ADD(&jobs, 1);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00007316 return;
7317 }
Emeric Brun3854e012017-05-17 20:42:48 +02007318 /* Else we can remove the fds from the fdtab
7319 * and call SSL_free.
7320 * note: we do a fd_remove and not a delete
7321 * because the fd is owned by the engine.
7322 * the engine is responsible to close
7323 */
7324 for (i=0 ; i < num_all_fds ; i++)
7325 fd_remove(all_fd[i]);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00007326 }
7327#endif
Olivier Houchard66ab4982019-02-26 18:37:15 +01007328 SSL_free(ctx->ssl);
Olivier Houchard54907bb2019-12-19 15:02:39 +01007329 b_free(&ctx->early_buf);
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02007330 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01007331 pool_free(ssl_sock_ctx_pool, ctx);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01007332 _HA_ATOMIC_SUB(&sslconns, 1);
Emeric Brun46591952012-05-18 15:47:34 +02007333 }
Emeric Brun46591952012-05-18 15:47:34 +02007334}
7335
7336/* This function tries to perform a clean shutdown on an SSL connection, and in
7337 * any case, flags the connection as reusable if no handshake was in progress.
7338 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007339static void ssl_sock_shutw(struct connection *conn, void *xprt_ctx, int clean)
Emeric Brun46591952012-05-18 15:47:34 +02007340{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007341 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007342
Willy Tarreau911db9b2020-01-23 16:27:54 +01007343 if (conn->flags & (CO_FL_WAIT_XPRT | CO_FL_SSL_WAIT_HS))
Emeric Brun46591952012-05-18 15:47:34 +02007344 return;
Emmanuel Hocdet405ff312017-01-08 14:07:39 +01007345 if (!clean)
7346 /* don't sent notify on SSL_shutdown */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007347 SSL_set_quiet_shutdown(ctx->ssl, 1);
Emeric Brun46591952012-05-18 15:47:34 +02007348 /* no handshake was in progress, try a clean ssl shutdown */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007349 if (SSL_shutdown(ctx->ssl) <= 0) {
Emeric Brun644cde02012-12-14 11:21:13 +01007350 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02007351 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01007352 ERR_clear_error();
7353 }
Emeric Brun46591952012-05-18 15:47:34 +02007354}
7355
William Lallemandd4f946c2019-12-05 10:26:40 +01007356/* fill a buffer with the algorithm and size of a public key */
7357static int cert_get_pkey_algo(X509 *crt, struct buffer *out)
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01007358{
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01007359 int bits = 0;
7360 int sig = TLSEXT_signature_anonymous;
7361 int len = -1;
Emmanuel Hocdetc3775d22019-11-04 18:19:32 +01007362 EVP_PKEY *pkey;
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01007363
Emmanuel Hocdetc3775d22019-11-04 18:19:32 +01007364 pkey = X509_get_pubkey(crt);
7365 if (pkey) {
7366 bits = EVP_PKEY_bits(pkey);
7367 switch(EVP_PKEY_base_id(pkey)) {
7368 case EVP_PKEY_RSA:
7369 sig = TLSEXT_signature_rsa;
7370 break;
7371 case EVP_PKEY_EC:
7372 sig = TLSEXT_signature_ecdsa;
7373 break;
7374 case EVP_PKEY_DSA:
7375 sig = TLSEXT_signature_dsa;
7376 break;
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01007377 }
Emmanuel Hocdetc3775d22019-11-04 18:19:32 +01007378 EVP_PKEY_free(pkey);
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01007379 }
7380
7381 switch(sig) {
7382 case TLSEXT_signature_rsa:
7383 len = chunk_printf(out, "RSA%d", bits);
7384 break;
7385 case TLSEXT_signature_ecdsa:
7386 len = chunk_printf(out, "EC%d", bits);
7387 break;
7388 case TLSEXT_signature_dsa:
7389 len = chunk_printf(out, "DSA%d", bits);
7390 break;
7391 default:
7392 return 0;
7393 }
7394 if (len < 0)
7395 return 0;
7396 return 1;
7397}
7398
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +05007399/* used for ppv2 pkey algo (can be used for logging) */
William Lallemandd4f946c2019-12-05 10:26:40 +01007400int ssl_sock_get_pkey_algo(struct connection *conn, struct buffer *out)
7401{
7402 struct ssl_sock_ctx *ctx;
7403 X509 *crt;
7404
7405 if (!ssl_sock_is_ssl(conn))
7406 return 0;
7407
7408 ctx = conn->xprt_ctx;
7409
7410 crt = SSL_get_certificate(ctx->ssl);
7411 if (!crt)
7412 return 0;
7413
7414 return cert_get_pkey_algo(crt, out);
7415}
7416
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01007417/* used for ppv2 cert signature (can be used for logging) */
7418const char *ssl_sock_get_cert_sig(struct connection *conn)
7419{
Christopher Faulet82004142019-09-10 10:12:03 +02007420 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007421
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01007422 __OPENSSL_110_CONST__ ASN1_OBJECT *algorithm;
7423 X509 *crt;
7424
7425 if (!ssl_sock_is_ssl(conn))
7426 return NULL;
Christopher Faulet82004142019-09-10 10:12:03 +02007427 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007428 crt = SSL_get_certificate(ctx->ssl);
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01007429 if (!crt)
7430 return NULL;
7431 X509_ALGOR_get0(&algorithm, NULL, NULL, X509_get0_tbs_sigalg(crt));
7432 return OBJ_nid2sn(OBJ_obj2nid(algorithm));
7433}
7434
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01007435/* used for ppv2 authority */
7436const char *ssl_sock_get_sni(struct connection *conn)
7437{
7438#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Christopher Faulet82004142019-09-10 10:12:03 +02007439 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007440
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01007441 if (!ssl_sock_is_ssl(conn))
7442 return NULL;
Christopher Faulet82004142019-09-10 10:12:03 +02007443 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007444 return SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01007445#else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007446 return NULL;
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01007447#endif
7448}
7449
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02007450/* used for logging/ppv2, may be changed for a sample fetch later */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007451const char *ssl_sock_get_cipher_name(struct connection *conn)
7452{
Christopher Faulet82004142019-09-10 10:12:03 +02007453 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007454
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02007455 if (!ssl_sock_is_ssl(conn))
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007456 return NULL;
Christopher Faulet82004142019-09-10 10:12:03 +02007457 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007458 return SSL_get_cipher_name(ctx->ssl);
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007459}
7460
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02007461/* used for logging/ppv2, may be changed for a sample fetch later */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007462const char *ssl_sock_get_proto_version(struct connection *conn)
7463{
Christopher Faulet82004142019-09-10 10:12:03 +02007464 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007465
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02007466 if (!ssl_sock_is_ssl(conn))
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007467 return NULL;
Christopher Faulet82004142019-09-10 10:12:03 +02007468 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007469 return SSL_get_version(ctx->ssl);
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02007470}
7471
Willy Tarreau8d598402012-10-22 17:58:39 +02007472/* Extract a serial from a cert, and copy it to a chunk.
7473 * Returns 1 if serial is found and copied, 0 if no serial found and
7474 * -1 if output is not large enough.
7475 */
7476static int
Willy Tarreau83061a82018-07-13 11:56:34 +02007477ssl_sock_get_serial(X509 *crt, struct buffer *out)
Willy Tarreau8d598402012-10-22 17:58:39 +02007478{
7479 ASN1_INTEGER *serial;
7480
7481 serial = X509_get_serialNumber(crt);
7482 if (!serial)
7483 return 0;
7484
7485 if (out->size < serial->length)
7486 return -1;
7487
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007488 memcpy(out->area, serial->data, serial->length);
7489 out->data = serial->length;
Willy Tarreau8d598402012-10-22 17:58:39 +02007490 return 1;
7491}
7492
Emeric Brun43e79582014-10-29 19:03:26 +01007493/* Extract a cert to der, and copy it to a chunk.
Joseph Herlant017b3da2018-11-15 09:07:59 -08007494 * Returns 1 if the cert is found and copied, 0 on der conversion failure
7495 * and -1 if the output is not large enough.
Emeric Brun43e79582014-10-29 19:03:26 +01007496 */
7497static int
Willy Tarreau83061a82018-07-13 11:56:34 +02007498ssl_sock_crt2der(X509 *crt, struct buffer *out)
Emeric Brun43e79582014-10-29 19:03:26 +01007499{
7500 int len;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007501 unsigned char *p = (unsigned char *) out->area;;
Emeric Brun43e79582014-10-29 19:03:26 +01007502
7503 len =i2d_X509(crt, NULL);
7504 if (len <= 0)
7505 return 1;
7506
7507 if (out->size < len)
7508 return -1;
7509
7510 i2d_X509(crt,&p);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007511 out->data = len;
Emeric Brun43e79582014-10-29 19:03:26 +01007512 return 1;
7513}
7514
Emeric Brunce5ad802012-10-22 14:11:22 +02007515
Willy Tarreau83061a82018-07-13 11:56:34 +02007516/* Copy Date in ASN1_UTCTIME format in struct buffer out.
Emeric Brunce5ad802012-10-22 14:11:22 +02007517 * Returns 1 if serial is found and copied, 0 if no valid time found
7518 * and -1 if output is not large enough.
7519 */
7520static int
Willy Tarreau83061a82018-07-13 11:56:34 +02007521ssl_sock_get_time(ASN1_TIME *tm, struct buffer *out)
Emeric Brunce5ad802012-10-22 14:11:22 +02007522{
7523 if (tm->type == V_ASN1_GENERALIZEDTIME) {
7524 ASN1_GENERALIZEDTIME *gentm = (ASN1_GENERALIZEDTIME *)tm;
7525
7526 if (gentm->length < 12)
7527 return 0;
7528 if (gentm->data[0] != 0x32 || gentm->data[1] != 0x30)
7529 return 0;
7530 if (out->size < gentm->length-2)
7531 return -1;
7532
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007533 memcpy(out->area, gentm->data+2, gentm->length-2);
7534 out->data = gentm->length-2;
Emeric Brunce5ad802012-10-22 14:11:22 +02007535 return 1;
7536 }
7537 else if (tm->type == V_ASN1_UTCTIME) {
7538 ASN1_UTCTIME *utctm = (ASN1_UTCTIME *)tm;
7539
7540 if (utctm->length < 10)
7541 return 0;
7542 if (utctm->data[0] >= 0x35)
7543 return 0;
7544 if (out->size < utctm->length)
7545 return -1;
7546
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007547 memcpy(out->area, utctm->data, utctm->length);
7548 out->data = utctm->length;
Emeric Brunce5ad802012-10-22 14:11:22 +02007549 return 1;
7550 }
7551
7552 return 0;
7553}
7554
Emeric Brun87855892012-10-17 17:39:35 +02007555/* Extract an entry from a X509_NAME and copy its value to an output chunk.
7556 * Returns 1 if entry found, 0 if entry not found, or -1 if output not large enough.
7557 */
7558static int
Willy Tarreau83061a82018-07-13 11:56:34 +02007559ssl_sock_get_dn_entry(X509_NAME *a, const struct buffer *entry, int pos,
7560 struct buffer *out)
Emeric Brun87855892012-10-17 17:39:35 +02007561{
7562 X509_NAME_ENTRY *ne;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007563 ASN1_OBJECT *obj;
7564 ASN1_STRING *data;
7565 const unsigned char *data_ptr;
7566 int data_len;
Emeric Brun87855892012-10-17 17:39:35 +02007567 int i, j, n;
7568 int cur = 0;
7569 const char *s;
7570 char tmp[128];
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007571 int name_count;
7572
7573 name_count = X509_NAME_entry_count(a);
Emeric Brun87855892012-10-17 17:39:35 +02007574
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007575 out->data = 0;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007576 for (i = 0; i < name_count; i++) {
Emeric Brun87855892012-10-17 17:39:35 +02007577 if (pos < 0)
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007578 j = (name_count-1) - i;
Emeric Brun87855892012-10-17 17:39:35 +02007579 else
7580 j = i;
7581
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007582 ne = X509_NAME_get_entry(a, j);
7583 obj = X509_NAME_ENTRY_get_object(ne);
7584 data = X509_NAME_ENTRY_get_data(ne);
7585 data_ptr = ASN1_STRING_get0_data(data);
7586 data_len = ASN1_STRING_length(data);
7587 n = OBJ_obj2nid(obj);
Emeric Brun87855892012-10-17 17:39:35 +02007588 if ((n == NID_undef) || ((s = OBJ_nid2sn(n)) == NULL)) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007589 i2t_ASN1_OBJECT(tmp, sizeof(tmp), obj);
Emeric Brun87855892012-10-17 17:39:35 +02007590 s = tmp;
7591 }
7592
7593 if (chunk_strcasecmp(entry, s) != 0)
7594 continue;
7595
7596 if (pos < 0)
7597 cur--;
7598 else
7599 cur++;
7600
7601 if (cur != pos)
7602 continue;
7603
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007604 if (data_len > out->size)
Emeric Brun87855892012-10-17 17:39:35 +02007605 return -1;
7606
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007607 memcpy(out->area, data_ptr, data_len);
7608 out->data = data_len;
Emeric Brun87855892012-10-17 17:39:35 +02007609 return 1;
7610 }
7611
7612 return 0;
7613
William Lallemandd4f946c2019-12-05 10:26:40 +01007614}
7615
7616/*
7617 * Extract and format the DNS SAN extensions and copy result into a chuink
7618 * Return 0;
7619 */
7620#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
7621static int ssl_sock_get_san_oneline(X509 *cert, struct buffer *out)
7622{
7623 int i;
7624 char *str;
7625 STACK_OF(GENERAL_NAME) *names = NULL;
7626
7627 names = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
7628 if (names) {
7629 for (i = 0; i < sk_GENERAL_NAME_num(names); i++) {
7630 GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
7631 if (i > 0)
7632 chunk_appendf(out, ", ");
7633 if (name->type == GEN_DNS) {
7634 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
7635 chunk_appendf(out, "DNS:%s", str);
7636 OPENSSL_free(str);
7637 }
7638 }
7639 }
7640 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
7641 }
7642 return 0;
Emeric Brun87855892012-10-17 17:39:35 +02007643}
William Lallemandd4f946c2019-12-05 10:26:40 +01007644#endif
Emeric Brun87855892012-10-17 17:39:35 +02007645
Elliot Otchet71f82972020-01-15 08:12:14 -05007646/*
7647 * Extract the DN in the specified format from the X509_NAME and copy result to a chunk.
7648 * Currently supports rfc2253 for returning LDAP V3 DNs.
7649 * Returns 1 if dn entries exist, 0 if no dn entry was found.
7650 */
7651static int
7652ssl_sock_get_dn_formatted(X509_NAME *a, const struct buffer *format, struct buffer *out)
7653{
7654 BIO *bio = NULL;
7655 int ret = 0;
7656 int data_len = 0;
7657
7658 if (chunk_strcmp(format, "rfc2253") == 0) {
7659 bio = BIO_new(BIO_s_mem());
7660 if (bio == NULL)
7661 goto out;
7662
7663 if (X509_NAME_print_ex(bio, a, 0, XN_FLAG_RFC2253) < 0)
7664 goto out;
7665
7666 if ((data_len = BIO_read(bio, out->area, out->size)) <= 0)
7667 goto out;
7668
7669 out->data = data_len;
7670
7671 ret = 1;
7672 }
7673out:
7674 if (bio)
7675 BIO_free(bio);
7676 return ret;
7677}
7678
Emeric Brun87855892012-10-17 17:39:35 +02007679/* Extract and format full DN from a X509_NAME and copy result into a chunk
7680 * Returns 1 if dn entries exits, 0 if no dn entry found or -1 if output is not large enough.
7681 */
7682static int
Willy Tarreau83061a82018-07-13 11:56:34 +02007683ssl_sock_get_dn_oneline(X509_NAME *a, struct buffer *out)
Emeric Brun87855892012-10-17 17:39:35 +02007684{
7685 X509_NAME_ENTRY *ne;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007686 ASN1_OBJECT *obj;
7687 ASN1_STRING *data;
7688 const unsigned char *data_ptr;
7689 int data_len;
Emeric Brun87855892012-10-17 17:39:35 +02007690 int i, n, ln;
7691 int l = 0;
7692 const char *s;
7693 char *p;
7694 char tmp[128];
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007695 int name_count;
7696
7697
7698 name_count = X509_NAME_entry_count(a);
Emeric Brun87855892012-10-17 17:39:35 +02007699
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007700 out->data = 0;
7701 p = out->area;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007702 for (i = 0; i < name_count; i++) {
7703 ne = X509_NAME_get_entry(a, i);
7704 obj = X509_NAME_ENTRY_get_object(ne);
7705 data = X509_NAME_ENTRY_get_data(ne);
7706 data_ptr = ASN1_STRING_get0_data(data);
7707 data_len = ASN1_STRING_length(data);
7708 n = OBJ_obj2nid(obj);
Emeric Brun87855892012-10-17 17:39:35 +02007709 if ((n == NID_undef) || ((s = OBJ_nid2sn(n)) == NULL)) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007710 i2t_ASN1_OBJECT(tmp, sizeof(tmp), obj);
Emeric Brun87855892012-10-17 17:39:35 +02007711 s = tmp;
7712 }
7713 ln = strlen(s);
7714
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007715 l += 1 + ln + 1 + data_len;
Emeric Brun87855892012-10-17 17:39:35 +02007716 if (l > out->size)
7717 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007718 out->data = l;
Emeric Brun87855892012-10-17 17:39:35 +02007719
7720 *(p++)='/';
7721 memcpy(p, s, ln);
7722 p += ln;
7723 *(p++)='=';
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007724 memcpy(p, data_ptr, data_len);
7725 p += data_len;
Emeric Brun87855892012-10-17 17:39:35 +02007726 }
7727
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007728 if (!out->data)
Emeric Brun87855892012-10-17 17:39:35 +02007729 return 0;
7730
7731 return 1;
7732}
7733
Olivier Houchardab28a322018-12-21 19:45:40 +01007734void ssl_sock_set_alpn(struct connection *conn, const unsigned char *alpn, int len)
7735{
7736#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Christopher Faulet82004142019-09-10 10:12:03 +02007737 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007738
Olivier Houcharde488ea82019-06-28 14:10:33 +02007739 if (!ssl_sock_is_ssl(conn))
7740 return;
Christopher Faulet82004142019-09-10 10:12:03 +02007741 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007742 SSL_set_alpn_protos(ctx->ssl, alpn, len);
Olivier Houchardab28a322018-12-21 19:45:40 +01007743#endif
7744}
7745
Willy Tarreau119a4082016-12-22 21:58:38 +01007746/* Sets advertised SNI for outgoing connections. Please set <hostname> to NULL
7747 * to disable SNI.
7748 */
Willy Tarreau63076412015-07-10 11:33:32 +02007749void ssl_sock_set_servername(struct connection *conn, const char *hostname)
7750{
7751#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Christopher Faulet82004142019-09-10 10:12:03 +02007752 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007753
Willy Tarreau119a4082016-12-22 21:58:38 +01007754 char *prev_name;
7755
Willy Tarreau63076412015-07-10 11:33:32 +02007756 if (!ssl_sock_is_ssl(conn))
7757 return;
Christopher Faulet82004142019-09-10 10:12:03 +02007758 ctx = conn->xprt_ctx;
Willy Tarreau63076412015-07-10 11:33:32 +02007759
Willy Tarreau119a4082016-12-22 21:58:38 +01007760 /* if the SNI changes, we must destroy the reusable context so that a
7761 * new connection will present a new SNI. As an optimization we could
7762 * later imagine having a small cache of ssl_ctx to hold a few SNI per
7763 * server.
7764 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007765 prev_name = (char *)SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau119a4082016-12-22 21:58:38 +01007766 if ((!prev_name && hostname) ||
7767 (prev_name && (!hostname || strcmp(hostname, prev_name) != 0)))
Olivier Houchard66ab4982019-02-26 18:37:15 +01007768 SSL_set_session(ctx->ssl, NULL);
Willy Tarreau119a4082016-12-22 21:58:38 +01007769
Olivier Houchard66ab4982019-02-26 18:37:15 +01007770 SSL_set_tlsext_host_name(ctx->ssl, hostname);
Willy Tarreau63076412015-07-10 11:33:32 +02007771#endif
7772}
7773
Emeric Brun0abf8362014-06-24 18:26:41 +02007774/* Extract peer certificate's common name into the chunk dest
7775 * Returns
7776 * the len of the extracted common name
7777 * or 0 if no CN found in DN
7778 * or -1 on error case (i.e. no peer certificate)
7779 */
Willy Tarreau83061a82018-07-13 11:56:34 +02007780int ssl_sock_get_remote_common_name(struct connection *conn,
7781 struct buffer *dest)
David Safb76832014-05-08 23:42:08 -04007782{
Christopher Faulet82004142019-09-10 10:12:03 +02007783 struct ssl_sock_ctx *ctx;
David Safb76832014-05-08 23:42:08 -04007784 X509 *crt = NULL;
7785 X509_NAME *name;
David Safb76832014-05-08 23:42:08 -04007786 const char find_cn[] = "CN";
Willy Tarreau83061a82018-07-13 11:56:34 +02007787 const struct buffer find_cn_chunk = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007788 .area = (char *)&find_cn,
7789 .data = sizeof(find_cn)-1
David Safb76832014-05-08 23:42:08 -04007790 };
Emeric Brun0abf8362014-06-24 18:26:41 +02007791 int result = -1;
David Safb76832014-05-08 23:42:08 -04007792
7793 if (!ssl_sock_is_ssl(conn))
Emeric Brun0abf8362014-06-24 18:26:41 +02007794 goto out;
Christopher Faulet82004142019-09-10 10:12:03 +02007795 ctx = conn->xprt_ctx;
David Safb76832014-05-08 23:42:08 -04007796
7797 /* SSL_get_peer_certificate, it increase X509 * ref count */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007798 crt = SSL_get_peer_certificate(ctx->ssl);
David Safb76832014-05-08 23:42:08 -04007799 if (!crt)
7800 goto out;
7801
7802 name = X509_get_subject_name(crt);
7803 if (!name)
7804 goto out;
David Safb76832014-05-08 23:42:08 -04007805
Emeric Brun0abf8362014-06-24 18:26:41 +02007806 result = ssl_sock_get_dn_entry(name, &find_cn_chunk, 1, dest);
7807out:
David Safb76832014-05-08 23:42:08 -04007808 if (crt)
7809 X509_free(crt);
7810
7811 return result;
7812}
7813
Dave McCowan328fb582014-07-30 10:39:13 -04007814/* returns 1 if client passed a certificate for this session, 0 if not */
7815int ssl_sock_get_cert_used_sess(struct connection *conn)
7816{
Christopher Faulet82004142019-09-10 10:12:03 +02007817 struct ssl_sock_ctx *ctx;
Dave McCowan328fb582014-07-30 10:39:13 -04007818 X509 *crt = NULL;
7819
7820 if (!ssl_sock_is_ssl(conn))
7821 return 0;
Christopher Faulet82004142019-09-10 10:12:03 +02007822 ctx = conn->xprt_ctx;
Dave McCowan328fb582014-07-30 10:39:13 -04007823
7824 /* SSL_get_peer_certificate, it increase X509 * ref count */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007825 crt = SSL_get_peer_certificate(ctx->ssl);
Dave McCowan328fb582014-07-30 10:39:13 -04007826 if (!crt)
7827 return 0;
7828
7829 X509_free(crt);
7830 return 1;
7831}
7832
7833/* returns 1 if client passed a certificate for this connection, 0 if not */
7834int ssl_sock_get_cert_used_conn(struct connection *conn)
David Safb76832014-05-08 23:42:08 -04007835{
Christopher Faulet82004142019-09-10 10:12:03 +02007836 struct ssl_sock_ctx *ctx;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007837
David Safb76832014-05-08 23:42:08 -04007838 if (!ssl_sock_is_ssl(conn))
7839 return 0;
Christopher Faulet82004142019-09-10 10:12:03 +02007840 ctx = conn->xprt_ctx;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007841 return SSL_SOCK_ST_FL_VERIFY_DONE & ctx->xprt_st ? 1 : 0;
David Safb76832014-05-08 23:42:08 -04007842}
7843
7844/* returns result from SSL verify */
7845unsigned int ssl_sock_get_verify_result(struct connection *conn)
7846{
Christopher Faulet82004142019-09-10 10:12:03 +02007847 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007848
David Safb76832014-05-08 23:42:08 -04007849 if (!ssl_sock_is_ssl(conn))
7850 return (unsigned int)X509_V_ERR_APPLICATION_VERIFICATION;
Christopher Faulet82004142019-09-10 10:12:03 +02007851 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007852 return (unsigned int)SSL_get_verify_result(ctx->ssl);
David Safb76832014-05-08 23:42:08 -04007853}
7854
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007855/* Returns the application layer protocol name in <str> and <len> when known.
7856 * Zero is returned if the protocol name was not found, otherwise non-zero is
7857 * returned. The string is allocated in the SSL context and doesn't have to be
7858 * freed by the caller. NPN is also checked if available since older versions
7859 * of openssl (1.0.1) which are more common in field only support this one.
7860 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007861static int ssl_sock_get_alpn(const struct connection *conn, void *xprt_ctx, const char **str, int *len)
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007862{
Olivier Houchard66ab4982019-02-26 18:37:15 +01007863#if defined(TLSEXT_TYPE_application_layer_protocol_negotiation) || \
7864 defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007865 struct ssl_sock_ctx *ctx = xprt_ctx;
7866 if (!ctx)
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007867 return 0;
7868
7869 *str = NULL;
7870
7871#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Olivier Houchard66ab4982019-02-26 18:37:15 +01007872 SSL_get0_alpn_selected(ctx->ssl, (const unsigned char **)str, (unsigned *)len);
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007873 if (*str)
7874 return 1;
7875#endif
Bernard Spil13c53f82018-02-15 13:34:58 +01007876#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007877 SSL_get0_next_proto_negotiated(ctx->ssl, (const unsigned char **)str, (unsigned *)len);
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007878 if (*str)
7879 return 1;
7880#endif
Olivier Houcharde179d0e2019-03-21 18:27:17 +01007881#endif
Willy Tarreau8743f7e2016-12-04 18:44:29 +01007882 return 0;
7883}
7884
Willy Tarreau7875d092012-09-10 08:20:03 +02007885/***** Below are some sample fetching functions for ACL/patterns *****/
7886
Olivier Houchardccaa7de2017-10-02 11:51:03 +02007887static int
7888smp_fetch_ssl_fc_has_early(const struct arg *args, struct sample *smp, const char *kw, void *private)
7889{
7890 struct connection *conn;
7891
7892 conn = objt_conn(smp->sess->origin);
7893 if (!conn || conn->xprt != &ssl_sock)
7894 return 0;
7895
7896 smp->flags = 0;
7897 smp->data.type = SMP_T_BOOL;
Emmanuel Hocdetc9858012019-08-07 14:44:49 +02007898#ifdef OPENSSL_IS_BORINGSSL
7899 {
7900 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
7901 smp->data.u.sint = (SSL_in_early_data(ctx->ssl) &&
7902 SSL_early_data_accepted(ctx->ssl));
7903 }
7904#else
Olivier Houchard25ae45a2017-11-29 19:51:19 +01007905 smp->data.u.sint = ((conn->flags & CO_FL_EARLY_DATA) &&
Olivier Houchard220a26c2020-01-23 14:57:36 +01007906 (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS))) ? 1 : 0;
Emmanuel Hocdetc9858012019-08-07 14:44:49 +02007907#endif
Olivier Houchardccaa7de2017-10-02 11:51:03 +02007908 return 1;
7909}
7910
Emeric Brune64aef12012-09-21 13:15:06 +02007911/* boolean, returns true if client cert was present */
7912static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007913smp_fetch_ssl_fc_has_crt(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brune64aef12012-09-21 13:15:06 +02007914{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007915 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007916 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007917
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007918 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007919 if (!conn || conn->xprt != &ssl_sock)
Emeric Brune64aef12012-09-21 13:15:06 +02007920 return 0;
7921
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007922 ctx = conn->xprt_ctx;
7923
Willy Tarreau911db9b2020-01-23 16:27:54 +01007924 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brune64aef12012-09-21 13:15:06 +02007925 smp->flags |= SMP_F_MAY_CHANGE;
7926 return 0;
7927 }
7928
7929 smp->flags = 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007930 smp->data.type = SMP_T_BOOL;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007931 smp->data.u.sint = SSL_SOCK_ST_FL_VERIFY_DONE & ctx->xprt_st ? 1 : 0;
Emeric Brune64aef12012-09-21 13:15:06 +02007932
7933 return 1;
7934}
7935
Emeric Brun43e79582014-10-29 19:03:26 +01007936/* binary, returns a certificate in a binary chunk (der/raw).
7937 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
7938 * should be use.
7939 */
7940static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007941smp_fetch_ssl_x_der(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun43e79582014-10-29 19:03:26 +01007942{
7943 int cert_peer = (kw[4] == 'c') ? 1 : 0;
7944 X509 *crt = NULL;
7945 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02007946 struct buffer *smp_trash;
Emeric Brun43e79582014-10-29 19:03:26 +01007947 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007948 struct ssl_sock_ctx *ctx;
Emeric Brun43e79582014-10-29 19:03:26 +01007949
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007950 conn = objt_conn(smp->sess->origin);
Emeric Brun43e79582014-10-29 19:03:26 +01007951 if (!conn || conn->xprt != &ssl_sock)
7952 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007953 ctx = conn->xprt_ctx;
Emeric Brun43e79582014-10-29 19:03:26 +01007954
Willy Tarreau911db9b2020-01-23 16:27:54 +01007955 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun43e79582014-10-29 19:03:26 +01007956 smp->flags |= SMP_F_MAY_CHANGE;
7957 return 0;
7958 }
7959
7960 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007961 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brun43e79582014-10-29 19:03:26 +01007962 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007963 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun43e79582014-10-29 19:03:26 +01007964
7965 if (!crt)
7966 goto out;
7967
7968 smp_trash = get_trash_chunk();
7969 if (ssl_sock_crt2der(crt, smp_trash) <= 0)
7970 goto out;
7971
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007972 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007973 smp->data.type = SMP_T_BIN;
Emeric Brun43e79582014-10-29 19:03:26 +01007974 ret = 1;
7975out:
7976 /* SSL_get_peer_certificate, it increase X509 * ref count */
7977 if (cert_peer && crt)
7978 X509_free(crt);
7979 return ret;
7980}
7981
Emeric Brunba841a12014-04-30 17:05:08 +02007982/* binary, returns serial of certificate in a binary chunk.
7983 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
7984 * should be use.
7985 */
Willy Tarreau8d598402012-10-22 17:58:39 +02007986static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007987smp_fetch_ssl_x_serial(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau8d598402012-10-22 17:58:39 +02007988{
Emeric Brunba841a12014-04-30 17:05:08 +02007989 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Willy Tarreau8d598402012-10-22 17:58:39 +02007990 X509 *crt = NULL;
7991 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02007992 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007993 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007994 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007995
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007996 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007997 if (!conn || conn->xprt != &ssl_sock)
Willy Tarreau8d598402012-10-22 17:58:39 +02007998 return 0;
7999
Olivier Houchard66ab4982019-02-26 18:37:15 +01008000 ctx = conn->xprt_ctx;
8001
Willy Tarreau911db9b2020-01-23 16:27:54 +01008002 if (conn->flags & CO_FL_WAIT_XPRT) {
Willy Tarreau8d598402012-10-22 17:58:39 +02008003 smp->flags |= SMP_F_MAY_CHANGE;
8004 return 0;
8005 }
8006
Emeric Brunba841a12014-04-30 17:05:08 +02008007 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008008 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008009 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008010 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008011
Willy Tarreau8d598402012-10-22 17:58:39 +02008012 if (!crt)
8013 goto out;
8014
Willy Tarreau47ca5452012-12-23 20:22:19 +01008015 smp_trash = get_trash_chunk();
Willy Tarreau8d598402012-10-22 17:58:39 +02008016 if (ssl_sock_get_serial(crt, smp_trash) <= 0)
8017 goto out;
8018
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008019 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008020 smp->data.type = SMP_T_BIN;
Willy Tarreau8d598402012-10-22 17:58:39 +02008021 ret = 1;
8022out:
Emeric Brunba841a12014-04-30 17:05:08 +02008023 /* SSL_get_peer_certificate, it increase X509 * ref count */
8024 if (cert_peer && crt)
Willy Tarreau8d598402012-10-22 17:58:39 +02008025 X509_free(crt);
8026 return ret;
8027}
Emeric Brune64aef12012-09-21 13:15:06 +02008028
Emeric Brunba841a12014-04-30 17:05:08 +02008029/* binary, returns the client certificate's SHA-1 fingerprint (SHA-1 hash of DER-encoded certificate) in a binary chunk.
8030 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8031 * should be use.
8032 */
James Votha051b4a2013-05-14 20:37:59 +02008033static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008034smp_fetch_ssl_x_sha1(const struct arg *args, struct sample *smp, const char *kw, void *private)
James Votha051b4a2013-05-14 20:37:59 +02008035{
Emeric Brunba841a12014-04-30 17:05:08 +02008036 int cert_peer = (kw[4] == 'c') ? 1 : 0;
James Votha051b4a2013-05-14 20:37:59 +02008037 X509 *crt = NULL;
8038 const EVP_MD *digest;
8039 int ret = 0;
Willy Tarreau105599c2020-02-25 08:59:23 +01008040 unsigned int len = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02008041 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008042 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008043 struct ssl_sock_ctx *ctx;
James Votha051b4a2013-05-14 20:37:59 +02008044
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008045 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008046 if (!conn || conn->xprt != &ssl_sock)
8047 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008048 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008049
Willy Tarreau911db9b2020-01-23 16:27:54 +01008050 if (conn->flags & CO_FL_WAIT_XPRT) {
James Votha051b4a2013-05-14 20:37:59 +02008051 smp->flags |= SMP_F_MAY_CHANGE;
8052 return 0;
8053 }
8054
Emeric Brunba841a12014-04-30 17:05:08 +02008055 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008056 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008057 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008058 crt = SSL_get_certificate(ctx->ssl);
James Votha051b4a2013-05-14 20:37:59 +02008059 if (!crt)
8060 goto out;
8061
8062 smp_trash = get_trash_chunk();
8063 digest = EVP_sha1();
Willy Tarreau105599c2020-02-25 08:59:23 +01008064 X509_digest(crt, digest, (unsigned char *) smp_trash->area, &len);
8065 smp_trash->data = len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008066 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008067 smp->data.type = SMP_T_BIN;
James Votha051b4a2013-05-14 20:37:59 +02008068 ret = 1;
8069out:
Emeric Brunba841a12014-04-30 17:05:08 +02008070 /* SSL_get_peer_certificate, it increase X509 * ref count */
8071 if (cert_peer && crt)
James Votha051b4a2013-05-14 20:37:59 +02008072 X509_free(crt);
8073 return ret;
8074}
8075
Emeric Brunba841a12014-04-30 17:05:08 +02008076/* string, returns certificate's notafter date in ASN1_UTCTIME format.
8077 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8078 * should be use.
8079 */
Emeric Brunce5ad802012-10-22 14:11:22 +02008080static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008081smp_fetch_ssl_x_notafter(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunce5ad802012-10-22 14:11:22 +02008082{
Emeric Brunba841a12014-04-30 17:05:08 +02008083 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brunce5ad802012-10-22 14:11:22 +02008084 X509 *crt = NULL;
8085 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02008086 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008087 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008088 struct ssl_sock_ctx *ctx;
Emeric Brunce5ad802012-10-22 14:11:22 +02008089
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008090 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008091 if (!conn || conn->xprt != &ssl_sock)
8092 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008093 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008094
Willy Tarreau911db9b2020-01-23 16:27:54 +01008095 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunce5ad802012-10-22 14:11:22 +02008096 smp->flags |= SMP_F_MAY_CHANGE;
8097 return 0;
8098 }
8099
Emeric Brunba841a12014-04-30 17:05:08 +02008100 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008101 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008102 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008103 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunce5ad802012-10-22 14:11:22 +02008104 if (!crt)
8105 goto out;
8106
Willy Tarreau47ca5452012-12-23 20:22:19 +01008107 smp_trash = get_trash_chunk();
Rosen Penev68185952018-12-14 08:47:02 -08008108 if (ssl_sock_get_time(X509_getm_notAfter(crt), smp_trash) <= 0)
Emeric Brunce5ad802012-10-22 14:11:22 +02008109 goto out;
8110
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008111 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008112 smp->data.type = SMP_T_STR;
Emeric Brunce5ad802012-10-22 14:11:22 +02008113 ret = 1;
8114out:
Emeric Brunba841a12014-04-30 17:05:08 +02008115 /* SSL_get_peer_certificate, it increase X509 * ref count */
8116 if (cert_peer && crt)
Emeric Brunce5ad802012-10-22 14:11:22 +02008117 X509_free(crt);
8118 return ret;
8119}
8120
Emeric Brunba841a12014-04-30 17:05:08 +02008121/* string, returns a string of a formatted full dn \C=..\O=..\OU=.. \CN=.. of certificate's issuer
8122 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8123 * should be use.
8124 */
Emeric Brun87855892012-10-17 17:39:35 +02008125static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008126smp_fetch_ssl_x_i_dn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun87855892012-10-17 17:39:35 +02008127{
Emeric Brunba841a12014-04-30 17:05:08 +02008128 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun87855892012-10-17 17:39:35 +02008129 X509 *crt = NULL;
8130 X509_NAME *name;
8131 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02008132 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008133 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008134 struct ssl_sock_ctx *ctx;
Emeric Brun87855892012-10-17 17:39:35 +02008135
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008136 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008137 if (!conn || conn->xprt != &ssl_sock)
8138 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008139 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008140
Willy Tarreau911db9b2020-01-23 16:27:54 +01008141 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun87855892012-10-17 17:39:35 +02008142 smp->flags |= SMP_F_MAY_CHANGE;
8143 return 0;
8144 }
8145
Emeric Brunba841a12014-04-30 17:05:08 +02008146 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008147 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008148 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008149 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun87855892012-10-17 17:39:35 +02008150 if (!crt)
8151 goto out;
8152
8153 name = X509_get_issuer_name(crt);
8154 if (!name)
8155 goto out;
8156
Willy Tarreau47ca5452012-12-23 20:22:19 +01008157 smp_trash = get_trash_chunk();
Elliot Otchet71f82972020-01-15 08:12:14 -05008158 if (args && args[0].type == ARGT_STR && args[0].data.str.data > 0) {
Emeric Brun87855892012-10-17 17:39:35 +02008159 int pos = 1;
8160
8161 if (args[1].type == ARGT_SINT)
8162 pos = args[1].data.sint;
Emeric Brun87855892012-10-17 17:39:35 +02008163
8164 if (ssl_sock_get_dn_entry(name, &args[0].data.str, pos, smp_trash) <= 0)
8165 goto out;
8166 }
Elliot Otchet71f82972020-01-15 08:12:14 -05008167 else if (args && args[2].type == ARGT_STR && args[2].data.str.data > 0) {
8168 if (ssl_sock_get_dn_formatted(name, &args[2].data.str, smp_trash) <= 0)
8169 goto out;
8170 }
Emeric Brun87855892012-10-17 17:39:35 +02008171 else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
8172 goto out;
8173
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008174 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008175 smp->data.u.str = *smp_trash;
Emeric Brun87855892012-10-17 17:39:35 +02008176 ret = 1;
8177out:
Emeric Brunba841a12014-04-30 17:05:08 +02008178 /* SSL_get_peer_certificate, it increase X509 * ref count */
8179 if (cert_peer && crt)
Emeric Brun87855892012-10-17 17:39:35 +02008180 X509_free(crt);
8181 return ret;
8182}
8183
Emeric Brunba841a12014-04-30 17:05:08 +02008184/* string, returns notbefore date in ASN1_UTCTIME format.
8185 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8186 * should be use.
8187 */
Emeric Brunce5ad802012-10-22 14:11:22 +02008188static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008189smp_fetch_ssl_x_notbefore(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunce5ad802012-10-22 14:11:22 +02008190{
Emeric Brunba841a12014-04-30 17:05:08 +02008191 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brunce5ad802012-10-22 14:11:22 +02008192 X509 *crt = NULL;
8193 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02008194 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008195 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008196 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008197
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008198 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008199 if (!conn || conn->xprt != &ssl_sock)
Emeric Brunce5ad802012-10-22 14:11:22 +02008200 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008201 ctx = conn->xprt_ctx;
Emeric Brunce5ad802012-10-22 14:11:22 +02008202
Willy Tarreau911db9b2020-01-23 16:27:54 +01008203 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunce5ad802012-10-22 14:11:22 +02008204 smp->flags |= SMP_F_MAY_CHANGE;
8205 return 0;
8206 }
8207
Emeric Brunba841a12014-04-30 17:05:08 +02008208 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008209 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008210 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008211 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunce5ad802012-10-22 14:11:22 +02008212 if (!crt)
8213 goto out;
8214
Willy Tarreau47ca5452012-12-23 20:22:19 +01008215 smp_trash = get_trash_chunk();
Rosen Penev68185952018-12-14 08:47:02 -08008216 if (ssl_sock_get_time(X509_getm_notBefore(crt), smp_trash) <= 0)
Emeric Brunce5ad802012-10-22 14:11:22 +02008217 goto out;
8218
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008219 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008220 smp->data.type = SMP_T_STR;
Emeric Brunce5ad802012-10-22 14:11:22 +02008221 ret = 1;
8222out:
Emeric Brunba841a12014-04-30 17:05:08 +02008223 /* SSL_get_peer_certificate, it increase X509 * ref count */
8224 if (cert_peer && crt)
Emeric Brunce5ad802012-10-22 14:11:22 +02008225 X509_free(crt);
8226 return ret;
8227}
8228
Emeric Brunba841a12014-04-30 17:05:08 +02008229/* string, returns a string of a formatted full dn \C=..\O=..\OU=.. \CN=.. of certificate's subject
8230 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8231 * should be use.
8232 */
Emeric Brun87855892012-10-17 17:39:35 +02008233static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008234smp_fetch_ssl_x_s_dn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun87855892012-10-17 17:39:35 +02008235{
Emeric Brunba841a12014-04-30 17:05:08 +02008236 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun87855892012-10-17 17:39:35 +02008237 X509 *crt = NULL;
8238 X509_NAME *name;
8239 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02008240 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008241 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008242 struct ssl_sock_ctx *ctx;
Emeric Brun87855892012-10-17 17:39:35 +02008243
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008244 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008245 if (!conn || conn->xprt != &ssl_sock)
8246 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008247 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008248
Willy Tarreau911db9b2020-01-23 16:27:54 +01008249 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun87855892012-10-17 17:39:35 +02008250 smp->flags |= SMP_F_MAY_CHANGE;
8251 return 0;
8252 }
8253
Emeric Brunba841a12014-04-30 17:05:08 +02008254 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008255 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008256 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008257 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun87855892012-10-17 17:39:35 +02008258 if (!crt)
8259 goto out;
8260
8261 name = X509_get_subject_name(crt);
8262 if (!name)
8263 goto out;
8264
Willy Tarreau47ca5452012-12-23 20:22:19 +01008265 smp_trash = get_trash_chunk();
Elliot Otchet71f82972020-01-15 08:12:14 -05008266 if (args && args[0].type == ARGT_STR && args[0].data.str.data > 0) {
Emeric Brun87855892012-10-17 17:39:35 +02008267 int pos = 1;
8268
8269 if (args[1].type == ARGT_SINT)
8270 pos = args[1].data.sint;
Emeric Brun87855892012-10-17 17:39:35 +02008271
8272 if (ssl_sock_get_dn_entry(name, &args[0].data.str, pos, smp_trash) <= 0)
8273 goto out;
8274 }
Elliot Otchet71f82972020-01-15 08:12:14 -05008275 else if (args && args[2].type == ARGT_STR && args[2].data.str.data > 0) {
8276 if (ssl_sock_get_dn_formatted(name, &args[2].data.str, smp_trash) <= 0)
8277 goto out;
8278 }
Emeric Brun87855892012-10-17 17:39:35 +02008279 else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
8280 goto out;
8281
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008282 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008283 smp->data.u.str = *smp_trash;
Emeric Brun87855892012-10-17 17:39:35 +02008284 ret = 1;
8285out:
Emeric Brunba841a12014-04-30 17:05:08 +02008286 /* SSL_get_peer_certificate, it increase X509 * ref count */
8287 if (cert_peer && crt)
Emeric Brun87855892012-10-17 17:39:35 +02008288 X509_free(crt);
8289 return ret;
8290}
Emeric Brun9143d372012-12-20 15:44:16 +01008291
8292/* integer, returns true if current session use a client certificate */
8293static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008294smp_fetch_ssl_c_used(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun9143d372012-12-20 15:44:16 +01008295{
8296 X509 *crt;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008297 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008298 struct ssl_sock_ctx *ctx;
Emeric Brun9143d372012-12-20 15:44:16 +01008299
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008300 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008301 if (!conn || conn->xprt != &ssl_sock)
8302 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008303 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008304
Willy Tarreau911db9b2020-01-23 16:27:54 +01008305 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun9143d372012-12-20 15:44:16 +01008306 smp->flags |= SMP_F_MAY_CHANGE;
8307 return 0;
8308 }
8309
8310 /* SSL_get_peer_certificate returns a ptr on allocated X509 struct */
Olivier Houchard66ab4982019-02-26 18:37:15 +01008311 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brun9143d372012-12-20 15:44:16 +01008312 if (crt) {
8313 X509_free(crt);
8314 }
8315
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008316 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008317 smp->data.u.sint = (crt != NULL);
Emeric Brun9143d372012-12-20 15:44:16 +01008318 return 1;
8319}
8320
Emeric Brunba841a12014-04-30 17:05:08 +02008321/* integer, returns the certificate version
8322 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8323 * should be use.
8324 */
Emeric Bruna7359fd2012-10-17 15:03:11 +02008325static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008326smp_fetch_ssl_x_version(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Bruna7359fd2012-10-17 15:03:11 +02008327{
Emeric Brunba841a12014-04-30 17:05:08 +02008328 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Bruna7359fd2012-10-17 15:03:11 +02008329 X509 *crt;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008330 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008331 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008332
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008333 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008334 if (!conn || conn->xprt != &ssl_sock)
Emeric Bruna7359fd2012-10-17 15:03:11 +02008335 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008336 ctx = conn->xprt_ctx;
Emeric Bruna7359fd2012-10-17 15:03:11 +02008337
Willy Tarreau911db9b2020-01-23 16:27:54 +01008338 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Bruna7359fd2012-10-17 15:03:11 +02008339 smp->flags |= SMP_F_MAY_CHANGE;
8340 return 0;
8341 }
8342
Emeric Brunba841a12014-04-30 17:05:08 +02008343 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008344 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008345 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008346 crt = SSL_get_certificate(ctx->ssl);
Emeric Bruna7359fd2012-10-17 15:03:11 +02008347 if (!crt)
8348 return 0;
8349
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008350 smp->data.u.sint = (unsigned int)(1 + X509_get_version(crt));
Emeric Brunba841a12014-04-30 17:05:08 +02008351 /* SSL_get_peer_certificate increase X509 * ref count */
8352 if (cert_peer)
8353 X509_free(crt);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008354 smp->data.type = SMP_T_SINT;
Emeric Bruna7359fd2012-10-17 15:03:11 +02008355
8356 return 1;
8357}
8358
Emeric Brunba841a12014-04-30 17:05:08 +02008359/* string, returns the certificate's signature algorithm.
8360 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8361 * should be use.
8362 */
Emeric Brun7f56e742012-10-19 18:15:40 +02008363static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008364smp_fetch_ssl_x_sig_alg(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun7f56e742012-10-19 18:15:40 +02008365{
Emeric Brunba841a12014-04-30 17:05:08 +02008366 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun7f56e742012-10-19 18:15:40 +02008367 X509 *crt;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02008368 __OPENSSL_110_CONST__ ASN1_OBJECT *algorithm;
Emeric Brun7f56e742012-10-19 18:15:40 +02008369 int nid;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008370 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008371 struct ssl_sock_ctx *ctx;
Emeric Brun7f56e742012-10-19 18:15:40 +02008372
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008373 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008374 if (!conn || conn->xprt != &ssl_sock)
8375 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008376 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008377
Willy Tarreau911db9b2020-01-23 16:27:54 +01008378 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun7f56e742012-10-19 18:15:40 +02008379 smp->flags |= SMP_F_MAY_CHANGE;
8380 return 0;
8381 }
8382
Emeric Brunba841a12014-04-30 17:05:08 +02008383 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008384 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008385 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008386 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun7f56e742012-10-19 18:15:40 +02008387 if (!crt)
8388 return 0;
8389
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02008390 X509_ALGOR_get0(&algorithm, NULL, NULL, X509_get0_tbs_sigalg(crt));
8391 nid = OBJ_obj2nid(algorithm);
Emeric Brun7f56e742012-10-19 18:15:40 +02008392
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008393 smp->data.u.str.area = (char *)OBJ_nid2sn(nid);
8394 if (!smp->data.u.str.area) {
Emeric Brunba841a12014-04-30 17:05:08 +02008395 /* SSL_get_peer_certificate increase X509 * ref count */
8396 if (cert_peer)
8397 X509_free(crt);
Emeric Brun7f56e742012-10-19 18:15:40 +02008398 return 0;
Emeric Brun9bf3ba22013-10-07 14:31:44 +02008399 }
Emeric Brun7f56e742012-10-19 18:15:40 +02008400
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008401 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008402 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008403 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brunba841a12014-04-30 17:05:08 +02008404 /* SSL_get_peer_certificate increase X509 * ref count */
8405 if (cert_peer)
8406 X509_free(crt);
Emeric Brun7f56e742012-10-19 18:15:40 +02008407
8408 return 1;
8409}
8410
Emeric Brunba841a12014-04-30 17:05:08 +02008411/* string, returns the certificate's key algorithm.
8412 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
8413 * should be use.
8414 */
Emeric Brun521a0112012-10-22 12:22:55 +02008415static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008416smp_fetch_ssl_x_key_alg(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun521a0112012-10-22 12:22:55 +02008417{
Emeric Brunba841a12014-04-30 17:05:08 +02008418 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun521a0112012-10-22 12:22:55 +02008419 X509 *crt;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02008420 ASN1_OBJECT *algorithm;
Emeric Brun521a0112012-10-22 12:22:55 +02008421 int nid;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008422 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008423 struct ssl_sock_ctx *ctx;
Emeric Brun521a0112012-10-22 12:22:55 +02008424
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008425 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008426 if (!conn || conn->xprt != &ssl_sock)
8427 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008428 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008429
Willy Tarreau911db9b2020-01-23 16:27:54 +01008430 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brun521a0112012-10-22 12:22:55 +02008431 smp->flags |= SMP_F_MAY_CHANGE;
8432 return 0;
8433 }
8434
Emeric Brunba841a12014-04-30 17:05:08 +02008435 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01008436 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02008437 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008438 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun521a0112012-10-22 12:22:55 +02008439 if (!crt)
8440 return 0;
8441
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02008442 X509_PUBKEY_get0_param(&algorithm, NULL, NULL, NULL, X509_get_X509_PUBKEY(crt));
8443 nid = OBJ_obj2nid(algorithm);
Emeric Brun521a0112012-10-22 12:22:55 +02008444
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008445 smp->data.u.str.area = (char *)OBJ_nid2sn(nid);
8446 if (!smp->data.u.str.area) {
Emeric Brunba841a12014-04-30 17:05:08 +02008447 /* SSL_get_peer_certificate increase X509 * ref count */
8448 if (cert_peer)
8449 X509_free(crt);
Emeric Brun521a0112012-10-22 12:22:55 +02008450 return 0;
Emeric Brun9bf3ba22013-10-07 14:31:44 +02008451 }
Emeric Brun521a0112012-10-22 12:22:55 +02008452
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008453 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008454 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008455 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brunba841a12014-04-30 17:05:08 +02008456 if (cert_peer)
8457 X509_free(crt);
Emeric Brun521a0112012-10-22 12:22:55 +02008458
8459 return 1;
8460}
8461
Emeric Brun645ae792014-04-30 14:21:06 +02008462/* boolean, returns true if front conn. transport layer is SSL.
8463 * This function is also usable on backend conn if the fetch keyword 5th
8464 * char is 'b'.
8465 */
Willy Tarreau7875d092012-09-10 08:20:03 +02008466static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008467smp_fetch_ssl_fc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02008468{
Emeric Bruneb8def92018-02-19 15:59:48 +01008469 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8470 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008471
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008472 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008473 smp->data.u.sint = (conn && conn->xprt == &ssl_sock);
Willy Tarreau7875d092012-09-10 08:20:03 +02008474 return 1;
8475}
8476
Emeric Brun2525b6b2012-10-18 15:59:43 +02008477/* boolean, returns true if client present a SNI */
Willy Tarreau7875d092012-09-10 08:20:03 +02008478static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008479smp_fetch_ssl_fc_has_sni(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02008480{
8481#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008482 struct connection *conn = objt_conn(smp->sess->origin);
Olivier Houchard66ab4982019-02-26 18:37:15 +01008483 struct ssl_sock_ctx *ctx = conn ? conn->xprt_ctx : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008484
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008485 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008486 smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008487 conn->xprt_ctx &&
Olivier Houchard66ab4982019-02-26 18:37:15 +01008488 SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name) != NULL;
Willy Tarreau7875d092012-09-10 08:20:03 +02008489 return 1;
8490#else
8491 return 0;
8492#endif
8493}
8494
Emeric Brun74f7ffa2018-02-19 16:14:12 +01008495/* boolean, returns true if client session has been resumed.
8496 * This function is also usable on backend conn if the fetch keyword 5th
8497 * char is 'b'.
8498 */
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02008499static int
8500smp_fetch_ssl_fc_is_resumed(const struct arg *args, struct sample *smp, const char *kw, void *private)
8501{
Emeric Brun74f7ffa2018-02-19 16:14:12 +01008502 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8503 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008504 struct ssl_sock_ctx *ctx = conn ? conn->xprt_ctx : NULL;
Emeric Brun74f7ffa2018-02-19 16:14:12 +01008505
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02008506
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008507 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008508 smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02008509 conn->xprt_ctx &&
Olivier Houchard66ab4982019-02-26 18:37:15 +01008510 SSL_session_reused(ctx->ssl);
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02008511 return 1;
8512}
8513
Emeric Brun645ae792014-04-30 14:21:06 +02008514/* string, returns the used cipher if front conn. transport layer is SSL.
8515 * This function is also usable on backend conn if the fetch keyword 5th
8516 * char is 'b'.
8517 */
Emeric Brun589fcad2012-10-16 14:13:26 +02008518static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008519smp_fetch_ssl_fc_cipher(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02008520{
Emeric Bruneb8def92018-02-19 15:59:48 +01008521 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8522 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008523 struct ssl_sock_ctx *ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02008524
Willy Tarreaube508f12016-03-10 11:47:01 +01008525 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008526 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Emeric Brun589fcad2012-10-16 14:13:26 +02008527 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008528 ctx = conn->xprt_ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02008529
Olivier Houchard66ab4982019-02-26 18:37:15 +01008530 smp->data.u.str.area = (char *)SSL_get_cipher_name(ctx->ssl);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008531 if (!smp->data.u.str.area)
Emeric Brun589fcad2012-10-16 14:13:26 +02008532 return 0;
8533
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008534 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008535 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008536 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brun589fcad2012-10-16 14:13:26 +02008537
8538 return 1;
8539}
8540
Emeric Brun645ae792014-04-30 14:21:06 +02008541/* integer, returns the algoritm's keysize if front conn. transport layer
8542 * is SSL.
8543 * This function is also usable on backend conn if the fetch keyword 5th
8544 * char is 'b'.
8545 */
Emeric Brun589fcad2012-10-16 14:13:26 +02008546static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008547smp_fetch_ssl_fc_alg_keysize(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02008548{
Emeric Bruneb8def92018-02-19 15:59:48 +01008549 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8550 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008551 struct ssl_sock_ctx *ctx;
Willy Tarreaue237fe12016-03-10 17:05:28 +01008552 int sint;
Willy Tarreaube508f12016-03-10 11:47:01 +01008553
Emeric Brun589fcad2012-10-16 14:13:26 +02008554 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008555 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Emeric Brun589fcad2012-10-16 14:13:26 +02008556 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008557 ctx = conn->xprt_ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02008558
Olivier Houchard66ab4982019-02-26 18:37:15 +01008559 if (!SSL_get_cipher_bits(ctx->ssl, &sint))
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008560 return 0;
8561
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008562 smp->data.u.sint = sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008563 smp->data.type = SMP_T_SINT;
Emeric Brun589fcad2012-10-16 14:13:26 +02008564
8565 return 1;
8566}
8567
Emeric Brun645ae792014-04-30 14:21:06 +02008568/* integer, returns the used keysize if front conn. transport layer is SSL.
8569 * This function is also usable on backend conn if the fetch keyword 5th
8570 * char is 'b'.
8571 */
Emeric Brun589fcad2012-10-16 14:13:26 +02008572static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008573smp_fetch_ssl_fc_use_keysize(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02008574{
Emeric Bruneb8def92018-02-19 15:59:48 +01008575 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8576 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008577 struct ssl_sock_ctx *ctx;
Willy Tarreaube508f12016-03-10 11:47:01 +01008578
Emeric Brun589fcad2012-10-16 14:13:26 +02008579 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008580 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8581 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008582 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008583
Olivier Houchard66ab4982019-02-26 18:37:15 +01008584 smp->data.u.sint = (unsigned int)SSL_get_cipher_bits(ctx->ssl, NULL);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008585 if (!smp->data.u.sint)
Emeric Brun589fcad2012-10-16 14:13:26 +02008586 return 0;
8587
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008588 smp->data.type = SMP_T_SINT;
Emeric Brun589fcad2012-10-16 14:13:26 +02008589
8590 return 1;
8591}
8592
Bernard Spil13c53f82018-02-15 13:34:58 +01008593#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau7875d092012-09-10 08:20:03 +02008594static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008595smp_fetch_ssl_fc_npn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreaua33c6542012-10-15 13:19:06 +02008596{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008597 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008598 struct ssl_sock_ctx *ctx;
Willy Tarreau105599c2020-02-25 08:59:23 +01008599 unsigned int len = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008600
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008601 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008602 smp->data.type = SMP_T_STR;
Willy Tarreaua33c6542012-10-15 13:19:06 +02008603
Olivier Houchard6b77f492018-11-22 18:18:29 +01008604 conn = (kw[4] != 'b' ) ? objt_conn(smp->sess->origin) :
8605 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008606 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8607 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008608 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008609
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008610 smp->data.u.str.area = NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008611 SSL_get0_next_proto_negotiated(ctx->ssl,
Willy Tarreau105599c2020-02-25 08:59:23 +01008612 (const unsigned char **)&smp->data.u.str.area,
8613 &len);
Willy Tarreaua33c6542012-10-15 13:19:06 +02008614
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008615 if (!smp->data.u.str.area)
Willy Tarreaua33c6542012-10-15 13:19:06 +02008616 return 0;
8617
Willy Tarreau105599c2020-02-25 08:59:23 +01008618 smp->data.u.str.data = len;
Willy Tarreaua33c6542012-10-15 13:19:06 +02008619 return 1;
Willy Tarreaua33c6542012-10-15 13:19:06 +02008620}
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02008621#endif
Willy Tarreaua33c6542012-10-15 13:19:06 +02008622
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01008623#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02008624static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008625smp_fetch_ssl_fc_alpn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauab861d32013-04-02 02:30:41 +02008626{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008627 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008628 struct ssl_sock_ctx *ctx;
Willy Tarreau105599c2020-02-25 08:59:23 +01008629 unsigned int len = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008630
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008631 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008632 smp->data.type = SMP_T_STR;
Willy Tarreauab861d32013-04-02 02:30:41 +02008633
Olivier Houchard6b77f492018-11-22 18:18:29 +01008634 conn = (kw[4] != 'b' ) ? objt_conn(smp->sess->origin) :
8635 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
8636
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008637 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Willy Tarreauab861d32013-04-02 02:30:41 +02008638 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008639 ctx = conn->xprt_ctx;
Willy Tarreauab861d32013-04-02 02:30:41 +02008640
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008641 smp->data.u.str.area = NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008642 SSL_get0_alpn_selected(ctx->ssl,
Willy Tarreau105599c2020-02-25 08:59:23 +01008643 (const unsigned char **)&smp->data.u.str.area,
8644 &len);
Willy Tarreauab861d32013-04-02 02:30:41 +02008645
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008646 if (!smp->data.u.str.area)
Willy Tarreauab861d32013-04-02 02:30:41 +02008647 return 0;
8648
Willy Tarreau105599c2020-02-25 08:59:23 +01008649 smp->data.u.str.data = len;
Willy Tarreauab861d32013-04-02 02:30:41 +02008650 return 1;
8651}
8652#endif
8653
Emeric Brun645ae792014-04-30 14:21:06 +02008654/* string, returns the used protocol if front conn. transport layer is SSL.
8655 * This function is also usable on backend conn if the fetch keyword 5th
8656 * char is 'b'.
8657 */
Willy Tarreaua33c6542012-10-15 13:19:06 +02008658static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008659smp_fetch_ssl_fc_protocol(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02008660{
Emeric Bruneb8def92018-02-19 15:59:48 +01008661 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8662 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008663 struct ssl_sock_ctx *ctx;
Willy Tarreaube508f12016-03-10 11:47:01 +01008664
Emeric Brun589fcad2012-10-16 14:13:26 +02008665 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008666 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8667 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008668 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008669
Olivier Houchard66ab4982019-02-26 18:37:15 +01008670 smp->data.u.str.area = (char *)SSL_get_version(ctx->ssl);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008671 if (!smp->data.u.str.area)
Emeric Brun589fcad2012-10-16 14:13:26 +02008672 return 0;
8673
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008674 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008675 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008676 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brun589fcad2012-10-16 14:13:26 +02008677
8678 return 1;
8679}
8680
Willy Tarreau87b09662015-04-03 00:22:06 +02008681/* binary, returns the SSL stream id if front conn. transport layer is SSL.
Emeric Brun645ae792014-04-30 14:21:06 +02008682 * This function is also usable on backend conn if the fetch keyword 5th
8683 * char is 'b'.
8684 */
Willy Tarreau9a1ab082019-05-09 13:26:41 +02008685#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brun589fcad2012-10-16 14:13:26 +02008686static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008687smp_fetch_ssl_fc_session_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunfe68f682012-10-16 14:59:28 +02008688{
Emeric Bruneb8def92018-02-19 15:59:48 +01008689 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8690 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaue237fe12016-03-10 17:05:28 +01008691 SSL_SESSION *ssl_sess;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008692 struct ssl_sock_ctx *ctx;
Willy Tarreau105599c2020-02-25 08:59:23 +01008693 unsigned int len = 0;
Willy Tarreaube508f12016-03-10 11:47:01 +01008694
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008695 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008696 smp->data.type = SMP_T_BIN;
Emeric Brunfe68f682012-10-16 14:59:28 +02008697
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008698 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8699 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008700 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008701
Olivier Houchard66ab4982019-02-26 18:37:15 +01008702 ssl_sess = SSL_get_session(ctx->ssl);
Willy Tarreau192252e2015-04-04 01:47:55 +02008703 if (!ssl_sess)
Emeric Brunfe68f682012-10-16 14:59:28 +02008704 return 0;
8705
Willy Tarreau105599c2020-02-25 08:59:23 +01008706 smp->data.u.str.area = (char *)SSL_SESSION_get_id(ssl_sess, &len);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008707 if (!smp->data.u.str.area || !smp->data.u.str.data)
Emeric Brunfe68f682012-10-16 14:59:28 +02008708 return 0;
8709
Willy Tarreau105599c2020-02-25 08:59:23 +01008710 smp->data.u.str.data = len;
Emeric Brunfe68f682012-10-16 14:59:28 +02008711 return 1;
Emeric Brunfe68f682012-10-16 14:59:28 +02008712}
Patrick Hemmer41966772018-04-28 19:15:48 -04008713#endif
8714
Emeric Brunfe68f682012-10-16 14:59:28 +02008715
Emmanuel Hocdet839af572019-05-14 16:27:35 +02008716#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmere0275472018-04-28 19:15:51 -04008717static int
Patrick Hemmer65674662019-06-04 08:13:03 -04008718smp_fetch_ssl_fc_random(const struct arg *args, struct sample *smp, const char *kw, void *private)
8719{
8720 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8721 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
8722 struct buffer *data;
8723 struct ssl_sock_ctx *ctx;
8724
8725 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8726 return 0;
8727 ctx = conn->xprt_ctx;
8728
8729 data = get_trash_chunk();
8730 if (kw[7] == 'c')
8731 data->data = SSL_get_client_random(ctx->ssl,
8732 (unsigned char *) data->area,
8733 data->size);
8734 else
8735 data->data = SSL_get_server_random(ctx->ssl,
8736 (unsigned char *) data->area,
8737 data->size);
8738 if (!data->data)
8739 return 0;
8740
8741 smp->flags = 0;
8742 smp->data.type = SMP_T_BIN;
8743 smp->data.u.str = *data;
8744
8745 return 1;
8746}
8747
8748static int
Patrick Hemmere0275472018-04-28 19:15:51 -04008749smp_fetch_ssl_fc_session_key(const struct arg *args, struct sample *smp, const char *kw, void *private)
8750{
8751 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8752 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
8753 SSL_SESSION *ssl_sess;
Willy Tarreau83061a82018-07-13 11:56:34 +02008754 struct buffer *data;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008755 struct ssl_sock_ctx *ctx;
Patrick Hemmere0275472018-04-28 19:15:51 -04008756
8757 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8758 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008759 ctx = conn->xprt_ctx;
Patrick Hemmere0275472018-04-28 19:15:51 -04008760
Olivier Houchard66ab4982019-02-26 18:37:15 +01008761 ssl_sess = SSL_get_session(ctx->ssl);
Patrick Hemmere0275472018-04-28 19:15:51 -04008762 if (!ssl_sess)
8763 return 0;
8764
8765 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008766 data->data = SSL_SESSION_get_master_key(ssl_sess,
8767 (unsigned char *) data->area,
8768 data->size);
8769 if (!data->data)
Patrick Hemmere0275472018-04-28 19:15:51 -04008770 return 0;
8771
8772 smp->flags = 0;
8773 smp->data.type = SMP_T_BIN;
8774 smp->data.u.str = *data;
8775
8776 return 1;
8777}
8778#endif
8779
Patrick Hemmer41966772018-04-28 19:15:48 -04008780#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emeric Brunfe68f682012-10-16 14:59:28 +02008781static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008782smp_fetch_ssl_fc_sni(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02008783{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008784 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008785 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008786
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01008787 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008788 smp->data.type = SMP_T_STR;
Willy Tarreau7875d092012-09-10 08:20:03 +02008789
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008790 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008791 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8792 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008793 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008794
Olivier Houchard66ab4982019-02-26 18:37:15 +01008795 smp->data.u.str.area = (char *)SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008796 if (!smp->data.u.str.area)
Willy Tarreau3e394c92012-09-14 23:56:58 +02008797 return 0;
8798
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008799 smp->data.u.str.data = strlen(smp->data.u.str.area);
Willy Tarreau7875d092012-09-10 08:20:03 +02008800 return 1;
Willy Tarreau7875d092012-09-10 08:20:03 +02008801}
Patrick Hemmer41966772018-04-28 19:15:48 -04008802#endif
Willy Tarreau7875d092012-09-10 08:20:03 +02008803
David Sc1ad52e2014-04-08 18:48:47 -04008804static int
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008805smp_fetch_ssl_fc_cl_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
8806{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008807 struct connection *conn;
8808 struct ssl_capture *capture;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008809 struct ssl_sock_ctx *ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008810
8811 conn = objt_conn(smp->sess->origin);
8812 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8813 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008814 ctx = conn->xprt_ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008815
Olivier Houchard66ab4982019-02-26 18:37:15 +01008816 capture = SSL_get_ex_data(ctx->ssl, ssl_capture_ptr_index);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008817 if (!capture)
8818 return 0;
8819
8820 smp->flags = SMP_F_CONST;
8821 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008822 smp->data.u.str.area = capture->ciphersuite;
8823 smp->data.u.str.data = capture->ciphersuite_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008824 return 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008825}
8826
8827static int
8828smp_fetch_ssl_fc_cl_hex(const struct arg *args, struct sample *smp, const char *kw, void *private)
8829{
Willy Tarreau83061a82018-07-13 11:56:34 +02008830 struct buffer *data;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008831
8832 if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
8833 return 0;
8834
8835 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008836 dump_binary(data, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008837 smp->data.type = SMP_T_BIN;
8838 smp->data.u.str = *data;
8839 return 1;
8840}
8841
8842static int
8843smp_fetch_ssl_fc_cl_xxh64(const struct arg *args, struct sample *smp, const char *kw, void *private)
8844{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008845 struct connection *conn;
8846 struct ssl_capture *capture;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008847 struct ssl_sock_ctx *ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008848
8849 conn = objt_conn(smp->sess->origin);
8850 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8851 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008852 ctx = conn->xprt_ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008853
Olivier Houchard66ab4982019-02-26 18:37:15 +01008854 capture = SSL_get_ex_data(ctx->ssl, ssl_capture_ptr_index);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008855 if (!capture)
8856 return 0;
8857
8858 smp->data.type = SMP_T_SINT;
8859 smp->data.u.sint = capture->xxh64;
8860 return 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008861}
8862
8863static int
8864smp_fetch_ssl_fc_cl_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
8865{
Willy Tarreau5db847a2019-05-09 14:13:35 +02008866#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL)
Willy Tarreau83061a82018-07-13 11:56:34 +02008867 struct buffer *data;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008868 int i;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008869
8870 if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
8871 return 0;
8872
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008873 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008874 for (i = 0; i + 1 < smp->data.u.str.data; i += 2) {
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02008875 const char *str;
8876 const SSL_CIPHER *cipher;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008877 const unsigned char *bin = (const unsigned char *) smp->data.u.str.area + i;
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02008878 uint16_t id = (bin[0] << 8) | bin[1];
8879#if defined(OPENSSL_IS_BORINGSSL)
8880 cipher = SSL_get_cipher_by_value(id);
8881#else
Willy Tarreaub7290772018-10-15 11:01:59 +02008882 struct connection *conn = __objt_conn(smp->sess->origin);
Olivier Houchard66ab4982019-02-26 18:37:15 +01008883 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
8884 cipher = SSL_CIPHER_find(ctx->ssl, bin);
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02008885#endif
8886 str = SSL_CIPHER_get_name(cipher);
8887 if (!str || strcmp(str, "(NONE)") == 0)
8888 chunk_appendf(data, "%sUNKNOWN(%04x)", i == 0 ? "" : ",", id);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008889 else
8890 chunk_appendf(data, "%s%s", i == 0 ? "" : ",", str);
8891 }
8892 smp->data.type = SMP_T_STR;
8893 smp->data.u.str = *data;
8894 return 1;
8895#else
8896 return smp_fetch_ssl_fc_cl_xxh64(args, smp, kw, private);
8897#endif
8898}
8899
Willy Tarreau9a1ab082019-05-09 13:26:41 +02008900#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01008901static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008902smp_fetch_ssl_fc_unique_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
David Sc1ad52e2014-04-08 18:48:47 -04008903{
Emeric Bruneb8def92018-02-19 15:59:48 +01008904 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
8905 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
David Sc1ad52e2014-04-08 18:48:47 -04008906 int finished_len;
Willy Tarreau83061a82018-07-13 11:56:34 +02008907 struct buffer *finished_trash;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008908 struct ssl_sock_ctx *ctx;
David Sc1ad52e2014-04-08 18:48:47 -04008909
8910 smp->flags = 0;
David Sc1ad52e2014-04-08 18:48:47 -04008911 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
8912 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01008913 ctx = conn->xprt_ctx;
David Sc1ad52e2014-04-08 18:48:47 -04008914
Willy Tarreau911db9b2020-01-23 16:27:54 +01008915 if (conn->flags & CO_FL_WAIT_XPRT) {
David Sc1ad52e2014-04-08 18:48:47 -04008916 smp->flags |= SMP_F_MAY_CHANGE;
8917 return 0;
8918 }
8919
8920 finished_trash = get_trash_chunk();
Olivier Houchard66ab4982019-02-26 18:37:15 +01008921 if (!SSL_session_reused(ctx->ssl))
8922 finished_len = SSL_get_peer_finished(ctx->ssl,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008923 finished_trash->area,
8924 finished_trash->size);
David Sc1ad52e2014-04-08 18:48:47 -04008925 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01008926 finished_len = SSL_get_finished(ctx->ssl,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008927 finished_trash->area,
8928 finished_trash->size);
David Sc1ad52e2014-04-08 18:48:47 -04008929
8930 if (!finished_len)
8931 return 0;
8932
Willy Tarreau843b7cb2018-07-13 10:54:26 +02008933 finished_trash->data = finished_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02008934 smp->data.u.str = *finished_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008935 smp->data.type = SMP_T_BIN;
David Sc1ad52e2014-04-08 18:48:47 -04008936
8937 return 1;
David Sc1ad52e2014-04-08 18:48:47 -04008938}
Patrick Hemmer41966772018-04-28 19:15:48 -04008939#endif
David Sc1ad52e2014-04-08 18:48:47 -04008940
Emeric Brun2525b6b2012-10-18 15:59:43 +02008941/* integer, returns the first verify error in CA chain of client certificate chain. */
Emeric Brunf282a812012-09-21 15:27:54 +02008942static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008943smp_fetch_ssl_c_ca_err(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunf282a812012-09-21 15:27:54 +02008944{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008945 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008946 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008947
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008948 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008949 if (!conn || conn->xprt != &ssl_sock)
8950 return 0;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008951 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008952
Willy Tarreau911db9b2020-01-23 16:27:54 +01008953 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunf282a812012-09-21 15:27:54 +02008954 smp->flags = SMP_F_MAY_CHANGE;
8955 return 0;
8956 }
8957
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008958 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008959 smp->data.u.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02008960 smp->flags = 0;
8961
8962 return 1;
8963}
8964
Emeric Brun2525b6b2012-10-18 15:59:43 +02008965/* integer, returns the depth of the first verify error in CA chain of client certificate chain. */
Emeric Brunf282a812012-09-21 15:27:54 +02008966static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008967smp_fetch_ssl_c_ca_err_depth(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunf282a812012-09-21 15:27:54 +02008968{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008969 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008970 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008971
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008972 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008973 if (!conn || conn->xprt != &ssl_sock)
Emeric Brunf282a812012-09-21 15:27:54 +02008974 return 0;
8975
Willy Tarreau911db9b2020-01-23 16:27:54 +01008976 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunf282a812012-09-21 15:27:54 +02008977 smp->flags = SMP_F_MAY_CHANGE;
8978 return 0;
8979 }
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008980 ctx = conn->xprt_ctx;
Emeric Brunf282a812012-09-21 15:27:54 +02008981
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02008982 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008983 smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02008984 smp->flags = 0;
8985
8986 return 1;
8987}
8988
Emeric Brun2525b6b2012-10-18 15:59:43 +02008989/* integer, returns the first verify error on client certificate */
Emeric Brunf282a812012-09-21 15:27:54 +02008990static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02008991smp_fetch_ssl_c_err(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunf282a812012-09-21 15:27:54 +02008992{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008993 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01008994 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008995
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02008996 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02008997 if (!conn || conn->xprt != &ssl_sock)
8998 return 0;
8999
Willy Tarreau911db9b2020-01-23 16:27:54 +01009000 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunf282a812012-09-21 15:27:54 +02009001 smp->flags = SMP_F_MAY_CHANGE;
9002 return 0;
9003 }
9004
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01009005 ctx = conn->xprt_ctx;
9006
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02009007 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01009008 smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02009009 smp->flags = 0;
9010
9011 return 1;
9012}
9013
Emeric Brun2525b6b2012-10-18 15:59:43 +02009014/* integer, returns the verify result on client cert */
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009015static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02009016smp_fetch_ssl_c_verify(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009017{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02009018 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01009019 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02009020
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02009021 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02009022 if (!conn || conn->xprt != &ssl_sock)
9023 return 0;
9024
Willy Tarreau911db9b2020-01-23 16:27:54 +01009025 if (conn->flags & CO_FL_WAIT_XPRT) {
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009026 smp->flags = SMP_F_MAY_CHANGE;
9027 return 0;
9028 }
9029
Willy Tarreaub363a1f2013-10-01 10:45:07 +02009030 if (!conn->xprt_ctx)
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009031 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01009032 ctx = conn->xprt_ctx;
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009033
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02009034 smp->data.type = SMP_T_SINT;
Olivier Houchard66ab4982019-02-26 18:37:15 +01009035 smp->data.u.sint = (long long int)SSL_get_verify_result(ctx->ssl);
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02009036 smp->flags = 0;
9037
9038 return 1;
9039}
9040
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009041/* for ca-file and ca-verify-file */
9042static int ssl_bind_parse_ca_file_common(char **args, int cur_arg, char **ca_file_p, char **err)
Emeric Brund94b3fe2012-09-20 18:23:56 +02009043{
9044 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009045 memprintf(err, "'%s' : missing CAfile path", args[cur_arg]);
Emeric Brund94b3fe2012-09-20 18:23:56 +02009046 return ERR_ALERT | ERR_FATAL;
9047 }
9048
Willy Tarreauef934602016-12-22 23:12:01 +01009049 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009050 memprintf(ca_file_p, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02009051 else
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009052 memprintf(ca_file_p, "%s", args[cur_arg + 1]);
Emeric Brunc8e8d122012-10-02 18:42:10 +02009053
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009054 if (!ssl_store_load_locations_file(*ca_file_p)) {
9055 memprintf(err, "'%s' : unable to load %s", args[cur_arg], *ca_file_p);
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +02009056 return ERR_ALERT | ERR_FATAL;
9057 }
Emeric Brund94b3fe2012-09-20 18:23:56 +02009058 return 0;
9059}
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009060
9061/* parse the "ca-file" bind keyword */
9062static int ssl_bind_parse_ca_file(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9063{
9064 return ssl_bind_parse_ca_file_common(args, cur_arg, &conf->ca_file, err);
9065}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009066static int bind_parse_ca_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9067{
9068 return ssl_bind_parse_ca_file(args, cur_arg, px, &conf->ssl_conf, err);
9069}
Emeric Brund94b3fe2012-09-20 18:23:56 +02009070
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +01009071/* parse the "ca-verify-file" bind keyword */
9072static int ssl_bind_parse_ca_verify_file(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9073{
9074 return ssl_bind_parse_ca_file_common(args, cur_arg, &conf->ca_verify_file, err);
9075}
9076static int bind_parse_ca_verify_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9077{
9078 return ssl_bind_parse_ca_verify_file(args, cur_arg, px, &conf->ssl_conf, err);
9079}
9080
Christopher Faulet31af49d2015-06-09 17:29:50 +02009081/* parse the "ca-sign-file" bind keyword */
9082static int bind_parse_ca_sign_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9083{
9084 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009085 memprintf(err, "'%s' : missing CAfile path", args[cur_arg]);
Christopher Faulet31af49d2015-06-09 17:29:50 +02009086 return ERR_ALERT | ERR_FATAL;
9087 }
9088
Willy Tarreauef934602016-12-22 23:12:01 +01009089 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
9090 memprintf(&conf->ca_sign_file, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Christopher Faulet31af49d2015-06-09 17:29:50 +02009091 else
9092 memprintf(&conf->ca_sign_file, "%s", args[cur_arg + 1]);
9093
9094 return 0;
9095}
9096
Bertrand Jacquinff13c062016-11-13 16:37:11 +00009097/* parse the "ca-sign-pass" bind keyword */
Christopher Faulet31af49d2015-06-09 17:29:50 +02009098static int bind_parse_ca_sign_pass(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9099{
9100 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009101 memprintf(err, "'%s' : missing CAkey password", args[cur_arg]);
Christopher Faulet31af49d2015-06-09 17:29:50 +02009102 return ERR_ALERT | ERR_FATAL;
9103 }
9104 memprintf(&conf->ca_sign_pass, "%s", args[cur_arg + 1]);
9105 return 0;
9106}
9107
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009108/* parse the "ciphers" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009109static int ssl_bind_parse_ciphers(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009110{
9111 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02009112 memprintf(err, "'%s' : missing cipher suite", args[cur_arg]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009113 return ERR_ALERT | ERR_FATAL;
9114 }
9115
Emeric Brun76d88952012-10-05 15:47:31 +02009116 free(conf->ciphers);
Willy Tarreau4348fad2012-09-20 16:48:07 +02009117 conf->ciphers = strdup(args[cur_arg + 1]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009118 return 0;
9119}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009120static int bind_parse_ciphers(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9121{
9122 return ssl_bind_parse_ciphers(args, cur_arg, px, &conf->ssl_conf, err);
9123}
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009124
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009125#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009126/* parse the "ciphersuites" bind keyword */
9127static int ssl_bind_parse_ciphersuites(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9128{
9129 if (!*args[cur_arg + 1]) {
9130 memprintf(err, "'%s' : missing cipher suite", args[cur_arg]);
9131 return ERR_ALERT | ERR_FATAL;
9132 }
9133
9134 free(conf->ciphersuites);
9135 conf->ciphersuites = strdup(args[cur_arg + 1]);
9136 return 0;
9137}
9138static int bind_parse_ciphersuites(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9139{
9140 return ssl_bind_parse_ciphersuites(args, cur_arg, px, &conf->ssl_conf, err);
9141}
9142#endif
9143
Willy Tarreaubbc91962019-10-16 16:42:19 +02009144/* parse the "crt" bind keyword. Returns a set of ERR_* flags possibly with an error in <err>. */
Willy Tarreau4348fad2012-09-20 16:48:07 +02009145static int bind_parse_crt(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009146{
Willy Tarreau38011032013-08-13 16:59:39 +02009147 char path[MAXPATHLEN];
Willy Tarreaub75d6922014-04-14 18:05:41 +02009148
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009149 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02009150 memprintf(err, "'%s' : missing certificate location", args[cur_arg]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009151 return ERR_ALERT | ERR_FATAL;
9152 }
9153
Willy Tarreauef934602016-12-22 23:12:01 +01009154 if ((*args[cur_arg + 1] != '/' ) && global_ssl.crt_base) {
9155 if ((strlen(global_ssl.crt_base) + 1 + strlen(args[cur_arg + 1]) + 1) > MAXPATHLEN) {
Emeric Brunc8e8d122012-10-02 18:42:10 +02009156 memprintf(err, "'%s' : path too long", args[cur_arg]);
9157 return ERR_ALERT | ERR_FATAL;
9158 }
Willy Tarreauef934602016-12-22 23:12:01 +01009159 snprintf(path, sizeof(path), "%s/%s", global_ssl.crt_base, args[cur_arg + 1]);
Willy Tarreaubbc91962019-10-16 16:42:19 +02009160 return ssl_sock_load_cert(path, conf, err);
Emeric Brunc8e8d122012-10-02 18:42:10 +02009161 }
9162
Willy Tarreaubbc91962019-10-16 16:42:19 +02009163 return ssl_sock_load_cert(args[cur_arg + 1], conf, err);
Emeric Brund94b3fe2012-09-20 18:23:56 +02009164}
9165
Willy Tarreaubbc91962019-10-16 16:42:19 +02009166/* parse the "crt-list" bind keyword. Returns a set of ERR_* flags possibly with an error in <err>. */
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01009167static int bind_parse_crt_list(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9168{
Willy Tarreaubbc91962019-10-16 16:42:19 +02009169 int err_code;
9170
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01009171 if (!*args[cur_arg + 1]) {
9172 memprintf(err, "'%s' : missing certificate location", args[cur_arg]);
9173 return ERR_ALERT | ERR_FATAL;
9174 }
9175
William Lallemand6be66ec2020-03-06 22:26:32 +01009176 err_code = ssl_sock_load_cert_list_file(args[cur_arg + 1], 0, conf, px, err);
Willy Tarreaubbc91962019-10-16 16:42:19 +02009177 if (err_code)
Willy Tarreauad1731d2013-04-02 17:35:58 +02009178 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01009179
Willy Tarreaubbc91962019-10-16 16:42:19 +02009180 return err_code;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01009181}
9182
Emeric Brunfb510ea2012-10-05 12:00:26 +02009183/* parse the "crl-file" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009184static int ssl_bind_parse_crl_file(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Emeric Brund94b3fe2012-09-20 18:23:56 +02009185{
Emeric Brun051cdab2012-10-02 19:25:50 +02009186#ifndef X509_V_FLAG_CRL_CHECK
Tim Duesterhus93128532019-11-23 23:45:10 +01009187 memprintf(err, "'%s' : library does not support CRL verify", args[cur_arg]);
Emeric Brun051cdab2012-10-02 19:25:50 +02009188 return ERR_ALERT | ERR_FATAL;
9189#else
Emeric Brund94b3fe2012-09-20 18:23:56 +02009190 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009191 memprintf(err, "'%s' : missing CRLfile path", args[cur_arg]);
Emeric Brund94b3fe2012-09-20 18:23:56 +02009192 return ERR_ALERT | ERR_FATAL;
9193 }
Emeric Brun2b58d042012-09-20 17:10:03 +02009194
Willy Tarreauef934602016-12-22 23:12:01 +01009195 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
9196 memprintf(&conf->crl_file, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02009197 else
9198 memprintf(&conf->crl_file, "%s", args[cur_arg + 1]);
Emeric Brunc8e8d122012-10-02 18:42:10 +02009199
Emmanuel Hocdetb270e812019-11-21 19:09:31 +01009200 if (!ssl_store_load_locations_file(conf->crl_file)) {
9201 memprintf(err, "'%s' : unable to load %s", args[cur_arg], conf->crl_file);
9202 return ERR_ALERT | ERR_FATAL;
9203 }
Emeric Brun2b58d042012-09-20 17:10:03 +02009204 return 0;
Emeric Brun051cdab2012-10-02 19:25:50 +02009205#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02009206}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009207static int bind_parse_crl_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9208{
9209 return ssl_bind_parse_crl_file(args, cur_arg, px, &conf->ssl_conf, err);
9210}
Emeric Brun2b58d042012-09-20 17:10:03 +02009211
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01009212/* parse the "curves" bind keyword keyword */
9213static int ssl_bind_parse_curves(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9214{
Lukas Tribusd14b49c2019-11-24 18:20:40 +01009215#if ((HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL) || defined(LIBRESSL_VERSION_NUMBER))
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01009216 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009217 memprintf(err, "'%s' : missing curve suite", args[cur_arg]);
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01009218 return ERR_ALERT | ERR_FATAL;
9219 }
9220 conf->curves = strdup(args[cur_arg + 1]);
9221 return 0;
9222#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009223 memprintf(err, "'%s' : library does not support curve suite", args[cur_arg]);
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01009224 return ERR_ALERT | ERR_FATAL;
9225#endif
9226}
9227static int bind_parse_curves(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9228{
9229 return ssl_bind_parse_curves(args, cur_arg, px, &conf->ssl_conf, err);
9230}
9231
Bertrand Jacquinff13c062016-11-13 16:37:11 +00009232/* parse the "ecdhe" bind keyword keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009233static int ssl_bind_parse_ecdhe(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Emeric Brun2b58d042012-09-20 17:10:03 +02009234{
Willy Tarreau9a1ab082019-05-09 13:26:41 +02009235#if HA_OPENSSL_VERSION_NUMBER < 0x0090800fL
Tim Duesterhus93128532019-11-23 23:45:10 +01009236 memprintf(err, "'%s' : library does not support elliptic curve Diffie-Hellman (too old)", args[cur_arg]);
Emeric Brun2b58d042012-09-20 17:10:03 +02009237 return ERR_ALERT | ERR_FATAL;
9238#elif defined(OPENSSL_NO_ECDH)
Tim Duesterhus93128532019-11-23 23:45:10 +01009239 memprintf(err, "'%s' : library does not support elliptic curve Diffie-Hellman (disabled via OPENSSL_NO_ECDH)", args[cur_arg]);
Emeric Brun2b58d042012-09-20 17:10:03 +02009240 return ERR_ALERT | ERR_FATAL;
9241#else
9242 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009243 memprintf(err, "'%s' : missing named curve", args[cur_arg]);
Emeric Brun2b58d042012-09-20 17:10:03 +02009244 return ERR_ALERT | ERR_FATAL;
9245 }
9246
9247 conf->ecdhe = strdup(args[cur_arg + 1]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009248
9249 return 0;
Emeric Brun2b58d042012-09-20 17:10:03 +02009250#endif
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009251}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009252static int bind_parse_ecdhe(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9253{
9254 return ssl_bind_parse_ecdhe(args, cur_arg, px, &conf->ssl_conf, err);
9255}
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009256
Bertrand Jacquinff13c062016-11-13 16:37:11 +00009257/* parse the "crt-ignore-err" and "ca-ignore-err" bind keywords */
Emeric Brun81c00f02012-09-21 14:31:21 +02009258static int bind_parse_ignore_err(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9259{
9260 int code;
9261 char *p = args[cur_arg + 1];
9262 unsigned long long *ignerr = &conf->crt_ignerr;
9263
9264 if (!*p) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009265 memprintf(err, "'%s' : missing error IDs list", args[cur_arg]);
Emeric Brun81c00f02012-09-21 14:31:21 +02009266 return ERR_ALERT | ERR_FATAL;
9267 }
9268
9269 if (strcmp(args[cur_arg], "ca-ignore-err") == 0)
9270 ignerr = &conf->ca_ignerr;
9271
9272 if (strcmp(p, "all") == 0) {
9273 *ignerr = ~0ULL;
9274 return 0;
9275 }
9276
9277 while (p) {
9278 code = atoi(p);
9279 if ((code <= 0) || (code > 63)) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009280 memprintf(err, "'%s' : ID '%d' out of range (1..63) in error IDs list '%s'",
9281 args[cur_arg], code, args[cur_arg + 1]);
Emeric Brun81c00f02012-09-21 14:31:21 +02009282 return ERR_ALERT | ERR_FATAL;
9283 }
9284 *ignerr |= 1ULL << code;
9285 p = strchr(p, ',');
9286 if (p)
9287 p++;
9288 }
9289
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009290 return 0;
9291}
9292
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009293/* parse tls_method_options "no-xxx" and "force-xxx" */
9294static int parse_tls_method_options(char *arg, struct tls_version_filter *methods, char **err)
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009295{
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009296 uint16_t v;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009297 char *p;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009298 p = strchr(arg, '-');
9299 if (!p)
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009300 goto fail;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009301 p++;
9302 if (!strcmp(p, "sslv3"))
9303 v = CONF_SSLV3;
9304 else if (!strcmp(p, "tlsv10"))
9305 v = CONF_TLSV10;
9306 else if (!strcmp(p, "tlsv11"))
9307 v = CONF_TLSV11;
9308 else if (!strcmp(p, "tlsv12"))
9309 v = CONF_TLSV12;
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +02009310 else if (!strcmp(p, "tlsv13"))
9311 v = CONF_TLSV13;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009312 else
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009313 goto fail;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009314 if (!strncmp(arg, "no-", 3))
9315 methods->flags |= methodVersions[v].flag;
9316 else if (!strncmp(arg, "force-", 6))
9317 methods->min = methods->max = v;
9318 else
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009319 goto fail;
Emeric Brun2d0c4822012-10-02 13:45:20 +02009320 return 0;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009321 fail:
Tim Duesterhus93128532019-11-23 23:45:10 +01009322 memprintf(err, "'%s' : option not implemented", arg);
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009323 return ERR_ALERT | ERR_FATAL;
Emeric Brun2d0c4822012-10-02 13:45:20 +02009324}
9325
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009326static int bind_parse_tls_method_options(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009327{
Emmanuel Hocdet43664762017-08-09 18:26:20 +02009328 return parse_tls_method_options(args[cur_arg], &conf->ssl_conf.ssl_methods, err);
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009329}
9330
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009331static int srv_parse_tls_method_options(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009332{
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009333 return parse_tls_method_options(args[*cur_arg], &newsrv->ssl_ctx.methods, err);
9334}
9335
9336/* parse tls_method min/max: "ssl-min-ver" and "ssl-max-ver" */
9337static int parse_tls_method_minmax(char **args, int cur_arg, struct tls_version_filter *methods, char **err)
9338{
9339 uint16_t i, v = 0;
9340 char *argv = args[cur_arg + 1];
9341 if (!*argv) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009342 memprintf(err, "'%s' : missing the ssl/tls version", args[cur_arg]);
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009343 return ERR_ALERT | ERR_FATAL;
9344 }
9345 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
9346 if (!strcmp(argv, methodVersions[i].name))
9347 v = i;
9348 if (!v) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009349 memprintf(err, "'%s' : unknown ssl/tls version", args[cur_arg + 1]);
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009350 return ERR_ALERT | ERR_FATAL;
9351 }
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009352 if (!strcmp("ssl-min-ver", args[cur_arg]))
9353 methods->min = v;
9354 else if (!strcmp("ssl-max-ver", args[cur_arg]))
9355 methods->max = v;
9356 else {
Tim Duesterhus93128532019-11-23 23:45:10 +01009357 memprintf(err, "'%s' : option not implemented", args[cur_arg]);
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009358 return ERR_ALERT | ERR_FATAL;
9359 }
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009360 return 0;
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009361}
Emeric Brun2cb7ae52012-10-05 14:14:21 +02009362
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02009363static int ssl_bind_parse_tls_method_minmax(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9364{
Willy Tarreau9a1ab082019-05-09 13:26:41 +02009365#if (HA_OPENSSL_VERSION_NUMBER < 0x10101000L) && !defined(OPENSSL_IS_BORINGSSL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01009366 ha_warning("crt-list: ssl-min-ver and ssl-max-ver are not supported with this Openssl version (skipped).\n");
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02009367#endif
9368 return parse_tls_method_minmax(args, cur_arg, &conf->ssl_methods, err);
9369}
9370
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009371static int bind_parse_tls_method_minmax(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9372{
Emmanuel Hocdet43664762017-08-09 18:26:20 +02009373 return parse_tls_method_minmax(args, cur_arg, &conf->ssl_conf.ssl_methods, err);
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009374}
9375
9376static int srv_parse_tls_method_minmax(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9377{
9378 return parse_tls_method_minmax(args, *cur_arg, &newsrv->ssl_ctx.methods, err);
9379}
9380
Emeric Brun2d0c4822012-10-02 13:45:20 +02009381/* parse the "no-tls-tickets" bind keyword */
Emmanuel Hocdet4608ed92017-01-20 13:06:27 +01009382static int bind_parse_no_tls_tickets(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Emeric Brun2d0c4822012-10-02 13:45:20 +02009383{
Emeric Brun89675492012-10-05 13:48:26 +02009384 conf->ssl_options |= BC_SSL_O_NO_TLS_TICKETS;
Emeric Brun81c00f02012-09-21 14:31:21 +02009385 return 0;
9386}
Emeric Brun2d0c4822012-10-02 13:45:20 +02009387
Olivier Houchardc2aae742017-09-22 18:26:28 +02009388/* parse the "allow-0rtt" bind keyword */
9389static int ssl_bind_parse_allow_0rtt(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9390{
9391 conf->early_data = 1;
9392 return 0;
9393}
9394
9395static int bind_parse_allow_0rtt(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9396{
Olivier Houchard9679ac92017-10-27 14:58:08 +02009397 conf->ssl_conf.early_data = 1;
Olivier Houchardc2aae742017-09-22 18:26:28 +02009398 return 0;
9399}
9400
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009401/* parse the "npn" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009402static int ssl_bind_parse_npn(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009403{
Bernard Spil13c53f82018-02-15 13:34:58 +01009404#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009405 char *p1, *p2;
9406
9407 if (!*args[cur_arg + 1]) {
9408 memprintf(err, "'%s' : missing the comma-delimited NPN protocol suite", args[cur_arg]);
9409 return ERR_ALERT | ERR_FATAL;
9410 }
9411
9412 free(conf->npn_str);
9413
Willy Tarreau3724da12016-02-12 17:11:12 +01009414 /* the NPN string is built as a suite of (<len> <name>)*,
9415 * so we reuse each comma to store the next <len> and need
9416 * one more for the end of the string.
9417 */
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009418 conf->npn_len = strlen(args[cur_arg + 1]) + 1;
Willy Tarreau3724da12016-02-12 17:11:12 +01009419 conf->npn_str = calloc(1, conf->npn_len + 1);
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009420 memcpy(conf->npn_str + 1, args[cur_arg + 1], conf->npn_len);
9421
9422 /* replace commas with the name length */
9423 p1 = conf->npn_str;
9424 p2 = p1 + 1;
9425 while (1) {
9426 p2 = memchr(p1 + 1, ',', conf->npn_str + conf->npn_len - (p1 + 1));
9427 if (!p2)
9428 p2 = p1 + 1 + strlen(p1 + 1);
9429
9430 if (p2 - (p1 + 1) > 255) {
9431 *p2 = '\0';
9432 memprintf(err, "'%s' : NPN protocol name too long : '%s'", args[cur_arg], p1 + 1);
9433 return ERR_ALERT | ERR_FATAL;
9434 }
9435
9436 *p1 = p2 - (p1 + 1);
9437 p1 = p2;
9438
9439 if (!*p2)
9440 break;
9441
9442 *(p2++) = '\0';
9443 }
9444 return 0;
9445#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009446 memprintf(err, "'%s' : library does not support TLS NPN extension", args[cur_arg]);
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02009447 return ERR_ALERT | ERR_FATAL;
9448#endif
9449}
9450
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009451static int bind_parse_npn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9452{
9453 return ssl_bind_parse_npn(args, cur_arg, px, &conf->ssl_conf, err);
9454}
9455
Willy Tarreauab861d32013-04-02 02:30:41 +02009456/* parse the "alpn" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009457static int ssl_bind_parse_alpn(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Willy Tarreauab861d32013-04-02 02:30:41 +02009458{
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01009459#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02009460 char *p1, *p2;
9461
9462 if (!*args[cur_arg + 1]) {
9463 memprintf(err, "'%s' : missing the comma-delimited ALPN protocol suite", args[cur_arg]);
9464 return ERR_ALERT | ERR_FATAL;
9465 }
9466
9467 free(conf->alpn_str);
9468
Marcoen Hirschbergbef60912016-02-12 17:05:24 +01009469 /* the ALPN string is built as a suite of (<len> <name>)*,
9470 * so we reuse each comma to store the next <len> and need
9471 * one more for the end of the string.
9472 */
Willy Tarreauab861d32013-04-02 02:30:41 +02009473 conf->alpn_len = strlen(args[cur_arg + 1]) + 1;
Marcoen Hirschbergbef60912016-02-12 17:05:24 +01009474 conf->alpn_str = calloc(1, conf->alpn_len + 1);
Willy Tarreauab861d32013-04-02 02:30:41 +02009475 memcpy(conf->alpn_str + 1, args[cur_arg + 1], conf->alpn_len);
9476
9477 /* replace commas with the name length */
9478 p1 = conf->alpn_str;
9479 p2 = p1 + 1;
9480 while (1) {
9481 p2 = memchr(p1 + 1, ',', conf->alpn_str + conf->alpn_len - (p1 + 1));
9482 if (!p2)
9483 p2 = p1 + 1 + strlen(p1 + 1);
9484
9485 if (p2 - (p1 + 1) > 255) {
9486 *p2 = '\0';
9487 memprintf(err, "'%s' : ALPN protocol name too long : '%s'", args[cur_arg], p1 + 1);
9488 return ERR_ALERT | ERR_FATAL;
9489 }
9490
9491 *p1 = p2 - (p1 + 1);
9492 p1 = p2;
9493
9494 if (!*p2)
9495 break;
9496
9497 *(p2++) = '\0';
9498 }
9499 return 0;
9500#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009501 memprintf(err, "'%s' : library does not support TLS ALPN extension", args[cur_arg]);
Willy Tarreauab861d32013-04-02 02:30:41 +02009502 return ERR_ALERT | ERR_FATAL;
9503#endif
9504}
9505
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009506static int bind_parse_alpn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9507{
9508 return ssl_bind_parse_alpn(args, cur_arg, px, &conf->ssl_conf, err);
9509}
9510
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009511/* parse the "ssl" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02009512static int bind_parse_ssl(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009513{
Willy Tarreau71a8c7c2016-12-21 22:04:54 +01009514 conf->xprt = &ssl_sock;
Willy Tarreau4348fad2012-09-20 16:48:07 +02009515 conf->is_ssl = 1;
Emeric Brun76d88952012-10-05 15:47:31 +02009516
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009517 if (global_ssl.listen_default_ciphers && !conf->ssl_conf.ciphers)
9518 conf->ssl_conf.ciphers = strdup(global_ssl.listen_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009519#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009520 if (global_ssl.listen_default_ciphersuites && !conf->ssl_conf.ciphersuites)
9521 conf->ssl_conf.ciphersuites = strdup(global_ssl.listen_default_ciphersuites);
9522#endif
Emmanuel Hocdet4608ed92017-01-20 13:06:27 +01009523 conf->ssl_options |= global_ssl.listen_default_ssloptions;
Emmanuel Hocdet43664762017-08-09 18:26:20 +02009524 conf->ssl_conf.ssl_methods.flags |= global_ssl.listen_default_sslmethods.flags;
9525 if (!conf->ssl_conf.ssl_methods.min)
9526 conf->ssl_conf.ssl_methods.min = global_ssl.listen_default_sslmethods.min;
9527 if (!conf->ssl_conf.ssl_methods.max)
9528 conf->ssl_conf.ssl_methods.max = global_ssl.listen_default_sslmethods.max;
Emeric Brun76d88952012-10-05 15:47:31 +02009529
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009530 return 0;
9531}
9532
Lukas Tribus53ae85c2017-05-04 15:45:40 +00009533/* parse the "prefer-client-ciphers" bind keyword */
9534static int bind_parse_pcc(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9535{
9536 conf->ssl_options |= BC_SSL_O_PREF_CLIE_CIPH;
9537 return 0;
9538}
9539
Christopher Faulet31af49d2015-06-09 17:29:50 +02009540/* parse the "generate-certificates" bind keyword */
9541static int bind_parse_generate_certs(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9542{
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01009543#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Christopher Faulet31af49d2015-06-09 17:29:50 +02009544 conf->generate_certs = 1;
9545#else
9546 memprintf(err, "%sthis version of openssl cannot generate SSL certificates.\n",
9547 err && *err ? *err : "");
9548#endif
9549 return 0;
9550}
9551
Emmanuel Hocdet65623372013-01-24 17:17:15 +01009552/* parse the "strict-sni" bind keyword */
9553static int bind_parse_strict_sni(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9554{
9555 conf->strict_sni = 1;
9556 return 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009557}
9558
9559/* parse the "tls-ticket-keys" bind keyword */
9560static int bind_parse_tls_ticket_keys(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9561{
9562#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
Christopher Faulete566f3d2019-10-21 09:55:49 +02009563 FILE *f = NULL;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009564 int i = 0;
9565 char thisline[LINESIZE];
Christopher Faulete566f3d2019-10-21 09:55:49 +02009566 struct tls_keys_ref *keys_ref = NULL;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009567
9568 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009569 memprintf(err, "'%s' : missing TLS ticket keys file path", args[cur_arg]);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009570 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009571 }
9572
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02009573 keys_ref = tlskeys_ref_lookup(args[cur_arg + 1]);
Willy Tarreau17b4aa12018-07-17 10:05:32 +02009574 if (keys_ref) {
9575 keys_ref->refcount++;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02009576 conf->keys_ref = keys_ref;
9577 return 0;
9578 }
9579
Christopher Faulete566f3d2019-10-21 09:55:49 +02009580 keys_ref = calloc(1, sizeof(*keys_ref));
Emeric Brun09852f72019-01-10 10:51:13 +01009581 if (!keys_ref) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009582 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009583 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01009584 }
9585
Emeric Brun9e754772019-01-10 17:51:55 +01009586 keys_ref->tlskeys = malloc(TLS_TICKETS_NO * sizeof(union tls_sess_key));
Emeric Brun09852f72019-01-10 10:51:13 +01009587 if (!keys_ref->tlskeys) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009588 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009589 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01009590 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009591
9592 if ((f = fopen(args[cur_arg + 1], "r")) == NULL) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009593 memprintf(err, "'%s' : unable to load ssl tickets keys file", args[cur_arg+1]);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009594 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009595 }
9596
Nenad Merdanovic146defa2015-05-09 08:46:00 +02009597 keys_ref->filename = strdup(args[cur_arg + 1]);
Emeric Brun09852f72019-01-10 10:51:13 +01009598 if (!keys_ref->filename) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009599 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009600 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01009601 }
Nenad Merdanovic146defa2015-05-09 08:46:00 +02009602
Emeric Brun9e754772019-01-10 17:51:55 +01009603 keys_ref->key_size_bits = 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009604 while (fgets(thisline, sizeof(thisline), f) != NULL) {
9605 int len = strlen(thisline);
Emeric Brun9e754772019-01-10 17:51:55 +01009606 int dec_size;
9607
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009608 /* Strip newline characters from the end */
9609 if(thisline[len - 1] == '\n')
9610 thisline[--len] = 0;
9611
9612 if(thisline[len - 1] == '\r')
9613 thisline[--len] = 0;
9614
Emeric Brun9e754772019-01-10 17:51:55 +01009615 dec_size = base64dec(thisline, len, (char *) (keys_ref->tlskeys + i % TLS_TICKETS_NO), sizeof(union tls_sess_key));
9616 if (dec_size < 0) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009617 memprintf(err, "'%s' : unable to decode base64 key on line %d", args[cur_arg+1], i + 1);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009618 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009619 }
Emeric Brun9e754772019-01-10 17:51:55 +01009620 else if (!keys_ref->key_size_bits && (dec_size == sizeof(struct tls_sess_key_128))) {
9621 keys_ref->key_size_bits = 128;
9622 }
9623 else if (!keys_ref->key_size_bits && (dec_size == sizeof(struct tls_sess_key_256))) {
9624 keys_ref->key_size_bits = 256;
9625 }
9626 else if (((dec_size != sizeof(struct tls_sess_key_128)) && (dec_size != sizeof(struct tls_sess_key_256)))
9627 || ((dec_size == sizeof(struct tls_sess_key_128) && (keys_ref->key_size_bits != 128)))
9628 || ((dec_size == sizeof(struct tls_sess_key_256) && (keys_ref->key_size_bits != 256)))) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009629 memprintf(err, "'%s' : wrong sized key on line %d", args[cur_arg+1], i + 1);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009630 goto fail;
Emeric Brun9e754772019-01-10 17:51:55 +01009631 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009632 i++;
9633 }
9634
9635 if (i < TLS_TICKETS_NO) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009636 memprintf(err, "'%s' : please supply at least %d keys in the tls-tickets-file", args[cur_arg+1], TLS_TICKETS_NO);
Christopher Faulete566f3d2019-10-21 09:55:49 +02009637 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009638 }
9639
9640 fclose(f);
9641
9642 /* Use penultimate key for encryption, handle when TLS_TICKETS_NO = 1 */
Nenad Merdanovic17891152016-03-25 22:16:57 +01009643 i -= 2;
9644 keys_ref->tls_ticket_enc_index = i < 0 ? 0 : i % TLS_TICKETS_NO;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02009645 keys_ref->unique_id = -1;
Willy Tarreau17b4aa12018-07-17 10:05:32 +02009646 keys_ref->refcount = 1;
Christopher Faulet16f45c82018-02-16 11:23:49 +01009647 HA_RWLOCK_INIT(&keys_ref->lock);
Nenad Merdanovic146defa2015-05-09 08:46:00 +02009648 conf->keys_ref = keys_ref;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009649
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02009650 LIST_ADD(&tlskeys_reference, &keys_ref->list);
9651
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009652 return 0;
Christopher Faulete566f3d2019-10-21 09:55:49 +02009653
9654 fail:
9655 if (f)
9656 fclose(f);
9657 if (keys_ref) {
9658 free(keys_ref->filename);
9659 free(keys_ref->tlskeys);
9660 free(keys_ref);
9661 }
9662 return ERR_ALERT | ERR_FATAL;
9663
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009664#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009665 memprintf(err, "'%s' : TLS ticket callback extension not supported", args[cur_arg]);
Nenad Merdanovic05552d42015-02-27 19:56:49 +01009666 return ERR_ALERT | ERR_FATAL;
9667#endif /* SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB */
Emmanuel Hocdet65623372013-01-24 17:17:15 +01009668}
9669
Emeric Brund94b3fe2012-09-20 18:23:56 +02009670/* parse the "verify" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009671static int ssl_bind_parse_verify(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Emeric Brund94b3fe2012-09-20 18:23:56 +02009672{
9673 if (!*args[cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009674 memprintf(err, "'%s' : missing verify method", args[cur_arg]);
Emeric Brund94b3fe2012-09-20 18:23:56 +02009675 return ERR_ALERT | ERR_FATAL;
9676 }
9677
9678 if (strcmp(args[cur_arg + 1], "none") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01009679 conf->verify = SSL_SOCK_VERIFY_NONE;
Emeric Brund94b3fe2012-09-20 18:23:56 +02009680 else if (strcmp(args[cur_arg + 1], "optional") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01009681 conf->verify = SSL_SOCK_VERIFY_OPTIONAL;
Emeric Brund94b3fe2012-09-20 18:23:56 +02009682 else if (strcmp(args[cur_arg + 1], "required") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01009683 conf->verify = SSL_SOCK_VERIFY_REQUIRED;
Emeric Brund94b3fe2012-09-20 18:23:56 +02009684 else {
Tim Duesterhus93128532019-11-23 23:45:10 +01009685 memprintf(err, "'%s' : unknown verify method '%s', only 'none', 'optional', and 'required' are supported\n",
9686 args[cur_arg], args[cur_arg + 1]);
Emeric Brund94b3fe2012-09-20 18:23:56 +02009687 return ERR_ALERT | ERR_FATAL;
9688 }
9689
9690 return 0;
9691}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009692static int bind_parse_verify(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9693{
9694 return ssl_bind_parse_verify(args, cur_arg, px, &conf->ssl_conf, err);
9695}
Emeric Brund94b3fe2012-09-20 18:23:56 +02009696
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02009697/* parse the "no-ca-names" bind keyword */
9698static int ssl_bind_parse_no_ca_names(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
9699{
9700 conf->no_ca_names = 1;
9701 return 0;
9702}
9703static int bind_parse_no_ca_names(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
9704{
9705 return ssl_bind_parse_no_ca_names(args, cur_arg, px, &conf->ssl_conf, err);
9706}
9707
Willy Tarreau92faadf2012-10-10 23:04:25 +02009708/************** "server" keywords ****************/
9709
Olivier Houchardc7566002018-11-20 23:33:50 +01009710/* parse the "npn" bind keyword */
9711static int srv_parse_npn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9712{
9713#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
9714 char *p1, *p2;
9715
9716 if (!*args[*cur_arg + 1]) {
9717 memprintf(err, "'%s' : missing the comma-delimited NPN protocol suite", args[*cur_arg]);
9718 return ERR_ALERT | ERR_FATAL;
9719 }
9720
9721 free(newsrv->ssl_ctx.npn_str);
9722
9723 /* the NPN string is built as a suite of (<len> <name>)*,
9724 * so we reuse each comma to store the next <len> and need
9725 * one more for the end of the string.
9726 */
9727 newsrv->ssl_ctx.npn_len = strlen(args[*cur_arg + 1]) + 1;
9728 newsrv->ssl_ctx.npn_str = calloc(1, newsrv->ssl_ctx.npn_len + 1);
9729 memcpy(newsrv->ssl_ctx.npn_str + 1, args[*cur_arg + 1],
9730 newsrv->ssl_ctx.npn_len);
9731
9732 /* replace commas with the name length */
9733 p1 = newsrv->ssl_ctx.npn_str;
9734 p2 = p1 + 1;
9735 while (1) {
9736 p2 = memchr(p1 + 1, ',', newsrv->ssl_ctx.npn_str +
9737 newsrv->ssl_ctx.npn_len - (p1 + 1));
9738 if (!p2)
9739 p2 = p1 + 1 + strlen(p1 + 1);
9740
9741 if (p2 - (p1 + 1) > 255) {
9742 *p2 = '\0';
9743 memprintf(err, "'%s' : NPN protocol name too long : '%s'", args[*cur_arg], p1 + 1);
9744 return ERR_ALERT | ERR_FATAL;
9745 }
9746
9747 *p1 = p2 - (p1 + 1);
9748 p1 = p2;
9749
9750 if (!*p2)
9751 break;
9752
9753 *(p2++) = '\0';
9754 }
9755 return 0;
9756#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009757 memprintf(err, "'%s' : library does not support TLS NPN extension", args[*cur_arg]);
Olivier Houchardc7566002018-11-20 23:33:50 +01009758 return ERR_ALERT | ERR_FATAL;
9759#endif
9760}
9761
Olivier Houchard92150142018-12-21 19:47:01 +01009762/* parse the "alpn" or the "check-alpn" server keyword */
Olivier Houchardc7566002018-11-20 23:33:50 +01009763static int srv_parse_alpn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9764{
9765#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
9766 char *p1, *p2;
Olivier Houchard92150142018-12-21 19:47:01 +01009767 char **alpn_str;
9768 int *alpn_len;
Olivier Houchardc7566002018-11-20 23:33:50 +01009769
Olivier Houchard92150142018-12-21 19:47:01 +01009770 if (*args[*cur_arg] == 'c') {
9771 alpn_str = &newsrv->check.alpn_str;
9772 alpn_len = &newsrv->check.alpn_len;
9773 } else {
9774 alpn_str = &newsrv->ssl_ctx.alpn_str;
9775 alpn_len = &newsrv->ssl_ctx.alpn_len;
9776
9777 }
Olivier Houchardc7566002018-11-20 23:33:50 +01009778 if (!*args[*cur_arg + 1]) {
9779 memprintf(err, "'%s' : missing the comma-delimited ALPN protocol suite", args[*cur_arg]);
9780 return ERR_ALERT | ERR_FATAL;
9781 }
9782
Olivier Houchard92150142018-12-21 19:47:01 +01009783 free(*alpn_str);
Olivier Houchardc7566002018-11-20 23:33:50 +01009784
9785 /* the ALPN string is built as a suite of (<len> <name>)*,
9786 * so we reuse each comma to store the next <len> and need
9787 * one more for the end of the string.
9788 */
Olivier Houchard92150142018-12-21 19:47:01 +01009789 *alpn_len = strlen(args[*cur_arg + 1]) + 1;
9790 *alpn_str = calloc(1, *alpn_len + 1);
9791 memcpy(*alpn_str + 1, args[*cur_arg + 1], *alpn_len);
Olivier Houchardc7566002018-11-20 23:33:50 +01009792
9793 /* replace commas with the name length */
Olivier Houchard92150142018-12-21 19:47:01 +01009794 p1 = *alpn_str;
Olivier Houchardc7566002018-11-20 23:33:50 +01009795 p2 = p1 + 1;
9796 while (1) {
Olivier Houchard92150142018-12-21 19:47:01 +01009797 p2 = memchr(p1 + 1, ',', *alpn_str + *alpn_len - (p1 + 1));
Olivier Houchardc7566002018-11-20 23:33:50 +01009798 if (!p2)
9799 p2 = p1 + 1 + strlen(p1 + 1);
9800
9801 if (p2 - (p1 + 1) > 255) {
9802 *p2 = '\0';
9803 memprintf(err, "'%s' : ALPN protocol name too long : '%s'", args[*cur_arg], p1 + 1);
9804 return ERR_ALERT | ERR_FATAL;
9805 }
9806
9807 *p1 = p2 - (p1 + 1);
9808 p1 = p2;
9809
9810 if (!*p2)
9811 break;
9812
9813 *(p2++) = '\0';
9814 }
9815 return 0;
9816#else
Tim Duesterhus93128532019-11-23 23:45:10 +01009817 memprintf(err, "'%s' : library does not support TLS ALPN extension", args[*cur_arg]);
Olivier Houchardc7566002018-11-20 23:33:50 +01009818 return ERR_ALERT | ERR_FATAL;
9819#endif
9820}
9821
Emeric Brunef42d922012-10-11 16:11:36 +02009822/* parse the "ca-file" server keyword */
9823static int srv_parse_ca_file(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9824{
9825 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009826 memprintf(err, "'%s' : missing CAfile path", args[*cur_arg]);
Emeric Brunef42d922012-10-11 16:11:36 +02009827 return ERR_ALERT | ERR_FATAL;
9828 }
9829
Willy Tarreauef934602016-12-22 23:12:01 +01009830 if ((*args[*cur_arg + 1] != '/') && global_ssl.ca_base)
9831 memprintf(&newsrv->ssl_ctx.ca_file, "%s/%s", global_ssl.ca_base, args[*cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02009832 else
9833 memprintf(&newsrv->ssl_ctx.ca_file, "%s", args[*cur_arg + 1]);
9834
Emmanuel Hocdetd4f9a602019-10-24 11:32:47 +02009835 if (!ssl_store_load_locations_file(newsrv->ssl_ctx.ca_file)) {
9836 memprintf(err, "'%s' : unable to load %s", args[*cur_arg], newsrv->ssl_ctx.ca_file);
9837 return ERR_ALERT | ERR_FATAL;
9838 }
Emeric Brunef42d922012-10-11 16:11:36 +02009839 return 0;
9840}
9841
Olivier Houchard9130a962017-10-17 17:33:43 +02009842/* parse the "check-sni" server keyword */
9843static int srv_parse_check_sni(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9844{
9845 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009846 memprintf(err, "'%s' : missing SNI", args[*cur_arg]);
Olivier Houchard9130a962017-10-17 17:33:43 +02009847 return ERR_ALERT | ERR_FATAL;
9848 }
9849
9850 newsrv->check.sni = strdup(args[*cur_arg + 1]);
9851 if (!newsrv->check.sni) {
9852 memprintf(err, "'%s' : failed to allocate memory", args[*cur_arg]);
9853 return ERR_ALERT | ERR_FATAL;
9854 }
9855 return 0;
9856
9857}
9858
Willy Tarreau92faadf2012-10-10 23:04:25 +02009859/* parse the "check-ssl" server keyword */
9860static int srv_parse_check_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9861{
9862 newsrv->check.use_ssl = 1;
Willy Tarreauef934602016-12-22 23:12:01 +01009863 if (global_ssl.connect_default_ciphers && !newsrv->ssl_ctx.ciphers)
9864 newsrv->ssl_ctx.ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009865#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009866 if (global_ssl.connect_default_ciphersuites && !newsrv->ssl_ctx.ciphersuites)
9867 newsrv->ssl_ctx.ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
9868#endif
Willy Tarreauef934602016-12-22 23:12:01 +01009869 newsrv->ssl_ctx.options |= global_ssl.connect_default_ssloptions;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009870 newsrv->ssl_ctx.methods.flags |= global_ssl.connect_default_sslmethods.flags;
9871 if (!newsrv->ssl_ctx.methods.min)
9872 newsrv->ssl_ctx.methods.min = global_ssl.connect_default_sslmethods.min;
9873 if (!newsrv->ssl_ctx.methods.max)
9874 newsrv->ssl_ctx.methods.max = global_ssl.connect_default_sslmethods.max;
9875
Willy Tarreau92faadf2012-10-10 23:04:25 +02009876 return 0;
9877}
9878
9879/* parse the "ciphers" server keyword */
9880static int srv_parse_ciphers(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9881{
9882 if (!*args[*cur_arg + 1]) {
9883 memprintf(err, "'%s' : missing cipher suite", args[*cur_arg]);
9884 return ERR_ALERT | ERR_FATAL;
9885 }
9886
9887 free(newsrv->ssl_ctx.ciphers);
9888 newsrv->ssl_ctx.ciphers = strdup(args[*cur_arg + 1]);
9889 return 0;
9890}
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009891
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009892#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009893/* parse the "ciphersuites" server keyword */
9894static int srv_parse_ciphersuites(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9895{
9896 if (!*args[*cur_arg + 1]) {
9897 memprintf(err, "'%s' : missing cipher suite", args[*cur_arg]);
9898 return ERR_ALERT | ERR_FATAL;
9899 }
9900
9901 free(newsrv->ssl_ctx.ciphersuites);
9902 newsrv->ssl_ctx.ciphersuites = strdup(args[*cur_arg + 1]);
9903 return 0;
9904}
9905#endif
Willy Tarreau92faadf2012-10-10 23:04:25 +02009906
Emeric Brunef42d922012-10-11 16:11:36 +02009907/* parse the "crl-file" server keyword */
9908static int srv_parse_crl_file(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9909{
9910#ifndef X509_V_FLAG_CRL_CHECK
Tim Duesterhus93128532019-11-23 23:45:10 +01009911 memprintf(err, "'%s' : library does not support CRL verify", args[*cur_arg]);
Emeric Brunef42d922012-10-11 16:11:36 +02009912 return ERR_ALERT | ERR_FATAL;
9913#else
9914 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009915 memprintf(err, "'%s' : missing CRLfile path", args[*cur_arg]);
Emeric Brunef42d922012-10-11 16:11:36 +02009916 return ERR_ALERT | ERR_FATAL;
9917 }
9918
Willy Tarreauef934602016-12-22 23:12:01 +01009919 if ((*args[*cur_arg + 1] != '/') && global_ssl.ca_base)
9920 memprintf(&newsrv->ssl_ctx.crl_file, "%s/%s", global_ssl.ca_base, args[*cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02009921 else
9922 memprintf(&newsrv->ssl_ctx.crl_file, "%s", args[*cur_arg + 1]);
9923
Emmanuel Hocdetb270e812019-11-21 19:09:31 +01009924 if (!ssl_store_load_locations_file(newsrv->ssl_ctx.crl_file)) {
9925 memprintf(err, "'%s' : unable to load %s", args[*cur_arg], newsrv->ssl_ctx.crl_file);
9926 return ERR_ALERT | ERR_FATAL;
9927 }
Emeric Brunef42d922012-10-11 16:11:36 +02009928 return 0;
9929#endif
9930}
9931
Emeric Bruna7aa3092012-10-26 12:58:00 +02009932/* parse the "crt" server keyword */
9933static int srv_parse_crt(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9934{
9935 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +01009936 memprintf(err, "'%s' : missing certificate file path", args[*cur_arg]);
Emeric Bruna7aa3092012-10-26 12:58:00 +02009937 return ERR_ALERT | ERR_FATAL;
9938 }
9939
Willy Tarreauef934602016-12-22 23:12:01 +01009940 if ((*args[*cur_arg + 1] != '/') && global_ssl.crt_base)
Christopher Fauletff3a41e2017-11-23 09:13:32 +01009941 memprintf(&newsrv->ssl_ctx.client_crt, "%s/%s", global_ssl.crt_base, args[*cur_arg + 1]);
Emeric Bruna7aa3092012-10-26 12:58:00 +02009942 else
9943 memprintf(&newsrv->ssl_ctx.client_crt, "%s", args[*cur_arg + 1]);
9944
9945 return 0;
9946}
Emeric Brunef42d922012-10-11 16:11:36 +02009947
Frédéric Lécaille340ae602017-03-13 10:38:04 +01009948/* parse the "no-check-ssl" server keyword */
9949static int srv_parse_no_check_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9950{
9951 newsrv->check.use_ssl = 0;
9952 free(newsrv->ssl_ctx.ciphers);
9953 newsrv->ssl_ctx.ciphers = NULL;
9954 newsrv->ssl_ctx.options &= ~global_ssl.connect_default_ssloptions;
9955 return 0;
9956}
9957
Frédéric Lécaillee892c4c2017-03-13 12:08:01 +01009958/* parse the "no-send-proxy-v2-ssl" server keyword */
9959static int srv_parse_no_send_proxy_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9960{
9961 newsrv->pp_opts &= ~SRV_PP_V2;
9962 newsrv->pp_opts &= ~SRV_PP_V2_SSL;
9963 return 0;
9964}
9965
9966/* parse the "no-send-proxy-v2-ssl-cn" server keyword */
9967static int srv_parse_no_send_proxy_cn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9968{
9969 newsrv->pp_opts &= ~SRV_PP_V2;
9970 newsrv->pp_opts &= ~SRV_PP_V2_SSL;
9971 newsrv->pp_opts &= ~SRV_PP_V2_SSL_CN;
9972 return 0;
9973}
9974
Frédéric Lécaillee381d762017-03-13 11:54:17 +01009975/* parse the "no-ssl" server keyword */
9976static int srv_parse_no_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9977{
9978 newsrv->use_ssl = 0;
9979 free(newsrv->ssl_ctx.ciphers);
9980 newsrv->ssl_ctx.ciphers = NULL;
9981 return 0;
9982}
9983
Olivier Houchard522eea72017-11-03 16:27:47 +01009984/* parse the "allow-0rtt" server keyword */
9985static int srv_parse_allow_0rtt(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9986{
9987 newsrv->ssl_ctx.options |= SRV_SSL_O_EARLY_DATA;
9988 return 0;
9989}
9990
Willy Tarreau2a3fb1c2015-02-05 16:47:07 +01009991/* parse the "no-ssl-reuse" server keyword */
9992static int srv_parse_no_ssl_reuse(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
9993{
9994 newsrv->ssl_ctx.options |= SRV_SSL_O_NO_REUSE;
9995 return 0;
9996}
9997
Emeric Brunf9c5c472012-10-11 15:28:34 +02009998/* parse the "no-tls-tickets" server keyword */
9999static int srv_parse_no_tls_tickets(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10000{
10001 newsrv->ssl_ctx.options |= SRV_SSL_O_NO_TLS_TICKETS;
10002 return 0;
10003}
David Safb76832014-05-08 23:42:08 -040010004/* parse the "send-proxy-v2-ssl" server keyword */
10005static int srv_parse_send_proxy_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10006{
10007 newsrv->pp_opts |= SRV_PP_V2;
10008 newsrv->pp_opts |= SRV_PP_V2_SSL;
10009 return 0;
10010}
10011
10012/* parse the "send-proxy-v2-ssl-cn" server keyword */
10013static int srv_parse_send_proxy_cn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10014{
10015 newsrv->pp_opts |= SRV_PP_V2;
10016 newsrv->pp_opts |= SRV_PP_V2_SSL;
10017 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
10018 return 0;
10019}
Emeric Brunf9c5c472012-10-11 15:28:34 +020010020
Willy Tarreau732eac42015-07-09 11:40:25 +020010021/* parse the "sni" server keyword */
10022static int srv_parse_sni(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10023{
10024#ifndef SSL_CTRL_SET_TLSEXT_HOSTNAME
10025 memprintf(err, "'%s' : the current SSL library doesn't support the SNI TLS extension", args[*cur_arg]);
10026 return ERR_ALERT | ERR_FATAL;
10027#else
Frédéric Lécaille9a146de2017-03-20 14:54:41 +010010028 char *arg;
Willy Tarreau732eac42015-07-09 11:40:25 +020010029
Frédéric Lécaille9a146de2017-03-20 14:54:41 +010010030 arg = args[*cur_arg + 1];
10031 if (!*arg) {
Willy Tarreau732eac42015-07-09 11:40:25 +020010032 memprintf(err, "'%s' : missing sni expression", args[*cur_arg]);
10033 return ERR_ALERT | ERR_FATAL;
10034 }
10035
Frédéric Lécaille9a146de2017-03-20 14:54:41 +010010036 free(newsrv->sni_expr);
10037 newsrv->sni_expr = strdup(arg);
Willy Tarreau732eac42015-07-09 11:40:25 +020010038
Willy Tarreau732eac42015-07-09 11:40:25 +020010039 return 0;
10040#endif
10041}
10042
Willy Tarreau92faadf2012-10-10 23:04:25 +020010043/* parse the "ssl" server keyword */
10044static int srv_parse_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10045{
10046 newsrv->use_ssl = 1;
Willy Tarreauef934602016-12-22 23:12:01 +010010047 if (global_ssl.connect_default_ciphers && !newsrv->ssl_ctx.ciphers)
10048 newsrv->ssl_ctx.ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +020010049#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020010050 if (global_ssl.connect_default_ciphersuites && !newsrv->ssl_ctx.ciphersuites)
10051 newsrv->ssl_ctx.ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
10052#endif
Willy Tarreau92faadf2012-10-10 23:04:25 +020010053 return 0;
10054}
10055
Frédéric Lécaille2cfcdbe2017-03-13 11:32:20 +010010056/* parse the "ssl-reuse" server keyword */
10057static int srv_parse_ssl_reuse(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10058{
10059 newsrv->ssl_ctx.options &= ~SRV_SSL_O_NO_REUSE;
10060 return 0;
10061}
10062
Frédéric Lécaille2cfcdbe2017-03-13 11:32:20 +010010063/* parse the "tls-tickets" server keyword */
10064static int srv_parse_tls_tickets(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10065{
10066 newsrv->ssl_ctx.options &= ~SRV_SSL_O_NO_TLS_TICKETS;
10067 return 0;
10068}
10069
Emeric Brunef42d922012-10-11 16:11:36 +020010070/* parse the "verify" server keyword */
10071static int srv_parse_verify(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10072{
10073 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +010010074 memprintf(err, "'%s' : missing verify method", args[*cur_arg]);
Emeric Brunef42d922012-10-11 16:11:36 +020010075 return ERR_ALERT | ERR_FATAL;
10076 }
10077
10078 if (strcmp(args[*cur_arg + 1], "none") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +010010079 newsrv->ssl_ctx.verify = SSL_SOCK_VERIFY_NONE;
Emeric Brunef42d922012-10-11 16:11:36 +020010080 else if (strcmp(args[*cur_arg + 1], "required") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +010010081 newsrv->ssl_ctx.verify = SSL_SOCK_VERIFY_REQUIRED;
Emeric Brunef42d922012-10-11 16:11:36 +020010082 else {
Tim Duesterhus93128532019-11-23 23:45:10 +010010083 memprintf(err, "'%s' : unknown verify method '%s', only 'none' and 'required' are supported\n",
10084 args[*cur_arg], args[*cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +020010085 return ERR_ALERT | ERR_FATAL;
10086 }
10087
Evan Broderbe554312013-06-27 00:05:25 -070010088 return 0;
10089}
10090
10091/* parse the "verifyhost" server keyword */
10092static int srv_parse_verifyhost(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
10093{
10094 if (!*args[*cur_arg + 1]) {
Tim Duesterhus93128532019-11-23 23:45:10 +010010095 memprintf(err, "'%s' : missing hostname to verify against", args[*cur_arg]);
Evan Broderbe554312013-06-27 00:05:25 -070010096 return ERR_ALERT | ERR_FATAL;
10097 }
10098
Frédéric Lécaille273f3212017-03-13 15:52:01 +010010099 free(newsrv->ssl_ctx.verify_host);
Evan Broderbe554312013-06-27 00:05:25 -070010100 newsrv->ssl_ctx.verify_host = strdup(args[*cur_arg + 1]);
10101
Emeric Brunef42d922012-10-11 16:11:36 +020010102 return 0;
10103}
10104
Emeric Brun2c86cbf2014-10-30 15:56:50 +010010105/* parse the "ssl-default-bind-options" keyword in global section */
10106static int ssl_parse_default_bind_options(char **args, int section_type, struct proxy *curpx,
10107 struct proxy *defpx, const char *file, int line,
10108 char **err) {
10109 int i = 1;
10110
10111 if (*(args[i]) == 0) {
10112 memprintf(err, "global statement '%s' expects an option as an argument.", args[0]);
10113 return -1;
10114 }
10115 while (*(args[i])) {
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020010116 if (!strcmp(args[i], "no-tls-tickets"))
Willy Tarreauef934602016-12-22 23:12:01 +010010117 global_ssl.listen_default_ssloptions |= BC_SSL_O_NO_TLS_TICKETS;
Lukas Tribus53ae85c2017-05-04 15:45:40 +000010118 else if (!strcmp(args[i], "prefer-client-ciphers"))
10119 global_ssl.listen_default_ssloptions |= BC_SSL_O_PREF_CLIE_CIPH;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020010120 else if (!strcmp(args[i], "ssl-min-ver") || !strcmp(args[i], "ssl-max-ver")) {
10121 if (!parse_tls_method_minmax(args, i, &global_ssl.listen_default_sslmethods, err))
10122 i++;
10123 else {
10124 memprintf(err, "%s on global statement '%s'.", *err, args[0]);
10125 return -1;
10126 }
10127 }
10128 else if (parse_tls_method_options(args[i], &global_ssl.listen_default_sslmethods, err)) {
Emeric Brun2c86cbf2014-10-30 15:56:50 +010010129 memprintf(err, "unknown option '%s' on global statement '%s'.", args[i], args[0]);
10130 return -1;
10131 }
10132 i++;
10133 }
10134 return 0;
10135}
10136
10137/* parse the "ssl-default-server-options" keyword in global section */
10138static int ssl_parse_default_server_options(char **args, int section_type, struct proxy *curpx,
10139 struct proxy *defpx, const char *file, int line,
10140 char **err) {
10141 int i = 1;
10142
10143 if (*(args[i]) == 0) {
10144 memprintf(err, "global statement '%s' expects an option as an argument.", args[0]);
10145 return -1;
10146 }
10147 while (*(args[i])) {
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020010148 if (!strcmp(args[i], "no-tls-tickets"))
Willy Tarreauef934602016-12-22 23:12:01 +010010149 global_ssl.connect_default_ssloptions |= SRV_SSL_O_NO_TLS_TICKETS;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020010150 else if (!strcmp(args[i], "ssl-min-ver") || !strcmp(args[i], "ssl-max-ver")) {
10151 if (!parse_tls_method_minmax(args, i, &global_ssl.connect_default_sslmethods, err))
10152 i++;
10153 else {
10154 memprintf(err, "%s on global statement '%s'.", *err, args[0]);
10155 return -1;
10156 }
10157 }
10158 else if (parse_tls_method_options(args[i], &global_ssl.connect_default_sslmethods, err)) {
Emeric Brun2c86cbf2014-10-30 15:56:50 +010010159 memprintf(err, "unknown option '%s' on global statement '%s'.", args[i], args[0]);
10160 return -1;
10161 }
10162 i++;
10163 }
10164 return 0;
10165}
10166
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +010010167/* parse the "ca-base" / "crt-base" keywords in global section.
10168 * Returns <0 on alert, >0 on warning, 0 on success.
10169 */
10170static int ssl_parse_global_ca_crt_base(char **args, int section_type, struct proxy *curpx,
10171 struct proxy *defpx, const char *file, int line,
10172 char **err)
10173{
10174 char **target;
10175
Willy Tarreauef934602016-12-22 23:12:01 +010010176 target = (args[0][1] == 'a') ? &global_ssl.ca_base : &global_ssl.crt_base;
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +010010177
10178 if (too_many_args(1, args, err, NULL))
10179 return -1;
10180
10181 if (*target) {
10182 memprintf(err, "'%s' already specified.", args[0]);
10183 return -1;
10184 }
10185
10186 if (*(args[1]) == 0) {
10187 memprintf(err, "global statement '%s' expects a directory path as an argument.", args[0]);
10188 return -1;
10189 }
10190 *target = strdup(args[1]);
10191 return 0;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010192}
10193
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010194/* "issuers-chain-path" load chain certificate in global */
10195static int ssl_load_global_issuer_from_BIO(BIO *in, char *fp, char **err)
10196{
10197 X509 *ca;
10198 X509_NAME *name = NULL;
10199 ASN1_OCTET_STRING *skid = NULL;
10200 STACK_OF(X509) *chain = NULL;
10201 struct issuer_chain *issuer;
10202 struct eb64_node *node;
10203 char *path;
10204 u64 key;
10205 int ret = 0;
10206
10207 while ((ca = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
10208 if (chain == NULL) {
10209 chain = sk_X509_new_null();
10210 skid = X509_get_ext_d2i(ca, NID_subject_key_identifier, NULL, NULL);
10211 name = X509_get_subject_name(ca);
10212 }
10213 if (!sk_X509_push(chain, ca)) {
10214 X509_free(ca);
10215 goto end;
10216 }
10217 }
10218 if (!chain) {
10219 memprintf(err, "unable to load issuers-chain %s : pem certificate not found.\n", fp);
10220 goto end;
10221 }
10222 if (!skid) {
10223 memprintf(err, "unable to load issuers-chain %s : SubjectKeyIdentifier not found.\n", fp);
10224 goto end;
10225 }
10226 if (!name) {
10227 memprintf(err, "unable to load issuers-chain %s : SubjectName not found.\n", fp);
10228 goto end;
10229 }
10230 key = XXH64(ASN1_STRING_get0_data(skid), ASN1_STRING_length(skid), 0);
William Lallemande0f3fd52020-02-25 14:53:06 +010010231 for (node = eb64_lookup(&cert_issuer_tree, key); node; node = eb64_next(node)) {
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010232 issuer = container_of(node, typeof(*issuer), node);
10233 if (!X509_NAME_cmp(name, X509_get_subject_name(sk_X509_value(issuer->chain, 0)))) {
10234 memprintf(err, "duplicate issuers-chain %s: %s already in store\n", fp, issuer->path);
10235 goto end;
10236 }
10237 }
10238 issuer = calloc(1, sizeof *issuer);
10239 path = strdup(fp);
10240 if (!issuer || !path) {
10241 free(issuer);
10242 free(path);
10243 goto end;
10244 }
10245 issuer->node.key = key;
10246 issuer->path = path;
10247 issuer->chain = chain;
10248 chain = NULL;
William Lallemande0f3fd52020-02-25 14:53:06 +010010249 eb64_insert(&cert_issuer_tree, &issuer->node);
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010250 ret = 1;
10251 end:
10252 if (skid)
10253 ASN1_OCTET_STRING_free(skid);
10254 if (chain)
10255 sk_X509_pop_free(chain, X509_free);
10256 return ret;
10257}
10258
Emmanuel Hocdetef87e0a2020-03-23 11:29:11 +010010259static struct issuer_chain* ssl_get0_issuer_chain(X509 *cert)
Emmanuel Hocdet75a7aa12020-02-18 15:19:24 +010010260{
10261 AUTHORITY_KEYID *akid;
10262 struct issuer_chain *issuer = NULL;
10263
10264 akid = X509_get_ext_d2i(cert, NID_authority_key_identifier, NULL, NULL);
10265 if (akid) {
10266 struct eb64_node *node;
10267 u64 hk;
10268 hk = XXH64(ASN1_STRING_get0_data(akid->keyid), ASN1_STRING_length(akid->keyid), 0);
10269 for (node = eb64_lookup(&cert_issuer_tree, hk); node; node = eb64_next(node)) {
10270 struct issuer_chain *ti = container_of(node, typeof(*issuer), node);
10271 if (X509_check_issued(sk_X509_value(ti->chain, 0), cert) == X509_V_OK) {
10272 issuer = ti;
10273 break;
10274 }
10275 }
10276 AUTHORITY_KEYID_free(akid);
10277 }
10278 return issuer;
10279}
10280
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010281static void ssl_free_global_issuers(void)
10282{
10283 struct eb64_node *node, *back;
10284 struct issuer_chain *issuer;
10285
William Lallemande0f3fd52020-02-25 14:53:06 +010010286 node = eb64_first(&cert_issuer_tree);
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010287 while (node) {
10288 issuer = container_of(node, typeof(*issuer), node);
10289 back = eb64_next(node);
10290 eb64_delete(node);
10291 free(issuer->path);
10292 sk_X509_pop_free(issuer->chain, X509_free);
10293 free(issuer);
10294 node = back;
10295 }
10296}
10297
10298static int ssl_load_global_issuers_from_path(char **args, int section_type, struct proxy *curpx,
10299 struct proxy *defpx, const char *file, int line,
10300 char **err)
10301{
10302 char *path;
10303 struct dirent **de_list;
10304 int i, n;
10305 struct stat buf;
10306 char *end;
10307 char fp[MAXPATHLEN+1];
10308
10309 if (too_many_args(1, args, err, NULL))
10310 return -1;
10311
10312 path = args[1];
10313 if (*path == 0 || stat(path, &buf)) {
10314 memprintf(err, "%sglobal statement '%s' expects a directory path as an argument.\n",
10315 err && *err ? *err : "", args[0]);
10316 return -1;
10317 }
10318 if (S_ISDIR(buf.st_mode) == 0) {
10319 memprintf(err, "%sglobal statement '%s': %s is not a directory.\n",
10320 err && *err ? *err : "", args[0], path);
10321 return -1;
10322 }
10323
10324 /* strip trailing slashes, including first one */
10325 for (end = path + strlen(path) - 1; end >= path && *end == '/'; end--)
10326 *end = 0;
10327 /* path already parsed? */
10328 if (global_ssl.issuers_chain_path && strcmp(global_ssl.issuers_chain_path, path) == 0)
10329 return 0;
10330 /* overwrite old issuers_chain_path */
10331 free(global_ssl.issuers_chain_path);
10332 global_ssl.issuers_chain_path = strdup(path);
10333 ssl_free_global_issuers();
10334
10335 n = scandir(path, &de_list, 0, alphasort);
10336 if (n < 0) {
10337 memprintf(err, "%sglobal statement '%s': unable to scan directory '%s' : %s.\n",
10338 err && *err ? *err : "", args[0], path, strerror(errno));
10339 return -1;
10340 }
10341 for (i = 0; i < n; i++) {
10342 struct dirent *de = de_list[i];
10343 BIO *in = NULL;
10344 char *warn = NULL;
10345
10346 snprintf(fp, sizeof(fp), "%s/%s", path, de->d_name);
10347 free(de);
10348 if (stat(fp, &buf) != 0) {
10349 ha_warning("unable to stat certificate from file '%s' : %s.\n", fp, strerror(errno));
10350 goto next;
10351 }
10352 if (!S_ISREG(buf.st_mode))
10353 goto next;
10354
10355 in = BIO_new(BIO_s_file());
10356 if (in == NULL)
10357 goto next;
10358 if (BIO_read_filename(in, fp) <= 0)
10359 goto next;
10360 ssl_load_global_issuer_from_BIO(in, fp, &warn);
10361 if (warn) {
Tim Duesterhuse8aa5f22020-02-19 11:41:13 +010010362 ha_warning("%s", warn);
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010010363 free(warn);
10364 warn = NULL;
10365 }
10366 next:
10367 if (in)
10368 BIO_free(in);
10369 }
10370 free(de_list);
10371
10372 return 0;
10373}
10374
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010375/* parse the "ssl-mode-async" keyword in global section.
10376 * Returns <0 on alert, >0 on warning, 0 on success.
10377 */
10378static int ssl_parse_global_ssl_async(char **args, int section_type, struct proxy *curpx,
10379 struct proxy *defpx, const char *file, int line,
10380 char **err)
10381{
Willy Tarreau5db847a2019-05-09 14:13:35 +020010382#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010383 global_ssl.async = 1;
Emeric Brunece0c332017-12-06 13:51:49 +010010384 global.ssl_used_async_engines = nb_engines;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010385 return 0;
10386#else
10387 memprintf(err, "'%s': openssl library does not support async mode", args[0]);
10388 return -1;
10389#endif
10390}
10391
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010392#ifndef OPENSSL_NO_ENGINE
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010393static int ssl_check_async_engine_count(void) {
10394 int err_code = 0;
10395
Emeric Brun3854e012017-05-17 20:42:48 +020010396 if (global_ssl.async && (openssl_engines_initialized > 32)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +010010397 ha_alert("ssl-mode-async only supports a maximum of 32 engines.\n");
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010398 err_code = ERR_ABORT;
10399 }
10400 return err_code;
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +010010401}
10402
Grant Zhang872f9c22017-01-21 01:10:18 +000010403/* parse the "ssl-engine" keyword in global section.
10404 * Returns <0 on alert, >0 on warning, 0 on success.
10405 */
10406static int ssl_parse_global_ssl_engine(char **args, int section_type, struct proxy *curpx,
10407 struct proxy *defpx, const char *file, int line,
10408 char **err)
10409{
10410 char *algo;
10411 int ret = -1;
10412
10413 if (*(args[1]) == 0) {
10414 memprintf(err, "global statement '%s' expects a valid engine name as an argument.", args[0]);
10415 return ret;
10416 }
10417
10418 if (*(args[2]) == 0) {
10419 /* if no list of algorithms is given, it defaults to ALL */
10420 algo = strdup("ALL");
10421 goto add_engine;
10422 }
10423
10424 /* otherwise the expected format is ssl-engine <engine_name> algo <list of algo> */
10425 if (strcmp(args[2], "algo") != 0) {
10426 memprintf(err, "global statement '%s' expects to have algo keyword.", args[0]);
10427 return ret;
10428 }
10429
10430 if (*(args[3]) == 0) {
10431 memprintf(err, "global statement '%s' expects algorithm names as an argument.", args[0]);
10432 return ret;
10433 }
10434 algo = strdup(args[3]);
10435
10436add_engine:
10437 if (ssl_init_single_engine(args[1], algo)==0) {
10438 openssl_engines_initialized++;
10439 ret = 0;
10440 }
10441 free(algo);
10442 return ret;
10443}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010444#endif
Grant Zhang872f9c22017-01-21 01:10:18 +000010445
Willy Tarreauf22e9682016-12-21 23:23:19 +010010446/* parse the "ssl-default-bind-ciphers" / "ssl-default-server-ciphers" keywords
10447 * in global section. Returns <0 on alert, >0 on warning, 0 on success.
10448 */
10449static int ssl_parse_global_ciphers(char **args, int section_type, struct proxy *curpx,
10450 struct proxy *defpx, const char *file, int line,
10451 char **err)
10452{
10453 char **target;
10454
Willy Tarreauef934602016-12-22 23:12:01 +010010455 target = (args[0][12] == 'b') ? &global_ssl.listen_default_ciphers : &global_ssl.connect_default_ciphers;
Willy Tarreauf22e9682016-12-21 23:23:19 +010010456
10457 if (too_many_args(1, args, err, NULL))
10458 return -1;
10459
10460 if (*(args[1]) == 0) {
10461 memprintf(err, "global statement '%s' expects a cipher suite as an argument.", args[0]);
10462 return -1;
10463 }
10464
10465 free(*target);
10466 *target = strdup(args[1]);
10467 return 0;
10468}
Dirkjan Bussink415150f2018-09-14 11:14:21 +020010469
Emmanuel Hocdet839af572019-05-14 16:27:35 +020010470#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020010471/* parse the "ssl-default-bind-ciphersuites" / "ssl-default-server-ciphersuites" keywords
10472 * in global section. Returns <0 on alert, >0 on warning, 0 on success.
10473 */
10474static int ssl_parse_global_ciphersuites(char **args, int section_type, struct proxy *curpx,
10475 struct proxy *defpx, const char *file, int line,
10476 char **err)
10477{
10478 char **target;
10479
10480 target = (args[0][12] == 'b') ? &global_ssl.listen_default_ciphersuites : &global_ssl.connect_default_ciphersuites;
10481
10482 if (too_many_args(1, args, err, NULL))
10483 return -1;
10484
10485 if (*(args[1]) == 0) {
10486 memprintf(err, "global statement '%s' expects a cipher suite as an argument.", args[0]);
10487 return -1;
10488 }
10489
10490 free(*target);
10491 *target = strdup(args[1]);
10492 return 0;
10493}
10494#endif
Willy Tarreauf22e9682016-12-21 23:23:19 +010010495
Willy Tarreau9ceda382016-12-21 23:13:03 +010010496/* parse various global tune.ssl settings consisting in positive integers.
10497 * Returns <0 on alert, >0 on warning, 0 on success.
10498 */
10499static int ssl_parse_global_int(char **args, int section_type, struct proxy *curpx,
10500 struct proxy *defpx, const char *file, int line,
10501 char **err)
10502{
10503 int *target;
10504
10505 if (strcmp(args[0], "tune.ssl.cachesize") == 0)
10506 target = &global.tune.sslcachesize;
10507 else if (strcmp(args[0], "tune.ssl.maxrecord") == 0)
Willy Tarreauef934602016-12-22 23:12:01 +010010508 target = (int *)&global_ssl.max_record;
Willy Tarreau9ceda382016-12-21 23:13:03 +010010509 else if (strcmp(args[0], "tune.ssl.ssl-ctx-cache-size") == 0)
Willy Tarreauef934602016-12-22 23:12:01 +010010510 target = &global_ssl.ctx_cache;
Willy Tarreau0bea58d2016-12-21 23:17:25 +010010511 else if (strcmp(args[0], "maxsslconn") == 0)
10512 target = &global.maxsslconn;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010010513 else if (strcmp(args[0], "tune.ssl.capture-cipherlist-size") == 0)
10514 target = &global_ssl.capture_cipherlist;
Willy Tarreau9ceda382016-12-21 23:13:03 +010010515 else {
10516 memprintf(err, "'%s' keyword not unhandled (please report this bug).", args[0]);
10517 return -1;
10518 }
10519
10520 if (too_many_args(1, args, err, NULL))
10521 return -1;
10522
10523 if (*(args[1]) == 0) {
10524 memprintf(err, "'%s' expects an integer argument.", args[0]);
10525 return -1;
10526 }
10527
10528 *target = atoi(args[1]);
10529 if (*target < 0) {
10530 memprintf(err, "'%s' expects a positive numeric value.", args[0]);
10531 return -1;
10532 }
10533 return 0;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010010534}
10535
10536static int ssl_parse_global_capture_cipherlist(char **args, int section_type, struct proxy *curpx,
10537 struct proxy *defpx, const char *file, int line,
10538 char **err)
10539{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010010540 int ret;
10541
10542 ret = ssl_parse_global_int(args, section_type, curpx, defpx, file, line, err);
10543 if (ret != 0)
10544 return ret;
10545
Willy Tarreaubafbe012017-11-24 17:34:44 +010010546 if (pool_head_ssl_capture) {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010010547 memprintf(err, "'%s' is already configured.", args[0]);
10548 return -1;
10549 }
10550
Willy Tarreaubafbe012017-11-24 17:34:44 +010010551 pool_head_ssl_capture = create_pool("ssl-capture", sizeof(struct ssl_capture) + global_ssl.capture_cipherlist, MEM_F_SHARED);
10552 if (!pool_head_ssl_capture) {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010010553 memprintf(err, "Out of memory error.");
10554 return -1;
10555 }
10556 return 0;
Willy Tarreau9ceda382016-12-21 23:13:03 +010010557}
10558
10559/* parse "ssl.force-private-cache".
10560 * Returns <0 on alert, >0 on warning, 0 on success.
10561 */
10562static int ssl_parse_global_private_cache(char **args, int section_type, struct proxy *curpx,
10563 struct proxy *defpx, const char *file, int line,
10564 char **err)
10565{
10566 if (too_many_args(0, args, err, NULL))
10567 return -1;
10568
Willy Tarreauef934602016-12-22 23:12:01 +010010569 global_ssl.private_cache = 1;
Willy Tarreau9ceda382016-12-21 23:13:03 +010010570 return 0;
10571}
10572
10573/* parse "ssl.lifetime".
10574 * Returns <0 on alert, >0 on warning, 0 on success.
10575 */
10576static int ssl_parse_global_lifetime(char **args, int section_type, struct proxy *curpx,
10577 struct proxy *defpx, const char *file, int line,
10578 char **err)
10579{
10580 const char *res;
10581
10582 if (too_many_args(1, args, err, NULL))
10583 return -1;
10584
10585 if (*(args[1]) == 0) {
10586 memprintf(err, "'%s' expects ssl sessions <lifetime> in seconds as argument.", args[0]);
10587 return -1;
10588 }
10589
Willy Tarreauef934602016-12-22 23:12:01 +010010590 res = parse_time_err(args[1], &global_ssl.life_time, TIME_UNIT_S);
Willy Tarreau9faebe32019-06-07 19:00:37 +020010591 if (res == PARSE_TIME_OVER) {
10592 memprintf(err, "timer overflow in argument '%s' to <%s> (maximum value is 2147483647 s or ~68 years).",
10593 args[1], args[0]);
10594 return -1;
10595 }
10596 else if (res == PARSE_TIME_UNDER) {
10597 memprintf(err, "timer underflow in argument '%s' to <%s> (minimum non-null value is 1 s).",
10598 args[1], args[0]);
10599 return -1;
10600 }
10601 else if (res) {
Willy Tarreau9ceda382016-12-21 23:13:03 +010010602 memprintf(err, "unexpected character '%c' in argument to <%s>.", *res, args[0]);
10603 return -1;
10604 }
10605 return 0;
10606}
10607
10608#ifndef OPENSSL_NO_DH
Willy Tarreau14e36a12016-12-21 23:28:13 +010010609/* parse "ssl-dh-param-file".
10610 * Returns <0 on alert, >0 on warning, 0 on success.
10611 */
10612static int ssl_parse_global_dh_param_file(char **args, int section_type, struct proxy *curpx,
10613 struct proxy *defpx, const char *file, int line,
10614 char **err)
10615{
10616 if (too_many_args(1, args, err, NULL))
10617 return -1;
10618
10619 if (*(args[1]) == 0) {
10620 memprintf(err, "'%s' expects a file path as an argument.", args[0]);
10621 return -1;
10622 }
10623
10624 if (ssl_sock_load_global_dh_param_from_file(args[1])) {
10625 memprintf(err, "'%s': unable to load DH parameters from file <%s>.", args[0], args[1]);
10626 return -1;
10627 }
10628 return 0;
10629}
10630
Willy Tarreau9ceda382016-12-21 23:13:03 +010010631/* parse "ssl.default-dh-param".
10632 * Returns <0 on alert, >0 on warning, 0 on success.
10633 */
10634static int ssl_parse_global_default_dh(char **args, int section_type, struct proxy *curpx,
10635 struct proxy *defpx, const char *file, int line,
10636 char **err)
10637{
10638 if (too_many_args(1, args, err, NULL))
10639 return -1;
10640
10641 if (*(args[1]) == 0) {
10642 memprintf(err, "'%s' expects an integer argument.", args[0]);
10643 return -1;
10644 }
10645
Willy Tarreauef934602016-12-22 23:12:01 +010010646 global_ssl.default_dh_param = atoi(args[1]);
10647 if (global_ssl.default_dh_param < 1024) {
Willy Tarreau9ceda382016-12-21 23:13:03 +010010648 memprintf(err, "'%s' expects a value >= 1024.", args[0]);
10649 return -1;
10650 }
10651 return 0;
10652}
10653#endif
10654
William Lallemand3af48e72020-02-03 17:15:52 +010010655
10656/*
10657 * parse "ssl-load-extra-files".
10658 * multiple arguments are allowed: "bundle", "sctl", "ocsp", "issuer", "all", "none"
10659 */
10660static int ssl_parse_global_extra_files(char **args, int section_type, struct proxy *curpx,
10661 struct proxy *defpx, const char *file, int line,
10662 char **err)
10663{
10664 int i;
10665 int gf = SSL_GF_NONE;
10666
10667 if (*(args[1]) == 0)
10668 goto err_arg;
10669
10670 for (i = 1; *args[i]; i++) {
10671
10672 if (!strcmp("bundle", args[i])) {
10673 gf |= SSL_GF_BUNDLE;
10674
10675 } else if (!strcmp("sctl", args[i])) {
10676 gf |= SSL_GF_SCTL;
10677
10678 } else if (!strcmp("ocsp", args[i])){
10679 gf |= SSL_GF_OCSP;
10680
10681 } else if (!strcmp("issuer", args[i])){
10682 gf |= SSL_GF_OCSP_ISSUER;
10683
William Lallemand4c5adbf2020-02-24 14:23:22 +010010684 } else if (!strcmp("key", args[i])) {
10685 gf |= SSL_GF_KEY;
10686
William Lallemand3af48e72020-02-03 17:15:52 +010010687 } else if (!strcmp("none", args[i])) {
10688 if (gf != SSL_GF_NONE)
10689 goto err_alone;
10690 gf = SSL_GF_NONE;
10691 i++;
10692 break;
10693
10694 } else if (!strcmp("all", args[i])) {
10695 if (gf != SSL_GF_NONE)
10696 goto err_alone;
10697 gf = SSL_GF_ALL;
10698 i++;
10699 break;
10700 } else {
10701 goto err_arg;
10702 }
10703 }
10704 /* break from loop but there are still arguments */
10705 if (*args[i])
10706 goto err_alone;
10707
10708 global_ssl.extra_files = gf;
10709
10710 return 0;
10711
10712err_alone:
10713 memprintf(err, "'%s' 'none' and 'all' can be only used alone", args[0]);
10714 return -1;
10715
10716err_arg:
10717 memprintf(err, "'%s' expects one or multiple arguments (none, all, bundle, sctl, ocsp, issuer).", args[0]);
10718 return -1;
10719}
10720
Willy Tarreau9ceda382016-12-21 23:13:03 +010010721
William Lallemand32af2032016-10-29 18:09:35 +020010722/* This function is used with TLS ticket keys management. It permits to browse
10723 * each reference. The variable <getnext> must contain the current node,
10724 * <end> point to the root node.
10725 */
10726#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
10727static inline
10728struct tls_keys_ref *tlskeys_list_get_next(struct tls_keys_ref *getnext, struct list *end)
10729{
10730 struct tls_keys_ref *ref = getnext;
10731
10732 while (1) {
10733
10734 /* Get next list entry. */
10735 ref = LIST_NEXT(&ref->list, struct tls_keys_ref *, list);
10736
10737 /* If the entry is the last of the list, return NULL. */
10738 if (&ref->list == end)
10739 return NULL;
10740
10741 return ref;
10742 }
10743}
10744
10745static inline
10746struct tls_keys_ref *tlskeys_ref_lookup_ref(const char *reference)
10747{
10748 int id;
10749 char *error;
10750
10751 /* If the reference starts by a '#', this is numeric id. */
10752 if (reference[0] == '#') {
10753 /* Try to convert the numeric id. If the conversion fails, the lookup fails. */
10754 id = strtol(reference + 1, &error, 10);
10755 if (*error != '\0')
10756 return NULL;
10757
10758 /* Perform the unique id lookup. */
10759 return tlskeys_ref_lookupid(id);
10760 }
10761
10762 /* Perform the string lookup. */
10763 return tlskeys_ref_lookup(reference);
10764}
10765#endif
10766
10767
10768#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
10769
10770static int cli_io_handler_tlskeys_files(struct appctx *appctx);
10771
10772static inline int cli_io_handler_tlskeys_entries(struct appctx *appctx) {
10773 return cli_io_handler_tlskeys_files(appctx);
10774}
10775
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010776/* dumps all tls keys. Relies on cli.i0 (non-null = only list file names), cli.i1
10777 * (next index to be dumped), and cli.p0 (next key reference).
10778 */
William Lallemand32af2032016-10-29 18:09:35 +020010779static int cli_io_handler_tlskeys_files(struct appctx *appctx) {
10780
10781 struct stream_interface *si = appctx->owner;
10782
10783 switch (appctx->st2) {
10784 case STAT_ST_INIT:
10785 /* Display the column headers. If the message cannot be sent,
Joseph Herlant017b3da2018-11-15 09:07:59 -080010786 * quit the function with returning 0. The function is called
William Lallemand32af2032016-10-29 18:09:35 +020010787 * later and restart at the state "STAT_ST_INIT".
10788 */
10789 chunk_reset(&trash);
10790
10791 if (appctx->io_handler == cli_io_handler_tlskeys_entries)
10792 chunk_appendf(&trash, "# id secret\n");
10793 else
10794 chunk_appendf(&trash, "# id (file)\n");
10795
Willy Tarreau06d80a92017-10-19 14:32:15 +020010796 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +010010797 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +020010798 return 0;
10799 }
10800
William Lallemand32af2032016-10-29 18:09:35 +020010801 /* Now, we start the browsing of the references lists.
10802 * Note that the following call to LIST_ELEM return bad pointer. The only
10803 * available field of this pointer is <list>. It is used with the function
10804 * tlskeys_list_get_next() for retruning the first available entry
10805 */
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010806 if (appctx->ctx.cli.p0 == NULL) {
10807 appctx->ctx.cli.p0 = LIST_ELEM(&tlskeys_reference, struct tls_keys_ref *, list);
10808 appctx->ctx.cli.p0 = tlskeys_list_get_next(appctx->ctx.cli.p0, &tlskeys_reference);
William Lallemand32af2032016-10-29 18:09:35 +020010809 }
10810
10811 appctx->st2 = STAT_ST_LIST;
10812 /* fall through */
10813
10814 case STAT_ST_LIST:
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010815 while (appctx->ctx.cli.p0) {
10816 struct tls_keys_ref *ref = appctx->ctx.cli.p0;
William Lallemand32af2032016-10-29 18:09:35 +020010817
10818 chunk_reset(&trash);
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010819 if (appctx->io_handler == cli_io_handler_tlskeys_entries && appctx->ctx.cli.i1 == 0)
William Lallemand32af2032016-10-29 18:09:35 +020010820 chunk_appendf(&trash, "# ");
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010821
10822 if (appctx->ctx.cli.i1 == 0)
10823 chunk_appendf(&trash, "%d (%s)\n", ref->unique_id, ref->filename);
10824
William Lallemand32af2032016-10-29 18:09:35 +020010825 if (appctx->io_handler == cli_io_handler_tlskeys_entries) {
Christopher Faulet16f45c82018-02-16 11:23:49 +010010826 int head;
10827
10828 HA_RWLOCK_RDLOCK(TLSKEYS_REF_LOCK, &ref->lock);
10829 head = ref->tls_ticket_enc_index;
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010830 while (appctx->ctx.cli.i1 < TLS_TICKETS_NO) {
Willy Tarreau83061a82018-07-13 11:56:34 +020010831 struct buffer *t2 = get_trash_chunk();
William Lallemand32af2032016-10-29 18:09:35 +020010832
10833 chunk_reset(t2);
10834 /* should never fail here because we dump only a key in the t2 buffer */
Emeric Brun9e754772019-01-10 17:51:55 +010010835 if (ref->key_size_bits == 128) {
10836 t2->data = a2base64((char *)(ref->tlskeys + (head + 2 + appctx->ctx.cli.i1) % TLS_TICKETS_NO),
10837 sizeof(struct tls_sess_key_128),
10838 t2->area, t2->size);
10839 chunk_appendf(&trash, "%d.%d %s\n", ref->unique_id, appctx->ctx.cli.i1,
10840 t2->area);
10841 }
10842 else if (ref->key_size_bits == 256) {
10843 t2->data = a2base64((char *)(ref->tlskeys + (head + 2 + appctx->ctx.cli.i1) % TLS_TICKETS_NO),
10844 sizeof(struct tls_sess_key_256),
10845 t2->area, t2->size);
10846 chunk_appendf(&trash, "%d.%d %s\n", ref->unique_id, appctx->ctx.cli.i1,
10847 t2->area);
10848 }
10849 else {
10850 /* This case should never happen */
10851 chunk_appendf(&trash, "%d.%d <unknown>\n", ref->unique_id, appctx->ctx.cli.i1);
10852 }
William Lallemand32af2032016-10-29 18:09:35 +020010853
Willy Tarreau06d80a92017-10-19 14:32:15 +020010854 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemand32af2032016-10-29 18:09:35 +020010855 /* let's try again later from this stream. We add ourselves into
10856 * this stream's users so that it can remove us upon termination.
10857 */
Christopher Faulet16f45c82018-02-16 11:23:49 +010010858 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +010010859 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +020010860 return 0;
10861 }
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010862 appctx->ctx.cli.i1++;
William Lallemand32af2032016-10-29 18:09:35 +020010863 }
Christopher Faulet16f45c82018-02-16 11:23:49 +010010864 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010865 appctx->ctx.cli.i1 = 0;
William Lallemand32af2032016-10-29 18:09:35 +020010866 }
Willy Tarreau06d80a92017-10-19 14:32:15 +020010867 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemand32af2032016-10-29 18:09:35 +020010868 /* let's try again later from this stream. We add ourselves into
10869 * this stream's users so that it can remove us upon termination.
10870 */
Willy Tarreaudb398432018-11-15 11:08:52 +010010871 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +020010872 return 0;
10873 }
10874
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010875 if (appctx->ctx.cli.i0 == 0) /* don't display everything if not necessary */
William Lallemand32af2032016-10-29 18:09:35 +020010876 break;
10877
10878 /* get next list entry and check the end of the list */
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010879 appctx->ctx.cli.p0 = tlskeys_list_get_next(appctx->ctx.cli.p0, &tlskeys_reference);
William Lallemand32af2032016-10-29 18:09:35 +020010880 }
10881
10882 appctx->st2 = STAT_ST_FIN;
10883 /* fall through */
10884
10885 default:
10886 appctx->st2 = STAT_ST_FIN;
10887 return 1;
10888 }
10889 return 0;
10890}
10891
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010892/* sets cli.i0 to non-zero if only file lists should be dumped */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020010893static int cli_parse_show_tlskeys(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +020010894{
William Lallemand32af2032016-10-29 18:09:35 +020010895 /* no parameter, shows only file list */
10896 if (!*args[2]) {
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010897 appctx->ctx.cli.i0 = 1;
William Lallemand32af2032016-10-29 18:09:35 +020010898 appctx->io_handler = cli_io_handler_tlskeys_files;
Willy Tarreau3067bfa2016-12-05 14:50:15 +010010899 return 0;
William Lallemand32af2032016-10-29 18:09:35 +020010900 }
10901
10902 if (args[2][0] == '*') {
10903 /* list every TLS ticket keys */
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010904 appctx->ctx.cli.i0 = 1;
William Lallemand32af2032016-10-29 18:09:35 +020010905 } else {
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010906 appctx->ctx.cli.p0 = tlskeys_ref_lookup_ref(args[2]);
Willy Tarreau9d008692019-08-09 11:21:01 +020010907 if (!appctx->ctx.cli.p0)
10908 return cli_err(appctx, "'show tls-keys' unable to locate referenced filename\n");
William Lallemand32af2032016-10-29 18:09:35 +020010909 }
William Lallemand32af2032016-10-29 18:09:35 +020010910 appctx->io_handler = cli_io_handler_tlskeys_entries;
Willy Tarreau3067bfa2016-12-05 14:50:15 +010010911 return 0;
William Lallemand32af2032016-10-29 18:09:35 +020010912}
10913
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020010914static int cli_parse_set_tlskeys(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +020010915{
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010916 struct tls_keys_ref *ref;
Willy Tarreau1c913e42018-08-22 05:26:57 +020010917 int ret;
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010918
William Lallemand32af2032016-10-29 18:09:35 +020010919 /* Expect two parameters: the filename and the new new TLS key in encoding */
Willy Tarreau9d008692019-08-09 11:21:01 +020010920 if (!*args[3] || !*args[4])
10921 return cli_err(appctx, "'set ssl tls-key' expects a filename and the new TLS key in base64 encoding.\n");
William Lallemand32af2032016-10-29 18:09:35 +020010922
Willy Tarreauf5f26e82016-12-16 18:47:27 +010010923 ref = tlskeys_ref_lookup_ref(args[3]);
Willy Tarreau9d008692019-08-09 11:21:01 +020010924 if (!ref)
10925 return cli_err(appctx, "'set ssl tls-key' unable to locate referenced filename\n");
William Lallemand32af2032016-10-29 18:09:35 +020010926
Willy Tarreau1c913e42018-08-22 05:26:57 +020010927 ret = base64dec(args[4], strlen(args[4]), trash.area, trash.size);
Willy Tarreau9d008692019-08-09 11:21:01 +020010928 if (ret < 0)
10929 return cli_err(appctx, "'set ssl tls-key' received invalid base64 encoded TLS key.\n");
Emeric Brun9e754772019-01-10 17:51:55 +010010930
Willy Tarreau1c913e42018-08-22 05:26:57 +020010931 trash.data = ret;
Willy Tarreau9d008692019-08-09 11:21:01 +020010932 if (ssl_sock_update_tlskey_ref(ref, &trash) < 0)
10933 return cli_err(appctx, "'set ssl tls-key' received a key of wrong size.\n");
William Lallemand32af2032016-10-29 18:09:35 +020010934
Willy Tarreau9d008692019-08-09 11:21:01 +020010935 return cli_msg(appctx, LOG_INFO, "TLS ticket key updated!\n");
William Lallemand32af2032016-10-29 18:09:35 +020010936}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +010010937#endif
William Lallemand32af2032016-10-29 18:09:35 +020010938
William Lallemanda6ffd5b2020-03-09 13:35:19 +010010939/*
10940 * Take an ssl_bind_conf structure and append the configuration line used to
10941 * create it in the buffer
10942 */
10943static void dump_crtlist_sslconf(struct buffer *buf, const struct ssl_bind_conf *conf)
10944{
10945 int space = 0;
10946
10947 if (conf == NULL)
10948 return;
10949
10950 chunk_appendf(buf, " [");
10951#ifdef OPENSSL_NPN_NEGOTIATED
10952 if (conf->npn_str) {
10953 int len = conf->npn_len;
10954 char *ptr = conf->npn_str;
10955 int comma = 0;
10956
10957 if (space) chunk_appendf(buf, " ");
10958 chunk_appendf(buf, "npn ");
10959 while (len) {
10960 unsigned short size;
10961
10962 size = *ptr;
10963 ptr++;
10964 if (comma)
10965 chunk_memcat(buf, ",", 1);
10966 chunk_memcat(buf, ptr, size);
10967 ptr += size;
10968 len -= size + 1;
10969 comma = 1;
10970 }
10971 chunk_memcat(buf, "", 1); /* finish with a \0 */
10972 space++;
10973 }
10974#endif
10975#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
10976 if (conf->alpn_str) {
10977 int len = conf->alpn_len;
10978 char *ptr = conf->alpn_str;
10979 int comma = 0;
10980
10981 if (space) chunk_appendf(buf, " ");
10982 chunk_appendf(buf, "alpn ");
10983 while (len) {
10984 unsigned short size;
10985
10986 size = *ptr;
10987 ptr++;
10988 if (comma)
10989 chunk_memcat(buf, ",", 1);
10990 chunk_memcat(buf, ptr, size);
10991 ptr += size;
10992 len -= size + 1;
10993 comma = 1;
10994 }
10995 chunk_memcat(buf, "", 1); /* finish with a \0 */
10996 space++;
10997 }
10998#endif
10999 /* verify */
11000 {
11001 if (conf->verify == SSL_SOCK_VERIFY_NONE) {
11002 if (space) chunk_appendf(buf, " ");
11003 chunk_appendf(buf, "verify none");
11004 space++;
11005 } else if (conf->verify == SSL_SOCK_VERIFY_OPTIONAL) {
11006 if (space) chunk_appendf(buf, " ");
11007 chunk_appendf(buf, "verify optional");
11008 space++;
11009 } else if (conf->verify == SSL_SOCK_VERIFY_REQUIRED) {
11010 if (space) chunk_appendf(buf, " ");
11011 chunk_appendf(buf, "verify required");
11012 space++;
11013 }
11014 }
11015
11016 if (conf->no_ca_names) {
11017 if (space) chunk_appendf(buf, " ");
11018 chunk_appendf(buf, "no-ca-names");
11019 space++;
11020 }
11021
11022 if (conf->early_data) {
11023 if (space) chunk_appendf(buf, " ");
11024 chunk_appendf(buf, "allow-0rtt");
11025 space++;
11026 }
11027 if (conf->ca_file) {
11028 if (space) chunk_appendf(buf, " ");
11029 chunk_appendf(buf, "ca-file %s", conf->ca_file);
11030 space++;
11031 }
11032 if (conf->crl_file) {
11033 if (space) chunk_appendf(buf, " ");
11034 chunk_appendf(buf, "crl-file %s", conf->crl_file);
11035 space++;
11036 }
11037 if (conf->ciphers) {
11038 if (space) chunk_appendf(buf, " ");
11039 chunk_appendf(buf, "ciphers %s", conf->ciphers);
11040 space++;
11041 }
11042#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L && !defined OPENSSL_IS_BORINGSSL && !defined LIBRESSL_VERSION_NUMBER)
11043 if (conf->ciphersuites) {
11044 if (space) chunk_appendf(buf, " ");
11045 chunk_appendf(buf, "ciphersuites %s", conf->ciphersuites);
11046 space++;
11047 }
11048#endif
11049 if (conf->curves) {
11050 if (space) chunk_appendf(buf, " ");
11051 chunk_appendf(buf, "curves %s", conf->curves);
11052 space++;
11053 }
11054 if (conf->ecdhe) {
11055 if (space) chunk_appendf(buf, " ");
11056 chunk_appendf(buf, "ecdhe %s", conf->ecdhe);
11057 space++;
11058 }
11059
11060 /* the crt-lists only support ssl-min-ver and ssl-max-ver */
11061 /* XXX: this part need to be revamp so we don't dump the default settings */
11062 if (conf->ssl_methods.min) {
11063 if (space) chunk_appendf(buf, " ");
11064 chunk_appendf(buf, "ssl-min-ver %s", methodVersions[conf->ssl_methods.min].name);
11065 space++;
11066 }
11067
11068 if (conf->ssl_methods.max) {
11069 if (space) chunk_appendf(buf, " ");
11070 chunk_appendf(buf, "ssl-max-ver %s", methodVersions[conf->ssl_methods.max].name);
11071 space++;
11072 }
11073
William Lallemand58a52222020-04-02 18:11:47 +020011074 chunk_appendf(buf, "]");
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011075
11076 return;
11077}
11078
11079/* dump a list of filters */
11080static void dump_crtlist_filters(struct buffer *buf, struct crtlist_entry *entry)
11081{
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011082 int i;
11083
11084 if (!entry->fcount)
11085 return;
11086
11087 for (i = 0; i < entry->fcount; i++) {
William Lallemand58a52222020-04-02 18:11:47 +020011088 chunk_appendf(buf, " %s", entry->filters[i]);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011089 }
11090 return;
11091}
11092
11093/* CLI IO handler for '(show|dump) ssl crt-list' */
11094static int cli_io_handler_dump_crtlist(struct appctx *appctx)
11095{
11096 struct buffer *trash = alloc_trash_chunk();
11097 struct stream_interface *si = appctx->owner;
11098 struct ebmb_node *lnode;
11099
11100 if (trash == NULL)
11101 return 1;
11102
11103 /* dump the list of crt-lists */
11104 lnode = appctx->ctx.cli.p1;
11105 if (lnode == NULL)
11106 lnode = ebmb_first(&crtlists_tree);
11107 while (lnode) {
11108 chunk_appendf(trash, "%s\n", lnode->key);
11109 if (ci_putchk(si_ic(si), trash) == -1) {
11110 si_rx_room_blk(si);
11111 goto yield;
11112 }
11113 lnode = ebmb_next(lnode);
11114 }
William Lallemand2ea1b492020-03-17 15:13:11 +010011115 free_trash_chunk(trash);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011116 return 1;
11117yield:
11118 appctx->ctx.cli.p1 = lnode;
William Lallemand2ea1b492020-03-17 15:13:11 +010011119 free_trash_chunk(trash);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011120 return 0;
11121}
11122
11123/* CLI IO handler for '(show|dump) ssl crt-list <filename>' */
11124static int cli_io_handler_dump_crtlist_entries(struct appctx *appctx)
11125{
11126 struct buffer *trash = alloc_trash_chunk();
11127 struct crtlist *crtlist;
11128 struct stream_interface *si = appctx->owner;
11129 struct crtlist_entry *entry;
11130
11131 if (trash == NULL)
11132 return 1;
11133
11134 crtlist = ebmb_entry(appctx->ctx.cli.p0, struct crtlist, node);
11135
11136 entry = appctx->ctx.cli.p1;
11137 if (entry == NULL) {
11138 entry = LIST_ELEM((crtlist->ord_entries).n, typeof(entry), by_crtlist);
11139 chunk_appendf(trash, "# %s\n", crtlist->node.key);
11140 if (ci_putchk(si_ic(si), trash) == -1) {
11141 si_rx_room_blk(si);
11142 goto yield;
11143 }
11144 }
11145
11146 list_for_each_entry_from(entry, &crtlist->ord_entries, by_crtlist) {
11147 struct ckch_store *store;
11148 const char *filename;
11149
11150 store = entry->node.key;
11151 filename = store->path;
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011152 chunk_appendf(trash, "%s", filename);
William Lallemandc69f02d2020-04-06 19:07:03 +020011153 if (appctx->ctx.cli.i0 == 's') /* show */
11154 chunk_appendf(trash, ":%d", entry->linenum);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011155 dump_crtlist_sslconf(trash, entry->ssl_conf);
11156 dump_crtlist_filters(trash, entry);
11157 chunk_appendf(trash, "\n");
11158
11159 if (ci_putchk(si_ic(si), trash) == -1) {
11160 si_rx_room_blk(si);
11161 goto yield;
11162 }
11163 }
William Lallemand2ea1b492020-03-17 15:13:11 +010011164 free_trash_chunk(trash);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011165 return 1;
11166yield:
11167 appctx->ctx.cli.p1 = entry;
William Lallemand2ea1b492020-03-17 15:13:11 +010011168 free_trash_chunk(trash);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011169 return 0;
11170}
11171
11172/* CLI argument parser for '(show|dump) ssl crt-list' */
11173static int cli_parse_dump_crtlist(char **args, char *payload, struct appctx *appctx, void *private)
11174{
11175 struct ebmb_node *lnode;
William Lallemandc69f02d2020-04-06 19:07:03 +020011176 char *filename = NULL;
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011177 int mode;
11178
11179 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
11180 return 1;
11181
11182 appctx->ctx.cli.p0 = NULL;
11183 appctx->ctx.cli.p1 = NULL;
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011184
William Lallemandc69f02d2020-04-06 19:07:03 +020011185 if (*args[3] && !strcmp(args[3], "-n")) {
11186 mode = 's';
11187 filename = args[4];
11188 } else {
11189 mode = 'd';
11190 filename = args[3];
11191 }
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011192
William Lallemandc69f02d2020-04-06 19:07:03 +020011193 if (mode == 's' && !*args[4])
11194 return cli_err(appctx, "'show ssl crt-list -n' expects a filename or a directory\n");
11195
11196 if (filename && *filename) {
11197 lnode = ebst_lookup(&crtlists_tree, filename);
William Lallemanda6ffd5b2020-03-09 13:35:19 +010011198 if (lnode == NULL)
11199 return cli_err(appctx, "didn't find the specified filename\n");
11200
11201 appctx->ctx.cli.p0 = lnode;
11202 appctx->io_handler = cli_io_handler_dump_crtlist_entries;
11203 }
11204 appctx->ctx.cli.i0 = mode;
11205
11206 return 0;
11207}
William Lallemand44b35322019-10-17 16:28:40 +020011208
William Lallemande67c80b2020-03-25 14:42:37 +010011209/* release function of the "add ssl crt-list' command, free things and unlock
11210 the spinlock */
11211static void cli_release_add_crtlist(struct appctx *appctx)
11212{
11213 struct crtlist_entry *entry = appctx->ctx.cli.p1;
11214
11215 if (appctx->st2 != SETCERT_ST_FIN) {
11216 struct ckch_inst *inst, *inst_s;
11217 /* upon error free the ckch_inst and everything inside */
11218 ebpt_delete(&entry->node);
11219 LIST_DEL(&entry->by_crtlist);
11220 LIST_DEL(&entry->by_ckch_store);
11221
11222 list_for_each_entry_safe(inst, inst_s, &entry->ckch_inst, by_ckchs) {
William Lallemandd9d5d1b2020-04-09 16:31:05 +020011223 ckch_inst_free(inst);
William Lallemande67c80b2020-03-25 14:42:37 +010011224 }
11225 crtlist_free_filters(entry->filters);
11226 ssl_sock_free_ssl_conf(entry->ssl_conf);
11227 free(entry->ssl_conf);
11228 free(entry);
11229 }
11230
11231 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11232}
11233
11234
11235/* IO Handler for the "add ssl crt-list" command It adds a new entry in the
11236 * crt-list and generates the ckch_insts for each bind_conf that uses this crt-list
11237 *
11238 * The logic is the same as the "commit ssl cert" command but without the
11239 * freeing of the old structures, because there are none.
11240 */
11241static int cli_io_handler_add_crtlist(struct appctx *appctx)
11242{
11243 struct bind_conf_list *bind_conf_node;
11244 struct stream_interface *si = appctx->owner;
11245 struct crtlist *crtlist = appctx->ctx.cli.p0;
11246 struct crtlist_entry *entry = appctx->ctx.cli.p1;
11247 struct ckch_store *store = entry->node.key;
11248 struct buffer *trash = alloc_trash_chunk();
11249 struct ckch_inst *new_inst;
11250 char *err = NULL;
11251 int i = 0;
11252 int errcode = 0;
11253
11254 if (trash == NULL)
11255 goto error;
11256
11257 /* for each bind_conf which use the crt-list, a new ckch_inst must be
11258 * created.
11259 */
11260 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
11261 goto error;
11262
11263 while (1) {
11264 switch (appctx->st2) {
11265 case SETCERT_ST_INIT:
11266 /* This state just print the update message */
11267 chunk_printf(trash, "Inserting certificate '%s' in crt-list '%s'", store->path, crtlist->node.key);
11268 if (ci_putchk(si_ic(si), trash) == -1) {
11269 si_rx_room_blk(si);
11270 goto yield;
11271 }
11272 appctx->st2 = SETCERT_ST_GEN;
11273 /* fallthrough */
11274 case SETCERT_ST_GEN:
11275 bind_conf_node = appctx->ctx.cli.p2; /* get the previous ptr from the yield */
11276 if (bind_conf_node == NULL)
11277 bind_conf_node = crtlist->bind_conf;
11278 for (; bind_conf_node; bind_conf_node = bind_conf_node->next) {
11279 struct bind_conf *bind_conf = bind_conf_node->bind_conf;
11280 struct sni_ctx *sni;
11281
11282 /* yield every 10 generations */
11283 if (i > 10) {
11284 appctx->ctx.cli.p2 = bind_conf_node;
11285 goto yield;
11286 }
11287
11288 /* we don't support multi-cert bundles, only simple ones */
11289 errcode |= ckch_inst_new_load_store(store->path, store, bind_conf, entry->ssl_conf, entry->filters, entry->fcount, &new_inst, &err);
11290 if (errcode & ERR_CODE)
11291 goto error;
11292
11293 /* we need to initialize the SSL_CTX generated */
11294 /* this iterate on the newly generated SNIs in the new instance to prepare their SSL_CTX */
11295 list_for_each_entry(sni, &new_inst->sni_ctx, by_ckch_inst) {
11296 if (!sni->order) { /* we initialized only the first SSL_CTX because it's the same in the other sni_ctx's */
11297 errcode |= ssl_sock_prepare_ctx(bind_conf, new_inst->ssl_conf, sni->ctx, &err);
11298 if (errcode & ERR_CODE)
11299 goto error;
11300 }
11301 }
11302 /* display one dot for each new instance */
11303 chunk_appendf(trash, ".");
11304 i++;
11305 LIST_ADDQ(&store->ckch_inst, &new_inst->by_ckchs);
11306 }
11307 appctx->st2 = SETCERT_ST_INSERT;
11308 /* fallthrough */
11309 case SETCERT_ST_INSERT:
11310 /* insert SNIs in bind_conf */
11311 list_for_each_entry(new_inst, &store->ckch_inst, by_ckchs) {
11312 HA_RWLOCK_WRLOCK(SNI_LOCK, &new_inst->bind_conf->sni_lock);
11313 ssl_sock_load_cert_sni(new_inst, new_inst->bind_conf);
11314 HA_RWLOCK_WRUNLOCK(SNI_LOCK, &new_inst->bind_conf->sni_lock);
11315 }
William Lallemandc69f02d2020-04-06 19:07:03 +020011316 entry->linenum = ++crtlist->linecount;
William Lallemande67c80b2020-03-25 14:42:37 +010011317 appctx->st2 = SETCERT_ST_FIN;
11318 goto end;
11319 }
11320 }
11321
11322end:
11323 chunk_appendf(trash, "\n");
11324 if (errcode & ERR_WARN)
11325 chunk_appendf(trash, "%s", err);
11326 chunk_appendf(trash, "Success!\n");
11327 if (ci_putchk(si_ic(si), trash) == -1)
11328 si_rx_room_blk(si);
11329 free_trash_chunk(trash);
11330 /* success: call the release function and don't come back */
11331 return 1;
11332yield:
11333 /* store the state */
11334 if (ci_putchk(si_ic(si), trash) == -1)
11335 si_rx_room_blk(si);
11336 free_trash_chunk(trash);
11337 si_rx_endp_more(si); /* let's come back later */
11338 return 0; /* should come back */
11339
11340error:
11341 /* spin unlock and free are done in the release function */
11342 if (trash) {
11343 chunk_appendf(trash, "\n%sFailed!\n", err);
11344 if (ci_putchk(si_ic(si), trash) == -1)
11345 si_rx_room_blk(si);
11346 free_trash_chunk(trash);
11347 }
11348 /* error: call the release function and don't come back */
11349 return 1;
11350}
11351
11352
11353/*
11354 * Parse a "add ssl crt-list <crt-list> <certfile>" line.
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011355 * Filters and option must be passed through payload:
William Lallemande67c80b2020-03-25 14:42:37 +010011356 */
11357static int cli_parse_add_crtlist(char **args, char *payload, struct appctx *appctx, void *private)
11358{
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011359 int cfgerr = 0;
William Lallemande67c80b2020-03-25 14:42:37 +010011360 struct ckch_store *store;
11361 char *err = NULL;
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011362 char path[MAXPATHLEN+1];
11363 char *crtlist_path;
11364 char *cert_path = NULL;
William Lallemande67c80b2020-03-25 14:42:37 +010011365 struct ebmb_node *eb;
11366 struct ebpt_node *inserted;
11367 struct crtlist *crtlist;
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011368 struct crtlist_entry *entry = NULL;
William Lallemande67c80b2020-03-25 14:42:37 +010011369
11370 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
11371 return 1;
11372
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011373 if (!*args[3] || (!payload && !*args[4]))
William Lallemande67c80b2020-03-25 14:42:37 +010011374 return cli_err(appctx, "'add ssl crtlist' expects a filename and a certificate name\n");
11375
11376 crtlist_path = args[3];
William Lallemande67c80b2020-03-25 14:42:37 +010011377
11378 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
11379 return cli_err(appctx, "Operations on certificates are currently locked!\n");
11380
11381 eb = ebst_lookup(&crtlists_tree, crtlist_path);
11382 if (!eb) {
11383 memprintf(&err, "crt-list '%s' does not exist!", crtlist_path);
11384 goto error;
11385 }
11386 crtlist = ebmb_entry(eb, struct crtlist, node);
11387
William Lallemande718dfb2020-04-10 11:09:25 +020011388 entry = crtlist_entry_new();
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011389 if (entry == NULL) {
11390 memprintf(&err, "Not enough memory!");
11391 goto error;
11392 }
William Lallemandc7c7a6b2020-04-01 17:32:46 +020011393
11394 if (payload) {
11395 char *lf;
11396
11397 lf = strrchr(payload, '\n');
11398 if (lf) {
11399 memprintf(&err, "only one line of payload is supported!");
11400 goto error;
11401 }
11402 /* cert_path is filled here */
11403 cfgerr |= crtlist_parse_line(payload, &cert_path, entry, "CLI", 1, &err);
11404 if (cfgerr & ERR_CODE)
11405 goto error;
11406 } else {
11407 cert_path = args[4];
11408 }
11409
11410 if (!cert_path) {
11411 memprintf(&err, "'add ssl crtlist' should contain the certificate name in the payload");
11412 cfgerr |= ERR_ALERT | ERR_FATAL;
11413 goto error;
11414 }
11415
11416 if (*cert_path != '/' && global_ssl.crt_base) {
11417 if ((strlen(global_ssl.crt_base) + 1 + strlen(cert_path)) > MAXPATHLEN) {
11418 memprintf(&err, "'%s' : path too long", cert_path);
11419 cfgerr |= ERR_ALERT | ERR_FATAL;
11420 goto error;
11421 }
11422 snprintf(path, sizeof(path), "%s/%s", global_ssl.crt_base, cert_path);
11423 cert_path = path;
11424 }
11425
William Lallemande67c80b2020-03-25 14:42:37 +010011426 store = ckchs_lookup(cert_path);
11427 if (store == NULL) {
11428 memprintf(&err, "certificate '%s' does not exist!", cert_path);
11429 goto error;
11430 }
William Lallemand36ccc392020-04-08 10:57:24 +020011431 if (store->multi) {
11432 memprintf(&err, "certificate '%s' is a bundle. You can disable the bundle merging with the directive 'ssl-load-extra-files' in the global section.", cert_path);
11433 goto error;
11434 }
William Lallemande67c80b2020-03-25 14:42:37 +010011435 if (store->ckch == NULL || store->ckch->cert == NULL) {
11436 memprintf(&err, "certificate '%s' is empty!", cert_path);
11437 goto error;
11438 }
11439
William Lallemande67c80b2020-03-25 14:42:37 +010011440 /* check if it's possible to insert this new crtlist_entry */
11441 entry->node.key = store;
11442 inserted = ebpt_insert(&crtlist->entries, &entry->node);
11443 if (inserted != &entry->node) {
11444 memprintf(&err, "file already exists in this directory!");
William Lallemande67c80b2020-03-25 14:42:37 +010011445 goto error;
11446 }
11447
11448 LIST_ADDQ(&crtlist->ord_entries, &entry->by_crtlist);
William Lallemande67c80b2020-03-25 14:42:37 +010011449 entry->crtlist = crtlist;
11450 LIST_ADDQ(&store->crtlist_entry, &entry->by_ckch_store);
11451
11452 appctx->st2 = SETCERT_ST_INIT;
11453 appctx->ctx.cli.p0 = crtlist;
11454 appctx->ctx.cli.p1 = entry;
11455
11456 /* unlock is done in the release handler */
11457 return 0;
11458
11459error:
William Lallemande718dfb2020-04-10 11:09:25 +020011460 crtlist_entry_free(entry);
William Lallemande67c80b2020-03-25 14:42:37 +010011461 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11462 err = memprintf(&err, "Can't edit the crt-list: %s\n", err ? err : "");
11463 return cli_dynerr(appctx, err);
11464}
11465
William Lallemand0a9b9412020-04-06 17:43:05 +020011466/* Parse a "del ssl crt-list <crt-list> <certfile>" line. */
11467static int cli_parse_del_crtlist(char **args, char *payload, struct appctx *appctx, void *private)
11468{
11469 struct ckch_store *store;
11470 char *err = NULL;
11471 char *crtlist_path, *cert_path;
11472 struct ebmb_node *ebmb;
11473 struct ebpt_node *ebpt;
11474 struct crtlist *crtlist;
11475 struct crtlist_entry *entry = NULL;
11476 struct ckch_inst *inst, *inst_s;
11477 int linenum = 0;
11478 char *colons;
11479
11480 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
11481 return 1;
11482
11483 if (!*args[3] || !*args[4])
11484 return cli_err(appctx, "'del ssl crtlist' expects a filename and a certificate name\n");
11485
William Lallemand463b5242020-04-08 10:30:44 +020011486 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
11487 return cli_err(appctx, "Can't delete!\nOperations on certificates are currently locked!\n");
11488
William Lallemand0a9b9412020-04-06 17:43:05 +020011489 crtlist_path = args[3];
11490 cert_path = args[4];
11491
11492 colons = strchr(cert_path, ':');
11493 if (colons) {
11494 char *endptr;
11495
11496 linenum = strtol(colons + 1, &endptr, 10);
11497 if (colons + 1 == endptr || *endptr != '\0') {
11498 memprintf(&err, "wrong line number after colons in '%s'!", cert_path);
11499 goto error;
11500 }
11501 *colons = '\0';
11502 }
11503 /* look for crtlist */
11504 ebmb = ebst_lookup(&crtlists_tree, crtlist_path);
11505 if (!ebmb) {
11506 memprintf(&err, "crt-list '%s' does not exist!", crtlist_path);
11507 goto error;
11508 }
11509 crtlist = ebmb_entry(ebmb, struct crtlist, node);
11510
11511 /* look for store */
11512 store = ckchs_lookup(cert_path);
11513 if (store == NULL) {
11514 memprintf(&err, "certificate '%s' does not exist!", cert_path);
11515 goto error;
11516 }
William Lallemand36ccc392020-04-08 10:57:24 +020011517 if (store->multi) {
11518 memprintf(&err, "certificate '%s' is a bundle. You can disable the bundle merging with the directive 'ssl-load-extra-files' in the global section.", cert_path);
11519 goto error;
11520 }
William Lallemand0a9b9412020-04-06 17:43:05 +020011521 if (store->ckch == NULL || store->ckch->cert == NULL) {
11522 memprintf(&err, "certificate '%s' is empty!", cert_path);
11523 goto error;
11524 }
11525
11526 ebpt = ebpt_lookup(&crtlist->entries, store);
11527 if (!ebpt) {
11528 memprintf(&err, "certificate '%s' can't be found in crt-list '%s'!", cert_path, crtlist_path);
11529 goto error;
11530 }
11531
11532 /* list the line number of entries for errors in err, and select the right ebpt */
11533 for (; ebpt; ebpt = ebpt_next_dup(ebpt)) {
11534 struct crtlist_entry *tmp;
11535
11536 tmp = ebpt_entry(ebpt, struct crtlist_entry, node);
11537 memprintf(&err, "%s%s%d", err ? err : "", err ? ", " : "", tmp->linenum);
11538
11539 /* select the entry we wanted */
11540 if (linenum == 0 || tmp->linenum == linenum) {
11541 if (!entry)
11542 entry = tmp;
11543 }
11544 }
11545
11546 /* we didn't found the specified entry */
11547 if (!entry) {
11548 memprintf(&err, "found a certificate '%s' but the line number is incorrect, please specify a correct line number preceded by colons (%s)!", cert_path, err ? err : NULL);
11549 goto error;
11550 }
11551
11552 /* we didn't specified a line number but there were several entries */
11553 if (linenum == 0 && ebpt_next_dup(&entry->node)) {
11554 memprintf(&err, "found the certificate '%s' in several entries, please specify a line number preceded by colons (%s)!", cert_path, err ? err : NULL);
11555 goto error;
11556 }
11557
11558 /* upon error free the ckch_inst and everything inside */
11559
11560 ebpt_delete(&entry->node);
11561 LIST_DEL(&entry->by_crtlist);
11562 LIST_DEL(&entry->by_ckch_store);
11563
11564 list_for_each_entry_safe(inst, inst_s, &entry->ckch_inst, by_crtlist_entry) {
11565 struct sni_ctx *sni, *sni_s;
11566
11567 HA_RWLOCK_WRLOCK(SNI_LOCK, &inst->bind_conf->sni_lock);
11568 list_for_each_entry_safe(sni, sni_s, &inst->sni_ctx, by_ckch_inst) {
11569 ebmb_delete(&sni->name);
11570 LIST_DEL(&sni->by_ckch_inst);
William Lallemand02e19a52020-04-08 16:11:26 +020011571 SSL_CTX_free(sni->ctx);
William Lallemand0a9b9412020-04-06 17:43:05 +020011572 free(sni);
11573 }
11574 HA_RWLOCK_WRUNLOCK(SNI_LOCK, &inst->bind_conf->sni_lock);
11575 LIST_DEL(&inst->by_ckchs);
11576 free(inst);
11577 }
11578
11579 crtlist_free_filters(entry->filters);
11580 ssl_sock_free_ssl_conf(entry->ssl_conf);
11581 free(entry->ssl_conf);
11582 free(entry);
11583
11584 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11585 err = memprintf(&err, "Entry '%s' deleted in crtlist '%s'!\n", cert_path, crtlist_path);
11586 return cli_dynmsg(appctx, LOG_NOTICE, err);
11587
11588error:
11589 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11590 err = memprintf(&err, "Can't delete the entry: %s\n", err ? err : "");
11591 return cli_dynerr(appctx, err);
11592}
William Lallemande67c80b2020-03-25 14:42:37 +010011593
William Lallemand44b35322019-10-17 16:28:40 +020011594/* Type of SSL payloads that can be updated over the CLI */
11595
11596enum {
11597 CERT_TYPE_PEM = 0,
William Lallemand4c5adbf2020-02-24 14:23:22 +010011598 CERT_TYPE_KEY,
Emmanuel Hocdetf6ac4fa2019-10-30 17:41:27 +010011599#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
William Lallemand44b35322019-10-17 16:28:40 +020011600 CERT_TYPE_OCSP,
Emmanuel Hocdetf6ac4fa2019-10-30 17:41:27 +010011601#endif
William Lallemand44b35322019-10-17 16:28:40 +020011602 CERT_TYPE_ISSUER,
Emmanuel Hocdetf6ac4fa2019-10-30 17:41:27 +010011603#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
William Lallemand44b35322019-10-17 16:28:40 +020011604 CERT_TYPE_SCTL,
Emmanuel Hocdetf6ac4fa2019-10-30 17:41:27 +010011605#endif
William Lallemand44b35322019-10-17 16:28:40 +020011606 CERT_TYPE_MAX,
11607};
11608
11609struct {
11610 const char *ext;
11611 int type;
11612 int (*load)(const char *path, char *payload, struct cert_key_and_chain *ckch, char **err);
11613 /* add a parsing callback */
William Lallemandf29cdef2019-10-23 15:00:52 +020011614} cert_exts[CERT_TYPE_MAX+1] = {
William Lallemand44b35322019-10-17 16:28:40 +020011615 [CERT_TYPE_PEM] = { "", CERT_TYPE_PEM, &ssl_sock_load_pem_into_ckch }, /* default mode, no extensions */
William Lallemand4c5adbf2020-02-24 14:23:22 +010011616 [CERT_TYPE_KEY] = { "key", CERT_TYPE_KEY, &ssl_sock_load_key_into_ckch },
William Lallemand541a5342019-10-23 14:11:54 +020011617#if ((defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP) || defined OPENSSL_IS_BORINGSSL)
William Lallemand44b35322019-10-17 16:28:40 +020011618 [CERT_TYPE_OCSP] = { "ocsp", CERT_TYPE_OCSP, &ssl_sock_load_ocsp_response_from_file },
William Lallemand541a5342019-10-23 14:11:54 +020011619#endif
11620#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
William Lallemand44b35322019-10-17 16:28:40 +020011621 [CERT_TYPE_SCTL] = { "sctl", CERT_TYPE_SCTL, &ssl_sock_load_sctl_from_file },
William Lallemand541a5342019-10-23 14:11:54 +020011622#endif
William Lallemand44b35322019-10-17 16:28:40 +020011623 [CERT_TYPE_ISSUER] = { "issuer", CERT_TYPE_ISSUER, &ssl_sock_load_issuer_file_into_ckch },
William Lallemandf29cdef2019-10-23 15:00:52 +020011624 [CERT_TYPE_MAX] = { NULL, CERT_TYPE_MAX, NULL },
William Lallemand44b35322019-10-17 16:28:40 +020011625};
11626
William Lallemand8f840d72019-10-23 10:53:05 +020011627
William Lallemandd4f946c2019-12-05 10:26:40 +010011628/* release function of the `show ssl cert' command */
11629static void cli_release_show_cert(struct appctx *appctx)
11630{
11631 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11632}
11633
11634/* IO handler of "show ssl cert <filename>" */
11635static int cli_io_handler_show_cert(struct appctx *appctx)
11636{
11637 struct buffer *trash = alloc_trash_chunk();
11638 struct ebmb_node *node;
11639 struct stream_interface *si = appctx->owner;
11640 struct ckch_store *ckchs;
William Lallemandd4f946c2019-12-05 10:26:40 +010011641
11642 if (trash == NULL)
11643 return 1;
11644
11645 if (!appctx->ctx.ssl.old_ckchs) {
11646 if (ckchs_transaction.old_ckchs) {
11647 ckchs = ckchs_transaction.old_ckchs;
11648 chunk_appendf(trash, "# transaction\n");
11649 if (!ckchs->multi) {
11650 chunk_appendf(trash, "*%s\n", ckchs->path);
William Lallemandba22e902019-12-18 20:36:01 +010011651#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
William Lallemandd4f946c2019-12-05 10:26:40 +010011652 } else {
William Lallemanda25a19f2020-01-29 00:04:24 +010011653 int n;
11654
William Lallemandd4f946c2019-12-05 10:26:40 +010011655 chunk_appendf(trash, "*%s:", ckchs->path);
11656 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
11657 if (ckchs->ckch[n].cert)
11658 chunk_appendf(trash, " %s.%s\n", ckchs->path, SSL_SOCK_KEYTYPE_NAMES[n]);
11659 }
11660 chunk_appendf(trash, "\n");
William Lallemandba22e902019-12-18 20:36:01 +010011661#endif
William Lallemandd4f946c2019-12-05 10:26:40 +010011662 }
11663 }
11664 }
11665
11666 if (!appctx->ctx.cli.p0) {
11667 chunk_appendf(trash, "# filename\n");
11668 node = ebmb_first(&ckchs_tree);
11669 } else {
11670 node = &((struct ckch_store *)appctx->ctx.cli.p0)->node;
11671 }
11672 while (node) {
11673 ckchs = ebmb_entry(node, struct ckch_store, node);
11674 if (!ckchs->multi) {
11675 chunk_appendf(trash, "%s\n", ckchs->path);
William Lallemandba22e902019-12-18 20:36:01 +010011676#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
William Lallemandd4f946c2019-12-05 10:26:40 +010011677 } else {
William Lallemanda25a19f2020-01-29 00:04:24 +010011678 int n;
11679
William Lallemandd4f946c2019-12-05 10:26:40 +010011680 chunk_appendf(trash, "%s:", ckchs->path);
11681 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
11682 if (ckchs->ckch[n].cert)
11683 chunk_appendf(trash, " %s.%s", ckchs->path, SSL_SOCK_KEYTYPE_NAMES[n]);
11684 }
11685 chunk_appendf(trash, "\n");
William Lallemandba22e902019-12-18 20:36:01 +010011686#endif
William Lallemandd4f946c2019-12-05 10:26:40 +010011687 }
11688
11689 node = ebmb_next(node);
11690 if (ci_putchk(si_ic(si), trash) == -1) {
11691 si_rx_room_blk(si);
11692 goto yield;
11693 }
11694 }
11695
11696 appctx->ctx.cli.p0 = NULL;
11697 free_trash_chunk(trash);
11698 return 1;
11699yield:
11700
11701 free_trash_chunk(trash);
11702 appctx->ctx.cli.p0 = ckchs;
11703 return 0; /* should come back */
11704}
11705
11706/* IO handler of the details "show ssl cert <filename>" */
11707static int cli_io_handler_show_cert_detail(struct appctx *appctx)
11708{
11709 struct stream_interface *si = appctx->owner;
11710 struct ckch_store *ckchs = appctx->ctx.cli.p0;
11711 struct buffer *out = alloc_trash_chunk();
11712 struct buffer *tmp = alloc_trash_chunk();
11713 X509_NAME *name = NULL;
Emmanuel Hocdetcf8cf6c2020-02-18 16:06:14 +010011714 STACK_OF(X509) *chain;
Willy Tarreau105599c2020-02-25 08:59:23 +010011715 unsigned int len = 0;
William Lallemandd4f946c2019-12-05 10:26:40 +010011716 int write = -1;
11717 BIO *bio = NULL;
William Lallemand35f4a9d2020-02-25 11:56:32 +010011718 int i;
William Lallemandd4f946c2019-12-05 10:26:40 +010011719
11720 if (!tmp || !out)
William Lallemand18eeb8e2020-03-20 14:42:36 +010011721 goto end_no_putchk;
William Lallemandd4f946c2019-12-05 10:26:40 +010011722
11723 if (!ckchs->multi) {
11724 chunk_appendf(out, "Filename: ");
11725 if (ckchs == ckchs_transaction.new_ckchs)
11726 chunk_appendf(out, "*");
11727 chunk_appendf(out, "%s\n", ckchs->path);
Emmanuel Hocdetcf8cf6c2020-02-18 16:06:14 +010011728
William Lallemand59c16fc2020-03-19 20:26:02 +010011729 chunk_appendf(out, "Status: ");
11730 if (ckchs->ckch->cert == NULL)
11731 chunk_appendf(out, "Empty\n");
11732 else if (LIST_ISEMPTY(&ckchs->ckch_inst))
11733 chunk_appendf(out, "Unused\n");
11734 else
11735 chunk_appendf(out, "Used\n");
11736
William Lallemandea987ed2020-03-19 16:48:33 +010011737 if (ckchs->ckch->cert == NULL)
11738 goto end;
11739
Emmanuel Hocdetcf8cf6c2020-02-18 16:06:14 +010011740 chain = ckchs->ckch->chain;
11741 if (chain == NULL) {
11742 struct issuer_chain *issuer;
Emmanuel Hocdetef87e0a2020-03-23 11:29:11 +010011743 issuer = ssl_get0_issuer_chain(ckchs->ckch->cert);
Emmanuel Hocdetcf8cf6c2020-02-18 16:06:14 +010011744 if (issuer) {
11745 chain = issuer->chain;
11746 chunk_appendf(out, "Chain Filename: ");
11747 chunk_appendf(out, "%s\n", issuer->path);
11748 }
11749 }
William Lallemandd4f946c2019-12-05 10:26:40 +010011750 chunk_appendf(out, "Serial: ");
11751 if (ssl_sock_get_serial(ckchs->ckch->cert, tmp) == -1)
11752 goto end;
11753 dump_binary(out, tmp->area, tmp->data);
11754 chunk_appendf(out, "\n");
11755
11756 chunk_appendf(out, "notBefore: ");
11757 chunk_reset(tmp);
11758 if ((bio = BIO_new(BIO_s_mem())) == NULL)
11759 goto end;
11760 if (ASN1_TIME_print(bio, X509_getm_notBefore(ckchs->ckch->cert)) == 0)
11761 goto end;
11762 write = BIO_read(bio, tmp->area, tmp->size-1);
11763 tmp->area[write] = '\0';
11764 BIO_free(bio);
William Lallemand67b991d2020-03-20 14:10:17 +010011765 bio = NULL;
William Lallemandd4f946c2019-12-05 10:26:40 +010011766 chunk_appendf(out, "%s\n", tmp->area);
11767
11768 chunk_appendf(out, "notAfter: ");
11769 chunk_reset(tmp);
11770 if ((bio = BIO_new(BIO_s_mem())) == NULL)
11771 goto end;
11772 if (ASN1_TIME_print(bio, X509_getm_notAfter(ckchs->ckch->cert)) == 0)
11773 goto end;
11774 if ((write = BIO_read(bio, tmp->area, tmp->size-1)) <= 0)
11775 goto end;
11776 tmp->area[write] = '\0';
11777 BIO_free(bio);
William Lallemand67b991d2020-03-20 14:10:17 +010011778 bio = NULL;
William Lallemandd4f946c2019-12-05 10:26:40 +010011779 chunk_appendf(out, "%s\n", tmp->area);
11780
William Lallemandd4f946c2019-12-05 10:26:40 +010011781#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
11782 chunk_appendf(out, "Subject Alternative Name: ");
11783 if (ssl_sock_get_san_oneline(ckchs->ckch->cert, out) == -1)
11784 goto end;
11785 *(out->area + out->data) = '\0';
11786 chunk_appendf(out, "\n");
11787#endif
11788 chunk_reset(tmp);
11789 chunk_appendf(out, "Algorithm: ");
11790 if (cert_get_pkey_algo(ckchs->ckch->cert, tmp) == 0)
11791 goto end;
11792 chunk_appendf(out, "%s\n", tmp->area);
11793
11794 chunk_reset(tmp);
11795 chunk_appendf(out, "SHA1 FingerPrint: ");
Willy Tarreau105599c2020-02-25 08:59:23 +010011796 if (X509_digest(ckchs->ckch->cert, EVP_sha1(), (unsigned char *) tmp->area, &len) == 0)
William Lallemandd4f946c2019-12-05 10:26:40 +010011797 goto end;
Willy Tarreau105599c2020-02-25 08:59:23 +010011798 tmp->data = len;
William Lallemandd4f946c2019-12-05 10:26:40 +010011799 dump_binary(out, tmp->area, tmp->data);
11800 chunk_appendf(out, "\n");
William Lallemand35f4a9d2020-02-25 11:56:32 +010011801
William Lallemanda90e5932020-02-25 14:07:58 +010011802 chunk_appendf(out, "Subject: ");
11803 if ((name = X509_get_subject_name(ckchs->ckch->cert)) == NULL)
11804 goto end;
11805 if ((ssl_sock_get_dn_oneline(name, tmp)) == -1)
11806 goto end;
11807 *(tmp->area + tmp->data) = '\0';
11808 chunk_appendf(out, "%s\n", tmp->area);
11809
11810 chunk_appendf(out, "Issuer: ");
11811 if ((name = X509_get_issuer_name(ckchs->ckch->cert)) == NULL)
11812 goto end;
11813 if ((ssl_sock_get_dn_oneline(name, tmp)) == -1)
11814 goto end;
11815 *(tmp->area + tmp->data) = '\0';
11816 chunk_appendf(out, "%s\n", tmp->area);
11817
William Lallemand35f4a9d2020-02-25 11:56:32 +010011818 /* Displays subject of each certificate in the chain */
Emmanuel Hocdetcf8cf6c2020-02-18 16:06:14 +010011819 for (i = 0; i < sk_X509_num(chain); i++) {
11820 X509 *ca = sk_X509_value(chain, i);
William Lallemand35f4a9d2020-02-25 11:56:32 +010011821
William Lallemandbb7288a2020-02-25 14:04:33 +010011822 chunk_appendf(out, "Chain Subject: ");
William Lallemand35f4a9d2020-02-25 11:56:32 +010011823 if ((name = X509_get_subject_name(ca)) == NULL)
11824 goto end;
11825 if ((ssl_sock_get_dn_oneline(name, tmp)) == -1)
11826 goto end;
11827 *(tmp->area + tmp->data) = '\0';
11828 chunk_appendf(out, "%s\n", tmp->area);
11829
William Lallemandbb7288a2020-02-25 14:04:33 +010011830 chunk_appendf(out, "Chain Issuer: ");
11831 if ((name = X509_get_issuer_name(ca)) == NULL)
11832 goto end;
11833 if ((ssl_sock_get_dn_oneline(name, tmp)) == -1)
11834 goto end;
11835 *(tmp->area + tmp->data) = '\0';
11836 chunk_appendf(out, "%s\n", tmp->area);
William Lallemand35f4a9d2020-02-25 11:56:32 +010011837 }
William Lallemandd4f946c2019-12-05 10:26:40 +010011838 }
11839
William Lallemandea987ed2020-03-19 16:48:33 +010011840end:
William Lallemandd4f946c2019-12-05 10:26:40 +010011841 if (ci_putchk(si_ic(si), out) == -1) {
11842 si_rx_room_blk(si);
11843 goto yield;
11844 }
11845
William Lallemand18eeb8e2020-03-20 14:42:36 +010011846end_no_putchk:
William Lallemand67b991d2020-03-20 14:10:17 +010011847 if (bio)
11848 BIO_free(bio);
William Lallemandd4f946c2019-12-05 10:26:40 +010011849 free_trash_chunk(tmp);
11850 free_trash_chunk(out);
11851 return 1;
11852yield:
11853 free_trash_chunk(tmp);
11854 free_trash_chunk(out);
11855 return 0; /* should come back */
11856}
11857
11858/* parsing function for 'show ssl cert [certfile]' */
11859static int cli_parse_show_cert(char **args, char *payload, struct appctx *appctx, void *private)
11860{
11861 struct ckch_store *ckchs;
11862
11863 if (!cli_has_level(appctx, ACCESS_LVL_OPER))
11864 return cli_err(appctx, "Can't allocate memory!\n");
11865
11866 /* The operations on the CKCH architecture are locked so we can
11867 * manipulate ckch_store and ckch_inst */
11868 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
11869 return cli_err(appctx, "Can't show!\nOperations on certificates are currently locked!\n");
11870
11871 /* check if there is a certificate to lookup */
11872 if (*args[3]) {
11873 if (*args[3] == '*') {
11874 if (!ckchs_transaction.new_ckchs)
11875 goto error;
11876
11877 ckchs = ckchs_transaction.new_ckchs;
11878
11879 if (strcmp(args[3] + 1, ckchs->path))
11880 goto error;
11881
11882 } else {
11883 if ((ckchs = ckchs_lookup(args[3])) == NULL)
11884 goto error;
11885
11886 }
11887
11888 if (ckchs->multi)
11889 goto error;
11890
11891 appctx->ctx.cli.p0 = ckchs;
11892 /* use the IO handler that shows details */
11893 appctx->io_handler = cli_io_handler_show_cert_detail;
11894 }
11895
11896 return 0;
11897
11898error:
11899 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
11900 return cli_err(appctx, "Can't display the certificate: Not found or the certificate is a bundle!\n");
11901}
11902
William Lallemand430413e2019-10-28 14:30:47 +010011903/* release function of the `set ssl cert' command, free things and unlock the spinlock */
William Lallemandbc6ca7c2019-10-29 23:48:19 +010011904static void cli_release_commit_cert(struct appctx *appctx)
William Lallemand8f840d72019-10-23 10:53:05 +020011905{
11906 struct ckch_store *new_ckchs;
William Lallemand8f840d72019-10-23 10:53:05 +020011907
William Lallemand430413e2019-10-28 14:30:47 +010011908 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
William Lallemand8f840d72019-10-23 10:53:05 +020011909
William Lallemand430413e2019-10-28 14:30:47 +010011910 if (appctx->st2 != SETCERT_ST_FIN) {
William Lallemand8f840d72019-10-23 10:53:05 +020011911 /* free every new sni_ctx and the new store, which are not in the trees so no spinlock there */
William Lallemandbeea2a42019-10-30 17:45:33 +010011912 new_ckchs = appctx->ctx.ssl.new_ckchs;
William Lallemand8f840d72019-10-23 10:53:05 +020011913
William Lallemandbeea2a42019-10-30 17:45:33 +010011914 /* if the allocation failed, we need to free everything from the temporary list */
William Lallemandba1c33f2020-04-08 17:55:45 +020011915 ckch_store_free(new_ckchs);
William Lallemand8f840d72019-10-23 10:53:05 +020011916 }
11917}
11918
11919
11920/*
11921 * This function tries to create the new ckch_inst and their SNIs
11922 */
William Lallemandbc6ca7c2019-10-29 23:48:19 +010011923static int cli_io_handler_commit_cert(struct appctx *appctx)
William Lallemand8f840d72019-10-23 10:53:05 +020011924{
11925 struct stream_interface *si = appctx->owner;
11926 int y = 0;
11927 char *err = NULL;
11928 int errcode = 0;
11929 struct ckch_store *old_ckchs, *new_ckchs = NULL;
11930 struct ckch_inst *ckchi, *ckchis;
William Lallemand8f840d72019-10-23 10:53:05 +020011931 struct buffer *trash = alloc_trash_chunk();
William Lallemand8ef0c2a2019-11-21 16:30:34 +010011932 struct sni_ctx *sc0, *sc0s;
William Lallemand90afe902020-03-30 19:29:45 +020011933 struct crtlist_entry *entry;
William Lallemand8f840d72019-10-23 10:53:05 +020011934
William Lallemand33cc76f2019-10-31 11:43:45 +010011935 if (trash == NULL)
11936 goto error;
11937
William Lallemand8f840d72019-10-23 10:53:05 +020011938 if (unlikely(si_ic(si)->flags & (CF_WRITE_ERROR|CF_SHUTW)))
11939 goto error;
11940
William Lallemand430413e2019-10-28 14:30:47 +010011941 while (1) {
11942 switch (appctx->st2) {
11943 case SETCERT_ST_INIT:
11944 /* This state just print the update message */
William Lallemandbc6ca7c2019-10-29 23:48:19 +010011945 chunk_printf(trash, "Committing %s", ckchs_transaction.path);
William Lallemand430413e2019-10-28 14:30:47 +010011946 if (ci_putchk(si_ic(si), trash) == -1) {
11947 si_rx_room_blk(si);
William Lallemand8f840d72019-10-23 10:53:05 +020011948 goto yield;
William Lallemand430413e2019-10-28 14:30:47 +010011949 }
11950 appctx->st2 = SETCERT_ST_GEN;
11951 /* fallthrough */
11952 case SETCERT_ST_GEN:
11953 /*
11954 * This state generates the ckch instances with their
11955 * sni_ctxs and SSL_CTX.
11956 *
William Lallemand430413e2019-10-28 14:30:47 +010011957 * Since the SSL_CTX generation can be CPU consumer, we
11958 * yield every 10 instances.
11959 */
William Lallemand8f840d72019-10-23 10:53:05 +020011960
William Lallemandbeea2a42019-10-30 17:45:33 +010011961 old_ckchs = appctx->ctx.ssl.old_ckchs;
11962 new_ckchs = appctx->ctx.ssl.new_ckchs;
William Lallemand8f840d72019-10-23 10:53:05 +020011963
William Lallemandbeea2a42019-10-30 17:45:33 +010011964 if (!new_ckchs)
11965 continue;
William Lallemand8f840d72019-10-23 10:53:05 +020011966
William Lallemandbeea2a42019-10-30 17:45:33 +010011967 /* get the next ckchi to regenerate */
11968 ckchi = appctx->ctx.ssl.next_ckchi;
11969 /* we didn't start yet, set it to the first elem */
11970 if (ckchi == NULL)
11971 ckchi = LIST_ELEM(old_ckchs->ckch_inst.n, typeof(ckchi), by_ckchs);
William Lallemand8f840d72019-10-23 10:53:05 +020011972
William Lallemandbeea2a42019-10-30 17:45:33 +010011973 /* walk through the old ckch_inst and creates new ckch_inst using the updated ckchs */
11974 list_for_each_entry_from(ckchi, &old_ckchs->ckch_inst, by_ckchs) {
11975 struct ckch_inst *new_inst;
William Lallemand38df1c82019-12-04 15:39:35 +010011976 char **sni_filter = NULL;
11977 int fcount = 0;
William Lallemand8f840d72019-10-23 10:53:05 +020011978
William Lallemandbeea2a42019-10-30 17:45:33 +010011979 /* it takes a lot of CPU to creates SSL_CTXs, so we yield every 10 CKCH instances */
11980 if (y >= 10) {
11981 /* save the next ckchi to compute */
11982 appctx->ctx.ssl.next_ckchi = ckchi;
11983 goto yield;
11984 }
William Lallemandcaa16192020-04-08 16:29:15 +020011985
11986 if (ckchi->crtlist_entry) {
11987 sni_filter = ckchi->crtlist_entry->filters;
11988 fcount = ckchi->crtlist_entry->fcount;
William Lallemand67630162020-03-09 16:56:39 +010011989 }
William Lallemand38df1c82019-12-04 15:39:35 +010011990
William Lallemandbeea2a42019-10-30 17:45:33 +010011991 if (new_ckchs->multi)
William Lallemand38df1c82019-12-04 15:39:35 +010011992 errcode |= ckch_inst_new_load_multi_store(new_ckchs->path, new_ckchs, ckchi->bind_conf, ckchi->ssl_conf, sni_filter, fcount, &new_inst, &err);
William Lallemandbeea2a42019-10-30 17:45:33 +010011993 else
William Lallemand38df1c82019-12-04 15:39:35 +010011994 errcode |= ckch_inst_new_load_store(new_ckchs->path, new_ckchs, ckchi->bind_conf, ckchi->ssl_conf, sni_filter, fcount, &new_inst, &err);
11995
William Lallemandbeea2a42019-10-30 17:45:33 +010011996 if (errcode & ERR_CODE)
11997 goto error;
William Lallemand8f840d72019-10-23 10:53:05 +020011998
William Lallemand21724f02019-11-04 17:56:13 +010011999 /* if the previous ckchi was used as the default */
12000 if (ckchi->is_default)
12001 new_inst->is_default = 1;
12002
William Lallemand8ef0c2a2019-11-21 16:30:34 +010012003 /* we need to initialize the SSL_CTX generated */
William Lallemand696f3172020-02-07 20:45:24 +010012004 /* this iterate on the newly generated SNIs in the new instance to prepare their SSL_CTX */
12005 list_for_each_entry_safe(sc0, sc0s, &new_inst->sni_ctx, by_ckch_inst) {
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012006 if (!sc0->order) { /* we initialized only the first SSL_CTX because it's the same in the other sni_ctx's */
William Lallemand8ef0c2a2019-11-21 16:30:34 +010012007 errcode |= ssl_sock_prepare_ctx(ckchi->bind_conf, ckchi->ssl_conf, sc0->ctx, &err);
12008 if (errcode & ERR_CODE)
12009 goto error;
12010 }
12011 }
12012
12013
William Lallemandbeea2a42019-10-30 17:45:33 +010012014 /* display one dot per new instance */
12015 chunk_appendf(trash, ".");
12016 /* link the new ckch_inst to the duplicate */
12017 LIST_ADDQ(&new_ckchs->ckch_inst, &new_inst->by_ckchs);
12018 y++;
12019 }
William Lallemand430413e2019-10-28 14:30:47 +010012020 appctx->st2 = SETCERT_ST_INSERT;
12021 /* fallthrough */
12022 case SETCERT_ST_INSERT:
12023 /* The generation is finished, we can insert everything */
William Lallemand8f840d72019-10-23 10:53:05 +020012024
William Lallemandbeea2a42019-10-30 17:45:33 +010012025 old_ckchs = appctx->ctx.ssl.old_ckchs;
12026 new_ckchs = appctx->ctx.ssl.new_ckchs;
William Lallemand8f840d72019-10-23 10:53:05 +020012027
William Lallemandbeea2a42019-10-30 17:45:33 +010012028 if (!new_ckchs)
12029 continue;
William Lallemand430413e2019-10-28 14:30:47 +010012030
William Lallemand90afe902020-03-30 19:29:45 +020012031 /* get the list of crtlist_entry in the old store, and update the pointers to the store */
12032 LIST_SPLICE(&new_ckchs->crtlist_entry, &old_ckchs->crtlist_entry);
12033 list_for_each_entry(entry, &new_ckchs->crtlist_entry, by_ckch_store) {
12034 ebpt_delete(&entry->node);
12035 /* change the ptr and reinsert the node */
12036 entry->node.key = new_ckchs;
12037 ebpt_insert(&entry->crtlist->entries, &entry->node);
12038 }
12039
William Lallemand21724f02019-11-04 17:56:13 +010012040 /* First, we insert every new SNIs in the trees, also replace the default_ctx */
William Lallemandbeea2a42019-10-30 17:45:33 +010012041 list_for_each_entry_safe(ckchi, ckchis, &new_ckchs->ckch_inst, by_ckchs) {
12042 HA_RWLOCK_WRLOCK(SNI_LOCK, &ckchi->bind_conf->sni_lock);
12043 ssl_sock_load_cert_sni(ckchi, ckchi->bind_conf);
12044 HA_RWLOCK_WRUNLOCK(SNI_LOCK, &ckchi->bind_conf->sni_lock);
12045 }
William Lallemand8f840d72019-10-23 10:53:05 +020012046
William Lallemandbeea2a42019-10-30 17:45:33 +010012047 /* delete the old sni_ctx, the old ckch_insts and the ckch_store */
12048 list_for_each_entry_safe(ckchi, ckchis, &old_ckchs->ckch_inst, by_ckchs) {
William Lallemandd5e93772020-04-09 17:12:16 +020012049 struct bind_conf *bind_conf = ckchi->bind_conf;
12050
12051 HA_RWLOCK_WRLOCK(SNI_LOCK, &bind_conf->sni_lock);
William Lallemandd9d5d1b2020-04-09 16:31:05 +020012052 ckch_inst_free(ckchi);
William Lallemandd5e93772020-04-09 17:12:16 +020012053 HA_RWLOCK_WRUNLOCK(SNI_LOCK, &bind_conf->sni_lock);
William Lallemandbeea2a42019-10-30 17:45:33 +010012054 }
William Lallemand8f840d72019-10-23 10:53:05 +020012055
William Lallemandbeea2a42019-10-30 17:45:33 +010012056 /* Replace the old ckchs by the new one */
William Lallemandba1c33f2020-04-08 17:55:45 +020012057 ckch_store_free(old_ckchs);
William Lallemandbeea2a42019-10-30 17:45:33 +010012058 ebst_insert(&ckchs_tree, &new_ckchs->node);
William Lallemand430413e2019-10-28 14:30:47 +010012059 appctx->st2 = SETCERT_ST_FIN;
12060 /* fallthrough */
12061 case SETCERT_ST_FIN:
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012062 /* we achieved the transaction, we can set everything to NULL */
12063 free(ckchs_transaction.path);
12064 ckchs_transaction.path = NULL;
12065 ckchs_transaction.new_ckchs = NULL;
12066 ckchs_transaction.old_ckchs = NULL;
William Lallemand430413e2019-10-28 14:30:47 +010012067 goto end;
12068 }
William Lallemand8f840d72019-10-23 10:53:05 +020012069 }
William Lallemand430413e2019-10-28 14:30:47 +010012070end:
William Lallemand8f840d72019-10-23 10:53:05 +020012071
William Lallemanded442432019-11-21 16:41:07 +010012072 chunk_appendf(trash, "\n");
12073 if (errcode & ERR_WARN)
Tim Duesterhusc0e820c2019-11-23 23:52:30 +010012074 chunk_appendf(trash, "%s", err);
William Lallemanded442432019-11-21 16:41:07 +010012075 chunk_appendf(trash, "Success!\n");
William Lallemand430413e2019-10-28 14:30:47 +010012076 if (ci_putchk(si_ic(si), trash) == -1)
12077 si_rx_room_blk(si);
12078 free_trash_chunk(trash);
12079 /* success: call the release function and don't come back */
12080 return 1;
William Lallemand8f840d72019-10-23 10:53:05 +020012081yield:
12082 /* store the state */
12083 if (ci_putchk(si_ic(si), trash) == -1)
12084 si_rx_room_blk(si);
12085 free_trash_chunk(trash);
12086 si_rx_endp_more(si); /* let's come back later */
William Lallemand8f840d72019-10-23 10:53:05 +020012087 return 0; /* should come back */
12088
12089error:
12090 /* spin unlock and free are done in the release function */
William Lallemand33cc76f2019-10-31 11:43:45 +010012091 if (trash) {
12092 chunk_appendf(trash, "\n%sFailed!\n", err);
12093 if (ci_putchk(si_ic(si), trash) == -1)
12094 si_rx_room_blk(si);
12095 free_trash_chunk(trash);
12096 }
William Lallemand430413e2019-10-28 14:30:47 +010012097 /* error: call the release function and don't come back */
12098 return 1;
William Lallemand8f840d72019-10-23 10:53:05 +020012099}
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012100
12101/*
12102 * Parsing function of 'commit ssl cert'
12103 */
12104static int cli_parse_commit_cert(char **args, char *payload, struct appctx *appctx, void *private)
12105{
12106 char *err = NULL;
12107
William Lallemand230662a2019-12-03 13:32:54 +010012108 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
12109 return 1;
12110
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012111 if (!*args[3])
12112 return cli_err(appctx, "'commit ssl cert expects a filename\n");
12113
12114 /* The operations on the CKCH architecture are locked so we can
12115 * manipulate ckch_store and ckch_inst */
12116 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
12117 return cli_err(appctx, "Can't commit the certificate!\nOperations on certificates are currently locked!\n");
12118
12119 if (!ckchs_transaction.path) {
12120 memprintf(&err, "No ongoing transaction! !\n");
12121 goto error;
12122 }
12123
12124 if (strcmp(ckchs_transaction.path, args[3]) != 0) {
12125 memprintf(&err, "The ongoing transaction is about '%s' but you are trying to set '%s'\n", ckchs_transaction.path, args[3]);
12126 goto error;
12127 }
12128
William Lallemand4c5adbf2020-02-24 14:23:22 +010012129#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
12130 if (ckchs_transaction.new_ckchs->multi) {
12131 int n;
12132
12133 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
12134 if (ckchs_transaction.new_ckchs->ckch[n].cert && !X509_check_private_key(ckchs_transaction.new_ckchs->ckch[n].cert, ckchs_transaction.new_ckchs->ckch[n].key)) {
12135 memprintf(&err, "inconsistencies between private key and certificate loaded '%s'.\n", ckchs_transaction.path);
12136 goto error;
12137 }
12138 }
12139 } else
12140#endif
12141 {
12142 if (!X509_check_private_key(ckchs_transaction.new_ckchs->ckch->cert, ckchs_transaction.new_ckchs->ckch->key)) {
12143 memprintf(&err, "inconsistencies between private key and certificate loaded '%s'.\n", ckchs_transaction.path);
12144 goto error;
12145 }
12146 }
12147
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012148 /* init the appctx structure */
12149 appctx->st2 = SETCERT_ST_INIT;
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012150 appctx->ctx.ssl.next_ckchi = NULL;
12151 appctx->ctx.ssl.new_ckchs = ckchs_transaction.new_ckchs;
12152 appctx->ctx.ssl.old_ckchs = ckchs_transaction.old_ckchs;
12153
12154 /* we don't unlock there, it will be unlock after the IO handler, in the release handler */
12155 return 0;
12156
12157error:
12158
12159 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12160 err = memprintf(&err, "%sCan't commit %s!\n", err ? err : "", args[3]);
12161
12162 return cli_dynerr(appctx, err);
12163}
12164
William Lallemand8f840d72019-10-23 10:53:05 +020012165/*
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012166 * Parsing function of `set ssl cert`, it updates or creates a temporary ckch.
William Lallemand8f840d72019-10-23 10:53:05 +020012167 */
William Lallemand150bfa82019-09-19 17:12:49 +020012168static int cli_parse_set_cert(char **args, char *payload, struct appctx *appctx, void *private)
12169{
William Lallemand0c3b7d92019-10-18 11:27:07 +020012170 struct ckch_store *new_ckchs = NULL;
William Lallemand8f840d72019-10-23 10:53:05 +020012171 struct ckch_store *old_ckchs = NULL;
William Lallemand150bfa82019-09-19 17:12:49 +020012172 char *err = NULL;
William Lallemand963b2e72019-10-14 11:38:36 +020012173 int i;
William Lallemand849eed62019-10-17 16:23:50 +020012174 int bundle = -1; /* TRUE if >= 0 (ckch index) */
Emeric Brunf69ed1d2019-10-17 11:56:56 +020012175 int errcode = 0;
William Lallemand44b35322019-10-17 16:28:40 +020012176 char *end;
12177 int type = CERT_TYPE_PEM;
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012178 struct cert_key_and_chain *ckch;
12179 struct buffer *buf;
William Lallemand8f840d72019-10-23 10:53:05 +020012180
William Lallemand230662a2019-12-03 13:32:54 +010012181 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
12182 return 1;
12183
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012184 if ((buf = alloc_trash_chunk()) == NULL)
12185 return cli_err(appctx, "Can't allocate memory\n");
William Lallemand150bfa82019-09-19 17:12:49 +020012186
12187 if (!*args[3] || !payload)
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012188 return cli_err(appctx, "'set ssl cert expects a filename and a certificate as a payload\n");
William Lallemand150bfa82019-09-19 17:12:49 +020012189
12190 /* The operations on the CKCH architecture are locked so we can
12191 * manipulate ckch_store and ckch_inst */
12192 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
12193 return cli_err(appctx, "Can't update the certificate!\nOperations on certificates are currently locked!\n");
12194
William Lallemand8f840d72019-10-23 10:53:05 +020012195 if (!chunk_strcpy(buf, args[3])) {
12196 memprintf(&err, "%sCan't allocate memory\n", err ? err : "");
12197 errcode |= ERR_ALERT | ERR_FATAL;
12198 goto end;
12199 }
12200
William Lallemand44b35322019-10-17 16:28:40 +020012201 /* check which type of file we want to update */
William Lallemandf29cdef2019-10-23 15:00:52 +020012202 for (i = 0; cert_exts[i].type < CERT_TYPE_MAX; i++) {
William Lallemand8f840d72019-10-23 10:53:05 +020012203 end = strrchr(buf->area, '.');
William Lallemand44b35322019-10-17 16:28:40 +020012204 if (end && *cert_exts[i].ext && (!strcmp(end + 1, cert_exts[i].ext))) {
12205 *end = '\0';
12206 type = cert_exts[i].type;
12207 break;
12208 }
12209 }
12210
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012211 appctx->ctx.ssl.old_ckchs = NULL;
12212 appctx->ctx.ssl.new_ckchs = NULL;
William Lallemand849eed62019-10-17 16:23:50 +020012213
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012214 /* if there is an ongoing transaction */
12215 if (ckchs_transaction.path) {
12216 /* if the ongoing transaction is a bundle, we need to find which part of the bundle need to be updated */
William Lallemand963b2e72019-10-14 11:38:36 +020012217#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012218 if (ckchs_transaction.new_ckchs->multi) {
Emmanuel Hocdet40f2f1e2019-10-30 17:31:28 +010012219 char *end;
William Lallemand963b2e72019-10-14 11:38:36 +020012220 int j;
William Lallemand150bfa82019-09-19 17:12:49 +020012221
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012222 /* check if it was used in a bundle by removing the
William Lallemand963b2e72019-10-14 11:38:36 +020012223 * .dsa/.rsa/.ecdsa at the end of the filename */
William Lallemand8f840d72019-10-23 10:53:05 +020012224 end = strrchr(buf->area, '.');
Emmanuel Hocdet40f2f1e2019-10-30 17:31:28 +010012225 for (j = 0; end && j < SSL_SOCK_NUM_KEYTYPES; j++) {
William Lallemand963b2e72019-10-14 11:38:36 +020012226 if (!strcmp(end + 1, SSL_SOCK_KEYTYPE_NAMES[j])) {
12227 bundle = j; /* keep the type of certificate so we insert it at the right place */
12228 *end = '\0'; /* it's a bundle let's end the string*/
12229 break;
12230 }
William Lallemand150bfa82019-09-19 17:12:49 +020012231 }
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012232 if (bundle < 0) {
12233 memprintf(&err, "The ongoing transaction is the '%s' bundle. You need to specify which part of the bundle you want to update ('%s.{rsa,ecdsa,dsa}')\n", ckchs_transaction.path, buf->area);
12234 errcode |= ERR_ALERT | ERR_FATAL;
12235 goto end;
12236 }
12237 }
12238#endif
12239
12240 /* if there is an ongoing transaction, check if this is the same file */
12241 if (strcmp(ckchs_transaction.path, buf->area) != 0) {
12242 memprintf(&err, "The ongoing transaction is about '%s' but you are trying to set '%s'\n", ckchs_transaction.path, buf->area);
12243 errcode |= ERR_ALERT | ERR_FATAL;
12244 goto end;
William Lallemand150bfa82019-09-19 17:12:49 +020012245 }
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012246
12247 appctx->ctx.ssl.old_ckchs = ckchs_transaction.new_ckchs;
12248
12249 } else {
12250 struct ckch_store *find_ckchs[2] = { NULL, NULL };
12251
12252 /* lookup for the certificate in the tree:
12253 * check if this is used as a bundle AND as a unique certificate */
12254 for (i = 0; i < 2; i++) {
12255
12256 if ((find_ckchs[i] = ckchs_lookup(buf->area)) != NULL) {
12257 /* only the bundle name is in the tree and you should
12258 * never update a bundle name, only a filename */
12259 if (bundle < 0 && find_ckchs[i]->multi) {
12260 /* we tried to look for a non-bundle and we found a bundle */
12261 memprintf(&err, "%s%s is a multi-cert bundle. Try updating %s.{dsa,rsa,ecdsa}\n",
12262 err ? err : "", args[3], args[3]);
12263 errcode |= ERR_ALERT | ERR_FATAL;
12264 goto end;
12265 }
William Lallemand3246d942019-11-04 14:02:11 +010012266 /* If we want a bundle but this is not a bundle
12267 * example: When you try to update <file>.rsa, but
12268 * <file> is a regular file */
12269 if (bundle >= 0 && find_ckchs[i]->multi == 0) {
12270 find_ckchs[i] = NULL;
12271 break;
12272 }
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012273 }
12274#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
12275 {
Emmanuel Hocdet40f2f1e2019-10-30 17:31:28 +010012276 char *end;
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012277 int j;
12278
12279 /* check if it was used in a bundle by removing the
12280 * .dsa/.rsa/.ecdsa at the end of the filename */
12281 end = strrchr(buf->area, '.');
Emmanuel Hocdet40f2f1e2019-10-30 17:31:28 +010012282 for (j = 0; end && j < SSL_SOCK_NUM_KEYTYPES; j++) {
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012283 if (!strcmp(end + 1, SSL_SOCK_KEYTYPE_NAMES[j])) {
12284 bundle = j; /* keep the type of certificate so we insert it at the right place */
12285 *end = '\0'; /* it's a bundle let's end the string*/
12286 break;
12287 }
12288 }
William Lallemand37031b82019-11-04 13:38:53 +010012289 if (bundle < 0) /* we didn't find a bundle extension */
12290 break;
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012291 }
William Lallemand963b2e72019-10-14 11:38:36 +020012292#else
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012293 /* bundles are not supported here, so we don't need to lookup again */
12294 break;
William Lallemand963b2e72019-10-14 11:38:36 +020012295#endif
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012296 }
12297
12298 if (find_ckchs[0] && find_ckchs[1]) {
12299 memprintf(&err, "%sUpdating a certificate which is used in the HAProxy configuration as a bundle and as a unique certificate is not supported. ('%s' and '%s')\n",
12300 err ? err : "", find_ckchs[0]->path, find_ckchs[1]->path);
12301 errcode |= ERR_ALERT | ERR_FATAL;
12302 goto end;
12303 }
12304
12305 appctx->ctx.ssl.old_ckchs = find_ckchs[0] ? find_ckchs[0] : find_ckchs[1];
William Lallemand150bfa82019-09-19 17:12:49 +020012306 }
12307
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012308 if (!appctx->ctx.ssl.old_ckchs) {
12309 memprintf(&err, "%sCan't replace a certificate which is not referenced by the configuration!\n",
William Lallemand150bfa82019-09-19 17:12:49 +020012310 err ? err : "");
Emeric Brunf69ed1d2019-10-17 11:56:56 +020012311 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand8f840d72019-10-23 10:53:05 +020012312 goto end;
William Lallemand150bfa82019-09-19 17:12:49 +020012313 }
12314
William Lallemand8a7fdf02019-11-04 10:59:32 +010012315 if (!appctx->ctx.ssl.path) {
12316 /* this is a new transaction, set the path of the transaction */
12317 appctx->ctx.ssl.path = strdup(appctx->ctx.ssl.old_ckchs->path);
12318 if (!appctx->ctx.ssl.path) {
12319 memprintf(&err, "%sCan't allocate memory\n", err ? err : "");
12320 errcode |= ERR_ALERT | ERR_FATAL;
12321 goto end;
12322 }
12323 }
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012324
12325 old_ckchs = appctx->ctx.ssl.old_ckchs;
12326
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012327 /* duplicate the ckch store */
12328 new_ckchs = ckchs_dup(old_ckchs);
12329 if (!new_ckchs) {
12330 memprintf(&err, "%sCannot allocate memory!\n",
12331 err ? err : "");
12332 errcode |= ERR_ALERT | ERR_FATAL;
12333 goto end;
12334 }
12335
12336 if (!new_ckchs->multi)
12337 ckch = new_ckchs->ckch;
12338 else
12339 ckch = &new_ckchs->ckch[bundle];
12340
12341 /* appply the change on the duplicate */
12342 if (cert_exts[type].load(buf->area, payload, ckch, &err) != 0) {
12343 memprintf(&err, "%sCan't load the payload\n", err ? err : "");
12344 errcode |= ERR_ALERT | ERR_FATAL;
12345 goto end;
12346 }
12347
12348 appctx->ctx.ssl.new_ckchs = new_ckchs;
12349
12350 /* we succeed, we can save the ckchs in the transaction */
12351
12352 /* if there wasn't a transaction, update the old ckchs */
William Dauchyc8bb1532019-11-24 15:04:20 +010012353 if (!ckchs_transaction.old_ckchs) {
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012354 ckchs_transaction.old_ckchs = appctx->ctx.ssl.old_ckchs;
12355 ckchs_transaction.path = appctx->ctx.ssl.path;
12356 err = memprintf(&err, "Transaction created for certificate %s!\n", ckchs_transaction.path);
12357 } else {
12358 err = memprintf(&err, "Transaction updated for certificate %s!\n", ckchs_transaction.path);
12359
12360 }
12361
12362 /* free the previous ckchs if there was a transaction */
William Lallemandba1c33f2020-04-08 17:55:45 +020012363 ckch_store_free(ckchs_transaction.new_ckchs);
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012364
12365 ckchs_transaction.new_ckchs = appctx->ctx.ssl.new_ckchs;
12366
12367
William Lallemand8f840d72019-10-23 10:53:05 +020012368 /* creates the SNI ctxs later in the IO handler */
William Lallemand150bfa82019-09-19 17:12:49 +020012369
William Lallemand8f840d72019-10-23 10:53:05 +020012370end:
12371 free_trash_chunk(buf);
William Lallemand150bfa82019-09-19 17:12:49 +020012372
Emeric Brunf69ed1d2019-10-17 11:56:56 +020012373 if (errcode & ERR_CODE) {
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012374
William Lallemandba1c33f2020-04-08 17:55:45 +020012375 ckch_store_free(appctx->ctx.ssl.new_ckchs);
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012376 appctx->ctx.ssl.new_ckchs = NULL;
12377
12378 appctx->ctx.ssl.old_ckchs = NULL;
12379
12380 free(appctx->ctx.ssl.path);
12381 appctx->ctx.ssl.path = NULL;
12382
12383 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
William Lallemand44b35322019-10-17 16:28:40 +020012384 return cli_dynerr(appctx, memprintf(&err, "%sCan't update %s!\n", err ? err : "", args[3]));
William Lallemand430413e2019-10-28 14:30:47 +010012385 } else {
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012386
12387 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12388 return cli_dynmsg(appctx, LOG_NOTICE, err);
William Lallemand430413e2019-10-28 14:30:47 +010012389 }
William Lallemand8f840d72019-10-23 10:53:05 +020012390 /* TODO: handle the ERR_WARN which are not handled because of the io_handler */
William Lallemand150bfa82019-09-19 17:12:49 +020012391}
12392
William Lallemand0bc9c8a2019-11-19 15:51:51 +010012393/* parsing function of 'abort ssl cert' */
12394static int cli_parse_abort_cert(char **args, char *payload, struct appctx *appctx, void *private)
12395{
12396 char *err = NULL;
12397
William Lallemand230662a2019-12-03 13:32:54 +010012398 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
12399 return 1;
12400
William Lallemand0bc9c8a2019-11-19 15:51:51 +010012401 if (!*args[3])
12402 return cli_err(appctx, "'abort ssl cert' expects a filename\n");
12403
12404 /* The operations on the CKCH architecture are locked so we can
12405 * manipulate ckch_store and ckch_inst */
12406 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
12407 return cli_err(appctx, "Can't abort!\nOperations on certificates are currently locked!\n");
12408
12409 if (!ckchs_transaction.path) {
12410 memprintf(&err, "No ongoing transaction!\n");
12411 goto error;
12412 }
12413
12414 if (strcmp(ckchs_transaction.path, args[3]) != 0) {
12415 memprintf(&err, "The ongoing transaction is about '%s' but you are trying to abort a transaction for '%s'\n", ckchs_transaction.path, args[3]);
12416 goto error;
12417 }
12418
12419 /* Only free the ckchs there, because the SNI and instances were not generated yet */
William Lallemandba1c33f2020-04-08 17:55:45 +020012420 ckch_store_free(ckchs_transaction.new_ckchs);
William Lallemand0bc9c8a2019-11-19 15:51:51 +010012421 ckchs_transaction.new_ckchs = NULL;
William Lallemandba1c33f2020-04-08 17:55:45 +020012422 ckch_store_free(ckchs_transaction.old_ckchs);
William Lallemand0bc9c8a2019-11-19 15:51:51 +010012423 ckchs_transaction.old_ckchs = NULL;
12424 free(ckchs_transaction.path);
12425 ckchs_transaction.path = NULL;
12426
12427 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12428
12429 err = memprintf(&err, "Transaction aborted for certificate '%s'!\n", args[3]);
12430 return cli_dynmsg(appctx, LOG_NOTICE, err);
12431
12432error:
12433 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12434
12435 return cli_dynerr(appctx, err);
12436}
12437
William Lallemandea987ed2020-03-19 16:48:33 +010012438/* parsing function of 'new ssl cert' */
12439static int cli_parse_new_cert(char **args, char *payload, struct appctx *appctx, void *private)
12440{
12441 struct ckch_store *store;
12442 char *err = NULL;
12443 char *path;
12444
12445 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
12446 return 1;
12447
12448 if (!*args[3])
12449 return cli_err(appctx, "'new ssl cert' expects a filename\n");
12450
12451 path = args[3];
12452
12453 /* The operations on the CKCH architecture are locked so we can
12454 * manipulate ckch_store and ckch_inst */
12455 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
12456 return cli_err(appctx, "Can't create a certificate!\nOperations on certificates are currently locked!\n");
12457
12458 store = ckchs_lookup(path);
12459 if (store != NULL) {
12460 memprintf(&err, "Certificate '%s' already exists!\n", path);
12461 store = NULL; /* we don't want to free it */
12462 goto error;
12463 }
William Lallemand8a874e42020-04-09 10:32:53 +020012464 /* we won't support multi-certificate bundle here */
12465 store = ckch_store_new(path, 1);
William Lallemandea987ed2020-03-19 16:48:33 +010012466 if (!store) {
12467 memprintf(&err, "unable to allocate memory.\n");
12468 goto error;
12469 }
William Lallemandea987ed2020-03-19 16:48:33 +010012470
12471 /* insert into the ckchs tree */
William Lallemandea987ed2020-03-19 16:48:33 +010012472 ebst_insert(&ckchs_tree, &store->node);
12473 memprintf(&err, "New empty certificate store '%s'!\n", args[3]);
12474
12475 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12476 return cli_dynmsg(appctx, LOG_NOTICE, err);
12477error:
12478 free(store);
12479 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12480 return cli_dynerr(appctx, err);
12481}
12482
William Lallemand419e6342020-04-08 12:05:39 +020012483/* parsing function of 'del ssl cert' */
12484static int cli_parse_del_cert(char **args, char *payload, struct appctx *appctx, void *private)
12485{
12486 struct ckch_store *store;
12487 char *err = NULL;
12488 char *filename;
12489
12490 if (!cli_has_level(appctx, ACCESS_LVL_ADMIN))
12491 return 1;
12492
12493 if (!*args[3])
12494 return cli_err(appctx, "'del ssl cert' expects a certificate name\n");
12495
12496 if (HA_SPIN_TRYLOCK(CKCH_LOCK, &ckch_lock))
12497 return cli_err(appctx, "Can't delete the certificate!\nOperations on certificates are currently locked!\n");
12498
12499 filename = args[3];
12500
12501 store = ckchs_lookup(filename);
12502 if (store == NULL) {
12503 memprintf(&err, "certificate '%s' doesn't exist!\n", filename);
12504 goto error;
12505 }
12506 if (!LIST_ISEMPTY(&store->ckch_inst)) {
12507 memprintf(&err, "certificate '%s' in use, can't be deleted!\n", filename);
12508 goto error;
12509 }
12510
12511 ebmb_delete(&store->node);
William Lallemandba1c33f2020-04-08 17:55:45 +020012512 ckch_store_free(store);
William Lallemand419e6342020-04-08 12:05:39 +020012513
12514 memprintf(&err, "Certificate '%s' deleted!\n", filename);
12515
12516 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12517 return cli_dynmsg(appctx, LOG_NOTICE, err);
12518
12519error:
12520 memprintf(&err, "Can't remove the certificate: %s\n", err ? err : "");
12521 HA_SPIN_UNLOCK(CKCH_LOCK, &ckch_lock);
12522 return cli_dynerr(appctx, err);
12523}
12524
12525
12526
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +020012527static int cli_parse_set_ocspresponse(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +020012528{
12529#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
12530 char *err = NULL;
Willy Tarreau1c913e42018-08-22 05:26:57 +020012531 int i, j, ret;
Aurélien Nephtali1e0867c2018-04-18 14:04:58 +020012532
12533 if (!payload)
12534 payload = args[3];
William Lallemand32af2032016-10-29 18:09:35 +020012535
12536 /* Expect one parameter: the new response in base64 encoding */
Willy Tarreau9d008692019-08-09 11:21:01 +020012537 if (!*payload)
12538 return cli_err(appctx, "'set ssl ocsp-response' expects response in base64 encoding.\n");
Aurélien Nephtali1e0867c2018-04-18 14:04:58 +020012539
12540 /* remove \r and \n from the payload */
12541 for (i = 0, j = 0; payload[i]; i++) {
12542 if (payload[i] == '\r' || payload[i] == '\n')
12543 continue;
12544 payload[j++] = payload[i];
12545 }
12546 payload[j] = 0;
William Lallemand32af2032016-10-29 18:09:35 +020012547
Willy Tarreau1c913e42018-08-22 05:26:57 +020012548 ret = base64dec(payload, j, trash.area, trash.size);
Willy Tarreau9d008692019-08-09 11:21:01 +020012549 if (ret < 0)
12550 return cli_err(appctx, "'set ssl ocsp-response' received invalid base64 encoded response.\n");
William Lallemand32af2032016-10-29 18:09:35 +020012551
Willy Tarreau1c913e42018-08-22 05:26:57 +020012552 trash.data = ret;
William Lallemand32af2032016-10-29 18:09:35 +020012553 if (ssl_sock_update_ocsp_response(&trash, &err)) {
Willy Tarreau9d008692019-08-09 11:21:01 +020012554 if (err)
12555 return cli_dynerr(appctx, memprintf(&err, "%s.\n", err));
12556 else
12557 return cli_err(appctx, "Failed to update OCSP response.\n");
William Lallemand32af2032016-10-29 18:09:35 +020012558 }
Willy Tarreau9d008692019-08-09 11:21:01 +020012559
12560 return cli_msg(appctx, LOG_INFO, "OCSP Response updated!\n");
William Lallemand32af2032016-10-29 18:09:35 +020012561#else
Willy Tarreau9d008692019-08-09 11:21:01 +020012562 return cli_err(appctx, "HAProxy was compiled against a version of OpenSSL that doesn't support OCSP stapling.\n");
William Lallemand32af2032016-10-29 18:09:35 +020012563#endif
12564
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010012565}
12566
Willy Tarreau86a394e2019-05-09 14:15:32 +020012567#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010012568static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
12569{
12570 switch (arg->type) {
12571 case ARGT_STR:
12572 smp->data.type = SMP_T_STR;
12573 smp->data.u.str = arg->data.str;
12574 return 1;
12575 case ARGT_VAR:
12576 if (!vars_get_by_desc(&arg->data.var, smp))
12577 return 0;
12578 if (!sample_casts[smp->data.type][SMP_T_STR])
12579 return 0;
12580 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
12581 return 0;
12582 return 1;
12583 default:
12584 return 0;
12585 }
12586}
12587
12588static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
12589 const char *file, int line, char **err)
12590{
12591 switch(args[0].data.sint) {
12592 case 128:
12593 case 192:
12594 case 256:
12595 break;
12596 default:
12597 memprintf(err, "key size must be 128, 192 or 256 (bits).");
12598 return 0;
12599 }
12600 /* Try to decode a variable. */
12601 vars_check_arg(&args[1], NULL);
12602 vars_check_arg(&args[2], NULL);
12603 vars_check_arg(&args[3], NULL);
12604 return 1;
12605}
12606
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012607/* Arguments: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010012608static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
12609{
12610 struct sample nonce, key, aead_tag;
12611 struct buffer *smp_trash, *smp_trash_alloc;
12612 EVP_CIPHER_CTX *ctx;
12613 int dec_size, ret;
12614
12615 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
12616 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
12617 return 0;
12618
12619 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
12620 if (!sample_conv_var2smp_str(&arg_p[2], &key))
12621 return 0;
12622
12623 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
12624 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
12625 return 0;
12626
12627 smp_trash = get_trash_chunk();
12628 smp_trash_alloc = alloc_trash_chunk();
12629 if (!smp_trash_alloc)
12630 return 0;
12631
12632 ctx = EVP_CIPHER_CTX_new();
12633
12634 if (!ctx)
12635 goto err;
12636
12637 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
12638 if (dec_size < 0)
12639 goto err;
12640 smp_trash->data = dec_size;
12641
12642 /* Set cipher type and mode */
12643 switch(arg_p[0].data.sint) {
12644 case 128:
12645 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
12646 break;
12647 case 192:
12648 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
12649 break;
12650 case 256:
12651 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
12652 break;
12653 }
12654
12655 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, smp_trash->data, NULL);
12656
12657 /* Initialise IV */
12658 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) smp_trash->area))
12659 goto err;
12660
12661 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
12662 if (dec_size < 0)
12663 goto err;
12664 smp_trash->data = dec_size;
12665
12666 /* Initialise key */
12667 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) smp_trash->area, NULL))
12668 goto err;
12669
12670 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
12671 (unsigned char *) smp->data.u.str.area, (int) smp->data.u.str.data))
12672 goto err;
12673
12674 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
12675 if (dec_size < 0)
12676 goto err;
12677 smp_trash_alloc->data = dec_size;
12678 dec_size = smp_trash->data;
12679
12680 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, smp_trash_alloc->data, (void *) smp_trash_alloc->area);
12681 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
12682
12683 if (ret <= 0)
12684 goto err;
12685
12686 smp->data.u.str.data = dec_size + smp_trash->data;
12687 smp->data.u.str.area = smp_trash->area;
12688 smp->data.type = SMP_T_BIN;
12689 smp->flags &= ~SMP_F_CONST;
12690 free_trash_chunk(smp_trash_alloc);
12691 return 1;
12692
12693err:
12694 free_trash_chunk(smp_trash_alloc);
12695 return 0;
William Lallemand32af2032016-10-29 18:09:35 +020012696}
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010012697# endif
William Lallemand32af2032016-10-29 18:09:35 +020012698
Elliot Otchet71f82972020-01-15 08:12:14 -050012699/* Argument validation functions */
12700
12701/* This function is used to validate the arguments passed to any "x_dn" ssl
12702 * keywords. These keywords support specifying a third parameter that must be
12703 * either empty or the value "rfc2253". Returns 0 on error, non-zero if OK.
12704 */
12705int val_dnfmt(struct arg *arg, char **err_msg)
12706{
12707 if (arg && arg[2].type == ARGT_STR && arg[2].data.str.data > 0 && (strcmp(arg[2].data.str.area, "rfc2253") != 0)) {
12708 memprintf(err_msg, "only rfc2253 or a blank value are currently supported as the format argument.");
12709 return 0;
12710 }
12711 return 1;
12712}
12713
William Lallemand32af2032016-10-29 18:09:35 +020012714/* register cli keywords */
12715static struct cli_kw_list cli_kws = {{ },{
12716#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
12717 { { "show", "tls-keys", NULL }, "show tls-keys [id|*]: show tls keys references or dump tls ticket keys when id specified", cli_parse_show_tlskeys, NULL },
Lukas Tribusf4bbc432017-10-24 12:26:31 +020012718 { { "set", "ssl", "tls-key", NULL }, "set ssl tls-key [id|keyfile] <tlskey>: set the next TLS key for the <id> or <keyfile> listener to <tlskey>", cli_parse_set_tlskeys, NULL },
William Lallemand32af2032016-10-29 18:09:35 +020012719#endif
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +010012720 { { "set", "ssl", "ocsp-response", NULL }, NULL, cli_parse_set_ocspresponse, NULL },
William Lallemandea987ed2020-03-19 16:48:33 +010012721 { { "new", "ssl", "cert", NULL }, "new ssl cert <certfile> : create a new certificate file to be used in a crt-list or a directory", cli_parse_new_cert, NULL, NULL },
William Lallemandbc6ca7c2019-10-29 23:48:19 +010012722 { { "set", "ssl", "cert", NULL }, "set ssl cert <certfile> <payload> : replace a certificate file", cli_parse_set_cert, NULL, NULL },
12723 { { "commit", "ssl", "cert", NULL }, "commit ssl cert <certfile> : commit a certificate file", cli_parse_commit_cert, cli_io_handler_commit_cert, cli_release_commit_cert },
William Lallemand0bc9c8a2019-11-19 15:51:51 +010012724 { { "abort", "ssl", "cert", NULL }, "abort ssl cert <certfile> : abort a transaction for a certificate file", cli_parse_abort_cert, NULL, NULL },
William Lallemand419e6342020-04-08 12:05:39 +020012725 { { "del", "ssl", "cert", NULL }, "del ssl cert <certfile> : delete an unused certificate file", cli_parse_del_cert, NULL, NULL },
William Lallemandd4f946c2019-12-05 10:26:40 +010012726 { { "show", "ssl", "cert", NULL }, "show ssl cert [<certfile>] : display the SSL certificates used in memory, or the details of a <certfile>", cli_parse_show_cert, cli_io_handler_show_cert, cli_release_show_cert },
William Lallemande67c80b2020-03-25 14:42:37 +010012727 { { "add", "ssl", "crt-list", NULL }, "add ssl crt-list <filename> <certfile> [options] : add a line <certfile> to a crt-list <filename>", cli_parse_add_crtlist, cli_io_handler_add_crtlist, cli_release_add_crtlist },
William Lallemand0a9b9412020-04-06 17:43:05 +020012728 { { "del", "ssl", "crt-list", NULL }, "del ssl crt-list <filename> <certfile[:line]> : delete a line <certfile> in a crt-list <filename>", cli_parse_del_crtlist, NULL, NULL },
William Lallemandc69f02d2020-04-06 19:07:03 +020012729 { { "show", "ssl", "crt-list", NULL }, "show ssl crt-list [-n] [<filename>] : show the list of crt-lists or the content of a crt-list <filename>", cli_parse_dump_crtlist, cli_io_handler_dump_crtlist, NULL },
William Lallemand32af2032016-10-29 18:09:35 +020012730 { { NULL }, NULL, NULL, NULL }
12731}};
12732
Willy Tarreau0108d902018-11-25 19:14:37 +010012733INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemand32af2032016-10-29 18:09:35 +020012734
Willy Tarreau7875d092012-09-10 08:20:03 +020012735/* Note: must not be declared <const> as its list will be overwritten.
12736 * Please take care of keeping this list alphabetically sorted.
12737 */
Willy Tarreaudc13c112013-06-21 23:16:39 +020012738static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
Emeric Brun645ae792014-04-30 14:21:06 +020012739 { "ssl_bc", smp_fetch_ssl_fc, 0, NULL, SMP_T_BOOL, SMP_USE_L5SRV },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012740 { "ssl_bc_alg_keysize", smp_fetch_ssl_fc_alg_keysize, 0, NULL, SMP_T_SINT, SMP_USE_L5SRV },
Olivier Houchard6b77f492018-11-22 18:18:29 +010012741#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Jérôme Magnine064a802018-12-03 22:21:04 +010012742 { "ssl_bc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Olivier Houchard6b77f492018-11-22 18:18:29 +010012743#endif
Emeric Brun645ae792014-04-30 14:21:06 +020012744 { "ssl_bc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Olivier Houchard6b77f492018-11-22 18:18:29 +010012745#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
12746 { "ssl_bc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
12747#endif
Emeric Brun74f7ffa2018-02-19 16:14:12 +010012748 { "ssl_bc_is_resumed", smp_fetch_ssl_fc_is_resumed, 0, NULL, SMP_T_BOOL, SMP_USE_L5SRV },
Emeric Brun645ae792014-04-30 14:21:06 +020012749 { "ssl_bc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Emeric Brunb73a9b02014-04-30 18:49:19 +020012750 { "ssl_bc_unique_id", smp_fetch_ssl_fc_unique_id, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012751 { "ssl_bc_use_keysize", smp_fetch_ssl_fc_use_keysize, 0, NULL, SMP_T_SINT, SMP_USE_L5SRV },
Willy Tarreau9a1ab082019-05-09 13:26:41 +020012752#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brun645ae792014-04-30 14:21:06 +020012753 { "ssl_bc_session_id", smp_fetch_ssl_fc_session_id, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
Patrick Hemmer41966772018-04-28 19:15:48 -040012754#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012755#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmer65674662019-06-04 08:13:03 -040012756 { "ssl_bc_client_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
12757 { "ssl_bc_server_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
Patrick Hemmere0275472018-04-28 19:15:51 -040012758 { "ssl_bc_session_key", smp_fetch_ssl_fc_session_key, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
12759#endif
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012760 { "ssl_c_ca_err", smp_fetch_ssl_c_ca_err, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
12761 { "ssl_c_ca_err_depth", smp_fetch_ssl_c_ca_err_depth, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Emeric Brun43e79582014-10-29 19:03:26 +010012762 { "ssl_c_der", smp_fetch_ssl_x_der, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012763 { "ssl_c_err", smp_fetch_ssl_c_err, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Elliot Otchet71f82972020-01-15 08:12:14 -050012764 { "ssl_c_i_dn", smp_fetch_ssl_x_i_dn, ARG3(0,STR,SINT,STR),val_dnfmt, SMP_T_STR, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +020012765 { "ssl_c_key_alg", smp_fetch_ssl_x_key_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12766 { "ssl_c_notafter", smp_fetch_ssl_x_notafter, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12767 { "ssl_c_notbefore", smp_fetch_ssl_x_notbefore, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12768 { "ssl_c_sig_alg", smp_fetch_ssl_x_sig_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Elliot Otchet71f82972020-01-15 08:12:14 -050012769 { "ssl_c_s_dn", smp_fetch_ssl_x_s_dn, ARG3(0,STR,SINT,STR),val_dnfmt, SMP_T_STR, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +020012770 { "ssl_c_serial", smp_fetch_ssl_x_serial, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
12771 { "ssl_c_sha1", smp_fetch_ssl_x_sha1, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +010012772 { "ssl_c_used", smp_fetch_ssl_c_used, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012773 { "ssl_c_verify", smp_fetch_ssl_c_verify, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
12774 { "ssl_c_version", smp_fetch_ssl_x_version, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Emeric Brun43e79582014-10-29 19:03:26 +010012775 { "ssl_f_der", smp_fetch_ssl_x_der, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Elliot Otchet71f82972020-01-15 08:12:14 -050012776 { "ssl_f_i_dn", smp_fetch_ssl_x_i_dn, ARG3(0,STR,SINT,STR),val_dnfmt, SMP_T_STR, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +020012777 { "ssl_f_key_alg", smp_fetch_ssl_x_key_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12778 { "ssl_f_notafter", smp_fetch_ssl_x_notafter, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12779 { "ssl_f_notbefore", smp_fetch_ssl_x_notbefore, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12780 { "ssl_f_sig_alg", smp_fetch_ssl_x_sig_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Elliot Otchet71f82972020-01-15 08:12:14 -050012781 { "ssl_f_s_dn", smp_fetch_ssl_x_s_dn, ARG3(0,STR,SINT,STR),val_dnfmt, SMP_T_STR, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +020012782 { "ssl_f_serial", smp_fetch_ssl_x_serial, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Emeric Brun55f4fa82014-04-30 17:11:25 +020012783 { "ssl_f_sha1", smp_fetch_ssl_x_sha1, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012784 { "ssl_f_version", smp_fetch_ssl_x_version, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +010012785 { "ssl_fc", smp_fetch_ssl_fc, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012786 { "ssl_fc_alg_keysize", smp_fetch_ssl_fc_alg_keysize, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012787 { "ssl_fc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +010012788 { "ssl_fc_has_crt", smp_fetch_ssl_fc_has_crt, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Olivier Houchardccaa7de2017-10-02 11:51:03 +020012789 { "ssl_fc_has_early", smp_fetch_ssl_fc_has_early, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +010012790 { "ssl_fc_has_sni", smp_fetch_ssl_fc_has_sni, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Nenad Merdanovic26ea8222015-05-18 02:28:57 +020012791 { "ssl_fc_is_resumed", smp_fetch_ssl_fc_is_resumed, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Bernard Spil13c53f82018-02-15 13:34:58 +010012792#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012793 { "ssl_fc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreaua33c6542012-10-15 13:19:06 +020012794#endif
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +010012795#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012796 { "ssl_fc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreauab861d32013-04-02 02:30:41 +020012797#endif
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012798 { "ssl_fc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreau9a1ab082019-05-09 13:26:41 +020012799#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brunb73a9b02014-04-30 18:49:19 +020012800 { "ssl_fc_unique_id", smp_fetch_ssl_fc_unique_id, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Patrick Hemmer41966772018-04-28 19:15:48 -040012801#endif
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +020012802 { "ssl_fc_use_keysize", smp_fetch_ssl_fc_use_keysize, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Willy Tarreau9a1ab082019-05-09 13:26:41 +020012803#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012804 { "ssl_fc_session_id", smp_fetch_ssl_fc_session_id, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Patrick Hemmer41966772018-04-28 19:15:48 -040012805#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012806#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmer65674662019-06-04 08:13:03 -040012807 { "ssl_fc_client_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
12808 { "ssl_fc_server_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Patrick Hemmere0275472018-04-28 19:15:51 -040012809 { "ssl_fc_session_key", smp_fetch_ssl_fc_session_key, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
12810#endif
Patrick Hemmer41966772018-04-28 19:15:48 -040012811#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +010012812 { "ssl_fc_sni", smp_fetch_ssl_fc_sni, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Patrick Hemmer41966772018-04-28 19:15:48 -040012813#endif
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010012814 { "ssl_fc_cipherlist_bin", smp_fetch_ssl_fc_cl_bin, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12815 { "ssl_fc_cipherlist_hex", smp_fetch_ssl_fc_cl_hex, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
12816 { "ssl_fc_cipherlist_str", smp_fetch_ssl_fc_cl_str, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
12817 { "ssl_fc_cipherlist_xxh", smp_fetch_ssl_fc_cl_xxh64, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Willy Tarreau7875d092012-09-10 08:20:03 +020012818 { NULL, NULL, 0, 0, 0 },
12819}};
12820
Willy Tarreau0108d902018-11-25 19:14:37 +010012821INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
12822
Willy Tarreau7875d092012-09-10 08:20:03 +020012823/* Note: must not be declared <const> as its list will be overwritten.
12824 * Please take care of keeping this list alphabetically sorted.
12825 */
Willy Tarreaudc13c112013-06-21 23:16:39 +020012826static struct acl_kw_list acl_kws = {ILH, {
Thierry FOURNIERc5a4e982014-03-05 16:07:08 +010012827 { "ssl_fc_sni_end", "ssl_fc_sni", PAT_MATCH_END },
12828 { "ssl_fc_sni_reg", "ssl_fc_sni", PAT_MATCH_REG },
Willy Tarreau8ed669b2013-01-11 15:49:37 +010012829 { /* END */ },
Willy Tarreau7875d092012-09-10 08:20:03 +020012830}};
12831
Willy Tarreau0108d902018-11-25 19:14:37 +010012832INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
12833
Willy Tarreau79eeafa2012-09-14 07:53:05 +020012834/* Note: must not be declared <const> as its list will be overwritten.
12835 * Please take care of keeping this list alphabetically sorted, doing so helps
12836 * all code contributors.
12837 * Optional keywords are also declared with a NULL ->parse() function so that
12838 * the config parser can report an appropriate error when a known keyword was
12839 * not enabled.
12840 */
William Lallemand557823f2020-04-01 17:42:47 +020012841
12842/* the <ssl_bind_kws> keywords are used for crt-list parsing, they *MUST* be safe
12843 * with their proxy argument NULL and must only fill the ssl_bind_conf */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012844static struct ssl_bind_kw ssl_bind_kws[] = {
Olivier Houchardc2aae742017-09-22 18:26:28 +020012845 { "allow-0rtt", ssl_bind_parse_allow_0rtt, 0 }, /* allow 0-RTT */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012846 { "alpn", ssl_bind_parse_alpn, 1 }, /* set ALPN supported protocols */
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +010012847 { "ca-file", ssl_bind_parse_ca_file, 1 }, /* set CAfile to process ca-names and verify on client cert */
12848 { "ca-verify-file", ssl_bind_parse_ca_verify_file, 1 }, /* set CAverify file to process verify on client cert */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012849 { "ciphers", ssl_bind_parse_ciphers, 1 }, /* set SSL cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012850#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020012851 { "ciphersuites", ssl_bind_parse_ciphersuites, 1 }, /* set TLS 1.3 cipher suite */
12852#endif
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012853 { "crl-file", ssl_bind_parse_crl_file, 1 }, /* set certificate revocation list file use on client cert verify */
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +010012854 { "curves", ssl_bind_parse_curves, 1 }, /* set SSL curve suite */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012855 { "ecdhe", ssl_bind_parse_ecdhe, 1 }, /* defines named curve for elliptic curve Diffie-Hellman */
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +020012856 { "no-ca-names", ssl_bind_parse_no_ca_names, 0 }, /* do not send ca names to clients (ca_file related) */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012857 { "npn", ssl_bind_parse_npn, 1 }, /* set NPN supported protocols */
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +020012858 { "ssl-min-ver", ssl_bind_parse_tls_method_minmax,1 }, /* minimum version */
12859 { "ssl-max-ver", ssl_bind_parse_tls_method_minmax,1 }, /* maximum version */
Emmanuel Hocdet98263292016-12-29 18:26:15 +010012860 { "verify", ssl_bind_parse_verify, 1 }, /* set SSL verify method */
12861 { NULL, NULL, 0 },
12862};
12863
Willy Tarreau0108d902018-11-25 19:14:37 +010012864/* no initcall for ssl_bind_kws, these ones are parsed in the parser loop */
12865
Willy Tarreau51fb7652012-09-18 18:24:39 +020012866static struct bind_kw_list bind_kws = { "SSL", { }, {
Olivier Houchardc2aae742017-09-22 18:26:28 +020012867 { "allow-0rtt", bind_parse_allow_0rtt, 0 }, /* Allow 0RTT */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012868 { "alpn", bind_parse_alpn, 1 }, /* set ALPN supported protocols */
Emmanuel Hocdet842e94e2019-12-16 16:39:17 +010012869 { "ca-file", bind_parse_ca_file, 1 }, /* set CAfile to process ca-names and verify on client cert */
12870 { "ca-verify-file", bind_parse_ca_verify_file, 1 }, /* set CAverify file to process verify on client cert */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012871 { "ca-ignore-err", bind_parse_ignore_err, 1 }, /* set error IDs to ignore on verify depth > 0 */
12872 { "ca-sign-file", bind_parse_ca_sign_file, 1 }, /* set CAFile used to generate and sign server certs */
12873 { "ca-sign-pass", bind_parse_ca_sign_pass, 1 }, /* set CAKey passphrase */
12874 { "ciphers", bind_parse_ciphers, 1 }, /* set SSL cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012875#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020012876 { "ciphersuites", bind_parse_ciphersuites, 1 }, /* set TLS 1.3 cipher suite */
12877#endif
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012878 { "crl-file", bind_parse_crl_file, 1 }, /* set certificate revocation list file use on client cert verify */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012879 { "crt", bind_parse_crt, 1 }, /* load SSL certificates from this location */
Ilya Shipitsin77e3b4a2020-03-10 12:06:11 +050012880 { "crt-ignore-err", bind_parse_ignore_err, 1 }, /* set error IDs to ignore on verify depth == 0 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012881 { "crt-list", bind_parse_crt_list, 1 }, /* load a list of crt from this location */
12882 { "curves", bind_parse_curves, 1 }, /* set SSL curve suite */
12883 { "ecdhe", bind_parse_ecdhe, 1 }, /* defines named curve for elliptic curve Diffie-Hellman */
12884 { "force-sslv3", bind_parse_tls_method_options, 0 }, /* force SSLv3 */
12885 { "force-tlsv10", bind_parse_tls_method_options, 0 }, /* force TLSv10 */
12886 { "force-tlsv11", bind_parse_tls_method_options, 0 }, /* force TLSv11 */
12887 { "force-tlsv12", bind_parse_tls_method_options, 0 }, /* force TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +020012888 { "force-tlsv13", bind_parse_tls_method_options, 0 }, /* force TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012889 { "generate-certificates", bind_parse_generate_certs, 0 }, /* enable the server certificates generation */
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +020012890 { "no-ca-names", bind_parse_no_ca_names, 0 }, /* do not send ca names to clients (ca_file related) */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012891 { "no-sslv3", bind_parse_tls_method_options, 0 }, /* disable SSLv3 */
12892 { "no-tlsv10", bind_parse_tls_method_options, 0 }, /* disable TLSv10 */
12893 { "no-tlsv11", bind_parse_tls_method_options, 0 }, /* disable TLSv11 */
12894 { "no-tlsv12", bind_parse_tls_method_options, 0 }, /* disable TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +020012895 { "no-tlsv13", bind_parse_tls_method_options, 0 }, /* disable TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012896 { "no-tls-tickets", bind_parse_no_tls_tickets, 0 }, /* disable session resumption tickets */
12897 { "ssl", bind_parse_ssl, 0 }, /* enable SSL processing */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020012898 { "ssl-min-ver", bind_parse_tls_method_minmax, 1 }, /* minimum version */
12899 { "ssl-max-ver", bind_parse_tls_method_minmax, 1 }, /* maximum version */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +020012900 { "strict-sni", bind_parse_strict_sni, 0 }, /* refuse negotiation if sni doesn't match a certificate */
12901 { "tls-ticket-keys", bind_parse_tls_ticket_keys, 1 }, /* set file to load TLS ticket keys from */
12902 { "verify", bind_parse_verify, 1 }, /* set SSL verify method */
12903 { "npn", bind_parse_npn, 1 }, /* set NPN supported protocols */
12904 { "prefer-client-ciphers", bind_parse_pcc, 0 }, /* prefer client ciphers */
Willy Tarreau79eeafa2012-09-14 07:53:05 +020012905 { NULL, NULL, 0 },
12906}};
Emeric Brun46591952012-05-18 15:47:34 +020012907
Willy Tarreau0108d902018-11-25 19:14:37 +010012908INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
12909
Willy Tarreau92faadf2012-10-10 23:04:25 +020012910/* Note: must not be declared <const> as its list will be overwritten.
12911 * Please take care of keeping this list alphabetically sorted, doing so helps
12912 * all code contributors.
12913 * Optional keywords are also declared with a NULL ->parse() function so that
12914 * the config parser can report an appropriate error when a known keyword was
12915 * not enabled.
12916 */
12917static struct srv_kw_list srv_kws = { "SSL", { }, {
Olivier Houchard522eea72017-11-03 16:27:47 +010012918 { "allow-0rtt", srv_parse_allow_0rtt, 0, 1 }, /* Allow using early data on this server */
Olivier Houchardc7566002018-11-20 23:33:50 +010012919 { "alpn", srv_parse_alpn, 1, 1 }, /* Set ALPN supported protocols */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020012920 { "ca-file", srv_parse_ca_file, 1, 1 }, /* set CAfile to process verify server cert */
Olivier Houchard92150142018-12-21 19:47:01 +010012921 { "check-alpn", srv_parse_alpn, 1, 1 }, /* Set ALPN used for checks */
Olivier Houchard9130a962017-10-17 17:33:43 +020012922 { "check-sni", srv_parse_check_sni, 1, 1 }, /* set SNI */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020012923 { "check-ssl", srv_parse_check_ssl, 0, 1 }, /* enable SSL for health checks */
12924 { "ciphers", srv_parse_ciphers, 1, 1 }, /* select the cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012925#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020012926 { "ciphersuites", srv_parse_ciphersuites, 1, 1 }, /* select the cipher suite */
12927#endif
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020012928 { "crl-file", srv_parse_crl_file, 1, 1 }, /* set certificate revocation list file use on server cert verify */
12929 { "crt", srv_parse_crt, 1, 1 }, /* set client certificate */
12930 { "force-sslv3", srv_parse_tls_method_options, 0, 1 }, /* force SSLv3 */
12931 { "force-tlsv10", srv_parse_tls_method_options, 0, 1 }, /* force TLSv10 */
12932 { "force-tlsv11", srv_parse_tls_method_options, 0, 1 }, /* force TLSv11 */
12933 { "force-tlsv12", srv_parse_tls_method_options, 0, 1 }, /* force TLSv12 */
12934 { "force-tlsv13", srv_parse_tls_method_options, 0, 1 }, /* force TLSv13 */
12935 { "no-check-ssl", srv_parse_no_check_ssl, 0, 1 }, /* disable SSL for health checks */
12936 { "no-send-proxy-v2-ssl", srv_parse_no_send_proxy_ssl, 0, 1 }, /* do not send PROXY protocol header v2 with SSL info */
12937 { "no-send-proxy-v2-ssl-cn", srv_parse_no_send_proxy_cn, 0, 1 }, /* do not send PROXY protocol header v2 with CN */
12938 { "no-ssl", srv_parse_no_ssl, 0, 1 }, /* disable SSL processing */
12939 { "no-ssl-reuse", srv_parse_no_ssl_reuse, 0, 1 }, /* disable session reuse */
12940 { "no-sslv3", srv_parse_tls_method_options, 0, 0 }, /* disable SSLv3 */
12941 { "no-tlsv10", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv10 */
12942 { "no-tlsv11", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv11 */
12943 { "no-tlsv12", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv12 */
12944 { "no-tlsv13", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv13 */
12945 { "no-tls-tickets", srv_parse_no_tls_tickets, 0, 1 }, /* disable session resumption tickets */
Olivier Houchardc7566002018-11-20 23:33:50 +010012946 { "npn", srv_parse_npn, 1, 1 }, /* Set NPN supported protocols */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +020012947 { "send-proxy-v2-ssl", srv_parse_send_proxy_ssl, 0, 1 }, /* send PROXY protocol header v2 with SSL info */
12948 { "send-proxy-v2-ssl-cn", srv_parse_send_proxy_cn, 0, 1 }, /* send PROXY protocol header v2 with CN */
12949 { "sni", srv_parse_sni, 1, 1 }, /* send SNI extension */
12950 { "ssl", srv_parse_ssl, 0, 1 }, /* enable SSL processing */
12951 { "ssl-min-ver", srv_parse_tls_method_minmax, 1, 1 }, /* minimum version */
12952 { "ssl-max-ver", srv_parse_tls_method_minmax, 1, 1 }, /* maximum version */
12953 { "ssl-reuse", srv_parse_ssl_reuse, 0, 1 }, /* enable session reuse */
12954 { "tls-tickets", srv_parse_tls_tickets, 0, 1 }, /* enable session resumption tickets */
12955 { "verify", srv_parse_verify, 1, 1 }, /* set SSL verify method */
12956 { "verifyhost", srv_parse_verifyhost, 1, 1 }, /* require that SSL cert verifies for hostname */
Willy Tarreau92faadf2012-10-10 23:04:25 +020012957 { NULL, NULL, 0, 0 },
12958}};
12959
Willy Tarreau0108d902018-11-25 19:14:37 +010012960INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
12961
Emeric Brun2c86cbf2014-10-30 15:56:50 +010012962static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +010012963 { CFG_GLOBAL, "ca-base", ssl_parse_global_ca_crt_base },
12964 { CFG_GLOBAL, "crt-base", ssl_parse_global_ca_crt_base },
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010012965 { CFG_GLOBAL, "issuers-chain-path", ssl_load_global_issuers_from_path },
Willy Tarreau0bea58d2016-12-21 23:17:25 +010012966 { CFG_GLOBAL, "maxsslconn", ssl_parse_global_int },
Emeric Brun2c86cbf2014-10-30 15:56:50 +010012967 { CFG_GLOBAL, "ssl-default-bind-options", ssl_parse_default_bind_options },
12968 { CFG_GLOBAL, "ssl-default-server-options", ssl_parse_default_server_options },
Willy Tarreau14e36a12016-12-21 23:28:13 +010012969#ifndef OPENSSL_NO_DH
12970 { CFG_GLOBAL, "ssl-dh-param-file", ssl_parse_global_dh_param_file },
12971#endif
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000012972 { CFG_GLOBAL, "ssl-mode-async", ssl_parse_global_ssl_async },
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020012973#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +000012974 { CFG_GLOBAL, "ssl-engine", ssl_parse_global_ssl_engine },
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020012975#endif
Willy Tarreau9ceda382016-12-21 23:13:03 +010012976 { CFG_GLOBAL, "tune.ssl.cachesize", ssl_parse_global_int },
12977#ifndef OPENSSL_NO_DH
12978 { CFG_GLOBAL, "tune.ssl.default-dh-param", ssl_parse_global_default_dh },
12979#endif
12980 { CFG_GLOBAL, "tune.ssl.force-private-cache", ssl_parse_global_private_cache },
12981 { CFG_GLOBAL, "tune.ssl.lifetime", ssl_parse_global_lifetime },
12982 { CFG_GLOBAL, "tune.ssl.maxrecord", ssl_parse_global_int },
12983 { CFG_GLOBAL, "tune.ssl.ssl-ctx-cache-size", ssl_parse_global_int },
Thierry FOURNIER5bf77322017-02-25 12:45:22 +010012984 { CFG_GLOBAL, "tune.ssl.capture-cipherlist-size", ssl_parse_global_capture_cipherlist },
Willy Tarreauf22e9682016-12-21 23:23:19 +010012985 { CFG_GLOBAL, "ssl-default-bind-ciphers", ssl_parse_global_ciphers },
12986 { CFG_GLOBAL, "ssl-default-server-ciphers", ssl_parse_global_ciphers },
Emmanuel Hocdet839af572019-05-14 16:27:35 +020012987#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020012988 { CFG_GLOBAL, "ssl-default-bind-ciphersuites", ssl_parse_global_ciphersuites },
12989 { CFG_GLOBAL, "ssl-default-server-ciphersuites", ssl_parse_global_ciphersuites },
12990#endif
William Lallemand3af48e72020-02-03 17:15:52 +010012991 { CFG_GLOBAL, "ssl-load-extra-files", ssl_parse_global_extra_files },
Emeric Brun2c86cbf2014-10-30 15:56:50 +010012992 { 0, NULL, NULL },
12993}};
12994
Willy Tarreau0108d902018-11-25 19:14:37 +010012995INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
12996
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010012997/* Note: must not be declared <const> as its list will be overwritten */
12998static struct sample_conv_kw_list conv_kws = {ILH, {
Willy Tarreau86a394e2019-05-09 14:15:32 +020012999#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010013000 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
13001#endif
13002 { NULL, NULL, 0, 0, 0 },
13003}};
13004
13005INITCALL1(STG_REGISTER, sample_register_convs, &conv_kws);
13006
Willy Tarreauf7bc57c2012-10-03 00:19:48 +020013007/* transport-layer operations for SSL sockets */
Willy Tarreaud9f5cca2016-12-22 21:08:52 +010013008static struct xprt_ops ssl_sock = {
Emeric Brun46591952012-05-18 15:47:34 +020013009 .snd_buf = ssl_sock_from_buf,
13010 .rcv_buf = ssl_sock_to_buf,
Olivier Houcharddf357842019-03-21 16:30:07 +010013011 .subscribe = ssl_subscribe,
13012 .unsubscribe = ssl_unsubscribe,
Olivier Houchard5149b592019-05-23 17:47:36 +020013013 .remove_xprt = ssl_remove_xprt,
Olivier Houchard2e055482019-05-27 19:50:12 +020013014 .add_xprt = ssl_add_xprt,
Emeric Brun46591952012-05-18 15:47:34 +020013015 .rcv_pipe = NULL,
13016 .snd_pipe = NULL,
13017 .shutr = NULL,
13018 .shutw = ssl_sock_shutw,
13019 .close = ssl_sock_close,
13020 .init = ssl_sock_init,
Willy Tarreau55d37912016-12-21 23:38:39 +010013021 .prepare_bind_conf = ssl_sock_prepare_bind_conf,
Willy Tarreau795cdab2016-12-22 17:30:54 +010013022 .destroy_bind_conf = ssl_sock_destroy_bind_conf,
Willy Tarreau17d45382016-12-22 21:16:08 +010013023 .prepare_srv = ssl_sock_prepare_srv_ctx,
13024 .destroy_srv = ssl_sock_free_srv_ctx,
Willy Tarreau8743f7e2016-12-04 18:44:29 +010013025 .get_alpn = ssl_sock_get_alpn,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +010013026 .name = "SSL",
Emeric Brun46591952012-05-18 15:47:34 +020013027};
13028
Olivier Houchardccaa7de2017-10-02 11:51:03 +020013029enum act_return ssl_action_wait_for_hs(struct act_rule *rule, struct proxy *px,
13030 struct session *sess, struct stream *s, int flags)
13031{
13032 struct connection *conn;
Olivier Houchard6fa63d92017-11-27 18:41:32 +010013033 struct conn_stream *cs;
Olivier Houchardccaa7de2017-10-02 11:51:03 +020013034
13035 conn = objt_conn(sess->origin);
Olivier Houchard6fa63d92017-11-27 18:41:32 +010013036 cs = objt_cs(s->si[0].end);
Olivier Houchardccaa7de2017-10-02 11:51:03 +020013037
Olivier Houchard6fa63d92017-11-27 18:41:32 +010013038 if (conn && cs) {
Olivier Houchardccaa7de2017-10-02 11:51:03 +020013039 if (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS)) {
Olivier Houchard6fa63d92017-11-27 18:41:32 +010013040 cs->flags |= CS_FL_WAIT_FOR_HS;
Olivier Houchardccaa7de2017-10-02 11:51:03 +020013041 s->req.flags |= CF_READ_NULL;
13042 return ACT_RET_YIELD;
13043 }
13044 }
13045 return (ACT_RET_CONT);
13046}
13047
13048static enum act_parse_ret ssl_parse_wait_for_hs(const char **args, int *orig_arg, struct proxy *px, struct act_rule *rule, char **err)
13049{
13050 rule->action_ptr = ssl_action_wait_for_hs;
13051
13052 return ACT_RET_PRS_OK;
13053}
13054
13055static struct action_kw_list http_req_actions = {ILH, {
13056 { "wait-for-handshake", ssl_parse_wait_for_hs },
13057 { /* END */ }
13058}};
13059
Willy Tarreau0108d902018-11-25 19:14:37 +010013060INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_actions);
13061
Willy Tarreau5db847a2019-05-09 14:13:35 +020013062#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010013063
13064static void ssl_sock_sctl_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
13065{
13066 if (ptr) {
13067 chunk_destroy(ptr);
13068 free(ptr);
13069 }
13070}
13071
13072#endif
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +010013073static void ssl_sock_capture_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
13074{
Willy Tarreaubafbe012017-11-24 17:34:44 +010013075 pool_free(pool_head_ssl_capture, ptr);
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +010013076}
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010013077
Emeric Brun46591952012-05-18 15:47:34 +020013078__attribute__((constructor))
Willy Tarreau92faadf2012-10-10 23:04:25 +020013079static void __ssl_sock_init(void)
13080{
Ilya Shipitsin0590f442019-05-25 19:30:50 +050013081#if (!defined(OPENSSL_NO_COMP) && !defined(SSL_OP_NO_COMPRESSION))
Emeric Brun46591952012-05-18 15:47:34 +020013082 STACK_OF(SSL_COMP)* cm;
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050013083 int n;
Ilya Shipitsin0590f442019-05-25 19:30:50 +050013084#endif
Emeric Brun46591952012-05-18 15:47:34 +020013085
Willy Tarreauef934602016-12-22 23:12:01 +010013086 if (global_ssl.listen_default_ciphers)
13087 global_ssl.listen_default_ciphers = strdup(global_ssl.listen_default_ciphers);
13088 if (global_ssl.connect_default_ciphers)
13089 global_ssl.connect_default_ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +020013090#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020013091 if (global_ssl.listen_default_ciphersuites)
13092 global_ssl.listen_default_ciphersuites = strdup(global_ssl.listen_default_ciphersuites);
13093 if (global_ssl.connect_default_ciphersuites)
13094 global_ssl.connect_default_ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
13095#endif
Willy Tarreau610f04b2014-02-13 11:36:41 +010013096
Willy Tarreau13e14102016-12-22 20:25:26 +010013097 xprt_register(XPRT_SSL, &ssl_sock);
Willy Tarreau9a1ab082019-05-09 13:26:41 +020013098#if HA_OPENSSL_VERSION_NUMBER < 0x10100000L
Emeric Brun46591952012-05-18 15:47:34 +020013099 SSL_library_init();
Rosen Penev68185952018-12-14 08:47:02 -080013100#endif
Ilya Shipitsin0590f442019-05-25 19:30:50 +050013101#if (!defined(OPENSSL_NO_COMP) && !defined(SSL_OP_NO_COMPRESSION))
Emeric Brun46591952012-05-18 15:47:34 +020013102 cm = SSL_COMP_get_compression_methods();
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050013103 n = sk_SSL_COMP_num(cm);
13104 while (n--) {
13105 (void) sk_SSL_COMP_pop(cm);
13106 }
Ilya Shipitsin0590f442019-05-25 19:30:50 +050013107#endif
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050013108
Willy Tarreau5db847a2019-05-09 14:13:35 +020013109#if defined(USE_THREAD) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Emeric Brun821bb9b2017-06-15 16:37:39 +020013110 ssl_locking_init();
13111#endif
Willy Tarreau5db847a2019-05-09 14:13:35 +020013112#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010013113 sctl_ex_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, ssl_sock_sctl_free_func);
13114#endif
Thierry FOURNIER28962c92018-06-17 21:37:05 +020013115 ssl_app_data_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
Thierry FOURNIER16ff0502018-06-17 21:33:01 +020013116 ssl_capture_ptr_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, ssl_sock_capture_free_func);
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020013117#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +000013118 ENGINE_load_builtin_engines();
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000013119 hap_register_post_check(ssl_check_async_engine_count);
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020013120#endif
Willy Tarreaud1c57502016-12-22 22:46:15 +010013121#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
13122 hap_register_post_check(tlskeys_finalize_config);
13123#endif
Willy Tarreau80713382018-11-26 10:19:54 +010013124
13125 global.ssl_session_max_cost = SSL_SESSION_MAX_COST;
13126 global.ssl_handshake_max_cost = SSL_HANDSHAKE_MAX_COST;
13127
Emmanuel Hocdet70df7bf2019-01-04 11:08:20 +010013128 hap_register_post_deinit(ssl_free_global_issuers);
13129
Willy Tarreau80713382018-11-26 10:19:54 +010013130#ifndef OPENSSL_NO_DH
13131 ssl_dh_ptr_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);
13132 hap_register_post_deinit(ssl_free_dh);
13133#endif
13134#ifndef OPENSSL_NO_ENGINE
13135 hap_register_post_deinit(ssl_free_engines);
13136#endif
13137 /* Load SSL string for the verbose & debug mode. */
13138 ERR_load_SSL_strings();
Olivier Houcharda8955d52019-04-07 22:00:38 +020013139 ha_meth = BIO_meth_new(0x666, "ha methods");
13140 BIO_meth_set_write(ha_meth, ha_ssl_write);
13141 BIO_meth_set_read(ha_meth, ha_ssl_read);
13142 BIO_meth_set_ctrl(ha_meth, ha_ssl_ctrl);
13143 BIO_meth_set_create(ha_meth, ha_ssl_new);
13144 BIO_meth_set_destroy(ha_meth, ha_ssl_free);
13145 BIO_meth_set_puts(ha_meth, ha_ssl_puts);
13146 BIO_meth_set_gets(ha_meth, ha_ssl_gets);
William Lallemand150bfa82019-09-19 17:12:49 +020013147
13148 HA_SPIN_INIT(&ckch_lock);
Willy Tarreau80713382018-11-26 10:19:54 +010013149}
Willy Tarreaud92aa5c2015-01-15 21:34:39 +010013150
Willy Tarreau80713382018-11-26 10:19:54 +010013151/* Compute and register the version string */
13152static void ssl_register_build_options()
13153{
13154 char *ptr = NULL;
13155 int i;
13156
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013157 memprintf(&ptr, "Built with OpenSSL version : "
13158#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet50e25e12017-03-24 15:20:03 +010013159 "BoringSSL");
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013160#else /* OPENSSL_IS_BORINGSSL */
13161 OPENSSL_VERSION_TEXT
13162 "\nRunning on OpenSSL version : %s%s",
Rosen Penev68185952018-12-14 08:47:02 -080013163 OpenSSL_version(OPENSSL_VERSION),
Willy Tarreau1d158ab2019-05-09 13:41:45 +020013164 ((OPENSSL_VERSION_NUMBER ^ OpenSSL_version_num()) >> 8) ? " (VERSIONS DIFFER!)" : "");
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013165#endif
13166 memprintf(&ptr, "%s\nOpenSSL library supports TLS extensions : "
Willy Tarreau9a1ab082019-05-09 13:26:41 +020013167#if HA_OPENSSL_VERSION_NUMBER < 0x00907000L
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013168 "no (library version too old)"
13169#elif defined(OPENSSL_NO_TLSEXT)
13170 "no (disabled via OPENSSL_NO_TLSEXT)"
13171#else
13172 "yes"
13173#endif
13174 "", ptr);
13175
13176 memprintf(&ptr, "%s\nOpenSSL library supports SNI : "
13177#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
13178 "yes"
13179#else
13180#ifdef OPENSSL_NO_TLSEXT
13181 "no (because of OPENSSL_NO_TLSEXT)"
13182#else
13183 "no (version might be too old, 0.9.8f min needed)"
13184#endif
13185#endif
13186 "", ptr);
13187
Emmanuel Hocdetf80bc242017-07-12 14:25:38 +020013188 memprintf(&ptr, "%s\nOpenSSL library supports :", ptr);
13189 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
13190 if (methodVersions[i].option)
13191 memprintf(&ptr, "%s %s", ptr, methodVersions[i].name);
Emmanuel Hocdet50e25e12017-03-24 15:20:03 +010013192
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013193 hap_register_build_opts(ptr, 1);
Willy Tarreau80713382018-11-26 10:19:54 +010013194}
Willy Tarreauc2c0b612016-12-21 19:23:20 +010013195
Willy Tarreau80713382018-11-26 10:19:54 +010013196INITCALL0(STG_REGISTER, ssl_register_build_options);
Remi Gacogne4f902b82015-05-28 16:23:00 +020013197
Emeric Brun46591952012-05-18 15:47:34 +020013198
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020013199#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +000013200void ssl_free_engines(void) {
13201 struct ssl_engine_list *wl, *wlb;
13202 /* free up engine list */
13203 list_for_each_entry_safe(wl, wlb, &openssl_engines, list) {
13204 ENGINE_finish(wl->e);
13205 ENGINE_free(wl->e);
13206 LIST_DEL(&wl->list);
13207 free(wl);
13208 }
13209}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020013210#endif
Christopher Faulet31af49d2015-06-09 17:29:50 +020013211
Remi Gacogned3a23c32015-05-28 16:39:47 +020013212#ifndef OPENSSL_NO_DH
Grant Zhang872f9c22017-01-21 01:10:18 +000013213void ssl_free_dh(void) {
13214 if (local_dh_1024) {
13215 DH_free(local_dh_1024);
13216 local_dh_1024 = NULL;
13217 }
13218 if (local_dh_2048) {
13219 DH_free(local_dh_2048);
13220 local_dh_2048 = NULL;
13221 }
13222 if (local_dh_4096) {
13223 DH_free(local_dh_4096);
13224 local_dh_4096 = NULL;
13225 }
Remi Gacogne47783ef2015-05-29 15:53:22 +020013226 if (global_dh) {
13227 DH_free(global_dh);
13228 global_dh = NULL;
13229 }
Grant Zhang872f9c22017-01-21 01:10:18 +000013230}
13231#endif
13232
13233__attribute__((destructor))
13234static void __ssl_sock_deinit(void)
13235{
13236#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Emeric Brun821bb9b2017-06-15 16:37:39 +020013237 if (ssl_ctx_lru_tree) {
13238 lru64_destroy(ssl_ctx_lru_tree);
Christopher Faulet2a944ee2017-11-07 10:42:54 +010013239 HA_RWLOCK_DESTROY(&ssl_ctx_lru_rwlock);
Emeric Brun821bb9b2017-06-15 16:37:39 +020013240 }
Remi Gacogned3a23c32015-05-28 16:39:47 +020013241#endif
13242
Willy Tarreau5db847a2019-05-09 14:13:35 +020013243#if (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Remi Gacogned3a23c32015-05-28 16:39:47 +020013244 ERR_remove_state(0);
13245 ERR_free_strings();
13246
13247 EVP_cleanup();
Rosen Penev68185952018-12-14 08:47:02 -080013248#endif
Remi Gacogned3a23c32015-05-28 16:39:47 +020013249
Willy Tarreau5db847a2019-05-09 14:13:35 +020013250#if (HA_OPENSSL_VERSION_NUMBER >= 0x00907000L) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Remi Gacogned3a23c32015-05-28 16:39:47 +020013251 CRYPTO_cleanup_all_ex_data();
13252#endif
Olivier Houcharda8955d52019-04-07 22:00:38 +020013253 BIO_meth_free(ha_meth);
Remi Gacogned3a23c32015-05-28 16:39:47 +020013254}
13255
13256
Emeric Brun46591952012-05-18 15:47:34 +020013257/*
13258 * Local variables:
13259 * c-indent-level: 8
13260 * c-basic-offset: 8
13261 * End:
13262 */