blob: 8e5d1a21f5a88978574218dea71c2ab7f7fda3b4 [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
Emeric Brunfc0421f2012-09-07 17:30:07 +020060#include <ebsttree.h>
61
William Lallemand32af2032016-10-29 18:09:35 +020062#include <types/applet.h>
63#include <types/cli.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020064#include <types/global.h>
65#include <types/ssl_sock.h>
William Lallemand32af2032016-10-29 18:09:35 +020066#include <types/stats.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020067
Willy Tarreau7875d092012-09-10 08:20:03 +020068#include <proto/acl.h>
69#include <proto/arg.h>
William Lallemand32af2032016-10-29 18:09:35 +020070#include <proto/channel.h>
Emeric Brun46591952012-05-18 15:47:34 +020071#include <proto/connection.h>
William Lallemand32af2032016-10-29 18:09:35 +020072#include <proto/cli.h>
Emeric Brun46591952012-05-18 15:47:34 +020073#include <proto/fd.h>
74#include <proto/freq_ctr.h>
75#include <proto/frontend.h>
Willy Tarreau61c112a2018-10-02 16:43:32 +020076#include <proto/http_rules.h>
Willy Tarreau79eeafa2012-09-14 07:53:05 +020077#include <proto/listener.h>
Thierry FOURNIERed66c292013-11-28 11:05:19 +010078#include <proto/pattern.h>
Christopher Faulet31af49d2015-06-09 17:29:50 +020079#include <proto/proto_tcp.h>
Olivier Houchardccaa7de2017-10-02 11:51:03 +020080#include <proto/proto_http.h>
Willy Tarreau92faadf2012-10-10 23:04:25 +020081#include <proto/server.h>
William Lallemand32af2032016-10-29 18:09:35 +020082#include <proto/stream_interface.h>
Emeric Brun46591952012-05-18 15:47:34 +020083#include <proto/log.h>
Emeric Brun94324a42012-10-11 14:00:19 +020084#include <proto/proxy.h>
Emeric Brunfc0421f2012-09-07 17:30:07 +020085#include <proto/shctx.h>
Emeric Brun46591952012-05-18 15:47:34 +020086#include <proto/ssl_sock.h>
Willy Tarreau9ad7bd42015-04-03 19:19:59 +020087#include <proto/stream.h>
Emeric Brun46591952012-05-18 15:47:34 +020088#include <proto/task.h>
Nenad Merdanovicc31499d2019-03-23 11:00:32 +010089#include <proto/vars.h>
Emeric Brun46591952012-05-18 15:47:34 +020090
Willy Tarreau9356dac2019-05-10 09:22:53 +020091/* ***** READ THIS before adding code here! *****
92 *
93 * Due to API incompatibilities between multiple OpenSSL versions and their
94 * derivatives, it's often tempting to add macros to (re-)define certain
95 * symbols. Please do not do this here, and do it in common/openssl-compat.h
96 * exclusively so that the whole code consistently uses the same macros.
97 *
98 * Whenever possible if a macro is missing in certain versions, it's better
99 * to conditionally define it in openssl-compat.h than using lots of ifdefs.
100 */
101
Willy Tarreau518cedd2014-02-17 15:43:01 +0100102/* Warning, these are bits, not integers! */
Emeric Brune64aef12012-09-21 13:15:06 +0200103#define SSL_SOCK_ST_FL_VERIFY_DONE 0x00000001
Emeric Brund8b2bb52014-01-28 15:43:53 +0100104#define SSL_SOCK_ST_FL_16K_WBFSIZE 0x00000002
Willy Tarreau518cedd2014-02-17 15:43:01 +0100105#define SSL_SOCK_SEND_UNLIMITED 0x00000004
Emeric Brun29f037d2014-04-25 19:05:36 +0200106#define SSL_SOCK_RECV_HEARTBEAT 0x00000008
107
Emeric Brunf282a812012-09-21 15:27:54 +0200108/* bits 0xFFFF0000 are reserved to store verify errors */
109
110/* Verify errors macros */
111#define SSL_SOCK_CA_ERROR_TO_ST(e) (((e > 63) ? 63 : e) << (16))
112#define SSL_SOCK_CAEDEPTH_TO_ST(d) (((d > 15) ? 15 : d) << (6+16))
113#define SSL_SOCK_CRTERROR_TO_ST(e) (((e > 63) ? 63 : e) << (4+6+16))
114
115#define SSL_SOCK_ST_TO_CA_ERROR(s) ((s >> (16)) & 63)
116#define SSL_SOCK_ST_TO_CAEDEPTH(s) ((s >> (6+16)) & 15)
117#define SSL_SOCK_ST_TO_CRTERROR(s) ((s >> (4+6+16)) & 63)
Emeric Brune64aef12012-09-21 13:15:06 +0200118
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200119/* ssl_methods flags for ssl options */
120#define MC_SSL_O_ALL 0x0000
121#define MC_SSL_O_NO_SSLV3 0x0001 /* disable SSLv3 */
122#define MC_SSL_O_NO_TLSV10 0x0002 /* disable TLSv10 */
123#define MC_SSL_O_NO_TLSV11 0x0004 /* disable TLSv11 */
124#define MC_SSL_O_NO_TLSV12 0x0008 /* disable TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +0200125#define MC_SSL_O_NO_TLSV13 0x0010 /* disable TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200126
127/* ssl_methods versions */
128enum {
129 CONF_TLSV_NONE = 0,
130 CONF_TLSV_MIN = 1,
131 CONF_SSLV3 = 1,
132 CONF_TLSV10 = 2,
133 CONF_TLSV11 = 3,
134 CONF_TLSV12 = 4,
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +0200135 CONF_TLSV13 = 5,
136 CONF_TLSV_MAX = 5,
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200137};
138
Emeric Brun850efd52014-01-29 12:24:34 +0100139/* server and bind verify method, it uses a global value as default */
140enum {
141 SSL_SOCK_VERIFY_DEFAULT = 0,
142 SSL_SOCK_VERIFY_REQUIRED = 1,
143 SSL_SOCK_VERIFY_OPTIONAL = 2,
144 SSL_SOCK_VERIFY_NONE = 3,
145};
146
William Lallemand3f85c9a2017-10-09 16:30:50 +0200147
Willy Tarreau71b734c2014-01-28 15:19:44 +0100148int sslconns = 0;
149int totalsslconns = 0;
Willy Tarreaud9f5cca2016-12-22 21:08:52 +0100150static struct xprt_ops ssl_sock;
Emeric Brunece0c332017-12-06 13:51:49 +0100151int nb_engines = 0;
Emeric Brune1f38db2012-09-03 20:36:47 +0200152
Willy Tarreauef934602016-12-22 23:12:01 +0100153static struct {
154 char *crt_base; /* base directory path for certificates */
155 char *ca_base; /* base directory path for CAs and CRLs */
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000156 int async; /* whether we use ssl async mode */
Willy Tarreauef934602016-12-22 23:12:01 +0100157
158 char *listen_default_ciphers;
159 char *connect_default_ciphers;
Emmanuel Hocdet839af572019-05-14 16:27:35 +0200160#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +0200161 char *listen_default_ciphersuites;
162 char *connect_default_ciphersuites;
163#endif
Willy Tarreauef934602016-12-22 23:12:01 +0100164 int listen_default_ssloptions;
165 int connect_default_ssloptions;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200166 struct tls_version_filter listen_default_sslmethods;
167 struct tls_version_filter connect_default_sslmethods;
Willy Tarreauef934602016-12-22 23:12:01 +0100168
169 int private_cache; /* Force to use a private session cache even if nbproc > 1 */
170 unsigned int life_time; /* SSL session lifetime in seconds */
171 unsigned int max_record; /* SSL max record size */
172 unsigned int default_dh_param; /* SSL maximum DH parameter size */
173 int ctx_cache; /* max number of entries in the ssl_ctx cache. */
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100174 int capture_cipherlist; /* Size of the cipherlist buffer. */
Willy Tarreauef934602016-12-22 23:12:01 +0100175} global_ssl = {
176#ifdef LISTEN_DEFAULT_CIPHERS
177 .listen_default_ciphers = LISTEN_DEFAULT_CIPHERS,
178#endif
179#ifdef CONNECT_DEFAULT_CIPHERS
180 .connect_default_ciphers = CONNECT_DEFAULT_CIPHERS,
181#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +0200182#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +0200183#ifdef LISTEN_DEFAULT_CIPHERSUITES
184 .listen_default_ciphersuites = LISTEN_DEFAULT_CIPHERSUITES,
185#endif
186#ifdef CONNECT_DEFAULT_CIPHERSUITES
187 .connect_default_ciphersuites = CONNECT_DEFAULT_CIPHERSUITES,
188#endif
189#endif
Willy Tarreauef934602016-12-22 23:12:01 +0100190 .listen_default_ssloptions = BC_SSL_O_NONE,
191 .connect_default_ssloptions = SRV_SSL_O_NONE,
192
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +0200193 .listen_default_sslmethods.flags = MC_SSL_O_ALL,
194 .listen_default_sslmethods.min = CONF_TLSV_NONE,
195 .listen_default_sslmethods.max = CONF_TLSV_NONE,
196 .connect_default_sslmethods.flags = MC_SSL_O_ALL,
197 .connect_default_sslmethods.min = CONF_TLSV_NONE,
198 .connect_default_sslmethods.max = CONF_TLSV_NONE,
199
Willy Tarreauef934602016-12-22 23:12:01 +0100200#ifdef DEFAULT_SSL_MAX_RECORD
201 .max_record = DEFAULT_SSL_MAX_RECORD,
202#endif
203 .default_dh_param = SSL_DEFAULT_DH_PARAM,
204 .ctx_cache = DEFAULT_SSL_CTX_CACHE,
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100205 .capture_cipherlist = 0,
Willy Tarreauef934602016-12-22 23:12:01 +0100206};
207
Olivier Houcharda8955d52019-04-07 22:00:38 +0200208static BIO_METHOD *ha_meth;
209
Olivier Houchard66ab4982019-02-26 18:37:15 +0100210struct ssl_sock_ctx {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200211 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +0100212 SSL *ssl;
Olivier Houcharda8955d52019-04-07 22:00:38 +0200213 BIO *bio;
Olivier Houchard5149b592019-05-23 17:47:36 +0200214 const struct xprt_ops *xprt;
Olivier Houchard66ab4982019-02-26 18:37:15 +0100215 void *xprt_ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +0200216 struct wait_event wait_event;
217 struct wait_event *recv_wait;
218 struct wait_event *send_wait;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +0100219 int xprt_st; /* transport layer state, initialized to zero */
Olivier Houchardf6715e72019-12-19 15:02:39 +0100220 struct buffer early_buf; /* buffer to store the early data received */
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +0100221 int sent_early_data; /* Amount of early data we sent so far */
222
Olivier Houchard66ab4982019-02-26 18:37:15 +0100223};
224
225DECLARE_STATIC_POOL(ssl_sock_ctx_pool, "ssl_sock_ctx_pool", sizeof(struct ssl_sock_ctx));
226
Olivier Houchardea8dd942019-05-20 14:02:16 +0200227static struct task *ssl_sock_io_cb(struct task *, void *, unsigned short);
Olivier Houchard000694c2019-05-23 14:45:12 +0200228static int ssl_sock_handshake(struct connection *conn, unsigned int flag);
Olivier Houchardea8dd942019-05-20 14:02:16 +0200229
Olivier Houcharda8955d52019-04-07 22:00:38 +0200230/* Methods to implement OpenSSL BIO */
231static int ha_ssl_write(BIO *h, const char *buf, int num)
232{
233 struct buffer tmpbuf;
234 struct ssl_sock_ctx *ctx;
235 int ret;
236
237 ctx = BIO_get_data(h);
238 tmpbuf.size = num;
239 tmpbuf.area = (void *)(uintptr_t)buf;
240 tmpbuf.data = num;
241 tmpbuf.head = 0;
242 ret = ctx->xprt->snd_buf(ctx->conn, ctx->xprt_ctx, &tmpbuf, num, 0);
Olivier Houchardb51937e2019-05-01 17:24:36 +0200243 if (ret == 0 && !(ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_WR_SH))) {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200244 BIO_set_retry_write(h);
Olivier Houcharda28454e2019-04-24 12:04:36 +0200245 ret = -1;
Olivier Houchardb51937e2019-05-01 17:24:36 +0200246 } else if (ret == 0)
247 BIO_clear_retry_flags(h);
Olivier Houcharda8955d52019-04-07 22:00:38 +0200248 return ret;
249}
250
251static int ha_ssl_gets(BIO *h, char *buf, int size)
252{
253
254 return 0;
255}
256
257static int ha_ssl_puts(BIO *h, const char *str)
258{
259
260 return ha_ssl_write(h, str, strlen(str));
261}
262
263static int ha_ssl_read(BIO *h, char *buf, int size)
264{
265 struct buffer tmpbuf;
266 struct ssl_sock_ctx *ctx;
267 int ret;
268
269 ctx = BIO_get_data(h);
270 tmpbuf.size = size;
271 tmpbuf.area = buf;
272 tmpbuf.data = 0;
273 tmpbuf.head = 0;
274 ret = ctx->xprt->rcv_buf(ctx->conn, ctx->xprt_ctx, &tmpbuf, size, 0);
Olivier Houchardb51937e2019-05-01 17:24:36 +0200275 if (ret == 0 && !(ctx->conn->flags & (CO_FL_ERROR | CO_FL_SOCK_RD_SH))) {
Olivier Houcharda8955d52019-04-07 22:00:38 +0200276 BIO_set_retry_read(h);
Olivier Houcharda28454e2019-04-24 12:04:36 +0200277 ret = -1;
Olivier Houchardb51937e2019-05-01 17:24:36 +0200278 } else if (ret == 0)
279 BIO_clear_retry_flags(h);
Olivier Houcharda8955d52019-04-07 22:00:38 +0200280
281 return ret;
282}
283
284static long ha_ssl_ctrl(BIO *h, int cmd, long arg1, void *arg2)
285{
286 int ret = 0;
287 switch (cmd) {
288 case BIO_CTRL_DUP:
289 case BIO_CTRL_FLUSH:
290 ret = 1;
291 break;
292 }
293 return ret;
294}
295
296static int ha_ssl_new(BIO *h)
297{
298 BIO_set_init(h, 1);
299 BIO_set_data(h, NULL);
300 BIO_clear_flags(h, ~0);
301 return 1;
302}
303
304static int ha_ssl_free(BIO *data)
305{
306
307 return 1;
308}
309
310
Willy Tarreau5db847a2019-05-09 14:13:35 +0200311#if defined(USE_THREAD) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Christopher Faulet9dcf9b62017-11-13 10:34:01 +0100312
Emeric Brun821bb9b2017-06-15 16:37:39 +0200313static HA_RWLOCK_T *ssl_rwlocks;
314
315
316unsigned long ssl_id_function(void)
317{
318 return (unsigned long)tid;
319}
320
321void ssl_locking_function(int mode, int n, const char * file, int line)
322{
323 if (mode & CRYPTO_LOCK) {
324 if (mode & CRYPTO_READ)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100325 HA_RWLOCK_RDLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200326 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100327 HA_RWLOCK_WRLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200328 }
329 else {
330 if (mode & CRYPTO_READ)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100331 HA_RWLOCK_RDUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200332 else
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100333 HA_RWLOCK_WRUNLOCK(SSL_LOCK, &ssl_rwlocks[n]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200334 }
335}
336
337static int ssl_locking_init(void)
338{
339 int i;
340
341 ssl_rwlocks = malloc(sizeof(HA_RWLOCK_T)*CRYPTO_num_locks());
342 if (!ssl_rwlocks)
343 return -1;
344
345 for (i = 0 ; i < CRYPTO_num_locks() ; i++)
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100346 HA_RWLOCK_INIT(&ssl_rwlocks[i]);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200347
348 CRYPTO_set_id_callback(ssl_id_function);
349 CRYPTO_set_locking_callback(ssl_locking_function);
350
351 return 0;
352}
Christopher Faulet9dcf9b62017-11-13 10:34:01 +0100353
Emeric Brun821bb9b2017-06-15 16:37:39 +0200354#endif
355
356
357
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +0100358/* This memory pool is used for capturing clienthello parameters. */
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100359struct ssl_capture {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +0100360 unsigned long long int xxh64;
361 unsigned char ciphersuite_len;
362 char ciphersuite[0];
363};
Willy Tarreaubafbe012017-11-24 17:34:44 +0100364struct pool_head *pool_head_ssl_capture = NULL;
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +0100365static int ssl_capture_ptr_index = -1;
Thierry FOURNIER28962c92018-06-17 21:37:05 +0200366static int ssl_app_data_index = -1;
Willy Tarreauef934602016-12-22 23:12:01 +0100367
Emmanuel Hocdet96b78342017-10-31 15:46:07 +0100368static int ssl_pkey_info_index = -1;
369
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +0200370#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
371struct list tlskeys_reference = LIST_HEAD_INIT(tlskeys_reference);
372#endif
373
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200374#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +0000375static unsigned int openssl_engines_initialized;
376struct list openssl_engines = LIST_HEAD_INIT(openssl_engines);
377struct ssl_engine_list {
378 struct list list;
379 ENGINE *e;
380};
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200381#endif
Grant Zhang872f9c22017-01-21 01:10:18 +0000382
Remi Gacogne8de54152014-07-15 11:36:40 +0200383#ifndef OPENSSL_NO_DH
Remi Gacogne4f902b82015-05-28 16:23:00 +0200384static int ssl_dh_ptr_index = -1;
Remi Gacogne47783ef2015-05-29 15:53:22 +0200385static DH *global_dh = NULL;
Remi Gacogne8de54152014-07-15 11:36:40 +0200386static DH *local_dh_1024 = NULL;
387static DH *local_dh_2048 = NULL;
388static DH *local_dh_4096 = NULL;
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +0100389static DH *ssl_get_tmp_dh(SSL *ssl, int export, int keylen);
Remi Gacogne8de54152014-07-15 11:36:40 +0200390#endif /* OPENSSL_NO_DH */
391
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100392#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Christopher Faulet31af49d2015-06-09 17:29:50 +0200393/* X509V3 Extensions that will be added on generated certificates */
394#define X509V3_EXT_SIZE 5
395static char *x509v3_ext_names[X509V3_EXT_SIZE] = {
396 "basicConstraints",
397 "nsComment",
398 "subjectKeyIdentifier",
399 "authorityKeyIdentifier",
400 "keyUsage",
401};
402static char *x509v3_ext_values[X509V3_EXT_SIZE] = {
403 "CA:FALSE",
404 "\"OpenSSL Generated Certificate\"",
405 "hash",
406 "keyid,issuer:always",
407 "nonRepudiation,digitalSignature,keyEncipherment"
408};
Christopher Faulet31af49d2015-06-09 17:29:50 +0200409/* LRU cache to store generated certificate */
410static struct lru64_head *ssl_ctx_lru_tree = NULL;
411static unsigned int ssl_ctx_lru_seed = 0;
Emeric Brun821bb9b2017-06-15 16:37:39 +0200412static unsigned int ssl_ctx_serial;
Willy Tarreau86abe442018-11-25 20:12:18 +0100413__decl_rwlock(ssl_ctx_lru_rwlock);
Emeric Brun821bb9b2017-06-15 16:37:39 +0200414
Willy Tarreauc8ad3be2015-06-17 15:48:26 +0200415#endif // SSL_CTRL_SET_TLSEXT_HOSTNAME
416
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100417static struct ssl_bind_kw ssl_bind_kws[];
418
Willy Tarreau9a1ab082019-05-09 13:26:41 +0200419#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhube2774d2015-12-10 15:07:30 -0500420/* The order here matters for picking a default context,
421 * keep the most common keytype at the bottom of the list
422 */
423const char *SSL_SOCK_KEYTYPE_NAMES[] = {
424 "dsa",
425 "ecdsa",
426 "rsa"
427};
428#define SSL_SOCK_NUM_KEYTYPES 3
Willy Tarreau30da7ad2015-12-14 11:28:33 +0100429#else
430#define SSL_SOCK_NUM_KEYTYPES 1
yanbzhube2774d2015-12-10 15:07:30 -0500431#endif
432
William Lallemandc3cd35f2017-11-28 11:04:43 +0100433static struct shared_context *ssl_shctx = NULL; /* ssl shared session cache */
William Lallemand4f45bb92017-10-30 20:08:51 +0100434static struct eb_root *sh_ssl_sess_tree; /* ssl shared session tree */
435
436#define sh_ssl_sess_tree_delete(s) ebmb_delete(&(s)->key);
437
438#define sh_ssl_sess_tree_insert(s) (struct sh_ssl_sess_hdr *)ebmb_insert(sh_ssl_sess_tree, \
439 &(s)->key, SSL_MAX_SSL_SESSION_ID_LENGTH);
440
441#define sh_ssl_sess_tree_lookup(k) (struct sh_ssl_sess_hdr *)ebmb_lookup(sh_ssl_sess_tree, \
442 (k), SSL_MAX_SSL_SESSION_ID_LENGTH);
William Lallemand3f85c9a2017-10-09 16:30:50 +0200443
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100444/*
445 * This function gives the detail of the SSL error. It is used only
446 * if the debug mode and the verbose mode are activated. It dump all
447 * the SSL error until the stack was empty.
448 */
449static forceinline void ssl_sock_dump_errors(struct connection *conn)
450{
451 unsigned long ret;
452
453 if (unlikely(global.mode & MODE_DEBUG)) {
454 while(1) {
455 ret = ERR_get_error();
456 if (ret == 0)
457 return;
458 fprintf(stderr, "fd[%04x] OpenSSL error[0x%lx] %s: %s\n",
Willy Tarreau585744b2017-08-24 14:31:19 +0200459 (unsigned short)conn->handle.fd, ret,
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100460 ERR_func_error_string(ret), ERR_reason_error_string(ret));
461 }
462 }
463}
464
yanbzhube2774d2015-12-10 15:07:30 -0500465
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200466#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +0000467static int ssl_init_single_engine(const char *engine_id, const char *def_algorithms)
468{
469 int err_code = ERR_ABORT;
470 ENGINE *engine;
471 struct ssl_engine_list *el;
472
473 /* grab the structural reference to the engine */
474 engine = ENGINE_by_id(engine_id);
475 if (engine == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100476 ha_alert("ssl-engine %s: failed to get structural reference\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000477 goto fail_get;
478 }
479
480 if (!ENGINE_init(engine)) {
481 /* the engine couldn't initialise, release it */
Christopher Faulet767a84b2017-11-24 16:50:31 +0100482 ha_alert("ssl-engine %s: failed to initialize\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000483 goto fail_init;
484 }
485
486 if (ENGINE_set_default_string(engine, def_algorithms) == 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +0100487 ha_alert("ssl-engine %s: failed on ENGINE_set_default_string\n", engine_id);
Grant Zhang872f9c22017-01-21 01:10:18 +0000488 goto fail_set_method;
489 }
490
491 el = calloc(1, sizeof(*el));
492 el->e = engine;
493 LIST_ADD(&openssl_engines, &el->list);
Emeric Brunece0c332017-12-06 13:51:49 +0100494 nb_engines++;
495 if (global_ssl.async)
496 global.ssl_used_async_engines = nb_engines;
Grant Zhang872f9c22017-01-21 01:10:18 +0000497 return 0;
498
499fail_set_method:
500 /* release the functional reference from ENGINE_init() */
501 ENGINE_finish(engine);
502
503fail_init:
504 /* release the structural reference from ENGINE_by_id() */
505 ENGINE_free(engine);
506
507fail_get:
508 return err_code;
509}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +0200510#endif
Grant Zhang872f9c22017-01-21 01:10:18 +0000511
Willy Tarreau5db847a2019-05-09 14:13:35 +0200512#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brun3854e012017-05-17 20:42:48 +0200513/*
514 * openssl async fd handler
515 */
Emeric Brund0e095c2019-04-19 17:15:28 +0200516void ssl_async_fd_handler(int fd)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000517{
Olivier Houchardea8dd942019-05-20 14:02:16 +0200518 struct ssl_sock_ctx *ctx = fdtab[fd].owner;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000519
Emeric Brun3854e012017-05-17 20:42:48 +0200520 /* fd is an async enfine fd, we must stop
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000521 * to poll this fd until it is requested
522 */
Emeric Brunbbc16542017-06-02 15:54:06 +0000523 fd_stop_recv(fd);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000524 fd_cant_recv(fd);
525
526 /* crypto engine is available, let's notify the associated
527 * connection that it can pursue its processing.
528 */
Olivier Houchard03abf2d2019-05-28 10:12:02 +0200529 ssl_sock_io_cb(NULL, ctx, 0);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000530}
531
Emeric Brun3854e012017-05-17 20:42:48 +0200532/*
533 * openssl async delayed SSL_free handler
534 */
Emeric Brund0e095c2019-04-19 17:15:28 +0200535void ssl_async_fd_free(int fd)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000536{
537 SSL *ssl = fdtab[fd].owner;
Emeric Brun3854e012017-05-17 20:42:48 +0200538 OSSL_ASYNC_FD all_fd[32];
539 size_t num_all_fds = 0;
540 int i;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000541
Emeric Brun3854e012017-05-17 20:42:48 +0200542 /* We suppose that the async job for a same SSL *
543 * are serialized. So if we are awake it is
544 * because the running job has just finished
545 * and we can remove all async fds safely
546 */
547 SSL_get_all_async_fds(ssl, NULL, &num_all_fds);
548 if (num_all_fds > 32) {
549 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
550 return;
551 }
552
553 SSL_get_all_async_fds(ssl, all_fd, &num_all_fds);
554 for (i=0 ; i < num_all_fds ; i++)
555 fd_remove(all_fd[i]);
556
557 /* Now we can safely call SSL_free, no more pending job in engines */
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000558 SSL_free(ssl);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +0100559 _HA_ATOMIC_SUB(&sslconns, 1);
560 _HA_ATOMIC_SUB(&jobs, 1);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000561}
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000562/*
Emeric Brun3854e012017-05-17 20:42:48 +0200563 * function used to manage a returned SSL_ERROR_WANT_ASYNC
564 * and enable/disable polling for async fds
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000565 */
Olivier Houchardea8dd942019-05-20 14:02:16 +0200566static inline void ssl_async_process_fds(struct ssl_sock_ctx *ctx)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000567{
Willy Tarreaua9786b62018-01-25 07:22:13 +0100568 OSSL_ASYNC_FD add_fd[32];
Emeric Brun3854e012017-05-17 20:42:48 +0200569 OSSL_ASYNC_FD del_fd[32];
Olivier Houchardea8dd942019-05-20 14:02:16 +0200570 SSL *ssl = ctx->ssl;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000571 size_t num_add_fds = 0;
572 size_t num_del_fds = 0;
Emeric Brun3854e012017-05-17 20:42:48 +0200573 int i;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000574
575 SSL_get_changed_async_fds(ssl, NULL, &num_add_fds, NULL,
576 &num_del_fds);
Emeric Brun3854e012017-05-17 20:42:48 +0200577 if (num_add_fds > 32 || num_del_fds > 32) {
578 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 +0000579 return;
580 }
581
Emeric Brun3854e012017-05-17 20:42:48 +0200582 SSL_get_changed_async_fds(ssl, add_fd, &num_add_fds, del_fd, &num_del_fds);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000583
Emeric Brun3854e012017-05-17 20:42:48 +0200584 /* We remove unused fds from the fdtab */
585 for (i=0 ; i < num_del_fds ; i++)
586 fd_remove(del_fd[i]);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000587
Emeric Brun3854e012017-05-17 20:42:48 +0200588 /* We add new fds to the fdtab */
589 for (i=0 ; i < num_add_fds ; i++) {
Olivier Houchardea8dd942019-05-20 14:02:16 +0200590 fd_insert(add_fd[i], ctx, ssl_async_fd_handler, tid_bit);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000591 }
592
Emeric Brun3854e012017-05-17 20:42:48 +0200593 num_add_fds = 0;
594 SSL_get_all_async_fds(ssl, NULL, &num_add_fds);
595 if (num_add_fds > 32) {
596 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
597 return;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000598 }
Emeric Brun3854e012017-05-17 20:42:48 +0200599
600 /* We activate the polling for all known async fds */
601 SSL_get_all_async_fds(ssl, add_fd, &num_add_fds);
Emeric Brunce9e01c2017-05-31 10:02:53 +0000602 for (i=0 ; i < num_add_fds ; i++) {
Emeric Brun3854e012017-05-17 20:42:48 +0200603 fd_want_recv(add_fd[i]);
Emeric Brunce9e01c2017-05-31 10:02:53 +0000604 /* To ensure that the fd cache won't be used
605 * We'll prefer to catch a real RD event
606 * because handling an EAGAIN on this fd will
607 * result in a context switch and also
608 * some engines uses a fd in blocking mode.
609 */
610 fd_cant_recv(add_fd[i]);
611 }
Emeric Brun3854e012017-05-17 20:42:48 +0200612
Grant Zhangfa6c7ee2017-01-14 01:42:15 +0000613}
614#endif
615
William Lallemandc33d83d2019-10-14 14:14:59 +0200616#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
Emeric Brun4f3c87a2014-06-20 15:46:13 +0200617/*
618 * This function returns the number of seconds elapsed
619 * since the Epoch, 1970-01-01 00:00:00 +0000 (UTC) and the
620 * date presented un ASN1_GENERALIZEDTIME.
621 *
622 * In parsing error case, it returns -1.
623 */
624static long asn1_generalizedtime_to_epoch(ASN1_GENERALIZEDTIME *d)
625{
626 long epoch;
627 char *p, *end;
628 const unsigned short month_offset[12] = {
629 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334
630 };
631 int year, month;
632
633 if (!d || (d->type != V_ASN1_GENERALIZEDTIME)) return -1;
634
635 p = (char *)d->data;
636 end = p + d->length;
637
638 if (end - p < 4) return -1;
639 year = 1000 * (p[0] - '0') + 100 * (p[1] - '0') + 10 * (p[2] - '0') + p[3] - '0';
640 p += 4;
641 if (end - p < 2) return -1;
642 month = 10 * (p[0] - '0') + p[1] - '0';
643 if (month < 1 || month > 12) return -1;
644 /* Compute the number of seconds since 1 jan 1970 and the beginning of current month
645 We consider leap years and the current month (<marsh or not) */
646 epoch = ( ((year - 1970) * 365)
647 + ((year - (month < 3)) / 4 - (year - (month < 3)) / 100 + (year - (month < 3)) / 400)
648 - ((1970 - 1) / 4 - (1970 - 1) / 100 + (1970 - 1) / 400)
649 + month_offset[month-1]
650 ) * 24 * 60 * 60;
651 p += 2;
652 if (end - p < 2) return -1;
653 /* Add the number of seconds of completed days of current month */
654 epoch += (10 * (p[0] - '0') + p[1] - '0' - 1) * 24 * 60 * 60;
655 p += 2;
656 if (end - p < 2) return -1;
657 /* Add the completed hours of the current day */
658 epoch += (10 * (p[0] - '0') + p[1] - '0') * 60 * 60;
659 p += 2;
660 if (end - p < 2) return -1;
661 /* Add the completed minutes of the current hour */
662 epoch += (10 * (p[0] - '0') + p[1] - '0') * 60;
663 p += 2;
664 if (p == end) return -1;
665 /* Test if there is available seconds */
666 if (p[0] < '0' || p[0] > '9')
667 goto nosec;
668 if (end - p < 2) return -1;
669 /* Add the seconds of the current minute */
670 epoch += 10 * (p[0] - '0') + p[1] - '0';
671 p += 2;
672 if (p == end) return -1;
673 /* Ignore seconds float part if present */
674 if (p[0] == '.') {
675 do {
676 if (++p == end) return -1;
677 } while (p[0] >= '0' && p[0] <= '9');
678 }
679
680nosec:
681 if (p[0] == 'Z') {
682 if (end - p != 1) return -1;
683 return epoch;
684 }
685 else if (p[0] == '+') {
686 if (end - p != 5) return -1;
687 /* Apply timezone offset */
Frederik Deweerdt953917a2017-10-16 07:37:31 -0700688 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 +0200689 }
690 else if (p[0] == '-') {
691 if (end - p != 5) return -1;
692 /* Apply timezone offset */
Frederik Deweerdt953917a2017-10-16 07:37:31 -0700693 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 +0200694 }
695
696 return -1;
697}
698
William Lallemandc33d83d2019-10-14 14:14:59 +0200699/*
700 * struct alignment works here such that the key.key is the same as key_data
701 * Do not change the placement of key_data
702 */
703struct certificate_ocsp {
704 struct ebmb_node key;
705 unsigned char key_data[OCSP_MAX_CERTID_ASN1_LENGTH];
706 struct buffer response;
707 long expire;
708};
709
710struct ocsp_cbk_arg {
711 int is_single;
712 int single_kt;
713 union {
714 struct certificate_ocsp *s_ocsp;
715 /*
716 * m_ocsp will have multiple entries dependent on key type
717 * Entry 0 - DSA
718 * Entry 1 - ECDSA
719 * Entry 2 - RSA
720 */
721 struct certificate_ocsp *m_ocsp[SSL_SOCK_NUM_KEYTYPES];
722 };
723};
724
Emeric Brun1d3865b2014-06-20 15:37:32 +0200725static struct eb_root cert_ocsp_tree = EB_ROOT_UNIQUE;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200726
727/* This function starts to check if the OCSP response (in DER format) contained
728 * in chunk 'ocsp_response' is valid (else exits on error).
729 * If 'cid' is not NULL, it will be compared to the OCSP certificate ID
730 * contained in the OCSP Response and exits on error if no match.
731 * If it's a valid OCSP Response:
732 * If 'ocsp' is not NULL, the chunk is copied in the OCSP response's container
733 * pointed by 'ocsp'.
734 * If 'ocsp' is NULL, the function looks up into the OCSP response's
735 * containers tree (using as index the ASN1 form of the OCSP Certificate ID extracted
736 * from the response) and exits on error if not found. Finally, If an OCSP response is
737 * already present in the container, it will be overwritten.
738 *
739 * Note: OCSP response containing more than one OCSP Single response is not
740 * considered valid.
741 *
742 * Returns 0 on success, 1 in error case.
743 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200744static int ssl_sock_load_ocsp_response(struct buffer *ocsp_response,
745 struct certificate_ocsp *ocsp,
746 OCSP_CERTID *cid, char **err)
Emeric Brun4147b2e2014-06-16 18:36:30 +0200747{
748 OCSP_RESPONSE *resp;
749 OCSP_BASICRESP *bs = NULL;
750 OCSP_SINGLERESP *sr;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200751 OCSP_CERTID *id;
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200752 unsigned char *p = (unsigned char *) ocsp_response->area;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200753 int rc , count_sr;
Emeric Brun13a6b482014-06-20 15:44:34 +0200754 ASN1_GENERALIZEDTIME *revtime, *thisupd, *nextupd = NULL;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200755 int reason;
756 int ret = 1;
757
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200758 resp = d2i_OCSP_RESPONSE(NULL, (const unsigned char **)&p,
759 ocsp_response->data);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200760 if (!resp) {
761 memprintf(err, "Unable to parse OCSP response");
762 goto out;
763 }
764
765 rc = OCSP_response_status(resp);
766 if (rc != OCSP_RESPONSE_STATUS_SUCCESSFUL) {
767 memprintf(err, "OCSP response status not successful");
768 goto out;
769 }
770
771 bs = OCSP_response_get1_basic(resp);
772 if (!bs) {
773 memprintf(err, "Failed to get basic response from OCSP Response");
774 goto out;
775 }
776
777 count_sr = OCSP_resp_count(bs);
778 if (count_sr > 1) {
779 memprintf(err, "OCSP response ignored because contains multiple single responses (%d)", count_sr);
780 goto out;
781 }
782
783 sr = OCSP_resp_get0(bs, 0);
784 if (!sr) {
785 memprintf(err, "Failed to get OCSP single response");
786 goto out;
787 }
788
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200789 id = (OCSP_CERTID*)OCSP_SINGLERESP_get0_id(sr);
790
Emeric Brun4147b2e2014-06-16 18:36:30 +0200791 rc = OCSP_single_get0_status(sr, &reason, &revtime, &thisupd, &nextupd);
Emmanuel Hocdetef607052017-10-24 14:57:16 +0200792 if (rc != V_OCSP_CERTSTATUS_GOOD && rc != V_OCSP_CERTSTATUS_REVOKED) {
Emmanuel Hocdet872085c2017-10-10 15:18:52 +0200793 memprintf(err, "OCSP single response: certificate status is unknown");
Emeric Brun4147b2e2014-06-16 18:36:30 +0200794 goto out;
795 }
796
Emeric Brun13a6b482014-06-20 15:44:34 +0200797 if (!nextupd) {
798 memprintf(err, "OCSP single response: missing nextupdate");
799 goto out;
800 }
801
Emeric Brunc8b27b62014-06-19 14:16:17 +0200802 rc = OCSP_check_validity(thisupd, nextupd, OCSP_MAX_RESPONSE_TIME_SKEW, -1);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200803 if (!rc) {
804 memprintf(err, "OCSP single response: no longer valid.");
805 goto out;
806 }
807
808 if (cid) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200809 if (OCSP_id_cmp(id, cid)) {
Emeric Brun4147b2e2014-06-16 18:36:30 +0200810 memprintf(err, "OCSP single response: Certificate ID does not match certificate and issuer");
811 goto out;
812 }
813 }
814
815 if (!ocsp) {
816 unsigned char key[OCSP_MAX_CERTID_ASN1_LENGTH];
817 unsigned char *p;
818
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200819 rc = i2d_OCSP_CERTID(id, NULL);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200820 if (!rc) {
821 memprintf(err, "OCSP single response: Unable to encode Certificate ID");
822 goto out;
823 }
824
825 if (rc > OCSP_MAX_CERTID_ASN1_LENGTH) {
826 memprintf(err, "OCSP single response: Certificate ID too long");
827 goto out;
828 }
829
830 p = key;
831 memset(key, 0, OCSP_MAX_CERTID_ASN1_LENGTH);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +0200832 i2d_OCSP_CERTID(id, &p);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200833 ocsp = (struct certificate_ocsp *)ebmb_lookup(&cert_ocsp_tree, key, OCSP_MAX_CERTID_ASN1_LENGTH);
834 if (!ocsp) {
835 memprintf(err, "OCSP single response: Certificate ID does not match any certificate or issuer");
836 goto out;
837 }
838 }
839
840 /* According to comments on "chunk_dup", the
841 previous chunk buffer will be freed */
842 if (!chunk_dup(&ocsp->response, ocsp_response)) {
843 memprintf(err, "OCSP response: Memory allocation error");
844 goto out;
845 }
846
Emeric Brun4f3c87a2014-06-20 15:46:13 +0200847 ocsp->expire = asn1_generalizedtime_to_epoch(nextupd) - OCSP_MAX_RESPONSE_TIME_SKEW;
848
Emeric Brun4147b2e2014-06-16 18:36:30 +0200849 ret = 0;
850out:
Janusz Dziemidowicz8d710492017-03-08 16:59:41 +0100851 ERR_clear_error();
852
Emeric Brun4147b2e2014-06-16 18:36:30 +0200853 if (bs)
854 OCSP_BASICRESP_free(bs);
855
856 if (resp)
857 OCSP_RESPONSE_free(resp);
858
859 return ret;
860}
861/*
862 * External function use to update the OCSP response in the OCSP response's
863 * containers tree. The chunk 'ocsp_response' must contain the OCSP response
864 * to update in DER format.
865 *
866 * Returns 0 on success, 1 in error case.
867 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200868int ssl_sock_update_ocsp_response(struct buffer *ocsp_response, char **err)
Emeric Brun4147b2e2014-06-16 18:36:30 +0200869{
870 return ssl_sock_load_ocsp_response(ocsp_response, NULL, NULL, err);
871}
872
873/*
874 * This function load the OCSP Resonse in DER format contained in file at
875 * path 'ocsp_path' and call 'ssl_sock_load_ocsp_response'
876 *
877 * Returns 0 on success, 1 in error case.
878 */
879static int ssl_sock_load_ocsp_response_from_file(const char *ocsp_path, struct certificate_ocsp *ocsp, OCSP_CERTID *cid, char **err)
880{
881 int fd = -1;
882 int r = 0;
883 int ret = 1;
884
885 fd = open(ocsp_path, O_RDONLY);
886 if (fd == -1) {
887 memprintf(err, "Error opening OCSP response file");
888 goto end;
889 }
890
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200891 trash.data = 0;
892 while (trash.data < trash.size) {
893 r = read(fd, trash.area + trash.data, trash.size - trash.data);
Emeric Brun4147b2e2014-06-16 18:36:30 +0200894 if (r < 0) {
895 if (errno == EINTR)
896 continue;
897
898 memprintf(err, "Error reading OCSP response from file");
899 goto end;
900 }
901 else if (r == 0) {
902 break;
903 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200904 trash.data += r;
Emeric Brun4147b2e2014-06-16 18:36:30 +0200905 }
906
907 close(fd);
908 fd = -1;
909
910 ret = ssl_sock_load_ocsp_response(&trash, ocsp, cid, err);
911end:
912 if (fd != -1)
913 close(fd);
914
915 return ret;
916}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +0100917#endif
Emeric Brun4147b2e2014-06-16 18:36:30 +0200918
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100919#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
920static 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)
921{
Christopher Faulet16f45c82018-02-16 11:23:49 +0100922 struct tls_keys_ref *ref;
Emeric Brun9e754772019-01-10 17:51:55 +0100923 union tls_sess_key *keys;
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100924 struct connection *conn;
925 int head;
926 int i;
Christopher Faulet16f45c82018-02-16 11:23:49 +0100927 int ret = -1; /* error by default */
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100928
Thierry FOURNIER28962c92018-06-17 21:37:05 +0200929 conn = SSL_get_ex_data(s, ssl_app_data_index);
Willy Tarreau07d94e42018-09-20 10:57:52 +0200930 ref = __objt_listener(conn->target)->bind_conf->keys_ref;
Christopher Faulet16f45c82018-02-16 11:23:49 +0100931 HA_RWLOCK_RDLOCK(TLSKEYS_REF_LOCK, &ref->lock);
932
933 keys = ref->tlskeys;
934 head = ref->tls_ticket_enc_index;
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100935
936 if (enc) {
937 memcpy(key_name, keys[head].name, 16);
938
939 if(!RAND_pseudo_bytes(iv, EVP_MAX_IV_LENGTH))
Christopher Faulet16f45c82018-02-16 11:23:49 +0100940 goto end;
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100941
Emeric Brun9e754772019-01-10 17:51:55 +0100942 if (ref->key_size_bits == 128) {
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100943
Emeric Brun9e754772019-01-10 17:51:55 +0100944 if(!EVP_EncryptInit_ex(ectx, EVP_aes_128_cbc(), NULL, keys[head].key_128.aes_key, iv))
945 goto end;
946
Willy Tarreau9356dac2019-05-10 09:22:53 +0200947 HMAC_Init_ex(hctx, keys[head].key_128.hmac_key, 16, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +0100948 ret = 1;
949 }
950 else if (ref->key_size_bits == 256 ) {
951
952 if(!EVP_EncryptInit_ex(ectx, EVP_aes_256_cbc(), NULL, keys[head].key_256.aes_key, iv))
953 goto end;
954
Willy Tarreau9356dac2019-05-10 09:22:53 +0200955 HMAC_Init_ex(hctx, keys[head].key_256.hmac_key, 32, TLS_TICKET_HASH_FUNCT(), NULL);
Emeric Brun9e754772019-01-10 17:51:55 +0100956 ret = 1;
957 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100958 } else {
959 for (i = 0; i < TLS_TICKETS_NO; i++) {
960 if (!memcmp(key_name, keys[(head + i) % TLS_TICKETS_NO].name, 16))
961 goto found;
962 }
Christopher Faulet16f45c82018-02-16 11:23:49 +0100963 ret = 0;
964 goto end;
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100965
Christopher Faulet16f45c82018-02-16 11:23:49 +0100966 found:
Emeric Brun9e754772019-01-10 17:51:55 +0100967 if (ref->key_size_bits == 128) {
Willy Tarreau9356dac2019-05-10 09:22:53 +0200968 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 +0100969 if(!EVP_DecryptInit_ex(ectx, EVP_aes_128_cbc(), NULL, keys[(head + i) % TLS_TICKETS_NO].key_128.aes_key, iv))
970 goto end;
971 /* 2 for key renewal, 1 if current key is still valid */
972 ret = i ? 2 : 1;
973 }
974 else if (ref->key_size_bits == 256) {
Willy Tarreau9356dac2019-05-10 09:22:53 +0200975 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 +0100976 if(!EVP_DecryptInit_ex(ectx, EVP_aes_256_cbc(), NULL, keys[(head + i) % TLS_TICKETS_NO].key_256.aes_key, iv))
977 goto end;
978 /* 2 for key renewal, 1 if current key is still valid */
979 ret = i ? 2 : 1;
980 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +0100981 }
Emeric Brun9e754772019-01-10 17:51:55 +0100982
Christopher Faulet16f45c82018-02-16 11:23:49 +0100983 end:
984 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
985 return ret;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +0200986}
987
988struct tls_keys_ref *tlskeys_ref_lookup(const char *filename)
989{
990 struct tls_keys_ref *ref;
991
992 list_for_each_entry(ref, &tlskeys_reference, list)
993 if (ref->filename && strcmp(filename, ref->filename) == 0)
994 return ref;
995 return NULL;
996}
997
998struct tls_keys_ref *tlskeys_ref_lookupid(int unique_id)
999{
1000 struct tls_keys_ref *ref;
1001
1002 list_for_each_entry(ref, &tlskeys_reference, list)
1003 if (ref->unique_id == unique_id)
1004 return ref;
1005 return NULL;
1006}
1007
Emeric Brun9e754772019-01-10 17:51:55 +01001008/* Update the key into ref: if keysize doesnt
1009 * match existing ones, this function returns -1
1010 * else it returns 0 on success.
1011 */
1012int ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref,
Willy Tarreau83061a82018-07-13 11:56:34 +02001013 struct buffer *tlskey)
Christopher Faulet16f45c82018-02-16 11:23:49 +01001014{
Emeric Brun9e754772019-01-10 17:51:55 +01001015 if (ref->key_size_bits == 128) {
1016 if (tlskey->data != sizeof(struct tls_sess_key_128))
1017 return -1;
1018 }
1019 else if (ref->key_size_bits == 256) {
1020 if (tlskey->data != sizeof(struct tls_sess_key_256))
1021 return -1;
1022 }
1023 else
1024 return -1;
1025
Christopher Faulet16f45c82018-02-16 11:23:49 +01001026 HA_RWLOCK_WRLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001027 memcpy((char *) (ref->tlskeys + ((ref->tls_ticket_enc_index + 2) % TLS_TICKETS_NO)),
1028 tlskey->area, tlskey->data);
Christopher Faulet16f45c82018-02-16 11:23:49 +01001029 ref->tls_ticket_enc_index = (ref->tls_ticket_enc_index + 1) % TLS_TICKETS_NO;
1030 HA_RWLOCK_WRUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Emeric Brun9e754772019-01-10 17:51:55 +01001031
1032 return 0;
Christopher Faulet16f45c82018-02-16 11:23:49 +01001033}
1034
Willy Tarreau83061a82018-07-13 11:56:34 +02001035int ssl_sock_update_tlskey(char *filename, struct buffer *tlskey, char **err)
Christopher Faulet16f45c82018-02-16 11:23:49 +01001036{
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001037 struct tls_keys_ref *ref = tlskeys_ref_lookup(filename);
1038
1039 if(!ref) {
1040 memprintf(err, "Unable to locate the referenced filename: %s", filename);
1041 return 1;
1042 }
Emeric Brun9e754772019-01-10 17:51:55 +01001043 if (ssl_sock_update_tlskey_ref(ref, tlskey) < 0) {
1044 memprintf(err, "Invalid key size");
1045 return 1;
1046 }
1047
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001048 return 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001049}
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001050
1051/* This function finalize the configuration parsing. Its set all the
Willy Tarreaud1c57502016-12-22 22:46:15 +01001052 * automatic ids. It's called just after the basic checks. It returns
1053 * 0 on success otherwise ERR_*.
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001054 */
Willy Tarreaud1c57502016-12-22 22:46:15 +01001055static int tlskeys_finalize_config(void)
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001056{
1057 int i = 0;
1058 struct tls_keys_ref *ref, *ref2, *ref3;
1059 struct list tkr = LIST_HEAD_INIT(tkr);
1060
1061 list_for_each_entry(ref, &tlskeys_reference, list) {
1062 if (ref->unique_id == -1) {
1063 /* Look for the first free id. */
1064 while (1) {
1065 list_for_each_entry(ref2, &tlskeys_reference, list) {
1066 if (ref2->unique_id == i) {
1067 i++;
1068 break;
1069 }
1070 }
1071 if (&ref2->list == &tlskeys_reference)
1072 break;
1073 }
1074
1075 /* Uses the unique id and increment it for the next entry. */
1076 ref->unique_id = i;
1077 i++;
1078 }
1079 }
1080
1081 /* This sort the reference list by id. */
1082 list_for_each_entry_safe(ref, ref2, &tlskeys_reference, list) {
1083 LIST_DEL(&ref->list);
1084 list_for_each_entry(ref3, &tkr, list) {
1085 if (ref->unique_id < ref3->unique_id) {
1086 LIST_ADDQ(&ref3->list, &ref->list);
1087 break;
1088 }
1089 }
1090 if (&ref3->list == &tkr)
1091 LIST_ADDQ(&tkr, &ref->list);
1092 }
1093
1094 /* swap root */
1095 LIST_ADD(&tkr, &tlskeys_reference);
1096 LIST_DEL(&tkr);
Willy Tarreaud1c57502016-12-22 22:46:15 +01001097 return 0;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02001098}
Nenad Merdanovic05552d42015-02-27 19:56:49 +01001099#endif /* SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB */
1100
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01001101#ifndef OPENSSL_NO_OCSP
yanbzhube2774d2015-12-10 15:07:30 -05001102int ssl_sock_get_ocsp_arg_kt_index(int evp_keytype)
1103{
1104 switch (evp_keytype) {
1105 case EVP_PKEY_RSA:
1106 return 2;
1107 case EVP_PKEY_DSA:
1108 return 0;
1109 case EVP_PKEY_EC:
1110 return 1;
1111 }
1112
1113 return -1;
1114}
1115
Emeric Brun4147b2e2014-06-16 18:36:30 +02001116/*
1117 * Callback used to set OCSP status extension content in server hello.
1118 */
1119int ssl_sock_ocsp_stapling_cbk(SSL *ssl, void *arg)
1120{
yanbzhube2774d2015-12-10 15:07:30 -05001121 struct certificate_ocsp *ocsp;
1122 struct ocsp_cbk_arg *ocsp_arg;
1123 char *ssl_buf;
1124 EVP_PKEY *ssl_pkey;
1125 int key_type;
1126 int index;
1127
Vincent Bernat3c2f2f22016-04-03 13:48:42 +02001128 ocsp_arg = arg;
yanbzhube2774d2015-12-10 15:07:30 -05001129
1130 ssl_pkey = SSL_get_privatekey(ssl);
1131 if (!ssl_pkey)
1132 return SSL_TLSEXT_ERR_NOACK;
1133
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001134 key_type = EVP_PKEY_base_id(ssl_pkey);
yanbzhube2774d2015-12-10 15:07:30 -05001135
1136 if (ocsp_arg->is_single && ocsp_arg->single_kt == key_type)
1137 ocsp = ocsp_arg->s_ocsp;
1138 else {
1139 /* For multiple certs per context, we have to find the correct OCSP response based on
1140 * the certificate type
1141 */
1142 index = ssl_sock_get_ocsp_arg_kt_index(key_type);
1143
1144 if (index < 0)
1145 return SSL_TLSEXT_ERR_NOACK;
1146
1147 ocsp = ocsp_arg->m_ocsp[index];
1148
1149 }
Emeric Brun4147b2e2014-06-16 18:36:30 +02001150
1151 if (!ocsp ||
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001152 !ocsp->response.area ||
1153 !ocsp->response.data ||
Emeric Brun4f3c87a2014-06-20 15:46:13 +02001154 (ocsp->expire < now.tv_sec))
Emeric Brun4147b2e2014-06-16 18:36:30 +02001155 return SSL_TLSEXT_ERR_NOACK;
1156
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001157 ssl_buf = OPENSSL_malloc(ocsp->response.data);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001158 if (!ssl_buf)
1159 return SSL_TLSEXT_ERR_NOACK;
1160
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001161 memcpy(ssl_buf, ocsp->response.area, ocsp->response.data);
1162 SSL_set_tlsext_status_ocsp_resp(ssl, ssl_buf, ocsp->response.data);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001163
1164 return SSL_TLSEXT_ERR_OK;
1165}
1166
1167/*
1168 * This function enables the handling of OCSP status extension on 'ctx' if a
1169 * file name 'cert_path' suffixed using ".ocsp" is present.
1170 * To enable OCSP status extension, the issuer's certificate is mandatory.
1171 * It should be present in the certificate's extra chain builded from file
1172 * 'cert_path'. If not found, the issuer certificate is loaded from a file
1173 * named 'cert_path' suffixed using '.issuer'.
1174 *
1175 * In addition, ".ocsp" file content is loaded as a DER format of an OCSP
1176 * response. If file is empty or content is not a valid OCSP response,
1177 * OCSP status extension is enabled but OCSP response is ignored (a warning
1178 * is displayed).
1179 *
1180 * Returns 1 if no ".ocsp" file found, 0 if OCSP status extension is
Joseph Herlant017b3da2018-11-15 09:07:59 -08001181 * successfully enabled, or -1 in other error case.
Emeric Brun4147b2e2014-06-16 18:36:30 +02001182 */
1183static int ssl_sock_load_ocsp(SSL_CTX *ctx, const char *cert_path)
1184{
1185
1186 BIO *in = NULL;
1187 X509 *x, *xi = NULL, *issuer = NULL;
1188 STACK_OF(X509) *chain = NULL;
1189 OCSP_CERTID *cid = NULL;
1190 SSL *ssl;
1191 char ocsp_path[MAXPATHLEN+1];
1192 int i, ret = -1;
1193 struct stat st;
1194 struct certificate_ocsp *ocsp = NULL, *iocsp;
1195 char *warn = NULL;
1196 unsigned char *p;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001197 pem_password_cb *passwd_cb;
1198 void *passwd_cb_userdata;
1199 void (*callback) (void);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001200
1201 snprintf(ocsp_path, MAXPATHLEN+1, "%s.ocsp", cert_path);
1202
1203 if (stat(ocsp_path, &st))
1204 return 1;
1205
1206 ssl = SSL_new(ctx);
1207 if (!ssl)
1208 goto out;
1209
1210 x = SSL_get_certificate(ssl);
1211 if (!x)
1212 goto out;
1213
1214 /* Try to lookup for issuer in certificate extra chain */
Emeric Brun4147b2e2014-06-16 18:36:30 +02001215 SSL_CTX_get_extra_chain_certs(ctx, &chain);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001216 for (i = 0; i < sk_X509_num(chain); i++) {
1217 issuer = sk_X509_value(chain, i);
1218 if (X509_check_issued(issuer, x) == X509_V_OK)
1219 break;
1220 else
1221 issuer = NULL;
1222 }
1223
1224 /* If not found try to load issuer from a suffixed file */
1225 if (!issuer) {
1226 char issuer_path[MAXPATHLEN+1];
1227
1228 in = BIO_new(BIO_s_file());
1229 if (!in)
1230 goto out;
1231
1232 snprintf(issuer_path, MAXPATHLEN+1, "%s.issuer", cert_path);
1233 if (BIO_read_filename(in, issuer_path) <= 0)
1234 goto out;
1235
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001236 passwd_cb = SSL_CTX_get_default_passwd_cb(ctx);
1237 passwd_cb_userdata = SSL_CTX_get_default_passwd_cb_userdata(ctx);
1238
1239 xi = PEM_read_bio_X509_AUX(in, NULL, passwd_cb, passwd_cb_userdata);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001240 if (!xi)
1241 goto out;
1242
1243 if (X509_check_issued(xi, x) != X509_V_OK)
1244 goto out;
1245
1246 issuer = xi;
1247 }
1248
1249 cid = OCSP_cert_to_id(0, x, issuer);
1250 if (!cid)
1251 goto out;
1252
1253 i = i2d_OCSP_CERTID(cid, NULL);
1254 if (!i || (i > OCSP_MAX_CERTID_ASN1_LENGTH))
1255 goto out;
1256
Vincent Bernat02779b62016-04-03 13:48:43 +02001257 ocsp = calloc(1, sizeof(*ocsp));
Emeric Brun4147b2e2014-06-16 18:36:30 +02001258 if (!ocsp)
1259 goto out;
1260
1261 p = ocsp->key_data;
1262 i2d_OCSP_CERTID(cid, &p);
1263
1264 iocsp = (struct certificate_ocsp *)ebmb_insert(&cert_ocsp_tree, &ocsp->key, OCSP_MAX_CERTID_ASN1_LENGTH);
1265 if (iocsp == ocsp)
1266 ocsp = NULL;
1267
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001268#ifndef SSL_CTX_get_tlsext_status_cb
1269# define SSL_CTX_get_tlsext_status_cb(ctx, cb) \
1270 *cb = (void (*) (void))ctx->tlsext_status_cb;
1271#endif
1272 SSL_CTX_get_tlsext_status_cb(ctx, &callback);
1273
1274 if (!callback) {
Vincent Bernat02779b62016-04-03 13:48:43 +02001275 struct ocsp_cbk_arg *cb_arg = calloc(1, sizeof(*cb_arg));
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001276 EVP_PKEY *pkey;
yanbzhube2774d2015-12-10 15:07:30 -05001277
1278 cb_arg->is_single = 1;
1279 cb_arg->s_ocsp = iocsp;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001280
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001281 pkey = X509_get_pubkey(x);
1282 cb_arg->single_kt = EVP_PKEY_base_id(pkey);
1283 EVP_PKEY_free(pkey);
yanbzhube2774d2015-12-10 15:07:30 -05001284
1285 SSL_CTX_set_tlsext_status_cb(ctx, ssl_sock_ocsp_stapling_cbk);
1286 SSL_CTX_set_tlsext_status_arg(ctx, cb_arg);
1287 } else {
1288 /*
1289 * If the ctx has a status CB, then we have previously set an OCSP staple for this ctx
1290 * Update that cb_arg with the new cert's staple
1291 */
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001292 struct ocsp_cbk_arg *cb_arg;
yanbzhube2774d2015-12-10 15:07:30 -05001293 struct certificate_ocsp *tmp_ocsp;
1294 int index;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001295 int key_type;
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001296 EVP_PKEY *pkey;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001297
1298#ifdef SSL_CTX_get_tlsext_status_arg
1299 SSL_CTX_ctrl(ctx, SSL_CTRL_GET_TLSEXT_STATUS_REQ_CB_ARG, 0, &cb_arg);
1300#else
1301 cb_arg = ctx->tlsext_status_arg;
1302#endif
yanbzhube2774d2015-12-10 15:07:30 -05001303
1304 /*
1305 * The following few lines will convert cb_arg from a single ocsp to multi ocsp
1306 * the order of operations below matter, take care when changing it
1307 */
1308 tmp_ocsp = cb_arg->s_ocsp;
1309 index = ssl_sock_get_ocsp_arg_kt_index(cb_arg->single_kt);
1310 cb_arg->s_ocsp = NULL;
1311 cb_arg->m_ocsp[index] = tmp_ocsp;
1312 cb_arg->is_single = 0;
1313 cb_arg->single_kt = 0;
1314
Emmanuel Hocdetb7a4c342017-01-06 12:57:46 +01001315 pkey = X509_get_pubkey(x);
1316 key_type = EVP_PKEY_base_id(pkey);
1317 EVP_PKEY_free(pkey);
1318
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001319 index = ssl_sock_get_ocsp_arg_kt_index(key_type);
yanbzhube2774d2015-12-10 15:07:30 -05001320 if (index >= 0 && !cb_arg->m_ocsp[index])
1321 cb_arg->m_ocsp[index] = iocsp;
1322
1323 }
Emeric Brun4147b2e2014-06-16 18:36:30 +02001324
1325 ret = 0;
1326
1327 warn = NULL;
1328 if (ssl_sock_load_ocsp_response_from_file(ocsp_path, iocsp, cid, &warn)) {
1329 memprintf(&warn, "Loading '%s': %s. Content will be ignored", ocsp_path, warn ? warn : "failure");
Christopher Faulet767a84b2017-11-24 16:50:31 +01001330 ha_warning("%s.\n", warn);
Emeric Brun4147b2e2014-06-16 18:36:30 +02001331 }
1332
1333out:
1334 if (ssl)
1335 SSL_free(ssl);
1336
1337 if (in)
1338 BIO_free(in);
1339
1340 if (xi)
1341 X509_free(xi);
1342
1343 if (cid)
1344 OCSP_CERTID_free(cid);
1345
1346 if (ocsp)
1347 free(ocsp);
1348
1349 if (warn)
1350 free(warn);
1351
1352
1353 return ret;
1354}
1355
1356#endif
1357
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001358#ifdef OPENSSL_IS_BORINGSSL
1359static int ssl_sock_set_ocsp_response_from_file(SSL_CTX *ctx, const char *cert_path)
1360{
1361 char ocsp_path[MAXPATHLEN+1];
1362 struct stat st;
1363 int fd = -1, r = 0;
1364
1365 snprintf(ocsp_path, MAXPATHLEN+1, "%s.ocsp", cert_path);
1366 if (stat(ocsp_path, &st))
1367 return 0;
1368
1369 fd = open(ocsp_path, O_RDONLY);
1370 if (fd == -1) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01001371 ha_warning("Error opening OCSP response file %s.\n", ocsp_path);
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001372 return -1;
1373 }
1374
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001375 trash.data = 0;
1376 while (trash.data < trash.size) {
1377 r = read(fd, trash.area + trash.data, trash.size - trash.data);
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001378 if (r < 0) {
1379 if (errno == EINTR)
1380 continue;
Christopher Faulet767a84b2017-11-24 16:50:31 +01001381 ha_warning("Error reading OCSP response from file %s.\n", ocsp_path);
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001382 close(fd);
1383 return -1;
1384 }
1385 else if (r == 0) {
1386 break;
1387 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001388 trash.data += r;
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001389 }
1390 close(fd);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001391 return SSL_CTX_set_ocsp_response(ctx, (const uint8_t *) trash.area,
1392 trash.data);
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02001393}
1394#endif
1395
Willy Tarreau5db847a2019-05-09 14:13:35 +02001396#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001397
1398#define CT_EXTENSION_TYPE 18
1399
1400static int sctl_ex_index = -1;
1401
1402/*
1403 * Try to parse Signed Certificate Timestamp List structure. This function
1404 * makes only basic test if the data seems like SCTL. No signature validation
1405 * is performed.
1406 */
Willy Tarreau83061a82018-07-13 11:56:34 +02001407static int ssl_sock_parse_sctl(struct buffer *sctl)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001408{
1409 int ret = 1;
1410 int len, pos, sct_len;
1411 unsigned char *data;
1412
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001413 if (sctl->data < 2)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001414 goto out;
1415
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001416 data = (unsigned char *) sctl->area;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001417 len = (data[0] << 8) | data[1];
1418
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001419 if (len + 2 != sctl->data)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001420 goto out;
1421
1422 data = data + 2;
1423 pos = 0;
1424 while (pos < len) {
1425 if (len - pos < 2)
1426 goto out;
1427
1428 sct_len = (data[pos] << 8) | data[pos + 1];
1429 if (pos + sct_len + 2 > len)
1430 goto out;
1431
1432 pos += sct_len + 2;
1433 }
1434
1435 ret = 0;
1436
1437out:
1438 return ret;
1439}
1440
Willy Tarreau83061a82018-07-13 11:56:34 +02001441static int ssl_sock_load_sctl_from_file(const char *sctl_path,
1442 struct buffer **sctl)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001443{
1444 int fd = -1;
1445 int r = 0;
1446 int ret = 1;
1447
1448 *sctl = NULL;
1449
1450 fd = open(sctl_path, O_RDONLY);
1451 if (fd == -1)
1452 goto end;
1453
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001454 trash.data = 0;
1455 while (trash.data < trash.size) {
1456 r = read(fd, trash.area + trash.data, trash.size - trash.data);
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001457 if (r < 0) {
1458 if (errno == EINTR)
1459 continue;
1460
1461 goto end;
1462 }
1463 else if (r == 0) {
1464 break;
1465 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001466 trash.data += r;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001467 }
1468
1469 ret = ssl_sock_parse_sctl(&trash);
1470 if (ret)
1471 goto end;
1472
Vincent Bernat02779b62016-04-03 13:48:43 +02001473 *sctl = calloc(1, sizeof(**sctl));
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001474 if (!chunk_dup(*sctl, &trash)) {
1475 free(*sctl);
1476 *sctl = NULL;
1477 goto end;
1478 }
1479
1480end:
1481 if (fd != -1)
1482 close(fd);
1483
1484 return ret;
1485}
1486
1487int ssl_sock_sctl_add_cbk(SSL *ssl, unsigned ext_type, const unsigned char **out, size_t *outlen, int *al, void *add_arg)
1488{
Willy Tarreau83061a82018-07-13 11:56:34 +02001489 struct buffer *sctl = add_arg;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001490
Willy Tarreau843b7cb2018-07-13 10:54:26 +02001491 *out = (unsigned char *) sctl->area;
1492 *outlen = sctl->data;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001493
1494 return 1;
1495}
1496
1497int ssl_sock_sctl_parse_cbk(SSL *s, unsigned int ext_type, const unsigned char *in, size_t inlen, int *al, void *parse_arg)
1498{
1499 return 1;
1500}
1501
1502static int ssl_sock_load_sctl(SSL_CTX *ctx, const char *cert_path)
1503{
1504 char sctl_path[MAXPATHLEN+1];
1505 int ret = -1;
1506 struct stat st;
Willy Tarreau83061a82018-07-13 11:56:34 +02001507 struct buffer *sctl = NULL;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01001508
1509 snprintf(sctl_path, MAXPATHLEN+1, "%s.sctl", cert_path);
1510
1511 if (stat(sctl_path, &st))
1512 return 1;
1513
1514 if (ssl_sock_load_sctl_from_file(sctl_path, &sctl))
1515 goto out;
1516
1517 if (!SSL_CTX_add_server_custom_ext(ctx, CT_EXTENSION_TYPE, ssl_sock_sctl_add_cbk, NULL, sctl, ssl_sock_sctl_parse_cbk, NULL)) {
1518 free(sctl);
1519 goto out;
1520 }
1521
1522 SSL_CTX_set_ex_data(ctx, sctl_ex_index, sctl);
1523
1524 ret = 0;
1525
1526out:
1527 return ret;
1528}
1529
1530#endif
1531
Emeric Brune1f38db2012-09-03 20:36:47 +02001532void ssl_sock_infocbk(const SSL *ssl, int where, int ret)
1533{
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001534 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001535 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Emeric Brund8b2bb52014-01-28 15:43:53 +01001536 BIO *write_bio;
Willy Tarreau622317d2015-02-27 16:36:16 +01001537 (void)ret; /* shut gcc stupid warning */
Emeric Brune1f38db2012-09-03 20:36:47 +02001538
Dirkjan Bussink526894f2019-01-21 09:35:03 -08001539#ifndef SSL_OP_NO_RENEGOTIATION
1540 /* Please note that BoringSSL defines this macro to zero so don't
1541 * change this to #if and do not assign a default value to this macro!
1542 */
Emeric Brune1f38db2012-09-03 20:36:47 +02001543 if (where & SSL_CB_HANDSHAKE_START) {
1544 /* Disable renegotiation (CVE-2009-3555) */
Olivier Houchard90084a12017-11-23 18:21:29 +01001545 if ((conn->flags & (CO_FL_CONNECTED | CO_FL_EARLY_SSL_HS | CO_FL_EARLY_DATA)) == CO_FL_CONNECTED) {
Emeric Brune1f38db2012-09-03 20:36:47 +02001546 conn->flags |= CO_FL_ERROR;
Willy Tarreau20879a02012-12-03 16:32:10 +01001547 conn->err_code = CO_ER_SSL_RENEG;
1548 }
Emeric Brune1f38db2012-09-03 20:36:47 +02001549 }
Dirkjan Bussink526894f2019-01-21 09:35:03 -08001550#endif
Emeric Brund8b2bb52014-01-28 15:43:53 +01001551
1552 if ((where & SSL_CB_ACCEPT_LOOP) == SSL_CB_ACCEPT_LOOP) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001553 if (!(ctx->xprt_st & SSL_SOCK_ST_FL_16K_WBFSIZE)) {
Emeric Brund8b2bb52014-01-28 15:43:53 +01001554 /* Long certificate chains optimz
1555 If write and read bios are differents, we
1556 consider that the buffering was activated,
1557 so we rise the output buffer size from 4k
1558 to 16k */
1559 write_bio = SSL_get_wbio(ssl);
1560 if (write_bio != SSL_get_rbio(ssl)) {
1561 BIO_set_write_buffer_size(write_bio, 16384);
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001562 ctx->xprt_st |= SSL_SOCK_ST_FL_16K_WBFSIZE;
Emeric Brund8b2bb52014-01-28 15:43:53 +01001563 }
1564 }
1565 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02001566}
1567
Emeric Brune64aef12012-09-21 13:15:06 +02001568/* Callback is called for each certificate of the chain during a verify
1569 ok is set to 1 if preverify detect no error on current certificate.
1570 Returns 0 to break the handshake, 1 otherwise. */
Evan Broderbe554312013-06-27 00:05:25 -07001571int ssl_sock_bind_verifycbk(int ok, X509_STORE_CTX *x_store)
Emeric Brune64aef12012-09-21 13:15:06 +02001572{
1573 SSL *ssl;
1574 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001575 struct ssl_sock_ctx *ctx;
Emeric Brun81c00f02012-09-21 14:31:21 +02001576 int err, depth;
Emeric Brune64aef12012-09-21 13:15:06 +02001577
1578 ssl = X509_STORE_CTX_get_ex_data(x_store, SSL_get_ex_data_X509_STORE_CTX_idx());
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001579 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Emeric Brune64aef12012-09-21 13:15:06 +02001580
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001581 ctx = conn->xprt_ctx;
1582
1583 ctx->xprt_st |= SSL_SOCK_ST_FL_VERIFY_DONE;
Emeric Brune64aef12012-09-21 13:15:06 +02001584
Emeric Brun81c00f02012-09-21 14:31:21 +02001585 if (ok) /* no errors */
1586 return ok;
1587
1588 depth = X509_STORE_CTX_get_error_depth(x_store);
1589 err = X509_STORE_CTX_get_error(x_store);
1590
1591 /* check if CA error needs to be ignored */
1592 if (depth > 0) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001593 if (!SSL_SOCK_ST_TO_CA_ERROR(ctx->xprt_st)) {
1594 ctx->xprt_st |= SSL_SOCK_CA_ERROR_TO_ST(err);
1595 ctx->xprt_st |= SSL_SOCK_CAEDEPTH_TO_ST(depth);
Emeric Brunf282a812012-09-21 15:27:54 +02001596 }
1597
Willy Tarreaua9d299f2020-02-04 14:02:02 +01001598 if (err < 64 && __objt_listener(conn->target)->bind_conf->ca_ignerr & (1ULL << err)) {
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02001599 ssl_sock_dump_errors(conn);
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001600 ERR_clear_error();
Emeric Brun81c00f02012-09-21 14:31:21 +02001601 return 1;
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001602 }
Emeric Brun81c00f02012-09-21 14:31:21 +02001603
Willy Tarreau20879a02012-12-03 16:32:10 +01001604 conn->err_code = CO_ER_SSL_CA_FAIL;
Emeric Brun81c00f02012-09-21 14:31:21 +02001605 return 0;
1606 }
1607
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001608 if (!SSL_SOCK_ST_TO_CRTERROR(ctx->xprt_st))
1609 ctx->xprt_st |= SSL_SOCK_CRTERROR_TO_ST(err);
Emeric Brunf282a812012-09-21 15:27:54 +02001610
Emeric Brun81c00f02012-09-21 14:31:21 +02001611 /* check if certificate error needs to be ignored */
Willy Tarreaua9d299f2020-02-04 14:02:02 +01001612 if (err < 64 && __objt_listener(conn->target)->bind_conf->crt_ignerr & (1ULL << err)) {
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02001613 ssl_sock_dump_errors(conn);
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001614 ERR_clear_error();
Emeric Brun81c00f02012-09-21 14:31:21 +02001615 return 1;
Emeric Brun1eb20ef2012-12-03 13:24:29 +01001616 }
Emeric Brun81c00f02012-09-21 14:31:21 +02001617
Willy Tarreau20879a02012-12-03 16:32:10 +01001618 conn->err_code = CO_ER_SSL_CRT_FAIL;
Emeric Brun81c00f02012-09-21 14:31:21 +02001619 return 0;
Emeric Brune64aef12012-09-21 13:15:06 +02001620}
1621
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001622static inline
1623void ssl_sock_parse_clienthello(int write_p, int version, int content_type,
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001624 const void *buf, size_t len, SSL *ssl)
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001625{
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001626 struct ssl_capture *capture;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001627 unsigned char *msg;
1628 unsigned char *end;
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001629 size_t rec_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001630
1631 /* This function is called for "from client" and "to server"
1632 * connections. The combination of write_p == 0 and content_type == 22
Joseph Herlant017b3da2018-11-15 09:07:59 -08001633 * is only available during "from client" connection.
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001634 */
1635
1636 /* "write_p" is set to 0 is the bytes are received messages,
1637 * otherwise it is set to 1.
1638 */
1639 if (write_p != 0)
1640 return;
1641
1642 /* content_type contains the type of message received or sent
1643 * according with the SSL/TLS protocol spec. This message is
1644 * encoded with one byte. The value 256 (two bytes) is used
1645 * for designing the SSL/TLS record layer. According with the
1646 * rfc6101, the expected message (other than 256) are:
1647 * - change_cipher_spec(20)
1648 * - alert(21)
1649 * - handshake(22)
1650 * - application_data(23)
1651 * - (255)
1652 * We are interessed by the handshake and specially the client
1653 * hello.
1654 */
1655 if (content_type != 22)
1656 return;
1657
1658 /* The message length is at least 4 bytes, containing the
1659 * message type and the message length.
1660 */
1661 if (len < 4)
1662 return;
1663
1664 /* First byte of the handshake message id the type of
1665 * message. The konwn types are:
1666 * - hello_request(0)
1667 * - client_hello(1)
1668 * - server_hello(2)
1669 * - certificate(11)
1670 * - server_key_exchange (12)
1671 * - certificate_request(13)
1672 * - server_hello_done(14)
1673 * We are interested by the client hello.
1674 */
1675 msg = (unsigned char *)buf;
1676 if (msg[0] != 1)
1677 return;
1678
1679 /* Next three bytes are the length of the message. The total length
1680 * must be this decoded length + 4. If the length given as argument
1681 * is not the same, we abort the protocol dissector.
1682 */
1683 rec_len = (msg[1] << 16) + (msg[2] << 8) + msg[3];
1684 if (len < rec_len + 4)
1685 return;
1686 msg += 4;
1687 end = msg + rec_len;
1688 if (end < msg)
1689 return;
1690
1691 /* Expect 2 bytes for protocol version (1 byte for major and 1 byte
1692 * for minor, the random, composed by 4 bytes for the unix time and
Baptiste Assmann6be139f2018-11-28 15:20:25 +01001693 * 28 bytes for unix payload. So we jump 1 + 1 + 4 + 28.
1694 */
1695 msg += 1 + 1 + 4 + 28;
1696 if (msg > end)
1697 return;
1698
1699 /* Next, is session id:
1700 * if present, we have to jump by length + 1 for the size information
1701 * if not present, we have to jump by 1 only
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001702 */
Baptiste Assmann6be139f2018-11-28 15:20:25 +01001703 if (msg[0] > 0)
1704 msg += msg[0];
1705 msg += 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001706 if (msg > end)
1707 return;
1708
1709 /* Next two bytes are the ciphersuite length. */
1710 if (msg + 2 > end)
1711 return;
1712 rec_len = (msg[0] << 8) + msg[1];
1713 msg += 2;
1714 if (msg + rec_len > end || msg + rec_len < msg)
1715 return;
1716
Willy Tarreaubafbe012017-11-24 17:34:44 +01001717 capture = pool_alloc_dirty(pool_head_ssl_capture);
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001718 if (!capture)
1719 return;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001720 /* Compute the xxh64 of the ciphersuite. */
1721 capture->xxh64 = XXH64(msg, rec_len, 0);
1722
1723 /* Capture the ciphersuite. */
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001724 capture->ciphersuite_len = (global_ssl.capture_cipherlist < rec_len) ?
1725 global_ssl.capture_cipherlist : rec_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001726 memcpy(capture->ciphersuite, msg, capture->ciphersuite_len);
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001727
1728 SSL_set_ex_data(ssl, ssl_capture_ptr_index, capture);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01001729}
1730
Emeric Brun29f037d2014-04-25 19:05:36 +02001731/* Callback is called for ssl protocol analyse */
1732void ssl_sock_msgcbk(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg)
1733{
Emeric Brun29f037d2014-04-25 19:05:36 +02001734#ifdef TLS1_RT_HEARTBEAT
1735 /* test heartbeat received (write_p is set to 0
1736 for a received record) */
Willy Tarreauf51c6982014-04-25 20:02:39 +02001737 if ((content_type == TLS1_RT_HEARTBEAT) && (write_p == 0)) {
Thierry FOURNIER28962c92018-06-17 21:37:05 +02001738 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
William Lallemand7e1770b2019-05-13 14:31:34 +02001739 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001740 const unsigned char *p = buf;
1741 unsigned int payload;
1742
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01001743 ctx->xprt_st |= SSL_SOCK_RECV_HEARTBEAT;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001744
1745 /* Check if this is a CVE-2014-0160 exploitation attempt. */
1746 if (*p != TLS1_HB_REQUEST)
1747 return;
1748
Willy Tarreauaeed6722014-04-25 23:59:58 +02001749 if (len < 1 + 2 + 16) /* 1 type + 2 size + 0 payload + 16 padding */
Willy Tarreauf51c6982014-04-25 20:02:39 +02001750 goto kill_it;
1751
1752 payload = (p[1] * 256) + p[2];
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001753 if (3 + payload + 16 <= len)
Willy Tarreauf51c6982014-04-25 20:02:39 +02001754 return; /* OK no problem */
Willy Tarreauaeed6722014-04-25 23:59:58 +02001755 kill_it:
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001756 /* We have a clear heartbleed attack (CVE-2014-0160), the
1757 * advertised payload is larger than the advertised packet
1758 * length, so we have garbage in the buffer between the
1759 * payload and the end of the buffer (p+len). We can't know
1760 * if the SSL stack is patched, and we don't know if we can
1761 * safely wipe out the area between p+3+len and payload.
1762 * So instead, we prevent the response from being sent by
1763 * setting the max_send_fragment to 0 and we report an SSL
1764 * error, which will kill this connection. It will be reported
1765 * above as SSL_ERROR_SSL while an other handshake failure with
Willy Tarreauf51c6982014-04-25 20:02:39 +02001766 * a heartbeat message will be reported as SSL_ERROR_SYSCALL.
1767 */
Willy Tarreau3b2fdb62014-04-25 23:44:22 +02001768 ssl->max_send_fragment = 0;
Willy Tarreauf51c6982014-04-25 20:02:39 +02001769 SSLerr(SSL_F_TLS1_HEARTBEAT, SSL_R_SSL_HANDSHAKE_FAILURE);
1770 return;
1771 }
Emeric Brun29f037d2014-04-25 19:05:36 +02001772#endif
Emmanuel Hocdete3804742017-03-08 11:07:10 +01001773 if (global_ssl.capture_cipherlist > 0)
1774 ssl_sock_parse_clienthello(write_p, version, content_type, buf, len, ssl);
Emeric Brun29f037d2014-04-25 19:05:36 +02001775}
1776
Bernard Spil13c53f82018-02-15 13:34:58 +01001777#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houchardc7566002018-11-20 23:33:50 +01001778static int ssl_sock_srv_select_protos(SSL *s, unsigned char **out, unsigned char *outlen,
1779 const unsigned char *in, unsigned int inlen,
1780 void *arg)
1781{
1782 struct server *srv = arg;
1783
1784 if (SSL_select_next_proto(out, outlen, in, inlen, (unsigned char *)srv->ssl_ctx.npn_str,
1785 srv->ssl_ctx.npn_len) == OPENSSL_NPN_NEGOTIATED)
1786 return SSL_TLSEXT_ERR_OK;
1787 return SSL_TLSEXT_ERR_NOACK;
1788}
1789#endif
1790
1791#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02001792/* This callback is used so that the server advertises the list of
1793 * negociable protocols for NPN.
1794 */
1795static int ssl_sock_advertise_npn_protos(SSL *s, const unsigned char **data,
1796 unsigned int *len, void *arg)
1797{
Emmanuel Hocdet98263292016-12-29 18:26:15 +01001798 struct ssl_bind_conf *conf = arg;
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02001799
1800 *data = (const unsigned char *)conf->npn_str;
1801 *len = conf->npn_len;
1802 return SSL_TLSEXT_ERR_OK;
1803}
1804#endif
1805
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001806#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02001807/* This callback is used so that the server advertises the list of
1808 * negociable protocols for ALPN.
1809 */
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001810static int ssl_sock_advertise_alpn_protos(SSL *s, const unsigned char **out,
1811 unsigned char *outlen,
1812 const unsigned char *server,
1813 unsigned int server_len, void *arg)
Willy Tarreauab861d32013-04-02 02:30:41 +02001814{
Emmanuel Hocdet98263292016-12-29 18:26:15 +01001815 struct ssl_bind_conf *conf = arg;
Willy Tarreauab861d32013-04-02 02:30:41 +02001816
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01001817 if (SSL_select_next_proto((unsigned char**) out, outlen, (const unsigned char *)conf->alpn_str,
1818 conf->alpn_len, server, server_len) != OPENSSL_NPN_NEGOTIATED) {
1819 return SSL_TLSEXT_ERR_NOACK;
1820 }
Willy Tarreauab861d32013-04-02 02:30:41 +02001821 return SSL_TLSEXT_ERR_OK;
1822}
1823#endif
1824
Willy Tarreauc8ad3be2015-06-17 15:48:26 +02001825#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01001826#ifndef SSL_NO_GENERATE_CERTIFICATES
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02001827
Christopher Faulet30548802015-06-11 13:39:32 +02001828/* Create a X509 certificate with the specified servername and serial. This
1829 * function returns a SSL_CTX object or NULL if an error occurs. */
Christopher Faulet7969a332015-10-09 11:15:03 +02001830static SSL_CTX *
Christopher Faulet635c0ad2015-11-12 11:35:51 +01001831ssl_sock_do_create_cert(const char *servername, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet31af49d2015-06-09 17:29:50 +02001832{
Christopher Faulet7969a332015-10-09 11:15:03 +02001833 X509 *cacert = bind_conf->ca_sign_cert;
1834 EVP_PKEY *capkey = bind_conf->ca_sign_pkey;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001835 SSL_CTX *ssl_ctx = NULL;
1836 X509 *newcrt = NULL;
1837 EVP_PKEY *pkey = NULL;
Emmanuel Hocdet15969292017-08-11 10:56:00 +02001838 SSL *tmp_ssl = NULL;
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02001839 CONF *ctmp = NULL;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001840 X509_NAME *name;
1841 const EVP_MD *digest;
1842 X509V3_CTX ctx;
1843 unsigned int i;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001844 int key_type;
Christopher Faulet31af49d2015-06-09 17:29:50 +02001845
Christopher Faulet48a83322017-07-28 16:56:09 +02001846 /* Get the private key of the default certificate and use it */
Willy Tarreau5db847a2019-05-09 14:13:35 +02001847#if (HA_OPENSSL_VERSION_NUMBER >= 0x10002000L)
Emmanuel Hocdet15969292017-08-11 10:56:00 +02001848 pkey = SSL_CTX_get0_privatekey(bind_conf->default_ctx);
1849#else
1850 tmp_ssl = SSL_new(bind_conf->default_ctx);
1851 if (tmp_ssl)
1852 pkey = SSL_get_privatekey(tmp_ssl);
1853#endif
1854 if (!pkey)
Christopher Faulet31af49d2015-06-09 17:29:50 +02001855 goto mkcert_error;
1856
1857 /* Create the certificate */
1858 if (!(newcrt = X509_new()))
1859 goto mkcert_error;
1860
1861 /* Set version number for the certificate (X509v3) and the serial
1862 * number */
1863 if (X509_set_version(newcrt, 2L) != 1)
1864 goto mkcert_error;
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01001865 ASN1_INTEGER_set(X509_get_serialNumber(newcrt), _HA_ATOMIC_ADD(&ssl_ctx_serial, 1));
Christopher Faulet31af49d2015-06-09 17:29:50 +02001866
1867 /* Set duration for the certificate */
Rosen Penev68185952018-12-14 08:47:02 -08001868 if (!X509_gmtime_adj(X509_getm_notBefore(newcrt), (long)-60*60*24) ||
1869 !X509_gmtime_adj(X509_getm_notAfter(newcrt),(long)60*60*24*365))
Christopher Faulet31af49d2015-06-09 17:29:50 +02001870 goto mkcert_error;
1871
1872 /* set public key in the certificate */
1873 if (X509_set_pubkey(newcrt, pkey) != 1)
1874 goto mkcert_error;
1875
1876 /* Set issuer name from the CA */
1877 if (!(name = X509_get_subject_name(cacert)))
1878 goto mkcert_error;
1879 if (X509_set_issuer_name(newcrt, name) != 1)
1880 goto mkcert_error;
1881
1882 /* Set the subject name using the same, but the CN */
1883 name = X509_NAME_dup(name);
1884 if (X509_NAME_add_entry_by_txt(name, "CN", MBSTRING_ASC,
1885 (const unsigned char *)servername,
1886 -1, -1, 0) != 1) {
1887 X509_NAME_free(name);
1888 goto mkcert_error;
1889 }
1890 if (X509_set_subject_name(newcrt, name) != 1) {
1891 X509_NAME_free(name);
1892 goto mkcert_error;
1893 }
1894 X509_NAME_free(name);
1895
1896 /* Add x509v3 extensions as specified */
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02001897 ctmp = NCONF_new(NULL);
Christopher Faulet31af49d2015-06-09 17:29:50 +02001898 X509V3_set_ctx(&ctx, cacert, newcrt, NULL, NULL, 0);
1899 for (i = 0; i < X509V3_EXT_SIZE; i++) {
1900 X509_EXTENSION *ext;
1901
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02001902 if (!(ext = X509V3_EXT_nconf(ctmp, &ctx, x509v3_ext_names[i], x509v3_ext_values[i])))
Christopher Faulet31af49d2015-06-09 17:29:50 +02001903 goto mkcert_error;
1904 if (!X509_add_ext(newcrt, ext, -1)) {
1905 X509_EXTENSION_free(ext);
1906 goto mkcert_error;
1907 }
1908 X509_EXTENSION_free(ext);
1909 }
1910
1911 /* Sign the certificate with the CA private key */
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001912
1913 key_type = EVP_PKEY_base_id(capkey);
1914
1915 if (key_type == EVP_PKEY_DSA)
1916 digest = EVP_sha1();
1917 else if (key_type == EVP_PKEY_RSA)
Christopher Faulet31af49d2015-06-09 17:29:50 +02001918 digest = EVP_sha256();
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02001919 else if (key_type == EVP_PKEY_EC)
Christopher Faulet7969a332015-10-09 11:15:03 +02001920 digest = EVP_sha256();
1921 else {
Willy Tarreau9a1ab082019-05-09 13:26:41 +02001922#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000000fL) && !defined(OPENSSL_IS_BORINGSSL)
Christopher Faulet7969a332015-10-09 11:15:03 +02001923 int nid;
1924
1925 if (EVP_PKEY_get_default_digest_nid(capkey, &nid) <= 0)
1926 goto mkcert_error;
1927 if (!(digest = EVP_get_digestbynid(nid)))
1928 goto mkcert_error;
Christopher Faulete7db2162015-10-19 13:59:24 +02001929#else
1930 goto mkcert_error;
1931#endif
Christopher Faulet7969a332015-10-09 11:15:03 +02001932 }
1933
Christopher Faulet31af49d2015-06-09 17:29:50 +02001934 if (!(X509_sign(newcrt, capkey, digest)))
1935 goto mkcert_error;
1936
1937 /* Create and set the new SSL_CTX */
1938 if (!(ssl_ctx = SSL_CTX_new(SSLv23_server_method())))
1939 goto mkcert_error;
1940 if (!SSL_CTX_use_PrivateKey(ssl_ctx, pkey))
1941 goto mkcert_error;
1942 if (!SSL_CTX_use_certificate(ssl_ctx, newcrt))
1943 goto mkcert_error;
1944 if (!SSL_CTX_check_private_key(ssl_ctx))
1945 goto mkcert_error;
1946
1947 if (newcrt) X509_free(newcrt);
Christopher Faulet7969a332015-10-09 11:15:03 +02001948
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01001949#ifndef OPENSSL_NO_DH
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02001950 SSL_CTX_set_tmp_dh_callback(ssl_ctx, ssl_get_tmp_dh);
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01001951#endif
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02001952#if defined(SSL_CTX_set_tmp_ecdh) && !defined(OPENSSL_NO_ECDH)
1953 {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01001954 const char *ecdhe = (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe : ECDHE_DEFAULT_CURVE);
Christopher Faulet85b5a1a2015-10-09 11:46:32 +02001955 EC_KEY *ecc;
1956 int nid;
1957
1958 if ((nid = OBJ_sn2nid(ecdhe)) == NID_undef)
1959 goto end;
1960 if (!(ecc = EC_KEY_new_by_curve_name(nid)))
1961 goto end;
1962 SSL_CTX_set_tmp_ecdh(ssl_ctx, ecc);
1963 EC_KEY_free(ecc);
1964 }
1965#endif
1966 end:
Christopher Faulet31af49d2015-06-09 17:29:50 +02001967 return ssl_ctx;
1968
1969 mkcert_error:
Emmanuel Hocdeta9b84022018-10-01 18:41:36 +02001970 if (ctmp) NCONF_free(ctmp);
Emmanuel Hocdet15969292017-08-11 10:56:00 +02001971 if (tmp_ssl) SSL_free(tmp_ssl);
Christopher Faulet31af49d2015-06-09 17:29:50 +02001972 if (ssl_ctx) SSL_CTX_free(ssl_ctx);
1973 if (newcrt) X509_free(newcrt);
Christopher Faulet31af49d2015-06-09 17:29:50 +02001974 return NULL;
1975}
1976
Christopher Faulet7969a332015-10-09 11:15:03 +02001977SSL_CTX *
Christopher Faulet635c0ad2015-11-12 11:35:51 +01001978ssl_sock_create_cert(struct connection *conn, const char *servername, unsigned int key)
Christopher Faulet7969a332015-10-09 11:15:03 +02001979{
Willy Tarreau07d94e42018-09-20 10:57:52 +02001980 struct bind_conf *bind_conf = __objt_listener(conn->target)->bind_conf;
Olivier Houchard66ab4982019-02-26 18:37:15 +01001981 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Christopher Faulet635c0ad2015-11-12 11:35:51 +01001982
Olivier Houchard66ab4982019-02-26 18:37:15 +01001983 return ssl_sock_do_create_cert(servername, bind_conf, ctx->ssl);
Christopher Faulet7969a332015-10-09 11:15:03 +02001984}
1985
Christopher Faulet30548802015-06-11 13:39:32 +02001986/* Do a lookup for a certificate in the LRU cache used to store generated
Emeric Brun821bb9b2017-06-15 16:37:39 +02001987 * certificates and immediately assign it to the SSL session if not null. */
Christopher Faulet30548802015-06-11 13:39:32 +02001988SSL_CTX *
Emeric Brun821bb9b2017-06-15 16:37:39 +02001989ssl_sock_assign_generated_cert(unsigned int key, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet30548802015-06-11 13:39:32 +02001990{
1991 struct lru64 *lru = NULL;
1992
1993 if (ssl_ctx_lru_tree) {
Willy Tarreau03f4ec42018-05-17 10:56:47 +02001994 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01001995 lru = lru64_lookup(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
Emeric Brun821bb9b2017-06-15 16:37:39 +02001996 if (lru && lru->domain) {
1997 if (ssl)
1998 SSL_set_SSL_CTX(ssl, (SSL_CTX *)lru->data);
Willy Tarreau03f4ec42018-05-17 10:56:47 +02001999 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet30548802015-06-11 13:39:32 +02002000 return (SSL_CTX *)lru->data;
Emeric Brun821bb9b2017-06-15 16:37:39 +02002001 }
Willy Tarreau03f4ec42018-05-17 10:56:47 +02002002 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet30548802015-06-11 13:39:32 +02002003 }
2004 return NULL;
2005}
2006
Emeric Brun821bb9b2017-06-15 16:37:39 +02002007/* Same as <ssl_sock_assign_generated_cert> but without SSL session. This
2008 * function is not thread-safe, it should only be used to check if a certificate
2009 * exists in the lru cache (with no warranty it will not be removed by another
2010 * thread). It is kept for backward compatibility. */
2011SSL_CTX *
2012ssl_sock_get_generated_cert(unsigned int key, struct bind_conf *bind_conf)
2013{
2014 return ssl_sock_assign_generated_cert(key, bind_conf, NULL);
2015}
2016
Christopher Fauletd2cab922015-07-28 16:03:47 +02002017/* Set a certificate int the LRU cache used to store generated
2018 * certificate. Return 0 on success, otherwise -1 */
2019int
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002020ssl_sock_set_generated_cert(SSL_CTX *ssl_ctx, unsigned int key, struct bind_conf *bind_conf)
Christopher Faulet30548802015-06-11 13:39:32 +02002021{
2022 struct lru64 *lru = NULL;
2023
2024 if (ssl_ctx_lru_tree) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002025 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002026 lru = lru64_get(key, ssl_ctx_lru_tree, bind_conf->ca_sign_cert, 0);
Emeric Brun821bb9b2017-06-15 16:37:39 +02002027 if (!lru) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002028 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002029 return -1;
Emeric Brun821bb9b2017-06-15 16:37:39 +02002030 }
Christopher Faulet30548802015-06-11 13:39:32 +02002031 if (lru->domain && lru->data)
2032 lru->free((SSL_CTX *)lru->data);
Christopher Faulet7969a332015-10-09 11:15:03 +02002033 lru64_commit(lru, ssl_ctx, bind_conf->ca_sign_cert, 0, (void (*)(void *))SSL_CTX_free);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002034 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002035 return 0;
Christopher Faulet30548802015-06-11 13:39:32 +02002036 }
Christopher Fauletd2cab922015-07-28 16:03:47 +02002037 return -1;
Christopher Faulet30548802015-06-11 13:39:32 +02002038}
2039
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002040/* Compute the key of the certificate. */
Christopher Faulet30548802015-06-11 13:39:32 +02002041unsigned int
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002042ssl_sock_generated_cert_key(const void *data, size_t len)
Christopher Faulet30548802015-06-11 13:39:32 +02002043{
2044 return XXH32(data, len, ssl_ctx_lru_seed);
2045}
2046
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002047/* Generate a cert and immediately assign it to the SSL session so that the cert's
2048 * refcount is maintained regardless of the cert's presence in the LRU cache.
2049 */
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002050static int
Christopher Faulet7969a332015-10-09 11:15:03 +02002051ssl_sock_generate_certificate(const char *servername, struct bind_conf *bind_conf, SSL *ssl)
Christopher Faulet31af49d2015-06-09 17:29:50 +02002052{
2053 X509 *cacert = bind_conf->ca_sign_cert;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002054 SSL_CTX *ssl_ctx = NULL;
2055 struct lru64 *lru = NULL;
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002056 unsigned int key;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002057
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002058 key = ssl_sock_generated_cert_key(servername, strlen(servername));
Christopher Faulet31af49d2015-06-09 17:29:50 +02002059 if (ssl_ctx_lru_tree) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002060 HA_RWLOCK_WRLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002061 lru = lru64_get(key, ssl_ctx_lru_tree, cacert, 0);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002062 if (lru && lru->domain)
2063 ssl_ctx = (SSL_CTX *)lru->data;
Christopher Fauletd2cab922015-07-28 16:03:47 +02002064 if (!ssl_ctx && lru) {
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002065 ssl_ctx = ssl_sock_do_create_cert(servername, bind_conf, ssl);
Christopher Faulet31af49d2015-06-09 17:29:50 +02002066 lru64_commit(lru, ssl_ctx, cacert, 0, (void (*)(void *))SSL_CTX_free);
Christopher Fauletd2cab922015-07-28 16:03:47 +02002067 }
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002068 SSL_set_SSL_CTX(ssl, ssl_ctx);
Christopher Faulet2a944ee2017-11-07 10:42:54 +01002069 HA_RWLOCK_WRUNLOCK(SSL_GEN_CERTS_LOCK, &ssl_ctx_lru_rwlock);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002070 return 1;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002071 }
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002072 else {
Christopher Faulet635c0ad2015-11-12 11:35:51 +01002073 ssl_ctx = ssl_sock_do_create_cert(servername, bind_conf, ssl);
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002074 SSL_set_SSL_CTX(ssl, ssl_ctx);
2075 /* No LRU cache, this CTX will be released as soon as the session dies */
2076 SSL_CTX_free(ssl_ctx);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002077 return 1;
Willy Tarreau2f63ef42015-10-20 15:16:01 +02002078 }
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002079 return 0;
2080}
2081static int
2082ssl_sock_generate_certificate_from_conn(struct bind_conf *bind_conf, SSL *ssl)
2083{
2084 unsigned int key;
Thierry FOURNIER28962c92018-06-17 21:37:05 +02002085 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002086
2087 conn_get_to_addr(conn);
2088 if (conn->flags & CO_FL_ADDR_TO_SET) {
2089 key = ssl_sock_generated_cert_key(&conn->addr.to, get_addr_len(&conn->addr.to));
Emeric Brun821bb9b2017-06-15 16:37:39 +02002090 if (ssl_sock_assign_generated_cert(key, bind_conf, ssl))
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002091 return 1;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002092 }
2093 return 0;
Christopher Faulet31af49d2015-06-09 17:29:50 +02002094}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002095#endif /* !defined SSL_NO_GENERATE_CERTIFICATES */
Christopher Faulet31af49d2015-06-09 17:29:50 +02002096
Willy Tarreau9a1ab082019-05-09 13:26:41 +02002097#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002098typedef enum { SET_CLIENT, SET_SERVER } set_context_func;
2099
2100static void ctx_set_SSLv3_func(SSL_CTX *ctx, set_context_func c)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002101{
Emmanuel Hocdet23877ab2017-07-12 12:53:02 +02002102#if SSL_OP_NO_SSLv3
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002103 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, SSLv3_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002104 : SSL_CTX_set_ssl_version(ctx, SSLv3_client_method());
2105#endif
2106}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002107static void ctx_set_TLSv10_func(SSL_CTX *ctx, set_context_func c) {
2108 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002109 : SSL_CTX_set_ssl_version(ctx, TLSv1_client_method());
2110}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002111static void ctx_set_TLSv11_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002112#if SSL_OP_NO_TLSv1_1
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002113 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_1_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002114 : SSL_CTX_set_ssl_version(ctx, TLSv1_1_client_method());
2115#endif
2116}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002117static void ctx_set_TLSv12_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002118#if SSL_OP_NO_TLSv1_2
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002119 c == SET_SERVER ? SSL_CTX_set_ssl_version(ctx, TLSv1_2_server_method())
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002120 : SSL_CTX_set_ssl_version(ctx, TLSv1_2_client_method());
2121#endif
2122}
Bertrand Jacquina25282b2018-08-14 00:56:13 +01002123/* TLSv1.2 is the last supported version in this context. */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002124static void ctx_set_TLSv13_func(SSL_CTX *ctx, set_context_func c) {}
2125/* Unusable in this context. */
2126static void ssl_set_SSLv3_func(SSL *ssl, set_context_func c) {}
2127static void ssl_set_TLSv10_func(SSL *ssl, set_context_func c) {}
2128static void ssl_set_TLSv11_func(SSL *ssl, set_context_func c) {}
2129static void ssl_set_TLSv12_func(SSL *ssl, set_context_func c) {}
2130static void ssl_set_TLSv13_func(SSL *ssl, set_context_func c) {}
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002131#else /* openssl >= 1.1.0 */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002132typedef enum { SET_MIN, SET_MAX } set_context_func;
2133
2134static void ctx_set_SSLv3_func(SSL_CTX *ctx, set_context_func c) {
2135 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, SSL3_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002136 : SSL_CTX_set_min_proto_version(ctx, SSL3_VERSION);
2137}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002138static void ssl_set_SSLv3_func(SSL *ssl, set_context_func c) {
2139 c == SET_MAX ? SSL_set_max_proto_version(ssl, SSL3_VERSION)
2140 : SSL_set_min_proto_version(ssl, SSL3_VERSION);
2141}
2142static void ctx_set_TLSv10_func(SSL_CTX *ctx, set_context_func c) {
2143 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002144 : SSL_CTX_set_min_proto_version(ctx, TLS1_VERSION);
2145}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002146static void ssl_set_TLSv10_func(SSL *ssl, set_context_func c) {
2147 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_VERSION)
2148 : SSL_set_min_proto_version(ssl, TLS1_VERSION);
2149}
2150static void ctx_set_TLSv11_func(SSL_CTX *ctx, set_context_func c) {
2151 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_1_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002152 : SSL_CTX_set_min_proto_version(ctx, TLS1_1_VERSION);
2153}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002154static void ssl_set_TLSv11_func(SSL *ssl, set_context_func c) {
2155 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_1_VERSION)
2156 : SSL_set_min_proto_version(ssl, TLS1_1_VERSION);
2157}
2158static void ctx_set_TLSv12_func(SSL_CTX *ctx, set_context_func c) {
2159 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_2_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002160 : SSL_CTX_set_min_proto_version(ctx, TLS1_2_VERSION);
2161}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002162static void ssl_set_TLSv12_func(SSL *ssl, set_context_func c) {
2163 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_2_VERSION)
2164 : SSL_set_min_proto_version(ssl, TLS1_2_VERSION);
2165}
2166static void ctx_set_TLSv13_func(SSL_CTX *ctx, set_context_func c) {
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002167#if SSL_OP_NO_TLSv1_3
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002168 c == SET_MAX ? SSL_CTX_set_max_proto_version(ctx, TLS1_3_VERSION)
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002169 : SSL_CTX_set_min_proto_version(ctx, TLS1_3_VERSION);
2170#endif
2171}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002172static void ssl_set_TLSv13_func(SSL *ssl, set_context_func c) {
2173#if SSL_OP_NO_TLSv1_3
2174 c == SET_MAX ? SSL_set_max_proto_version(ssl, TLS1_3_VERSION)
2175 : SSL_set_min_proto_version(ssl, TLS1_3_VERSION);
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002176#endif
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002177}
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002178#endif
2179static void ctx_set_None_func(SSL_CTX *ctx, set_context_func c) { }
2180static void ssl_set_None_func(SSL *ssl, set_context_func c) { }
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002181
2182static struct {
2183 int option;
2184 uint16_t flag;
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002185 void (*ctx_set_version)(SSL_CTX *, set_context_func);
2186 void (*ssl_set_version)(SSL *, set_context_func);
Emmanuel Hocdetecb0e232017-05-18 11:56:58 +02002187 const char *name;
2188} methodVersions[] = {
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02002189 {0, 0, ctx_set_None_func, ssl_set_None_func, "NONE"}, /* CONF_TLSV_NONE */
2190 {SSL_OP_NO_SSLv3, MC_SSL_O_NO_SSLV3, ctx_set_SSLv3_func, ssl_set_SSLv3_func, "SSLv3"}, /* CONF_SSLV3 */
2191 {SSL_OP_NO_TLSv1, MC_SSL_O_NO_TLSV10, ctx_set_TLSv10_func, ssl_set_TLSv10_func, "TLSv1.0"}, /* CONF_TLSV10 */
2192 {SSL_OP_NO_TLSv1_1, MC_SSL_O_NO_TLSV11, ctx_set_TLSv11_func, ssl_set_TLSv11_func, "TLSv1.1"}, /* CONF_TLSV11 */
2193 {SSL_OP_NO_TLSv1_2, MC_SSL_O_NO_TLSV12, ctx_set_TLSv12_func, ssl_set_TLSv12_func, "TLSv1.2"}, /* CONF_TLSV12 */
2194 {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 +02002195};
2196
Emmanuel Hocdet530141f2017-03-01 18:54:56 +01002197static void ssl_sock_switchctx_set(SSL *ssl, SSL_CTX *ctx)
2198{
2199 SSL_set_verify(ssl, SSL_CTX_get_verify_mode(ctx), ssl_sock_bind_verifycbk);
2200 SSL_set_client_CA_list(ssl, SSL_dup_CA_list(SSL_CTX_get_client_CA_list(ctx)));
2201 SSL_set_SSL_CTX(ssl, ctx);
2202}
2203
Willy Tarreau5db847a2019-05-09 14:13:35 +02002204#if ((HA_OPENSSL_VERSION_NUMBER >= 0x10101000L) || defined(OPENSSL_IS_BORINGSSL))
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002205
2206static int ssl_sock_switchctx_err_cbk(SSL *ssl, int *al, void *priv)
2207{
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002208 struct bind_conf *s = priv;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002209 (void)al; /* shut gcc stupid warning */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002210
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002211 if (SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name) || s->generate_certs)
2212 return SSL_TLSEXT_ERR_OK;
2213 return SSL_TLSEXT_ERR_NOACK;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002214}
2215
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002216#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002217static int ssl_sock_switchctx_cbk(const struct ssl_early_callback_ctx *ctx)
2218{
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002219 SSL *ssl = ctx->ssl;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002220#else
2221static int ssl_sock_switchctx_cbk(SSL *ssl, int *al, void *arg)
2222{
2223#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002224 struct connection *conn;
2225 struct bind_conf *s;
2226 const uint8_t *extension_data;
2227 size_t extension_len;
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002228 int has_rsa_sig = 0, has_ecdsa_sig = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002229
2230 char *wildp = NULL;
2231 const uint8_t *servername;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002232 size_t servername_len;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002233 struct ebmb_node *node, *n, *node_ecdsa = NULL, *node_rsa = NULL, *node_anonymous = NULL;
Olivier Houchardc2aae742017-09-22 18:26:28 +02002234 int allow_early = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002235 int i;
2236
Thierry FOURNIER28962c92018-06-17 21:37:05 +02002237 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Willy Tarreaua8825522018-10-15 13:20:07 +02002238 s = __objt_listener(conn->target)->bind_conf;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002239
Olivier Houchard9679ac92017-10-27 14:58:08 +02002240 if (s->ssl_conf.early_data)
Olivier Houchardc2aae742017-09-22 18:26:28 +02002241 allow_early = 1;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002242#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002243 if (SSL_early_callback_ctx_extension_get(ctx, TLSEXT_TYPE_server_name,
2244 &extension_data, &extension_len)) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002245#else
2246 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_server_name, &extension_data, &extension_len)) {
2247#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002248 /*
2249 * The server_name extension was given too much extensibility when it
2250 * was written, so parsing the normal case is a bit complex.
2251 */
2252 size_t len;
2253 if (extension_len <= 2)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002254 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002255 /* Extract the length of the supplied list of names. */
2256 len = (*extension_data++) << 8;
2257 len |= *extension_data++;
2258 if (len + 2 != extension_len)
2259 goto abort;
2260 /*
2261 * The list in practice only has a single element, so we only consider
2262 * the first one.
2263 */
2264 if (len == 0 || *extension_data++ != TLSEXT_NAMETYPE_host_name)
2265 goto abort;
2266 extension_len = len - 1;
2267 /* Now we can finally pull out the byte array with the actual hostname. */
2268 if (extension_len <= 2)
2269 goto abort;
2270 len = (*extension_data++) << 8;
2271 len |= *extension_data++;
2272 if (len == 0 || len + 2 > extension_len || len > TLSEXT_MAXLEN_host_name
2273 || memchr(extension_data, 0, len) != NULL)
2274 goto abort;
2275 servername = extension_data;
2276 servername_len = len;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002277 } else {
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002278#if (!defined SSL_NO_GENERATE_CERTIFICATES)
2279 if (s->generate_certs && ssl_sock_generate_certificate_from_conn(s, ssl)) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02002280 goto allow_early;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002281 }
2282#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002283 /* without SNI extension, is the default_ctx (need SSL_TLSEXT_ERR_NOACK) */
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002284 if (!s->strict_sni) {
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002285 ssl_sock_switchctx_set(ssl, s->default_ctx);
Olivier Houchardc2aae742017-09-22 18:26:28 +02002286 goto allow_early;
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002287 }
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002288 goto abort;
2289 }
2290
2291 /* extract/check clientHello informations */
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002292#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002293 if (SSL_early_callback_ctx_extension_get(ctx, TLSEXT_TYPE_signature_algorithms, &extension_data, &extension_len)) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002294#else
2295 if (SSL_client_hello_get0_ext(ssl, TLSEXT_TYPE_signature_algorithms, &extension_data, &extension_len)) {
2296#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002297 uint8_t sign;
2298 size_t len;
2299 if (extension_len < 2)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002300 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002301 len = (*extension_data++) << 8;
2302 len |= *extension_data++;
2303 if (len + 2 != extension_len)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002304 goto abort;
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002305 if (len % 2 != 0)
2306 goto abort;
2307 for (; len > 0; len -= 2) {
2308 extension_data++; /* hash */
2309 sign = *extension_data++;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002310 switch (sign) {
2311 case TLSEXT_signature_rsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002312 has_rsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002313 break;
2314 case TLSEXT_signature_ecdsa:
2315 has_ecdsa_sig = 1;
2316 break;
2317 default:
2318 continue;
2319 }
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002320 if (has_ecdsa_sig && has_rsa_sig)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002321 break;
2322 }
2323 } else {
Bertrand Jacquina25282b2018-08-14 00:56:13 +01002324 /* without TLSEXT_TYPE_signature_algorithms extension (< TLSv1.2) */
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002325 has_rsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002326 }
2327 if (has_ecdsa_sig) { /* in very rare case: has ecdsa sign but not a ECDSA cipher */
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002328 const SSL_CIPHER *cipher;
2329 size_t len;
2330 const uint8_t *cipher_suites;
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002331 has_ecdsa_sig = 0;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002332#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002333 len = ctx->cipher_suites_len;
2334 cipher_suites = ctx->cipher_suites;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002335#else
2336 len = SSL_client_hello_get0_ciphers(ssl, &cipher_suites);
2337#endif
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002338 if (len % 2 != 0)
2339 goto abort;
2340 for (; len != 0; len -= 2, cipher_suites += 2) {
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002341#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002342 uint16_t cipher_suite = (cipher_suites[0] << 8) | cipher_suites[1];
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002343 cipher = SSL_get_cipher_by_value(cipher_suite);
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002344#else
2345 cipher = SSL_CIPHER_find(ssl, cipher_suites);
2346#endif
Emmanuel Hocdet019f9b12017-10-02 17:12:06 +02002347 if (cipher && SSL_CIPHER_get_auth_nid(cipher) == NID_auth_ecdsa) {
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002348 has_ecdsa_sig = 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002349 break;
2350 }
2351 }
2352 }
2353
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002354 for (i = 0; i < trash.size && i < servername_len; i++) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002355 trash.area[i] = tolower(servername[i]);
2356 if (!wildp && (trash.area[i] == '.'))
2357 wildp = &trash.area[i];
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002358 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002359 trash.area[i] = 0;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002360
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002361
Emmanuel Hocdetcc957c32019-11-06 16:05:34 +01002362 for (i = 0; i < 2; i++) {
2363 if (i == 0) /* lookup in full qualified names */
2364 node = ebst_lookup(&s->sni_ctx, trash.area);
2365 else if (i == 1 && wildp) /* lookup in wildcards names */
2366 node = ebst_lookup(&s->sni_w_ctx, wildp);
2367 else
2368 break;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002369 for (n = node; n; n = ebmb_next_dup(n)) {
Emmanuel Hocdetcc957c32019-11-06 16:05:34 +01002370 /* lookup a not neg filter */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002371 if (!container_of(n, struct sni_ctx, name)->neg) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002372 switch(container_of(n, struct sni_ctx, name)->kinfo.sig) {
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002373 case TLSEXT_signature_ecdsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002374 if (!node_ecdsa)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002375 node_ecdsa = n;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002376 break;
2377 case TLSEXT_signature_rsa:
Emmanuel Hocdet9f9b0c62018-09-03 16:29:16 +02002378 if (!node_rsa)
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002379 node_rsa = n;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002380 break;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002381 default: /* TLSEXT_signature_anonymous|dsa */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002382 if (!node_anonymous)
2383 node_anonymous = n;
2384 break;
2385 }
2386 }
2387 }
Emmanuel Hocdetcc957c32019-11-06 16:05:34 +01002388 /* select by key_signature priority order */
2389 node = (has_ecdsa_sig && node_ecdsa) ? node_ecdsa
2390 : ((has_rsa_sig && node_rsa) ? node_rsa
2391 : (node_anonymous ? node_anonymous
2392 : (node_ecdsa ? node_ecdsa /* no ecdsa signature case (< TLSv1.2) */
2393 : node_rsa /* no rsa signature case (far far away) */
2394 )));
2395 if (node) {
2396 /* switch ctx */
2397 struct ssl_bind_conf *conf = container_of(node, struct sni_ctx, name)->conf;
2398 ssl_sock_switchctx_set(ssl, container_of(node, struct sni_ctx, name)->ctx);
Olivier Houchard35a63cc2017-11-02 19:04:38 +01002399 if (conf) {
2400 methodVersions[conf->ssl_methods.min].ssl_set_version(ssl, SET_MIN);
2401 methodVersions[conf->ssl_methods.max].ssl_set_version(ssl, SET_MAX);
2402 if (conf->early_data)
2403 allow_early = 1;
2404 }
2405 goto allow_early;
Emmanuel Hocdetcc957c32019-11-06 16:05:34 +01002406 }
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002407 }
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002408#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002409 if (s->generate_certs && ssl_sock_generate_certificate(trash.area, s, ssl)) {
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002410 /* switch ctx done in ssl_sock_generate_certificate */
Olivier Houchardc2aae742017-09-22 18:26:28 +02002411 goto allow_early;
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002412 }
2413#endif
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002414 if (!s->strict_sni) {
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002415 /* no certificate match, is the default_ctx */
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002416 ssl_sock_switchctx_set(ssl, s->default_ctx);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002417 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02002418allow_early:
2419#ifdef OPENSSL_IS_BORINGSSL
2420 if (allow_early)
2421 SSL_set_early_data_enabled(ssl, 1);
2422#else
2423 if (!allow_early)
2424 SSL_set_max_early_data(ssl, 0);
2425#endif
2426 return 1;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002427 abort:
2428 /* abort handshake (was SSL_TLSEXT_ERR_ALERT_FATAL) */
2429 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002430#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet48e87552017-08-16 11:28:44 +02002431 return ssl_select_cert_error;
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02002432#else
2433 *al = SSL_AD_UNRECOGNIZED_NAME;
2434 return 0;
2435#endif
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002436}
2437
2438#else /* OPENSSL_IS_BORINGSSL */
2439
Emeric Brunfc0421f2012-09-07 17:30:07 +02002440/* Sets the SSL ctx of <ssl> to match the advertised server name. Returns a
2441 * warning when no match is found, which implies the default (first) cert
2442 * will keep being used.
2443 */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002444static int ssl_sock_switchctx_cbk(SSL *ssl, int *al, void *priv)
Emeric Brunfc0421f2012-09-07 17:30:07 +02002445{
2446 const char *servername;
2447 const char *wildp = NULL;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002448 struct ebmb_node *node, *n;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002449 struct bind_conf *s = priv;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002450 int i;
2451 (void)al; /* shut gcc stupid warning */
2452
2453 servername = SSL_get_servername(ssl, TLSEXT_NAMETYPE_host_name);
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002454 if (!servername) {
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002455#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002456 if (s->generate_certs && ssl_sock_generate_certificate_from_conn(s, ssl))
2457 return SSL_TLSEXT_ERR_OK;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002458#endif
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002459 if (s->strict_sni)
2460 return SSL_TLSEXT_ERR_ALERT_FATAL;
2461 ssl_sock_switchctx_set(ssl, s->default_ctx);
2462 return SSL_TLSEXT_ERR_NOACK;
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002463 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02002464
Willy Tarreau19d14ef2012-10-29 16:51:55 +01002465 for (i = 0; i < trash.size; i++) {
Emeric Brunfc0421f2012-09-07 17:30:07 +02002466 if (!servername[i])
2467 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002468 trash.area[i] = tolower(servername[i]);
2469 if (!wildp && (trash.area[i] == '.'))
2470 wildp = &trash.area[i];
Emeric Brunfc0421f2012-09-07 17:30:07 +02002471 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002472 trash.area[i] = 0;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002473
Emmanuel Hocdet26b7b802019-11-04 15:49:46 +01002474 node = NULL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002475 /* lookup in full qualified names */
Emmanuel Hocdet26b7b802019-11-04 15:49:46 +01002476 for (n = ebst_lookup(&s->sni_ctx, trash.area); n; n = ebmb_next_dup(n)) {
2477 /* lookup a not neg filter */
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002478 if (!container_of(n, struct sni_ctx, name)->neg) {
2479 node = n;
2480 break;
Emmanuel Hocdet65623372013-01-24 17:17:15 +01002481 }
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002482 }
2483 if (!node && wildp) {
2484 /* lookup in wildcards names */
Emmanuel Hocdet26b7b802019-11-04 15:49:46 +01002485 for (n = ebst_lookup(&s->sni_w_ctx, wildp); n; n = ebmb_next_dup(n)) {
2486 /* lookup a not neg filter */
2487 if (!container_of(n, struct sni_ctx, name)->neg) {
2488 node = n;
2489 break;
2490 }
2491 }
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002492 }
Emmanuel Hocdet26b7b802019-11-04 15:49:46 +01002493 if (!node) {
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002494#if (!defined SSL_NO_GENERATE_CERTIFICATES)
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02002495 if (s->generate_certs && ssl_sock_generate_certificate(servername, s, ssl)) {
2496 /* switch ctx done in ssl_sock_generate_certificate */
Christopher Faulet31af49d2015-06-09 17:29:50 +02002497 return SSL_TLSEXT_ERR_OK;
2498 }
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01002499#endif
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01002500 if (s->strict_sni)
2501 return SSL_TLSEXT_ERR_ALERT_FATAL;
2502 ssl_sock_switchctx_set(ssl, s->default_ctx);
2503 return SSL_TLSEXT_ERR_OK;
Emeric Brunfc0421f2012-09-07 17:30:07 +02002504 }
2505
2506 /* switch ctx */
Emmanuel Hocdet530141f2017-03-01 18:54:56 +01002507 ssl_sock_switchctx_set(ssl, container_of(node, struct sni_ctx, name)->ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02002508 return SSL_TLSEXT_ERR_OK;
2509}
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002510#endif /* (!) OPENSSL_IS_BORINGSSL */
Emeric Brunfc0421f2012-09-07 17:30:07 +02002511#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
2512
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002513#ifndef OPENSSL_NO_DH
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002514
2515static DH * ssl_get_dh_1024(void)
2516{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002517 static unsigned char dh1024_p[]={
2518 0xFA,0xF9,0x2A,0x22,0x2A,0xA7,0x7F,0xE1,0x67,0x4E,0x53,0xF7,
2519 0x56,0x13,0xC3,0xB1,0xE3,0x29,0x6B,0x66,0x31,0x6A,0x7F,0xB3,
2520 0xC2,0x68,0x6B,0xCB,0x1D,0x57,0x39,0x1D,0x1F,0xFF,0x1C,0xC9,
2521 0xA6,0xA4,0x98,0x82,0x31,0x5D,0x25,0xFF,0x8A,0xE0,0x73,0x96,
2522 0x81,0xC8,0x83,0x79,0xC1,0x5A,0x04,0xF8,0x37,0x0D,0xA8,0x3D,
2523 0xAE,0x74,0xBC,0xDB,0xB6,0xA4,0x75,0xD9,0x71,0x8A,0xA0,0x17,
2524 0x9E,0x2D,0xC8,0xA8,0xDF,0x2C,0x5F,0x82,0x95,0xF8,0x92,0x9B,
2525 0xA7,0x33,0x5F,0x89,0x71,0xC8,0x2D,0x6B,0x18,0x86,0xC4,0x94,
2526 0x22,0xA5,0x52,0x8D,0xF6,0xF6,0xD2,0x37,0x92,0x0F,0xA5,0xCC,
2527 0xDB,0x7B,0x1D,0x3D,0xA1,0x31,0xB7,0x80,0x8F,0x0B,0x67,0x5E,
2528 0x36,0xA5,0x60,0x0C,0xF1,0x95,0x33,0x8B,
2529 };
2530 static unsigned char dh1024_g[]={
2531 0x02,
2532 };
2533
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002534 BIGNUM *p;
2535 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002536 DH *dh = DH_new();
2537 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002538 p = BN_bin2bn(dh1024_p, sizeof dh1024_p, NULL);
2539 g = BN_bin2bn(dh1024_g, sizeof dh1024_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002540
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002541 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002542 DH_free(dh);
2543 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002544 } else {
2545 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002546 }
2547 }
2548 return dh;
2549}
2550
2551static DH *ssl_get_dh_2048(void)
2552{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002553 static unsigned char dh2048_p[]={
2554 0xEC,0x86,0xF8,0x70,0xA0,0x33,0x16,0xEC,0x05,0x1A,0x73,0x59,
2555 0xCD,0x1F,0x8B,0xF8,0x29,0xE4,0xD2,0xCF,0x52,0xDD,0xC2,0x24,
2556 0x8D,0xB5,0x38,0x9A,0xFB,0x5C,0xA4,0xE4,0xB2,0xDA,0xCE,0x66,
2557 0x50,0x74,0xA6,0x85,0x4D,0x4B,0x1D,0x30,0xB8,0x2B,0xF3,0x10,
2558 0xE9,0xA7,0x2D,0x05,0x71,0xE7,0x81,0xDF,0x8B,0x59,0x52,0x3B,
2559 0x5F,0x43,0x0B,0x68,0xF1,0xDB,0x07,0xBE,0x08,0x6B,0x1B,0x23,
2560 0xEE,0x4D,0xCC,0x9E,0x0E,0x43,0xA0,0x1E,0xDF,0x43,0x8C,0xEC,
2561 0xBE,0xBE,0x90,0xB4,0x51,0x54,0xB9,0x2F,0x7B,0x64,0x76,0x4E,
2562 0x5D,0xD4,0x2E,0xAE,0xC2,0x9E,0xAE,0x51,0x43,0x59,0xC7,0x77,
2563 0x9C,0x50,0x3C,0x0E,0xED,0x73,0x04,0x5F,0xF1,0x4C,0x76,0x2A,
2564 0xD8,0xF8,0xCF,0xFC,0x34,0x40,0xD1,0xB4,0x42,0x61,0x84,0x66,
2565 0x42,0x39,0x04,0xF8,0x68,0xB2,0x62,0xD7,0x55,0xED,0x1B,0x74,
2566 0x75,0x91,0xE0,0xC5,0x69,0xC1,0x31,0x5C,0xDB,0x7B,0x44,0x2E,
2567 0xCE,0x84,0x58,0x0D,0x1E,0x66,0x0C,0xC8,0x44,0x9E,0xFD,0x40,
2568 0x08,0x67,0x5D,0xFB,0xA7,0x76,0x8F,0x00,0x11,0x87,0xE9,0x93,
2569 0xF9,0x7D,0xC4,0xBC,0x74,0x55,0x20,0xD4,0x4A,0x41,0x2F,0x43,
2570 0x42,0x1A,0xC1,0xF2,0x97,0x17,0x49,0x27,0x37,0x6B,0x2F,0x88,
2571 0x7E,0x1C,0xA0,0xA1,0x89,0x92,0x27,0xD9,0x56,0x5A,0x71,0xC1,
2572 0x56,0x37,0x7E,0x3A,0x9D,0x05,0xE7,0xEE,0x5D,0x8F,0x82,0x17,
2573 0xBC,0xE9,0xC2,0x93,0x30,0x82,0xF9,0xF4,0xC9,0xAE,0x49,0xDB,
2574 0xD0,0x54,0xB4,0xD9,0x75,0x4D,0xFA,0x06,0xB8,0xD6,0x38,0x41,
2575 0xB7,0x1F,0x77,0xF3,
2576 };
2577 static unsigned char dh2048_g[]={
2578 0x02,
2579 };
2580
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002581 BIGNUM *p;
2582 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002583 DH *dh = DH_new();
2584 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002585 p = BN_bin2bn(dh2048_p, sizeof dh2048_p, NULL);
2586 g = BN_bin2bn(dh2048_g, sizeof dh2048_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002587
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002588 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002589 DH_free(dh);
2590 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002591 } else {
2592 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002593 }
2594 }
2595 return dh;
2596}
2597
2598static DH *ssl_get_dh_4096(void)
2599{
Remi Gacogned3a341a2015-05-29 16:26:17 +02002600 static unsigned char dh4096_p[]={
2601 0xDE,0x16,0x94,0xCD,0x99,0x58,0x07,0xF1,0xF7,0x32,0x96,0x11,
2602 0x04,0x82,0xD4,0x84,0x72,0x80,0x99,0x06,0xCA,0xF0,0xA3,0x68,
2603 0x07,0xCE,0x64,0x50,0xE7,0x74,0x45,0x20,0x80,0x5E,0x4D,0xAD,
2604 0xA5,0xB6,0xED,0xFA,0x80,0x6C,0x3B,0x35,0xC4,0x9A,0x14,0x6B,
2605 0x32,0xBB,0xFD,0x1F,0x17,0x8E,0xB7,0x1F,0xD6,0xFA,0x3F,0x7B,
2606 0xEE,0x16,0xA5,0x62,0x33,0x0D,0xED,0xBC,0x4E,0x58,0xE5,0x47,
2607 0x4D,0xE9,0xAB,0x8E,0x38,0xD3,0x6E,0x90,0x57,0xE3,0x22,0x15,
2608 0x33,0xBD,0xF6,0x43,0x45,0xB5,0x10,0x0A,0xBE,0x2C,0xB4,0x35,
2609 0xB8,0x53,0x8D,0xAD,0xFB,0xA7,0x1F,0x85,0x58,0x41,0x7A,0x79,
2610 0x20,0x68,0xB3,0xE1,0x3D,0x08,0x76,0xBF,0x86,0x0D,0x49,0xE3,
2611 0x82,0x71,0x8C,0xB4,0x8D,0x81,0x84,0xD4,0xE7,0xBE,0x91,0xDC,
2612 0x26,0x39,0x48,0x0F,0x35,0xC4,0xCA,0x65,0xE3,0x40,0x93,0x52,
2613 0x76,0x58,0x7D,0xDD,0x51,0x75,0xDC,0x69,0x61,0xBF,0x47,0x2C,
2614 0x16,0x68,0x2D,0xC9,0x29,0xD3,0xE6,0xC0,0x99,0x48,0xA0,0x9A,
2615 0xC8,0x78,0xC0,0x6D,0x81,0x67,0x12,0x61,0x3F,0x71,0xBA,0x41,
2616 0x1F,0x6C,0x89,0x44,0x03,0xBA,0x3B,0x39,0x60,0xAA,0x28,0x55,
2617 0x59,0xAE,0xB8,0xFA,0xCB,0x6F,0xA5,0x1A,0xF7,0x2B,0xDD,0x52,
2618 0x8A,0x8B,0xE2,0x71,0xA6,0x5E,0x7E,0xD8,0x2E,0x18,0xE0,0x66,
2619 0xDF,0xDD,0x22,0x21,0x99,0x52,0x73,0xA6,0x33,0x20,0x65,0x0E,
2620 0x53,0xE7,0x6B,0x9B,0xC5,0xA3,0x2F,0x97,0x65,0x76,0xD3,0x47,
2621 0x23,0x77,0x12,0xB6,0x11,0x7B,0x24,0xED,0xF1,0xEF,0xC0,0xE2,
2622 0xA3,0x7E,0x67,0x05,0x3E,0x96,0x4D,0x45,0xC2,0x18,0xD1,0x73,
2623 0x9E,0x07,0xF3,0x81,0x6E,0x52,0x63,0xF6,0x20,0x76,0xB9,0x13,
2624 0xD2,0x65,0x30,0x18,0x16,0x09,0x16,0x9E,0x8F,0xF1,0xD2,0x10,
2625 0x5A,0xD3,0xD4,0xAF,0x16,0x61,0xDA,0x55,0x2E,0x18,0x5E,0x14,
2626 0x08,0x54,0x2E,0x2A,0x25,0xA2,0x1A,0x9B,0x8B,0x32,0xA9,0xFD,
2627 0xC2,0x48,0x96,0xE1,0x80,0xCA,0xE9,0x22,0x17,0xBB,0xCE,0x3E,
2628 0x9E,0xED,0xC7,0xF1,0x1F,0xEC,0x17,0x21,0xDC,0x7B,0x82,0x48,
2629 0x8E,0xBB,0x4B,0x9D,0x5B,0x04,0x04,0xDA,0xDB,0x39,0xDF,0x01,
2630 0x40,0xC3,0xAA,0x26,0x23,0x89,0x75,0xC6,0x0B,0xD0,0xA2,0x60,
2631 0x6A,0xF1,0xCC,0x65,0x18,0x98,0x1B,0x52,0xD2,0x74,0x61,0xCC,
2632 0xBD,0x60,0xAE,0xA3,0xA0,0x66,0x6A,0x16,0x34,0x92,0x3F,0x41,
2633 0x40,0x31,0x29,0xC0,0x2C,0x63,0xB2,0x07,0x8D,0xEB,0x94,0xB8,
2634 0xE8,0x47,0x92,0x52,0x93,0x6A,0x1B,0x7E,0x1A,0x61,0xB3,0x1B,
2635 0xF0,0xD6,0x72,0x9B,0xF1,0xB0,0xAF,0xBF,0x3E,0x65,0xEF,0x23,
2636 0x1D,0x6F,0xFF,0x70,0xCD,0x8A,0x4C,0x8A,0xA0,0x72,0x9D,0xBE,
2637 0xD4,0xBB,0x24,0x47,0x4A,0x68,0xB5,0xF5,0xC6,0xD5,0x7A,0xCD,
2638 0xCA,0x06,0x41,0x07,0xAD,0xC2,0x1E,0xE6,0x54,0xA7,0xAD,0x03,
2639 0xD9,0x12,0xC1,0x9C,0x13,0xB1,0xC9,0x0A,0x43,0x8E,0x1E,0x08,
2640 0xCE,0x50,0x82,0x73,0x5F,0xA7,0x55,0x1D,0xD9,0x59,0xAC,0xB5,
2641 0xEA,0x02,0x7F,0x6C,0x5B,0x74,0x96,0x98,0x67,0x24,0xA3,0x0F,
2642 0x15,0xFC,0xA9,0x7D,0x3E,0x67,0xD1,0x70,0xF8,0x97,0xF3,0x67,
2643 0xC5,0x8C,0x88,0x44,0x08,0x02,0xC7,0x2B,
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002644 };
Remi Gacogned3a341a2015-05-29 16:26:17 +02002645 static unsigned char dh4096_g[]={
2646 0x02,
2647 };
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002648
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002649 BIGNUM *p;
2650 BIGNUM *g;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002651 DH *dh = DH_new();
2652 if (dh) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002653 p = BN_bin2bn(dh4096_p, sizeof dh4096_p, NULL);
2654 g = BN_bin2bn(dh4096_g, sizeof dh4096_g, NULL);
Remi Gacogned3a341a2015-05-29 16:26:17 +02002655
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002656 if (!p || !g) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002657 DH_free(dh);
2658 dh = NULL;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002659 } else {
2660 DH_set0_pqg(dh, p, NULL, g);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002661 }
2662 }
2663 return dh;
2664}
2665
2666/* Returns Diffie-Hellman parameters matching the private key length
Willy Tarreauef934602016-12-22 23:12:01 +01002667 but not exceeding global_ssl.default_dh_param */
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002668static DH *ssl_get_tmp_dh(SSL *ssl, int export, int keylen)
2669{
2670 DH *dh = NULL;
2671 EVP_PKEY *pkey = SSL_get_privatekey(ssl);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02002672 int type;
2673
2674 type = pkey ? EVP_PKEY_base_id(pkey) : EVP_PKEY_NONE;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002675
2676 /* The keylen supplied by OpenSSL can only be 512 or 1024.
2677 See ssl3_send_server_key_exchange() in ssl/s3_srvr.c
2678 */
2679 if (type == EVP_PKEY_RSA || type == EVP_PKEY_DSA) {
2680 keylen = EVP_PKEY_bits(pkey);
2681 }
2682
Willy Tarreauef934602016-12-22 23:12:01 +01002683 if (keylen > global_ssl.default_dh_param) {
2684 keylen = global_ssl.default_dh_param;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002685 }
2686
Remi Gacogned3a341a2015-05-29 16:26:17 +02002687 if (keylen >= 4096) {
Remi Gacogne8de54152014-07-15 11:36:40 +02002688 dh = local_dh_4096;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002689 }
2690 else if (keylen >= 2048) {
Remi Gacogne8de54152014-07-15 11:36:40 +02002691 dh = local_dh_2048;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002692 }
2693 else {
Remi Gacogne8de54152014-07-15 11:36:40 +02002694 dh = local_dh_1024;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002695 }
2696
2697 return dh;
2698}
2699
Remi Gacogne47783ef2015-05-29 15:53:22 +02002700static DH * ssl_sock_get_dh_from_file(const char *filename)
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002701{
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002702 DH *dh = NULL;
Remi Gacogne47783ef2015-05-29 15:53:22 +02002703 BIO *in = BIO_new(BIO_s_file());
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002704
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002705 if (in == NULL)
2706 goto end;
2707
Remi Gacogne47783ef2015-05-29 15:53:22 +02002708 if (BIO_read_filename(in, filename) <= 0)
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002709 goto end;
2710
Remi Gacogne47783ef2015-05-29 15:53:22 +02002711 dh = PEM_read_bio_DHparams(in, NULL, NULL, NULL);
2712
2713end:
2714 if (in)
2715 BIO_free(in);
2716
Emeric Brune1b4ed42018-08-16 15:14:12 +02002717 ERR_clear_error();
2718
Remi Gacogne47783ef2015-05-29 15:53:22 +02002719 return dh;
2720}
2721
2722int ssl_sock_load_global_dh_param_from_file(const char *filename)
2723{
2724 global_dh = ssl_sock_get_dh_from_file(filename);
2725
2726 if (global_dh) {
2727 return 0;
2728 }
2729
2730 return -1;
2731}
2732
Emeric Bruncfc1afe2019-10-17 13:27:40 +02002733/* Loads Diffie-Hellman parameter from a ckchs to an SSL_CTX.
2734 * If there is no DH paramater availaible in the ckchs, the global
2735 * DH parameter is loaded into the SSL_CTX and if there is no
2736 * DH parameter available in ckchs nor in global, the default
2737 * DH parameters are applied on the SSL_CTX.
2738 * Returns a bitfield containing the flags:
2739 * ERR_FATAL in any fatal error case
2740 * ERR_ALERT if a reason of the error is availabine in err
2741 * ERR_WARN if a warning is available into err
2742 * The value 0 means there is no error nor warning and
2743 * the operation succeed.
2744 */
2745static int ssl_sock_load_dh_params(SSL_CTX *ctx, const char *file, char **err)
2746 {
2747 int ret = 0;
Remi Gacogne47783ef2015-05-29 15:53:22 +02002748 DH *dh = ssl_sock_get_dh_from_file(file);
2749
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002750 if (dh) {
Emeric Brund6de1512019-10-17 14:53:03 +02002751 if (!SSL_CTX_set_tmp_dh(ctx, dh)) {
2752 memprintf(err, "%sunable to load the DH parameter specified in '%s'",
2753 err && *err ? *err : "", file);
2754#if defined(SSL_CTX_set_dh_auto)
2755 SSL_CTX_set_dh_auto(ctx, 1);
2756 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
2757 err && *err ? *err : "");
2758#else
2759 memprintf(err, "%s, DH ciphers won't be available.\n",
2760 err && *err ? *err : "");
2761#endif
2762 ret |= ERR_WARN;
2763 goto end;
2764 }
Remi Gacogne4f902b82015-05-28 16:23:00 +02002765
2766 if (ssl_dh_ptr_index >= 0) {
2767 /* store a pointer to the DH params to avoid complaining about
2768 ssl-default-dh-param not being set for this SSL_CTX */
2769 SSL_CTX_set_ex_data(ctx, ssl_dh_ptr_index, dh);
2770 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002771 }
Remi Gacogne47783ef2015-05-29 15:53:22 +02002772 else if (global_dh) {
Emeric Brund6de1512019-10-17 14:53:03 +02002773 if (!SSL_CTX_set_tmp_dh(ctx, global_dh)) {
2774 memprintf(err, "%sunable to use the global DH parameter for certificate '%s'",
2775 err && *err ? *err : "", file);
2776#if defined(SSL_CTX_set_dh_auto)
2777 SSL_CTX_set_dh_auto(ctx, 1);
2778 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
2779 err && *err ? *err : "");
2780#else
2781 memprintf(err, "%s, DH ciphers won't be available.\n",
2782 err && *err ? *err : "");
2783#endif
2784 ret |= ERR_WARN;
2785 goto end;
2786 }
Remi Gacogne47783ef2015-05-29 15:53:22 +02002787 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002788 else {
Emeric Brun41fdb3c2013-04-26 11:05:44 +02002789 /* Clear openssl global errors stack */
2790 ERR_clear_error();
2791
Willy Tarreauef934602016-12-22 23:12:01 +01002792 if (global_ssl.default_dh_param <= 1024) {
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002793 /* we are limited to DH parameter of 1024 bits anyway */
Remi Gacognec7e12632016-07-02 16:26:10 +02002794 if (local_dh_1024 == NULL)
2795 local_dh_1024 = ssl_get_dh_1024();
2796
Emeric Bruncfc1afe2019-10-17 13:27:40 +02002797 if (local_dh_1024 == NULL) {
2798 memprintf(err, "%sunable to load default 1024 bits DH parameter for certificate '%s'.\n",
2799 err && *err ? *err : "", file);
2800 ret |= ERR_ALERT | ERR_FATAL;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002801 goto end;
Emeric Bruncfc1afe2019-10-17 13:27:40 +02002802 }
Willy Tarreau6e774b42014-04-25 21:35:23 +02002803
Emeric Brund6de1512019-10-17 14:53:03 +02002804 if (!SSL_CTX_set_tmp_dh(ctx, local_dh_1024)) {
2805 memprintf(err, "%sunable to load default 1024 bits DH parameter for certificate '%s'.\n",
2806 err && *err ? *err : "", file);
2807#if defined(SSL_CTX_set_dh_auto)
2808 SSL_CTX_set_dh_auto(ctx, 1);
2809 memprintf(err, "%s, SSL library will use an automatically generated DH parameter.\n",
2810 err && *err ? *err : "");
2811#else
2812 memprintf(err, "%s, DH ciphers won't be available.\n",
2813 err && *err ? *err : "");
2814#endif
2815 ret |= ERR_WARN;
2816 goto end;
2817 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02002818 }
2819 else {
2820 SSL_CTX_set_tmp_dh_callback(ctx, ssl_get_tmp_dh);
2821 }
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002822 }
Emeric Brun644cde02012-12-14 11:21:13 +01002823
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002824end:
2825 if (dh)
2826 DH_free(dh);
2827
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02002828 return ret;
2829}
2830#endif
2831
Emmanuel Hocdet05942112017-02-20 16:11:50 +01002832static int ssl_sock_add_cert_sni(SSL_CTX *ctx, struct bind_conf *s, struct ssl_bind_conf *conf,
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002833 struct pkey_info kinfo, char *name, int order)
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01002834{
2835 struct sni_ctx *sc;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002836 int wild = 0, neg = 0;
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002837 struct ebmb_node *node;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01002838
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002839 if (*name == '!') {
2840 neg = 1;
2841 name++;
2842 }
2843 if (*name == '*') {
2844 wild = 1;
2845 name++;
2846 }
2847 /* !* filter is a nop */
2848 if (neg && wild)
2849 return order;
2850 if (*name) {
2851 int j, len;
2852 len = strlen(name);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002853 for (j = 0; j < len && j < trash.size; j++)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002854 trash.area[j] = tolower(name[j]);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002855 if (j >= trash.size)
William Lallemand24e292c2019-10-03 23:46:33 +02002856 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002857 trash.area[j] = 0;
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002858
2859 /* Check for duplicates. */
2860 if (wild)
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002861 node = ebst_lookup(&s->sni_w_ctx, trash.area);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002862 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002863 node = ebst_lookup(&s->sni_ctx, trash.area);
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002864 for (; node; node = ebmb_next_dup(node)) {
2865 sc = ebmb_entry(node, struct sni_ctx, name);
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002866 if (sc->ctx == ctx && sc->conf == conf && sc->neg == neg)
Thierry FOURNIER / OZON.IO07c3d782016-10-06 10:56:48 +02002867 return order;
2868 }
2869
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01002870 sc = malloc(sizeof(struct sni_ctx) + len + 1);
Thierry FOURNIER / OZON.IO7a3bd3b2016-10-06 10:35:29 +02002871 if (!sc)
William Lallemand24e292c2019-10-03 23:46:33 +02002872 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02002873 memcpy(sc->name.key, trash.area, len + 1);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01002874 sc->ctx = ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01002875 sc->conf = conf;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02002876 sc->kinfo = kinfo;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02002877 sc->order = order++;
2878 sc->neg = neg;
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01002879 if (kinfo.sig != TLSEXT_signature_anonymous)
2880 SSL_CTX_set_ex_data(ctx, ssl_pkey_info_index, &sc->kinfo);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01002881 if (wild)
2882 ebst_insert(&s->sni_w_ctx, &sc->name);
2883 else
2884 ebst_insert(&s->sni_ctx, &sc->name);
2885 }
2886 return order;
2887}
2888
yanbzhu488a4d22015-12-01 15:16:07 -05002889
2890/* The following code is used for loading multiple crt files into
2891 * SSL_CTX's based on CN/SAN
2892 */
Willy Tarreau5db847a2019-05-09 14:13:35 +02002893#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu488a4d22015-12-01 15:16:07 -05002894/* This is used to preload the certifcate, private key
2895 * and Cert Chain of a file passed in via the crt
2896 * argument
2897 *
2898 * This way, we do not have to read the file multiple times
2899 */
2900struct cert_key_and_chain {
2901 X509 *cert;
2902 EVP_PKEY *key;
2903 unsigned int num_chain_certs;
2904 /* This is an array of X509 pointers */
2905 X509 **chain_certs;
2906};
2907
yanbzhu08ce6ab2015-12-02 13:01:29 -05002908#define SSL_SOCK_POSSIBLE_KT_COMBOS (1<<(SSL_SOCK_NUM_KEYTYPES))
2909
2910struct key_combo_ctx {
2911 SSL_CTX *ctx;
2912 int order;
2913};
2914
2915/* Map used for processing multiple keypairs for a single purpose
2916 *
2917 * This maps CN/SNI name to certificate type
2918 */
2919struct sni_keytype {
2920 int keytypes; /* BITMASK for keytypes */
2921 struct ebmb_node name; /* node holding the servername value */
2922};
2923
2924
yanbzhu488a4d22015-12-01 15:16:07 -05002925/* Frees the contents of a cert_key_and_chain
2926 */
2927static void ssl_sock_free_cert_key_and_chain_contents(struct cert_key_and_chain *ckch)
2928{
2929 int i;
2930
2931 if (!ckch)
2932 return;
2933
2934 /* Free the certificate and set pointer to NULL */
2935 if (ckch->cert)
2936 X509_free(ckch->cert);
2937 ckch->cert = NULL;
2938
2939 /* Free the key and set pointer to NULL */
2940 if (ckch->key)
2941 EVP_PKEY_free(ckch->key);
2942 ckch->key = NULL;
2943
2944 /* Free each certificate in the chain */
2945 for (i = 0; i < ckch->num_chain_certs; i++) {
2946 if (ckch->chain_certs[i])
2947 X509_free(ckch->chain_certs[i]);
2948 }
2949
2950 /* Free the chain obj itself and set to NULL */
2951 if (ckch->num_chain_certs > 0) {
2952 free(ckch->chain_certs);
2953 ckch->num_chain_certs = 0;
2954 ckch->chain_certs = NULL;
2955 }
2956
2957}
2958
2959/* checks if a key and cert exists in the ckch
2960 */
2961static int ssl_sock_is_ckch_valid(struct cert_key_and_chain *ckch)
2962{
2963 return (ckch->cert != NULL && ckch->key != NULL);
2964}
2965
2966
2967/* Loads the contents of a crt file (path) into a cert_key_and_chain
2968 * This allows us to carry the contents of the file without having to
2969 * read the file multiple times.
2970 *
2971 * returns:
2972 * 0 on Success
2973 * 1 on SSL Failure
2974 * 2 on file not found
2975 */
2976static int ssl_sock_load_crt_file_into_ckch(const char *path, struct cert_key_and_chain *ckch, char **err)
2977{
2978
2979 BIO *in;
2980 X509 *ca = NULL;
2981 int ret = 1;
2982
2983 ssl_sock_free_cert_key_and_chain_contents(ckch);
2984
2985 in = BIO_new(BIO_s_file());
2986 if (in == NULL)
2987 goto end;
2988
2989 if (BIO_read_filename(in, path) <= 0)
2990 goto end;
2991
yanbzhu488a4d22015-12-01 15:16:07 -05002992 /* Read Private Key */
2993 ckch->key = PEM_read_bio_PrivateKey(in, NULL, NULL, NULL);
2994 if (ckch->key == NULL) {
2995 memprintf(err, "%sunable to load private key from file '%s'.\n",
2996 err && *err ? *err : "", path);
2997 goto end;
2998 }
2999
Willy Tarreaubb137a82016-04-06 19:02:38 +02003000 /* Seek back to beginning of file */
Thierry FOURNIER / OZON.IOd44ea3f2016-10-14 00:49:21 +02003001 if (BIO_reset(in) == -1) {
3002 memprintf(err, "%san error occurred while reading the file '%s'.\n",
3003 err && *err ? *err : "", path);
3004 goto end;
3005 }
Willy Tarreaubb137a82016-04-06 19:02:38 +02003006
3007 /* Read Certificate */
3008 ckch->cert = PEM_read_bio_X509_AUX(in, NULL, NULL, NULL);
3009 if (ckch->cert == NULL) {
3010 memprintf(err, "%sunable to load certificate from file '%s'.\n",
3011 err && *err ? *err : "", path);
3012 goto end;
3013 }
3014
yanbzhu488a4d22015-12-01 15:16:07 -05003015 /* Read Certificate Chain */
3016 while ((ca = PEM_read_bio_X509(in, NULL, NULL, NULL))) {
3017 /* Grow the chain certs */
3018 ckch->num_chain_certs++;
3019 ckch->chain_certs = realloc(ckch->chain_certs, (ckch->num_chain_certs * sizeof(X509 *)));
3020
3021 /* use - 1 here since we just incremented it above */
3022 ckch->chain_certs[ckch->num_chain_certs - 1] = ca;
3023 }
3024 ret = ERR_get_error();
3025 if (ret && (ERR_GET_LIB(ret) != ERR_LIB_PEM && ERR_GET_REASON(ret) != PEM_R_NO_START_LINE)) {
3026 memprintf(err, "%sunable to load certificate chain from file '%s'.\n",
3027 err && *err ? *err : "", path);
3028 ret = 1;
3029 goto end;
3030 }
3031
3032 ret = 0;
3033
3034end:
3035
3036 ERR_clear_error();
3037 if (in)
3038 BIO_free(in);
3039
3040 /* Something went wrong in one of the reads */
3041 if (ret != 0)
3042 ssl_sock_free_cert_key_and_chain_contents(ckch);
3043
3044 return ret;
3045}
3046
3047/* Loads the info in ckch into ctx
Emeric Brun394701d2019-10-17 13:25:14 +02003048 * Returns a bitfield containing the flags:
3049 * ERR_FATAL in any fatal error case
3050 * ERR_ALERT if the reason of the error is available in err
3051 * ERR_WARN if a warning is available into err
3052 * The value 0 means there is no error nor warning and
3053 * the operation succeed.
yanbzhu488a4d22015-12-01 15:16:07 -05003054 */
3055static int ssl_sock_put_ckch_into_ctx(const char *path, const struct cert_key_and_chain *ckch, SSL_CTX *ctx, char **err)
3056{
3057 int i = 0;
Emeric Brun394701d2019-10-17 13:25:14 +02003058 int errcode = 0;
yanbzhu488a4d22015-12-01 15:16:07 -05003059
3060 if (SSL_CTX_use_PrivateKey(ctx, ckch->key) <= 0) {
3061 memprintf(err, "%sunable to load SSL private key into SSL Context '%s'.\n",
3062 err && *err ? *err : "", path);
Emeric Brun394701d2019-10-17 13:25:14 +02003063 errcode |= ERR_ALERT | ERR_FATAL;
3064 return errcode;
yanbzhu488a4d22015-12-01 15:16:07 -05003065 }
3066
3067 if (!SSL_CTX_use_certificate(ctx, ckch->cert)) {
3068 memprintf(err, "%sunable to load SSL certificate into SSL Context '%s'.\n",
3069 err && *err ? *err : "", path);
Emeric Brun394701d2019-10-17 13:25:14 +02003070 errcode |= ERR_ALERT | ERR_FATAL;
3071 goto end;
yanbzhu488a4d22015-12-01 15:16:07 -05003072 }
3073
yanbzhu488a4d22015-12-01 15:16:07 -05003074 /* Load all certs in the ckch into the ctx_chain for the ssl_ctx */
3075 for (i = 0; i < ckch->num_chain_certs; i++) {
3076 if (!SSL_CTX_add1_chain_cert(ctx, ckch->chain_certs[i])) {
yanbzhu08ce6ab2015-12-02 13:01:29 -05003077 memprintf(err, "%sunable to load chain certificate #%d into SSL Context '%s'. Make sure you are linking against Openssl >= 1.0.2.\n",
3078 err && *err ? *err : "", (i+1), path);
Emeric Brun394701d2019-10-17 13:25:14 +02003079 errcode |= ERR_ALERT | ERR_FATAL;
3080 goto end;
yanbzhu488a4d22015-12-01 15:16:07 -05003081 }
3082 }
3083
3084 if (SSL_CTX_check_private_key(ctx) <= 0) {
3085 memprintf(err, "%sinconsistencies between private key and certificate loaded from PEM file '%s'.\n",
3086 err && *err ? *err : "", path);
Emeric Brun394701d2019-10-17 13:25:14 +02003087 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu488a4d22015-12-01 15:16:07 -05003088 }
3089
Emeric Brun394701d2019-10-17 13:25:14 +02003090 end:
3091 return errcode;
yanbzhu488a4d22015-12-01 15:16:07 -05003092}
3093
yanbzhu08ce6ab2015-12-02 13:01:29 -05003094
William Lallemand4801c702019-10-04 17:36:55 +02003095static int ssl_sock_populate_sni_keytypes_hplr(const char *str, struct eb_root *sni_keytypes, int key_index)
yanbzhu08ce6ab2015-12-02 13:01:29 -05003096{
3097 struct sni_keytype *s_kt = NULL;
3098 struct ebmb_node *node;
3099 int i;
3100
3101 for (i = 0; i < trash.size; i++) {
3102 if (!str[i])
3103 break;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003104 trash.area[i] = tolower(str[i]);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003105 }
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003106 trash.area[i] = 0;
3107 node = ebst_lookup(sni_keytypes, trash.area);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003108 if (!node) {
3109 /* CN not found in tree */
3110 s_kt = malloc(sizeof(struct sni_keytype) + i + 1);
3111 /* Using memcpy here instead of strncpy.
3112 * strncpy will cause sig_abrt errors under certain versions of gcc with -O2
3113 * See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60792
3114 */
William Lallemand4801c702019-10-04 17:36:55 +02003115 if (!s_kt)
3116 return -1;
3117
Willy Tarreau843b7cb2018-07-13 10:54:26 +02003118 memcpy(s_kt->name.key, trash.area, i+1);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003119 s_kt->keytypes = 0;
3120 ebst_insert(sni_keytypes, &s_kt->name);
3121 } else {
3122 /* CN found in tree */
3123 s_kt = container_of(node, struct sni_keytype, name);
3124 }
3125
3126 /* Mark that this CN has the keytype of key_index via keytypes mask */
3127 s_kt->keytypes |= 1<<key_index;
3128
William Lallemand4801c702019-10-04 17:36:55 +02003129 return 0;
3130
yanbzhu08ce6ab2015-12-02 13:01:29 -05003131}
3132
3133
3134/* Given a path that does not exist, try to check for path.rsa, path.dsa and path.ecdsa files.
3135 * If any are found, group these files into a set of SSL_CTX*
3136 * based on shared and unique CN and SAN entries. Add these SSL_CTX* to the SNI tree.
3137 *
Joseph Herlant017b3da2018-11-15 09:07:59 -08003138 * This will allow the user to explicitly group multiple cert/keys for a single purpose
yanbzhu08ce6ab2015-12-02 13:01:29 -05003139 *
Willy Tarreaub131c872019-10-16 16:42:19 +02003140 * Returns a set of ERR_* flags possibly with an error in <err>.
3141 *
yanbzhu08ce6ab2015-12-02 13:01:29 -05003142 */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003143static int ssl_sock_load_multi_cert(const char *path, struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
3144 char **sni_filter, int fcount, char **err)
yanbzhu08ce6ab2015-12-02 13:01:29 -05003145{
3146 char fp[MAXPATHLEN+1] = {0};
3147 int n = 0;
3148 int i = 0;
3149 struct cert_key_and_chain certs_and_keys[SSL_SOCK_NUM_KEYTYPES] = { {0} };
3150 struct eb_root sni_keytypes_map = { {0} };
3151 struct ebmb_node *node;
3152 struct ebmb_node *next;
3153 /* Array of SSL_CTX pointers corresponding to each possible combo
3154 * of keytypes
3155 */
3156 struct key_combo_ctx key_combos[SSL_SOCK_POSSIBLE_KT_COMBOS] = { {0} };
Willy Tarreaub131c872019-10-16 16:42:19 +02003157 int errcode = 0;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003158 X509_NAME *xname = NULL;
3159 char *str = NULL;
3160#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
3161 STACK_OF(GENERAL_NAME) *names = NULL;
3162#endif
3163
3164 /* Load all possible certs and keys */
3165 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
3166 struct stat buf;
3167
3168 snprintf(fp, sizeof(fp), "%s.%s", path, SSL_SOCK_KEYTYPE_NAMES[n]);
3169 if (stat(fp, &buf) == 0) {
3170 if (ssl_sock_load_crt_file_into_ckch(fp, &certs_and_keys[n], err) == 1) {
Willy Tarreaub131c872019-10-16 16:42:19 +02003171 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003172 goto end;
3173 }
3174 }
3175 }
3176
3177 /* Process each ckch and update keytypes for each CN/SAN
3178 * for example, if CN/SAN www.a.com is associated with
3179 * certs with keytype 0 and 2, then at the end of the loop,
3180 * www.a.com will have:
3181 * keyindex = 0 | 1 | 4 = 5
3182 */
3183 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
William Lallemand4801c702019-10-04 17:36:55 +02003184 int ret;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003185
3186 if (!ssl_sock_is_ckch_valid(&certs_and_keys[n]))
3187 continue;
3188
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003189 if (fcount) {
William Lallemand4801c702019-10-04 17:36:55 +02003190 for (i = 0; i < fcount; i++) {
3191 ret = ssl_sock_populate_sni_keytypes_hplr(sni_filter[i], &sni_keytypes_map, n);
3192 if (ret < 0) {
3193 memprintf(err, "%sunable to allocate SSL context.\n",
3194 err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003195 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand4801c702019-10-04 17:36:55 +02003196 goto end;
3197 }
3198 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003199 } else {
3200 /* A lot of the following code is OpenSSL boilerplate for processing CN's and SAN's,
3201 * so the line that contains logic is marked via comments
3202 */
3203 xname = X509_get_subject_name(certs_and_keys[n].cert);
3204 i = -1;
3205 while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
3206 X509_NAME_ENTRY *entry = X509_NAME_get_entry(xname, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003207 ASN1_STRING *value;
3208 value = X509_NAME_ENTRY_get_data(entry);
3209 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003210 /* Important line is here */
William Lallemand4801c702019-10-04 17:36:55 +02003211 ret = ssl_sock_populate_sni_keytypes_hplr(str, &sni_keytypes_map, n);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003212
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003213 OPENSSL_free(str);
3214 str = NULL;
William Lallemand4801c702019-10-04 17:36:55 +02003215 if (ret < 0) {
3216 memprintf(err, "%sunable to allocate SSL context.\n",
3217 err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003218 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand4801c702019-10-04 17:36:55 +02003219 goto end;
3220 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003221 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003222 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003223
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003224 /* Do the above logic for each SAN */
yanbzhu08ce6ab2015-12-02 13:01:29 -05003225#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003226 names = X509_get_ext_d2i(certs_and_keys[n].cert, NID_subject_alt_name, NULL, NULL);
3227 if (names) {
3228 for (i = 0; i < sk_GENERAL_NAME_num(names); i++) {
3229 GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003230
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003231 if (name->type == GEN_DNS) {
3232 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
3233 /* Important line is here */
William Lallemand4801c702019-10-04 17:36:55 +02003234 ret = ssl_sock_populate_sni_keytypes_hplr(str, &sni_keytypes_map, n);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003235
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003236 OPENSSL_free(str);
3237 str = NULL;
William Lallemand4801c702019-10-04 17:36:55 +02003238 if (ret < 0) {
3239 memprintf(err, "%sunable to allocate SSL context.\n",
3240 err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003241 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand4801c702019-10-04 17:36:55 +02003242 goto end;
3243 }
Emmanuel Hocdetd294aea2016-05-13 11:14:06 +02003244 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003245 }
3246 }
3247 }
3248 }
3249#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
3250 }
3251
3252 /* If no files found, return error */
3253 if (eb_is_empty(&sni_keytypes_map)) {
3254 memprintf(err, "%sunable to load SSL certificate file '%s' file does not exist.\n",
3255 err && *err ? *err : "", path);
Willy Tarreaub131c872019-10-16 16:42:19 +02003256 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003257 goto end;
3258 }
3259
3260 /* We now have a map of CN/SAN to keytypes that are loaded in
3261 * Iterate through the map to create the SSL_CTX's (if needed)
3262 * and add each CTX to the SNI tree
3263 *
3264 * Some math here:
Joseph Herlant017b3da2018-11-15 09:07:59 -08003265 * There are 2^n - 1 possible combinations, each unique
yanbzhu08ce6ab2015-12-02 13:01:29 -05003266 * combination is denoted by the key in the map. Each key
3267 * has a value between 1 and 2^n - 1. Conveniently, the array
3268 * of SSL_CTX* is sized 2^n. So, we can simply use the i'th
3269 * entry in the array to correspond to the unique combo (key)
3270 * associated with i. This unique key combo (i) will be associated
3271 * with combos[i-1]
3272 */
3273
3274 node = ebmb_first(&sni_keytypes_map);
3275 while (node) {
3276 SSL_CTX *cur_ctx;
Bertrand Jacquin33423092016-11-13 16:37:13 +00003277 char cur_file[MAXPATHLEN+1];
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003278 const struct pkey_info kinfo = { .sig = TLSEXT_signature_anonymous, .bits = 0 };
yanbzhu08ce6ab2015-12-02 13:01:29 -05003279
3280 str = (char *)container_of(node, struct sni_keytype, name)->name.key;
3281 i = container_of(node, struct sni_keytype, name)->keytypes;
3282 cur_ctx = key_combos[i-1].ctx;
3283
3284 if (cur_ctx == NULL) {
3285 /* need to create SSL_CTX */
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01003286 cur_ctx = SSL_CTX_new(SSLv23_server_method());
yanbzhu08ce6ab2015-12-02 13:01:29 -05003287 if (cur_ctx == NULL) {
3288 memprintf(err, "%sunable to allocate SSL context.\n",
3289 err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003290 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003291 goto end;
3292 }
3293
yanbzhube2774d2015-12-10 15:07:30 -05003294 /* Load all required certs/keys/chains/OCSPs info into SSL_CTX */
yanbzhu08ce6ab2015-12-02 13:01:29 -05003295 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++) {
3296 if (i & (1<<n)) {
3297 /* Key combo contains ckch[n] */
Bertrand Jacquin33423092016-11-13 16:37:13 +00003298 snprintf(cur_file, MAXPATHLEN+1, "%s.%s", path, SSL_SOCK_KEYTYPE_NAMES[n]);
Emeric Brun394701d2019-10-17 13:25:14 +02003299 errcode |= ssl_sock_put_ckch_into_ctx(cur_file, &certs_and_keys[n], cur_ctx, err);
3300 if (errcode & ERR_CODE) {
yanbzhu08ce6ab2015-12-02 13:01:29 -05003301 SSL_CTX_free(cur_ctx);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003302 goto end;
3303 }
yanbzhube2774d2015-12-10 15:07:30 -05003304
3305#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
3306 /* Load OCSP Info into context */
Bertrand Jacquin33423092016-11-13 16:37:13 +00003307 if (ssl_sock_load_ocsp(cur_ctx, cur_file) < 0) {
yanbzhube2774d2015-12-10 15:07:30 -05003308 if (err)
3309 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",
Bertrand Jacquin5424ee02016-11-13 16:37:14 +00003310 *err ? *err : "", cur_file);
yanbzhube2774d2015-12-10 15:07:30 -05003311 SSL_CTX_free(cur_ctx);
Willy Tarreaub131c872019-10-16 16:42:19 +02003312 errcode |= ERR_ALERT | ERR_FATAL;
yanbzhube2774d2015-12-10 15:07:30 -05003313 goto end;
3314 }
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02003315#elif (defined OPENSSL_IS_BORINGSSL)
3316 ssl_sock_set_ocsp_response_from_file(cur_ctx, cur_file);
yanbzhube2774d2015-12-10 15:07:30 -05003317#endif
yanbzhu08ce6ab2015-12-02 13:01:29 -05003318 }
3319 }
3320
3321 /* Load DH params into the ctx to support DHE keys */
3322#ifndef OPENSSL_NO_DH
3323 if (ssl_dh_ptr_index >= 0)
3324 SSL_CTX_set_ex_data(cur_ctx, ssl_dh_ptr_index, NULL);
3325
Emeric Bruncfc1afe2019-10-17 13:27:40 +02003326 errcode |= ssl_sock_load_dh_params(cur_ctx, NULL, err);
3327 if (errcode & ERR_CODE) {
yanbzhu08ce6ab2015-12-02 13:01:29 -05003328 if (err)
3329 memprintf(err, "%sunable to load DH parameters from file '%s'.\n",
3330 *err ? *err : "", path);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003331 goto end;
3332 }
3333#endif
3334
3335 /* Update key_combos */
3336 key_combos[i-1].ctx = cur_ctx;
3337 }
3338
3339 /* Update SNI Tree */
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003340 key_combos[i-1].order = ssl_sock_add_cert_sni(cur_ctx, bind_conf, ssl_conf,
William Lallemand24e292c2019-10-03 23:46:33 +02003341 kinfo, str, key_combos[i-1].order);
3342 if (key_combos[i-1].order < 0) {
3343 memprintf(err, "%sunable to create a sni context.\n", err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003344 errcode |= ERR_ALERT | ERR_FATAL;
William Lallemand24e292c2019-10-03 23:46:33 +02003345 goto end;
3346 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003347 node = ebmb_next(node);
3348 }
3349
3350
3351 /* Mark a default context if none exists, using the ctx that has the most shared keys */
3352 if (!bind_conf->default_ctx) {
3353 for (i = SSL_SOCK_POSSIBLE_KT_COMBOS - 1; i >= 0; i--) {
3354 if (key_combos[i].ctx) {
3355 bind_conf->default_ctx = key_combos[i].ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003356 bind_conf->default_ssl_conf = ssl_conf;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003357 break;
3358 }
3359 }
3360 }
3361
3362end:
3363
3364 if (names)
3365 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
3366
3367 for (n = 0; n < SSL_SOCK_NUM_KEYTYPES; n++)
3368 ssl_sock_free_cert_key_and_chain_contents(&certs_and_keys[n]);
3369
3370 node = ebmb_first(&sni_keytypes_map);
3371 while (node) {
3372 next = ebmb_next(node);
3373 ebmb_delete(node);
William Lallemande92c0302019-10-04 17:24:39 +02003374 free(ebmb_entry(node, struct sni_keytype, name));
yanbzhu08ce6ab2015-12-02 13:01:29 -05003375 node = next;
3376 }
3377
Willy Tarreaub131c872019-10-16 16:42:19 +02003378 return errcode;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003379}
3380#else
3381/* This is a dummy, that just logs an error and returns error */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003382static int ssl_sock_load_multi_cert(const char *path, struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
3383 char **sni_filter, int fcount, char **err)
yanbzhu08ce6ab2015-12-02 13:01:29 -05003384{
3385 memprintf(err, "%sunable to stat SSL certificate from file '%s' : %s.\n",
3386 err && *err ? *err : "", path, strerror(errno));
3387 return 1;
3388}
3389
Willy Tarreau9a1ab082019-05-09 13:26:41 +02003390#endif /* #if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL: Support for loading multiple certs into a single SSL_CTX */
yanbzhu488a4d22015-12-01 15:16:07 -05003391
Emeric Brunfc0421f2012-09-07 17:30:07 +02003392/* Loads a certificate key and CA chain from a file. Returns 0 on error, -1 if
3393 * an early error happens and the caller must call SSL_CTX_free() by itelf.
3394 */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003395static int ssl_sock_load_cert_chain_file(SSL_CTX *ctx, const char *file, struct bind_conf *s,
3396 struct ssl_bind_conf *ssl_conf, char **sni_filter, int fcount)
Emeric Brunfc0421f2012-09-07 17:30:07 +02003397{
3398 BIO *in;
3399 X509 *x = NULL, *ca;
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02003400 int i, err;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003401 int ret = -1;
3402 int order = 0;
3403 X509_NAME *xname;
3404 char *str;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003405 pem_password_cb *passwd_cb;
3406 void *passwd_cb_userdata;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003407 EVP_PKEY *pkey;
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003408 struct pkey_info kinfo = { .sig = TLSEXT_signature_anonymous, .bits = 0 };
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003409
Emeric Brunfc0421f2012-09-07 17:30:07 +02003410#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
3411 STACK_OF(GENERAL_NAME) *names;
3412#endif
3413
3414 in = BIO_new(BIO_s_file());
3415 if (in == NULL)
3416 goto end;
3417
3418 if (BIO_read_filename(in, file) <= 0)
3419 goto end;
3420
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003421
3422 passwd_cb = SSL_CTX_get_default_passwd_cb(ctx);
3423 passwd_cb_userdata = SSL_CTX_get_default_passwd_cb_userdata(ctx);
3424
3425 x = PEM_read_bio_X509_AUX(in, NULL, passwd_cb, passwd_cb_userdata);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003426 if (x == NULL)
3427 goto end;
3428
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003429 pkey = X509_get_pubkey(x);
3430 if (pkey) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003431 kinfo.bits = EVP_PKEY_bits(pkey);
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003432 switch(EVP_PKEY_base_id(pkey)) {
3433 case EVP_PKEY_RSA:
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003434 kinfo.sig = TLSEXT_signature_rsa;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003435 break;
3436 case EVP_PKEY_EC:
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003437 kinfo.sig = TLSEXT_signature_ecdsa;
3438 break;
3439 case EVP_PKEY_DSA:
3440 kinfo.sig = TLSEXT_signature_dsa;
Emmanuel Hocdet05942112017-02-20 16:11:50 +01003441 break;
3442 }
3443 EVP_PKEY_free(pkey);
3444 }
3445
Emeric Brun50bcecc2013-04-22 13:05:23 +02003446 if (fcount) {
William Lallemand24e292c2019-10-03 23:46:33 +02003447 while (fcount--) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003448 order = ssl_sock_add_cert_sni(ctx, s, ssl_conf, kinfo, sni_filter[fcount], order);
William Lallemand24e292c2019-10-03 23:46:33 +02003449 if (order < 0)
3450 goto end;
3451 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003452 }
3453 else {
Emeric Brunfc0421f2012-09-07 17:30:07 +02003454#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003455 names = X509_get_ext_d2i(x, NID_subject_alt_name, NULL, NULL);
3456 if (names) {
3457 for (i = 0; i < sk_GENERAL_NAME_num(names); i++) {
3458 GENERAL_NAME *name = sk_GENERAL_NAME_value(names, i);
3459 if (name->type == GEN_DNS) {
3460 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003461 order = ssl_sock_add_cert_sni(ctx, s, ssl_conf, kinfo, str, order);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003462 OPENSSL_free(str);
William Lallemand24e292c2019-10-03 23:46:33 +02003463 if (order < 0)
3464 goto end;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003465 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02003466 }
3467 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003468 sk_GENERAL_NAME_pop_free(names, GENERAL_NAME_free);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003469 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02003470#endif /* SSL_CTRL_SET_TLSEXT_HOSTNAME */
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003471 xname = X509_get_subject_name(x);
3472 i = -1;
3473 while ((i = X509_NAME_get_index_by_NID(xname, NID_commonName, i)) != -1) {
3474 X509_NAME_ENTRY *entry = X509_NAME_get_entry(xname, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003475 ASN1_STRING *value;
3476
3477 value = X509_NAME_ENTRY_get_data(entry);
3478 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
Emmanuel Hocdetddc090b2017-10-27 18:43:29 +02003479 order = ssl_sock_add_cert_sni(ctx, s, ssl_conf, kinfo, str, order);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003480 OPENSSL_free(str);
William Lallemand24e292c2019-10-03 23:46:33 +02003481 if (order < 0)
3482 goto end;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003483 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02003484 }
3485 }
3486
3487 ret = 0; /* the caller must not free the SSL_CTX argument anymore */
3488 if (!SSL_CTX_use_certificate(ctx, x))
3489 goto end;
3490
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003491#ifdef SSL_CTX_clear_extra_chain_certs
3492 SSL_CTX_clear_extra_chain_certs(ctx);
3493#else
Emeric Brunfc0421f2012-09-07 17:30:07 +02003494 if (ctx->extra_certs != NULL) {
3495 sk_X509_pop_free(ctx->extra_certs, X509_free);
3496 ctx->extra_certs = NULL;
3497 }
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003498#endif
Emeric Brunfc0421f2012-09-07 17:30:07 +02003499
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02003500 while ((ca = PEM_read_bio_X509(in, NULL, passwd_cb, passwd_cb_userdata))) {
Emeric Brunfc0421f2012-09-07 17:30:07 +02003501 if (!SSL_CTX_add_extra_chain_cert(ctx, ca)) {
3502 X509_free(ca);
3503 goto end;
3504 }
3505 }
3506
3507 err = ERR_get_error();
3508 if (!err || (ERR_GET_LIB(err) == ERR_LIB_PEM && ERR_GET_REASON(err) == PEM_R_NO_START_LINE)) {
3509 /* we successfully reached the last cert in the file */
3510 ret = 1;
3511 }
3512 ERR_clear_error();
3513
3514end:
3515 if (x)
3516 X509_free(x);
3517
3518 if (in)
3519 BIO_free(in);
3520
3521 return ret;
3522}
3523
Willy Tarreaub131c872019-10-16 16:42:19 +02003524/* Returns a set of ERR_* flags possibly with an error in <err>. */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003525static int ssl_sock_load_cert_file(const char *path, struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf,
3526 char **sni_filter, int fcount, char **err)
Emeric Brunfc0421f2012-09-07 17:30:07 +02003527{
Emeric Bruncfc1afe2019-10-17 13:27:40 +02003528 int errcode = 0;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003529 int ret;
3530 SSL_CTX *ctx;
3531
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01003532 ctx = SSL_CTX_new(SSLv23_server_method());
Emeric Brunfc0421f2012-09-07 17:30:07 +02003533 if (!ctx) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003534 memprintf(err, "%sunable to allocate SSL context for cert '%s'.\n",
3535 err && *err ? *err : "", path);
Willy Tarreaub131c872019-10-16 16:42:19 +02003536 return ERR_ALERT | ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003537 }
3538
3539 if (SSL_CTX_use_PrivateKey_file(ctx, path, SSL_FILETYPE_PEM) <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003540 memprintf(err, "%sunable to load SSL private key from PEM file '%s'.\n",
3541 err && *err ? *err : "", path);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003542 SSL_CTX_free(ctx);
Willy Tarreaub131c872019-10-16 16:42:19 +02003543 return ERR_ALERT | ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003544 }
3545
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003546 ret = ssl_sock_load_cert_chain_file(ctx, path, bind_conf, ssl_conf, sni_filter, fcount);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003547 if (ret <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003548 memprintf(err, "%sunable to load SSL certificate from PEM file '%s'.\n",
3549 err && *err ? *err : "", path);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003550 if (ret < 0) /* serious error, must do that ourselves */
3551 SSL_CTX_free(ctx);
Willy Tarreaub131c872019-10-16 16:42:19 +02003552 return ERR_ALERT | ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003553 }
Emeric Brun61694ab2012-10-26 13:35:33 +02003554
3555 if (SSL_CTX_check_private_key(ctx) <= 0) {
3556 memprintf(err, "%sinconsistencies between private key and certificate loaded from PEM file '%s'.\n",
3557 err && *err ? *err : "", path);
Willy Tarreaub131c872019-10-16 16:42:19 +02003558 return ERR_ALERT | ERR_FATAL;
Emeric Brun61694ab2012-10-26 13:35:33 +02003559 }
3560
Emeric Brunfc0421f2012-09-07 17:30:07 +02003561 /* we must not free the SSL_CTX anymore below, since it's already in
3562 * the tree, so it will be discovered and cleaned in time.
3563 */
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02003564#ifndef OPENSSL_NO_DH
Remi Gacogne4f902b82015-05-28 16:23:00 +02003565 /* store a NULL pointer to indicate we have not yet loaded
3566 a custom DH param file */
3567 if (ssl_dh_ptr_index >= 0) {
3568 SSL_CTX_set_ex_data(ctx, ssl_dh_ptr_index, NULL);
3569 }
3570
Emeric Bruncfc1afe2019-10-17 13:27:40 +02003571 errcode |= ssl_sock_load_dh_params(ctx, path, err);
3572 if (errcode & ERR_CODE) {
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02003573 if (err)
3574 memprintf(err, "%sunable to load DH parameters from file '%s'.\n",
3575 *err ? *err : "", path);
Emeric Bruncfc1afe2019-10-17 13:27:40 +02003576 return errcode;
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02003577 }
3578#endif
3579
Lukas Tribuse4e30f72014-12-09 16:32:51 +01003580#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
Emeric Brun4147b2e2014-06-16 18:36:30 +02003581 ret = ssl_sock_load_ocsp(ctx, path);
3582 if (ret < 0) {
3583 if (err)
3584 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",
3585 *err ? *err : "", path);
Willy Tarreaub131c872019-10-16 16:42:19 +02003586 return ERR_ALERT | ERR_FATAL;
Emeric Brun4147b2e2014-06-16 18:36:30 +02003587 }
Emmanuel Hocdet2c32d8f2017-05-22 14:58:00 +02003588#elif (defined OPENSSL_IS_BORINGSSL)
3589 ssl_sock_set_ocsp_response_from_file(ctx, path);
Emeric Brun4147b2e2014-06-16 18:36:30 +02003590#endif
3591
Willy Tarreau5db847a2019-05-09 14:13:35 +02003592#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01003593 if (sctl_ex_index >= 0) {
3594 ret = ssl_sock_load_sctl(ctx, path);
3595 if (ret < 0) {
3596 if (err)
3597 memprintf(err, "%s '%s.sctl' is present but cannot be read or parsed'.\n",
3598 *err ? *err : "", path);
Willy Tarreaub131c872019-10-16 16:42:19 +02003599 return ERR_ALERT | ERR_FATAL;
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +01003600 }
3601 }
3602#endif
3603
Emeric Brunfc0421f2012-09-07 17:30:07 +02003604#ifndef SSL_CTRL_SET_TLSEXT_HOSTNAME
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003605 if (bind_conf->default_ctx) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02003606 memprintf(err, "%sthis version of openssl cannot load multiple SSL certificates.\n",
3607 err && *err ? *err : "");
Willy Tarreaub131c872019-10-16 16:42:19 +02003608 return ERR_ALERT | ERR_FATAL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003609 }
3610#endif
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003611 if (!bind_conf->default_ctx) {
Willy Tarreau2a65ff02012-09-13 17:54:29 +02003612 bind_conf->default_ctx = ctx;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003613 bind_conf->default_ssl_conf = ssl_conf;
3614 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02003615
Emeric Bruncfc1afe2019-10-17 13:27:40 +02003616 return errcode;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003617}
3618
Willy Tarreaub131c872019-10-16 16:42:19 +02003619
3620/* Returns a set of ERR_* flags possibly with an error in <err>. */
Willy Tarreau03209342016-12-22 17:08:28 +01003621int ssl_sock_load_cert(char *path, struct bind_conf *bind_conf, char **err)
Emeric Brunfc0421f2012-09-07 17:30:07 +02003622{
Cyril Bonté3180f7b2015-01-25 00:16:08 +01003623 struct dirent **de_list;
3624 int i, n;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003625 DIR *dir;
3626 struct stat buf;
Willy Tarreauee2663b2012-12-06 11:36:59 +01003627 char *end;
3628 char fp[MAXPATHLEN+1];
Emeric Brunfc0421f2012-09-07 17:30:07 +02003629 int cfgerr = 0;
Willy Tarreau9a1ab082019-05-09 13:26:41 +02003630#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu63ea8462015-12-09 13:35:14 -05003631 int is_bundle;
3632 int j;
3633#endif
Emeric Brunfc0421f2012-09-07 17:30:07 +02003634
yanbzhu08ce6ab2015-12-02 13:01:29 -05003635 if (stat(path, &buf) == 0) {
3636 dir = opendir(path);
3637 if (!dir)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003638 return ssl_sock_load_cert_file(path, bind_conf, NULL, NULL, 0, err);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003639
yanbzhu08ce6ab2015-12-02 13:01:29 -05003640 /* strip trailing slashes, including first one */
3641 for (end = path + strlen(path) - 1; end >= path && *end == '/'; end--)
3642 *end = 0;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003643
yanbzhu08ce6ab2015-12-02 13:01:29 -05003644 n = scandir(path, &de_list, 0, alphasort);
3645 if (n < 0) {
3646 memprintf(err, "%sunable to scan directory '%s' : %s.\n",
3647 err && *err ? *err : "", path, strerror(errno));
Willy Tarreaub131c872019-10-16 16:42:19 +02003648 cfgerr |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003649 }
3650 else {
3651 for (i = 0; i < n; i++) {
3652 struct dirent *de = de_list[i];
Emeric Brun2aab7222014-06-18 18:15:09 +02003653
yanbzhu08ce6ab2015-12-02 13:01:29 -05003654 end = strrchr(de->d_name, '.');
3655 if (end && (!strcmp(end, ".issuer") || !strcmp(end, ".ocsp") || !strcmp(end, ".sctl")))
3656 goto ignore_entry;
Cyril Bonté3180f7b2015-01-25 00:16:08 +01003657
yanbzhu08ce6ab2015-12-02 13:01:29 -05003658 snprintf(fp, sizeof(fp), "%s/%s", path, de->d_name);
3659 if (stat(fp, &buf) != 0) {
3660 memprintf(err, "%sunable to stat SSL certificate from file '%s' : %s.\n",
3661 err && *err ? *err : "", fp, strerror(errno));
Willy Tarreaub131c872019-10-16 16:42:19 +02003662 cfgerr |= ERR_ALERT | ERR_FATAL;
yanbzhu08ce6ab2015-12-02 13:01:29 -05003663 goto ignore_entry;
3664 }
3665 if (!S_ISREG(buf.st_mode))
3666 goto ignore_entry;
yanbzhu63ea8462015-12-09 13:35:14 -05003667
Willy Tarreau9a1ab082019-05-09 13:26:41 +02003668#if HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL
yanbzhu63ea8462015-12-09 13:35:14 -05003669 is_bundle = 0;
3670 /* Check if current entry in directory is part of a multi-cert bundle */
3671
3672 if (end) {
3673 for (j = 0; j < SSL_SOCK_NUM_KEYTYPES; j++) {
3674 if (!strcmp(end + 1, SSL_SOCK_KEYTYPE_NAMES[j])) {
3675 is_bundle = 1;
3676 break;
3677 }
3678 }
3679
3680 if (is_bundle) {
yanbzhu63ea8462015-12-09 13:35:14 -05003681 int dp_len;
3682
3683 dp_len = end - de->d_name;
yanbzhu63ea8462015-12-09 13:35:14 -05003684
3685 /* increment i and free de until we get to a non-bundle cert
3686 * Note here that we look at de_list[i + 1] before freeing de
Willy Tarreau5b8a8652019-10-29 10:48:50 +01003687 * this is important since ignore_entry will free de. This also
3688 * guarantees that de->d_name continues to hold the same prefix.
yanbzhu63ea8462015-12-09 13:35:14 -05003689 */
Willy Tarreau5b8a8652019-10-29 10:48:50 +01003690 while (i + 1 < n && !strncmp(de_list[i + 1]->d_name, de->d_name, dp_len)) {
yanbzhu63ea8462015-12-09 13:35:14 -05003691 free(de);
3692 i++;
3693 de = de_list[i];
3694 }
3695
Willy Tarreau5b8a8652019-10-29 10:48:50 +01003696 snprintf(fp, sizeof(fp), "%s/%.*s", path, dp_len, de->d_name);
Willy Tarreaub131c872019-10-16 16:42:19 +02003697 cfgerr |= ssl_sock_load_multi_cert(fp, bind_conf, NULL, NULL, 0, err);
yanbzhu63ea8462015-12-09 13:35:14 -05003698 /* Successfully processed the bundle */
3699 goto ignore_entry;
3700 }
3701 }
3702
3703#endif
Willy Tarreaub131c872019-10-16 16:42:19 +02003704 cfgerr |= ssl_sock_load_cert_file(fp, bind_conf, NULL, NULL, 0, err);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003705ignore_entry:
3706 free(de);
Cyril Bonté3180f7b2015-01-25 00:16:08 +01003707 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003708 free(de_list);
Emeric Brunfc0421f2012-09-07 17:30:07 +02003709 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003710 closedir(dir);
3711 return cfgerr;
Emeric Brunfc0421f2012-09-07 17:30:07 +02003712 }
yanbzhu08ce6ab2015-12-02 13:01:29 -05003713
Willy Tarreaub131c872019-10-16 16:42:19 +02003714 cfgerr |= ssl_sock_load_multi_cert(path, bind_conf, NULL, NULL, 0, err);
yanbzhu08ce6ab2015-12-02 13:01:29 -05003715
Emeric Brunfc0421f2012-09-07 17:30:07 +02003716 return cfgerr;
3717}
3718
Thierry Fournier383085f2013-01-24 14:15:43 +01003719/* Make sure openssl opens /dev/urandom before the chroot. The work is only
3720 * done once. Zero is returned if the operation fails. No error is returned
3721 * if the random is said as not implemented, because we expect that openssl
3722 * will use another method once needed.
3723 */
3724static int ssl_initialize_random()
3725{
3726 unsigned char random;
3727 static int random_initialized = 0;
3728
3729 if (!random_initialized && RAND_bytes(&random, 1) != 0)
3730 random_initialized = 1;
3731
3732 return random_initialized;
3733}
3734
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003735/* release ssl bind conf */
3736void ssl_sock_free_ssl_conf(struct ssl_bind_conf *conf)
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003737{
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003738 if (conf) {
Bernard Spil13c53f82018-02-15 13:34:58 +01003739#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003740 free(conf->npn_str);
3741 conf->npn_str = NULL;
3742#endif
3743#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
3744 free(conf->alpn_str);
3745 conf->alpn_str = NULL;
3746#endif
3747 free(conf->ca_file);
3748 conf->ca_file = NULL;
3749 free(conf->crl_file);
3750 conf->crl_file = NULL;
3751 free(conf->ciphers);
3752 conf->ciphers = NULL;
Emmanuel Hocdet839af572019-05-14 16:27:35 +02003753#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02003754 free(conf->ciphersuites);
3755 conf->ciphersuites = NULL;
3756#endif
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01003757 free(conf->curves);
3758 conf->curves = NULL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003759 free(conf->ecdhe);
3760 conf->ecdhe = NULL;
3761 }
3762}
3763
Willy Tarreaub131c872019-10-16 16:42:19 +02003764/* Returns a set of ERR_* flags possibly with an error in <err>. */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003765int ssl_sock_load_cert_list_file(char *file, struct bind_conf *bind_conf, struct proxy *curproxy, char **err)
3766{
3767 char thisline[CRT_LINESIZE];
3768 char path[MAXPATHLEN+1];
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003769 FILE *f;
yanbzhu1b04e5b2015-12-02 13:54:14 -05003770 struct stat buf;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003771 int linenum = 0;
3772 int cfgerr = 0;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003773
Willy Tarreauad1731d2013-04-02 17:35:58 +02003774 if ((f = fopen(file, "r")) == NULL) {
3775 memprintf(err, "cannot open file '%s' : %s", file, strerror(errno));
Willy Tarreaub131c872019-10-16 16:42:19 +02003776 return ERR_ALERT | ERR_FATAL;
Willy Tarreauad1731d2013-04-02 17:35:58 +02003777 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003778
3779 while (fgets(thisline, sizeof(thisline), f) != NULL) {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003780 int arg, newarg, cur_arg, i, ssl_b = 0, ssl_e = 0;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003781 char *end;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003782 char *args[MAX_CRT_ARGS + 1];
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003783 char *line = thisline;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003784 char *crt_path;
3785 struct ssl_bind_conf *ssl_conf = NULL;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003786
3787 linenum++;
3788 end = line + strlen(line);
3789 if (end-line == sizeof(thisline)-1 && *(end-1) != '\n') {
3790 /* Check if we reached the limit and the last char is not \n.
3791 * Watch out for the last line without the terminating '\n'!
3792 */
Willy Tarreauad1731d2013-04-02 17:35:58 +02003793 memprintf(err, "line %d too long in file '%s', limit is %d characters",
3794 linenum, file, (int)sizeof(thisline)-1);
Willy Tarreaub131c872019-10-16 16:42:19 +02003795 cfgerr |= ERR_ALERT | ERR_FATAL;
Willy Tarreauad1731d2013-04-02 17:35:58 +02003796 break;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003797 }
3798
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003799 arg = 0;
Emeric Brun50bcecc2013-04-22 13:05:23 +02003800 newarg = 1;
3801 while (*line) {
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003802 if (*line == '#' || *line == '\n' || *line == '\r') {
3803 /* end of string, end of loop */
3804 *line = 0;
3805 break;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003806 } else if (isspace(*line)) {
Emeric Brun50bcecc2013-04-22 13:05:23 +02003807 newarg = 1;
3808 *line = 0;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003809 } else if (*line == '[') {
3810 if (ssl_b) {
3811 memprintf(err, "too many '[' on line %d in file '%s'.", linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003812 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003813 break;
3814 }
3815 if (!arg) {
3816 memprintf(err, "file must start with a cert on line %d in file '%s'", linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003817 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003818 break;
3819 }
3820 ssl_b = arg;
3821 newarg = 1;
3822 *line = 0;
3823 } else if (*line == ']') {
3824 if (ssl_e) {
3825 memprintf(err, "too many ']' on line %d in file '%s'.", linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003826 cfgerr |= ERR_ALERT | ERR_FATAL;
Emeric Brun50bcecc2013-04-22 13:05:23 +02003827 break;
3828 }
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003829 if (!ssl_b) {
3830 memprintf(err, "missing '[' in line %d in file '%s'.", linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003831 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003832 break;
3833 }
3834 ssl_e = arg;
3835 newarg = 1;
3836 *line = 0;
3837 } else if (newarg) {
3838 if (arg == MAX_CRT_ARGS) {
3839 memprintf(err, "too many args on line %d in file '%s'.", linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003840 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003841 break;
3842 }
Emeric Brun50bcecc2013-04-22 13:05:23 +02003843 newarg = 0;
3844 args[arg++] = line;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003845 }
Emeric Brun50bcecc2013-04-22 13:05:23 +02003846 line++;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003847 }
Willy Tarreaub131c872019-10-16 16:42:19 +02003848 if (cfgerr & ERR_CODE)
Emmanuel Hocdet7c41a1b2013-05-07 20:20:06 +02003849 break;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003850 args[arg++] = line;
Willy Tarreauad1731d2013-04-02 17:35:58 +02003851
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003852 /* empty line */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003853 if (!*args[0])
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003854 continue;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003855
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003856 crt_path = args[0];
3857 if (*crt_path != '/' && global_ssl.crt_base) {
3858 if ((strlen(global_ssl.crt_base) + 1 + strlen(crt_path)) > MAXPATHLEN) {
3859 memprintf(err, "'%s' : path too long on line %d in file '%s'",
3860 crt_path, linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003861 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003862 break;
3863 }
3864 snprintf(path, sizeof(path), "%s/%s", global_ssl.crt_base, crt_path);
3865 crt_path = path;
3866 }
3867
3868 ssl_conf = calloc(1, sizeof *ssl_conf);
3869 cur_arg = ssl_b ? ssl_b : 1;
3870 while (cur_arg < ssl_e) {
3871 newarg = 0;
3872 for (i = 0; ssl_bind_kws[i].kw != NULL; i++) {
3873 if (strcmp(ssl_bind_kws[i].kw, args[cur_arg]) == 0) {
3874 newarg = 1;
Willy Tarreaub131c872019-10-16 16:42:19 +02003875 cfgerr |= ssl_bind_kws[i].parse(args, cur_arg, curproxy, ssl_conf, err);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003876 if (cur_arg + 1 + ssl_bind_kws[i].skip > ssl_e) {
3877 memprintf(err, "ssl args out of '[]' for %s on line %d in file '%s'",
3878 args[cur_arg], linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003879 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003880 }
3881 cur_arg += 1 + ssl_bind_kws[i].skip;
3882 break;
3883 }
3884 }
3885 if (!cfgerr && !newarg) {
3886 memprintf(err, "unknown ssl keyword %s on line %d in file '%s'.",
3887 args[cur_arg], linenum, file);
Willy Tarreaub131c872019-10-16 16:42:19 +02003888 cfgerr |= ERR_ALERT | ERR_FATAL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003889 break;
3890 }
3891 }
Willy Tarreaub131c872019-10-16 16:42:19 +02003892
3893 if (cfgerr & ERR_CODE) {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003894 ssl_sock_free_ssl_conf(ssl_conf);
3895 free(ssl_conf);
3896 ssl_conf = NULL;
3897 break;
3898 }
3899
3900 if (stat(crt_path, &buf) == 0) {
Willy Tarreaub131c872019-10-16 16:42:19 +02003901 cfgerr |= ssl_sock_load_cert_file(crt_path, bind_conf, ssl_conf,
Emmanuel Hocdet98263292016-12-29 18:26:15 +01003902 &args[cur_arg], arg - cur_arg - 1, err);
Willy Tarreaub131c872019-10-16 16:42:19 +02003903 } else {
3904 cfgerr |= ssl_sock_load_multi_cert(crt_path, bind_conf, ssl_conf,
3905 &args[cur_arg], arg - cur_arg - 1, err);
yanbzhu1b04e5b2015-12-02 13:54:14 -05003906 }
3907
Willy Tarreaub131c872019-10-16 16:42:19 +02003908 if (cfgerr & ERR_CODE) {
Willy Tarreauad1731d2013-04-02 17:35:58 +02003909 memprintf(err, "error processing line %d in file '%s' : %s", linenum, file, *err);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003910 break;
Willy Tarreauad1731d2013-04-02 17:35:58 +02003911 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003912 }
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01003913 fclose(f);
3914 return cfgerr;
3915}
3916
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01003917/* Create an initial CTX used to start the SSL connection before switchctx */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003918static int
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01003919ssl_sock_initial_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02003920{
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01003921 SSL_CTX *ctx = NULL;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003922 long options =
Emeric Brunfc0421f2012-09-07 17:30:07 +02003923 SSL_OP_ALL | /* all known workarounds for bugs */
3924 SSL_OP_NO_SSLv2 |
3925 SSL_OP_NO_COMPRESSION |
Emeric Bruna4bcd9a2012-09-20 16:19:02 +02003926 SSL_OP_SINGLE_DH_USE |
Emeric Brun2b58d042012-09-20 17:10:03 +02003927 SSL_OP_SINGLE_ECDH_USE |
Emeric Brun3c4bc6e2012-10-04 18:44:19 +02003928 SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION |
Lukas Tribus926594f2018-05-18 17:55:57 +02003929 SSL_OP_PRIORITIZE_CHACHA |
Emeric Brun3c4bc6e2012-10-04 18:44:19 +02003930 SSL_OP_CIPHER_SERVER_PREFERENCE;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003931 long mode =
Emeric Brunfc0421f2012-09-07 17:30:07 +02003932 SSL_MODE_ENABLE_PARTIAL_WRITE |
3933 SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
Willy Tarreau396a1862014-11-13 14:06:52 +01003934 SSL_MODE_RELEASE_BUFFERS |
3935 SSL_MODE_SMALL_BUFFERS;
Emmanuel Hocdet43664762017-08-09 18:26:20 +02003936 struct tls_version_filter *conf_ssl_methods = &bind_conf->ssl_conf.ssl_methods;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003937 int i, min, max, hole;
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003938 int flags = MC_SSL_O_ALL;
3939 int cfgerr = 0;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01003940
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003941 ctx = SSL_CTX_new(SSLv23_server_method());
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003942 bind_conf->initial_ctx = ctx;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003943
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003944 if (conf_ssl_methods->flags && (conf_ssl_methods->min || conf_ssl_methods->max))
Christopher Faulet767a84b2017-11-24 16:50:31 +01003945 ha_warning("Proxy '%s': no-sslv3/no-tlsv1x are ignored for bind '%s' at [%s:%d]. "
3946 "Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
3947 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003948 else
3949 flags = conf_ssl_methods->flags;
3950
Emmanuel Hocdetbd695fe2017-05-15 15:53:41 +02003951 min = conf_ssl_methods->min;
3952 max = conf_ssl_methods->max;
3953 /* start with TLSv10 to remove SSLv3 per default */
3954 if (!min && (!max || max >= CONF_TLSV10))
3955 min = CONF_TLSV10;
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02003956 /* Real min and max should be determinate with configuration and openssl's capabilities */
Emmanuel Hocdetbd695fe2017-05-15 15:53:41 +02003957 if (min)
3958 flags |= (methodVersions[min].flag - 1);
3959 if (max)
3960 flags |= ~((methodVersions[max].flag << 1) - 1);
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02003961 /* find min, max and holes */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003962 min = max = CONF_TLSV_NONE;
3963 hole = 0;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003964 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003965 /* version is in openssl && version not disable in configuration */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003966 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003967 if (min) {
3968 if (hole) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003969 ha_warning("Proxy '%s': SSL/TLS versions range not contiguous for bind '%s' at [%s:%d]. "
3970 "Hole find for %s. Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
3971 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line,
3972 methodVersions[hole].name);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003973 hole = 0;
3974 }
3975 max = i;
3976 }
3977 else {
3978 min = max = i;
3979 }
3980 }
3981 else {
3982 if (min)
3983 hole = i;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02003984 }
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003985 if (!min) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01003986 ha_alert("Proxy '%s': all SSL/TLS versions are disabled for bind '%s' at [%s:%d].\n",
3987 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003988 cfgerr += 1;
3989 }
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02003990 /* save real min/max in bind_conf */
3991 conf_ssl_methods->min = min;
3992 conf_ssl_methods->max = max;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003993
Willy Tarreau9a1ab082019-05-09 13:26:41 +02003994#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003995 /* Keep force-xxx implementation as it is in older haproxy. It's a
Joseph Herlant017b3da2018-11-15 09:07:59 -08003996 precautionary measure to avoid any surprise with older openssl version. */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02003997 if (min == max)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02003998 methodVersions[min].ctx_set_version(ctx, SET_SERVER);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02003999 else
4000 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
4001 if (flags & methodVersions[i].flag)
4002 options |= methodVersions[i].option;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004003#else /* openssl >= 1.1.0 */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004004 /* set the max_version is required to cap TLS version or activate new TLS (v1.3) */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02004005 methodVersions[min].ctx_set_version(ctx, SET_MIN);
4006 methodVersions[max].ctx_set_version(ctx, SET_MAX);
Emeric Brunfa5c5c82017-04-28 16:19:51 +02004007#endif
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004008
4009 if (bind_conf->ssl_options & BC_SSL_O_NO_TLS_TICKETS)
4010 options |= SSL_OP_NO_TICKET;
4011 if (bind_conf->ssl_options & BC_SSL_O_PREF_CLIE_CIPH)
4012 options &= ~SSL_OP_CIPHER_SERVER_PREFERENCE;
Dirkjan Bussink526894f2019-01-21 09:35:03 -08004013
4014#ifdef SSL_OP_NO_RENEGOTIATION
4015 options |= SSL_OP_NO_RENEGOTIATION;
4016#endif
4017
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004018 SSL_CTX_set_options(ctx, options);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00004019
Willy Tarreau5db847a2019-05-09 14:13:35 +02004020#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00004021 if (global_ssl.async)
4022 mode |= SSL_MODE_ASYNC;
4023#endif
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004024 SSL_CTX_set_mode(ctx, mode);
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004025 if (global_ssl.life_time)
4026 SSL_CTX_set_timeout(ctx, global_ssl.life_time);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004027
4028#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
4029#ifdef OPENSSL_IS_BORINGSSL
4030 SSL_CTX_set_select_certificate_cb(ctx, ssl_sock_switchctx_cbk);
4031 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_err_cbk);
Willy Tarreau5db847a2019-05-09 14:13:35 +02004032#elif (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houcharde82c1d42019-12-17 15:39:54 +01004033 if (bind_conf->ssl_conf.early_data)
Olivier Houchard51088ce2019-01-02 18:46:41 +01004034 SSL_CTX_set_options(ctx, SSL_OP_NO_ANTI_REPLAY);
Emmanuel Hocdet84e417d2017-08-16 11:33:17 +02004035 SSL_CTX_set_client_hello_cb(ctx, ssl_sock_switchctx_cbk, NULL);
4036 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_err_cbk);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004037#else
4038 SSL_CTX_set_tlsext_servername_callback(ctx, ssl_sock_switchctx_cbk);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004039#endif
Emmanuel Hocdet253c62b2017-08-14 11:01:25 +02004040 SSL_CTX_set_tlsext_servername_arg(ctx, bind_conf);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004041#endif
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004042 return cfgerr;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004043}
4044
William Lallemand4f45bb92017-10-30 20:08:51 +01004045
4046static inline void sh_ssl_sess_free_blocks(struct shared_block *first, struct shared_block *block)
4047{
4048 if (first == block) {
4049 struct sh_ssl_sess_hdr *sh_ssl_sess = (struct sh_ssl_sess_hdr *)first->data;
4050 if (first->len > 0)
4051 sh_ssl_sess_tree_delete(sh_ssl_sess);
4052 }
4053}
4054
4055/* return first block from sh_ssl_sess */
4056static inline struct shared_block *sh_ssl_sess_first_block(struct sh_ssl_sess_hdr *sh_ssl_sess)
4057{
4058 return (struct shared_block *)((unsigned char *)sh_ssl_sess - ((struct shared_block *)NULL)->data);
4059
4060}
4061
4062/* store a session into the cache
4063 * s_id : session id padded with zero to SSL_MAX_SSL_SESSION_ID_LENGTH
4064 * data: asn1 encoded session
4065 * data_len: asn1 encoded session length
4066 * Returns 1 id session was stored (else 0)
4067 */
4068static int sh_ssl_sess_store(unsigned char *s_id, unsigned char *data, int data_len)
4069{
4070 struct shared_block *first;
4071 struct sh_ssl_sess_hdr *sh_ssl_sess, *oldsh_ssl_sess;
4072
Frédéric Lécaille0bec8072018-10-22 17:55:57 +02004073 first = shctx_row_reserve_hot(ssl_shctx, NULL, data_len + sizeof(struct sh_ssl_sess_hdr));
William Lallemand4f45bb92017-10-30 20:08:51 +01004074 if (!first) {
4075 /* Could not retrieve enough free blocks to store that session */
4076 return 0;
4077 }
4078
4079 /* STORE the key in the first elem */
4080 sh_ssl_sess = (struct sh_ssl_sess_hdr *)first->data;
4081 memcpy(sh_ssl_sess->key_data, s_id, SSL_MAX_SSL_SESSION_ID_LENGTH);
4082 first->len = sizeof(struct sh_ssl_sess_hdr);
4083
4084 /* it returns the already existing node
4085 or current node if none, never returns null */
4086 oldsh_ssl_sess = sh_ssl_sess_tree_insert(sh_ssl_sess);
4087 if (oldsh_ssl_sess != sh_ssl_sess) {
4088 /* NOTE: Row couldn't be in use because we lock read & write function */
4089 /* release the reserved row */
4090 shctx_row_dec_hot(ssl_shctx, first);
4091 /* replace the previous session already in the tree */
4092 sh_ssl_sess = oldsh_ssl_sess;
4093 /* ignore the previous session data, only use the header */
4094 first = sh_ssl_sess_first_block(sh_ssl_sess);
4095 shctx_row_inc_hot(ssl_shctx, first);
4096 first->len = sizeof(struct sh_ssl_sess_hdr);
4097 }
4098
Frédéric Lécaille0bec8072018-10-22 17:55:57 +02004099 if (shctx_row_data_append(ssl_shctx, first, NULL, data, data_len) < 0) {
William Lallemand99b90af2018-01-03 19:15:51 +01004100 shctx_row_dec_hot(ssl_shctx, first);
William Lallemand4f45bb92017-10-30 20:08:51 +01004101 return 0;
William Lallemand99b90af2018-01-03 19:15:51 +01004102 }
4103
4104 shctx_row_dec_hot(ssl_shctx, first);
William Lallemand4f45bb92017-10-30 20:08:51 +01004105
4106 return 1;
4107}
William Lallemanded0b5ad2017-10-30 19:36:36 +01004108
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004109/* SSL callback used when a new session is created while connecting to a server */
4110static int ssl_sess_new_srv_cb(SSL *ssl, SSL_SESSION *sess)
4111{
Thierry FOURNIER28962c92018-06-17 21:37:05 +02004112 struct connection *conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houcharde6060c52017-11-16 17:42:52 +01004113 struct server *s;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004114
Willy Tarreau07d94e42018-09-20 10:57:52 +02004115 s = __objt_server(conn->target);
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004116
Olivier Houcharde6060c52017-11-16 17:42:52 +01004117 if (!(s->ssl_ctx.options & SRV_SSL_O_NO_REUSE)) {
4118 int len;
4119 unsigned char *ptr;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004120
Olivier Houcharde6060c52017-11-16 17:42:52 +01004121 len = i2d_SSL_SESSION(sess, NULL);
4122 if (s->ssl_ctx.reused_sess[tid].ptr && s->ssl_ctx.reused_sess[tid].allocated_size >= len) {
4123 ptr = s->ssl_ctx.reused_sess[tid].ptr;
4124 } else {
4125 free(s->ssl_ctx.reused_sess[tid].ptr);
4126 ptr = s->ssl_ctx.reused_sess[tid].ptr = malloc(len);
4127 s->ssl_ctx.reused_sess[tid].allocated_size = len;
4128 }
4129 if (s->ssl_ctx.reused_sess[tid].ptr) {
4130 s->ssl_ctx.reused_sess[tid].size = i2d_SSL_SESSION(sess,
4131 &ptr);
4132 }
4133 } else {
4134 free(s->ssl_ctx.reused_sess[tid].ptr);
4135 s->ssl_ctx.reused_sess[tid].ptr = NULL;
4136 }
4137
4138 return 0;
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004139}
4140
Olivier Houcharde6060c52017-11-16 17:42:52 +01004141
William Lallemanded0b5ad2017-10-30 19:36:36 +01004142/* SSL callback used on new session creation */
William Lallemand4f45bb92017-10-30 20:08:51 +01004143int sh_ssl_sess_new_cb(SSL *ssl, SSL_SESSION *sess)
William Lallemanded0b5ad2017-10-30 19:36:36 +01004144{
4145 unsigned char encsess[SHSESS_MAX_DATA_LEN]; /* encoded session */
4146 unsigned char encid[SSL_MAX_SSL_SESSION_ID_LENGTH]; /* encoded id */
4147 unsigned char *p;
4148 int data_len;
Emeric Brun7b34de32019-10-08 18:27:37 +02004149 unsigned int sid_length;
William Lallemanded0b5ad2017-10-30 19:36:36 +01004150 const unsigned char *sid_data;
William Lallemanded0b5ad2017-10-30 19:36:36 +01004151
4152 /* Session id is already stored in to key and session id is known
4153 * so we dont store it to keep size.
Emeric Brun7b34de32019-10-08 18:27:37 +02004154 * note: SSL_SESSION_set1_id is using
4155 * a memcpy so we need to use a different pointer
4156 * than sid_data or sid_ctx_data to avoid valgrind
4157 * complaining.
William Lallemanded0b5ad2017-10-30 19:36:36 +01004158 */
4159
4160 sid_data = SSL_SESSION_get_id(sess, &sid_length);
Emeric Brun7b34de32019-10-08 18:27:37 +02004161
4162 /* copy value in an other buffer */
4163 memcpy(encid, sid_data, sid_length);
4164
4165 /* pad with 0 */
4166 if (sid_length < SSL_MAX_SSL_SESSION_ID_LENGTH)
4167 memset(encid + sid_length, 0, SSL_MAX_SSL_SESSION_ID_LENGTH-sid_length);
4168
4169 /* force length to zero to avoid ASN1 encoding */
4170 SSL_SESSION_set1_id(sess, encid, 0);
4171
4172 /* force length to zero to avoid ASN1 encoding */
4173 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, 0);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004174
4175 /* check if buffer is large enough for the ASN1 encoded session */
4176 data_len = i2d_SSL_SESSION(sess, NULL);
4177 if (data_len > SHSESS_MAX_DATA_LEN)
4178 goto err;
4179
4180 p = encsess;
4181
4182 /* process ASN1 session encoding before the lock */
4183 i2d_SSL_SESSION(sess, &p);
4184
William Lallemanded0b5ad2017-10-30 19:36:36 +01004185
William Lallemanda3c77cf2017-10-30 23:44:40 +01004186 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004187 /* store to cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01004188 sh_ssl_sess_store(encid, encsess, data_len);
William Lallemanda3c77cf2017-10-30 23:44:40 +01004189 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004190err:
4191 /* reset original length values */
Emeric Brun7b34de32019-10-08 18:27:37 +02004192 SSL_SESSION_set1_id(sess, encid, sid_length);
4193 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
William Lallemanded0b5ad2017-10-30 19:36:36 +01004194
4195 return 0; /* do not increment session reference count */
4196}
4197
4198/* SSL callback used on lookup an existing session cause none found in internal cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01004199SSL_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 +01004200{
William Lallemand4f45bb92017-10-30 20:08:51 +01004201 struct sh_ssl_sess_hdr *sh_ssl_sess;
William Lallemanded0b5ad2017-10-30 19:36:36 +01004202 unsigned char data[SHSESS_MAX_DATA_LEN], *p;
4203 unsigned char tmpkey[SSL_MAX_SSL_SESSION_ID_LENGTH];
William Lallemanded0b5ad2017-10-30 19:36:36 +01004204 SSL_SESSION *sess;
William Lallemand4f45bb92017-10-30 20:08:51 +01004205 struct shared_block *first;
William Lallemanded0b5ad2017-10-30 19:36:36 +01004206
4207 global.shctx_lookups++;
4208
4209 /* allow the session to be freed automatically by openssl */
4210 *do_copy = 0;
4211
4212 /* tree key is zeros padded sessionid */
4213 if (key_len < SSL_MAX_SSL_SESSION_ID_LENGTH) {
4214 memcpy(tmpkey, key, key_len);
4215 memset(tmpkey + key_len, 0, SSL_MAX_SSL_SESSION_ID_LENGTH - key_len);
4216 key = tmpkey;
4217 }
4218
4219 /* lock cache */
William Lallemanda3c77cf2017-10-30 23:44:40 +01004220 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004221
4222 /* lookup for session */
William Lallemand4f45bb92017-10-30 20:08:51 +01004223 sh_ssl_sess = sh_ssl_sess_tree_lookup(key);
4224 if (!sh_ssl_sess) {
William Lallemanded0b5ad2017-10-30 19:36:36 +01004225 /* no session found: unlock cache and exit */
William Lallemanda3c77cf2017-10-30 23:44:40 +01004226 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004227 global.shctx_misses++;
4228 return NULL;
4229 }
4230
William Lallemand4f45bb92017-10-30 20:08:51 +01004231 /* sh_ssl_sess (shared_block->data) is at the end of shared_block */
4232 first = sh_ssl_sess_first_block(sh_ssl_sess);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004233
William Lallemand4f45bb92017-10-30 20:08:51 +01004234 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 +01004235
William Lallemanda3c77cf2017-10-30 23:44:40 +01004236 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004237
4238 /* decode ASN1 session */
4239 p = data;
William Lallemand4f45bb92017-10-30 20:08:51 +01004240 sess = d2i_SSL_SESSION(NULL, (const unsigned char **)&p, first->len-sizeof(struct sh_ssl_sess_hdr));
William Lallemanded0b5ad2017-10-30 19:36:36 +01004241 /* Reset session id and session id contenxt */
4242 if (sess) {
4243 SSL_SESSION_set1_id(sess, key, key_len);
4244 SSL_SESSION_set1_id_context(sess, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
4245 }
4246
4247 return sess;
4248}
4249
William Lallemand4f45bb92017-10-30 20:08:51 +01004250
William Lallemanded0b5ad2017-10-30 19:36:36 +01004251/* SSL callback used to signal session is no more used in internal cache */
William Lallemand4f45bb92017-10-30 20:08:51 +01004252void sh_ssl_sess_remove_cb(SSL_CTX *ctx, SSL_SESSION *sess)
William Lallemanded0b5ad2017-10-30 19:36:36 +01004253{
William Lallemand4f45bb92017-10-30 20:08:51 +01004254 struct sh_ssl_sess_hdr *sh_ssl_sess;
William Lallemanded0b5ad2017-10-30 19:36:36 +01004255 unsigned char tmpkey[SSL_MAX_SSL_SESSION_ID_LENGTH];
4256 unsigned int sid_length;
4257 const unsigned char *sid_data;
4258 (void)ctx;
4259
4260 sid_data = SSL_SESSION_get_id(sess, &sid_length);
4261 /* tree key is zeros padded sessionid */
4262 if (sid_length < SSL_MAX_SSL_SESSION_ID_LENGTH) {
4263 memcpy(tmpkey, sid_data, sid_length);
4264 memset(tmpkey+sid_length, 0, SSL_MAX_SSL_SESSION_ID_LENGTH - sid_length);
4265 sid_data = tmpkey;
4266 }
4267
William Lallemanda3c77cf2017-10-30 23:44:40 +01004268 shctx_lock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004269
4270 /* lookup for session */
William Lallemand4f45bb92017-10-30 20:08:51 +01004271 sh_ssl_sess = sh_ssl_sess_tree_lookup(sid_data);
4272 if (sh_ssl_sess) {
William Lallemanded0b5ad2017-10-30 19:36:36 +01004273 /* free session */
William Lallemand4f45bb92017-10-30 20:08:51 +01004274 sh_ssl_sess_tree_delete(sh_ssl_sess);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004275 }
4276
4277 /* unlock cache */
William Lallemanda3c77cf2017-10-30 23:44:40 +01004278 shctx_unlock(ssl_shctx);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004279}
4280
4281/* Set session cache mode to server and disable openssl internal cache.
4282 * Set shared cache callbacks on an ssl context.
4283 * Shared context MUST be firstly initialized */
William Lallemand4f45bb92017-10-30 20:08:51 +01004284void ssl_set_shctx(SSL_CTX *ctx)
William Lallemanded0b5ad2017-10-30 19:36:36 +01004285{
4286 SSL_CTX_set_session_id_context(ctx, (const unsigned char *)SHCTX_APPNAME, strlen(SHCTX_APPNAME));
4287
4288 if (!ssl_shctx) {
4289 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
4290 return;
4291 }
4292
4293 SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_SERVER |
4294 SSL_SESS_CACHE_NO_INTERNAL |
4295 SSL_SESS_CACHE_NO_AUTO_CLEAR);
4296
4297 /* Set callbacks */
William Lallemand4f45bb92017-10-30 20:08:51 +01004298 SSL_CTX_sess_set_new_cb(ctx, sh_ssl_sess_new_cb);
4299 SSL_CTX_sess_set_get_cb(ctx, sh_ssl_sess_get_cb);
4300 SSL_CTX_sess_set_remove_cb(ctx, sh_ssl_sess_remove_cb);
William Lallemanded0b5ad2017-10-30 19:36:36 +01004301}
4302
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004303int ssl_sock_prepare_ctx(struct bind_conf *bind_conf, struct ssl_bind_conf *ssl_conf, SSL_CTX *ctx)
4304{
4305 struct proxy *curproxy = bind_conf->frontend;
4306 int cfgerr = 0;
4307 int verify = SSL_VERIFY_NONE;
Willy Tarreau5d4cafb2018-01-04 18:55:19 +01004308 struct ssl_bind_conf __maybe_unused *ssl_conf_cur;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004309 const char *conf_ciphers;
Emmanuel Hocdet839af572019-05-14 16:27:35 +02004310#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02004311 const char *conf_ciphersuites;
4312#endif
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01004313 const char *conf_curves = NULL;
Emeric Brunfc0421f2012-09-07 17:30:07 +02004314
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02004315 if (ssl_conf) {
4316 struct tls_version_filter *conf_ssl_methods = &ssl_conf->ssl_methods;
4317 int i, min, max;
4318 int flags = MC_SSL_O_ALL;
4319
4320 /* Real min and max should be determinate with configuration and openssl's capabilities */
Emmanuel Hocdet43664762017-08-09 18:26:20 +02004321 min = conf_ssl_methods->min ? conf_ssl_methods->min : bind_conf->ssl_conf.ssl_methods.min;
4322 max = conf_ssl_methods->max ? conf_ssl_methods->max : bind_conf->ssl_conf.ssl_methods.max;
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02004323 if (min)
4324 flags |= (methodVersions[min].flag - 1);
4325 if (max)
4326 flags |= ~((methodVersions[max].flag << 1) - 1);
4327 min = max = CONF_TLSV_NONE;
4328 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
4329 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
4330 if (min)
4331 max = i;
4332 else
4333 min = max = i;
4334 }
4335 /* save real min/max */
4336 conf_ssl_methods->min = min;
4337 conf_ssl_methods->max = max;
4338 if (!min) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004339 ha_alert("Proxy '%s': all SSL/TLS versions are disabled for bind '%s' at [%s:%d].\n",
4340 bind_conf->frontend->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02004341 cfgerr += 1;
4342 }
4343 }
4344
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004345 switch ((ssl_conf && ssl_conf->verify) ? ssl_conf->verify : bind_conf->ssl_conf.verify) {
Emeric Brun850efd52014-01-29 12:24:34 +01004346 case SSL_SOCK_VERIFY_NONE:
4347 verify = SSL_VERIFY_NONE;
4348 break;
4349 case SSL_SOCK_VERIFY_OPTIONAL:
4350 verify = SSL_VERIFY_PEER;
4351 break;
4352 case SSL_SOCK_VERIFY_REQUIRED:
4353 verify = SSL_VERIFY_PEER|SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
4354 break;
4355 }
4356 SSL_CTX_set_verify(ctx, verify, ssl_sock_bind_verifycbk);
4357 if (verify & SSL_VERIFY_PEER) {
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004358 char *ca_file = (ssl_conf && ssl_conf->ca_file) ? ssl_conf->ca_file : bind_conf->ssl_conf.ca_file;
4359 char *crl_file = (ssl_conf && ssl_conf->crl_file) ? ssl_conf->crl_file : bind_conf->ssl_conf.crl_file;
4360 if (ca_file) {
Emeric Brund94b3fe2012-09-20 18:23:56 +02004361 /* load CAfile to verify */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004362 if (!SSL_CTX_load_verify_locations(ctx, ca_file, NULL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004363 ha_alert("Proxy '%s': unable to load CA file '%s' for bind '%s' at [%s:%d].\n",
4364 curproxy->id, ca_file, bind_conf->arg, bind_conf->file, bind_conf->line);
Emeric Brund94b3fe2012-09-20 18:23:56 +02004365 cfgerr++;
4366 }
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02004367 if (!((ssl_conf && ssl_conf->no_ca_names) || bind_conf->ssl_conf.no_ca_names)) {
4368 /* set CA names for client cert request, function returns void */
4369 SSL_CTX_set_client_CA_list(ctx, SSL_load_client_CA_file(ca_file));
4370 }
Emeric Brund94b3fe2012-09-20 18:23:56 +02004371 }
Emeric Brun850efd52014-01-29 12:24:34 +01004372 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004373 ha_alert("Proxy '%s': verify is enabled but no CA file specified for bind '%s' at [%s:%d].\n",
4374 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emeric Brun850efd52014-01-29 12:24:34 +01004375 cfgerr++;
4376 }
Emeric Brun051cdab2012-10-02 19:25:50 +02004377#ifdef X509_V_FLAG_CRL_CHECK
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004378 if (crl_file) {
Emeric Brund94b3fe2012-09-20 18:23:56 +02004379 X509_STORE *store = SSL_CTX_get_cert_store(ctx);
4380
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004381 if (!store || !X509_STORE_load_locations(store, crl_file, NULL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004382 ha_alert("Proxy '%s': unable to configure CRL file '%s' for bind '%s' at [%s:%d].\n",
4383 curproxy->id, crl_file, bind_conf->arg, bind_conf->file, bind_conf->line);
Emeric Brund94b3fe2012-09-20 18:23:56 +02004384 cfgerr++;
4385 }
Emeric Brun561e5742012-10-02 15:20:55 +02004386 else {
4387 X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
4388 }
Emeric Brund94b3fe2012-09-20 18:23:56 +02004389 }
Emeric Brun051cdab2012-10-02 19:25:50 +02004390#endif
Emeric Brun644cde02012-12-14 11:21:13 +01004391 ERR_clear_error();
Emeric Brund94b3fe2012-09-20 18:23:56 +02004392 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01004393#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
Nenad Merdanovic146defa2015-05-09 08:46:00 +02004394 if(bind_conf->keys_ref) {
Nenad Merdanovic05552d42015-02-27 19:56:49 +01004395 if (!SSL_CTX_set_tlsext_ticket_key_cb(ctx, ssl_tlsext_ticket_key_cb)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004396 ha_alert("Proxy '%s': unable to set callback for TLS ticket validation for bind '%s' at [%s:%d].\n",
4397 curproxy->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Nenad Merdanovic05552d42015-02-27 19:56:49 +01004398 cfgerr++;
4399 }
4400 }
4401#endif
4402
William Lallemand4f45bb92017-10-30 20:08:51 +01004403 ssl_set_shctx(ctx);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004404 conf_ciphers = (ssl_conf && ssl_conf->ciphers) ? ssl_conf->ciphers : bind_conf->ssl_conf.ciphers;
4405 if (conf_ciphers &&
4406 !SSL_CTX_set_cipher_list(ctx, conf_ciphers)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004407 ha_alert("Proxy '%s': unable to set SSL cipher list to '%s' for bind '%s' at [%s:%d].\n",
4408 curproxy->id, conf_ciphers, bind_conf->arg, bind_conf->file, bind_conf->line);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004409 cfgerr++;
4410 }
4411
Emmanuel Hocdet839af572019-05-14 16:27:35 +02004412#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02004413 conf_ciphersuites = (ssl_conf && ssl_conf->ciphersuites) ? ssl_conf->ciphersuites : bind_conf->ssl_conf.ciphersuites;
4414 if (conf_ciphersuites &&
4415 !SSL_CTX_set_ciphersuites(ctx, conf_ciphersuites)) {
4416 ha_alert("Proxy '%s': unable to set TLS 1.3 cipher suites to '%s' for bind '%s' at [%s:%d].\n",
4417 curproxy->id, conf_ciphersuites, bind_conf->arg, bind_conf->file, bind_conf->line);
4418 cfgerr++;
4419 }
4420#endif
4421
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01004422#ifndef OPENSSL_NO_DH
Remi Gacogne47783ef2015-05-29 15:53:22 +02004423 /* If tune.ssl.default-dh-param has not been set,
4424 neither has ssl-default-dh-file and no static DH
4425 params were in the certificate file. */
Willy Tarreauef934602016-12-22 23:12:01 +01004426 if (global_ssl.default_dh_param == 0 &&
Remi Gacogne47783ef2015-05-29 15:53:22 +02004427 global_dh == NULL &&
Remi Gacogne4f902b82015-05-28 16:23:00 +02004428 (ssl_dh_ptr_index == -1 ||
4429 SSL_CTX_get_ex_data(ctx, ssl_dh_ptr_index) == NULL)) {
Emmanuel Hocdetcc6c2a22017-03-03 17:04:14 +01004430 STACK_OF(SSL_CIPHER) * ciphers = NULL;
4431 const SSL_CIPHER * cipher = NULL;
4432 char cipher_description[128];
4433 /* The description of ciphers using an Ephemeral Diffie Hellman key exchange
4434 contains " Kx=DH " or " Kx=DH(". Beware of " Kx=DH/",
4435 which is not ephemeral DH. */
4436 const char dhe_description[] = " Kx=DH ";
4437 const char dhe_export_description[] = " Kx=DH(";
4438 int idx = 0;
4439 int dhe_found = 0;
4440 SSL *ssl = NULL;
Lukas Tribus90132722014-08-18 00:56:33 +02004441
Remi Gacogne23d5d372014-10-10 17:04:26 +02004442 ssl = SSL_new(ctx);
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004443
Remi Gacogne23d5d372014-10-10 17:04:26 +02004444 if (ssl) {
4445 ciphers = SSL_get_ciphers(ssl);
4446
4447 if (ciphers) {
4448 for (idx = 0; idx < sk_SSL_CIPHER_num(ciphers); idx++) {
4449 cipher = sk_SSL_CIPHER_value(ciphers, idx);
4450 if (SSL_CIPHER_description(cipher, cipher_description, sizeof (cipher_description)) == cipher_description) {
4451 if (strstr(cipher_description, dhe_description) != NULL ||
4452 strstr(cipher_description, dhe_export_description) != NULL) {
4453 dhe_found = 1;
4454 break;
4455 }
Remi Gacognec1eab8c2014-06-12 18:20:11 +02004456 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004457 }
4458 }
Remi Gacogne23d5d372014-10-10 17:04:26 +02004459 SSL_free(ssl);
4460 ssl = NULL;
Lukas Tribus90132722014-08-18 00:56:33 +02004461 }
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004462
Lukas Tribus90132722014-08-18 00:56:33 +02004463 if (dhe_found) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004464 ha_warning("Setting 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");
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004465 }
4466
Willy Tarreauef934602016-12-22 23:12:01 +01004467 global_ssl.default_dh_param = 1024;
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004468 }
Remi Gacogne8de54152014-07-15 11:36:40 +02004469
Willy Tarreauef934602016-12-22 23:12:01 +01004470 if (global_ssl.default_dh_param >= 1024) {
Remi Gacogne8de54152014-07-15 11:36:40 +02004471 if (local_dh_1024 == NULL) {
4472 local_dh_1024 = ssl_get_dh_1024();
4473 }
Willy Tarreauef934602016-12-22 23:12:01 +01004474 if (global_ssl.default_dh_param >= 2048) {
Remi Gacogne8de54152014-07-15 11:36:40 +02004475 if (local_dh_2048 == NULL) {
4476 local_dh_2048 = ssl_get_dh_2048();
4477 }
Willy Tarreauef934602016-12-22 23:12:01 +01004478 if (global_ssl.default_dh_param >= 4096) {
Remi Gacogne8de54152014-07-15 11:36:40 +02004479 if (local_dh_4096 == NULL) {
4480 local_dh_4096 = ssl_get_dh_4096();
4481 }
Remi Gacogne8de54152014-07-15 11:36:40 +02004482 }
4483 }
4484 }
4485#endif /* OPENSSL_NO_DH */
Remi Gacognef46cd6e2014-06-12 14:58:40 +02004486
Emeric Brunfc0421f2012-09-07 17:30:07 +02004487 SSL_CTX_set_info_callback(ctx, ssl_sock_infocbk);
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004488#if HA_OPENSSL_VERSION_NUMBER >= 0x00907000L
Emeric Brun29f037d2014-04-25 19:05:36 +02004489 SSL_CTX_set_msg_callback(ctx, ssl_sock_msgcbk);
Willy Tarreau5cbe4ef2014-05-08 22:45:11 +02004490#endif
Emeric Brun29f037d2014-04-25 19:05:36 +02004491
Bernard Spil13c53f82018-02-15 13:34:58 +01004492#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004493 ssl_conf_cur = NULL;
4494 if (ssl_conf && ssl_conf->npn_str)
4495 ssl_conf_cur = ssl_conf;
4496 else if (bind_conf->ssl_conf.npn_str)
4497 ssl_conf_cur = &bind_conf->ssl_conf;
4498 if (ssl_conf_cur)
4499 SSL_CTX_set_next_protos_advertised_cb(ctx, ssl_sock_advertise_npn_protos, ssl_conf_cur);
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02004500#endif
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01004501#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004502 ssl_conf_cur = NULL;
4503 if (ssl_conf && ssl_conf->alpn_str)
4504 ssl_conf_cur = ssl_conf;
4505 else if (bind_conf->ssl_conf.alpn_str)
4506 ssl_conf_cur = &bind_conf->ssl_conf;
4507 if (ssl_conf_cur)
4508 SSL_CTX_set_alpn_select_cb(ctx, ssl_sock_advertise_alpn_protos, ssl_conf_cur);
Willy Tarreauab861d32013-04-02 02:30:41 +02004509#endif
Lukas Tribusd13e9252019-11-24 18:20:40 +01004510#if ((HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL) || defined(LIBRESSL_VERSION_NUMBER))
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01004511 conf_curves = (ssl_conf && ssl_conf->curves) ? ssl_conf->curves : bind_conf->ssl_conf.curves;
4512 if (conf_curves) {
4513 if (!SSL_CTX_set1_curves_list(ctx, conf_curves)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004514 ha_alert("Proxy '%s': unable to set SSL curves list to '%s' for bind '%s' at [%s:%d].\n",
4515 curproxy->id, conf_curves, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01004516 cfgerr++;
4517 }
Emmanuel Hocdeta52bb152017-03-20 11:11:49 +01004518 (void)SSL_CTX_set_ecdh_auto(ctx, 1);
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01004519 }
4520#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02004521#if defined(SSL_CTX_set_tmp_ecdh) && !defined(OPENSSL_NO_ECDH)
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01004522 if (!conf_curves) {
Emeric Brun2b58d042012-09-20 17:10:03 +02004523 int i;
4524 EC_KEY *ecdh;
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004525#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004526 const char *ecdhe = (ssl_conf && ssl_conf->ecdhe) ? ssl_conf->ecdhe :
Olivier Houchardc2aae742017-09-22 18:26:28 +02004527 (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe :
4528 NULL);
4529
4530 if (ecdhe == NULL) {
Eric Salama27c21cd2019-11-20 11:33:40 +01004531 (void)SSL_CTX_set_ecdh_auto(ctx, 1);
Olivier Houchardc2aae742017-09-22 18:26:28 +02004532 return cfgerr;
4533 }
4534#else
4535 const char *ecdhe = (ssl_conf && ssl_conf->ecdhe) ? ssl_conf->ecdhe :
4536 (bind_conf->ssl_conf.ecdhe ? bind_conf->ssl_conf.ecdhe :
4537 ECDHE_DEFAULT_CURVE);
4538#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02004539
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004540 i = OBJ_sn2nid(ecdhe);
Emeric Brun2b58d042012-09-20 17:10:03 +02004541 if (!i || ((ecdh = EC_KEY_new_by_curve_name(i)) == NULL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004542 ha_alert("Proxy '%s': unable to set elliptic named curve to '%s' for bind '%s' at [%s:%d].\n",
4543 curproxy->id, ecdhe, bind_conf->arg, bind_conf->file, bind_conf->line);
Emeric Brun2b58d042012-09-20 17:10:03 +02004544 cfgerr++;
4545 }
4546 else {
4547 SSL_CTX_set_tmp_ecdh(ctx, ecdh);
4548 EC_KEY_free(ecdh);
4549 }
4550 }
4551#endif
4552
Emeric Brunfc0421f2012-09-07 17:30:07 +02004553 return cfgerr;
4554}
4555
Evan Broderbe554312013-06-27 00:05:25 -07004556static int ssl_sock_srv_hostcheck(const char *pattern, const char *hostname)
4557{
4558 const char *pattern_wildcard, *pattern_left_label_end, *hostname_left_label_end;
4559 size_t prefixlen, suffixlen;
4560
4561 /* Trivial case */
4562 if (strcmp(pattern, hostname) == 0)
4563 return 1;
4564
Evan Broderbe554312013-06-27 00:05:25 -07004565 /* The rest of this logic is based on RFC 6125, section 6.4.3
4566 * (http://tools.ietf.org/html/rfc6125#section-6.4.3) */
4567
Emeric Bruna848dae2013-10-08 11:27:28 +02004568 pattern_wildcard = NULL;
4569 pattern_left_label_end = pattern;
4570 while (*pattern_left_label_end != '.') {
4571 switch (*pattern_left_label_end) {
4572 case 0:
4573 /* End of label not found */
4574 return 0;
4575 case '*':
4576 /* If there is more than one wildcards */
4577 if (pattern_wildcard)
4578 return 0;
4579 pattern_wildcard = pattern_left_label_end;
4580 break;
4581 }
4582 pattern_left_label_end++;
4583 }
4584
4585 /* If it's not trivial and there is no wildcard, it can't
4586 * match */
4587 if (!pattern_wildcard)
Evan Broderbe554312013-06-27 00:05:25 -07004588 return 0;
4589
4590 /* Make sure all labels match except the leftmost */
4591 hostname_left_label_end = strchr(hostname, '.');
4592 if (!hostname_left_label_end
4593 || strcmp(pattern_left_label_end, hostname_left_label_end) != 0)
4594 return 0;
4595
4596 /* Make sure the leftmost label of the hostname is long enough
4597 * that the wildcard can match */
Emeric Brun369da852013-10-08 11:39:35 +02004598 if (hostname_left_label_end - hostname < (pattern_left_label_end - pattern) - 1)
Evan Broderbe554312013-06-27 00:05:25 -07004599 return 0;
4600
4601 /* Finally compare the string on either side of the
4602 * wildcard */
4603 prefixlen = pattern_wildcard - pattern;
4604 suffixlen = pattern_left_label_end - (pattern_wildcard + 1);
Emeric Bruna848dae2013-10-08 11:27:28 +02004605 if ((prefixlen && (memcmp(pattern, hostname, prefixlen) != 0))
4606 || (suffixlen && (memcmp(pattern_wildcard + 1, hostname_left_label_end - suffixlen, suffixlen) != 0)))
Evan Broderbe554312013-06-27 00:05:25 -07004607 return 0;
4608
4609 return 1;
4610}
4611
4612static int ssl_sock_srv_verifycbk(int ok, X509_STORE_CTX *ctx)
4613{
4614 SSL *ssl;
4615 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01004616 struct ssl_sock_ctx *ssl_ctx;
Willy Tarreau2ab88672017-07-05 18:23:03 +02004617 const char *servername;
Willy Tarreau71d058c2017-07-26 20:09:56 +02004618 const char *sni;
Evan Broderbe554312013-06-27 00:05:25 -07004619
4620 int depth;
4621 X509 *cert;
4622 STACK_OF(GENERAL_NAME) *alt_names;
4623 int i;
4624 X509_NAME *cert_subject;
4625 char *str;
4626
4627 if (ok == 0)
4628 return ok;
4629
4630 ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
Thierry FOURNIER28962c92018-06-17 21:37:05 +02004631 conn = SSL_get_ex_data(ssl, ssl_app_data_index);
Olivier Houchard66ab4982019-02-26 18:37:15 +01004632 ssl_ctx = conn->xprt_ctx;
Evan Broderbe554312013-06-27 00:05:25 -07004633
Willy Tarreauad92a9a2017-07-28 11:38:41 +02004634 /* We're checking if the provided hostnames match the desired one. The
4635 * desired hostname comes from the SNI we presented if any, or if not
4636 * provided then it may have been explicitly stated using a "verifyhost"
4637 * directive. If neither is set, we don't care about the name so the
4638 * verification is OK.
Willy Tarreau2ab88672017-07-05 18:23:03 +02004639 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01004640 servername = SSL_get_servername(ssl_ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau71d058c2017-07-26 20:09:56 +02004641 sni = servername;
Willy Tarreau2ab88672017-07-05 18:23:03 +02004642 if (!servername) {
Willy Tarreau07d94e42018-09-20 10:57:52 +02004643 servername = __objt_server(conn->target)->ssl_ctx.verify_host;
Willy Tarreau2ab88672017-07-05 18:23:03 +02004644 if (!servername)
4645 return ok;
4646 }
Evan Broderbe554312013-06-27 00:05:25 -07004647
4648 /* We only need to verify the CN on the actual server cert,
4649 * not the indirect CAs */
4650 depth = X509_STORE_CTX_get_error_depth(ctx);
4651 if (depth != 0)
4652 return ok;
4653
4654 /* At this point, the cert is *not* OK unless we can find a
4655 * hostname match */
4656 ok = 0;
4657
4658 cert = X509_STORE_CTX_get_current_cert(ctx);
4659 /* It seems like this might happen if verify peer isn't set */
4660 if (!cert)
4661 return ok;
4662
4663 alt_names = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
4664 if (alt_names) {
4665 for (i = 0; !ok && i < sk_GENERAL_NAME_num(alt_names); i++) {
4666 GENERAL_NAME *name = sk_GENERAL_NAME_value(alt_names, i);
4667 if (name->type == GEN_DNS) {
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004668#if HA_OPENSSL_VERSION_NUMBER < 0x00907000L
Emeric Bruna33410c2013-09-17 15:47:48 +02004669 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.ia5) >= 0) {
4670#else
Evan Broderbe554312013-06-27 00:05:25 -07004671 if (ASN1_STRING_to_UTF8((unsigned char **)&str, name->d.dNSName) >= 0) {
Emeric Bruna33410c2013-09-17 15:47:48 +02004672#endif
Evan Broderbe554312013-06-27 00:05:25 -07004673 ok = ssl_sock_srv_hostcheck(str, servername);
4674 OPENSSL_free(str);
4675 }
4676 }
4677 }
Emeric Brun4ad50a42013-09-17 15:19:54 +02004678 sk_GENERAL_NAME_pop_free(alt_names, GENERAL_NAME_free);
Evan Broderbe554312013-06-27 00:05:25 -07004679 }
4680
4681 cert_subject = X509_get_subject_name(cert);
4682 i = -1;
4683 while (!ok && (i = X509_NAME_get_index_by_NID(cert_subject, NID_commonName, i)) != -1) {
4684 X509_NAME_ENTRY *entry = X509_NAME_get_entry(cert_subject, i);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02004685 ASN1_STRING *value;
4686 value = X509_NAME_ENTRY_get_data(entry);
4687 if (ASN1_STRING_to_UTF8((unsigned char **)&str, value) >= 0) {
Evan Broderbe554312013-06-27 00:05:25 -07004688 ok = ssl_sock_srv_hostcheck(str, servername);
4689 OPENSSL_free(str);
4690 }
4691 }
4692
Willy Tarreau71d058c2017-07-26 20:09:56 +02004693 /* report the mismatch and indicate if SNI was used or not */
4694 if (!ok && !conn->err_code)
4695 conn->err_code = sni ? CO_ER_SSL_MISMATCH_SNI : CO_ER_SSL_MISMATCH;
Evan Broderbe554312013-06-27 00:05:25 -07004696 return ok;
4697}
4698
Emeric Brun94324a42012-10-11 14:00:19 +02004699/* prepare ssl context from servers options. Returns an error count */
Willy Tarreau03209342016-12-22 17:08:28 +01004700int ssl_sock_prepare_srv_ctx(struct server *srv)
Emeric Brun94324a42012-10-11 14:00:19 +02004701{
Willy Tarreau03209342016-12-22 17:08:28 +01004702 struct proxy *curproxy = srv->proxy;
Emeric Brun94324a42012-10-11 14:00:19 +02004703 int cfgerr = 0;
Remi Gacogneaf5c3da2014-05-19 10:29:58 +02004704 long options =
Emeric Brun94324a42012-10-11 14:00:19 +02004705 SSL_OP_ALL | /* all known workarounds for bugs */
4706 SSL_OP_NO_SSLv2 |
4707 SSL_OP_NO_COMPRESSION;
Remi Gacogneaf5c3da2014-05-19 10:29:58 +02004708 long mode =
Emeric Brun94324a42012-10-11 14:00:19 +02004709 SSL_MODE_ENABLE_PARTIAL_WRITE |
4710 SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER |
Willy Tarreau396a1862014-11-13 14:06:52 +01004711 SSL_MODE_RELEASE_BUFFERS |
4712 SSL_MODE_SMALL_BUFFERS;
Emeric Brun850efd52014-01-29 12:24:34 +01004713 int verify = SSL_VERIFY_NONE;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004714 SSL_CTX *ctx = NULL;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004715 struct tls_version_filter *conf_ssl_methods = &srv->ssl_ctx.methods;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004716 int i, min, max, hole;
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004717 int flags = MC_SSL_O_ALL;
Emeric Brun94324a42012-10-11 14:00:19 +02004718
Thierry Fournier383085f2013-01-24 14:15:43 +01004719 /* Make sure openssl opens /dev/urandom before the chroot */
4720 if (!ssl_initialize_random()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004721 ha_alert("OpenSSL random data generator initialization failed.\n");
Thierry Fournier383085f2013-01-24 14:15:43 +01004722 cfgerr++;
4723 }
4724
Willy Tarreaufce03112015-01-15 21:32:40 +01004725 /* Automatic memory computations need to know we use SSL there */
4726 global.ssl_used_backend = 1;
4727
4728 /* Initiate SSL context for current server */
Emeric Brun821bb9b2017-06-15 16:37:39 +02004729 if (!srv->ssl_ctx.reused_sess) {
Olivier Houcharde6060c52017-11-16 17:42:52 +01004730 if ((srv->ssl_ctx.reused_sess = calloc(1, global.nbthread*sizeof(*srv->ssl_ctx.reused_sess))) == NULL) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004731 ha_alert("Proxy '%s', server '%s' [%s:%d] out of memory.\n",
4732 curproxy->id, srv->id,
4733 srv->conf.file, srv->conf.line);
Emeric Brun821bb9b2017-06-15 16:37:39 +02004734 cfgerr++;
4735 return cfgerr;
4736 }
4737 }
Emeric Brun94324a42012-10-11 14:00:19 +02004738 if (srv->use_ssl)
4739 srv->xprt = &ssl_sock;
4740 if (srv->check.use_ssl)
Cyril Bonté9ce13112014-11-15 22:41:27 +01004741 srv->check.xprt = &ssl_sock;
Emeric Brun94324a42012-10-11 14:00:19 +02004742
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004743 ctx = SSL_CTX_new(SSLv23_client_method());
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004744 if (!ctx) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004745 ha_alert("config : %s '%s', server '%s': unable to allocate ssl context.\n",
4746 proxy_type_str(curproxy), curproxy->id,
4747 srv->id);
Emeric Brun94324a42012-10-11 14:00:19 +02004748 cfgerr++;
4749 return cfgerr;
4750 }
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004751
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004752 if (conf_ssl_methods->flags && (conf_ssl_methods->min || conf_ssl_methods->max))
Christopher Faulet767a84b2017-11-24 16:50:31 +01004753 ha_warning("config : %s '%s': no-sslv3/no-tlsv1x are ignored for server '%s'. "
4754 "Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
4755 proxy_type_str(curproxy), curproxy->id, srv->id);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004756 else
4757 flags = conf_ssl_methods->flags;
4758
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004759 /* Real min and max should be determinate with configuration and openssl's capabilities */
4760 if (conf_ssl_methods->min)
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004761 flags |= (methodVersions[conf_ssl_methods->min].flag - 1);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004762 if (conf_ssl_methods->max)
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004763 flags |= ~((methodVersions[conf_ssl_methods->max].flag << 1) - 1);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004764
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02004765 /* find min, max and holes */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004766 min = max = CONF_TLSV_NONE;
4767 hole = 0;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004768 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004769 /* version is in openssl && version not disable in configuration */
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004770 if (methodVersions[i].option && !(flags & methodVersions[i].flag)) {
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004771 if (min) {
4772 if (hole) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004773 ha_warning("config : %s '%s': SSL/TLS versions range not contiguous for server '%s'. "
4774 "Hole find for %s. Use only 'ssl-min-ver' and 'ssl-max-ver' to fix.\n",
4775 proxy_type_str(curproxy), curproxy->id, srv->id,
4776 methodVersions[hole].name);
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004777 hole = 0;
4778 }
4779 max = i;
4780 }
4781 else {
4782 min = max = i;
4783 }
4784 }
4785 else {
4786 if (min)
4787 hole = i;
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004788 }
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004789 if (!min) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004790 ha_alert("config : %s '%s': all SSL/TLS versions are disabled for server '%s'.\n",
4791 proxy_type_str(curproxy), curproxy->id, srv->id);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004792 cfgerr += 1;
4793 }
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004794
Willy Tarreau9a1ab082019-05-09 13:26:41 +02004795#if (HA_OPENSSL_VERSION_NUMBER < 0x1010000fL)
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004796 /* Keep force-xxx implementation as it is in older haproxy. It's a
Joseph Herlant017b3da2018-11-15 09:07:59 -08004797 precautionary measure to avoid any surprise with older openssl version. */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004798 if (min == max)
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02004799 methodVersions[min].ctx_set_version(ctx, SET_CLIENT);
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004800 else
4801 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
4802 if (flags & methodVersions[i].flag)
4803 options |= methodVersions[i].option;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004804#else /* openssl >= 1.1.0 */
Emmanuel Hocdetb4e9ba42017-03-30 19:25:07 +02004805 /* set the max_version is required to cap TLS version or activate new TLS (v1.3) */
Emmanuel Hocdet4aa615f2017-05-18 12:33:19 +02004806 methodVersions[min].ctx_set_version(ctx, SET_MIN);
4807 methodVersions[max].ctx_set_version(ctx, SET_MAX);
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02004808#endif
4809
4810 if (srv->ssl_ctx.options & SRV_SSL_O_NO_TLS_TICKETS)
4811 options |= SSL_OP_NO_TICKET;
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004812 SSL_CTX_set_options(ctx, options);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00004813
Willy Tarreau5db847a2019-05-09 14:13:35 +02004814#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00004815 if (global_ssl.async)
4816 mode |= SSL_MODE_ASYNC;
4817#endif
Emmanuel Hocdet4de1ff12017-03-03 12:21:32 +01004818 SSL_CTX_set_mode(ctx, mode);
4819 srv->ssl_ctx.ctx = ctx;
4820
Emeric Bruna7aa3092012-10-26 12:58:00 +02004821 if (srv->ssl_ctx.client_crt) {
4822 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 +01004823 ha_alert("config : %s '%s', server '%s': unable to load SSL private key from PEM file '%s'.\n",
4824 proxy_type_str(curproxy), curproxy->id,
4825 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02004826 cfgerr++;
4827 }
4828 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 +01004829 ha_alert("config : %s '%s', server '%s': unable to load ssl certificate from PEM file '%s'.\n",
4830 proxy_type_str(curproxy), curproxy->id,
4831 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02004832 cfgerr++;
4833 }
4834 else if (SSL_CTX_check_private_key(srv->ssl_ctx.ctx) <= 0) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004835 ha_alert("config : %s '%s', server '%s': inconsistencies between private key and certificate loaded from PEM file '%s'.\n",
4836 proxy_type_str(curproxy), curproxy->id,
4837 srv->id, srv->ssl_ctx.client_crt);
Emeric Bruna7aa3092012-10-26 12:58:00 +02004838 cfgerr++;
4839 }
4840 }
Emeric Brun94324a42012-10-11 14:00:19 +02004841
Emeric Brun850efd52014-01-29 12:24:34 +01004842 if (global.ssl_server_verify == SSL_SERVER_VERIFY_REQUIRED)
4843 verify = SSL_VERIFY_PEER;
Emeric Brun850efd52014-01-29 12:24:34 +01004844 switch (srv->ssl_ctx.verify) {
4845 case SSL_SOCK_VERIFY_NONE:
4846 verify = SSL_VERIFY_NONE;
4847 break;
4848 case SSL_SOCK_VERIFY_REQUIRED:
4849 verify = SSL_VERIFY_PEER;
4850 break;
4851 }
Evan Broderbe554312013-06-27 00:05:25 -07004852 SSL_CTX_set_verify(srv->ssl_ctx.ctx,
Emeric Brun850efd52014-01-29 12:24:34 +01004853 verify,
Willy Tarreau2ab88672017-07-05 18:23:03 +02004854 (srv->ssl_ctx.verify_host || (verify & SSL_VERIFY_PEER)) ? ssl_sock_srv_verifycbk : NULL);
Emeric Brun850efd52014-01-29 12:24:34 +01004855 if (verify & SSL_VERIFY_PEER) {
Emeric Brunef42d922012-10-11 16:11:36 +02004856 if (srv->ssl_ctx.ca_file) {
4857 /* load CAfile to verify */
4858 if (!SSL_CTX_load_verify_locations(srv->ssl_ctx.ctx, srv->ssl_ctx.ca_file, NULL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004859 ha_alert("Proxy '%s', server '%s' [%s:%d] unable to load CA file '%s'.\n",
4860 curproxy->id, srv->id,
4861 srv->conf.file, srv->conf.line, srv->ssl_ctx.ca_file);
Emeric Brunef42d922012-10-11 16:11:36 +02004862 cfgerr++;
4863 }
4864 }
Emeric Brun850efd52014-01-29 12:24:34 +01004865 else {
4866 if (global.ssl_server_verify == SSL_SERVER_VERIFY_REQUIRED)
Christopher Faulet767a84b2017-11-24 16:50:31 +01004867 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",
4868 curproxy->id, srv->id,
4869 srv->conf.file, srv->conf.line);
Emeric Brun850efd52014-01-29 12:24:34 +01004870 else
Christopher Faulet767a84b2017-11-24 16:50:31 +01004871 ha_alert("Proxy '%s', server '%s' [%s:%d] verify is enabled but no CA file specified.\n",
4872 curproxy->id, srv->id,
4873 srv->conf.file, srv->conf.line);
Emeric Brun850efd52014-01-29 12:24:34 +01004874 cfgerr++;
4875 }
Emeric Brunef42d922012-10-11 16:11:36 +02004876#ifdef X509_V_FLAG_CRL_CHECK
4877 if (srv->ssl_ctx.crl_file) {
4878 X509_STORE *store = SSL_CTX_get_cert_store(srv->ssl_ctx.ctx);
4879
4880 if (!store || !X509_STORE_load_locations(store, srv->ssl_ctx.crl_file, NULL)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004881 ha_alert("Proxy '%s', server '%s' [%s:%d] unable to configure CRL file '%s'.\n",
4882 curproxy->id, srv->id,
4883 srv->conf.file, srv->conf.line, srv->ssl_ctx.crl_file);
Emeric Brunef42d922012-10-11 16:11:36 +02004884 cfgerr++;
4885 }
4886 else {
4887 X509_STORE_set_flags(store, X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
4888 }
4889 }
4890#endif
4891 }
4892
Olivier Houchardbd84ac82017-11-03 13:43:35 +01004893 SSL_CTX_set_session_cache_mode(srv->ssl_ctx.ctx, SSL_SESS_CACHE_CLIENT |
4894 SSL_SESS_CACHE_NO_INTERNAL_STORE);
4895 SSL_CTX_sess_set_new_cb(srv->ssl_ctx.ctx, ssl_sess_new_srv_cb);
Emeric Brun94324a42012-10-11 14:00:19 +02004896 if (srv->ssl_ctx.ciphers &&
4897 !SSL_CTX_set_cipher_list(srv->ssl_ctx.ctx, srv->ssl_ctx.ciphers)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004898 ha_alert("Proxy '%s', server '%s' [%s:%d] : unable to set SSL cipher list to '%s'.\n",
4899 curproxy->id, srv->id,
4900 srv->conf.file, srv->conf.line, srv->ssl_ctx.ciphers);
Emeric Brun94324a42012-10-11 14:00:19 +02004901 cfgerr++;
4902 }
Dirkjan Bussink415150f2018-09-14 11:14:21 +02004903
Emmanuel Hocdet839af572019-05-14 16:27:35 +02004904#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02004905 if (srv->ssl_ctx.ciphersuites &&
Pierre Cheynierbc34cd12019-03-21 16:15:47 +00004906 !SSL_CTX_set_ciphersuites(srv->ssl_ctx.ctx, srv->ssl_ctx.ciphersuites)) {
Dirkjan Bussink415150f2018-09-14 11:14:21 +02004907 ha_alert("Proxy '%s', server '%s' [%s:%d] : unable to set TLS 1.3 cipher suites to '%s'.\n",
4908 curproxy->id, srv->id,
4909 srv->conf.file, srv->conf.line, srv->ssl_ctx.ciphersuites);
4910 cfgerr++;
4911 }
4912#endif
Olivier Houchardc7566002018-11-20 23:33:50 +01004913#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
4914 if (srv->ssl_ctx.npn_str)
4915 SSL_CTX_set_next_proto_select_cb(ctx, ssl_sock_srv_select_protos, srv);
4916#endif
4917#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
4918 if (srv->ssl_ctx.alpn_str)
4919 SSL_CTX_set_alpn_protos(ctx, (unsigned char *)srv->ssl_ctx.alpn_str, srv->ssl_ctx.alpn_len);
4920#endif
4921
Emeric Brun94324a42012-10-11 14:00:19 +02004922
4923 return cfgerr;
4924}
4925
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004926/* Walks down the two trees in bind_conf and prepares all certs. The pointer may
Emeric Brunfc0421f2012-09-07 17:30:07 +02004927 * be NULL, in which case nothing is done. Returns the number of errors
4928 * encountered.
4929 */
Willy Tarreau03209342016-12-22 17:08:28 +01004930int ssl_sock_prepare_all_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02004931{
4932 struct ebmb_node *node;
4933 struct sni_ctx *sni;
4934 int err = 0;
4935
Willy Tarreaufce03112015-01-15 21:32:40 +01004936 /* Automatic memory computations need to know we use SSL there */
4937 global.ssl_used_frontend = 1;
4938
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004939 /* Make sure openssl opens /dev/urandom before the chroot */
4940 if (!ssl_initialize_random()) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004941 ha_alert("OpenSSL random data generator initialization failed.\n");
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004942 err++;
4943 }
4944 /* Create initial_ctx used to start the ssl connection before do switchctx */
4945 if (!bind_conf->initial_ctx) {
Emmanuel Hocdetabd32332017-05-05 18:06:12 +02004946 err += ssl_sock_initial_ctx(bind_conf);
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01004947 /* It should not be necessary to call this function, but it's
4948 necessary first to check and move all initialisation related
4949 to initial_ctx in ssl_sock_initial_ctx. */
4950 err += ssl_sock_prepare_ctx(bind_conf, NULL, bind_conf->initial_ctx);
4951 }
Emeric Brun0bed9942014-10-30 19:25:24 +01004952 if (bind_conf->default_ctx)
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004953 err += ssl_sock_prepare_ctx(bind_conf, bind_conf->default_ssl_conf, bind_conf->default_ctx);
Emeric Brun0bed9942014-10-30 19:25:24 +01004954
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004955 node = ebmb_first(&bind_conf->sni_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004956 while (node) {
4957 sni = ebmb_entry(node, struct sni_ctx, name);
Emeric Brun0bed9942014-10-30 19:25:24 +01004958 if (!sni->order && sni->ctx != bind_conf->default_ctx)
4959 /* only initialize the CTX on its first occurrence and
4960 if it is not the default_ctx */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004961 err += ssl_sock_prepare_ctx(bind_conf, sni->conf, sni->ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004962 node = ebmb_next(node);
4963 }
4964
Willy Tarreau2a65ff02012-09-13 17:54:29 +02004965 node = ebmb_first(&bind_conf->sni_w_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004966 while (node) {
4967 sni = ebmb_entry(node, struct sni_ctx, name);
Emeric Brun0bed9942014-10-30 19:25:24 +01004968 if (!sni->order && sni->ctx != bind_conf->default_ctx)
4969 /* only initialize the CTX on its first occurrence and
4970 if it is not the default_ctx */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01004971 err += ssl_sock_prepare_ctx(bind_conf, sni->conf, sni->ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02004972 node = ebmb_next(node);
4973 }
4974 return err;
4975}
4976
Willy Tarreau55d37912016-12-21 23:38:39 +01004977/* Prepares all the contexts for a bind_conf and allocates the shared SSL
4978 * context if needed. Returns < 0 on error, 0 on success. The warnings and
4979 * alerts are directly emitted since the rest of the stack does it below.
4980 */
4981int ssl_sock_prepare_bind_conf(struct bind_conf *bind_conf)
4982{
4983 struct proxy *px = bind_conf->frontend;
4984 int alloc_ctx;
4985 int err;
4986
4987 if (!bind_conf->is_ssl) {
4988 if (bind_conf->default_ctx) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004989 ha_warning("Proxy '%s': A certificate was specified but SSL was not enabled on bind '%s' at [%s:%d] (use 'ssl').\n",
4990 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Willy Tarreau55d37912016-12-21 23:38:39 +01004991 }
4992 return 0;
4993 }
4994 if (!bind_conf->default_ctx) {
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02004995 if (bind_conf->strict_sni && !bind_conf->generate_certs) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01004996 ha_warning("Proxy '%s': no SSL certificate specified for bind '%s' at [%s:%d], ssl connections will fail (use 'crt').\n",
4997 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02004998 }
4999 else {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005000 ha_alert("Proxy '%s': no SSL certificate specified for bind '%s' at [%s:%d] (use 'crt').\n",
5001 px->id, bind_conf->arg, bind_conf->file, bind_conf->line);
Emmanuel Hocdetaa0d6372017-08-09 11:24:25 +02005002 return -1;
5003 }
Willy Tarreau55d37912016-12-21 23:38:39 +01005004 }
William Lallemandc61c0b32017-12-04 18:46:39 +01005005 if (!ssl_shctx && global.tune.sslcachesize) {
William Lallemandc3cd35f2017-11-28 11:04:43 +01005006 alloc_ctx = shctx_init(&ssl_shctx, global.tune.sslcachesize,
Frédéric Lécailleb7838af2018-10-22 16:21:39 +02005007 sizeof(struct sh_ssl_sess_hdr) + SHSESS_BLOCK_MIN_SIZE, -1,
William Lallemandc3cd35f2017-11-28 11:04:43 +01005008 sizeof(*sh_ssl_sess_tree),
5009 ((global.nbthread > 1) || (!global_ssl.private_cache && (global.nbproc > 1))) ? 1 : 0);
Frédéric Lécaille4c8aa112018-10-25 20:22:46 +02005010 if (alloc_ctx <= 0) {
William Lallemandc3cd35f2017-11-28 11:04:43 +01005011 if (alloc_ctx == SHCTX_E_INIT_LOCK)
5012 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");
5013 else
5014 ha_alert("Unable to allocate SSL session cache.\n");
5015 return -1;
5016 }
5017 /* free block callback */
5018 ssl_shctx->free_block = sh_ssl_sess_free_blocks;
5019 /* init the root tree within the extra space */
5020 sh_ssl_sess_tree = (void *)ssl_shctx + sizeof(struct shared_context);
5021 *sh_ssl_sess_tree = EB_ROOT_UNIQUE;
Willy Tarreau55d37912016-12-21 23:38:39 +01005022 }
Willy Tarreau55d37912016-12-21 23:38:39 +01005023 err = 0;
5024 /* initialize all certificate contexts */
5025 err += ssl_sock_prepare_all_ctx(bind_conf);
5026
5027 /* initialize CA variables if the certificates generation is enabled */
5028 err += ssl_sock_load_ca(bind_conf);
5029
5030 return -err;
5031}
Christopher Faulet77fe80c2015-07-29 13:02:40 +02005032
5033/* release ssl context allocated for servers. */
5034void ssl_sock_free_srv_ctx(struct server *srv)
5035{
Olivier Houchardc7566002018-11-20 23:33:50 +01005036#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
5037 if (srv->ssl_ctx.alpn_str)
5038 free(srv->ssl_ctx.alpn_str);
5039#endif
Lukas Tribusda95fd92018-11-25 13:21:27 +01005040#ifdef OPENSSL_NPN_NEGOTIATED
Olivier Houchardc7566002018-11-20 23:33:50 +01005041 if (srv->ssl_ctx.npn_str)
5042 free(srv->ssl_ctx.npn_str);
Lukas Tribus7706b852018-11-26 22:57:17 +01005043#endif
Christopher Faulet77fe80c2015-07-29 13:02:40 +02005044 if (srv->ssl_ctx.ctx)
5045 SSL_CTX_free(srv->ssl_ctx.ctx);
5046}
5047
Willy Tarreau2a65ff02012-09-13 17:54:29 +02005048/* Walks down the two trees in bind_conf and frees all the certs. The pointer may
Emeric Brunfc0421f2012-09-07 17:30:07 +02005049 * be NULL, in which case nothing is done. The default_ctx is nullified too.
5050 */
Willy Tarreau2a65ff02012-09-13 17:54:29 +02005051void ssl_sock_free_all_ctx(struct bind_conf *bind_conf)
Emeric Brunfc0421f2012-09-07 17:30:07 +02005052{
5053 struct ebmb_node *node, *back;
5054 struct sni_ctx *sni;
5055
Willy Tarreau2a65ff02012-09-13 17:54:29 +02005056 node = ebmb_first(&bind_conf->sni_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02005057 while (node) {
5058 sni = ebmb_entry(node, struct sni_ctx, name);
5059 back = ebmb_next(node);
5060 ebmb_delete(node);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005061 if (!sni->order) { /* only free the CTX on its first occurrence */
Emeric Brunfc0421f2012-09-07 17:30:07 +02005062 SSL_CTX_free(sni->ctx);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005063 ssl_sock_free_ssl_conf(sni->conf);
5064 free(sni->conf);
5065 sni->conf = NULL;
5066 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02005067 free(sni);
5068 node = back;
5069 }
5070
Willy Tarreau2a65ff02012-09-13 17:54:29 +02005071 node = ebmb_first(&bind_conf->sni_w_ctx);
Emeric Brunfc0421f2012-09-07 17:30:07 +02005072 while (node) {
5073 sni = ebmb_entry(node, struct sni_ctx, name);
5074 back = ebmb_next(node);
5075 ebmb_delete(node);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005076 if (!sni->order) { /* only free the CTX on its first occurrence */
Emeric Brunfc0421f2012-09-07 17:30:07 +02005077 SSL_CTX_free(sni->ctx);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005078 ssl_sock_free_ssl_conf(sni->conf);
5079 free(sni->conf);
5080 sni->conf = NULL;
5081 }
Emeric Brunfc0421f2012-09-07 17:30:07 +02005082 free(sni);
5083 node = back;
5084 }
Emmanuel Hocdetf6b37c62017-03-06 15:34:44 +01005085 SSL_CTX_free(bind_conf->initial_ctx);
5086 bind_conf->initial_ctx = NULL;
Willy Tarreau2a65ff02012-09-13 17:54:29 +02005087 bind_conf->default_ctx = NULL;
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005088 bind_conf->default_ssl_conf = NULL;
Emeric Brune1f38db2012-09-03 20:36:47 +02005089}
5090
Willy Tarreau795cdab2016-12-22 17:30:54 +01005091/* Destroys all the contexts for a bind_conf. This is used during deinit(). */
5092void ssl_sock_destroy_bind_conf(struct bind_conf *bind_conf)
5093{
5094 ssl_sock_free_ca(bind_conf);
5095 ssl_sock_free_all_ctx(bind_conf);
Emmanuel Hocdet98263292016-12-29 18:26:15 +01005096 ssl_sock_free_ssl_conf(&bind_conf->ssl_conf);
Willy Tarreau795cdab2016-12-22 17:30:54 +01005097 free(bind_conf->ca_sign_file);
5098 free(bind_conf->ca_sign_pass);
Willy Tarreau17b4aa12018-07-17 10:05:32 +02005099 if (bind_conf->keys_ref && !--bind_conf->keys_ref->refcount) {
Willy Tarreau795cdab2016-12-22 17:30:54 +01005100 free(bind_conf->keys_ref->filename);
5101 free(bind_conf->keys_ref->tlskeys);
5102 LIST_DEL(&bind_conf->keys_ref->list);
5103 free(bind_conf->keys_ref);
5104 }
5105 bind_conf->keys_ref = NULL;
Willy Tarreau795cdab2016-12-22 17:30:54 +01005106 bind_conf->ca_sign_pass = NULL;
5107 bind_conf->ca_sign_file = NULL;
Willy Tarreau795cdab2016-12-22 17:30:54 +01005108}
5109
Christopher Faulet31af49d2015-06-09 17:29:50 +02005110/* Load CA cert file and private key used to generate certificates */
5111int
Willy Tarreau03209342016-12-22 17:08:28 +01005112ssl_sock_load_ca(struct bind_conf *bind_conf)
Christopher Faulet31af49d2015-06-09 17:29:50 +02005113{
Willy Tarreau03209342016-12-22 17:08:28 +01005114 struct proxy *px = bind_conf->frontend;
Christopher Faulet31af49d2015-06-09 17:29:50 +02005115 FILE *fp;
5116 X509 *cacert = NULL;
5117 EVP_PKEY *capkey = NULL;
5118 int err = 0;
5119
Christopher Fauletf8bb0ce2017-09-15 09:52:49 +02005120 if (!bind_conf->generate_certs)
Christopher Faulet31af49d2015-06-09 17:29:50 +02005121 return err;
5122
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005123#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Emeric Brun821bb9b2017-06-15 16:37:39 +02005124 if (global_ssl.ctx_cache) {
Willy Tarreauef934602016-12-22 23:12:01 +01005125 ssl_ctx_lru_tree = lru64_new(global_ssl.ctx_cache);
Emeric Brun821bb9b2017-06-15 16:37:39 +02005126 }
Christopher Fauletd2cab922015-07-28 16:03:47 +02005127 ssl_ctx_lru_seed = (unsigned int)time(NULL);
Emeric Brun821bb9b2017-06-15 16:37:39 +02005128 ssl_ctx_serial = now_ms;
Willy Tarreaua84c2672015-10-09 12:10:13 +02005129#endif
Christopher Fauletd2cab922015-07-28 16:03:47 +02005130
Christopher Faulet31af49d2015-06-09 17:29:50 +02005131 if (!bind_conf->ca_sign_file) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005132 ha_alert("Proxy '%s': cannot enable certificate generation, "
5133 "no CA certificate File configured at [%s:%d].\n",
5134 px->id, bind_conf->file, bind_conf->line);
Christopher Faulet31af49d2015-06-09 17:29:50 +02005135 goto load_error;
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005136 }
Christopher Faulet31af49d2015-06-09 17:29:50 +02005137
5138 /* read in the CA certificate */
5139 if (!(fp = fopen(bind_conf->ca_sign_file, "r"))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005140 ha_alert("Proxy '%s': Failed to read CA certificate file '%s' at [%s:%d].\n",
5141 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Faulet31af49d2015-06-09 17:29:50 +02005142 goto load_error;
5143 }
5144 if (!(cacert = PEM_read_X509(fp, NULL, NULL, NULL))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005145 ha_alert("Proxy '%s': Failed to read CA certificate file '%s' at [%s:%d].\n",
5146 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005147 goto read_error;
Christopher Faulet31af49d2015-06-09 17:29:50 +02005148 }
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005149 rewind(fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02005150 if (!(capkey = PEM_read_PrivateKey(fp, NULL, NULL, bind_conf->ca_sign_pass))) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01005151 ha_alert("Proxy '%s': Failed to read CA private key file '%s' at [%s:%d].\n",
5152 px->id, bind_conf->ca_sign_file, bind_conf->file, bind_conf->line);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005153 goto read_error;
Christopher Faulet31af49d2015-06-09 17:29:50 +02005154 }
Christopher Faulet31af49d2015-06-09 17:29:50 +02005155
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005156 fclose (fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02005157 bind_conf->ca_sign_cert = cacert;
5158 bind_conf->ca_sign_pkey = capkey;
5159 return err;
5160
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005161 read_error:
5162 fclose (fp);
Christopher Faulet31af49d2015-06-09 17:29:50 +02005163 if (capkey) EVP_PKEY_free(capkey);
5164 if (cacert) X509_free(cacert);
Christopher Fauletc6f02fb2015-10-09 10:53:31 +02005165 load_error:
5166 bind_conf->generate_certs = 0;
5167 err++;
Christopher Faulet31af49d2015-06-09 17:29:50 +02005168 return err;
5169}
5170
5171/* Release CA cert and private key used to generate certificated */
5172void
5173ssl_sock_free_ca(struct bind_conf *bind_conf)
5174{
Christopher Faulet31af49d2015-06-09 17:29:50 +02005175 if (bind_conf->ca_sign_pkey)
5176 EVP_PKEY_free(bind_conf->ca_sign_pkey);
5177 if (bind_conf->ca_sign_cert)
5178 X509_free(bind_conf->ca_sign_cert);
Willy Tarreau94ff03a2016-12-22 17:57:46 +01005179 bind_conf->ca_sign_pkey = NULL;
5180 bind_conf->ca_sign_cert = NULL;
Christopher Faulet31af49d2015-06-09 17:29:50 +02005181}
5182
Emeric Brun46591952012-05-18 15:47:34 +02005183/*
5184 * This function is called if SSL * context is not yet allocated. The function
5185 * is designed to be called before any other data-layer operation and sets the
5186 * handshake flag on the connection. It is safe to call it multiple times.
5187 * It returns 0 on success and -1 in error case.
5188 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005189static int ssl_sock_init(struct connection *conn, void **xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02005190{
Olivier Houchard66ab4982019-02-26 18:37:15 +01005191 struct ssl_sock_ctx *ctx;
Emeric Brun46591952012-05-18 15:47:34 +02005192 /* already initialized */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005193 if (*xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02005194 return 0;
5195
Willy Tarreau3c728722014-01-23 13:50:42 +01005196 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +02005197 return 0;
5198
Olivier Houchard66ab4982019-02-26 18:37:15 +01005199 ctx = pool_alloc(ssl_sock_ctx_pool);
5200 if (!ctx) {
5201 conn->err_code = CO_ER_SSL_NO_MEM;
5202 return -1;
5203 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005204 ctx->wait_event.tasklet = tasklet_new();
5205 if (!ctx->wait_event.tasklet) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02005206 conn->err_code = CO_ER_SSL_NO_MEM;
5207 pool_free(ssl_sock_ctx_pool, ctx);
5208 return -1;
5209 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005210 ctx->wait_event.tasklet->process = ssl_sock_io_cb;
5211 ctx->wait_event.tasklet->context = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02005212 ctx->wait_event.events = 0;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005213 ctx->sent_early_data = 0;
Olivier Houchardf6715e72019-12-19 15:02:39 +01005214 ctx->early_buf = BUF_NULL;
Olivier Houcharda8955d52019-04-07 22:00:38 +02005215 ctx->conn = conn;
Olivier Houchard81284e62019-06-06 13:21:23 +02005216 ctx->send_wait = NULL;
5217 ctx->recv_wait = NULL;
Emeric Brun87cfd662019-09-06 15:36:02 +02005218 ctx->xprt_st = 0;
5219 ctx->xprt_ctx = NULL;
Olivier Houcharda8955d52019-04-07 22:00:38 +02005220
5221 /* Only work with sockets for now, this should be adapted when we'll
5222 * add QUIC support.
5223 */
5224 ctx->xprt = xprt_get(XPRT_RAW);
Olivier Houchard19afb272019-05-23 18:24:07 +02005225 if (ctx->xprt->init) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02005226 if (ctx->xprt->init(conn, &ctx->xprt_ctx) != 0)
5227 goto err;
Olivier Houchard19afb272019-05-23 18:24:07 +02005228 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01005229
Willy Tarreau20879a02012-12-03 16:32:10 +01005230 if (global.maxsslconn && sslconns >= global.maxsslconn) {
5231 conn->err_code = CO_ER_SSL_TOO_MANY;
Olivier Houchardea8dd942019-05-20 14:02:16 +02005232 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01005233 }
Willy Tarreau403edff2012-09-06 11:58:37 +02005234
Emeric Brun46591952012-05-18 15:47:34 +02005235 /* If it is in client mode initiate SSL session
5236 in connect state otherwise accept state */
Willy Tarreau3fdb3662012-11-12 00:42:33 +01005237 if (objt_server(conn->target)) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005238 int may_retry = 1;
5239
5240 retry_connect:
Emeric Brun46591952012-05-18 15:47:34 +02005241 /* Alloc a new SSL session ctx */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005242 ctx->ssl = SSL_new(__objt_server(conn->target)->ssl_ctx.ctx);
5243 if (!ctx->ssl) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005244 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005245 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005246 goto retry_connect;
5247 }
Willy Tarreau20879a02012-12-03 16:32:10 +01005248 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005249 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01005250 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02005251 ctx->bio = BIO_new(ha_meth);
5252 if (!ctx->bio) {
Olivier Houchardb451b972020-01-24 15:17:38 +01005253 SSL_free(ctx->ssl);
5254 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005255 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005256 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005257 goto retry_connect;
5258 }
Emeric Brun55476152014-11-12 17:35:37 +01005259 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005260 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01005261 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02005262 BIO_set_data(ctx->bio, ctx);
Olivier Houcharda8955d52019-04-07 22:00:38 +02005263 SSL_set_bio(ctx->ssl, ctx->bio, ctx->bio);
Emeric Brun46591952012-05-18 15:47:34 +02005264
Evan Broderbe554312013-06-27 00:05:25 -07005265 /* set connection pointer */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005266 if (!SSL_set_ex_data(ctx->ssl, ssl_app_data_index, conn)) {
5267 SSL_free(ctx->ssl);
5268 ctx->ssl = NULL;
Emeric Brun55476152014-11-12 17:35:37 +01005269 conn->xprt_ctx = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005270 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005271 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005272 goto retry_connect;
5273 }
Emeric Brun55476152014-11-12 17:35:37 +01005274 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005275 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01005276 }
5277
Olivier Houchard66ab4982019-02-26 18:37:15 +01005278 SSL_set_connect_state(ctx->ssl);
Willy Tarreau07d94e42018-09-20 10:57:52 +02005279 if (__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr) {
5280 const unsigned char *ptr = __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr;
5281 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 +01005282 if (sess && !SSL_set_session(ctx->ssl, sess)) {
Olivier Houcharde6060c52017-11-16 17:42:52 +01005283 SSL_SESSION_free(sess);
Willy Tarreau07d94e42018-09-20 10:57:52 +02005284 free(__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr);
5285 __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr = NULL;
Olivier Houcharde6060c52017-11-16 17:42:52 +01005286 } else if (sess) {
5287 SSL_SESSION_free(sess);
Emeric Brun55476152014-11-12 17:35:37 +01005288 }
5289 }
Evan Broderbe554312013-06-27 00:05:25 -07005290
Emeric Brun46591952012-05-18 15:47:34 +02005291 /* leave init state and start handshake */
Willy Tarreau05737472012-09-04 08:03:39 +02005292 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Willy Tarreau403edff2012-09-06 11:58:37 +02005293
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01005294 _HA_ATOMIC_ADD(&sslconns, 1);
5295 _HA_ATOMIC_ADD(&totalsslconns, 1);
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005296 *xprt_ctx = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02005297 /* Start the handshake */
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005298 tasklet_wakeup(ctx->wait_event.tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02005299 if (conn->flags & CO_FL_ERROR)
5300 goto err;
Emeric Brun46591952012-05-18 15:47:34 +02005301 return 0;
5302 }
Willy Tarreau3fdb3662012-11-12 00:42:33 +01005303 else if (objt_listener(conn->target)) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005304 int may_retry = 1;
5305
5306 retry_accept:
Emeric Brun46591952012-05-18 15:47:34 +02005307 /* Alloc a new SSL session ctx */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005308 ctx->ssl = SSL_new(__objt_listener(conn->target)->bind_conf->initial_ctx);
5309 if (!ctx->ssl) {
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005310 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005311 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005312 goto retry_accept;
5313 }
Willy Tarreau20879a02012-12-03 16:32:10 +01005314 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005315 goto err;
Willy Tarreau20879a02012-12-03 16:32:10 +01005316 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02005317 ctx->bio = BIO_new(ha_meth);
5318 if (!ctx->bio) {
Olivier Houchardb451b972020-01-24 15:17:38 +01005319 SSL_free(ctx->ssl);
5320 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005321 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005322 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005323 goto retry_accept;
5324 }
Emeric Brun55476152014-11-12 17:35:37 +01005325 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005326 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01005327 }
Olivier Houcharda8955d52019-04-07 22:00:38 +02005328 BIO_set_data(ctx->bio, ctx);
Olivier Houcharda8955d52019-04-07 22:00:38 +02005329 SSL_set_bio(ctx->ssl, ctx->bio, ctx->bio);
Emeric Brun46591952012-05-18 15:47:34 +02005330
Emeric Brune1f38db2012-09-03 20:36:47 +02005331 /* set connection pointer */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005332 if (!SSL_set_ex_data(ctx->ssl, ssl_app_data_index, conn)) {
5333 SSL_free(ctx->ssl);
5334 ctx->ssl = NULL;
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005335 if (may_retry--) {
Willy Tarreaubafbe012017-11-24 17:34:44 +01005336 pool_gc(NULL);
Willy Tarreaufba03cd2014-11-13 13:48:58 +01005337 goto retry_accept;
5338 }
Emeric Brun55476152014-11-12 17:35:37 +01005339 conn->err_code = CO_ER_SSL_NO_MEM;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005340 goto err;
Emeric Brun55476152014-11-12 17:35:37 +01005341 }
5342
Frédéric Lécaille583362f2020-01-24 14:56:18 +01005343#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
5344 if (__objt_listener(conn->target)->bind_conf->ssl_conf.early_data) {
5345 b_alloc(&ctx->early_buf);
5346 SSL_set_max_early_data(ctx->ssl,
5347 /* Only allow early data if we managed to allocate
5348 * a buffer.
5349 */
5350 (!b_is_null(&ctx->early_buf)) ?
5351 global.tune.bufsize - global.tune.maxrewrite : 0);
5352 }
5353#endif
5354
Olivier Houchard66ab4982019-02-26 18:37:15 +01005355 SSL_set_accept_state(ctx->ssl);
Emeric Brune1f38db2012-09-03 20:36:47 +02005356
Emeric Brun46591952012-05-18 15:47:34 +02005357 /* leave init state and start handshake */
Willy Tarreau05737472012-09-04 08:03:39 +02005358 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Emmanuel Hocdet510fce52019-08-05 18:04:16 +02005359#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchardc2aae742017-09-22 18:26:28 +02005360 conn->flags |= CO_FL_EARLY_SSL_HS;
5361#endif
Willy Tarreau403edff2012-09-06 11:58:37 +02005362
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01005363 _HA_ATOMIC_ADD(&sslconns, 1);
5364 _HA_ATOMIC_ADD(&totalsslconns, 1);
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005365 *xprt_ctx = ctx;
Olivier Houchardea8dd942019-05-20 14:02:16 +02005366 /* Start the handshake */
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005367 tasklet_wakeup(ctx->wait_event.tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02005368 if (conn->flags & CO_FL_ERROR)
5369 goto err;
Emeric Brun46591952012-05-18 15:47:34 +02005370 return 0;
5371 }
5372 /* don't know how to handle such a target */
Willy Tarreau20879a02012-12-03 16:32:10 +01005373 conn->err_code = CO_ER_SSL_NO_TARGET;
Olivier Houchard66ab4982019-02-26 18:37:15 +01005374err:
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005375 if (ctx && ctx->wait_event.tasklet)
5376 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01005377 pool_free(ssl_sock_ctx_pool, ctx);
Emeric Brun46591952012-05-18 15:47:34 +02005378 return -1;
5379}
5380
5381
5382/* This is the callback which is used when an SSL handshake is pending. It
5383 * updates the FD status if it wants some polling before being called again.
5384 * It returns 0 if it fails in a fatal way or needs to poll to go further,
5385 * otherwise it returns non-zero and removes itself from the connection's
5386 * flags (the bit is provided in <flag> by the caller).
5387 */
Olivier Houchard000694c2019-05-23 14:45:12 +02005388static int ssl_sock_handshake(struct connection *conn, unsigned int flag)
Emeric Brun46591952012-05-18 15:47:34 +02005389{
Olivier Houchard66ab4982019-02-26 18:37:15 +01005390 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
Emeric Brun46591952012-05-18 15:47:34 +02005391 int ret;
5392
Willy Tarreau3c728722014-01-23 13:50:42 +01005393 if (!conn_ctrl_ready(conn))
Willy Tarreauf79c8172013-10-21 16:30:56 +02005394 return 0;
5395
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02005396 if (!conn->xprt_ctx)
Emeric Brun46591952012-05-18 15:47:34 +02005397 goto out_error;
5398
Willy Tarreau5db847a2019-05-09 14:13:35 +02005399#if HA_OPENSSL_VERSION_NUMBER >= 0x10101000L
Olivier Houchardc2aae742017-09-22 18:26:28 +02005400 /*
5401 * Check if we have early data. If we do, we have to read them
5402 * before SSL_do_handshake() is called, And there's no way to
5403 * detect early data, except to try to read them
5404 */
5405 if (conn->flags & CO_FL_EARLY_SSL_HS) {
Olivier Houchardf6715e72019-12-19 15:02:39 +01005406 size_t read_data = 0;
Olivier Houchardc2aae742017-09-22 18:26:28 +02005407
Olivier Houchardf6715e72019-12-19 15:02:39 +01005408 while (1) {
5409 ret = SSL_read_early_data(ctx->ssl,
5410 b_tail(&ctx->early_buf), b_room(&ctx->early_buf),
5411 &read_data);
5412 if (ret == SSL_READ_EARLY_DATA_ERROR)
5413 goto check_error;
5414 if (read_data > 0) {
5415 conn->flags |= CO_FL_EARLY_DATA;
5416 b_add(&ctx->early_buf, read_data);
5417 }
5418 if (ret == SSL_READ_EARLY_DATA_FINISH) {
5419 conn->flags &= ~CO_FL_EARLY_SSL_HS;
5420 if (!b_data(&ctx->early_buf))
5421 b_free(&ctx->early_buf);
5422 break;
5423 }
5424 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02005425 }
5426#endif
Emeric Brun674b7432012-11-08 19:21:55 +01005427 /* If we use SSL_do_handshake to process a reneg initiated by
5428 * the remote peer, it sometimes returns SSL_ERROR_SSL.
5429 * Usually SSL_write and SSL_read are used and process implicitly
5430 * the reneg handshake.
5431 * Here we use SSL_peek as a workaround for reneg.
5432 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005433 if ((conn->flags & CO_FL_CONNECTED) && SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun674b7432012-11-08 19:21:55 +01005434 char c;
5435
Olivier Houchard66ab4982019-02-26 18:37:15 +01005436 ret = SSL_peek(ctx->ssl, &c, 1);
Emeric Brun674b7432012-11-08 19:21:55 +01005437 if (ret <= 0) {
5438 /* handshake may have not been completed, let's find why */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005439 ret = SSL_get_error(ctx->ssl, ret);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005440
Emeric Brun674b7432012-11-08 19:21:55 +01005441 if (ret == SSL_ERROR_WANT_WRITE) {
5442 /* SSL handshake needs to write, L4 connection may not be ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02005443 if (!(ctx->wait_event.events & SUB_RETRY_SEND))
Olivier Houchardea8dd942019-05-20 14:02:16 +02005444 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Emeric Brun674b7432012-11-08 19:21:55 +01005445 return 0;
5446 }
5447 else if (ret == SSL_ERROR_WANT_READ) {
5448 /* handshake may have been completed but we have
5449 * no more data to read.
5450 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005451 if (!SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun674b7432012-11-08 19:21:55 +01005452 ret = 1;
5453 goto reneg_ok;
5454 }
5455 /* SSL handshake needs to read, L4 connection is ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02005456 if (!(ctx->wait_event.events & SUB_RETRY_RECV))
Olivier Houchardea8dd942019-05-20 14:02:16 +02005457 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
Emeric Brun674b7432012-11-08 19:21:55 +01005458 return 0;
5459 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02005460#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005461 else if (ret == SSL_ERROR_WANT_ASYNC) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02005462 ssl_async_process_fds(ctx);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005463 return 0;
5464 }
5465#endif
Emeric Brun674b7432012-11-08 19:21:55 +01005466 else if (ret == SSL_ERROR_SYSCALL) {
5467 /* if errno is null, then connection was successfully established */
5468 if (!errno && conn->flags & CO_FL_WAIT_L4_CONN)
5469 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Willy Tarreau20879a02012-12-03 16:32:10 +01005470 if (!conn->err_code) {
Lukas Tribus5db881f2019-07-08 14:29:15 +02005471#if defined(OPENSSL_IS_BORINGSSL) || defined(LIBRESSL_VERSION_NUMBER)
5472 /* do not handle empty handshakes in BoringSSL or LibreSSL */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005473 conn->err_code = CO_ER_SSL_HANDSHAKE;
5474#else
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005475 int empty_handshake;
Willy Tarreau5db847a2019-05-09 14:13:35 +02005476#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL)
Lukas Tribus5db881f2019-07-08 14:29:15 +02005477 /* use SSL_get_state() in OpenSSL >= 1.1.0; SSL_state() is broken */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005478 OSSL_HANDSHAKE_STATE state = SSL_get_state((SSL *)ctx->ssl);
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005479 empty_handshake = state == TLS_ST_BEFORE;
5480#else
Lukas Tribus5db881f2019-07-08 14:29:15 +02005481 /* access packet_length directly in OpenSSL <= 1.0.2; SSL_state() is broken */
5482 empty_handshake = !ctx->ssl->packet_length;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005483#endif
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005484 if (empty_handshake) {
Emeric Brun29f037d2014-04-25 19:05:36 +02005485 if (!errno) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005486 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02005487 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
5488 else
5489 conn->err_code = CO_ER_SSL_EMPTY;
5490 }
5491 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005492 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02005493 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
5494 else
5495 conn->err_code = CO_ER_SSL_ABORT;
5496 }
5497 }
5498 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005499 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02005500 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
Willy Tarreau20879a02012-12-03 16:32:10 +01005501 else
Emeric Brun29f037d2014-04-25 19:05:36 +02005502 conn->err_code = CO_ER_SSL_HANDSHAKE;
5503 }
Lukas Tribus5db881f2019-07-08 14:29:15 +02005504#endif /* BoringSSL or LibreSSL */
Willy Tarreau20879a02012-12-03 16:32:10 +01005505 }
Emeric Brun674b7432012-11-08 19:21:55 +01005506 goto out_error;
5507 }
5508 else {
5509 /* Fail on all other handshake errors */
5510 /* Note: OpenSSL may leave unread bytes in the socket's
5511 * buffer, causing an RST to be emitted upon close() on
5512 * TCP sockets. We first try to drain possibly pending
5513 * data to avoid this as much as possible.
5514 */
Willy Tarreaud85c4852015-03-13 00:40:28 +01005515 conn_sock_drain(conn);
Willy Tarreau20879a02012-12-03 16:32:10 +01005516 if (!conn->err_code)
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005517 conn->err_code = (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ?
Willy Tarreauf51c6982014-04-25 20:02:39 +02005518 CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE;
Emeric Brun674b7432012-11-08 19:21:55 +01005519 goto out_error;
5520 }
5521 }
5522 /* read some data: consider handshake completed */
5523 goto reneg_ok;
5524 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01005525 ret = SSL_do_handshake(ctx->ssl);
Olivier Houchardc2aae742017-09-22 18:26:28 +02005526check_error:
Emeric Brun46591952012-05-18 15:47:34 +02005527 if (ret != 1) {
5528 /* handshake did not complete, let's find why */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005529 ret = SSL_get_error(ctx->ssl, ret);
Emeric Brun46591952012-05-18 15:47:34 +02005530
5531 if (ret == SSL_ERROR_WANT_WRITE) {
5532 /* SSL handshake needs to write, L4 connection may not be ready */
Olivier Houchard03abf2d2019-05-28 10:12:02 +02005533 if (!(ctx->wait_event.events & SUB_RETRY_SEND))
Olivier Houchardea8dd942019-05-20 14:02:16 +02005534 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Emeric Brun46591952012-05-18 15:47:34 +02005535 return 0;
5536 }
5537 else if (ret == SSL_ERROR_WANT_READ) {
5538 /* SSL handshake needs to read, L4 connection is ready */
Olivier Houchardea8dd942019-05-20 14:02:16 +02005539 if (!(ctx->wait_event.events & SUB_RETRY_RECV))
Olivier Houchardea8dd942019-05-20 14:02:16 +02005540 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
5541 SUB_RETRY_RECV, &ctx->wait_event);
Emeric Brun46591952012-05-18 15:47:34 +02005542 return 0;
5543 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02005544#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005545 else if (ret == SSL_ERROR_WANT_ASYNC) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02005546 ssl_async_process_fds(ctx);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00005547 return 0;
5548 }
5549#endif
Willy Tarreau89230192012-09-28 20:22:13 +02005550 else if (ret == SSL_ERROR_SYSCALL) {
5551 /* if errno is null, then connection was successfully established */
5552 if (!errno && conn->flags & CO_FL_WAIT_L4_CONN)
5553 conn->flags &= ~CO_FL_WAIT_L4_CONN;
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005554 if (!conn->err_code) {
Lukas Tribus5db881f2019-07-08 14:29:15 +02005555#if defined(OPENSSL_IS_BORINGSSL) || defined(LIBRESSL_VERSION_NUMBER)
5556 /* do not handle empty handshakes in BoringSSL or LibreSSL */
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005557 conn->err_code = CO_ER_SSL_HANDSHAKE;
5558#else
5559 int empty_handshake;
Willy Tarreau5db847a2019-05-09 14:13:35 +02005560#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL)
Lukas Tribus5db881f2019-07-08 14:29:15 +02005561 /* use SSL_get_state() in OpenSSL >= 1.1.0; SSL_state() is broken */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005562 OSSL_HANDSHAKE_STATE state = SSL_get_state(ctx->ssl);
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005563 empty_handshake = state == TLS_ST_BEFORE;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005564#else
Lukas Tribus5db881f2019-07-08 14:29:15 +02005565 /* access packet_length directly in OpenSSL <= 1.0.2; SSL_state() is broken */
5566 empty_handshake = !ctx->ssl->packet_length;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02005567#endif
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005568 if (empty_handshake) {
5569 if (!errno) {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005570 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005571 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
5572 else
5573 conn->err_code = CO_ER_SSL_EMPTY;
5574 }
5575 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005576 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005577 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
5578 else
5579 conn->err_code = CO_ER_SSL_ABORT;
5580 }
Emeric Brun29f037d2014-04-25 19:05:36 +02005581 }
5582 else {
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005583 if (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT)
Emeric Brun29f037d2014-04-25 19:05:36 +02005584 conn->err_code = CO_ER_SSL_HANDSHAKE_HB;
5585 else
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01005586 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emeric Brun29f037d2014-04-25 19:05:36 +02005587 }
Lukas Tribus5db881f2019-07-08 14:29:15 +02005588#endif /* BoringSSL or LibreSSL */
Emeric Brun29f037d2014-04-25 19:05:36 +02005589 }
Willy Tarreau89230192012-09-28 20:22:13 +02005590 goto out_error;
5591 }
Emeric Brun46591952012-05-18 15:47:34 +02005592 else {
5593 /* Fail on all other handshake errors */
Willy Tarreau566dc552012-10-19 20:52:18 +02005594 /* Note: OpenSSL may leave unread bytes in the socket's
5595 * buffer, causing an RST to be emitted upon close() on
5596 * TCP sockets. We first try to drain possibly pending
5597 * data to avoid this as much as possible.
5598 */
Willy Tarreaud85c4852015-03-13 00:40:28 +01005599 conn_sock_drain(conn);
Willy Tarreau20879a02012-12-03 16:32:10 +01005600 if (!conn->err_code)
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005601 conn->err_code = (ctx->xprt_st & SSL_SOCK_RECV_HEARTBEAT) ?
Willy Tarreauf51c6982014-04-25 20:02:39 +02005602 CO_ER_SSL_KILLED_HB : CO_ER_SSL_HANDSHAKE;
Emeric Brun46591952012-05-18 15:47:34 +02005603 goto out_error;
5604 }
5605 }
Willy Tarreau5db847a2019-05-09 14:13:35 +02005606#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchard522eea72017-11-03 16:27:47 +01005607 else {
5608 /*
5609 * If the server refused the early data, we have to send a
5610 * 425 to the client, as we no longer have the data to sent
5611 * them again.
5612 */
5613 if ((conn->flags & CO_FL_EARLY_DATA) && (objt_server(conn->target))) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01005614 if (SSL_get_early_data_status(ctx->ssl) == SSL_EARLY_DATA_REJECTED) {
Olivier Houchard522eea72017-11-03 16:27:47 +01005615 conn->err_code = CO_ER_SSL_EARLY_FAILED;
5616 goto out_error;
5617 }
5618 }
5619 }
5620#endif
5621
Emeric Brun46591952012-05-18 15:47:34 +02005622
Emeric Brun674b7432012-11-08 19:21:55 +01005623reneg_ok:
Emeric Brunb5e42a82017-06-06 12:35:14 +00005624
Willy Tarreau5db847a2019-05-09 14:13:35 +02005625#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00005626 /* ASYNC engine API doesn't support moving read/write
5627 * buffers. So we disable ASYNC mode right after
5628 * the handshake to avoid buffer oveflows.
5629 */
5630 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01005631 SSL_clear_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00005632#endif
Emeric Brun46591952012-05-18 15:47:34 +02005633 /* Handshake succeeded */
Olivier Houchard66ab4982019-02-26 18:37:15 +01005634 if (!SSL_session_reused(ctx->ssl)) {
Willy Tarreau0c9c2722014-05-28 12:28:58 +02005635 if (objt_server(conn->target)) {
5636 update_freq_ctr(&global.ssl_be_keys_per_sec, 1);
5637 if (global.ssl_be_keys_per_sec.curr_ctr > global.ssl_be_keys_max)
5638 global.ssl_be_keys_max = global.ssl_be_keys_per_sec.curr_ctr;
Emeric Brun46591952012-05-18 15:47:34 +02005639 }
Willy Tarreau0c9c2722014-05-28 12:28:58 +02005640 else {
5641 update_freq_ctr(&global.ssl_fe_keys_per_sec, 1);
5642 if (global.ssl_fe_keys_per_sec.curr_ctr > global.ssl_fe_keys_max)
5643 global.ssl_fe_keys_max = global.ssl_fe_keys_per_sec.curr_ctr;
5644 }
Emeric Brun46591952012-05-18 15:47:34 +02005645 }
5646
5647 /* The connection is now established at both layers, it's time to leave */
5648 conn->flags &= ~(flag | CO_FL_WAIT_L4_CONN | CO_FL_WAIT_L6_CONN);
5649 return 1;
5650
5651 out_error:
Emeric Brun644cde02012-12-14 11:21:13 +01005652 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02005653 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01005654 ERR_clear_error();
5655
Emeric Brun9fa89732012-10-04 17:09:56 +02005656 /* free resumed session if exists */
Willy Tarreau07d94e42018-09-20 10:57:52 +02005657 if (objt_server(conn->target) && __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr) {
5658 free(__objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr);
5659 __objt_server(conn->target)->ssl_ctx.reused_sess[tid].ptr = NULL;
Emeric Brun9fa89732012-10-04 17:09:56 +02005660 }
5661
Emeric Brun46591952012-05-18 15:47:34 +02005662 /* Fail on all other handshake errors */
5663 conn->flags |= CO_FL_ERROR;
Willy Tarreau20879a02012-12-03 16:32:10 +01005664 if (!conn->err_code)
5665 conn->err_code = CO_ER_SSL_HANDSHAKE;
Emeric Brun46591952012-05-18 15:47:34 +02005666 return 0;
5667}
5668
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005669static int ssl_subscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
Olivier Houcharddf357842019-03-21 16:30:07 +01005670{
Olivier Houchardea8dd942019-05-20 14:02:16 +02005671 struct wait_event *sw;
5672 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005673
Olivier Houcharda37eb6a2019-06-24 18:57:39 +02005674 if (!ctx)
5675 return -1;
5676
Olivier Houchardea8dd942019-05-20 14:02:16 +02005677 if (event_type & SUB_RETRY_RECV) {
5678 sw = param;
5679 BUG_ON(ctx->recv_wait != NULL || (sw->events & SUB_RETRY_RECV));
5680 sw->events |= SUB_RETRY_RECV;
5681 ctx->recv_wait = sw;
5682 if (!(conn->flags & CO_FL_SSL_WAIT_HS) &&
5683 !(ctx->wait_event.events & SUB_RETRY_RECV))
5684 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV, &ctx->wait_event);
5685 event_type &= ~SUB_RETRY_RECV;
5686 }
5687 if (event_type & SUB_RETRY_SEND) {
5688sw = param;
5689 BUG_ON(ctx->send_wait != NULL || (sw->events & SUB_RETRY_SEND));
5690 sw->events |= SUB_RETRY_SEND;
5691 ctx->send_wait = sw;
5692 if (!(conn->flags & CO_FL_SSL_WAIT_HS) &&
5693 !(ctx->wait_event.events & SUB_RETRY_SEND))
5694 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
5695 event_type &= ~SUB_RETRY_SEND;
5696
5697 }
5698 if (event_type != 0)
5699 return -1;
5700 return 0;
Olivier Houcharddf357842019-03-21 16:30:07 +01005701}
5702
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005703static int ssl_unsubscribe(struct connection *conn, void *xprt_ctx, int event_type, void *param)
Olivier Houcharddf357842019-03-21 16:30:07 +01005704{
Olivier Houchardea8dd942019-05-20 14:02:16 +02005705 struct wait_event *sw;
5706 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005707
Olivier Houchardea8dd942019-05-20 14:02:16 +02005708 if (event_type & SUB_RETRY_RECV) {
5709 sw = param;
5710 BUG_ON(ctx->recv_wait != sw);
5711 ctx->recv_wait = NULL;
5712 sw->events &= ~SUB_RETRY_RECV;
5713 /* If we subscribed, and we're not doing the handshake,
5714 * then we subscribed because the upper layer asked for it,
5715 * as the upper layer is no longer interested, we can
5716 * unsubscribe too.
5717 */
5718 if (!(ctx->conn->flags & CO_FL_SSL_WAIT_HS) &&
5719 (ctx->wait_event.events & SUB_RETRY_RECV))
5720 conn_unsubscribe(conn, ctx->xprt_ctx, SUB_RETRY_RECV,
5721 &ctx->wait_event);
5722 }
5723 if (event_type & SUB_RETRY_SEND) {
5724 sw = param;
5725 BUG_ON(ctx->send_wait != sw);
5726 ctx->send_wait = NULL;
5727 sw->events &= ~SUB_RETRY_SEND;
5728 if (!(ctx->conn->flags & CO_FL_SSL_WAIT_HS) &&
5729 (ctx->wait_event.events & SUB_RETRY_SEND))
5730 conn_unsubscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND,
5731 &ctx->wait_event);
5732
5733 }
5734
5735 return 0;
Olivier Houcharddf357842019-03-21 16:30:07 +01005736}
5737
Olivier Houchard2e055482019-05-27 19:50:12 +02005738/* Use the provided XPRT as an underlying XPRT, and provide the old one.
5739 * Returns 0 on success, and non-zero on failure.
5740 */
5741static 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)
5742{
5743 struct ssl_sock_ctx *ctx = xprt_ctx;
5744
5745 if (oldxprt_ops != NULL)
5746 *oldxprt_ops = ctx->xprt;
5747 if (oldxprt_ctx != NULL)
5748 *oldxprt_ctx = ctx->xprt_ctx;
5749 ctx->xprt = toadd_ops;
5750 ctx->xprt_ctx = toadd_ctx;
5751 return 0;
5752}
5753
Olivier Houchard5149b592019-05-23 17:47:36 +02005754/* Remove the specified xprt. If if it our underlying XPRT, remove it and
5755 * return 0, otherwise just call the remove_xprt method from the underlying
5756 * XPRT.
5757 */
5758static int ssl_remove_xprt(struct connection *conn, void *xprt_ctx, void *toremove_ctx, const struct xprt_ops *newops, void *newctx)
5759{
5760 struct ssl_sock_ctx *ctx = xprt_ctx;
5761
5762 if (ctx->xprt_ctx == toremove_ctx) {
5763 ctx->xprt_ctx = newctx;
5764 ctx->xprt = newops;
5765 return 0;
5766 }
5767 return (ctx->xprt->remove_xprt(conn, ctx->xprt_ctx, toremove_ctx, newops, newctx));
5768}
5769
Olivier Houchardea8dd942019-05-20 14:02:16 +02005770static struct task *ssl_sock_io_cb(struct task *t, void *context, unsigned short state)
5771{
5772 struct ssl_sock_ctx *ctx = context;
5773
5774 /* First if we're doing an handshake, try that */
5775 if (ctx->conn->flags & CO_FL_SSL_WAIT_HS)
5776 ssl_sock_handshake(ctx->conn, CO_FL_SSL_WAIT_HS);
5777 /* If we had an error, or the handshake is done and I/O is available,
5778 * let the upper layer know.
5779 * If no mux was set up yet, and nobody subscribed, then call
5780 * xprt_done_cb() ourself if it's set, or destroy the connection,
5781 * we can't be sure conn_fd_handler() will be called again.
5782 */
5783 if ((ctx->conn->flags & CO_FL_ERROR) ||
5784 !(ctx->conn->flags & CO_FL_SSL_WAIT_HS)) {
5785 int ret = 0;
5786 int woke = 0;
5787
5788 /* On error, wake any waiter */
5789 if (ctx->recv_wait) {
5790 ctx->recv_wait->events &= ~SUB_RETRY_RECV;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005791 tasklet_wakeup(ctx->recv_wait->tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02005792 ctx->recv_wait = NULL;
5793 woke = 1;
5794 }
5795 if (ctx->send_wait) {
5796 ctx->send_wait->events &= ~SUB_RETRY_SEND;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02005797 tasklet_wakeup(ctx->send_wait->tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02005798 ctx->send_wait = NULL;
5799 woke = 1;
5800 }
5801 /* If we're the first xprt for the connection, let the
5802 * upper layers know. If xprt_done_cb() is set, call it,
5803 * otherwise, we should have a mux, so call its wake
5804 * method if we didn't woke a tasklet already.
5805 */
5806 if (ctx->conn->xprt_ctx == ctx) {
5807 if (ctx->conn->xprt_done_cb)
5808 ret = ctx->conn->xprt_done_cb(ctx->conn);
5809 if (ret >= 0 && !woke && ctx->conn->mux && ctx->conn->mux->wake)
5810 ctx->conn->mux->wake(ctx->conn);
5811 return NULL;
5812 }
5813 }
Olivier Houchardf6715e72019-12-19 15:02:39 +01005814#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
5815 /* If we have early data and somebody wants to receive, let them */
5816 else if (b_data(&ctx->early_buf) && ctx->recv_wait) {
5817 ctx->recv_wait->events &= ~SUB_RETRY_RECV;
5818 tasklet_wakeup(ctx->recv_wait->tasklet);
5819 ctx->recv_wait = NULL;
5820
5821 }
5822#endif
Olivier Houchardea8dd942019-05-20 14:02:16 +02005823 return NULL;
5824}
5825
Emeric Brun46591952012-05-18 15:47:34 +02005826/* Receive up to <count> bytes from connection <conn>'s socket and store them
Willy Tarreauabf08d92014-01-14 11:31:27 +01005827 * into buffer <buf>. Only one call to recv() is performed, unless the
Emeric Brun46591952012-05-18 15:47:34 +02005828 * buffer wraps, in which case a second call may be performed. The connection's
5829 * flags are updated with whatever special event is detected (error, read0,
5830 * empty). The caller is responsible for taking care of those events and
5831 * avoiding the call if inappropriate. The function does not call the
5832 * connection's polling update function, so the caller is responsible for this.
5833 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005834static 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 +02005835{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005836 struct ssl_sock_ctx *ctx = xprt_ctx;
Willy Tarreaubfc4d772018-07-18 11:22:03 +02005837 ssize_t ret;
5838 size_t try, done = 0;
Emeric Brun46591952012-05-18 15:47:34 +02005839
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02005840 conn_refresh_polling_flags(conn);
5841
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005842 if (!ctx)
Emeric Brun46591952012-05-18 15:47:34 +02005843 goto out_error;
5844
Olivier Houchardf6715e72019-12-19 15:02:39 +01005845#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
5846 if (b_data(&ctx->early_buf)) {
5847 try = b_contig_space(buf);
5848 if (try > b_data(&ctx->early_buf))
5849 try = b_data(&ctx->early_buf);
5850 memcpy(b_tail(buf), b_head(&ctx->early_buf), try);
5851 b_add(buf, try);
5852 b_del(&ctx->early_buf, try);
5853 if (b_data(&ctx->early_buf) == 0)
5854 b_free(&ctx->early_buf);
5855 return try;
5856 }
5857#endif
5858
Emeric Brun46591952012-05-18 15:47:34 +02005859 if (conn->flags & CO_FL_HANDSHAKE)
5860 /* a handshake was requested */
5861 return 0;
5862
Emeric Brun46591952012-05-18 15:47:34 +02005863 /* read the largest possible block. For this, we perform only one call
5864 * to recv() unless the buffer wraps and we exactly fill the first hunk,
5865 * in which case we accept to do it once again. A new attempt is made on
5866 * EINTR too.
5867 */
Willy Tarreau00b0fb92014-01-17 11:09:40 +01005868 while (count > 0) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02005869
Willy Tarreau591d4452018-06-15 17:21:00 +02005870 try = b_contig_space(buf);
5871 if (!try)
5872 break;
5873
Willy Tarreauabf08d92014-01-14 11:31:27 +01005874 if (try > count)
5875 try = count;
Willy Tarreau591d4452018-06-15 17:21:00 +02005876
Olivier Houchard66ab4982019-02-26 18:37:15 +01005877 ret = SSL_read(ctx->ssl, b_tail(buf), try);
Emmanuel Hocdet510fce52019-08-05 18:04:16 +02005878
Emeric Brune1f38db2012-09-03 20:36:47 +02005879 if (conn->flags & CO_FL_ERROR) {
5880 /* CO_FL_ERROR may be set by ssl_sock_infocbk */
Emeric Brun644cde02012-12-14 11:21:13 +01005881 goto out_error;
Emeric Brune1f38db2012-09-03 20:36:47 +02005882 }
Emeric Brun46591952012-05-18 15:47:34 +02005883 if (ret > 0) {
Olivier Houchardacd14032018-06-28 18:17:23 +02005884 b_add(buf, ret);
Emeric Brun46591952012-05-18 15:47:34 +02005885 done += ret;
Emeric Brun46591952012-05-18 15:47:34 +02005886 count -= ret;
Emeric Brun46591952012-05-18 15:47:34 +02005887 }
Emeric Brun46591952012-05-18 15:47:34 +02005888 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01005889 ret = SSL_get_error(ctx->ssl, ret);
Emeric Brun46591952012-05-18 15:47:34 +02005890 if (ret == SSL_ERROR_WANT_WRITE) {
Emeric Brun8af8dd12012-11-08 17:56:20 +01005891 /* handshake is running, and it needs to enable write */
Emeric Brun46591952012-05-18 15:47:34 +02005892 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02005893 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02005894#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00005895 /* Async mode can be re-enabled, because we're leaving data state.*/
5896 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01005897 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00005898#endif
Emeric Brun46591952012-05-18 15:47:34 +02005899 break;
5900 }
5901 else if (ret == SSL_ERROR_WANT_READ) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01005902 if (SSL_renegotiate_pending(ctx->ssl)) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02005903 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
5904 SUB_RETRY_RECV,
5905 &ctx->wait_event);
Emeric Brun282a76a2012-11-08 18:02:56 +01005906 /* handshake is running, and it may need to re-enable read */
5907 conn->flags |= CO_FL_SSL_WAIT_HS;
Willy Tarreau5db847a2019-05-09 14:13:35 +02005908#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00005909 /* Async mode can be re-enabled, because we're leaving data state.*/
5910 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01005911 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00005912#endif
Emeric Brun282a76a2012-11-08 18:02:56 +01005913 break;
5914 }
Emeric Brun46591952012-05-18 15:47:34 +02005915 break;
Olivier Houchardc2aae742017-09-22 18:26:28 +02005916 } else if (ret == SSL_ERROR_ZERO_RETURN)
5917 goto read0;
Christopher Faulet4ac77a92018-02-19 14:25:15 +01005918 /* For SSL_ERROR_SYSCALL, make sure to clear the error
5919 * stack before shutting down the connection for
5920 * reading. */
Olivier Houchard7e2e5052018-02-13 15:17:23 +01005921 if (ret == SSL_ERROR_SYSCALL && (!errno || errno == EAGAIN))
5922 goto clear_ssl_error;
Emeric Brun46591952012-05-18 15:47:34 +02005923 /* otherwise it's a real error */
5924 goto out_error;
5925 }
5926 }
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02005927 leave:
Emeric Brun46591952012-05-18 15:47:34 +02005928 return done;
5929
Christopher Faulet4ac77a92018-02-19 14:25:15 +01005930 clear_ssl_error:
5931 /* Clear openssl global errors stack */
5932 ssl_sock_dump_errors(conn);
5933 ERR_clear_error();
Emeric Brun46591952012-05-18 15:47:34 +02005934 read0:
5935 conn_sock_read0(conn);
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02005936 goto leave;
Christopher Faulet4ac77a92018-02-19 14:25:15 +01005937
Emeric Brun46591952012-05-18 15:47:34 +02005938 out_error:
Olivier Houchard7e2e5052018-02-13 15:17:23 +01005939 conn->flags |= CO_FL_ERROR;
Emeric Brun644cde02012-12-14 11:21:13 +01005940 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02005941 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01005942 ERR_clear_error();
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02005943 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +02005944}
5945
5946
Willy Tarreau787db9a2018-06-14 18:31:46 +02005947/* Send up to <count> pending bytes from buffer <buf> to connection <conn>'s
5948 * socket. <flags> may contain some CO_SFL_* flags to hint the system about
5949 * other pending data for example, but this flag is ignored at the moment.
Emeric Brun46591952012-05-18 15:47:34 +02005950 * Only one call to send() is performed, unless the buffer wraps, in which case
5951 * a second call may be performed. The connection's flags are updated with
5952 * whatever special event is detected (error, empty). The caller is responsible
5953 * for taking care of those events and avoiding the call if inappropriate. The
5954 * function does not call the connection's polling update function, so the caller
Willy Tarreau787db9a2018-06-14 18:31:46 +02005955 * is responsible for this. The buffer's output is not adjusted, it's up to the
5956 * caller to take care of this. It's up to the caller to update the buffer's
5957 * contents based on the return value.
Emeric Brun46591952012-05-18 15:47:34 +02005958 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005959static 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 +02005960{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005961 struct ssl_sock_ctx *ctx = xprt_ctx;
Willy Tarreau787db9a2018-06-14 18:31:46 +02005962 ssize_t ret;
5963 size_t try, done;
Emeric Brun46591952012-05-18 15:47:34 +02005964
5965 done = 0;
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02005966 conn_refresh_polling_flags(conn);
Emeric Brun46591952012-05-18 15:47:34 +02005967
Olivier Houcharde179d0e2019-03-21 18:27:17 +01005968 if (!ctx)
Emeric Brun46591952012-05-18 15:47:34 +02005969 goto out_error;
5970
Olivier Houchard010941f2019-05-03 20:56:19 +02005971 if (conn->flags & (CO_FL_HANDSHAKE | CO_FL_EARLY_SSL_HS))
Emeric Brun46591952012-05-18 15:47:34 +02005972 /* a handshake was requested */
5973 return 0;
5974
5975 /* send the largest possible block. For this we perform only one call
5976 * to send() unless the buffer wraps and we exactly fill the first hunk,
5977 * in which case we accept to do it once again.
5978 */
Willy Tarreau787db9a2018-06-14 18:31:46 +02005979 while (count) {
Willy Tarreau5db847a2019-05-09 14:13:35 +02005980#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchardc2aae742017-09-22 18:26:28 +02005981 size_t written_data;
5982#endif
5983
Willy Tarreau787db9a2018-06-14 18:31:46 +02005984 try = b_contig_data(buf, done);
5985 if (try > count)
5986 try = count;
Willy Tarreaubfd59462013-02-21 07:46:09 +01005987
Willy Tarreau7bed9452014-02-02 02:00:24 +01005988 if (!(flags & CO_SFL_STREAMER) &&
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005989 !(ctx->xprt_st & SSL_SOCK_SEND_UNLIMITED) &&
Willy Tarreauef934602016-12-22 23:12:01 +01005990 global_ssl.max_record && try > global_ssl.max_record) {
5991 try = global_ssl.max_record;
Willy Tarreau518cedd2014-02-17 15:43:01 +01005992 }
5993 else {
5994 /* we need to keep the information about the fact that
5995 * we're not limiting the upcoming send(), because if it
5996 * fails, we'll have to retry with at least as many data.
5997 */
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01005998 ctx->xprt_st |= SSL_SOCK_SEND_UNLIMITED;
Willy Tarreau518cedd2014-02-17 15:43:01 +01005999 }
Willy Tarreaubfd59462013-02-21 07:46:09 +01006000
Willy Tarreau5db847a2019-05-09 14:13:35 +02006001#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Olivier Houchard010941f2019-05-03 20:56:19 +02006002 if (!SSL_is_init_finished(ctx->ssl) && conn_is_back(conn)) {
Olivier Houchardc2aae742017-09-22 18:26:28 +02006003 unsigned int max_early;
6004
Olivier Houchard522eea72017-11-03 16:27:47 +01006005 if (objt_listener(conn->target))
Olivier Houchard66ab4982019-02-26 18:37:15 +01006006 max_early = SSL_get_max_early_data(ctx->ssl);
Olivier Houchard522eea72017-11-03 16:27:47 +01006007 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01006008 if (SSL_get0_session(ctx->ssl))
6009 max_early = SSL_SESSION_get_max_early_data(SSL_get0_session(ctx->ssl));
Olivier Houchard522eea72017-11-03 16:27:47 +01006010 else
6011 max_early = 0;
6012 }
6013
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006014 if (try + ctx->sent_early_data > max_early) {
6015 try -= (try + ctx->sent_early_data) - max_early;
Olivier Houchard522eea72017-11-03 16:27:47 +01006016 if (try <= 0) {
Olivier Houchard010941f2019-05-03 20:56:19 +02006017 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN;
Olivier Houchard965e84e2019-06-15 20:59:30 +02006018 tasklet_wakeup(ctx->wait_event.tasklet);
Olivier Houchardc2aae742017-09-22 18:26:28 +02006019 break;
Olivier Houchard522eea72017-11-03 16:27:47 +01006020 }
Olivier Houchardc2aae742017-09-22 18:26:28 +02006021 }
Olivier Houchard66ab4982019-02-26 18:37:15 +01006022 ret = SSL_write_early_data(ctx->ssl, b_peek(buf, done), try, &written_data);
Olivier Houchardc2aae742017-09-22 18:26:28 +02006023 if (ret == 1) {
6024 ret = written_data;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006025 ctx->sent_early_data += ret;
Olivier Houchard965e84e2019-06-15 20:59:30 +02006026 if (objt_server(conn->target)) {
Olivier Houchard522eea72017-11-03 16:27:47 +01006027 conn->flags |= CO_FL_SSL_WAIT_HS | CO_FL_WAIT_L6_CONN | CO_FL_EARLY_DATA;
Olivier Houchard965e84e2019-06-15 20:59:30 +02006028 /* Initiate the handshake, now */
6029 tasklet_wakeup(ctx->wait_event.tasklet);
6030 }
Olivier Houchard522eea72017-11-03 16:27:47 +01006031
Olivier Houchardc2aae742017-09-22 18:26:28 +02006032 }
6033
6034 } else
6035#endif
Olivier Houchard66ab4982019-02-26 18:37:15 +01006036 ret = SSL_write(ctx->ssl, b_peek(buf, done), try);
Willy Tarreau518cedd2014-02-17 15:43:01 +01006037
Emeric Brune1f38db2012-09-03 20:36:47 +02006038 if (conn->flags & CO_FL_ERROR) {
6039 /* CO_FL_ERROR may be set by ssl_sock_infocbk */
Emeric Brun644cde02012-12-14 11:21:13 +01006040 goto out_error;
Emeric Brune1f38db2012-09-03 20:36:47 +02006041 }
Emeric Brun46591952012-05-18 15:47:34 +02006042 if (ret > 0) {
Olivier Houchardf24502b2019-01-17 19:09:11 +01006043 /* A send succeeded, so we can consier ourself connected */
6044 conn->flags |= CO_FL_CONNECTED;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006045 ctx->xprt_st &= ~SSL_SOCK_SEND_UNLIMITED;
Willy Tarreau787db9a2018-06-14 18:31:46 +02006046 count -= ret;
Emeric Brun46591952012-05-18 15:47:34 +02006047 done += ret;
Emeric Brun46591952012-05-18 15:47:34 +02006048 }
6049 else {
Olivier Houchard66ab4982019-02-26 18:37:15 +01006050 ret = SSL_get_error(ctx->ssl, ret);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006051
Emeric Brun46591952012-05-18 15:47:34 +02006052 if (ret == SSL_ERROR_WANT_WRITE) {
Olivier Houchard66ab4982019-02-26 18:37:15 +01006053 if (SSL_renegotiate_pending(ctx->ssl)) {
Emeric Brun282a76a2012-11-08 18:02:56 +01006054 /* handshake is running, and it may need to re-enable write */
6055 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006056 ctx->xprt->subscribe(conn, ctx->xprt_ctx, SUB_RETRY_SEND, &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02006057#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00006058 /* Async mode can be re-enabled, because we're leaving data state.*/
6059 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006060 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00006061#endif
Emeric Brun282a76a2012-11-08 18:02:56 +01006062 break;
6063 }
Olivier Houchardea8dd942019-05-20 14:02:16 +02006064
Emeric Brun46591952012-05-18 15:47:34 +02006065 break;
6066 }
6067 else if (ret == SSL_ERROR_WANT_READ) {
Emeric Brun8af8dd12012-11-08 17:56:20 +01006068 /* handshake is running, and it needs to enable read */
Emeric Brun46591952012-05-18 15:47:34 +02006069 conn->flags |= CO_FL_SSL_WAIT_HS;
Olivier Houchardea8dd942019-05-20 14:02:16 +02006070 ctx->xprt->subscribe(conn, ctx->xprt_ctx,
6071 SUB_RETRY_RECV,
6072 &ctx->wait_event);
Willy Tarreau5db847a2019-05-09 14:13:35 +02006073#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brunb5e42a82017-06-06 12:35:14 +00006074 /* Async mode can be re-enabled, because we're leaving data state.*/
6075 if (global_ssl.async)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006076 SSL_set_mode(ctx->ssl, SSL_MODE_ASYNC);
Emeric Brunb5e42a82017-06-06 12:35:14 +00006077#endif
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006078 break;
6079 }
Emeric Brun46591952012-05-18 15:47:34 +02006080 goto out_error;
6081 }
6082 }
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02006083 leave:
Emeric Brun46591952012-05-18 15:47:34 +02006084 return done;
6085
6086 out_error:
Emeric Brun644cde02012-12-14 11:21:13 +01006087 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02006088 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01006089 ERR_clear_error();
6090
Emeric Brun46591952012-05-18 15:47:34 +02006091 conn->flags |= CO_FL_ERROR;
Willy Tarreau31d4dbe2017-10-25 09:32:15 +02006092 goto leave;
Emeric Brun46591952012-05-18 15:47:34 +02006093}
6094
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006095static void ssl_sock_close(struct connection *conn, void *xprt_ctx) {
Emeric Brun46591952012-05-18 15:47:34 +02006096
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006097 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006098
Olivier Houchardea8dd942019-05-20 14:02:16 +02006099
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006100 if (ctx) {
Olivier Houchardea8dd942019-05-20 14:02:16 +02006101 if (ctx->wait_event.events != 0)
6102 ctx->xprt->unsubscribe(ctx->conn, ctx->xprt_ctx,
6103 ctx->wait_event.events,
6104 &ctx->wait_event);
6105 if (ctx->send_wait) {
6106 ctx->send_wait->events &= ~SUB_RETRY_SEND;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006107 tasklet_wakeup(ctx->send_wait->tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006108 }
6109 if (ctx->recv_wait) {
6110 ctx->recv_wait->events &= ~SUB_RETRY_RECV;
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006111 tasklet_wakeup(ctx->recv_wait->tasklet);
Olivier Houchardea8dd942019-05-20 14:02:16 +02006112 }
Olivier Houchard692c1d02019-05-23 18:41:47 +02006113 if (ctx->xprt->close)
6114 ctx->xprt->close(conn, ctx->xprt_ctx);
Willy Tarreau5db847a2019-05-09 14:13:35 +02006115#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Emeric Brun3854e012017-05-17 20:42:48 +02006116 if (global_ssl.async) {
6117 OSSL_ASYNC_FD all_fd[32], afd;
6118 size_t num_all_fds = 0;
6119 int i;
6120
Olivier Houchard66ab4982019-02-26 18:37:15 +01006121 SSL_get_all_async_fds(ctx->ssl, NULL, &num_all_fds);
Emeric Brun3854e012017-05-17 20:42:48 +02006122 if (num_all_fds > 32) {
6123 send_log(NULL, LOG_EMERG, "haproxy: openssl returns too many async fds. It seems a bug. Process may crash\n");
6124 return;
6125 }
6126
Olivier Houchard66ab4982019-02-26 18:37:15 +01006127 SSL_get_all_async_fds(ctx->ssl, all_fd, &num_all_fds);
Emeric Brun3854e012017-05-17 20:42:48 +02006128
6129 /* If an async job is pending, we must try to
6130 to catch the end using polling before calling
6131 SSL_free */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006132 if (num_all_fds && SSL_waiting_for_async(ctx->ssl)) {
Emeric Brun3854e012017-05-17 20:42:48 +02006133 for (i=0 ; i < num_all_fds ; i++) {
6134 /* switch on an handler designed to
6135 * handle the SSL_free
6136 */
6137 afd = all_fd[i];
6138 fdtab[afd].iocb = ssl_async_fd_free;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006139 fdtab[afd].owner = ctx->ssl;
Emeric Brun3854e012017-05-17 20:42:48 +02006140 fd_want_recv(afd);
Emeric Brunce9e01c2017-05-31 10:02:53 +00006141 /* To ensure that the fd cache won't be used
6142 * and we'll catch a real RD event.
6143 */
6144 fd_cant_recv(afd);
Emeric Brun3854e012017-05-17 20:42:48 +02006145 }
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006146 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01006147 pool_free(ssl_sock_ctx_pool, ctx);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01006148 _HA_ATOMIC_ADD(&jobs, 1);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006149 return;
6150 }
Emeric Brun3854e012017-05-17 20:42:48 +02006151 /* Else we can remove the fds from the fdtab
6152 * and call SSL_free.
6153 * note: we do a fd_remove and not a delete
6154 * because the fd is owned by the engine.
6155 * the engine is responsible to close
6156 */
6157 for (i=0 ; i < num_all_fds ; i++)
6158 fd_remove(all_fd[i]);
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00006159 }
6160#endif
Olivier Houchard66ab4982019-02-26 18:37:15 +01006161 SSL_free(ctx->ssl);
Olivier Houchardf6715e72019-12-19 15:02:39 +01006162 b_free(&ctx->early_buf);
Willy Tarreau3c39a7d2019-06-14 14:42:29 +02006163 tasklet_free(ctx->wait_event.tasklet);
Olivier Houchard66ab4982019-02-26 18:37:15 +01006164 pool_free(ssl_sock_ctx_pool, ctx);
Olivier Houchard2be5a4c2019-03-08 18:54:43 +01006165 _HA_ATOMIC_SUB(&sslconns, 1);
Emeric Brun46591952012-05-18 15:47:34 +02006166 }
Emeric Brun46591952012-05-18 15:47:34 +02006167}
6168
6169/* This function tries to perform a clean shutdown on an SSL connection, and in
6170 * any case, flags the connection as reusable if no handshake was in progress.
6171 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006172static void ssl_sock_shutw(struct connection *conn, void *xprt_ctx, int clean)
Emeric Brun46591952012-05-18 15:47:34 +02006173{
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006174 struct ssl_sock_ctx *ctx = xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006175
Emeric Brun46591952012-05-18 15:47:34 +02006176 if (conn->flags & CO_FL_HANDSHAKE)
6177 return;
Emmanuel Hocdet405ff312017-01-08 14:07:39 +01006178 if (!clean)
6179 /* don't sent notify on SSL_shutdown */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006180 SSL_set_quiet_shutdown(ctx->ssl, 1);
Emeric Brun46591952012-05-18 15:47:34 +02006181 /* no handshake was in progress, try a clean ssl shutdown */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006182 if (SSL_shutdown(ctx->ssl) <= 0) {
Emeric Brun644cde02012-12-14 11:21:13 +01006183 /* Clear openssl global errors stack */
Thierry FOURNIER / OZON.IO8b068c22016-10-10 11:59:50 +02006184 ssl_sock_dump_errors(conn);
Emeric Brun644cde02012-12-14 11:21:13 +01006185 ERR_clear_error();
6186 }
Emeric Brun46591952012-05-18 15:47:34 +02006187}
6188
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01006189/* used for ppv2 pkey alog (can be used for logging) */
Willy Tarreau83061a82018-07-13 11:56:34 +02006190int ssl_sock_get_pkey_algo(struct connection *conn, struct buffer *out)
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01006191{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006192 struct ssl_sock_ctx *ctx;
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01006193 struct pkey_info *pkinfo;
6194 int bits = 0;
6195 int sig = TLSEXT_signature_anonymous;
6196 int len = -1;
6197
6198 if (!ssl_sock_is_ssl(conn))
6199 return 0;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006200 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006201 pkinfo = SSL_CTX_get_ex_data(SSL_get_SSL_CTX(ctx->ssl), ssl_pkey_info_index);
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01006202 if (pkinfo) {
6203 sig = pkinfo->sig;
6204 bits = pkinfo->bits;
6205 } else {
6206 /* multicert and generated cert have no pkey info */
6207 X509 *crt;
6208 EVP_PKEY *pkey;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006209 crt = SSL_get_certificate(ctx->ssl);
Emmanuel Hocdet96b78342017-10-31 15:46:07 +01006210 if (!crt)
6211 return 0;
6212 pkey = X509_get_pubkey(crt);
6213 if (pkey) {
6214 bits = EVP_PKEY_bits(pkey);
6215 switch(EVP_PKEY_base_id(pkey)) {
6216 case EVP_PKEY_RSA:
6217 sig = TLSEXT_signature_rsa;
6218 break;
6219 case EVP_PKEY_EC:
6220 sig = TLSEXT_signature_ecdsa;
6221 break;
6222 case EVP_PKEY_DSA:
6223 sig = TLSEXT_signature_dsa;
6224 break;
6225 }
6226 EVP_PKEY_free(pkey);
6227 }
6228 }
6229
6230 switch(sig) {
6231 case TLSEXT_signature_rsa:
6232 len = chunk_printf(out, "RSA%d", bits);
6233 break;
6234 case TLSEXT_signature_ecdsa:
6235 len = chunk_printf(out, "EC%d", bits);
6236 break;
6237 case TLSEXT_signature_dsa:
6238 len = chunk_printf(out, "DSA%d", bits);
6239 break;
6240 default:
6241 return 0;
6242 }
6243 if (len < 0)
6244 return 0;
6245 return 1;
6246}
6247
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01006248/* used for ppv2 cert signature (can be used for logging) */
6249const char *ssl_sock_get_cert_sig(struct connection *conn)
6250{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006251 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006252
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01006253 __OPENSSL_110_CONST__ ASN1_OBJECT *algorithm;
6254 X509 *crt;
6255
6256 if (!ssl_sock_is_ssl(conn))
6257 return NULL;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006258 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006259 crt = SSL_get_certificate(ctx->ssl);
Emmanuel Hocdet283e0042017-11-02 14:05:23 +01006260 if (!crt)
6261 return NULL;
6262 X509_ALGOR_get0(&algorithm, NULL, NULL, X509_get0_tbs_sigalg(crt));
6263 return OBJ_nid2sn(OBJ_obj2nid(algorithm));
6264}
6265
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01006266/* used for ppv2 authority */
6267const char *ssl_sock_get_sni(struct connection *conn)
6268{
6269#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006270 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006271
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01006272 if (!ssl_sock_is_ssl(conn))
6273 return NULL;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006274 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006275 return SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01006276#else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006277 return NULL;
Emmanuel Hocdet253c3b72018-02-01 18:29:59 +01006278#endif
6279}
6280
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02006281/* used for logging/ppv2, may be changed for a sample fetch later */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006282const char *ssl_sock_get_cipher_name(struct connection *conn)
6283{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006284 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006285
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02006286 if (!ssl_sock_is_ssl(conn))
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006287 return NULL;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006288 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006289 return SSL_get_cipher_name(ctx->ssl);
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006290}
6291
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02006292/* used for logging/ppv2, may be changed for a sample fetch later */
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006293const char *ssl_sock_get_proto_version(struct connection *conn)
6294{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006295 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006296
Emmanuel Hocdet01da5712017-10-13 16:59:49 +02006297 if (!ssl_sock_is_ssl(conn))
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006298 return NULL;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006299 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006300 return SSL_get_version(ctx->ssl);
Willy Tarreauffc3fcd2012-10-12 20:17:54 +02006301}
6302
Willy Tarreau8d598402012-10-22 17:58:39 +02006303/* Extract a serial from a cert, and copy it to a chunk.
6304 * Returns 1 if serial is found and copied, 0 if no serial found and
6305 * -1 if output is not large enough.
6306 */
6307static int
Willy Tarreau83061a82018-07-13 11:56:34 +02006308ssl_sock_get_serial(X509 *crt, struct buffer *out)
Willy Tarreau8d598402012-10-22 17:58:39 +02006309{
6310 ASN1_INTEGER *serial;
6311
6312 serial = X509_get_serialNumber(crt);
6313 if (!serial)
6314 return 0;
6315
6316 if (out->size < serial->length)
6317 return -1;
6318
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006319 memcpy(out->area, serial->data, serial->length);
6320 out->data = serial->length;
Willy Tarreau8d598402012-10-22 17:58:39 +02006321 return 1;
6322}
6323
Emeric Brun43e79582014-10-29 19:03:26 +01006324/* Extract a cert to der, and copy it to a chunk.
Joseph Herlant017b3da2018-11-15 09:07:59 -08006325 * Returns 1 if the cert is found and copied, 0 on der conversion failure
6326 * and -1 if the output is not large enough.
Emeric Brun43e79582014-10-29 19:03:26 +01006327 */
6328static int
Willy Tarreau83061a82018-07-13 11:56:34 +02006329ssl_sock_crt2der(X509 *crt, struct buffer *out)
Emeric Brun43e79582014-10-29 19:03:26 +01006330{
6331 int len;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006332 unsigned char *p = (unsigned char *) out->area;;
Emeric Brun43e79582014-10-29 19:03:26 +01006333
6334 len =i2d_X509(crt, NULL);
6335 if (len <= 0)
6336 return 1;
6337
6338 if (out->size < len)
6339 return -1;
6340
6341 i2d_X509(crt,&p);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006342 out->data = len;
Emeric Brun43e79582014-10-29 19:03:26 +01006343 return 1;
6344}
6345
Emeric Brunce5ad802012-10-22 14:11:22 +02006346
Willy Tarreau83061a82018-07-13 11:56:34 +02006347/* Copy Date in ASN1_UTCTIME format in struct buffer out.
Emeric Brunce5ad802012-10-22 14:11:22 +02006348 * Returns 1 if serial is found and copied, 0 if no valid time found
6349 * and -1 if output is not large enough.
6350 */
6351static int
Willy Tarreau83061a82018-07-13 11:56:34 +02006352ssl_sock_get_time(ASN1_TIME *tm, struct buffer *out)
Emeric Brunce5ad802012-10-22 14:11:22 +02006353{
6354 if (tm->type == V_ASN1_GENERALIZEDTIME) {
6355 ASN1_GENERALIZEDTIME *gentm = (ASN1_GENERALIZEDTIME *)tm;
6356
6357 if (gentm->length < 12)
6358 return 0;
6359 if (gentm->data[0] != 0x32 || gentm->data[1] != 0x30)
6360 return 0;
6361 if (out->size < gentm->length-2)
6362 return -1;
6363
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006364 memcpy(out->area, gentm->data+2, gentm->length-2);
6365 out->data = gentm->length-2;
Emeric Brunce5ad802012-10-22 14:11:22 +02006366 return 1;
6367 }
6368 else if (tm->type == V_ASN1_UTCTIME) {
6369 ASN1_UTCTIME *utctm = (ASN1_UTCTIME *)tm;
6370
6371 if (utctm->length < 10)
6372 return 0;
6373 if (utctm->data[0] >= 0x35)
6374 return 0;
6375 if (out->size < utctm->length)
6376 return -1;
6377
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006378 memcpy(out->area, utctm->data, utctm->length);
6379 out->data = utctm->length;
Emeric Brunce5ad802012-10-22 14:11:22 +02006380 return 1;
6381 }
6382
6383 return 0;
6384}
6385
Emeric Brun87855892012-10-17 17:39:35 +02006386/* Extract an entry from a X509_NAME and copy its value to an output chunk.
6387 * Returns 1 if entry found, 0 if entry not found, or -1 if output not large enough.
6388 */
6389static int
Willy Tarreau83061a82018-07-13 11:56:34 +02006390ssl_sock_get_dn_entry(X509_NAME *a, const struct buffer *entry, int pos,
6391 struct buffer *out)
Emeric Brun87855892012-10-17 17:39:35 +02006392{
6393 X509_NAME_ENTRY *ne;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006394 ASN1_OBJECT *obj;
6395 ASN1_STRING *data;
6396 const unsigned char *data_ptr;
6397 int data_len;
Emeric Brun87855892012-10-17 17:39:35 +02006398 int i, j, n;
6399 int cur = 0;
6400 const char *s;
6401 char tmp[128];
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006402 int name_count;
6403
6404 name_count = X509_NAME_entry_count(a);
Emeric Brun87855892012-10-17 17:39:35 +02006405
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006406 out->data = 0;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006407 for (i = 0; i < name_count; i++) {
Emeric Brun87855892012-10-17 17:39:35 +02006408 if (pos < 0)
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006409 j = (name_count-1) - i;
Emeric Brun87855892012-10-17 17:39:35 +02006410 else
6411 j = i;
6412
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006413 ne = X509_NAME_get_entry(a, j);
6414 obj = X509_NAME_ENTRY_get_object(ne);
6415 data = X509_NAME_ENTRY_get_data(ne);
6416 data_ptr = ASN1_STRING_get0_data(data);
6417 data_len = ASN1_STRING_length(data);
6418 n = OBJ_obj2nid(obj);
Emeric Brun87855892012-10-17 17:39:35 +02006419 if ((n == NID_undef) || ((s = OBJ_nid2sn(n)) == NULL)) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006420 i2t_ASN1_OBJECT(tmp, sizeof(tmp), obj);
Emeric Brun87855892012-10-17 17:39:35 +02006421 s = tmp;
6422 }
6423
6424 if (chunk_strcasecmp(entry, s) != 0)
6425 continue;
6426
6427 if (pos < 0)
6428 cur--;
6429 else
6430 cur++;
6431
6432 if (cur != pos)
6433 continue;
6434
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006435 if (data_len > out->size)
Emeric Brun87855892012-10-17 17:39:35 +02006436 return -1;
6437
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006438 memcpy(out->area, data_ptr, data_len);
6439 out->data = data_len;
Emeric Brun87855892012-10-17 17:39:35 +02006440 return 1;
6441 }
6442
6443 return 0;
6444
6445}
6446
6447/* Extract and format full DN from a X509_NAME and copy result into a chunk
6448 * Returns 1 if dn entries exits, 0 if no dn entry found or -1 if output is not large enough.
6449 */
6450static int
Willy Tarreau83061a82018-07-13 11:56:34 +02006451ssl_sock_get_dn_oneline(X509_NAME *a, struct buffer *out)
Emeric Brun87855892012-10-17 17:39:35 +02006452{
6453 X509_NAME_ENTRY *ne;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006454 ASN1_OBJECT *obj;
6455 ASN1_STRING *data;
6456 const unsigned char *data_ptr;
6457 int data_len;
Emeric Brun87855892012-10-17 17:39:35 +02006458 int i, n, ln;
6459 int l = 0;
6460 const char *s;
6461 char *p;
6462 char tmp[128];
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006463 int name_count;
6464
6465
6466 name_count = X509_NAME_entry_count(a);
Emeric Brun87855892012-10-17 17:39:35 +02006467
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006468 out->data = 0;
6469 p = out->area;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006470 for (i = 0; i < name_count; i++) {
6471 ne = X509_NAME_get_entry(a, i);
6472 obj = X509_NAME_ENTRY_get_object(ne);
6473 data = X509_NAME_ENTRY_get_data(ne);
6474 data_ptr = ASN1_STRING_get0_data(data);
6475 data_len = ASN1_STRING_length(data);
6476 n = OBJ_obj2nid(obj);
Emeric Brun87855892012-10-17 17:39:35 +02006477 if ((n == NID_undef) || ((s = OBJ_nid2sn(n)) == NULL)) {
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006478 i2t_ASN1_OBJECT(tmp, sizeof(tmp), obj);
Emeric Brun87855892012-10-17 17:39:35 +02006479 s = tmp;
6480 }
6481 ln = strlen(s);
6482
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006483 l += 1 + ln + 1 + data_len;
Emeric Brun87855892012-10-17 17:39:35 +02006484 if (l > out->size)
6485 return -1;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006486 out->data = l;
Emeric Brun87855892012-10-17 17:39:35 +02006487
6488 *(p++)='/';
6489 memcpy(p, s, ln);
6490 p += ln;
6491 *(p++)='=';
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02006492 memcpy(p, data_ptr, data_len);
6493 p += data_len;
Emeric Brun87855892012-10-17 17:39:35 +02006494 }
6495
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006496 if (!out->data)
Emeric Brun87855892012-10-17 17:39:35 +02006497 return 0;
6498
6499 return 1;
6500}
6501
Olivier Houchardab28a322018-12-21 19:45:40 +01006502void ssl_sock_set_alpn(struct connection *conn, const unsigned char *alpn, int len)
6503{
6504#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006505 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006506
Olivier Houchardaa2ecea2019-06-28 14:10:33 +02006507 if (!ssl_sock_is_ssl(conn))
6508 return;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006509 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006510 SSL_set_alpn_protos(ctx->ssl, alpn, len);
Olivier Houchardab28a322018-12-21 19:45:40 +01006511#endif
6512}
6513
Willy Tarreau119a4082016-12-22 21:58:38 +01006514/* Sets advertised SNI for outgoing connections. Please set <hostname> to NULL
6515 * to disable SNI.
6516 */
Willy Tarreau63076412015-07-10 11:33:32 +02006517void ssl_sock_set_servername(struct connection *conn, const char *hostname)
6518{
6519#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006520 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006521
Willy Tarreau119a4082016-12-22 21:58:38 +01006522 char *prev_name;
6523
Willy Tarreau63076412015-07-10 11:33:32 +02006524 if (!ssl_sock_is_ssl(conn))
6525 return;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006526 ctx = conn->xprt_ctx;
Willy Tarreau63076412015-07-10 11:33:32 +02006527
Willy Tarreau119a4082016-12-22 21:58:38 +01006528 /* if the SNI changes, we must destroy the reusable context so that a
6529 * new connection will present a new SNI. As an optimization we could
6530 * later imagine having a small cache of ssl_ctx to hold a few SNI per
6531 * server.
6532 */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006533 prev_name = (char *)SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau119a4082016-12-22 21:58:38 +01006534 if ((!prev_name && hostname) ||
6535 (prev_name && (!hostname || strcmp(hostname, prev_name) != 0)))
Olivier Houchard66ab4982019-02-26 18:37:15 +01006536 SSL_set_session(ctx->ssl, NULL);
Willy Tarreau119a4082016-12-22 21:58:38 +01006537
Olivier Houchard66ab4982019-02-26 18:37:15 +01006538 SSL_set_tlsext_host_name(ctx->ssl, hostname);
Willy Tarreau63076412015-07-10 11:33:32 +02006539#endif
6540}
6541
Emeric Brun0abf8362014-06-24 18:26:41 +02006542/* Extract peer certificate's common name into the chunk dest
6543 * Returns
6544 * the len of the extracted common name
6545 * or 0 if no CN found in DN
6546 * or -1 on error case (i.e. no peer certificate)
6547 */
Willy Tarreau83061a82018-07-13 11:56:34 +02006548int ssl_sock_get_remote_common_name(struct connection *conn,
6549 struct buffer *dest)
David Safb76832014-05-08 23:42:08 -04006550{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006551 struct ssl_sock_ctx *ctx;
David Safb76832014-05-08 23:42:08 -04006552 X509 *crt = NULL;
6553 X509_NAME *name;
David Safb76832014-05-08 23:42:08 -04006554 const char find_cn[] = "CN";
Willy Tarreau83061a82018-07-13 11:56:34 +02006555 const struct buffer find_cn_chunk = {
Willy Tarreau843b7cb2018-07-13 10:54:26 +02006556 .area = (char *)&find_cn,
6557 .data = sizeof(find_cn)-1
David Safb76832014-05-08 23:42:08 -04006558 };
Emeric Brun0abf8362014-06-24 18:26:41 +02006559 int result = -1;
David Safb76832014-05-08 23:42:08 -04006560
6561 if (!ssl_sock_is_ssl(conn))
Emeric Brun0abf8362014-06-24 18:26:41 +02006562 goto out;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006563 ctx = conn->xprt_ctx;
David Safb76832014-05-08 23:42:08 -04006564
6565 /* SSL_get_peer_certificate, it increase X509 * ref count */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006566 crt = SSL_get_peer_certificate(ctx->ssl);
David Safb76832014-05-08 23:42:08 -04006567 if (!crt)
6568 goto out;
6569
6570 name = X509_get_subject_name(crt);
6571 if (!name)
6572 goto out;
David Safb76832014-05-08 23:42:08 -04006573
Emeric Brun0abf8362014-06-24 18:26:41 +02006574 result = ssl_sock_get_dn_entry(name, &find_cn_chunk, 1, dest);
6575out:
David Safb76832014-05-08 23:42:08 -04006576 if (crt)
6577 X509_free(crt);
6578
6579 return result;
6580}
6581
Dave McCowan328fb582014-07-30 10:39:13 -04006582/* returns 1 if client passed a certificate for this session, 0 if not */
6583int ssl_sock_get_cert_used_sess(struct connection *conn)
6584{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006585 struct ssl_sock_ctx *ctx;
Dave McCowan328fb582014-07-30 10:39:13 -04006586 X509 *crt = NULL;
6587
6588 if (!ssl_sock_is_ssl(conn))
6589 return 0;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006590 ctx = conn->xprt_ctx;
Dave McCowan328fb582014-07-30 10:39:13 -04006591
6592 /* SSL_get_peer_certificate, it increase X509 * ref count */
Olivier Houchard66ab4982019-02-26 18:37:15 +01006593 crt = SSL_get_peer_certificate(ctx->ssl);
Dave McCowan328fb582014-07-30 10:39:13 -04006594 if (!crt)
6595 return 0;
6596
6597 X509_free(crt);
6598 return 1;
6599}
6600
6601/* returns 1 if client passed a certificate for this connection, 0 if not */
6602int ssl_sock_get_cert_used_conn(struct connection *conn)
David Safb76832014-05-08 23:42:08 -04006603{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006604 struct ssl_sock_ctx *ctx;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006605
David Safb76832014-05-08 23:42:08 -04006606 if (!ssl_sock_is_ssl(conn))
6607 return 0;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006608 ctx = conn->xprt_ctx;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006609 return SSL_SOCK_ST_FL_VERIFY_DONE & ctx->xprt_st ? 1 : 0;
David Safb76832014-05-08 23:42:08 -04006610}
6611
6612/* returns result from SSL verify */
6613unsigned int ssl_sock_get_verify_result(struct connection *conn)
6614{
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006615 struct ssl_sock_ctx *ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006616
David Safb76832014-05-08 23:42:08 -04006617 if (!ssl_sock_is_ssl(conn))
6618 return (unsigned int)X509_V_ERR_APPLICATION_VERIFICATION;
Christopher Faulet4517b0c2019-09-10 10:12:03 +02006619 ctx = conn->xprt_ctx;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006620 return (unsigned int)SSL_get_verify_result(ctx->ssl);
David Safb76832014-05-08 23:42:08 -04006621}
6622
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006623/* Returns the application layer protocol name in <str> and <len> when known.
6624 * Zero is returned if the protocol name was not found, otherwise non-zero is
6625 * returned. The string is allocated in the SSL context and doesn't have to be
6626 * freed by the caller. NPN is also checked if available since older versions
6627 * of openssl (1.0.1) which are more common in field only support this one.
6628 */
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006629static int ssl_sock_get_alpn(const struct connection *conn, void *xprt_ctx, const char **str, int *len)
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006630{
Olivier Houchard66ab4982019-02-26 18:37:15 +01006631#if defined(TLSEXT_TYPE_application_layer_protocol_negotiation) || \
6632 defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006633 struct ssl_sock_ctx *ctx = xprt_ctx;
6634 if (!ctx)
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006635 return 0;
6636
6637 *str = NULL;
6638
6639#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Olivier Houchard66ab4982019-02-26 18:37:15 +01006640 SSL_get0_alpn_selected(ctx->ssl, (const unsigned char **)str, (unsigned *)len);
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006641 if (*str)
6642 return 1;
6643#endif
Bernard Spil13c53f82018-02-15 13:34:58 +01006644#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006645 SSL_get0_next_proto_negotiated(ctx->ssl, (const unsigned char **)str, (unsigned *)len);
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006646 if (*str)
6647 return 1;
6648#endif
Olivier Houcharde179d0e2019-03-21 18:27:17 +01006649#endif
Willy Tarreau8743f7e2016-12-04 18:44:29 +01006650 return 0;
6651}
6652
Willy Tarreau7875d092012-09-10 08:20:03 +02006653/***** Below are some sample fetching functions for ACL/patterns *****/
6654
Olivier Houchardccaa7de2017-10-02 11:51:03 +02006655static int
6656smp_fetch_ssl_fc_has_early(const struct arg *args, struct sample *smp, const char *kw, void *private)
6657{
6658 struct connection *conn;
6659
6660 conn = objt_conn(smp->sess->origin);
6661 if (!conn || conn->xprt != &ssl_sock)
6662 return 0;
6663
6664 smp->flags = 0;
6665 smp->data.type = SMP_T_BOOL;
Emmanuel Hocdetbb8643c2019-08-07 14:44:49 +02006666#ifdef OPENSSL_IS_BORINGSSL
6667 {
6668 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
6669 smp->data.u.sint = (SSL_in_early_data(ctx->ssl) &&
6670 SSL_early_data_accepted(ctx->ssl));
6671 }
6672#else
Olivier Houchard25ae45a2017-11-29 19:51:19 +01006673 smp->data.u.sint = ((conn->flags & CO_FL_EARLY_DATA) &&
Olivier Houchard629693f2020-01-23 14:57:36 +01006674 (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS))) ? 1 : 0;
Emmanuel Hocdetbb8643c2019-08-07 14:44:49 +02006675#endif
Olivier Houchardccaa7de2017-10-02 11:51:03 +02006676 return 1;
6677}
6678
Emeric Brune64aef12012-09-21 13:15:06 +02006679/* boolean, returns true if client cert was present */
6680static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006681smp_fetch_ssl_fc_has_crt(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brune64aef12012-09-21 13:15:06 +02006682{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006683 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006684 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006685
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006686 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006687 if (!conn || conn->xprt != &ssl_sock)
Emeric Brune64aef12012-09-21 13:15:06 +02006688 return 0;
6689
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006690 ctx = conn->xprt_ctx;
6691
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006692 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brune64aef12012-09-21 13:15:06 +02006693 smp->flags |= SMP_F_MAY_CHANGE;
6694 return 0;
6695 }
6696
6697 smp->flags = 0;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006698 smp->data.type = SMP_T_BOOL;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01006699 smp->data.u.sint = SSL_SOCK_ST_FL_VERIFY_DONE & ctx->xprt_st ? 1 : 0;
Emeric Brune64aef12012-09-21 13:15:06 +02006700
6701 return 1;
6702}
6703
Emeric Brun43e79582014-10-29 19:03:26 +01006704/* binary, returns a certificate in a binary chunk (der/raw).
6705 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6706 * should be use.
6707 */
6708static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006709smp_fetch_ssl_x_der(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun43e79582014-10-29 19:03:26 +01006710{
6711 int cert_peer = (kw[4] == 'c') ? 1 : 0;
6712 X509 *crt = NULL;
6713 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006714 struct buffer *smp_trash;
Emeric Brun43e79582014-10-29 19:03:26 +01006715 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006716 struct ssl_sock_ctx *ctx;
Emeric Brun43e79582014-10-29 19:03:26 +01006717
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006718 conn = objt_conn(smp->sess->origin);
Emeric Brun43e79582014-10-29 19:03:26 +01006719 if (!conn || conn->xprt != &ssl_sock)
6720 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006721 ctx = conn->xprt_ctx;
Emeric Brun43e79582014-10-29 19:03:26 +01006722
6723 if (!(conn->flags & CO_FL_CONNECTED)) {
6724 smp->flags |= SMP_F_MAY_CHANGE;
6725 return 0;
6726 }
6727
6728 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006729 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brun43e79582014-10-29 19:03:26 +01006730 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006731 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun43e79582014-10-29 19:03:26 +01006732
6733 if (!crt)
6734 goto out;
6735
6736 smp_trash = get_trash_chunk();
6737 if (ssl_sock_crt2der(crt, smp_trash) <= 0)
6738 goto out;
6739
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006740 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006741 smp->data.type = SMP_T_BIN;
Emeric Brun43e79582014-10-29 19:03:26 +01006742 ret = 1;
6743out:
6744 /* SSL_get_peer_certificate, it increase X509 * ref count */
6745 if (cert_peer && crt)
6746 X509_free(crt);
6747 return ret;
6748}
6749
Emeric Brunba841a12014-04-30 17:05:08 +02006750/* binary, returns serial of certificate in a binary chunk.
6751 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6752 * should be use.
6753 */
Willy Tarreau8d598402012-10-22 17:58:39 +02006754static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006755smp_fetch_ssl_x_serial(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau8d598402012-10-22 17:58:39 +02006756{
Emeric Brunba841a12014-04-30 17:05:08 +02006757 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Willy Tarreau8d598402012-10-22 17:58:39 +02006758 X509 *crt = NULL;
6759 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006760 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006761 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006762 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006763
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006764 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006765 if (!conn || conn->xprt != &ssl_sock)
Willy Tarreau8d598402012-10-22 17:58:39 +02006766 return 0;
6767
Olivier Houchard66ab4982019-02-26 18:37:15 +01006768 ctx = conn->xprt_ctx;
6769
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006770 if (!(conn->flags & CO_FL_CONNECTED)) {
Willy Tarreau8d598402012-10-22 17:58:39 +02006771 smp->flags |= SMP_F_MAY_CHANGE;
6772 return 0;
6773 }
6774
Emeric Brunba841a12014-04-30 17:05:08 +02006775 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006776 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006777 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006778 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006779
Willy Tarreau8d598402012-10-22 17:58:39 +02006780 if (!crt)
6781 goto out;
6782
Willy Tarreau47ca5452012-12-23 20:22:19 +01006783 smp_trash = get_trash_chunk();
Willy Tarreau8d598402012-10-22 17:58:39 +02006784 if (ssl_sock_get_serial(crt, smp_trash) <= 0)
6785 goto out;
6786
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006787 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006788 smp->data.type = SMP_T_BIN;
Willy Tarreau8d598402012-10-22 17:58:39 +02006789 ret = 1;
6790out:
Emeric Brunba841a12014-04-30 17:05:08 +02006791 /* SSL_get_peer_certificate, it increase X509 * ref count */
6792 if (cert_peer && crt)
Willy Tarreau8d598402012-10-22 17:58:39 +02006793 X509_free(crt);
6794 return ret;
6795}
Emeric Brune64aef12012-09-21 13:15:06 +02006796
Emeric Brunba841a12014-04-30 17:05:08 +02006797/* binary, returns the client certificate's SHA-1 fingerprint (SHA-1 hash of DER-encoded certificate) in a binary chunk.
6798 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6799 * should be use.
6800 */
James Votha051b4a2013-05-14 20:37:59 +02006801static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006802smp_fetch_ssl_x_sha1(const struct arg *args, struct sample *smp, const char *kw, void *private)
James Votha051b4a2013-05-14 20:37:59 +02006803{
Emeric Brunba841a12014-04-30 17:05:08 +02006804 int cert_peer = (kw[4] == 'c') ? 1 : 0;
James Votha051b4a2013-05-14 20:37:59 +02006805 X509 *crt = NULL;
6806 const EVP_MD *digest;
6807 int ret = 0;
Willy Tarreau767e8ad2020-02-25 08:59:23 +01006808 unsigned int len = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006809 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006810 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006811 struct ssl_sock_ctx *ctx;
James Votha051b4a2013-05-14 20:37:59 +02006812
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006813 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006814 if (!conn || conn->xprt != &ssl_sock)
6815 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006816 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006817
6818 if (!(conn->flags & CO_FL_CONNECTED)) {
James Votha051b4a2013-05-14 20:37:59 +02006819 smp->flags |= SMP_F_MAY_CHANGE;
6820 return 0;
6821 }
6822
Emeric Brunba841a12014-04-30 17:05:08 +02006823 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006824 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006825 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006826 crt = SSL_get_certificate(ctx->ssl);
James Votha051b4a2013-05-14 20:37:59 +02006827 if (!crt)
6828 goto out;
6829
6830 smp_trash = get_trash_chunk();
6831 digest = EVP_sha1();
Willy Tarreau767e8ad2020-02-25 08:59:23 +01006832 X509_digest(crt, digest, (unsigned char *) smp_trash->area, &len);
6833 smp_trash->data = len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006834 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006835 smp->data.type = SMP_T_BIN;
James Votha051b4a2013-05-14 20:37:59 +02006836 ret = 1;
6837out:
Emeric Brunba841a12014-04-30 17:05:08 +02006838 /* SSL_get_peer_certificate, it increase X509 * ref count */
6839 if (cert_peer && crt)
James Votha051b4a2013-05-14 20:37:59 +02006840 X509_free(crt);
6841 return ret;
6842}
6843
Emeric Brunba841a12014-04-30 17:05:08 +02006844/* string, returns certificate's notafter date in ASN1_UTCTIME format.
6845 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6846 * should be use.
6847 */
Emeric Brunce5ad802012-10-22 14:11:22 +02006848static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006849smp_fetch_ssl_x_notafter(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunce5ad802012-10-22 14:11:22 +02006850{
Emeric Brunba841a12014-04-30 17:05:08 +02006851 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brunce5ad802012-10-22 14:11:22 +02006852 X509 *crt = NULL;
6853 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006854 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006855 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006856 struct ssl_sock_ctx *ctx;
Emeric Brunce5ad802012-10-22 14:11:22 +02006857
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006858 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006859 if (!conn || conn->xprt != &ssl_sock)
6860 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006861 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006862
6863 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunce5ad802012-10-22 14:11:22 +02006864 smp->flags |= SMP_F_MAY_CHANGE;
6865 return 0;
6866 }
6867
Emeric Brunba841a12014-04-30 17:05:08 +02006868 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006869 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006870 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006871 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunce5ad802012-10-22 14:11:22 +02006872 if (!crt)
6873 goto out;
6874
Willy Tarreau47ca5452012-12-23 20:22:19 +01006875 smp_trash = get_trash_chunk();
Rosen Penev68185952018-12-14 08:47:02 -08006876 if (ssl_sock_get_time(X509_getm_notAfter(crt), smp_trash) <= 0)
Emeric Brunce5ad802012-10-22 14:11:22 +02006877 goto out;
6878
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006879 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006880 smp->data.type = SMP_T_STR;
Emeric Brunce5ad802012-10-22 14:11:22 +02006881 ret = 1;
6882out:
Emeric Brunba841a12014-04-30 17:05:08 +02006883 /* SSL_get_peer_certificate, it increase X509 * ref count */
6884 if (cert_peer && crt)
Emeric Brunce5ad802012-10-22 14:11:22 +02006885 X509_free(crt);
6886 return ret;
6887}
6888
Emeric Brunba841a12014-04-30 17:05:08 +02006889/* string, returns a string of a formatted full dn \C=..\O=..\OU=.. \CN=.. of certificate's issuer
6890 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6891 * should be use.
6892 */
Emeric Brun87855892012-10-17 17:39:35 +02006893static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006894smp_fetch_ssl_x_i_dn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun87855892012-10-17 17:39:35 +02006895{
Emeric Brunba841a12014-04-30 17:05:08 +02006896 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun87855892012-10-17 17:39:35 +02006897 X509 *crt = NULL;
6898 X509_NAME *name;
6899 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006900 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006901 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006902 struct ssl_sock_ctx *ctx;
Emeric Brun87855892012-10-17 17:39:35 +02006903
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006904 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006905 if (!conn || conn->xprt != &ssl_sock)
6906 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006907 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006908
6909 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brun87855892012-10-17 17:39:35 +02006910 smp->flags |= SMP_F_MAY_CHANGE;
6911 return 0;
6912 }
6913
Emeric Brunba841a12014-04-30 17:05:08 +02006914 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006915 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006916 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006917 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun87855892012-10-17 17:39:35 +02006918 if (!crt)
6919 goto out;
6920
6921 name = X509_get_issuer_name(crt);
6922 if (!name)
6923 goto out;
6924
Willy Tarreau47ca5452012-12-23 20:22:19 +01006925 smp_trash = get_trash_chunk();
Emeric Brun87855892012-10-17 17:39:35 +02006926 if (args && args[0].type == ARGT_STR) {
6927 int pos = 1;
6928
6929 if (args[1].type == ARGT_SINT)
6930 pos = args[1].data.sint;
Emeric Brun87855892012-10-17 17:39:35 +02006931
6932 if (ssl_sock_get_dn_entry(name, &args[0].data.str, pos, smp_trash) <= 0)
6933 goto out;
6934 }
6935 else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
6936 goto out;
6937
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006938 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006939 smp->data.u.str = *smp_trash;
Emeric Brun87855892012-10-17 17:39:35 +02006940 ret = 1;
6941out:
Emeric Brunba841a12014-04-30 17:05:08 +02006942 /* SSL_get_peer_certificate, it increase X509 * ref count */
6943 if (cert_peer && crt)
Emeric Brun87855892012-10-17 17:39:35 +02006944 X509_free(crt);
6945 return ret;
6946}
6947
Emeric Brunba841a12014-04-30 17:05:08 +02006948/* string, returns notbefore date in ASN1_UTCTIME format.
6949 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6950 * should be use.
6951 */
Emeric Brunce5ad802012-10-22 14:11:22 +02006952static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006953smp_fetch_ssl_x_notbefore(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunce5ad802012-10-22 14:11:22 +02006954{
Emeric Brunba841a12014-04-30 17:05:08 +02006955 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brunce5ad802012-10-22 14:11:22 +02006956 X509 *crt = NULL;
6957 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02006958 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006959 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006960 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006961
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02006962 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006963 if (!conn || conn->xprt != &ssl_sock)
Emeric Brunce5ad802012-10-22 14:11:22 +02006964 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01006965 ctx = conn->xprt_ctx;
Emeric Brunce5ad802012-10-22 14:11:22 +02006966
Willy Tarreaub363a1f2013-10-01 10:45:07 +02006967 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunce5ad802012-10-22 14:11:22 +02006968 smp->flags |= SMP_F_MAY_CHANGE;
6969 return 0;
6970 }
6971
Emeric Brunba841a12014-04-30 17:05:08 +02006972 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01006973 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02006974 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01006975 crt = SSL_get_certificate(ctx->ssl);
Emeric Brunce5ad802012-10-22 14:11:22 +02006976 if (!crt)
6977 goto out;
6978
Willy Tarreau47ca5452012-12-23 20:22:19 +01006979 smp_trash = get_trash_chunk();
Rosen Penev68185952018-12-14 08:47:02 -08006980 if (ssl_sock_get_time(X509_getm_notBefore(crt), smp_trash) <= 0)
Emeric Brunce5ad802012-10-22 14:11:22 +02006981 goto out;
6982
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02006983 smp->data.u.str = *smp_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02006984 smp->data.type = SMP_T_STR;
Emeric Brunce5ad802012-10-22 14:11:22 +02006985 ret = 1;
6986out:
Emeric Brunba841a12014-04-30 17:05:08 +02006987 /* SSL_get_peer_certificate, it increase X509 * ref count */
6988 if (cert_peer && crt)
Emeric Brunce5ad802012-10-22 14:11:22 +02006989 X509_free(crt);
6990 return ret;
6991}
6992
Emeric Brunba841a12014-04-30 17:05:08 +02006993/* string, returns a string of a formatted full dn \C=..\O=..\OU=.. \CN=.. of certificate's subject
6994 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
6995 * should be use.
6996 */
Emeric Brun87855892012-10-17 17:39:35 +02006997static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02006998smp_fetch_ssl_x_s_dn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun87855892012-10-17 17:39:35 +02006999{
Emeric Brunba841a12014-04-30 17:05:08 +02007000 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun87855892012-10-17 17:39:35 +02007001 X509 *crt = NULL;
7002 X509_NAME *name;
7003 int ret = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +02007004 struct buffer *smp_trash;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007005 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007006 struct ssl_sock_ctx *ctx;
Emeric Brun87855892012-10-17 17:39:35 +02007007
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007008 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007009 if (!conn || conn->xprt != &ssl_sock)
7010 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007011 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007012
7013 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brun87855892012-10-17 17:39:35 +02007014 smp->flags |= SMP_F_MAY_CHANGE;
7015 return 0;
7016 }
7017
Emeric Brunba841a12014-04-30 17:05:08 +02007018 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007019 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02007020 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007021 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun87855892012-10-17 17:39:35 +02007022 if (!crt)
7023 goto out;
7024
7025 name = X509_get_subject_name(crt);
7026 if (!name)
7027 goto out;
7028
Willy Tarreau47ca5452012-12-23 20:22:19 +01007029 smp_trash = get_trash_chunk();
Emeric Brun87855892012-10-17 17:39:35 +02007030 if (args && args[0].type == ARGT_STR) {
7031 int pos = 1;
7032
7033 if (args[1].type == ARGT_SINT)
7034 pos = args[1].data.sint;
Emeric Brun87855892012-10-17 17:39:35 +02007035
7036 if (ssl_sock_get_dn_entry(name, &args[0].data.str, pos, smp_trash) <= 0)
7037 goto out;
7038 }
7039 else if (ssl_sock_get_dn_oneline(name, smp_trash) <= 0)
7040 goto out;
7041
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007042 smp->data.type = SMP_T_STR;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007043 smp->data.u.str = *smp_trash;
Emeric Brun87855892012-10-17 17:39:35 +02007044 ret = 1;
7045out:
Emeric Brunba841a12014-04-30 17:05:08 +02007046 /* SSL_get_peer_certificate, it increase X509 * ref count */
7047 if (cert_peer && crt)
Emeric Brun87855892012-10-17 17:39:35 +02007048 X509_free(crt);
7049 return ret;
7050}
Emeric Brun9143d372012-12-20 15:44:16 +01007051
7052/* integer, returns true if current session use a client certificate */
7053static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007054smp_fetch_ssl_c_used(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun9143d372012-12-20 15:44:16 +01007055{
7056 X509 *crt;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007057 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007058 struct ssl_sock_ctx *ctx;
Emeric Brun9143d372012-12-20 15:44:16 +01007059
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007060 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007061 if (!conn || conn->xprt != &ssl_sock)
7062 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007063 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007064
7065 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brun9143d372012-12-20 15:44:16 +01007066 smp->flags |= SMP_F_MAY_CHANGE;
7067 return 0;
7068 }
7069
7070 /* SSL_get_peer_certificate returns a ptr on allocated X509 struct */
Olivier Houchard66ab4982019-02-26 18:37:15 +01007071 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brun9143d372012-12-20 15:44:16 +01007072 if (crt) {
7073 X509_free(crt);
7074 }
7075
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007076 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007077 smp->data.u.sint = (crt != NULL);
Emeric Brun9143d372012-12-20 15:44:16 +01007078 return 1;
7079}
7080
Emeric Brunba841a12014-04-30 17:05:08 +02007081/* integer, returns the certificate version
7082 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
7083 * should be use.
7084 */
Emeric Bruna7359fd2012-10-17 15:03:11 +02007085static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007086smp_fetch_ssl_x_version(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Bruna7359fd2012-10-17 15:03:11 +02007087{
Emeric Brunba841a12014-04-30 17:05:08 +02007088 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Bruna7359fd2012-10-17 15:03:11 +02007089 X509 *crt;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007090 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007091 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007092
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007093 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007094 if (!conn || conn->xprt != &ssl_sock)
Emeric Bruna7359fd2012-10-17 15:03:11 +02007095 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007096 ctx = conn->xprt_ctx;
Emeric Bruna7359fd2012-10-17 15:03:11 +02007097
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007098 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Bruna7359fd2012-10-17 15:03:11 +02007099 smp->flags |= SMP_F_MAY_CHANGE;
7100 return 0;
7101 }
7102
Emeric Brunba841a12014-04-30 17:05:08 +02007103 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007104 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02007105 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007106 crt = SSL_get_certificate(ctx->ssl);
Emeric Bruna7359fd2012-10-17 15:03:11 +02007107 if (!crt)
7108 return 0;
7109
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007110 smp->data.u.sint = (unsigned int)(1 + X509_get_version(crt));
Emeric Brunba841a12014-04-30 17:05:08 +02007111 /* SSL_get_peer_certificate increase X509 * ref count */
7112 if (cert_peer)
7113 X509_free(crt);
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007114 smp->data.type = SMP_T_SINT;
Emeric Bruna7359fd2012-10-17 15:03:11 +02007115
7116 return 1;
7117}
7118
Emeric Brunba841a12014-04-30 17:05:08 +02007119/* string, returns the certificate's signature algorithm.
7120 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
7121 * should be use.
7122 */
Emeric Brun7f56e742012-10-19 18:15:40 +02007123static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007124smp_fetch_ssl_x_sig_alg(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun7f56e742012-10-19 18:15:40 +02007125{
Emeric Brunba841a12014-04-30 17:05:08 +02007126 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun7f56e742012-10-19 18:15:40 +02007127 X509 *crt;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007128 __OPENSSL_110_CONST__ ASN1_OBJECT *algorithm;
Emeric Brun7f56e742012-10-19 18:15:40 +02007129 int nid;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007130 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007131 struct ssl_sock_ctx *ctx;
Emeric Brun7f56e742012-10-19 18:15:40 +02007132
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007133 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007134 if (!conn || conn->xprt != &ssl_sock)
7135 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007136 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007137
7138 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brun7f56e742012-10-19 18:15:40 +02007139 smp->flags |= SMP_F_MAY_CHANGE;
7140 return 0;
7141 }
7142
Emeric Brunba841a12014-04-30 17:05:08 +02007143 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007144 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02007145 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007146 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun7f56e742012-10-19 18:15:40 +02007147 if (!crt)
7148 return 0;
7149
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007150 X509_ALGOR_get0(&algorithm, NULL, NULL, X509_get0_tbs_sigalg(crt));
7151 nid = OBJ_obj2nid(algorithm);
Emeric Brun7f56e742012-10-19 18:15:40 +02007152
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007153 smp->data.u.str.area = (char *)OBJ_nid2sn(nid);
7154 if (!smp->data.u.str.area) {
Emeric Brunba841a12014-04-30 17:05:08 +02007155 /* SSL_get_peer_certificate increase X509 * ref count */
7156 if (cert_peer)
7157 X509_free(crt);
Emeric Brun7f56e742012-10-19 18:15:40 +02007158 return 0;
Emeric Brun9bf3ba22013-10-07 14:31:44 +02007159 }
Emeric Brun7f56e742012-10-19 18:15:40 +02007160
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007161 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007162 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007163 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brunba841a12014-04-30 17:05:08 +02007164 /* SSL_get_peer_certificate increase X509 * ref count */
7165 if (cert_peer)
7166 X509_free(crt);
Emeric Brun7f56e742012-10-19 18:15:40 +02007167
7168 return 1;
7169}
7170
Emeric Brunba841a12014-04-30 17:05:08 +02007171/* string, returns the certificate's key algorithm.
7172 * The 5th keyword char is used to know if SSL_get_certificate or SSL_get_peer_certificate
7173 * should be use.
7174 */
Emeric Brun521a0112012-10-22 12:22:55 +02007175static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007176smp_fetch_ssl_x_key_alg(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun521a0112012-10-22 12:22:55 +02007177{
Emeric Brunba841a12014-04-30 17:05:08 +02007178 int cert_peer = (kw[4] == 'c') ? 1 : 0;
Emeric Brun521a0112012-10-22 12:22:55 +02007179 X509 *crt;
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007180 ASN1_OBJECT *algorithm;
Emeric Brun521a0112012-10-22 12:22:55 +02007181 int nid;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007182 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007183 struct ssl_sock_ctx *ctx;
Emeric Brun521a0112012-10-22 12:22:55 +02007184
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007185 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007186 if (!conn || conn->xprt != &ssl_sock)
7187 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007188 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007189
7190 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brun521a0112012-10-22 12:22:55 +02007191 smp->flags |= SMP_F_MAY_CHANGE;
7192 return 0;
7193 }
7194
Emeric Brunba841a12014-04-30 17:05:08 +02007195 if (cert_peer)
Olivier Houchard66ab4982019-02-26 18:37:15 +01007196 crt = SSL_get_peer_certificate(ctx->ssl);
Emeric Brunba841a12014-04-30 17:05:08 +02007197 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007198 crt = SSL_get_certificate(ctx->ssl);
Emeric Brun521a0112012-10-22 12:22:55 +02007199 if (!crt)
7200 return 0;
7201
Dirkjan Bussink1866d6d2016-08-29 13:26:37 +02007202 X509_PUBKEY_get0_param(&algorithm, NULL, NULL, NULL, X509_get_X509_PUBKEY(crt));
7203 nid = OBJ_obj2nid(algorithm);
Emeric Brun521a0112012-10-22 12:22:55 +02007204
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007205 smp->data.u.str.area = (char *)OBJ_nid2sn(nid);
7206 if (!smp->data.u.str.area) {
Emeric Brunba841a12014-04-30 17:05:08 +02007207 /* SSL_get_peer_certificate increase X509 * ref count */
7208 if (cert_peer)
7209 X509_free(crt);
Emeric Brun521a0112012-10-22 12:22:55 +02007210 return 0;
Emeric Brun9bf3ba22013-10-07 14:31:44 +02007211 }
Emeric Brun521a0112012-10-22 12:22:55 +02007212
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007213 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007214 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007215 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brunba841a12014-04-30 17:05:08 +02007216 if (cert_peer)
7217 X509_free(crt);
Emeric Brun521a0112012-10-22 12:22:55 +02007218
7219 return 1;
7220}
7221
Emeric Brun645ae792014-04-30 14:21:06 +02007222/* boolean, returns true if front conn. transport layer is SSL.
7223 * This function is also usable on backend conn if the fetch keyword 5th
7224 * char is 'b'.
7225 */
Willy Tarreau7875d092012-09-10 08:20:03 +02007226static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007227smp_fetch_ssl_fc(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02007228{
Emeric Bruneb8def92018-02-19 15:59:48 +01007229 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7230 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007231
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007232 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007233 smp->data.u.sint = (conn && conn->xprt == &ssl_sock);
Willy Tarreau7875d092012-09-10 08:20:03 +02007234 return 1;
7235}
7236
Emeric Brun2525b6b2012-10-18 15:59:43 +02007237/* boolean, returns true if client present a SNI */
Willy Tarreau7875d092012-09-10 08:20:03 +02007238static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007239smp_fetch_ssl_fc_has_sni(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02007240{
7241#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007242 struct connection *conn = objt_conn(smp->sess->origin);
Olivier Houchard66ab4982019-02-26 18:37:15 +01007243 struct ssl_sock_ctx *ctx = conn ? conn->xprt_ctx : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007244
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007245 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007246 smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007247 conn->xprt_ctx &&
Olivier Houchard66ab4982019-02-26 18:37:15 +01007248 SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name) != NULL;
Willy Tarreau7875d092012-09-10 08:20:03 +02007249 return 1;
7250#else
7251 return 0;
7252#endif
7253}
7254
Emeric Brun74f7ffa2018-02-19 16:14:12 +01007255/* boolean, returns true if client session has been resumed.
7256 * This function is also usable on backend conn if the fetch keyword 5th
7257 * char is 'b'.
7258 */
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02007259static int
7260smp_fetch_ssl_fc_is_resumed(const struct arg *args, struct sample *smp, const char *kw, void *private)
7261{
Emeric Brun74f7ffa2018-02-19 16:14:12 +01007262 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7263 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007264 struct ssl_sock_ctx *ctx = conn ? conn->xprt_ctx : NULL;
Emeric Brun74f7ffa2018-02-19 16:14:12 +01007265
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02007266
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007267 smp->data.type = SMP_T_BOOL;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007268 smp->data.u.sint = (conn && conn->xprt == &ssl_sock) &&
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02007269 conn->xprt_ctx &&
Olivier Houchard66ab4982019-02-26 18:37:15 +01007270 SSL_session_reused(ctx->ssl);
Nenad Merdanovic26ea8222015-05-18 02:28:57 +02007271 return 1;
7272}
7273
Emeric Brun645ae792014-04-30 14:21:06 +02007274/* string, returns the used cipher if front conn. transport layer is SSL.
7275 * This function is also usable on backend conn if the fetch keyword 5th
7276 * char is 'b'.
7277 */
Emeric Brun589fcad2012-10-16 14:13:26 +02007278static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007279smp_fetch_ssl_fc_cipher(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02007280{
Emeric Bruneb8def92018-02-19 15:59:48 +01007281 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7282 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007283 struct ssl_sock_ctx *ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02007284
Willy Tarreaube508f12016-03-10 11:47:01 +01007285 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007286 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Emeric Brun589fcad2012-10-16 14:13:26 +02007287 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007288 ctx = conn->xprt_ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02007289
Olivier Houchard66ab4982019-02-26 18:37:15 +01007290 smp->data.u.str.area = (char *)SSL_get_cipher_name(ctx->ssl);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007291 if (!smp->data.u.str.area)
Emeric Brun589fcad2012-10-16 14:13:26 +02007292 return 0;
7293
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007294 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007295 smp->flags |= SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007296 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brun589fcad2012-10-16 14:13:26 +02007297
7298 return 1;
7299}
7300
Emeric Brun645ae792014-04-30 14:21:06 +02007301/* integer, returns the algoritm's keysize if front conn. transport layer
7302 * is SSL.
7303 * This function is also usable on backend conn if the fetch keyword 5th
7304 * char is 'b'.
7305 */
Emeric Brun589fcad2012-10-16 14:13:26 +02007306static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007307smp_fetch_ssl_fc_alg_keysize(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02007308{
Emeric Bruneb8def92018-02-19 15:59:48 +01007309 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7310 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007311 struct ssl_sock_ctx *ctx;
Willy Tarreaue237fe12016-03-10 17:05:28 +01007312 int sint;
Willy Tarreaube508f12016-03-10 11:47:01 +01007313
Emeric Brun589fcad2012-10-16 14:13:26 +02007314 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007315 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Emeric Brun589fcad2012-10-16 14:13:26 +02007316 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007317 ctx = conn->xprt_ctx;
Emeric Brun589fcad2012-10-16 14:13:26 +02007318
Olivier Houchard66ab4982019-02-26 18:37:15 +01007319 if (!SSL_get_cipher_bits(ctx->ssl, &sint))
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007320 return 0;
7321
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007322 smp->data.u.sint = sint;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007323 smp->data.type = SMP_T_SINT;
Emeric Brun589fcad2012-10-16 14:13:26 +02007324
7325 return 1;
7326}
7327
Emeric Brun645ae792014-04-30 14:21:06 +02007328/* integer, returns the used keysize if front conn. transport layer is SSL.
7329 * This function is also usable on backend conn if the fetch keyword 5th
7330 * char is 'b'.
7331 */
Emeric Brun589fcad2012-10-16 14:13:26 +02007332static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007333smp_fetch_ssl_fc_use_keysize(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02007334{
Emeric Bruneb8def92018-02-19 15:59:48 +01007335 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7336 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007337 struct ssl_sock_ctx *ctx;
Willy Tarreaube508f12016-03-10 11:47:01 +01007338
Emeric Brun589fcad2012-10-16 14:13:26 +02007339 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007340 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7341 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007342 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007343
Olivier Houchard66ab4982019-02-26 18:37:15 +01007344 smp->data.u.sint = (unsigned int)SSL_get_cipher_bits(ctx->ssl, NULL);
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007345 if (!smp->data.u.sint)
Emeric Brun589fcad2012-10-16 14:13:26 +02007346 return 0;
7347
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007348 smp->data.type = SMP_T_SINT;
Emeric Brun589fcad2012-10-16 14:13:26 +02007349
7350 return 1;
7351}
7352
Bernard Spil13c53f82018-02-15 13:34:58 +01007353#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau7875d092012-09-10 08:20:03 +02007354static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007355smp_fetch_ssl_fc_npn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreaua33c6542012-10-15 13:19:06 +02007356{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007357 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007358 struct ssl_sock_ctx *ctx;
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007359 unsigned int len = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007360
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007361 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007362 smp->data.type = SMP_T_STR;
Willy Tarreaua33c6542012-10-15 13:19:06 +02007363
Olivier Houchard6b77f492018-11-22 18:18:29 +01007364 conn = (kw[4] != 'b' ) ? objt_conn(smp->sess->origin) :
7365 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007366 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7367 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007368 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007369
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007370 smp->data.u.str.area = NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007371 SSL_get0_next_proto_negotiated(ctx->ssl,
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007372 (const unsigned char **)&smp->data.u.str.area,
7373 &len);
Willy Tarreaua33c6542012-10-15 13:19:06 +02007374
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007375 if (!smp->data.u.str.area)
Willy Tarreaua33c6542012-10-15 13:19:06 +02007376 return 0;
7377
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007378 smp->data.u.str.data = len;
Willy Tarreaua33c6542012-10-15 13:19:06 +02007379 return 1;
Willy Tarreaua33c6542012-10-15 13:19:06 +02007380}
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02007381#endif
Willy Tarreaua33c6542012-10-15 13:19:06 +02007382
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01007383#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02007384static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007385smp_fetch_ssl_fc_alpn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreauab861d32013-04-02 02:30:41 +02007386{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007387 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007388 struct ssl_sock_ctx *ctx;
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007389 unsigned int len = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007390
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007391 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007392 smp->data.type = SMP_T_STR;
Willy Tarreauab861d32013-04-02 02:30:41 +02007393
Olivier Houchard6b77f492018-11-22 18:18:29 +01007394 conn = (kw[4] != 'b' ) ? objt_conn(smp->sess->origin) :
7395 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
7396
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007397 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
Willy Tarreauab861d32013-04-02 02:30:41 +02007398 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007399 ctx = conn->xprt_ctx;
Willy Tarreauab861d32013-04-02 02:30:41 +02007400
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007401 smp->data.u.str.area = NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007402 SSL_get0_alpn_selected(ctx->ssl,
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007403 (const unsigned char **)&smp->data.u.str.area,
7404 &len);
Willy Tarreauab861d32013-04-02 02:30:41 +02007405
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007406 if (!smp->data.u.str.area)
Willy Tarreauab861d32013-04-02 02:30:41 +02007407 return 0;
7408
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007409 smp->data.u.str.data = len;
Willy Tarreauab861d32013-04-02 02:30:41 +02007410 return 1;
7411}
7412#endif
7413
Emeric Brun645ae792014-04-30 14:21:06 +02007414/* string, returns the used protocol if front conn. transport layer is SSL.
7415 * This function is also usable on backend conn if the fetch keyword 5th
7416 * char is 'b'.
7417 */
Willy Tarreaua33c6542012-10-15 13:19:06 +02007418static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007419smp_fetch_ssl_fc_protocol(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brun589fcad2012-10-16 14:13:26 +02007420{
Emeric Bruneb8def92018-02-19 15:59:48 +01007421 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7422 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007423 struct ssl_sock_ctx *ctx;
Willy Tarreaube508f12016-03-10 11:47:01 +01007424
Emeric Brun589fcad2012-10-16 14:13:26 +02007425 smp->flags = 0;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007426 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7427 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007428 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007429
Olivier Houchard66ab4982019-02-26 18:37:15 +01007430 smp->data.u.str.area = (char *)SSL_get_version(ctx->ssl);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007431 if (!smp->data.u.str.area)
Emeric Brun589fcad2012-10-16 14:13:26 +02007432 return 0;
7433
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007434 smp->data.type = SMP_T_STR;
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007435 smp->flags = SMP_F_CONST;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007436 smp->data.u.str.data = strlen(smp->data.u.str.area);
Emeric Brun589fcad2012-10-16 14:13:26 +02007437
7438 return 1;
7439}
7440
Willy Tarreau87b09662015-04-03 00:22:06 +02007441/* binary, returns the SSL stream id if front conn. transport layer is SSL.
Emeric Brun645ae792014-04-30 14:21:06 +02007442 * This function is also usable on backend conn if the fetch keyword 5th
7443 * char is 'b'.
7444 */
Willy Tarreau9a1ab082019-05-09 13:26:41 +02007445#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brun589fcad2012-10-16 14:13:26 +02007446static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007447smp_fetch_ssl_fc_session_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunfe68f682012-10-16 14:59:28 +02007448{
Emeric Bruneb8def92018-02-19 15:59:48 +01007449 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7450 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
Willy Tarreaue237fe12016-03-10 17:05:28 +01007451 SSL_SESSION *ssl_sess;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007452 struct ssl_sock_ctx *ctx;
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007453 unsigned int len = 0;
Willy Tarreaube508f12016-03-10 11:47:01 +01007454
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007455 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007456 smp->data.type = SMP_T_BIN;
Emeric Brunfe68f682012-10-16 14:59:28 +02007457
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007458 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7459 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007460 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007461
Olivier Houchard66ab4982019-02-26 18:37:15 +01007462 ssl_sess = SSL_get_session(ctx->ssl);
Willy Tarreau192252e2015-04-04 01:47:55 +02007463 if (!ssl_sess)
Emeric Brunfe68f682012-10-16 14:59:28 +02007464 return 0;
7465
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007466 smp->data.u.str.area = (char *)SSL_SESSION_get_id(ssl_sess, &len);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007467 if (!smp->data.u.str.area || !smp->data.u.str.data)
Emeric Brunfe68f682012-10-16 14:59:28 +02007468 return 0;
7469
Willy Tarreau767e8ad2020-02-25 08:59:23 +01007470 smp->data.u.str.data = len;
Emeric Brunfe68f682012-10-16 14:59:28 +02007471 return 1;
Emeric Brunfe68f682012-10-16 14:59:28 +02007472}
Patrick Hemmer41966772018-04-28 19:15:48 -04007473#endif
7474
Emeric Brunfe68f682012-10-16 14:59:28 +02007475
Emmanuel Hocdet839af572019-05-14 16:27:35 +02007476#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmere0275472018-04-28 19:15:51 -04007477static int
Patrick Hemmer65674662019-06-04 08:13:03 -04007478smp_fetch_ssl_fc_random(const struct arg *args, struct sample *smp, const char *kw, void *private)
7479{
7480 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7481 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
7482 struct buffer *data;
7483 struct ssl_sock_ctx *ctx;
7484
7485 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7486 return 0;
7487 ctx = conn->xprt_ctx;
7488
7489 data = get_trash_chunk();
7490 if (kw[7] == 'c')
7491 data->data = SSL_get_client_random(ctx->ssl,
7492 (unsigned char *) data->area,
7493 data->size);
7494 else
7495 data->data = SSL_get_server_random(ctx->ssl,
7496 (unsigned char *) data->area,
7497 data->size);
7498 if (!data->data)
7499 return 0;
7500
7501 smp->flags = 0;
7502 smp->data.type = SMP_T_BIN;
7503 smp->data.u.str = *data;
7504
7505 return 1;
7506}
7507
7508static int
Patrick Hemmere0275472018-04-28 19:15:51 -04007509smp_fetch_ssl_fc_session_key(const struct arg *args, struct sample *smp, const char *kw, void *private)
7510{
7511 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7512 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
7513 SSL_SESSION *ssl_sess;
Willy Tarreau83061a82018-07-13 11:56:34 +02007514 struct buffer *data;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007515 struct ssl_sock_ctx *ctx;
Patrick Hemmere0275472018-04-28 19:15:51 -04007516
7517 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7518 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007519 ctx = conn->xprt_ctx;
Patrick Hemmere0275472018-04-28 19:15:51 -04007520
Olivier Houchard66ab4982019-02-26 18:37:15 +01007521 ssl_sess = SSL_get_session(ctx->ssl);
Patrick Hemmere0275472018-04-28 19:15:51 -04007522 if (!ssl_sess)
7523 return 0;
7524
7525 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007526 data->data = SSL_SESSION_get_master_key(ssl_sess,
7527 (unsigned char *) data->area,
7528 data->size);
7529 if (!data->data)
Patrick Hemmere0275472018-04-28 19:15:51 -04007530 return 0;
7531
7532 smp->flags = 0;
7533 smp->data.type = SMP_T_BIN;
7534 smp->data.u.str = *data;
7535
7536 return 1;
7537}
7538#endif
7539
Patrick Hemmer41966772018-04-28 19:15:48 -04007540#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Emeric Brunfe68f682012-10-16 14:59:28 +02007541static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007542smp_fetch_ssl_fc_sni(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau7875d092012-09-10 08:20:03 +02007543{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007544 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007545 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007546
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01007547 smp->flags = SMP_F_CONST;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007548 smp->data.type = SMP_T_STR;
Willy Tarreau7875d092012-09-10 08:20:03 +02007549
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007550 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007551 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7552 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007553 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007554
Olivier Houchard66ab4982019-02-26 18:37:15 +01007555 smp->data.u.str.area = (char *)SSL_get_servername(ctx->ssl, TLSEXT_NAMETYPE_host_name);
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007556 if (!smp->data.u.str.area)
Willy Tarreau3e394c92012-09-14 23:56:58 +02007557 return 0;
7558
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007559 smp->data.u.str.data = strlen(smp->data.u.str.area);
Willy Tarreau7875d092012-09-10 08:20:03 +02007560 return 1;
Willy Tarreau7875d092012-09-10 08:20:03 +02007561}
Patrick Hemmer41966772018-04-28 19:15:48 -04007562#endif
Willy Tarreau7875d092012-09-10 08:20:03 +02007563
David Sc1ad52e2014-04-08 18:48:47 -04007564static int
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007565smp_fetch_ssl_fc_cl_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
7566{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007567 struct connection *conn;
7568 struct ssl_capture *capture;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007569 struct ssl_sock_ctx *ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007570
7571 conn = objt_conn(smp->sess->origin);
7572 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7573 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007574 ctx = conn->xprt_ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007575
Olivier Houchard66ab4982019-02-26 18:37:15 +01007576 capture = SSL_get_ex_data(ctx->ssl, ssl_capture_ptr_index);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007577 if (!capture)
7578 return 0;
7579
7580 smp->flags = SMP_F_CONST;
7581 smp->data.type = SMP_T_BIN;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007582 smp->data.u.str.area = capture->ciphersuite;
7583 smp->data.u.str.data = capture->ciphersuite_len;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007584 return 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007585}
7586
7587static int
7588smp_fetch_ssl_fc_cl_hex(const struct arg *args, struct sample *smp, const char *kw, void *private)
7589{
Willy Tarreau83061a82018-07-13 11:56:34 +02007590 struct buffer *data;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007591
7592 if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
7593 return 0;
7594
7595 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007596 dump_binary(data, smp->data.u.str.area, smp->data.u.str.data);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007597 smp->data.type = SMP_T_BIN;
7598 smp->data.u.str = *data;
7599 return 1;
7600}
7601
7602static int
7603smp_fetch_ssl_fc_cl_xxh64(const struct arg *args, struct sample *smp, const char *kw, void *private)
7604{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007605 struct connection *conn;
7606 struct ssl_capture *capture;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007607 struct ssl_sock_ctx *ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007608
7609 conn = objt_conn(smp->sess->origin);
7610 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7611 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007612 ctx = conn->xprt_ctx;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007613
Olivier Houchard66ab4982019-02-26 18:37:15 +01007614 capture = SSL_get_ex_data(ctx->ssl, ssl_capture_ptr_index);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007615 if (!capture)
7616 return 0;
7617
7618 smp->data.type = SMP_T_SINT;
7619 smp->data.u.sint = capture->xxh64;
7620 return 1;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007621}
7622
7623static int
7624smp_fetch_ssl_fc_cl_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
7625{
Willy Tarreau5db847a2019-05-09 14:13:35 +02007626#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL)
Willy Tarreau83061a82018-07-13 11:56:34 +02007627 struct buffer *data;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007628 int i;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007629
7630 if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
7631 return 0;
7632
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007633 data = get_trash_chunk();
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007634 for (i = 0; i + 1 < smp->data.u.str.data; i += 2) {
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02007635 const char *str;
7636 const SSL_CIPHER *cipher;
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007637 const unsigned char *bin = (const unsigned char *) smp->data.u.str.area + i;
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02007638 uint16_t id = (bin[0] << 8) | bin[1];
7639#if defined(OPENSSL_IS_BORINGSSL)
7640 cipher = SSL_get_cipher_by_value(id);
7641#else
Willy Tarreaub7290772018-10-15 11:01:59 +02007642 struct connection *conn = __objt_conn(smp->sess->origin);
Olivier Houchard66ab4982019-02-26 18:37:15 +01007643 struct ssl_sock_ctx *ctx = conn->xprt_ctx;
7644 cipher = SSL_CIPHER_find(ctx->ssl, bin);
Emmanuel Hocdetddcde192017-09-01 17:32:08 +02007645#endif
7646 str = SSL_CIPHER_get_name(cipher);
7647 if (!str || strcmp(str, "(NONE)") == 0)
7648 chunk_appendf(data, "%sUNKNOWN(%04x)", i == 0 ? "" : ",", id);
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007649 else
7650 chunk_appendf(data, "%s%s", i == 0 ? "" : ",", str);
7651 }
7652 smp->data.type = SMP_T_STR;
7653 smp->data.u.str = *data;
7654 return 1;
7655#else
7656 return smp_fetch_ssl_fc_cl_xxh64(args, smp, kw, private);
7657#endif
7658}
7659
Willy Tarreau9a1ab082019-05-09 13:26:41 +02007660#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01007661static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007662smp_fetch_ssl_fc_unique_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
David Sc1ad52e2014-04-08 18:48:47 -04007663{
Emeric Bruneb8def92018-02-19 15:59:48 +01007664 struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
7665 smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
David Sc1ad52e2014-04-08 18:48:47 -04007666 int finished_len;
Willy Tarreau83061a82018-07-13 11:56:34 +02007667 struct buffer *finished_trash;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007668 struct ssl_sock_ctx *ctx;
David Sc1ad52e2014-04-08 18:48:47 -04007669
7670 smp->flags = 0;
David Sc1ad52e2014-04-08 18:48:47 -04007671 if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
7672 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007673 ctx = conn->xprt_ctx;
David Sc1ad52e2014-04-08 18:48:47 -04007674
7675 if (!(conn->flags & CO_FL_CONNECTED)) {
7676 smp->flags |= SMP_F_MAY_CHANGE;
7677 return 0;
7678 }
7679
7680 finished_trash = get_trash_chunk();
Olivier Houchard66ab4982019-02-26 18:37:15 +01007681 if (!SSL_session_reused(ctx->ssl))
7682 finished_len = SSL_get_peer_finished(ctx->ssl,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007683 finished_trash->area,
7684 finished_trash->size);
David Sc1ad52e2014-04-08 18:48:47 -04007685 else
Olivier Houchard66ab4982019-02-26 18:37:15 +01007686 finished_len = SSL_get_finished(ctx->ssl,
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007687 finished_trash->area,
7688 finished_trash->size);
David Sc1ad52e2014-04-08 18:48:47 -04007689
7690 if (!finished_len)
7691 return 0;
7692
Willy Tarreau843b7cb2018-07-13 10:54:26 +02007693 finished_trash->data = finished_len;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02007694 smp->data.u.str = *finished_trash;
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007695 smp->data.type = SMP_T_BIN;
David Sc1ad52e2014-04-08 18:48:47 -04007696
7697 return 1;
David Sc1ad52e2014-04-08 18:48:47 -04007698}
Patrick Hemmer41966772018-04-28 19:15:48 -04007699#endif
David Sc1ad52e2014-04-08 18:48:47 -04007700
Emeric Brun2525b6b2012-10-18 15:59:43 +02007701/* integer, returns the first verify error in CA chain of client certificate chain. */
Emeric Brunf282a812012-09-21 15:27:54 +02007702static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007703smp_fetch_ssl_c_ca_err(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunf282a812012-09-21 15:27:54 +02007704{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007705 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007706 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007707
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007708 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007709 if (!conn || conn->xprt != &ssl_sock)
7710 return 0;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007711 ctx = conn->xprt_ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007712
7713 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunf282a812012-09-21 15:27:54 +02007714 smp->flags = SMP_F_MAY_CHANGE;
7715 return 0;
7716 }
7717
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007718 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007719 smp->data.u.sint = (unsigned long long int)SSL_SOCK_ST_TO_CA_ERROR(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02007720 smp->flags = 0;
7721
7722 return 1;
7723}
7724
Emeric Brun2525b6b2012-10-18 15:59:43 +02007725/* integer, returns the depth of the first verify error in CA chain of client certificate chain. */
Emeric Brunf282a812012-09-21 15:27:54 +02007726static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007727smp_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 +02007728{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007729 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007730 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007731
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007732 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007733 if (!conn || conn->xprt != &ssl_sock)
Emeric Brunf282a812012-09-21 15:27:54 +02007734 return 0;
7735
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007736 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunf282a812012-09-21 15:27:54 +02007737 smp->flags = SMP_F_MAY_CHANGE;
7738 return 0;
7739 }
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007740 ctx = conn->xprt_ctx;
Emeric Brunf282a812012-09-21 15:27:54 +02007741
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007742 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007743 smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CAEDEPTH(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02007744 smp->flags = 0;
7745
7746 return 1;
7747}
7748
Emeric Brun2525b6b2012-10-18 15:59:43 +02007749/* integer, returns the first verify error on client certificate */
Emeric Brunf282a812012-09-21 15:27:54 +02007750static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007751smp_fetch_ssl_c_err(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunf282a812012-09-21 15:27:54 +02007752{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007753 struct connection *conn;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007754 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007755
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007756 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007757 if (!conn || conn->xprt != &ssl_sock)
7758 return 0;
7759
7760 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunf282a812012-09-21 15:27:54 +02007761 smp->flags = SMP_F_MAY_CHANGE;
7762 return 0;
7763 }
7764
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007765 ctx = conn->xprt_ctx;
7766
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007767 smp->data.type = SMP_T_SINT;
Olivier Houchard7b5fd1e2019-02-28 18:10:45 +01007768 smp->data.u.sint = (long long int)SSL_SOCK_ST_TO_CRTERROR(ctx->xprt_st);
Emeric Brunf282a812012-09-21 15:27:54 +02007769 smp->flags = 0;
7770
7771 return 1;
7772}
7773
Emeric Brun2525b6b2012-10-18 15:59:43 +02007774/* integer, returns the verify result on client cert */
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007775static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02007776smp_fetch_ssl_c_verify(const struct arg *args, struct sample *smp, const char *kw, void *private)
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007777{
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007778 struct connection *conn;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007779 struct ssl_sock_ctx *ctx;
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007780
Thierry FOURNIER0a9a2b82015-05-11 15:20:49 +02007781 conn = objt_conn(smp->sess->origin);
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007782 if (!conn || conn->xprt != &ssl_sock)
7783 return 0;
7784
7785 if (!(conn->flags & CO_FL_CONNECTED)) {
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007786 smp->flags = SMP_F_MAY_CHANGE;
7787 return 0;
7788 }
7789
Willy Tarreaub363a1f2013-10-01 10:45:07 +02007790 if (!conn->xprt_ctx)
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007791 return 0;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007792 ctx = conn->xprt_ctx;
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007793
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02007794 smp->data.type = SMP_T_SINT;
Olivier Houchard66ab4982019-02-26 18:37:15 +01007795 smp->data.u.sint = (long long int)SSL_get_verify_result(ctx->ssl);
Emeric Brunbaf8ffb2012-09-21 15:27:20 +02007796 smp->flags = 0;
7797
7798 return 1;
7799}
7800
Emeric Brunfb510ea2012-10-05 12:00:26 +02007801/* parse the "ca-file" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007802static int ssl_bind_parse_ca_file(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
Emeric Brund94b3fe2012-09-20 18:23:56 +02007803{
7804 if (!*args[cur_arg + 1]) {
7805 if (err)
7806 memprintf(err, "'%s' : missing CAfile path", args[cur_arg]);
7807 return ERR_ALERT | ERR_FATAL;
7808 }
7809
Willy Tarreauef934602016-12-22 23:12:01 +01007810 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
7811 memprintf(&conf->ca_file, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02007812 else
7813 memprintf(&conf->ca_file, "%s", args[cur_arg + 1]);
Emeric Brunc8e8d122012-10-02 18:42:10 +02007814
Emeric Brund94b3fe2012-09-20 18:23:56 +02007815 return 0;
7816}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007817static int bind_parse_ca_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7818{
7819 return ssl_bind_parse_ca_file(args, cur_arg, px, &conf->ssl_conf, err);
7820}
Emeric Brund94b3fe2012-09-20 18:23:56 +02007821
Christopher Faulet31af49d2015-06-09 17:29:50 +02007822/* parse the "ca-sign-file" bind keyword */
7823static int bind_parse_ca_sign_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7824{
7825 if (!*args[cur_arg + 1]) {
7826 if (err)
7827 memprintf(err, "'%s' : missing CAfile path", args[cur_arg]);
7828 return ERR_ALERT | ERR_FATAL;
7829 }
7830
Willy Tarreauef934602016-12-22 23:12:01 +01007831 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
7832 memprintf(&conf->ca_sign_file, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Christopher Faulet31af49d2015-06-09 17:29:50 +02007833 else
7834 memprintf(&conf->ca_sign_file, "%s", args[cur_arg + 1]);
7835
7836 return 0;
7837}
7838
Bertrand Jacquinff13c062016-11-13 16:37:11 +00007839/* parse the "ca-sign-pass" bind keyword */
Christopher Faulet31af49d2015-06-09 17:29:50 +02007840static int bind_parse_ca_sign_pass(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7841{
7842 if (!*args[cur_arg + 1]) {
7843 if (err)
7844 memprintf(err, "'%s' : missing CAkey password", args[cur_arg]);
7845 return ERR_ALERT | ERR_FATAL;
7846 }
7847 memprintf(&conf->ca_sign_pass, "%s", args[cur_arg + 1]);
7848 return 0;
7849}
7850
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007851/* parse the "ciphers" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007852static 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 +02007853{
7854 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02007855 memprintf(err, "'%s' : missing cipher suite", args[cur_arg]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007856 return ERR_ALERT | ERR_FATAL;
7857 }
7858
Emeric Brun76d88952012-10-05 15:47:31 +02007859 free(conf->ciphers);
Willy Tarreau4348fad2012-09-20 16:48:07 +02007860 conf->ciphers = strdup(args[cur_arg + 1]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007861 return 0;
7862}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007863static int bind_parse_ciphers(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7864{
7865 return ssl_bind_parse_ciphers(args, cur_arg, px, &conf->ssl_conf, err);
7866}
Dirkjan Bussink415150f2018-09-14 11:14:21 +02007867
Emmanuel Hocdet839af572019-05-14 16:27:35 +02007868#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02007869/* parse the "ciphersuites" bind keyword */
7870static int ssl_bind_parse_ciphersuites(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
7871{
7872 if (!*args[cur_arg + 1]) {
7873 memprintf(err, "'%s' : missing cipher suite", args[cur_arg]);
7874 return ERR_ALERT | ERR_FATAL;
7875 }
7876
7877 free(conf->ciphersuites);
7878 conf->ciphersuites = strdup(args[cur_arg + 1]);
7879 return 0;
7880}
7881static int bind_parse_ciphersuites(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7882{
7883 return ssl_bind_parse_ciphersuites(args, cur_arg, px, &conf->ssl_conf, err);
7884}
7885#endif
7886
Willy Tarreaub131c872019-10-16 16:42:19 +02007887/* parse the "crt" bind keyword. Returns a set of ERR_* flags possibly with an error in <err>. */
Willy Tarreau4348fad2012-09-20 16:48:07 +02007888static 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 +02007889{
Willy Tarreau38011032013-08-13 16:59:39 +02007890 char path[MAXPATHLEN];
Willy Tarreaub75d6922014-04-14 18:05:41 +02007891
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007892 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02007893 memprintf(err, "'%s' : missing certificate location", args[cur_arg]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007894 return ERR_ALERT | ERR_FATAL;
7895 }
7896
Willy Tarreauef934602016-12-22 23:12:01 +01007897 if ((*args[cur_arg + 1] != '/' ) && global_ssl.crt_base) {
7898 if ((strlen(global_ssl.crt_base) + 1 + strlen(args[cur_arg + 1]) + 1) > MAXPATHLEN) {
Emeric Brunc8e8d122012-10-02 18:42:10 +02007899 memprintf(err, "'%s' : path too long", args[cur_arg]);
7900 return ERR_ALERT | ERR_FATAL;
7901 }
Willy Tarreauef934602016-12-22 23:12:01 +01007902 snprintf(path, sizeof(path), "%s/%s", global_ssl.crt_base, args[cur_arg + 1]);
Willy Tarreaub131c872019-10-16 16:42:19 +02007903 return ssl_sock_load_cert(path, conf, err);
Emeric Brunc8e8d122012-10-02 18:42:10 +02007904 }
7905
Willy Tarreaub131c872019-10-16 16:42:19 +02007906 return ssl_sock_load_cert(args[cur_arg + 1], conf, err);
Emeric Brund94b3fe2012-09-20 18:23:56 +02007907}
7908
Willy Tarreaub131c872019-10-16 16:42:19 +02007909/* 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 +01007910static int bind_parse_crt_list(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7911{
Willy Tarreaub131c872019-10-16 16:42:19 +02007912 int err_code;
7913
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01007914 if (!*args[cur_arg + 1]) {
7915 memprintf(err, "'%s' : missing certificate location", args[cur_arg]);
7916 return ERR_ALERT | ERR_FATAL;
7917 }
7918
Willy Tarreaub131c872019-10-16 16:42:19 +02007919 err_code = ssl_sock_load_cert_list_file(args[cur_arg + 1], conf, px, err);
7920 if (err_code)
Willy Tarreauad1731d2013-04-02 17:35:58 +02007921 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01007922
Willy Tarreaub131c872019-10-16 16:42:19 +02007923 return err_code;
Emmanuel Hocdetfe616562013-01-22 15:31:15 +01007924}
7925
Emeric Brunfb510ea2012-10-05 12:00:26 +02007926/* parse the "crl-file" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007927static 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 +02007928{
Emeric Brun051cdab2012-10-02 19:25:50 +02007929#ifndef X509_V_FLAG_CRL_CHECK
7930 if (err)
7931 memprintf(err, "'%s' : library does not support CRL verify", args[cur_arg]);
7932 return ERR_ALERT | ERR_FATAL;
7933#else
Emeric Brund94b3fe2012-09-20 18:23:56 +02007934 if (!*args[cur_arg + 1]) {
7935 if (err)
7936 memprintf(err, "'%s' : missing CRLfile path", args[cur_arg]);
7937 return ERR_ALERT | ERR_FATAL;
7938 }
Emeric Brun2b58d042012-09-20 17:10:03 +02007939
Willy Tarreauef934602016-12-22 23:12:01 +01007940 if ((*args[cur_arg + 1] != '/') && global_ssl.ca_base)
7941 memprintf(&conf->crl_file, "%s/%s", global_ssl.ca_base, args[cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02007942 else
7943 memprintf(&conf->crl_file, "%s", args[cur_arg + 1]);
Emeric Brunc8e8d122012-10-02 18:42:10 +02007944
Emeric Brun2b58d042012-09-20 17:10:03 +02007945 return 0;
Emeric Brun051cdab2012-10-02 19:25:50 +02007946#endif
Emeric Brun2b58d042012-09-20 17:10:03 +02007947}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007948static int bind_parse_crl_file(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7949{
7950 return ssl_bind_parse_crl_file(args, cur_arg, px, &conf->ssl_conf, err);
7951}
Emeric Brun2b58d042012-09-20 17:10:03 +02007952
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01007953/* parse the "curves" bind keyword keyword */
7954static int ssl_bind_parse_curves(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
7955{
Lukas Tribusd13e9252019-11-24 18:20:40 +01007956#if ((HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL) || defined(LIBRESSL_VERSION_NUMBER))
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01007957 if (!*args[cur_arg + 1]) {
7958 if (err)
7959 memprintf(err, "'%s' : missing curve suite", args[cur_arg]);
7960 return ERR_ALERT | ERR_FATAL;
7961 }
7962 conf->curves = strdup(args[cur_arg + 1]);
7963 return 0;
7964#else
7965 if (err)
7966 memprintf(err, "'%s' : library does not support curve suite", args[cur_arg]);
7967 return ERR_ALERT | ERR_FATAL;
7968#endif
7969}
7970static int bind_parse_curves(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7971{
7972 return ssl_bind_parse_curves(args, cur_arg, px, &conf->ssl_conf, err);
7973}
7974
Bertrand Jacquinff13c062016-11-13 16:37:11 +00007975/* parse the "ecdhe" bind keyword keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007976static 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 +02007977{
Willy Tarreau9a1ab082019-05-09 13:26:41 +02007978#if HA_OPENSSL_VERSION_NUMBER < 0x0090800fL
Emeric Brun2b58d042012-09-20 17:10:03 +02007979 if (err)
7980 memprintf(err, "'%s' : library does not support elliptic curve Diffie-Hellman (too old)", args[cur_arg]);
7981 return ERR_ALERT | ERR_FATAL;
7982#elif defined(OPENSSL_NO_ECDH)
7983 if (err)
7984 memprintf(err, "'%s' : library does not support elliptic curve Diffie-Hellman (disabled via OPENSSL_NO_ECDH)", args[cur_arg]);
7985 return ERR_ALERT | ERR_FATAL;
7986#else
7987 if (!*args[cur_arg + 1]) {
7988 if (err)
7989 memprintf(err, "'%s' : missing named curve", args[cur_arg]);
7990 return ERR_ALERT | ERR_FATAL;
7991 }
7992
7993 conf->ecdhe = strdup(args[cur_arg + 1]);
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007994
7995 return 0;
Emeric Brun2b58d042012-09-20 17:10:03 +02007996#endif
Willy Tarreau79eeafa2012-09-14 07:53:05 +02007997}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01007998static int bind_parse_ecdhe(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
7999{
8000 return ssl_bind_parse_ecdhe(args, cur_arg, px, &conf->ssl_conf, err);
8001}
Willy Tarreau79eeafa2012-09-14 07:53:05 +02008002
Bertrand Jacquinff13c062016-11-13 16:37:11 +00008003/* parse the "crt-ignore-err" and "ca-ignore-err" bind keywords */
Emeric Brun81c00f02012-09-21 14:31:21 +02008004static int bind_parse_ignore_err(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8005{
8006 int code;
8007 char *p = args[cur_arg + 1];
8008 unsigned long long *ignerr = &conf->crt_ignerr;
8009
8010 if (!*p) {
8011 if (err)
8012 memprintf(err, "'%s' : missing error IDs list", args[cur_arg]);
8013 return ERR_ALERT | ERR_FATAL;
8014 }
8015
8016 if (strcmp(args[cur_arg], "ca-ignore-err") == 0)
8017 ignerr = &conf->ca_ignerr;
8018
8019 if (strcmp(p, "all") == 0) {
8020 *ignerr = ~0ULL;
8021 return 0;
8022 }
8023
8024 while (p) {
8025 code = atoi(p);
8026 if ((code <= 0) || (code > 63)) {
8027 if (err)
8028 memprintf(err, "'%s' : ID '%d' out of range (1..63) in error IDs list '%s'",
8029 args[cur_arg], code, args[cur_arg + 1]);
8030 return ERR_ALERT | ERR_FATAL;
8031 }
8032 *ignerr |= 1ULL << code;
8033 p = strchr(p, ',');
8034 if (p)
8035 p++;
8036 }
8037
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008038 return 0;
8039}
8040
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008041/* parse tls_method_options "no-xxx" and "force-xxx" */
8042static int parse_tls_method_options(char *arg, struct tls_version_filter *methods, char **err)
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008043{
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008044 uint16_t v;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008045 char *p;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008046 p = strchr(arg, '-');
8047 if (!p)
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008048 goto fail;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008049 p++;
8050 if (!strcmp(p, "sslv3"))
8051 v = CONF_SSLV3;
8052 else if (!strcmp(p, "tlsv10"))
8053 v = CONF_TLSV10;
8054 else if (!strcmp(p, "tlsv11"))
8055 v = CONF_TLSV11;
8056 else if (!strcmp(p, "tlsv12"))
8057 v = CONF_TLSV12;
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +02008058 else if (!strcmp(p, "tlsv13"))
8059 v = CONF_TLSV13;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008060 else
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008061 goto fail;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008062 if (!strncmp(arg, "no-", 3))
8063 methods->flags |= methodVersions[v].flag;
8064 else if (!strncmp(arg, "force-", 6))
8065 methods->min = methods->max = v;
8066 else
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008067 goto fail;
Emeric Brun2d0c4822012-10-02 13:45:20 +02008068 return 0;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008069 fail:
8070 if (err)
8071 memprintf(err, "'%s' : option not implemented", arg);
8072 return ERR_ALERT | ERR_FATAL;
Emeric Brun2d0c4822012-10-02 13:45:20 +02008073}
8074
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008075static 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 +02008076{
Emmanuel Hocdet43664762017-08-09 18:26:20 +02008077 return parse_tls_method_options(args[cur_arg], &conf->ssl_conf.ssl_methods, err);
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008078}
8079
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008080static 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 +02008081{
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008082 return parse_tls_method_options(args[*cur_arg], &newsrv->ssl_ctx.methods, err);
8083}
8084
8085/* parse tls_method min/max: "ssl-min-ver" and "ssl-max-ver" */
8086static int parse_tls_method_minmax(char **args, int cur_arg, struct tls_version_filter *methods, char **err)
8087{
8088 uint16_t i, v = 0;
8089 char *argv = args[cur_arg + 1];
8090 if (!*argv) {
8091 if (err)
8092 memprintf(err, "'%s' : missing the ssl/tls version", args[cur_arg]);
8093 return ERR_ALERT | ERR_FATAL;
8094 }
8095 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
8096 if (!strcmp(argv, methodVersions[i].name))
8097 v = i;
8098 if (!v) {
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008099 if (err)
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008100 memprintf(err, "'%s' : unknown ssl/tls version", args[cur_arg + 1]);
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008101 return ERR_ALERT | ERR_FATAL;
8102 }
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008103 if (!strcmp("ssl-min-ver", args[cur_arg]))
8104 methods->min = v;
8105 else if (!strcmp("ssl-max-ver", args[cur_arg]))
8106 methods->max = v;
8107 else {
8108 if (err)
8109 memprintf(err, "'%s' : option not implemented", args[cur_arg]);
8110 return ERR_ALERT | ERR_FATAL;
8111 }
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008112 return 0;
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008113}
Emeric Brun2cb7ae52012-10-05 14:14:21 +02008114
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02008115static int ssl_bind_parse_tls_method_minmax(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
8116{
Willy Tarreau9a1ab082019-05-09 13:26:41 +02008117#if (HA_OPENSSL_VERSION_NUMBER < 0x10101000L) && !defined(OPENSSL_IS_BORINGSSL)
Christopher Faulet767a84b2017-11-24 16:50:31 +01008118 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 +02008119#endif
8120 return parse_tls_method_minmax(args, cur_arg, &conf->ssl_methods, err);
8121}
8122
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008123static int bind_parse_tls_method_minmax(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8124{
Emmanuel Hocdet43664762017-08-09 18:26:20 +02008125 return parse_tls_method_minmax(args, cur_arg, &conf->ssl_conf.ssl_methods, err);
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008126}
8127
8128static int srv_parse_tls_method_minmax(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8129{
8130 return parse_tls_method_minmax(args, *cur_arg, &newsrv->ssl_ctx.methods, err);
8131}
8132
Emeric Brun2d0c4822012-10-02 13:45:20 +02008133/* parse the "no-tls-tickets" bind keyword */
Emmanuel Hocdet4608ed92017-01-20 13:06:27 +01008134static 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 +02008135{
Emeric Brun89675492012-10-05 13:48:26 +02008136 conf->ssl_options |= BC_SSL_O_NO_TLS_TICKETS;
Emeric Brun81c00f02012-09-21 14:31:21 +02008137 return 0;
8138}
Emeric Brun2d0c4822012-10-02 13:45:20 +02008139
Olivier Houchardc2aae742017-09-22 18:26:28 +02008140/* parse the "allow-0rtt" bind keyword */
8141static int ssl_bind_parse_allow_0rtt(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
8142{
8143 conf->early_data = 1;
8144 return 0;
8145}
8146
8147static int bind_parse_allow_0rtt(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8148{
Olivier Houchard9679ac92017-10-27 14:58:08 +02008149 conf->ssl_conf.early_data = 1;
Olivier Houchardc2aae742017-09-22 18:26:28 +02008150 return 0;
8151}
8152
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02008153/* parse the "npn" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008154static 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 +02008155{
Bernard Spil13c53f82018-02-15 13:34:58 +01008156#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02008157 char *p1, *p2;
8158
8159 if (!*args[cur_arg + 1]) {
8160 memprintf(err, "'%s' : missing the comma-delimited NPN protocol suite", args[cur_arg]);
8161 return ERR_ALERT | ERR_FATAL;
8162 }
8163
8164 free(conf->npn_str);
8165
Willy Tarreau3724da12016-02-12 17:11:12 +01008166 /* the NPN string is built as a suite of (<len> <name>)*,
8167 * so we reuse each comma to store the next <len> and need
8168 * one more for the end of the string.
8169 */
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02008170 conf->npn_len = strlen(args[cur_arg + 1]) + 1;
Willy Tarreau3724da12016-02-12 17:11:12 +01008171 conf->npn_str = calloc(1, conf->npn_len + 1);
Willy Tarreau6c9a3d52012-10-18 18:57:14 +02008172 memcpy(conf->npn_str + 1, args[cur_arg + 1], conf->npn_len);
8173
8174 /* replace commas with the name length */
8175 p1 = conf->npn_str;
8176 p2 = p1 + 1;
8177 while (1) {
8178 p2 = memchr(p1 + 1, ',', conf->npn_str + conf->npn_len - (p1 + 1));
8179 if (!p2)
8180 p2 = p1 + 1 + strlen(p1 + 1);
8181
8182 if (p2 - (p1 + 1) > 255) {
8183 *p2 = '\0';
8184 memprintf(err, "'%s' : NPN protocol name too long : '%s'", args[cur_arg], p1 + 1);
8185 return ERR_ALERT | ERR_FATAL;
8186 }
8187
8188 *p1 = p2 - (p1 + 1);
8189 p1 = p2;
8190
8191 if (!*p2)
8192 break;
8193
8194 *(p2++) = '\0';
8195 }
8196 return 0;
8197#else
8198 if (err)
8199 memprintf(err, "'%s' : library does not support TLS NPN extension", args[cur_arg]);
8200 return ERR_ALERT | ERR_FATAL;
8201#endif
8202}
8203
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008204static int bind_parse_npn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8205{
8206 return ssl_bind_parse_npn(args, cur_arg, px, &conf->ssl_conf, err);
8207}
8208
Willy Tarreauab861d32013-04-02 02:30:41 +02008209/* parse the "alpn" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008210static 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 +02008211{
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01008212#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Willy Tarreauab861d32013-04-02 02:30:41 +02008213 char *p1, *p2;
8214
8215 if (!*args[cur_arg + 1]) {
8216 memprintf(err, "'%s' : missing the comma-delimited ALPN protocol suite", args[cur_arg]);
8217 return ERR_ALERT | ERR_FATAL;
8218 }
8219
8220 free(conf->alpn_str);
8221
Marcoen Hirschbergbef60912016-02-12 17:05:24 +01008222 /* the ALPN string is built as a suite of (<len> <name>)*,
8223 * so we reuse each comma to store the next <len> and need
8224 * one more for the end of the string.
8225 */
Willy Tarreauab861d32013-04-02 02:30:41 +02008226 conf->alpn_len = strlen(args[cur_arg + 1]) + 1;
Marcoen Hirschbergbef60912016-02-12 17:05:24 +01008227 conf->alpn_str = calloc(1, conf->alpn_len + 1);
Willy Tarreauab861d32013-04-02 02:30:41 +02008228 memcpy(conf->alpn_str + 1, args[cur_arg + 1], conf->alpn_len);
8229
8230 /* replace commas with the name length */
8231 p1 = conf->alpn_str;
8232 p2 = p1 + 1;
8233 while (1) {
8234 p2 = memchr(p1 + 1, ',', conf->alpn_str + conf->alpn_len - (p1 + 1));
8235 if (!p2)
8236 p2 = p1 + 1 + strlen(p1 + 1);
8237
8238 if (p2 - (p1 + 1) > 255) {
8239 *p2 = '\0';
8240 memprintf(err, "'%s' : ALPN protocol name too long : '%s'", args[cur_arg], p1 + 1);
8241 return ERR_ALERT | ERR_FATAL;
8242 }
8243
8244 *p1 = p2 - (p1 + 1);
8245 p1 = p2;
8246
8247 if (!*p2)
8248 break;
8249
8250 *(p2++) = '\0';
8251 }
8252 return 0;
8253#else
8254 if (err)
8255 memprintf(err, "'%s' : library does not support TLS ALPN extension", args[cur_arg]);
8256 return ERR_ALERT | ERR_FATAL;
8257#endif
8258}
8259
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008260static int bind_parse_alpn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8261{
8262 return ssl_bind_parse_alpn(args, cur_arg, px, &conf->ssl_conf, err);
8263}
8264
Willy Tarreau79eeafa2012-09-14 07:53:05 +02008265/* parse the "ssl" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02008266static 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 +02008267{
Willy Tarreau71a8c7c2016-12-21 22:04:54 +01008268 conf->xprt = &ssl_sock;
Willy Tarreau4348fad2012-09-20 16:48:07 +02008269 conf->is_ssl = 1;
Emeric Brun76d88952012-10-05 15:47:31 +02008270
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008271 if (global_ssl.listen_default_ciphers && !conf->ssl_conf.ciphers)
8272 conf->ssl_conf.ciphers = strdup(global_ssl.listen_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +02008273#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02008274 if (global_ssl.listen_default_ciphersuites && !conf->ssl_conf.ciphersuites)
8275 conf->ssl_conf.ciphersuites = strdup(global_ssl.listen_default_ciphersuites);
8276#endif
Emmanuel Hocdet4608ed92017-01-20 13:06:27 +01008277 conf->ssl_options |= global_ssl.listen_default_ssloptions;
Emmanuel Hocdet43664762017-08-09 18:26:20 +02008278 conf->ssl_conf.ssl_methods.flags |= global_ssl.listen_default_sslmethods.flags;
8279 if (!conf->ssl_conf.ssl_methods.min)
8280 conf->ssl_conf.ssl_methods.min = global_ssl.listen_default_sslmethods.min;
8281 if (!conf->ssl_conf.ssl_methods.max)
8282 conf->ssl_conf.ssl_methods.max = global_ssl.listen_default_sslmethods.max;
Emeric Brun76d88952012-10-05 15:47:31 +02008283
Willy Tarreau79eeafa2012-09-14 07:53:05 +02008284 return 0;
8285}
8286
Lukas Tribus53ae85c2017-05-04 15:45:40 +00008287/* parse the "prefer-client-ciphers" bind keyword */
8288static int bind_parse_pcc(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8289{
8290 conf->ssl_options |= BC_SSL_O_PREF_CLIE_CIPH;
8291 return 0;
8292}
8293
Christopher Faulet31af49d2015-06-09 17:29:50 +02008294/* parse the "generate-certificates" bind keyword */
8295static int bind_parse_generate_certs(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8296{
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01008297#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Christopher Faulet31af49d2015-06-09 17:29:50 +02008298 conf->generate_certs = 1;
8299#else
8300 memprintf(err, "%sthis version of openssl cannot generate SSL certificates.\n",
8301 err && *err ? *err : "");
8302#endif
8303 return 0;
8304}
8305
Emmanuel Hocdet65623372013-01-24 17:17:15 +01008306/* parse the "strict-sni" bind keyword */
8307static int bind_parse_strict_sni(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8308{
8309 conf->strict_sni = 1;
8310 return 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008311}
8312
8313/* parse the "tls-ticket-keys" bind keyword */
8314static int bind_parse_tls_ticket_keys(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8315{
8316#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008317 FILE *f = NULL;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008318 int i = 0;
8319 char thisline[LINESIZE];
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008320 struct tls_keys_ref *keys_ref = NULL;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008321
8322 if (!*args[cur_arg + 1]) {
8323 if (err)
8324 memprintf(err, "'%s' : missing TLS ticket keys file path", args[cur_arg]);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008325 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008326 }
8327
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02008328 keys_ref = tlskeys_ref_lookup(args[cur_arg + 1]);
Willy Tarreau17b4aa12018-07-17 10:05:32 +02008329 if (keys_ref) {
8330 keys_ref->refcount++;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02008331 conf->keys_ref = keys_ref;
8332 return 0;
8333 }
8334
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008335 keys_ref = calloc(1, sizeof(*keys_ref));
Emeric Brun09852f72019-01-10 10:51:13 +01008336 if (!keys_ref) {
8337 if (err)
8338 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008339 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01008340 }
8341
Emeric Brun9e754772019-01-10 17:51:55 +01008342 keys_ref->tlskeys = malloc(TLS_TICKETS_NO * sizeof(union tls_sess_key));
Emeric Brun09852f72019-01-10 10:51:13 +01008343 if (!keys_ref->tlskeys) {
Emeric Brun09852f72019-01-10 10:51:13 +01008344 if (err)
8345 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008346 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01008347 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008348
8349 if ((f = fopen(args[cur_arg + 1], "r")) == NULL) {
8350 if (err)
8351 memprintf(err, "'%s' : unable to load ssl tickets keys file", args[cur_arg+1]);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008352 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008353 }
8354
Nenad Merdanovic146defa2015-05-09 08:46:00 +02008355 keys_ref->filename = strdup(args[cur_arg + 1]);
Emeric Brun09852f72019-01-10 10:51:13 +01008356 if (!keys_ref->filename) {
Emeric Brun09852f72019-01-10 10:51:13 +01008357 if (err)
8358 memprintf(err, "'%s' : allocation error", args[cur_arg+1]);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008359 goto fail;
Emeric Brun09852f72019-01-10 10:51:13 +01008360 }
Nenad Merdanovic146defa2015-05-09 08:46:00 +02008361
Emeric Brun9e754772019-01-10 17:51:55 +01008362 keys_ref->key_size_bits = 0;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008363 while (fgets(thisline, sizeof(thisline), f) != NULL) {
8364 int len = strlen(thisline);
Emeric Brun9e754772019-01-10 17:51:55 +01008365 int dec_size;
8366
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008367 /* Strip newline characters from the end */
8368 if(thisline[len - 1] == '\n')
8369 thisline[--len] = 0;
8370
8371 if(thisline[len - 1] == '\r')
8372 thisline[--len] = 0;
8373
Emeric Brun9e754772019-01-10 17:51:55 +01008374 dec_size = base64dec(thisline, len, (char *) (keys_ref->tlskeys + i % TLS_TICKETS_NO), sizeof(union tls_sess_key));
8375 if (dec_size < 0) {
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008376 if (err)
8377 memprintf(err, "'%s' : unable to decode base64 key on line %d", args[cur_arg+1], i + 1);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008378 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008379 }
Emeric Brun9e754772019-01-10 17:51:55 +01008380 else if (!keys_ref->key_size_bits && (dec_size == sizeof(struct tls_sess_key_128))) {
8381 keys_ref->key_size_bits = 128;
8382 }
8383 else if (!keys_ref->key_size_bits && (dec_size == sizeof(struct tls_sess_key_256))) {
8384 keys_ref->key_size_bits = 256;
8385 }
8386 else if (((dec_size != sizeof(struct tls_sess_key_128)) && (dec_size != sizeof(struct tls_sess_key_256)))
8387 || ((dec_size == sizeof(struct tls_sess_key_128) && (keys_ref->key_size_bits != 128)))
8388 || ((dec_size == sizeof(struct tls_sess_key_256) && (keys_ref->key_size_bits != 256)))) {
Emeric Brun9e754772019-01-10 17:51:55 +01008389 if (err)
8390 memprintf(err, "'%s' : wrong sized key on line %d", args[cur_arg+1], i + 1);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008391 goto fail;
Emeric Brun9e754772019-01-10 17:51:55 +01008392 }
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008393 i++;
8394 }
8395
8396 if (i < TLS_TICKETS_NO) {
8397 if (err)
8398 memprintf(err, "'%s' : please supply at least %d keys in the tls-tickets-file", args[cur_arg+1], TLS_TICKETS_NO);
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008399 goto fail;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008400 }
8401
8402 fclose(f);
8403
8404 /* Use penultimate key for encryption, handle when TLS_TICKETS_NO = 1 */
Nenad Merdanovic17891152016-03-25 22:16:57 +01008405 i -= 2;
8406 keys_ref->tls_ticket_enc_index = i < 0 ? 0 : i % TLS_TICKETS_NO;
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02008407 keys_ref->unique_id = -1;
Willy Tarreau17b4aa12018-07-17 10:05:32 +02008408 keys_ref->refcount = 1;
Christopher Faulet16f45c82018-02-16 11:23:49 +01008409 HA_RWLOCK_INIT(&keys_ref->lock);
Nenad Merdanovic146defa2015-05-09 08:46:00 +02008410 conf->keys_ref = keys_ref;
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008411
Nenad Merdanovic200b0fa2015-05-09 08:46:01 +02008412 LIST_ADD(&tlskeys_reference, &keys_ref->list);
8413
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008414 return 0;
Christopher Faulet2bbc80d2019-10-21 09:55:49 +02008415
8416 fail:
8417 if (f)
8418 fclose(f);
8419 if (keys_ref) {
8420 free(keys_ref->filename);
8421 free(keys_ref->tlskeys);
8422 free(keys_ref);
8423 }
8424 return ERR_ALERT | ERR_FATAL;
8425
Nenad Merdanovic05552d42015-02-27 19:56:49 +01008426#else
8427 if (err)
8428 memprintf(err, "'%s' : TLS ticket callback extension not supported", args[cur_arg]);
8429 return ERR_ALERT | ERR_FATAL;
8430#endif /* SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB */
Emmanuel Hocdet65623372013-01-24 17:17:15 +01008431}
8432
Emeric Brund94b3fe2012-09-20 18:23:56 +02008433/* parse the "verify" bind keyword */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008434static 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 +02008435{
8436 if (!*args[cur_arg + 1]) {
8437 if (err)
8438 memprintf(err, "'%s' : missing verify method", args[cur_arg]);
8439 return ERR_ALERT | ERR_FATAL;
8440 }
8441
8442 if (strcmp(args[cur_arg + 1], "none") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01008443 conf->verify = SSL_SOCK_VERIFY_NONE;
Emeric Brund94b3fe2012-09-20 18:23:56 +02008444 else if (strcmp(args[cur_arg + 1], "optional") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01008445 conf->verify = SSL_SOCK_VERIFY_OPTIONAL;
Emeric Brund94b3fe2012-09-20 18:23:56 +02008446 else if (strcmp(args[cur_arg + 1], "required") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01008447 conf->verify = SSL_SOCK_VERIFY_REQUIRED;
Emeric Brund94b3fe2012-09-20 18:23:56 +02008448 else {
8449 if (err)
8450 memprintf(err, "'%s' : unknown verify method '%s', only 'none', 'optional', and 'required' are supported\n",
8451 args[cur_arg], args[cur_arg + 1]);
8452 return ERR_ALERT | ERR_FATAL;
8453 }
8454
8455 return 0;
8456}
Emmanuel Hocdet98263292016-12-29 18:26:15 +01008457static int bind_parse_verify(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8458{
8459 return ssl_bind_parse_verify(args, cur_arg, px, &conf->ssl_conf, err);
8460}
Emeric Brund94b3fe2012-09-20 18:23:56 +02008461
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02008462/* parse the "no-ca-names" bind keyword */
8463static int ssl_bind_parse_no_ca_names(char **args, int cur_arg, struct proxy *px, struct ssl_bind_conf *conf, char **err)
8464{
8465 conf->no_ca_names = 1;
8466 return 0;
8467}
8468static int bind_parse_no_ca_names(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
8469{
8470 return ssl_bind_parse_no_ca_names(args, cur_arg, px, &conf->ssl_conf, err);
8471}
8472
Willy Tarreau92faadf2012-10-10 23:04:25 +02008473/************** "server" keywords ****************/
8474
Olivier Houchardc7566002018-11-20 23:33:50 +01008475/* parse the "npn" bind keyword */
8476static int srv_parse_npn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8477{
8478#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
8479 char *p1, *p2;
8480
8481 if (!*args[*cur_arg + 1]) {
8482 memprintf(err, "'%s' : missing the comma-delimited NPN protocol suite", args[*cur_arg]);
8483 return ERR_ALERT | ERR_FATAL;
8484 }
8485
8486 free(newsrv->ssl_ctx.npn_str);
8487
8488 /* the NPN string is built as a suite of (<len> <name>)*,
8489 * so we reuse each comma to store the next <len> and need
8490 * one more for the end of the string.
8491 */
8492 newsrv->ssl_ctx.npn_len = strlen(args[*cur_arg + 1]) + 1;
8493 newsrv->ssl_ctx.npn_str = calloc(1, newsrv->ssl_ctx.npn_len + 1);
8494 memcpy(newsrv->ssl_ctx.npn_str + 1, args[*cur_arg + 1],
8495 newsrv->ssl_ctx.npn_len);
8496
8497 /* replace commas with the name length */
8498 p1 = newsrv->ssl_ctx.npn_str;
8499 p2 = p1 + 1;
8500 while (1) {
8501 p2 = memchr(p1 + 1, ',', newsrv->ssl_ctx.npn_str +
8502 newsrv->ssl_ctx.npn_len - (p1 + 1));
8503 if (!p2)
8504 p2 = p1 + 1 + strlen(p1 + 1);
8505
8506 if (p2 - (p1 + 1) > 255) {
8507 *p2 = '\0';
8508 memprintf(err, "'%s' : NPN protocol name too long : '%s'", args[*cur_arg], p1 + 1);
8509 return ERR_ALERT | ERR_FATAL;
8510 }
8511
8512 *p1 = p2 - (p1 + 1);
8513 p1 = p2;
8514
8515 if (!*p2)
8516 break;
8517
8518 *(p2++) = '\0';
8519 }
8520 return 0;
8521#else
8522 if (err)
8523 memprintf(err, "'%s' : library does not support TLS NPN extension", args[*cur_arg]);
8524 return ERR_ALERT | ERR_FATAL;
8525#endif
8526}
8527
Olivier Houchard92150142018-12-21 19:47:01 +01008528/* parse the "alpn" or the "check-alpn" server keyword */
Olivier Houchardc7566002018-11-20 23:33:50 +01008529static int srv_parse_alpn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8530{
8531#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
8532 char *p1, *p2;
Olivier Houchard92150142018-12-21 19:47:01 +01008533 char **alpn_str;
8534 int *alpn_len;
Olivier Houchardc7566002018-11-20 23:33:50 +01008535
Olivier Houchard92150142018-12-21 19:47:01 +01008536 if (*args[*cur_arg] == 'c') {
8537 alpn_str = &newsrv->check.alpn_str;
8538 alpn_len = &newsrv->check.alpn_len;
8539 } else {
8540 alpn_str = &newsrv->ssl_ctx.alpn_str;
8541 alpn_len = &newsrv->ssl_ctx.alpn_len;
8542
8543 }
Olivier Houchardc7566002018-11-20 23:33:50 +01008544 if (!*args[*cur_arg + 1]) {
8545 memprintf(err, "'%s' : missing the comma-delimited ALPN protocol suite", args[*cur_arg]);
8546 return ERR_ALERT | ERR_FATAL;
8547 }
8548
Olivier Houchard92150142018-12-21 19:47:01 +01008549 free(*alpn_str);
Olivier Houchardc7566002018-11-20 23:33:50 +01008550
8551 /* the ALPN string is built as a suite of (<len> <name>)*,
8552 * so we reuse each comma to store the next <len> and need
8553 * one more for the end of the string.
8554 */
Olivier Houchard92150142018-12-21 19:47:01 +01008555 *alpn_len = strlen(args[*cur_arg + 1]) + 1;
8556 *alpn_str = calloc(1, *alpn_len + 1);
8557 memcpy(*alpn_str + 1, args[*cur_arg + 1], *alpn_len);
Olivier Houchardc7566002018-11-20 23:33:50 +01008558
8559 /* replace commas with the name length */
Olivier Houchard92150142018-12-21 19:47:01 +01008560 p1 = *alpn_str;
Olivier Houchardc7566002018-11-20 23:33:50 +01008561 p2 = p1 + 1;
8562 while (1) {
Olivier Houchard92150142018-12-21 19:47:01 +01008563 p2 = memchr(p1 + 1, ',', *alpn_str + *alpn_len - (p1 + 1));
Olivier Houchardc7566002018-11-20 23:33:50 +01008564 if (!p2)
8565 p2 = p1 + 1 + strlen(p1 + 1);
8566
8567 if (p2 - (p1 + 1) > 255) {
8568 *p2 = '\0';
8569 memprintf(err, "'%s' : ALPN protocol name too long : '%s'", args[*cur_arg], p1 + 1);
8570 return ERR_ALERT | ERR_FATAL;
8571 }
8572
8573 *p1 = p2 - (p1 + 1);
8574 p1 = p2;
8575
8576 if (!*p2)
8577 break;
8578
8579 *(p2++) = '\0';
8580 }
8581 return 0;
8582#else
8583 if (err)
8584 memprintf(err, "'%s' : library does not support TLS ALPN extension", args[*cur_arg]);
8585 return ERR_ALERT | ERR_FATAL;
8586#endif
8587}
8588
Emeric Brunef42d922012-10-11 16:11:36 +02008589/* parse the "ca-file" server keyword */
8590static int srv_parse_ca_file(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8591{
8592 if (!*args[*cur_arg + 1]) {
8593 if (err)
8594 memprintf(err, "'%s' : missing CAfile path", args[*cur_arg]);
8595 return ERR_ALERT | ERR_FATAL;
8596 }
8597
Willy Tarreauef934602016-12-22 23:12:01 +01008598 if ((*args[*cur_arg + 1] != '/') && global_ssl.ca_base)
8599 memprintf(&newsrv->ssl_ctx.ca_file, "%s/%s", global_ssl.ca_base, args[*cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02008600 else
8601 memprintf(&newsrv->ssl_ctx.ca_file, "%s", args[*cur_arg + 1]);
8602
8603 return 0;
8604}
8605
Olivier Houchard9130a962017-10-17 17:33:43 +02008606/* parse the "check-sni" server keyword */
8607static int srv_parse_check_sni(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8608{
8609 if (!*args[*cur_arg + 1]) {
8610 if (err)
8611 memprintf(err, "'%s' : missing SNI", args[*cur_arg]);
8612 return ERR_ALERT | ERR_FATAL;
8613 }
8614
8615 newsrv->check.sni = strdup(args[*cur_arg + 1]);
8616 if (!newsrv->check.sni) {
8617 memprintf(err, "'%s' : failed to allocate memory", args[*cur_arg]);
8618 return ERR_ALERT | ERR_FATAL;
8619 }
8620 return 0;
8621
8622}
8623
Willy Tarreau92faadf2012-10-10 23:04:25 +02008624/* parse the "check-ssl" server keyword */
8625static int srv_parse_check_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8626{
8627 newsrv->check.use_ssl = 1;
Willy Tarreauef934602016-12-22 23:12:01 +01008628 if (global_ssl.connect_default_ciphers && !newsrv->ssl_ctx.ciphers)
8629 newsrv->ssl_ctx.ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +02008630#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02008631 if (global_ssl.connect_default_ciphersuites && !newsrv->ssl_ctx.ciphersuites)
8632 newsrv->ssl_ctx.ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
8633#endif
Willy Tarreauef934602016-12-22 23:12:01 +01008634 newsrv->ssl_ctx.options |= global_ssl.connect_default_ssloptions;
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008635 newsrv->ssl_ctx.methods.flags |= global_ssl.connect_default_sslmethods.flags;
8636 if (!newsrv->ssl_ctx.methods.min)
8637 newsrv->ssl_ctx.methods.min = global_ssl.connect_default_sslmethods.min;
8638 if (!newsrv->ssl_ctx.methods.max)
8639 newsrv->ssl_ctx.methods.max = global_ssl.connect_default_sslmethods.max;
8640
Willy Tarreau92faadf2012-10-10 23:04:25 +02008641 return 0;
8642}
8643
8644/* parse the "ciphers" server keyword */
8645static int srv_parse_ciphers(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8646{
8647 if (!*args[*cur_arg + 1]) {
8648 memprintf(err, "'%s' : missing cipher suite", args[*cur_arg]);
8649 return ERR_ALERT | ERR_FATAL;
8650 }
8651
8652 free(newsrv->ssl_ctx.ciphers);
8653 newsrv->ssl_ctx.ciphers = strdup(args[*cur_arg + 1]);
8654 return 0;
8655}
Dirkjan Bussink415150f2018-09-14 11:14:21 +02008656
Emmanuel Hocdet839af572019-05-14 16:27:35 +02008657#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02008658/* parse the "ciphersuites" server keyword */
8659static int srv_parse_ciphersuites(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8660{
8661 if (!*args[*cur_arg + 1]) {
8662 memprintf(err, "'%s' : missing cipher suite", args[*cur_arg]);
8663 return ERR_ALERT | ERR_FATAL;
8664 }
8665
8666 free(newsrv->ssl_ctx.ciphersuites);
8667 newsrv->ssl_ctx.ciphersuites = strdup(args[*cur_arg + 1]);
8668 return 0;
8669}
8670#endif
Willy Tarreau92faadf2012-10-10 23:04:25 +02008671
Emeric Brunef42d922012-10-11 16:11:36 +02008672/* parse the "crl-file" server keyword */
8673static int srv_parse_crl_file(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8674{
8675#ifndef X509_V_FLAG_CRL_CHECK
8676 if (err)
8677 memprintf(err, "'%s' : library does not support CRL verify", args[*cur_arg]);
8678 return ERR_ALERT | ERR_FATAL;
8679#else
8680 if (!*args[*cur_arg + 1]) {
8681 if (err)
8682 memprintf(err, "'%s' : missing CRLfile path", args[*cur_arg]);
8683 return ERR_ALERT | ERR_FATAL;
8684 }
8685
Willy Tarreauef934602016-12-22 23:12:01 +01008686 if ((*args[*cur_arg + 1] != '/') && global_ssl.ca_base)
8687 memprintf(&newsrv->ssl_ctx.crl_file, "%s/%s", global_ssl.ca_base, args[*cur_arg + 1]);
Emeric Brunef42d922012-10-11 16:11:36 +02008688 else
8689 memprintf(&newsrv->ssl_ctx.crl_file, "%s", args[*cur_arg + 1]);
8690
8691 return 0;
8692#endif
8693}
8694
Emeric Bruna7aa3092012-10-26 12:58:00 +02008695/* parse the "crt" server keyword */
8696static int srv_parse_crt(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8697{
8698 if (!*args[*cur_arg + 1]) {
8699 if (err)
8700 memprintf(err, "'%s' : missing certificate file path", args[*cur_arg]);
8701 return ERR_ALERT | ERR_FATAL;
8702 }
8703
Willy Tarreauef934602016-12-22 23:12:01 +01008704 if ((*args[*cur_arg + 1] != '/') && global_ssl.crt_base)
Christopher Fauletff3a41e2017-11-23 09:13:32 +01008705 memprintf(&newsrv->ssl_ctx.client_crt, "%s/%s", global_ssl.crt_base, args[*cur_arg + 1]);
Emeric Bruna7aa3092012-10-26 12:58:00 +02008706 else
8707 memprintf(&newsrv->ssl_ctx.client_crt, "%s", args[*cur_arg + 1]);
8708
8709 return 0;
8710}
Emeric Brunef42d922012-10-11 16:11:36 +02008711
Frédéric Lécaille340ae602017-03-13 10:38:04 +01008712/* parse the "no-check-ssl" server keyword */
8713static int srv_parse_no_check_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8714{
8715 newsrv->check.use_ssl = 0;
8716 free(newsrv->ssl_ctx.ciphers);
8717 newsrv->ssl_ctx.ciphers = NULL;
8718 newsrv->ssl_ctx.options &= ~global_ssl.connect_default_ssloptions;
8719 return 0;
8720}
8721
Frédéric Lécaillee892c4c2017-03-13 12:08:01 +01008722/* parse the "no-send-proxy-v2-ssl" server keyword */
8723static int srv_parse_no_send_proxy_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8724{
8725 newsrv->pp_opts &= ~SRV_PP_V2;
8726 newsrv->pp_opts &= ~SRV_PP_V2_SSL;
8727 return 0;
8728}
8729
8730/* parse the "no-send-proxy-v2-ssl-cn" server keyword */
8731static int srv_parse_no_send_proxy_cn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8732{
8733 newsrv->pp_opts &= ~SRV_PP_V2;
8734 newsrv->pp_opts &= ~SRV_PP_V2_SSL;
8735 newsrv->pp_opts &= ~SRV_PP_V2_SSL_CN;
8736 return 0;
8737}
8738
Frédéric Lécaillee381d762017-03-13 11:54:17 +01008739/* parse the "no-ssl" server keyword */
8740static int srv_parse_no_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8741{
8742 newsrv->use_ssl = 0;
8743 free(newsrv->ssl_ctx.ciphers);
8744 newsrv->ssl_ctx.ciphers = NULL;
8745 return 0;
8746}
8747
Olivier Houchard522eea72017-11-03 16:27:47 +01008748/* parse the "allow-0rtt" server keyword */
8749static int srv_parse_allow_0rtt(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8750{
8751 newsrv->ssl_ctx.options |= SRV_SSL_O_EARLY_DATA;
8752 return 0;
8753}
8754
Willy Tarreau2a3fb1c2015-02-05 16:47:07 +01008755/* parse the "no-ssl-reuse" server keyword */
8756static int srv_parse_no_ssl_reuse(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8757{
8758 newsrv->ssl_ctx.options |= SRV_SSL_O_NO_REUSE;
8759 return 0;
8760}
8761
Emeric Brunf9c5c472012-10-11 15:28:34 +02008762/* parse the "no-tls-tickets" server keyword */
8763static int srv_parse_no_tls_tickets(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8764{
8765 newsrv->ssl_ctx.options |= SRV_SSL_O_NO_TLS_TICKETS;
8766 return 0;
8767}
David Safb76832014-05-08 23:42:08 -04008768/* parse the "send-proxy-v2-ssl" server keyword */
8769static int srv_parse_send_proxy_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8770{
8771 newsrv->pp_opts |= SRV_PP_V2;
8772 newsrv->pp_opts |= SRV_PP_V2_SSL;
8773 return 0;
8774}
8775
8776/* parse the "send-proxy-v2-ssl-cn" server keyword */
8777static int srv_parse_send_proxy_cn(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8778{
8779 newsrv->pp_opts |= SRV_PP_V2;
8780 newsrv->pp_opts |= SRV_PP_V2_SSL;
8781 newsrv->pp_opts |= SRV_PP_V2_SSL_CN;
8782 return 0;
8783}
Emeric Brunf9c5c472012-10-11 15:28:34 +02008784
Willy Tarreau732eac42015-07-09 11:40:25 +02008785/* parse the "sni" server keyword */
8786static int srv_parse_sni(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8787{
8788#ifndef SSL_CTRL_SET_TLSEXT_HOSTNAME
8789 memprintf(err, "'%s' : the current SSL library doesn't support the SNI TLS extension", args[*cur_arg]);
8790 return ERR_ALERT | ERR_FATAL;
8791#else
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01008792 char *arg;
Willy Tarreau732eac42015-07-09 11:40:25 +02008793
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01008794 arg = args[*cur_arg + 1];
8795 if (!*arg) {
Willy Tarreau732eac42015-07-09 11:40:25 +02008796 memprintf(err, "'%s' : missing sni expression", args[*cur_arg]);
8797 return ERR_ALERT | ERR_FATAL;
8798 }
8799
Frédéric Lécaille9a146de2017-03-20 14:54:41 +01008800 free(newsrv->sni_expr);
8801 newsrv->sni_expr = strdup(arg);
Willy Tarreau732eac42015-07-09 11:40:25 +02008802
Willy Tarreau732eac42015-07-09 11:40:25 +02008803 return 0;
8804#endif
8805}
8806
Willy Tarreau92faadf2012-10-10 23:04:25 +02008807/* parse the "ssl" server keyword */
8808static int srv_parse_ssl(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8809{
8810 newsrv->use_ssl = 1;
Willy Tarreauef934602016-12-22 23:12:01 +01008811 if (global_ssl.connect_default_ciphers && !newsrv->ssl_ctx.ciphers)
8812 newsrv->ssl_ctx.ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +02008813#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02008814 if (global_ssl.connect_default_ciphersuites && !newsrv->ssl_ctx.ciphersuites)
8815 newsrv->ssl_ctx.ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
8816#endif
Willy Tarreau92faadf2012-10-10 23:04:25 +02008817 return 0;
8818}
8819
Frédéric Lécaille2cfcdbe2017-03-13 11:32:20 +01008820/* parse the "ssl-reuse" server keyword */
8821static int srv_parse_ssl_reuse(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8822{
8823 newsrv->ssl_ctx.options &= ~SRV_SSL_O_NO_REUSE;
8824 return 0;
8825}
8826
Frédéric Lécaille2cfcdbe2017-03-13 11:32:20 +01008827/* parse the "tls-tickets" server keyword */
8828static int srv_parse_tls_tickets(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8829{
8830 newsrv->ssl_ctx.options &= ~SRV_SSL_O_NO_TLS_TICKETS;
8831 return 0;
8832}
8833
Emeric Brunef42d922012-10-11 16:11:36 +02008834/* parse the "verify" server keyword */
8835static int srv_parse_verify(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8836{
8837 if (!*args[*cur_arg + 1]) {
8838 if (err)
8839 memprintf(err, "'%s' : missing verify method", args[*cur_arg]);
8840 return ERR_ALERT | ERR_FATAL;
8841 }
8842
8843 if (strcmp(args[*cur_arg + 1], "none") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01008844 newsrv->ssl_ctx.verify = SSL_SOCK_VERIFY_NONE;
Emeric Brunef42d922012-10-11 16:11:36 +02008845 else if (strcmp(args[*cur_arg + 1], "required") == 0)
Emeric Brun850efd52014-01-29 12:24:34 +01008846 newsrv->ssl_ctx.verify = SSL_SOCK_VERIFY_REQUIRED;
Emeric Brunef42d922012-10-11 16:11:36 +02008847 else {
8848 if (err)
8849 memprintf(err, "'%s' : unknown verify method '%s', only 'none' and 'required' are supported\n",
8850 args[*cur_arg], args[*cur_arg + 1]);
8851 return ERR_ALERT | ERR_FATAL;
8852 }
8853
Evan Broderbe554312013-06-27 00:05:25 -07008854 return 0;
8855}
8856
8857/* parse the "verifyhost" server keyword */
8858static int srv_parse_verifyhost(char **args, int *cur_arg, struct proxy *px, struct server *newsrv, char **err)
8859{
8860 if (!*args[*cur_arg + 1]) {
8861 if (err)
8862 memprintf(err, "'%s' : missing hostname to verify against", args[*cur_arg]);
8863 return ERR_ALERT | ERR_FATAL;
8864 }
8865
Frédéric Lécaille273f3212017-03-13 15:52:01 +01008866 free(newsrv->ssl_ctx.verify_host);
Evan Broderbe554312013-06-27 00:05:25 -07008867 newsrv->ssl_ctx.verify_host = strdup(args[*cur_arg + 1]);
8868
Emeric Brunef42d922012-10-11 16:11:36 +02008869 return 0;
8870}
8871
Emeric Brun2c86cbf2014-10-30 15:56:50 +01008872/* parse the "ssl-default-bind-options" keyword in global section */
8873static int ssl_parse_default_bind_options(char **args, int section_type, struct proxy *curpx,
8874 struct proxy *defpx, const char *file, int line,
8875 char **err) {
8876 int i = 1;
8877
8878 if (*(args[i]) == 0) {
8879 memprintf(err, "global statement '%s' expects an option as an argument.", args[0]);
8880 return -1;
8881 }
8882 while (*(args[i])) {
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008883 if (!strcmp(args[i], "no-tls-tickets"))
Willy Tarreauef934602016-12-22 23:12:01 +01008884 global_ssl.listen_default_ssloptions |= BC_SSL_O_NO_TLS_TICKETS;
Lukas Tribus53ae85c2017-05-04 15:45:40 +00008885 else if (!strcmp(args[i], "prefer-client-ciphers"))
8886 global_ssl.listen_default_ssloptions |= BC_SSL_O_PREF_CLIE_CIPH;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008887 else if (!strcmp(args[i], "ssl-min-ver") || !strcmp(args[i], "ssl-max-ver")) {
8888 if (!parse_tls_method_minmax(args, i, &global_ssl.listen_default_sslmethods, err))
8889 i++;
8890 else {
8891 memprintf(err, "%s on global statement '%s'.", *err, args[0]);
8892 return -1;
8893 }
8894 }
8895 else if (parse_tls_method_options(args[i], &global_ssl.listen_default_sslmethods, err)) {
Emeric Brun2c86cbf2014-10-30 15:56:50 +01008896 memprintf(err, "unknown option '%s' on global statement '%s'.", args[i], args[0]);
8897 return -1;
8898 }
8899 i++;
8900 }
8901 return 0;
8902}
8903
8904/* parse the "ssl-default-server-options" keyword in global section */
8905static int ssl_parse_default_server_options(char **args, int section_type, struct proxy *curpx,
8906 struct proxy *defpx, const char *file, int line,
8907 char **err) {
8908 int i = 1;
8909
8910 if (*(args[i]) == 0) {
8911 memprintf(err, "global statement '%s' expects an option as an argument.", args[0]);
8912 return -1;
8913 }
8914 while (*(args[i])) {
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02008915 if (!strcmp(args[i], "no-tls-tickets"))
Willy Tarreauef934602016-12-22 23:12:01 +01008916 global_ssl.connect_default_ssloptions |= SRV_SSL_O_NO_TLS_TICKETS;
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02008917 else if (!strcmp(args[i], "ssl-min-ver") || !strcmp(args[i], "ssl-max-ver")) {
8918 if (!parse_tls_method_minmax(args, i, &global_ssl.connect_default_sslmethods, err))
8919 i++;
8920 else {
8921 memprintf(err, "%s on global statement '%s'.", *err, args[0]);
8922 return -1;
8923 }
8924 }
8925 else if (parse_tls_method_options(args[i], &global_ssl.connect_default_sslmethods, err)) {
Emeric Brun2c86cbf2014-10-30 15:56:50 +01008926 memprintf(err, "unknown option '%s' on global statement '%s'.", args[i], args[0]);
8927 return -1;
8928 }
8929 i++;
8930 }
8931 return 0;
8932}
8933
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +01008934/* parse the "ca-base" / "crt-base" keywords in global section.
8935 * Returns <0 on alert, >0 on warning, 0 on success.
8936 */
8937static int ssl_parse_global_ca_crt_base(char **args, int section_type, struct proxy *curpx,
8938 struct proxy *defpx, const char *file, int line,
8939 char **err)
8940{
8941 char **target;
8942
Willy Tarreauef934602016-12-22 23:12:01 +01008943 target = (args[0][1] == 'a') ? &global_ssl.ca_base : &global_ssl.crt_base;
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +01008944
8945 if (too_many_args(1, args, err, NULL))
8946 return -1;
8947
8948 if (*target) {
8949 memprintf(err, "'%s' already specified.", args[0]);
8950 return -1;
8951 }
8952
8953 if (*(args[1]) == 0) {
8954 memprintf(err, "global statement '%s' expects a directory path as an argument.", args[0]);
8955 return -1;
8956 }
8957 *target = strdup(args[1]);
8958 return 0;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00008959}
8960
8961/* parse the "ssl-mode-async" keyword in global section.
8962 * Returns <0 on alert, >0 on warning, 0 on success.
8963 */
8964static int ssl_parse_global_ssl_async(char **args, int section_type, struct proxy *curpx,
8965 struct proxy *defpx, const char *file, int line,
8966 char **err)
8967{
Willy Tarreau5db847a2019-05-09 14:13:35 +02008968#if (HA_OPENSSL_VERSION_NUMBER >= 0x1010000fL) && !defined(OPENSSL_NO_ASYNC)
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00008969 global_ssl.async = 1;
Emeric Brunece0c332017-12-06 13:51:49 +01008970 global.ssl_used_async_engines = nb_engines;
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00008971 return 0;
8972#else
8973 memprintf(err, "'%s': openssl library does not support async mode", args[0]);
8974 return -1;
8975#endif
8976}
8977
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +02008978#ifndef OPENSSL_NO_ENGINE
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00008979static int ssl_check_async_engine_count(void) {
8980 int err_code = 0;
8981
Emeric Brun3854e012017-05-17 20:42:48 +02008982 if (global_ssl.async && (openssl_engines_initialized > 32)) {
Christopher Faulet767a84b2017-11-24 16:50:31 +01008983 ha_alert("ssl-mode-async only supports a maximum of 32 engines.\n");
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00008984 err_code = ERR_ABORT;
8985 }
8986 return err_code;
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +01008987}
8988
Grant Zhang872f9c22017-01-21 01:10:18 +00008989/* parse the "ssl-engine" keyword in global section.
8990 * Returns <0 on alert, >0 on warning, 0 on success.
8991 */
8992static int ssl_parse_global_ssl_engine(char **args, int section_type, struct proxy *curpx,
8993 struct proxy *defpx, const char *file, int line,
8994 char **err)
8995{
8996 char *algo;
8997 int ret = -1;
8998
8999 if (*(args[1]) == 0) {
9000 memprintf(err, "global statement '%s' expects a valid engine name as an argument.", args[0]);
9001 return ret;
9002 }
9003
9004 if (*(args[2]) == 0) {
9005 /* if no list of algorithms is given, it defaults to ALL */
9006 algo = strdup("ALL");
9007 goto add_engine;
9008 }
9009
9010 /* otherwise the expected format is ssl-engine <engine_name> algo <list of algo> */
9011 if (strcmp(args[2], "algo") != 0) {
9012 memprintf(err, "global statement '%s' expects to have algo keyword.", args[0]);
9013 return ret;
9014 }
9015
9016 if (*(args[3]) == 0) {
9017 memprintf(err, "global statement '%s' expects algorithm names as an argument.", args[0]);
9018 return ret;
9019 }
9020 algo = strdup(args[3]);
9021
9022add_engine:
9023 if (ssl_init_single_engine(args[1], algo)==0) {
9024 openssl_engines_initialized++;
9025 ret = 0;
9026 }
9027 free(algo);
9028 return ret;
9029}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +02009030#endif
Grant Zhang872f9c22017-01-21 01:10:18 +00009031
Willy Tarreauf22e9682016-12-21 23:23:19 +01009032/* parse the "ssl-default-bind-ciphers" / "ssl-default-server-ciphers" keywords
9033 * in global section. Returns <0 on alert, >0 on warning, 0 on success.
9034 */
9035static int ssl_parse_global_ciphers(char **args, int section_type, struct proxy *curpx,
9036 struct proxy *defpx, const char *file, int line,
9037 char **err)
9038{
9039 char **target;
9040
Willy Tarreauef934602016-12-22 23:12:01 +01009041 target = (args[0][12] == 'b') ? &global_ssl.listen_default_ciphers : &global_ssl.connect_default_ciphers;
Willy Tarreauf22e9682016-12-21 23:23:19 +01009042
9043 if (too_many_args(1, args, err, NULL))
9044 return -1;
9045
9046 if (*(args[1]) == 0) {
9047 memprintf(err, "global statement '%s' expects a cipher suite as an argument.", args[0]);
9048 return -1;
9049 }
9050
9051 free(*target);
9052 *target = strdup(args[1]);
9053 return 0;
9054}
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009055
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009056#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009057/* parse the "ssl-default-bind-ciphersuites" / "ssl-default-server-ciphersuites" keywords
9058 * in global section. Returns <0 on alert, >0 on warning, 0 on success.
9059 */
9060static int ssl_parse_global_ciphersuites(char **args, int section_type, struct proxy *curpx,
9061 struct proxy *defpx, const char *file, int line,
9062 char **err)
9063{
9064 char **target;
9065
9066 target = (args[0][12] == 'b') ? &global_ssl.listen_default_ciphersuites : &global_ssl.connect_default_ciphersuites;
9067
9068 if (too_many_args(1, args, err, NULL))
9069 return -1;
9070
9071 if (*(args[1]) == 0) {
9072 memprintf(err, "global statement '%s' expects a cipher suite as an argument.", args[0]);
9073 return -1;
9074 }
9075
9076 free(*target);
9077 *target = strdup(args[1]);
9078 return 0;
9079}
9080#endif
Willy Tarreauf22e9682016-12-21 23:23:19 +01009081
Willy Tarreau9ceda382016-12-21 23:13:03 +01009082/* parse various global tune.ssl settings consisting in positive integers.
9083 * Returns <0 on alert, >0 on warning, 0 on success.
9084 */
9085static int ssl_parse_global_int(char **args, int section_type, struct proxy *curpx,
9086 struct proxy *defpx, const char *file, int line,
9087 char **err)
9088{
9089 int *target;
9090
9091 if (strcmp(args[0], "tune.ssl.cachesize") == 0)
9092 target = &global.tune.sslcachesize;
9093 else if (strcmp(args[0], "tune.ssl.maxrecord") == 0)
Willy Tarreauef934602016-12-22 23:12:01 +01009094 target = (int *)&global_ssl.max_record;
Willy Tarreau9ceda382016-12-21 23:13:03 +01009095 else if (strcmp(args[0], "tune.ssl.ssl-ctx-cache-size") == 0)
Willy Tarreauef934602016-12-22 23:12:01 +01009096 target = &global_ssl.ctx_cache;
Willy Tarreau0bea58d2016-12-21 23:17:25 +01009097 else if (strcmp(args[0], "maxsslconn") == 0)
9098 target = &global.maxsslconn;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009099 else if (strcmp(args[0], "tune.ssl.capture-cipherlist-size") == 0)
9100 target = &global_ssl.capture_cipherlist;
Willy Tarreau9ceda382016-12-21 23:13:03 +01009101 else {
9102 memprintf(err, "'%s' keyword not unhandled (please report this bug).", args[0]);
9103 return -1;
9104 }
9105
9106 if (too_many_args(1, args, err, NULL))
9107 return -1;
9108
9109 if (*(args[1]) == 0) {
9110 memprintf(err, "'%s' expects an integer argument.", args[0]);
9111 return -1;
9112 }
9113
9114 *target = atoi(args[1]);
9115 if (*target < 0) {
9116 memprintf(err, "'%s' expects a positive numeric value.", args[0]);
9117 return -1;
9118 }
9119 return 0;
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009120}
9121
9122static int ssl_parse_global_capture_cipherlist(char **args, int section_type, struct proxy *curpx,
9123 struct proxy *defpx, const char *file, int line,
9124 char **err)
9125{
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009126 int ret;
9127
9128 ret = ssl_parse_global_int(args, section_type, curpx, defpx, file, line, err);
9129 if (ret != 0)
9130 return ret;
9131
Willy Tarreaubafbe012017-11-24 17:34:44 +01009132 if (pool_head_ssl_capture) {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009133 memprintf(err, "'%s' is already configured.", args[0]);
9134 return -1;
9135 }
9136
Willy Tarreaubafbe012017-11-24 17:34:44 +01009137 pool_head_ssl_capture = create_pool("ssl-capture", sizeof(struct ssl_capture) + global_ssl.capture_cipherlist, MEM_F_SHARED);
9138 if (!pool_head_ssl_capture) {
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009139 memprintf(err, "Out of memory error.");
9140 return -1;
9141 }
9142 return 0;
Willy Tarreau9ceda382016-12-21 23:13:03 +01009143}
9144
9145/* parse "ssl.force-private-cache".
9146 * Returns <0 on alert, >0 on warning, 0 on success.
9147 */
9148static int ssl_parse_global_private_cache(char **args, int section_type, struct proxy *curpx,
9149 struct proxy *defpx, const char *file, int line,
9150 char **err)
9151{
9152 if (too_many_args(0, args, err, NULL))
9153 return -1;
9154
Willy Tarreauef934602016-12-22 23:12:01 +01009155 global_ssl.private_cache = 1;
Willy Tarreau9ceda382016-12-21 23:13:03 +01009156 return 0;
9157}
9158
9159/* parse "ssl.lifetime".
9160 * Returns <0 on alert, >0 on warning, 0 on success.
9161 */
9162static int ssl_parse_global_lifetime(char **args, int section_type, struct proxy *curpx,
9163 struct proxy *defpx, const char *file, int line,
9164 char **err)
9165{
9166 const char *res;
9167
9168 if (too_many_args(1, args, err, NULL))
9169 return -1;
9170
9171 if (*(args[1]) == 0) {
9172 memprintf(err, "'%s' expects ssl sessions <lifetime> in seconds as argument.", args[0]);
9173 return -1;
9174 }
9175
Willy Tarreauef934602016-12-22 23:12:01 +01009176 res = parse_time_err(args[1], &global_ssl.life_time, TIME_UNIT_S);
Willy Tarreau9faebe32019-06-07 19:00:37 +02009177 if (res == PARSE_TIME_OVER) {
9178 memprintf(err, "timer overflow in argument '%s' to <%s> (maximum value is 2147483647 s or ~68 years).",
9179 args[1], args[0]);
9180 return -1;
9181 }
9182 else if (res == PARSE_TIME_UNDER) {
9183 memprintf(err, "timer underflow in argument '%s' to <%s> (minimum non-null value is 1 s).",
9184 args[1], args[0]);
9185 return -1;
9186 }
9187 else if (res) {
Willy Tarreau9ceda382016-12-21 23:13:03 +01009188 memprintf(err, "unexpected character '%c' in argument to <%s>.", *res, args[0]);
9189 return -1;
9190 }
9191 return 0;
9192}
9193
9194#ifndef OPENSSL_NO_DH
Willy Tarreau14e36a12016-12-21 23:28:13 +01009195/* parse "ssl-dh-param-file".
9196 * Returns <0 on alert, >0 on warning, 0 on success.
9197 */
9198static int ssl_parse_global_dh_param_file(char **args, int section_type, struct proxy *curpx,
9199 struct proxy *defpx, const char *file, int line,
9200 char **err)
9201{
9202 if (too_many_args(1, args, err, NULL))
9203 return -1;
9204
9205 if (*(args[1]) == 0) {
9206 memprintf(err, "'%s' expects a file path as an argument.", args[0]);
9207 return -1;
9208 }
9209
9210 if (ssl_sock_load_global_dh_param_from_file(args[1])) {
9211 memprintf(err, "'%s': unable to load DH parameters from file <%s>.", args[0], args[1]);
9212 return -1;
9213 }
9214 return 0;
9215}
9216
Willy Tarreau9ceda382016-12-21 23:13:03 +01009217/* parse "ssl.default-dh-param".
9218 * Returns <0 on alert, >0 on warning, 0 on success.
9219 */
9220static int ssl_parse_global_default_dh(char **args, int section_type, struct proxy *curpx,
9221 struct proxy *defpx, const char *file, int line,
9222 char **err)
9223{
9224 if (too_many_args(1, args, err, NULL))
9225 return -1;
9226
9227 if (*(args[1]) == 0) {
9228 memprintf(err, "'%s' expects an integer argument.", args[0]);
9229 return -1;
9230 }
9231
Willy Tarreauef934602016-12-22 23:12:01 +01009232 global_ssl.default_dh_param = atoi(args[1]);
9233 if (global_ssl.default_dh_param < 1024) {
Willy Tarreau9ceda382016-12-21 23:13:03 +01009234 memprintf(err, "'%s' expects a value >= 1024.", args[0]);
9235 return -1;
9236 }
9237 return 0;
9238}
9239#endif
9240
9241
William Lallemand32af2032016-10-29 18:09:35 +02009242/* This function is used with TLS ticket keys management. It permits to browse
9243 * each reference. The variable <getnext> must contain the current node,
9244 * <end> point to the root node.
9245 */
9246#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
9247static inline
9248struct tls_keys_ref *tlskeys_list_get_next(struct tls_keys_ref *getnext, struct list *end)
9249{
9250 struct tls_keys_ref *ref = getnext;
9251
9252 while (1) {
9253
9254 /* Get next list entry. */
9255 ref = LIST_NEXT(&ref->list, struct tls_keys_ref *, list);
9256
9257 /* If the entry is the last of the list, return NULL. */
9258 if (&ref->list == end)
9259 return NULL;
9260
9261 return ref;
9262 }
9263}
9264
9265static inline
9266struct tls_keys_ref *tlskeys_ref_lookup_ref(const char *reference)
9267{
9268 int id;
9269 char *error;
9270
9271 /* If the reference starts by a '#', this is numeric id. */
9272 if (reference[0] == '#') {
9273 /* Try to convert the numeric id. If the conversion fails, the lookup fails. */
9274 id = strtol(reference + 1, &error, 10);
9275 if (*error != '\0')
9276 return NULL;
9277
9278 /* Perform the unique id lookup. */
9279 return tlskeys_ref_lookupid(id);
9280 }
9281
9282 /* Perform the string lookup. */
9283 return tlskeys_ref_lookup(reference);
9284}
9285#endif
9286
9287
9288#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
9289
9290static int cli_io_handler_tlskeys_files(struct appctx *appctx);
9291
9292static inline int cli_io_handler_tlskeys_entries(struct appctx *appctx) {
9293 return cli_io_handler_tlskeys_files(appctx);
9294}
9295
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009296/* dumps all tls keys. Relies on cli.i0 (non-null = only list file names), cli.i1
9297 * (next index to be dumped), and cli.p0 (next key reference).
9298 */
William Lallemand32af2032016-10-29 18:09:35 +02009299static int cli_io_handler_tlskeys_files(struct appctx *appctx) {
9300
9301 struct stream_interface *si = appctx->owner;
9302
9303 switch (appctx->st2) {
9304 case STAT_ST_INIT:
9305 /* Display the column headers. If the message cannot be sent,
Joseph Herlant017b3da2018-11-15 09:07:59 -08009306 * quit the function with returning 0. The function is called
William Lallemand32af2032016-10-29 18:09:35 +02009307 * later and restart at the state "STAT_ST_INIT".
9308 */
9309 chunk_reset(&trash);
9310
9311 if (appctx->io_handler == cli_io_handler_tlskeys_entries)
9312 chunk_appendf(&trash, "# id secret\n");
9313 else
9314 chunk_appendf(&trash, "# id (file)\n");
9315
Willy Tarreau06d80a92017-10-19 14:32:15 +02009316 if (ci_putchk(si_ic(si), &trash) == -1) {
Willy Tarreaudb398432018-11-15 11:08:52 +01009317 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +02009318 return 0;
9319 }
9320
William Lallemand32af2032016-10-29 18:09:35 +02009321 /* Now, we start the browsing of the references lists.
9322 * Note that the following call to LIST_ELEM return bad pointer. The only
9323 * available field of this pointer is <list>. It is used with the function
9324 * tlskeys_list_get_next() for retruning the first available entry
9325 */
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009326 if (appctx->ctx.cli.p0 == NULL) {
9327 appctx->ctx.cli.p0 = LIST_ELEM(&tlskeys_reference, struct tls_keys_ref *, list);
9328 appctx->ctx.cli.p0 = tlskeys_list_get_next(appctx->ctx.cli.p0, &tlskeys_reference);
William Lallemand32af2032016-10-29 18:09:35 +02009329 }
9330
9331 appctx->st2 = STAT_ST_LIST;
9332 /* fall through */
9333
9334 case STAT_ST_LIST:
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009335 while (appctx->ctx.cli.p0) {
9336 struct tls_keys_ref *ref = appctx->ctx.cli.p0;
William Lallemand32af2032016-10-29 18:09:35 +02009337
9338 chunk_reset(&trash);
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009339 if (appctx->io_handler == cli_io_handler_tlskeys_entries && appctx->ctx.cli.i1 == 0)
William Lallemand32af2032016-10-29 18:09:35 +02009340 chunk_appendf(&trash, "# ");
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009341
9342 if (appctx->ctx.cli.i1 == 0)
9343 chunk_appendf(&trash, "%d (%s)\n", ref->unique_id, ref->filename);
9344
William Lallemand32af2032016-10-29 18:09:35 +02009345 if (appctx->io_handler == cli_io_handler_tlskeys_entries) {
Christopher Faulet16f45c82018-02-16 11:23:49 +01009346 int head;
9347
9348 HA_RWLOCK_RDLOCK(TLSKEYS_REF_LOCK, &ref->lock);
9349 head = ref->tls_ticket_enc_index;
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009350 while (appctx->ctx.cli.i1 < TLS_TICKETS_NO) {
Willy Tarreau83061a82018-07-13 11:56:34 +02009351 struct buffer *t2 = get_trash_chunk();
William Lallemand32af2032016-10-29 18:09:35 +02009352
9353 chunk_reset(t2);
9354 /* should never fail here because we dump only a key in the t2 buffer */
Emeric Brun9e754772019-01-10 17:51:55 +01009355 if (ref->key_size_bits == 128) {
9356 t2->data = a2base64((char *)(ref->tlskeys + (head + 2 + appctx->ctx.cli.i1) % TLS_TICKETS_NO),
9357 sizeof(struct tls_sess_key_128),
9358 t2->area, t2->size);
9359 chunk_appendf(&trash, "%d.%d %s\n", ref->unique_id, appctx->ctx.cli.i1,
9360 t2->area);
9361 }
9362 else if (ref->key_size_bits == 256) {
9363 t2->data = a2base64((char *)(ref->tlskeys + (head + 2 + appctx->ctx.cli.i1) % TLS_TICKETS_NO),
9364 sizeof(struct tls_sess_key_256),
9365 t2->area, t2->size);
9366 chunk_appendf(&trash, "%d.%d %s\n", ref->unique_id, appctx->ctx.cli.i1,
9367 t2->area);
9368 }
9369 else {
9370 /* This case should never happen */
9371 chunk_appendf(&trash, "%d.%d <unknown>\n", ref->unique_id, appctx->ctx.cli.i1);
9372 }
William Lallemand32af2032016-10-29 18:09:35 +02009373
Willy Tarreau06d80a92017-10-19 14:32:15 +02009374 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemand32af2032016-10-29 18:09:35 +02009375 /* let's try again later from this stream. We add ourselves into
9376 * this stream's users so that it can remove us upon termination.
9377 */
Christopher Faulet16f45c82018-02-16 11:23:49 +01009378 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreaudb398432018-11-15 11:08:52 +01009379 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +02009380 return 0;
9381 }
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009382 appctx->ctx.cli.i1++;
William Lallemand32af2032016-10-29 18:09:35 +02009383 }
Christopher Faulet16f45c82018-02-16 11:23:49 +01009384 HA_RWLOCK_RDUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009385 appctx->ctx.cli.i1 = 0;
William Lallemand32af2032016-10-29 18:09:35 +02009386 }
Willy Tarreau06d80a92017-10-19 14:32:15 +02009387 if (ci_putchk(si_ic(si), &trash) == -1) {
William Lallemand32af2032016-10-29 18:09:35 +02009388 /* let's try again later from this stream. We add ourselves into
9389 * this stream's users so that it can remove us upon termination.
9390 */
Willy Tarreaudb398432018-11-15 11:08:52 +01009391 si_rx_room_blk(si);
William Lallemand32af2032016-10-29 18:09:35 +02009392 return 0;
9393 }
9394
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009395 if (appctx->ctx.cli.i0 == 0) /* don't display everything if not necessary */
William Lallemand32af2032016-10-29 18:09:35 +02009396 break;
9397
9398 /* get next list entry and check the end of the list */
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009399 appctx->ctx.cli.p0 = tlskeys_list_get_next(appctx->ctx.cli.p0, &tlskeys_reference);
William Lallemand32af2032016-10-29 18:09:35 +02009400 }
9401
9402 appctx->st2 = STAT_ST_FIN;
9403 /* fall through */
9404
9405 default:
9406 appctx->st2 = STAT_ST_FIN;
9407 return 1;
9408 }
9409 return 0;
9410}
9411
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009412/* sets cli.i0 to non-zero if only file lists should be dumped */
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02009413static int cli_parse_show_tlskeys(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +02009414{
William Lallemand32af2032016-10-29 18:09:35 +02009415 /* no parameter, shows only file list */
9416 if (!*args[2]) {
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009417 appctx->ctx.cli.i0 = 1;
William Lallemand32af2032016-10-29 18:09:35 +02009418 appctx->io_handler = cli_io_handler_tlskeys_files;
Willy Tarreau3067bfa2016-12-05 14:50:15 +01009419 return 0;
William Lallemand32af2032016-10-29 18:09:35 +02009420 }
9421
9422 if (args[2][0] == '*') {
9423 /* list every TLS ticket keys */
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009424 appctx->ctx.cli.i0 = 1;
William Lallemand32af2032016-10-29 18:09:35 +02009425 } else {
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009426 appctx->ctx.cli.p0 = tlskeys_ref_lookup_ref(args[2]);
9427 if (!appctx->ctx.cli.p0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009428 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009429 appctx->ctx.cli.msg = "'show tls-keys' unable to locate referenced filename\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009430 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009431 return 1;
9432 }
9433 }
William Lallemand32af2032016-10-29 18:09:35 +02009434 appctx->io_handler = cli_io_handler_tlskeys_entries;
Willy Tarreau3067bfa2016-12-05 14:50:15 +01009435 return 0;
William Lallemand32af2032016-10-29 18:09:35 +02009436}
9437
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02009438static int cli_parse_set_tlskeys(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +02009439{
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009440 struct tls_keys_ref *ref;
Willy Tarreau1c913e42018-08-22 05:26:57 +02009441 int ret;
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009442
William Lallemand32af2032016-10-29 18:09:35 +02009443 /* Expect two parameters: the filename and the new new TLS key in encoding */
9444 if (!*args[3] || !*args[4]) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009445 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009446 appctx->ctx.cli.msg = "'set ssl tls-key' expects a filename and the new TLS key in base64 encoding.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009447 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009448 return 1;
9449 }
9450
Willy Tarreauf5f26e82016-12-16 18:47:27 +01009451 ref = tlskeys_ref_lookup_ref(args[3]);
9452 if (!ref) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009453 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009454 appctx->ctx.cli.msg = "'set ssl tls-key' unable to locate referenced filename\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009455 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009456 return 1;
9457 }
9458
Willy Tarreau1c913e42018-08-22 05:26:57 +02009459 ret = base64dec(args[4], strlen(args[4]), trash.area, trash.size);
Emeric Brun9e754772019-01-10 17:51:55 +01009460 if (ret < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009461 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009462 appctx->ctx.cli.msg = "'set ssl tls-key' received invalid base64 encoded TLS key.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009463 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009464 return 1;
9465 }
Emeric Brun9e754772019-01-10 17:51:55 +01009466
Willy Tarreau1c913e42018-08-22 05:26:57 +02009467 trash.data = ret;
Emeric Brun9e754772019-01-10 17:51:55 +01009468 if (ssl_sock_update_tlskey_ref(ref, &trash) < 0) {
9469 appctx->ctx.cli.severity = LOG_ERR;
9470 appctx->ctx.cli.msg = "'set ssl tls-key' received a key of wrong size.\n";
9471 appctx->st0 = CLI_ST_PRINT;
9472 return 1;
9473 }
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009474 appctx->ctx.cli.severity = LOG_INFO;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01009475 appctx->ctx.cli.msg = "TLS ticket key updated!\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009476 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009477 return 1;
9478
9479}
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01009480#endif
William Lallemand32af2032016-10-29 18:09:35 +02009481
Aurélien Nephtaliabbf6072018-04-18 13:26:46 +02009482static int cli_parse_set_ocspresponse(char **args, char *payload, struct appctx *appctx, void *private)
William Lallemand32af2032016-10-29 18:09:35 +02009483{
9484#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
9485 char *err = NULL;
Willy Tarreau1c913e42018-08-22 05:26:57 +02009486 int i, j, ret;
Aurélien Nephtali1e0867c2018-04-18 14:04:58 +02009487
9488 if (!payload)
9489 payload = args[3];
William Lallemand32af2032016-10-29 18:09:35 +02009490
9491 /* Expect one parameter: the new response in base64 encoding */
Aurélien Nephtali1e0867c2018-04-18 14:04:58 +02009492 if (!*payload) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009493 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009494 appctx->ctx.cli.msg = "'set ssl ocsp-response' expects response in base64 encoding.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009495 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009496 return 1;
9497 }
Aurélien Nephtali1e0867c2018-04-18 14:04:58 +02009498
9499 /* remove \r and \n from the payload */
9500 for (i = 0, j = 0; payload[i]; i++) {
9501 if (payload[i] == '\r' || payload[i] == '\n')
9502 continue;
9503 payload[j++] = payload[i];
9504 }
9505 payload[j] = 0;
William Lallemand32af2032016-10-29 18:09:35 +02009506
Willy Tarreau1c913e42018-08-22 05:26:57 +02009507 ret = base64dec(payload, j, trash.area, trash.size);
9508 if (ret < 0) {
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009509 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009510 appctx->ctx.cli.msg = "'set ssl ocsp-response' received invalid base64 encoded response.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009511 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009512 return 1;
9513 }
9514
Willy Tarreau1c913e42018-08-22 05:26:57 +02009515 trash.data = ret;
William Lallemand32af2032016-10-29 18:09:35 +02009516 if (ssl_sock_update_ocsp_response(&trash, &err)) {
9517 if (err) {
9518 memprintf(&err, "%s.\n", err);
9519 appctx->ctx.cli.err = err;
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009520 appctx->st0 = CLI_ST_PRINT_FREE;
William Lallemand32af2032016-10-29 18:09:35 +02009521 }
Aurélien Nephtali9a4da682018-04-16 19:02:42 +02009522 else {
9523 appctx->ctx.cli.severity = LOG_ERR;
9524 appctx->ctx.cli.msg = "Failed to update OCSP response.\n";
9525 appctx->st0 = CLI_ST_PRINT;
9526 }
William Lallemand32af2032016-10-29 18:09:35 +02009527 return 1;
9528 }
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009529 appctx->ctx.cli.severity = LOG_INFO;
Aurélien Nephtali6e8a41d2018-03-15 21:48:50 +01009530 appctx->ctx.cli.msg = "OCSP Response updated!\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009531 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009532 return 1;
9533#else
Andjelko Iharosc3680ec2017-07-20 16:49:14 +02009534 appctx->ctx.cli.severity = LOG_ERR;
William Lallemand32af2032016-10-29 18:09:35 +02009535 appctx->ctx.cli.msg = "HAProxy was compiled against a version of OpenSSL that doesn't support OCSP stapling.\n";
Willy Tarreau3b6e5472016-11-24 15:53:53 +01009536 appctx->st0 = CLI_ST_PRINT;
William Lallemand32af2032016-10-29 18:09:35 +02009537 return 1;
9538#endif
9539
Nenad Merdanovicc31499d2019-03-23 11:00:32 +01009540}
9541
Willy Tarreau86a394e2019-05-09 14:15:32 +02009542#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Nenad Merdanovicc31499d2019-03-23 11:00:32 +01009543static inline int sample_conv_var2smp_str(const struct arg *arg, struct sample *smp)
9544{
9545 switch (arg->type) {
9546 case ARGT_STR:
9547 smp->data.type = SMP_T_STR;
9548 smp->data.u.str = arg->data.str;
9549 return 1;
9550 case ARGT_VAR:
9551 if (!vars_get_by_desc(&arg->data.var, smp))
9552 return 0;
9553 if (!sample_casts[smp->data.type][SMP_T_STR])
9554 return 0;
9555 if (!sample_casts[smp->data.type][SMP_T_STR](smp))
9556 return 0;
9557 return 1;
9558 default:
9559 return 0;
9560 }
9561}
9562
9563static int check_aes_gcm(struct arg *args, struct sample_conv *conv,
9564 const char *file, int line, char **err)
9565{
9566 switch(args[0].data.sint) {
9567 case 128:
9568 case 192:
9569 case 256:
9570 break;
9571 default:
9572 memprintf(err, "key size must be 128, 192 or 256 (bits).");
9573 return 0;
9574 }
9575 /* Try to decode a variable. */
9576 vars_check_arg(&args[1], NULL);
9577 vars_check_arg(&args[2], NULL);
9578 vars_check_arg(&args[3], NULL);
9579 return 1;
9580}
9581
9582/* Arguements: AES size in bits, nonce, key, tag. The last three arguments are base64 encoded */
9583static int sample_conv_aes_gcm_dec(const struct arg *arg_p, struct sample *smp, void *private)
9584{
9585 struct sample nonce, key, aead_tag;
9586 struct buffer *smp_trash, *smp_trash_alloc;
9587 EVP_CIPHER_CTX *ctx;
9588 int dec_size, ret;
9589
9590 smp_set_owner(&nonce, smp->px, smp->sess, smp->strm, smp->opt);
9591 if (!sample_conv_var2smp_str(&arg_p[1], &nonce))
9592 return 0;
9593
9594 smp_set_owner(&key, smp->px, smp->sess, smp->strm, smp->opt);
9595 if (!sample_conv_var2smp_str(&arg_p[2], &key))
9596 return 0;
9597
9598 smp_set_owner(&aead_tag, smp->px, smp->sess, smp->strm, smp->opt);
9599 if (!sample_conv_var2smp_str(&arg_p[3], &aead_tag))
9600 return 0;
9601
9602 smp_trash = get_trash_chunk();
9603 smp_trash_alloc = alloc_trash_chunk();
9604 if (!smp_trash_alloc)
9605 return 0;
9606
9607 ctx = EVP_CIPHER_CTX_new();
9608
9609 if (!ctx)
9610 goto err;
9611
9612 dec_size = base64dec(nonce.data.u.str.area, nonce.data.u.str.data, smp_trash->area, smp_trash->size);
9613 if (dec_size < 0)
9614 goto err;
9615 smp_trash->data = dec_size;
9616
9617 /* Set cipher type and mode */
9618 switch(arg_p[0].data.sint) {
9619 case 128:
9620 EVP_DecryptInit_ex(ctx, EVP_aes_128_gcm(), NULL, NULL, NULL);
9621 break;
9622 case 192:
9623 EVP_DecryptInit_ex(ctx, EVP_aes_192_gcm(), NULL, NULL, NULL);
9624 break;
9625 case 256:
9626 EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL, NULL, NULL);
9627 break;
9628 }
9629
9630 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_IVLEN, smp_trash->data, NULL);
9631
9632 /* Initialise IV */
9633 if(!EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, (unsigned char *) smp_trash->area))
9634 goto err;
9635
9636 dec_size = base64dec(key.data.u.str.area, key.data.u.str.data, smp_trash->area, smp_trash->size);
9637 if (dec_size < 0)
9638 goto err;
9639 smp_trash->data = dec_size;
9640
9641 /* Initialise key */
9642 if (!EVP_DecryptInit_ex(ctx, NULL, NULL, (unsigned char *) smp_trash->area, NULL))
9643 goto err;
9644
9645 if (!EVP_DecryptUpdate(ctx, (unsigned char *) smp_trash->area, (int *) &smp_trash->data,
9646 (unsigned char *) smp->data.u.str.area, (int) smp->data.u.str.data))
9647 goto err;
9648
9649 dec_size = base64dec(aead_tag.data.u.str.area, aead_tag.data.u.str.data, smp_trash_alloc->area, smp_trash_alloc->size);
9650 if (dec_size < 0)
9651 goto err;
9652 smp_trash_alloc->data = dec_size;
9653 dec_size = smp_trash->data;
9654
9655 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, smp_trash_alloc->data, (void *) smp_trash_alloc->area);
9656 ret = EVP_DecryptFinal_ex(ctx, (unsigned char *) smp_trash->area + smp_trash->data, (int *) &smp_trash->data);
9657
9658 if (ret <= 0)
9659 goto err;
9660
9661 smp->data.u.str.data = dec_size + smp_trash->data;
9662 smp->data.u.str.area = smp_trash->area;
9663 smp->data.type = SMP_T_BIN;
9664 smp->flags &= ~SMP_F_CONST;
9665 free_trash_chunk(smp_trash_alloc);
9666 return 1;
9667
9668err:
9669 free_trash_chunk(smp_trash_alloc);
9670 return 0;
William Lallemand32af2032016-10-29 18:09:35 +02009671}
Nenad Merdanovicc31499d2019-03-23 11:00:32 +01009672# endif
William Lallemand32af2032016-10-29 18:09:35 +02009673
9674/* register cli keywords */
9675static struct cli_kw_list cli_kws = {{ },{
9676#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
9677 { { "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 +02009678 { { "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 +02009679#endif
Emmanuel Hocdetfdec7892017-01-13 17:48:18 +01009680 { { "set", "ssl", "ocsp-response", NULL }, NULL, cli_parse_set_ocspresponse, NULL },
William Lallemand32af2032016-10-29 18:09:35 +02009681 { { NULL }, NULL, NULL, NULL }
9682}};
9683
Willy Tarreau0108d902018-11-25 19:14:37 +01009684INITCALL1(STG_REGISTER, cli_register_kw, &cli_kws);
William Lallemand32af2032016-10-29 18:09:35 +02009685
Willy Tarreau7875d092012-09-10 08:20:03 +02009686/* Note: must not be declared <const> as its list will be overwritten.
9687 * Please take care of keeping this list alphabetically sorted.
9688 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02009689static struct sample_fetch_kw_list sample_fetch_keywords = {ILH, {
Emeric Brun645ae792014-04-30 14:21:06 +02009690 { "ssl_bc", smp_fetch_ssl_fc, 0, NULL, SMP_T_BOOL, SMP_USE_L5SRV },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009691 { "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 +01009692#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Jérôme Magnine064a802018-12-03 22:21:04 +01009693 { "ssl_bc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Olivier Houchard6b77f492018-11-22 18:18:29 +01009694#endif
Emeric Brun645ae792014-04-30 14:21:06 +02009695 { "ssl_bc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Olivier Houchard6b77f492018-11-22 18:18:29 +01009696#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
9697 { "ssl_bc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
9698#endif
Emeric Brun74f7ffa2018-02-19 16:14:12 +01009699 { "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 +02009700 { "ssl_bc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_STR, SMP_USE_L5SRV },
Emeric Brunb73a9b02014-04-30 18:49:19 +02009701 { "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 +02009702 { "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 +02009703#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brun645ae792014-04-30 14:21:06 +02009704 { "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 -04009705#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009706#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmer65674662019-06-04 08:13:03 -04009707 { "ssl_bc_client_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
9708 { "ssl_bc_server_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
Patrick Hemmere0275472018-04-28 19:15:51 -04009709 { "ssl_bc_session_key", smp_fetch_ssl_fc_session_key, 0, NULL, SMP_T_BIN, SMP_USE_L5SRV },
9710#endif
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009711 { "ssl_c_ca_err", smp_fetch_ssl_c_ca_err, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
9712 { "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 +01009713 { "ssl_c_der", smp_fetch_ssl_x_der, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009714 { "ssl_c_err", smp_fetch_ssl_c_err, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +02009715 { "ssl_c_i_dn", smp_fetch_ssl_x_i_dn, ARG2(0,STR,SINT), NULL, SMP_T_STR, SMP_USE_L5CLI },
9716 { "ssl_c_key_alg", smp_fetch_ssl_x_key_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9717 { "ssl_c_notafter", smp_fetch_ssl_x_notafter, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9718 { "ssl_c_notbefore", smp_fetch_ssl_x_notbefore, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9719 { "ssl_c_sig_alg", smp_fetch_ssl_x_sig_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9720 { "ssl_c_s_dn", smp_fetch_ssl_x_s_dn, ARG2(0,STR,SINT), NULL, SMP_T_STR, SMP_USE_L5CLI },
9721 { "ssl_c_serial", smp_fetch_ssl_x_serial, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
9722 { "ssl_c_sha1", smp_fetch_ssl_x_sha1, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +01009723 { "ssl_c_used", smp_fetch_ssl_c_used, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009724 { "ssl_c_verify", smp_fetch_ssl_c_verify, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
9725 { "ssl_c_version", smp_fetch_ssl_x_version, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Emeric Brun43e79582014-10-29 19:03:26 +01009726 { "ssl_f_der", smp_fetch_ssl_x_der, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Emeric Brunba841a12014-04-30 17:05:08 +02009727 { "ssl_f_i_dn", smp_fetch_ssl_x_i_dn, ARG2(0,STR,SINT), NULL, SMP_T_STR, SMP_USE_L5CLI },
9728 { "ssl_f_key_alg", smp_fetch_ssl_x_key_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9729 { "ssl_f_notafter", smp_fetch_ssl_x_notafter, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9730 { "ssl_f_notbefore", smp_fetch_ssl_x_notbefore, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9731 { "ssl_f_sig_alg", smp_fetch_ssl_x_sig_alg, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9732 { "ssl_f_s_dn", smp_fetch_ssl_x_s_dn, ARG2(0,STR,SINT), NULL, SMP_T_STR, SMP_USE_L5CLI },
9733 { "ssl_f_serial", smp_fetch_ssl_x_serial, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Emeric Brun55f4fa82014-04-30 17:11:25 +02009734 { "ssl_f_sha1", smp_fetch_ssl_x_sha1, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009735 { "ssl_f_version", smp_fetch_ssl_x_version, 0, NULL, SMP_T_SINT, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +01009736 { "ssl_fc", smp_fetch_ssl_fc, 0, NULL, SMP_T_BOOL, SMP_USE_L5CLI },
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009737 { "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 +01009738 { "ssl_fc_cipher", smp_fetch_ssl_fc_cipher, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreau80aca902013-01-07 15:42:20 +01009739 { "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 +02009740 { "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 +01009741 { "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 +02009742 { "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 +01009743#if defined(OPENSSL_NPN_NEGOTIATED) && !defined(OPENSSL_NO_NEXTPROTONEG)
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01009744 { "ssl_fc_npn", smp_fetch_ssl_fc_npn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreaua33c6542012-10-15 13:19:06 +02009745#endif
Dirkjan Bussink48f1c4e2014-02-13 12:29:42 +01009746#ifdef TLSEXT_TYPE_application_layer_protocol_negotiation
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01009747 { "ssl_fc_alpn", smp_fetch_ssl_fc_alpn, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreauab861d32013-04-02 02:30:41 +02009748#endif
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01009749 { "ssl_fc_protocol", smp_fetch_ssl_fc_protocol, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Willy Tarreau9a1ab082019-05-09 13:26:41 +02009750#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Emeric Brunb73a9b02014-04-30 18:49:19 +02009751 { "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 -04009752#endif
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02009753 { "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 +02009754#if HA_OPENSSL_VERSION_NUMBER > 0x0090800fL
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01009755 { "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 -04009756#endif
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009757#if HA_OPENSSL_VERSION_NUMBER >= 0x10100000L
Patrick Hemmer65674662019-06-04 08:13:03 -04009758 { "ssl_fc_client_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
9759 { "ssl_fc_server_random", smp_fetch_ssl_fc_random, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
Patrick Hemmere0275472018-04-28 19:15:51 -04009760 { "ssl_fc_session_key", smp_fetch_ssl_fc_session_key, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
9761#endif
Patrick Hemmer41966772018-04-28 19:15:48 -04009762#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
Thierry FOURNIER7654c9f2013-12-17 00:20:33 +01009763 { "ssl_fc_sni", smp_fetch_ssl_fc_sni, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
Patrick Hemmer41966772018-04-28 19:15:48 -04009764#endif
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009765 { "ssl_fc_cipherlist_bin", smp_fetch_ssl_fc_cl_bin, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9766 { "ssl_fc_cipherlist_hex", smp_fetch_ssl_fc_cl_hex, 0, NULL, SMP_T_BIN, SMP_USE_L5CLI },
9767 { "ssl_fc_cipherlist_str", smp_fetch_ssl_fc_cl_str, 0, NULL, SMP_T_STR, SMP_USE_L5CLI },
9768 { "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 +02009769 { NULL, NULL, 0, 0, 0 },
9770}};
9771
Willy Tarreau0108d902018-11-25 19:14:37 +01009772INITCALL1(STG_REGISTER, sample_register_fetches, &sample_fetch_keywords);
9773
Willy Tarreau7875d092012-09-10 08:20:03 +02009774/* Note: must not be declared <const> as its list will be overwritten.
9775 * Please take care of keeping this list alphabetically sorted.
9776 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02009777static struct acl_kw_list acl_kws = {ILH, {
Thierry FOURNIERc5a4e982014-03-05 16:07:08 +01009778 { "ssl_fc_sni_end", "ssl_fc_sni", PAT_MATCH_END },
9779 { "ssl_fc_sni_reg", "ssl_fc_sni", PAT_MATCH_REG },
Willy Tarreau8ed669b2013-01-11 15:49:37 +01009780 { /* END */ },
Willy Tarreau7875d092012-09-10 08:20:03 +02009781}};
9782
Willy Tarreau0108d902018-11-25 19:14:37 +01009783INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
9784
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009785/* Note: must not be declared <const> as its list will be overwritten.
9786 * Please take care of keeping this list alphabetically sorted, doing so helps
9787 * all code contributors.
9788 * Optional keywords are also declared with a NULL ->parse() function so that
9789 * the config parser can report an appropriate error when a known keyword was
9790 * not enabled.
9791 */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009792static struct ssl_bind_kw ssl_bind_kws[] = {
Olivier Houchardc2aae742017-09-22 18:26:28 +02009793 { "allow-0rtt", ssl_bind_parse_allow_0rtt, 0 }, /* allow 0-RTT */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009794 { "alpn", ssl_bind_parse_alpn, 1 }, /* set ALPN supported protocols */
9795 { "ca-file", ssl_bind_parse_ca_file, 1 }, /* set CAfile to process verify on client cert */
9796 { "ciphers", ssl_bind_parse_ciphers, 1 }, /* set SSL cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009797#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009798 { "ciphersuites", ssl_bind_parse_ciphersuites, 1 }, /* set TLS 1.3 cipher suite */
9799#endif
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009800 { "crl-file", ssl_bind_parse_crl_file, 1 }, /* set certificat revocation list file use on client cert verify */
Emmanuel Hocdete7f2b732017-01-09 16:15:54 +01009801 { "curves", ssl_bind_parse_curves, 1 }, /* set SSL curve suite */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009802 { "ecdhe", ssl_bind_parse_ecdhe, 1 }, /* defines named curve for elliptic curve Diffie-Hellman */
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02009803 { "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 +01009804 { "npn", ssl_bind_parse_npn, 1 }, /* set NPN supported protocols */
Emmanuel Hocdetdf701a22017-05-18 12:46:50 +02009805 { "ssl-min-ver", ssl_bind_parse_tls_method_minmax,1 }, /* minimum version */
9806 { "ssl-max-ver", ssl_bind_parse_tls_method_minmax,1 }, /* maximum version */
Emmanuel Hocdet98263292016-12-29 18:26:15 +01009807 { "verify", ssl_bind_parse_verify, 1 }, /* set SSL verify method */
9808 { NULL, NULL, 0 },
9809};
9810
Willy Tarreau0108d902018-11-25 19:14:37 +01009811/* no initcall for ssl_bind_kws, these ones are parsed in the parser loop */
9812
Willy Tarreau51fb7652012-09-18 18:24:39 +02009813static struct bind_kw_list bind_kws = { "SSL", { }, {
Olivier Houchardc2aae742017-09-22 18:26:28 +02009814 { "allow-0rtt", bind_parse_allow_0rtt, 0 }, /* Allow 0RTT */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009815 { "alpn", bind_parse_alpn, 1 }, /* set ALPN supported protocols */
9816 { "ca-file", bind_parse_ca_file, 1 }, /* set CAfile to process verify on client cert */
9817 { "ca-ignore-err", bind_parse_ignore_err, 1 }, /* set error IDs to ignore on verify depth > 0 */
9818 { "ca-sign-file", bind_parse_ca_sign_file, 1 }, /* set CAFile used to generate and sign server certs */
9819 { "ca-sign-pass", bind_parse_ca_sign_pass, 1 }, /* set CAKey passphrase */
9820 { "ciphers", bind_parse_ciphers, 1 }, /* set SSL cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009821#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009822 { "ciphersuites", bind_parse_ciphersuites, 1 }, /* set TLS 1.3 cipher suite */
9823#endif
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009824 { "crl-file", bind_parse_crl_file, 1 }, /* set certificat revocation list file use on client cert verify */
9825 { "crt", bind_parse_crt, 1 }, /* load SSL certificates from this location */
9826 { "crt-ignore-err", bind_parse_ignore_err, 1 }, /* set error IDs to ingore on verify depth == 0 */
9827 { "crt-list", bind_parse_crt_list, 1 }, /* load a list of crt from this location */
9828 { "curves", bind_parse_curves, 1 }, /* set SSL curve suite */
9829 { "ecdhe", bind_parse_ecdhe, 1 }, /* defines named curve for elliptic curve Diffie-Hellman */
9830 { "force-sslv3", bind_parse_tls_method_options, 0 }, /* force SSLv3 */
9831 { "force-tlsv10", bind_parse_tls_method_options, 0 }, /* force TLSv10 */
9832 { "force-tlsv11", bind_parse_tls_method_options, 0 }, /* force TLSv11 */
9833 { "force-tlsv12", bind_parse_tls_method_options, 0 }, /* force TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +02009834 { "force-tlsv13", bind_parse_tls_method_options, 0 }, /* force TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009835 { "generate-certificates", bind_parse_generate_certs, 0 }, /* enable the server certificates generation */
Emmanuel Hocdet174dfe52017-07-28 15:01:05 +02009836 { "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 +02009837 { "no-sslv3", bind_parse_tls_method_options, 0 }, /* disable SSLv3 */
9838 { "no-tlsv10", bind_parse_tls_method_options, 0 }, /* disable TLSv10 */
9839 { "no-tlsv11", bind_parse_tls_method_options, 0 }, /* disable TLSv11 */
9840 { "no-tlsv12", bind_parse_tls_method_options, 0 }, /* disable TLSv12 */
Emmanuel Hocdet42fb9802017-03-30 19:29:39 +02009841 { "no-tlsv13", bind_parse_tls_method_options, 0 }, /* disable TLSv13 */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009842 { "no-tls-tickets", bind_parse_no_tls_tickets, 0 }, /* disable session resumption tickets */
9843 { "ssl", bind_parse_ssl, 0 }, /* enable SSL processing */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009844 { "ssl-min-ver", bind_parse_tls_method_minmax, 1 }, /* minimum version */
9845 { "ssl-max-ver", bind_parse_tls_method_minmax, 1 }, /* maximum version */
Emmanuel Hocdet5db33cb2017-03-30 19:19:37 +02009846 { "strict-sni", bind_parse_strict_sni, 0 }, /* refuse negotiation if sni doesn't match a certificate */
9847 { "tls-ticket-keys", bind_parse_tls_ticket_keys, 1 }, /* set file to load TLS ticket keys from */
9848 { "verify", bind_parse_verify, 1 }, /* set SSL verify method */
9849 { "npn", bind_parse_npn, 1 }, /* set NPN supported protocols */
9850 { "prefer-client-ciphers", bind_parse_pcc, 0 }, /* prefer client ciphers */
Willy Tarreau79eeafa2012-09-14 07:53:05 +02009851 { NULL, NULL, 0 },
9852}};
Emeric Brun46591952012-05-18 15:47:34 +02009853
Willy Tarreau0108d902018-11-25 19:14:37 +01009854INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
9855
Willy Tarreau92faadf2012-10-10 23:04:25 +02009856/* Note: must not be declared <const> as its list will be overwritten.
9857 * Please take care of keeping this list alphabetically sorted, doing so helps
9858 * all code contributors.
9859 * Optional keywords are also declared with a NULL ->parse() function so that
9860 * the config parser can report an appropriate error when a known keyword was
9861 * not enabled.
9862 */
9863static struct srv_kw_list srv_kws = { "SSL", { }, {
Olivier Houchard522eea72017-11-03 16:27:47 +01009864 { "allow-0rtt", srv_parse_allow_0rtt, 0, 1 }, /* Allow using early data on this server */
Olivier Houchardc7566002018-11-20 23:33:50 +01009865 { "alpn", srv_parse_alpn, 1, 1 }, /* Set ALPN supported protocols */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009866 { "ca-file", srv_parse_ca_file, 1, 1 }, /* set CAfile to process verify server cert */
Olivier Houchard92150142018-12-21 19:47:01 +01009867 { "check-alpn", srv_parse_alpn, 1, 1 }, /* Set ALPN used for checks */
Olivier Houchard9130a962017-10-17 17:33:43 +02009868 { "check-sni", srv_parse_check_sni, 1, 1 }, /* set SNI */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009869 { "check-ssl", srv_parse_check_ssl, 0, 1 }, /* enable SSL for health checks */
9870 { "ciphers", srv_parse_ciphers, 1, 1 }, /* select the cipher suite */
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009871#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009872 { "ciphersuites", srv_parse_ciphersuites, 1, 1 }, /* select the cipher suite */
9873#endif
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009874 { "crl-file", srv_parse_crl_file, 1, 1 }, /* set certificate revocation list file use on server cert verify */
9875 { "crt", srv_parse_crt, 1, 1 }, /* set client certificate */
9876 { "force-sslv3", srv_parse_tls_method_options, 0, 1 }, /* force SSLv3 */
9877 { "force-tlsv10", srv_parse_tls_method_options, 0, 1 }, /* force TLSv10 */
9878 { "force-tlsv11", srv_parse_tls_method_options, 0, 1 }, /* force TLSv11 */
9879 { "force-tlsv12", srv_parse_tls_method_options, 0, 1 }, /* force TLSv12 */
9880 { "force-tlsv13", srv_parse_tls_method_options, 0, 1 }, /* force TLSv13 */
9881 { "no-check-ssl", srv_parse_no_check_ssl, 0, 1 }, /* disable SSL for health checks */
9882 { "no-send-proxy-v2-ssl", srv_parse_no_send_proxy_ssl, 0, 1 }, /* do not send PROXY protocol header v2 with SSL info */
9883 { "no-send-proxy-v2-ssl-cn", srv_parse_no_send_proxy_cn, 0, 1 }, /* do not send PROXY protocol header v2 with CN */
9884 { "no-ssl", srv_parse_no_ssl, 0, 1 }, /* disable SSL processing */
9885 { "no-ssl-reuse", srv_parse_no_ssl_reuse, 0, 1 }, /* disable session reuse */
9886 { "no-sslv3", srv_parse_tls_method_options, 0, 0 }, /* disable SSLv3 */
9887 { "no-tlsv10", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv10 */
9888 { "no-tlsv11", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv11 */
9889 { "no-tlsv12", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv12 */
9890 { "no-tlsv13", srv_parse_tls_method_options, 0, 0 }, /* disable TLSv13 */
9891 { "no-tls-tickets", srv_parse_no_tls_tickets, 0, 1 }, /* disable session resumption tickets */
Olivier Houchardc7566002018-11-20 23:33:50 +01009892 { "npn", srv_parse_npn, 1, 1 }, /* Set NPN supported protocols */
Emmanuel Hocdete1c722b2017-03-31 15:02:54 +02009893 { "send-proxy-v2-ssl", srv_parse_send_proxy_ssl, 0, 1 }, /* send PROXY protocol header v2 with SSL info */
9894 { "send-proxy-v2-ssl-cn", srv_parse_send_proxy_cn, 0, 1 }, /* send PROXY protocol header v2 with CN */
9895 { "sni", srv_parse_sni, 1, 1 }, /* send SNI extension */
9896 { "ssl", srv_parse_ssl, 0, 1 }, /* enable SSL processing */
9897 { "ssl-min-ver", srv_parse_tls_method_minmax, 1, 1 }, /* minimum version */
9898 { "ssl-max-ver", srv_parse_tls_method_minmax, 1, 1 }, /* maximum version */
9899 { "ssl-reuse", srv_parse_ssl_reuse, 0, 1 }, /* enable session reuse */
9900 { "tls-tickets", srv_parse_tls_tickets, 0, 1 }, /* enable session resumption tickets */
9901 { "verify", srv_parse_verify, 1, 1 }, /* set SSL verify method */
9902 { "verifyhost", srv_parse_verifyhost, 1, 1 }, /* require that SSL cert verifies for hostname */
Willy Tarreau92faadf2012-10-10 23:04:25 +02009903 { NULL, NULL, 0, 0 },
9904}};
9905
Willy Tarreau0108d902018-11-25 19:14:37 +01009906INITCALL1(STG_REGISTER, srv_register_keywords, &srv_kws);
9907
Emeric Brun2c86cbf2014-10-30 15:56:50 +01009908static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau8c3b0fd2016-12-21 22:44:46 +01009909 { CFG_GLOBAL, "ca-base", ssl_parse_global_ca_crt_base },
9910 { CFG_GLOBAL, "crt-base", ssl_parse_global_ca_crt_base },
Willy Tarreau0bea58d2016-12-21 23:17:25 +01009911 { CFG_GLOBAL, "maxsslconn", ssl_parse_global_int },
Emeric Brun2c86cbf2014-10-30 15:56:50 +01009912 { CFG_GLOBAL, "ssl-default-bind-options", ssl_parse_default_bind_options },
9913 { CFG_GLOBAL, "ssl-default-server-options", ssl_parse_default_server_options },
Willy Tarreau14e36a12016-12-21 23:28:13 +01009914#ifndef OPENSSL_NO_DH
9915 { CFG_GLOBAL, "ssl-dh-param-file", ssl_parse_global_dh_param_file },
9916#endif
Grant Zhangfa6c7ee2017-01-14 01:42:15 +00009917 { CFG_GLOBAL, "ssl-mode-async", ssl_parse_global_ssl_async },
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +02009918#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +00009919 { CFG_GLOBAL, "ssl-engine", ssl_parse_global_ssl_engine },
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +02009920#endif
Willy Tarreau9ceda382016-12-21 23:13:03 +01009921 { CFG_GLOBAL, "tune.ssl.cachesize", ssl_parse_global_int },
9922#ifndef OPENSSL_NO_DH
9923 { CFG_GLOBAL, "tune.ssl.default-dh-param", ssl_parse_global_default_dh },
9924#endif
9925 { CFG_GLOBAL, "tune.ssl.force-private-cache", ssl_parse_global_private_cache },
9926 { CFG_GLOBAL, "tune.ssl.lifetime", ssl_parse_global_lifetime },
9927 { CFG_GLOBAL, "tune.ssl.maxrecord", ssl_parse_global_int },
9928 { CFG_GLOBAL, "tune.ssl.ssl-ctx-cache-size", ssl_parse_global_int },
Thierry FOURNIER5bf77322017-02-25 12:45:22 +01009929 { CFG_GLOBAL, "tune.ssl.capture-cipherlist-size", ssl_parse_global_capture_cipherlist },
Willy Tarreauf22e9682016-12-21 23:23:19 +01009930 { CFG_GLOBAL, "ssl-default-bind-ciphers", ssl_parse_global_ciphers },
9931 { CFG_GLOBAL, "ssl-default-server-ciphers", ssl_parse_global_ciphers },
Emmanuel Hocdet839af572019-05-14 16:27:35 +02009932#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +02009933 { CFG_GLOBAL, "ssl-default-bind-ciphersuites", ssl_parse_global_ciphersuites },
9934 { CFG_GLOBAL, "ssl-default-server-ciphersuites", ssl_parse_global_ciphersuites },
9935#endif
Emeric Brun2c86cbf2014-10-30 15:56:50 +01009936 { 0, NULL, NULL },
9937}};
9938
Willy Tarreau0108d902018-11-25 19:14:37 +01009939INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
9940
Nenad Merdanovicc31499d2019-03-23 11:00:32 +01009941/* Note: must not be declared <const> as its list will be overwritten */
9942static struct sample_conv_kw_list conv_kws = {ILH, {
Willy Tarreau86a394e2019-05-09 14:15:32 +02009943#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000100fL)
Nenad Merdanovicc31499d2019-03-23 11:00:32 +01009944 { "aes_gcm_dec", sample_conv_aes_gcm_dec, ARG4(4,SINT,STR,STR,STR), check_aes_gcm, SMP_T_BIN, SMP_T_BIN },
9945#endif
9946 { NULL, NULL, 0, 0, 0 },
9947}};
9948
9949INITCALL1(STG_REGISTER, sample_register_convs, &conv_kws);
9950
Willy Tarreauf7bc57c2012-10-03 00:19:48 +02009951/* transport-layer operations for SSL sockets */
Willy Tarreaud9f5cca2016-12-22 21:08:52 +01009952static struct xprt_ops ssl_sock = {
Emeric Brun46591952012-05-18 15:47:34 +02009953 .snd_buf = ssl_sock_from_buf,
9954 .rcv_buf = ssl_sock_to_buf,
Olivier Houcharddf357842019-03-21 16:30:07 +01009955 .subscribe = ssl_subscribe,
9956 .unsubscribe = ssl_unsubscribe,
Olivier Houchard5149b592019-05-23 17:47:36 +02009957 .remove_xprt = ssl_remove_xprt,
Olivier Houchard2e055482019-05-27 19:50:12 +02009958 .add_xprt = ssl_add_xprt,
Emeric Brun46591952012-05-18 15:47:34 +02009959 .rcv_pipe = NULL,
9960 .snd_pipe = NULL,
9961 .shutr = NULL,
9962 .shutw = ssl_sock_shutw,
9963 .close = ssl_sock_close,
9964 .init = ssl_sock_init,
Willy Tarreau55d37912016-12-21 23:38:39 +01009965 .prepare_bind_conf = ssl_sock_prepare_bind_conf,
Willy Tarreau795cdab2016-12-22 17:30:54 +01009966 .destroy_bind_conf = ssl_sock_destroy_bind_conf,
Willy Tarreau17d45382016-12-22 21:16:08 +01009967 .prepare_srv = ssl_sock_prepare_srv_ctx,
9968 .destroy_srv = ssl_sock_free_srv_ctx,
Willy Tarreau8743f7e2016-12-04 18:44:29 +01009969 .get_alpn = ssl_sock_get_alpn,
Willy Tarreau8e0bb0a2016-11-24 16:58:12 +01009970 .name = "SSL",
Emeric Brun46591952012-05-18 15:47:34 +02009971};
9972
Olivier Houchardccaa7de2017-10-02 11:51:03 +02009973enum act_return ssl_action_wait_for_hs(struct act_rule *rule, struct proxy *px,
9974 struct session *sess, struct stream *s, int flags)
9975{
9976 struct connection *conn;
Olivier Houchard6fa63d92017-11-27 18:41:32 +01009977 struct conn_stream *cs;
Olivier Houchardccaa7de2017-10-02 11:51:03 +02009978
9979 conn = objt_conn(sess->origin);
Olivier Houchard6fa63d92017-11-27 18:41:32 +01009980 cs = objt_cs(s->si[0].end);
Olivier Houchardccaa7de2017-10-02 11:51:03 +02009981
Olivier Houchard6fa63d92017-11-27 18:41:32 +01009982 if (conn && cs) {
Olivier Houchardccaa7de2017-10-02 11:51:03 +02009983 if (conn->flags & (CO_FL_EARLY_SSL_HS | CO_FL_SSL_WAIT_HS)) {
Olivier Houchard6fa63d92017-11-27 18:41:32 +01009984 cs->flags |= CS_FL_WAIT_FOR_HS;
Olivier Houchardccaa7de2017-10-02 11:51:03 +02009985 s->req.flags |= CF_READ_NULL;
9986 return ACT_RET_YIELD;
9987 }
9988 }
9989 return (ACT_RET_CONT);
9990}
9991
9992static enum act_parse_ret ssl_parse_wait_for_hs(const char **args, int *orig_arg, struct proxy *px, struct act_rule *rule, char **err)
9993{
9994 rule->action_ptr = ssl_action_wait_for_hs;
9995
9996 return ACT_RET_PRS_OK;
9997}
9998
9999static struct action_kw_list http_req_actions = {ILH, {
10000 { "wait-for-handshake", ssl_parse_wait_for_hs },
10001 { /* END */ }
10002}};
10003
Willy Tarreau0108d902018-11-25 19:14:37 +010010004INITCALL1(STG_REGISTER, http_req_keywords_register, &http_req_actions);
10005
Willy Tarreau5db847a2019-05-09 14:13:35 +020010006#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010010007
10008static void ssl_sock_sctl_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
10009{
10010 if (ptr) {
10011 chunk_destroy(ptr);
10012 free(ptr);
10013 }
10014}
10015
10016#endif
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +010010017static void ssl_sock_capture_free_func(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx, long argl, void *argp)
10018{
Willy Tarreaubafbe012017-11-24 17:34:44 +010010019 pool_free(pool_head_ssl_capture, ptr);
Emmanuel Hocdetaaee7502017-03-07 18:34:58 +010010020}
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010010021
Emeric Brun46591952012-05-18 15:47:34 +020010022__attribute__((constructor))
Willy Tarreau92faadf2012-10-10 23:04:25 +020010023static void __ssl_sock_init(void)
10024{
Ilya Shipitsin0590f442019-05-25 19:30:50 +050010025#if (!defined(OPENSSL_NO_COMP) && !defined(SSL_OP_NO_COMPRESSION))
Emeric Brun46591952012-05-18 15:47:34 +020010026 STACK_OF(SSL_COMP)* cm;
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050010027 int n;
Ilya Shipitsin0590f442019-05-25 19:30:50 +050010028#endif
Emeric Brun46591952012-05-18 15:47:34 +020010029
Willy Tarreauef934602016-12-22 23:12:01 +010010030 if (global_ssl.listen_default_ciphers)
10031 global_ssl.listen_default_ciphers = strdup(global_ssl.listen_default_ciphers);
10032 if (global_ssl.connect_default_ciphers)
10033 global_ssl.connect_default_ciphers = strdup(global_ssl.connect_default_ciphers);
Emmanuel Hocdet839af572019-05-14 16:27:35 +020010034#if (HA_OPENSSL_VERSION_NUMBER >= 0x10101000L)
Dirkjan Bussink415150f2018-09-14 11:14:21 +020010035 if (global_ssl.listen_default_ciphersuites)
10036 global_ssl.listen_default_ciphersuites = strdup(global_ssl.listen_default_ciphersuites);
10037 if (global_ssl.connect_default_ciphersuites)
10038 global_ssl.connect_default_ciphersuites = strdup(global_ssl.connect_default_ciphersuites);
10039#endif
Willy Tarreau610f04b2014-02-13 11:36:41 +010010040
Willy Tarreau13e14102016-12-22 20:25:26 +010010041 xprt_register(XPRT_SSL, &ssl_sock);
Willy Tarreau9a1ab082019-05-09 13:26:41 +020010042#if HA_OPENSSL_VERSION_NUMBER < 0x10100000L
Emeric Brun46591952012-05-18 15:47:34 +020010043 SSL_library_init();
Rosen Penev68185952018-12-14 08:47:02 -080010044#endif
Ilya Shipitsin0590f442019-05-25 19:30:50 +050010045#if (!defined(OPENSSL_NO_COMP) && !defined(SSL_OP_NO_COMPRESSION))
Emeric Brun46591952012-05-18 15:47:34 +020010046 cm = SSL_COMP_get_compression_methods();
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050010047 n = sk_SSL_COMP_num(cm);
10048 while (n--) {
10049 (void) sk_SSL_COMP_pop(cm);
10050 }
Ilya Shipitsin0590f442019-05-25 19:30:50 +050010051#endif
Ilya Shipitsine242f3d2019-05-25 03:38:14 +050010052
Willy Tarreau5db847a2019-05-09 14:13:35 +020010053#if defined(USE_THREAD) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Emeric Brun821bb9b2017-06-15 16:37:39 +020010054 ssl_locking_init();
10055#endif
Willy Tarreau5db847a2019-05-09 14:13:35 +020010056#if (HA_OPENSSL_VERSION_NUMBER >= 0x1000200fL && !defined OPENSSL_NO_TLSEXT && !defined OPENSSL_IS_BORINGSSL)
Janusz Dziemidowicz2c701b52015-03-07 23:03:59 +010010057 sctl_ex_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, ssl_sock_sctl_free_func);
10058#endif
Thierry FOURNIER28962c92018-06-17 21:37:05 +020010059 ssl_app_data_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, NULL);
Thierry FOURNIER16ff0502018-06-17 21:33:01 +020010060 ssl_capture_ptr_index = SSL_get_ex_new_index(0, NULL, NULL, NULL, ssl_sock_capture_free_func);
Emmanuel Hocdet96b78342017-10-31 15:46:07 +010010061 ssl_pkey_info_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010062#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +000010063 ENGINE_load_builtin_engines();
Grant Zhangfa6c7ee2017-01-14 01:42:15 +000010064 hap_register_post_check(ssl_check_async_engine_count);
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010065#endif
Willy Tarreaud1c57502016-12-22 22:46:15 +010010066#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
10067 hap_register_post_check(tlskeys_finalize_config);
10068#endif
Willy Tarreau80713382018-11-26 10:19:54 +010010069
10070 global.ssl_session_max_cost = SSL_SESSION_MAX_COST;
10071 global.ssl_handshake_max_cost = SSL_HANDSHAKE_MAX_COST;
10072
10073#ifndef OPENSSL_NO_DH
10074 ssl_dh_ptr_index = SSL_CTX_get_ex_new_index(0, NULL, NULL, NULL, NULL);
10075 hap_register_post_deinit(ssl_free_dh);
10076#endif
10077#ifndef OPENSSL_NO_ENGINE
10078 hap_register_post_deinit(ssl_free_engines);
10079#endif
10080 /* Load SSL string for the verbose & debug mode. */
10081 ERR_load_SSL_strings();
Olivier Houcharda8955d52019-04-07 22:00:38 +020010082 ha_meth = BIO_meth_new(0x666, "ha methods");
10083 BIO_meth_set_write(ha_meth, ha_ssl_write);
10084 BIO_meth_set_read(ha_meth, ha_ssl_read);
10085 BIO_meth_set_ctrl(ha_meth, ha_ssl_ctrl);
10086 BIO_meth_set_create(ha_meth, ha_ssl_new);
10087 BIO_meth_set_destroy(ha_meth, ha_ssl_free);
10088 BIO_meth_set_puts(ha_meth, ha_ssl_puts);
10089 BIO_meth_set_gets(ha_meth, ha_ssl_gets);
Willy Tarreau80713382018-11-26 10:19:54 +010010090}
Willy Tarreaud92aa5c2015-01-15 21:34:39 +010010091
Willy Tarreau80713382018-11-26 10:19:54 +010010092/* Compute and register the version string */
10093static void ssl_register_build_options()
10094{
10095 char *ptr = NULL;
10096 int i;
10097
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010098 memprintf(&ptr, "Built with OpenSSL version : "
10099#ifdef OPENSSL_IS_BORINGSSL
Emmanuel Hocdet50e25e12017-03-24 15:20:03 +010010100 "BoringSSL");
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010101#else /* OPENSSL_IS_BORINGSSL */
10102 OPENSSL_VERSION_TEXT
10103 "\nRunning on OpenSSL version : %s%s",
Rosen Penev68185952018-12-14 08:47:02 -080010104 OpenSSL_version(OPENSSL_VERSION),
Willy Tarreau1d158ab2019-05-09 13:41:45 +020010105 ((OPENSSL_VERSION_NUMBER ^ OpenSSL_version_num()) >> 8) ? " (VERSIONS DIFFER!)" : "");
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010106#endif
10107 memprintf(&ptr, "%s\nOpenSSL library supports TLS extensions : "
Willy Tarreau9a1ab082019-05-09 13:26:41 +020010108#if HA_OPENSSL_VERSION_NUMBER < 0x00907000L
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010109 "no (library version too old)"
10110#elif defined(OPENSSL_NO_TLSEXT)
10111 "no (disabled via OPENSSL_NO_TLSEXT)"
10112#else
10113 "yes"
10114#endif
10115 "", ptr);
10116
10117 memprintf(&ptr, "%s\nOpenSSL library supports SNI : "
10118#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
10119 "yes"
10120#else
10121#ifdef OPENSSL_NO_TLSEXT
10122 "no (because of OPENSSL_NO_TLSEXT)"
10123#else
10124 "no (version might be too old, 0.9.8f min needed)"
10125#endif
10126#endif
10127 "", ptr);
10128
Emmanuel Hocdetf80bc242017-07-12 14:25:38 +020010129 memprintf(&ptr, "%s\nOpenSSL library supports :", ptr);
10130 for (i = CONF_TLSV_MIN; i <= CONF_TLSV_MAX; i++)
10131 if (methodVersions[i].option)
10132 memprintf(&ptr, "%s %s", ptr, methodVersions[i].name);
Emmanuel Hocdet50e25e12017-03-24 15:20:03 +010010133
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010134 hap_register_build_opts(ptr, 1);
Willy Tarreau80713382018-11-26 10:19:54 +010010135}
Willy Tarreauc2c0b612016-12-21 19:23:20 +010010136
Willy Tarreau80713382018-11-26 10:19:54 +010010137INITCALL0(STG_REGISTER, ssl_register_build_options);
Remi Gacogne4f902b82015-05-28 16:23:00 +020010138
Emeric Brun46591952012-05-18 15:47:34 +020010139
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010140#ifndef OPENSSL_NO_ENGINE
Grant Zhang872f9c22017-01-21 01:10:18 +000010141void ssl_free_engines(void) {
10142 struct ssl_engine_list *wl, *wlb;
10143 /* free up engine list */
10144 list_for_each_entry_safe(wl, wlb, &openssl_engines, list) {
10145 ENGINE_finish(wl->e);
10146 ENGINE_free(wl->e);
10147 LIST_DEL(&wl->list);
10148 free(wl);
10149 }
10150}
Emmanuel Hocdet9ac143b2017-05-29 14:36:20 +020010151#endif
Christopher Faulet31af49d2015-06-09 17:29:50 +020010152
Remi Gacogned3a23c32015-05-28 16:39:47 +020010153#ifndef OPENSSL_NO_DH
Grant Zhang872f9c22017-01-21 01:10:18 +000010154void ssl_free_dh(void) {
10155 if (local_dh_1024) {
10156 DH_free(local_dh_1024);
10157 local_dh_1024 = NULL;
10158 }
10159 if (local_dh_2048) {
10160 DH_free(local_dh_2048);
10161 local_dh_2048 = NULL;
10162 }
10163 if (local_dh_4096) {
10164 DH_free(local_dh_4096);
10165 local_dh_4096 = NULL;
10166 }
Remi Gacogne47783ef2015-05-29 15:53:22 +020010167 if (global_dh) {
10168 DH_free(global_dh);
10169 global_dh = NULL;
10170 }
Grant Zhang872f9c22017-01-21 01:10:18 +000010171}
10172#endif
10173
10174__attribute__((destructor))
10175static void __ssl_sock_deinit(void)
10176{
10177#if (defined SSL_CTRL_SET_TLSEXT_HOSTNAME && !defined SSL_NO_GENERATE_CERTIFICATES)
Emeric Brun821bb9b2017-06-15 16:37:39 +020010178 if (ssl_ctx_lru_tree) {
10179 lru64_destroy(ssl_ctx_lru_tree);
Christopher Faulet2a944ee2017-11-07 10:42:54 +010010180 HA_RWLOCK_DESTROY(&ssl_ctx_lru_rwlock);
Emeric Brun821bb9b2017-06-15 16:37:39 +020010181 }
Remi Gacogned3a23c32015-05-28 16:39:47 +020010182#endif
10183
Willy Tarreau5db847a2019-05-09 14:13:35 +020010184#if (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Remi Gacogned3a23c32015-05-28 16:39:47 +020010185 ERR_remove_state(0);
10186 ERR_free_strings();
10187
10188 EVP_cleanup();
Rosen Penev68185952018-12-14 08:47:02 -080010189#endif
Remi Gacogned3a23c32015-05-28 16:39:47 +020010190
Willy Tarreau5db847a2019-05-09 14:13:35 +020010191#if (HA_OPENSSL_VERSION_NUMBER >= 0x00907000L) && (HA_OPENSSL_VERSION_NUMBER < 0x10100000L)
Remi Gacogned3a23c32015-05-28 16:39:47 +020010192 CRYPTO_cleanup_all_ex_data();
10193#endif
Olivier Houcharda8955d52019-04-07 22:00:38 +020010194 BIO_meth_free(ha_meth);
Remi Gacogned3a23c32015-05-28 16:39:47 +020010195}
10196
10197
Emeric Brun46591952012-05-18 15:47:34 +020010198/*
10199 * Local variables:
10200 * c-indent-level: 8
10201 * c-basic-offset: 8
10202 * End:
10203 */