libcurl: update to 8.8.0

1 files changed, 607 insertions, 300 deletions

diff --git a/libs/libcurl/src/vtls/openssl.c b/libs/libcurl/src/vtls/openssl.c
index b22ec269ac..f53cb69471 100644
--- a/libs/libcurl/src/vtls/openssl.c
+++ b/libs/libcurl/src/vtls/openssl.c
@@ -82,6 +82,17 @@
 #include <openssl/tls1.h>

 #include <openssl/evp.h>

 

+#ifdef USE_ECH

+# ifndef OPENSSL_IS_BORINGSSL

+#  include <openssl/ech.h>

+# endif

+# include "curl_base64.h"

+# define ECH_ENABLED(__data__) \

+    (__data__->set.tls_ech && \

+     !(__data__->set.tls_ech & CURLECH_DISABLE)\

+    )

+#endif /* USE_ECH */

+

 #if (OPENSSL_VERSION_NUMBER >= 0x0090808fL) && !defined(OPENSSL_NO_OCSP)

 #include <openssl/ocsp.h>

 #endif

@@ -193,12 +204,10 @@
  * Whether SSL_CTX_set_keylog_callback is available.

  * OpenSSL: supported since 1.1.1 https://github.com/openssl/openssl/pull/2287

  * BoringSSL: supported since d28f59c27bac (committed 2015-11-19)

- * LibreSSL: supported since 3.5.0 (released 2022-02-24)

+ * LibreSSL: not supported. 3.5.0+ has a stub function that does nothing.

  */

 #if (OPENSSL_VERSION_NUMBER >= 0x10101000L && \

      !defined(LIBRESSL_VERSION_NUMBER)) || \

-    (defined(LIBRESSL_VERSION_NUMBER) && \

-     LIBRESSL_VERSION_NUMBER >= 0x3050000fL) || \

     defined(OPENSSL_IS_BORINGSSL)

 #define HAVE_KEYLOG_CALLBACK

 #endif

@@ -298,20 +307,6 @@ typedef unsigned long sslerr_t;
 #define USE_PRE_1_1_API (OPENSSL_VERSION_NUMBER < 0x10100000L)

 #endif /* !LIBRESSL_VERSION_NUMBER */

 

-struct ossl_ssl_backend_data {

-  /* these ones requires specific SSL-types */

-  SSL_CTX* ctx;

-  SSL*     handle;

-  X509*    server_cert;

-  BIO_METHOD *bio_method;

-  CURLcode io_result;       /* result of last BIO cfilter operation */

-#ifndef HAVE_KEYLOG_CALLBACK

-  /* Set to true once a valid keylog entry has been created to avoid dupes. */

-  bool     keylog_done;

-#endif

-  bool x509_store_setup;            /* x509 store has been set up */

-};

-

 #if defined(HAVE_SSL_X509_STORE_SHARE)

 struct multi_ssl_backend_data {

   char *CAfile;         /* CAfile path used to generate X509 store */

@@ -726,8 +721,7 @@ static int ossl_bio_cf_out_write(BIO *bio, const char *buf, int blen)
 {

   struct Curl_cfilter *cf = BIO_get_data(bio);

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

   struct Curl_easy *data = CF_DATA_CURRENT(cf);

   ssize_t nwritten;

   CURLcode result = CURLE_SEND_ERROR;

@@ -737,7 +731,7 @@ static int ossl_bio_cf_out_write(BIO *bio, const char *buf, int blen)
   CURL_TRC_CF(data, cf, "ossl_bio_cf_out_write(len=%d) -> %d, err=%d",

               blen, (int)nwritten, result);

   BIO_clear_retry_flags(bio);

-  backend->io_result = result;

+  octx->io_result = result;

   if(nwritten < 0) {

     if(CURLE_AGAIN == result)

       BIO_set_retry_write(bio);

@@ -749,8 +743,7 @@ static int ossl_bio_cf_in_read(BIO *bio, char *buf, int blen)
 {

   struct Curl_cfilter *cf = BIO_get_data(bio);

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

   struct Curl_easy *data = CF_DATA_CURRENT(cf);

   ssize_t nread;

   CURLcode result = CURLE_RECV_ERROR;

@@ -764,7 +757,7 @@ static int ossl_bio_cf_in_read(BIO *bio, char *buf, int blen)
   CURL_TRC_CF(data, cf, "ossl_bio_cf_in_read(len=%d) -> %d, err=%d",

               blen, (int)nread, result);

   BIO_clear_retry_flags(bio);

-  backend->io_result = result;

+  octx->io_result = result;

   if(nread < 0) {

     if(CURLE_AGAIN == result)

       BIO_set_retry_read(bio);

@@ -775,13 +768,13 @@ static int ossl_bio_cf_in_read(BIO *bio, char *buf, int blen)
 

   /* Before returning server replies to the SSL instance, we need

    * to have setup the x509 store or verification will fail. */

-  if(!backend->x509_store_setup) {

-    result = Curl_ssl_setup_x509_store(cf, data, backend->ctx);

+  if(!octx->x509_store_setup) {

+    result = Curl_ssl_setup_x509_store(cf, data, octx->ssl_ctx);

     if(result) {

-      backend->io_result = result;

+      octx->io_result = result;

       return -1;

     }

-    backend->x509_store_setup = TRUE;

+    octx->x509_store_setup = TRUE;

   }

 

   return (int)nread;

@@ -1883,13 +1876,12 @@ static struct curl_slist *ossl_engines_list(struct Curl_easy *data)
 static void ossl_close(struct Curl_cfilter *cf, struct Curl_easy *data)

 {

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

 

   (void)data;

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

-  if(backend->handle) {

+  if(octx->ssl) {

     /* Send the TLS shutdown if we are still connected *and* if

      * the peer did not already close the connection. */

     if(cf->next && cf->next->connected && !connssl->peer_closed) {

@@ -1900,8 +1892,8 @@ static void ossl_close(struct Curl_cfilter *cf, struct Curl_easy *data)
       /* Maybe the server has already sent a close notify alert.

          Read it to avoid an RST on the TCP connection. */

       ERR_clear_error();

-      nread = SSL_read(backend->handle, buf, (int)sizeof(buf));

-      err = SSL_get_error(backend->handle, nread);

+      nread = SSL_read(octx->ssl, buf, (int)sizeof(buf));

+      err = SSL_get_error(octx->ssl, nread);

       if(!nread && err == SSL_ERROR_ZERO_RETURN) {

         CURLcode result;

         ssize_t n;

@@ -1924,12 +1916,12 @@ static void ossl_close(struct Curl_cfilter *cf, struct Curl_easy *data)
         CURL_TRC_CF(data, cf, "not from sending TLS shutdown on "

                     "connection closed by peer");

       }

-      else if(SSL_shutdown(backend->handle) == 1) {

+      else if(SSL_shutdown(octx->ssl) == 1) {

         CURL_TRC_CF(data, cf, "SSL shutdown finished");

       }

       else {

-        nread = SSL_read(backend->handle, buf, (int)sizeof(buf));

-        err = SSL_get_error(backend->handle, nread);

+        nread = SSL_read(octx->ssl, buf, (int)sizeof(buf));

+        err = SSL_get_error(octx->ssl, nread);

         switch(err) {

         case SSL_ERROR_NONE: /* this is not an error */

         case SSL_ERROR_ZERO_RETURN: /* no more data */

@@ -1955,20 +1947,20 @@ static void ossl_close(struct Curl_cfilter *cf, struct Curl_easy *data)
       }

 

       ERR_clear_error();

-      SSL_set_connect_state(backend->handle);

+      SSL_set_connect_state(octx->ssl);

     }

 

-    SSL_free(backend->handle);

-    backend->handle = NULL;

+    SSL_free(octx->ssl);

+    octx->ssl = NULL;

   }

-  if(backend->ctx) {

-    SSL_CTX_free(backend->ctx);

-    backend->ctx = NULL;

-    backend->x509_store_setup = FALSE;

+  if(octx->ssl_ctx) {

+    SSL_CTX_free(octx->ssl_ctx);

+    octx->ssl_ctx = NULL;

+    octx->x509_store_setup = FALSE;

   }

-  if(backend->bio_method) {

-    ossl_bio_cf_method_free(backend->bio_method);

-    backend->bio_method = NULL;

+  if(octx->bio_method) {

+    ossl_bio_cf_method_free(octx->bio_method);

+    octx->bio_method = NULL;

   }

 }

 

@@ -1988,11 +1980,10 @@ static int ossl_shutdown(struct Curl_cfilter *cf,
   int buffsize;

   int err;

   bool done = FALSE;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

   int loop = 10;

 

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

 #ifndef CURL_DISABLE_FTP

   /* This has only been tested on the proftpd server, and the mod_tls code

@@ -2001,10 +1992,10 @@ static int ossl_shutdown(struct Curl_cfilter *cf,
      we do not send one. Let's hope other servers do the same... */

 

   if(data->set.ftp_ccc == CURLFTPSSL_CCC_ACTIVE)

-    (void)SSL_shutdown(backend->handle);

+    (void)SSL_shutdown(octx->ssl);

 #endif

 

-  if(backend->handle) {

+  if(octx->ssl) {

     buffsize = (int)sizeof(buf);

     while(!done && loop--) {

       int what = SOCKET_READABLE(Curl_conn_cf_get_socket(cf, data),

@@ -2014,8 +2005,8 @@ static int ossl_shutdown(struct Curl_cfilter *cf,
 

         /* Something to read, let's do it and hope that it is the close

            notify alert from the server */

-        nread = SSL_read(backend->handle, buf, buffsize);

-        err = SSL_get_error(backend->handle, nread);

+        nread = SSL_read(octx->ssl, buf, buffsize);

+        err = SSL_get_error(octx->ssl, nread);

 

         switch(err) {

         case SSL_ERROR_NONE: /* this is not an error */

@@ -2060,7 +2051,7 @@ static int ossl_shutdown(struct Curl_cfilter *cf,
 

     if(data->set.verbose) {

 #ifdef HAVE_SSL_GET_SHUTDOWN

-      switch(SSL_get_shutdown(backend->handle)) {

+      switch(SSL_get_shutdown(octx->ssl)) {

       case SSL_SENT_SHUTDOWN:

         infof(data, "SSL_get_shutdown() returned SSL_SENT_SHUTDOWN");

         break;

@@ -2075,16 +2066,17 @@ static int ossl_shutdown(struct Curl_cfilter *cf,
 #endif

     }

 

-    SSL_free(backend->handle);

-    backend->handle = NULL;

+    SSL_free(octx->ssl);

+    octx->ssl = NULL;

   }

   return retval;

 }

 

-static void ossl_session_free(void *ptr)

+static void ossl_session_free(void *sessionid, size_t idsize)

 {

   /* free the ID */

-  SSL_SESSION_free(ptr);

+  (void)idsize;

+  SSL_SESSION_free(sessionid);

 }

 

 /*

@@ -2165,14 +2157,14 @@ CURLcode Curl_ossl_verifyhost(struct Curl_easy *data, struct connectdata *conn,
   int target; /* target type, GEN_DNS or GEN_IPADD */

   size_t addrlen = 0;

   STACK_OF(GENERAL_NAME) *altnames;

-#ifdef ENABLE_IPV6

+#ifdef USE_IPV6

   struct in6_addr addr;

 #else

   struct in_addr addr;

 #endif

   CURLcode result = CURLE_OK;

   bool dNSName = FALSE; /* if a dNSName field exists in the cert */

-  bool iPAddress = FALSE; /* if a iPAddress field exists in the cert */

+  bool iPAddress = FALSE; /* if an iPAddress field exists in the cert */

   size_t hostlen;

 

   (void)conn;

@@ -2184,7 +2176,7 @@ CURLcode Curl_ossl_verifyhost(struct Curl_easy *data, struct connectdata *conn,
     target = GEN_IPADD;

     addrlen = sizeof(struct in_addr);

     break;

-#ifdef ENABLE_IPV6

+#ifdef USE_IPV6

   case CURL_SSL_PEER_IPV6:

     if(!Curl_inet_pton(AF_INET6, peer->hostname, &addr))

       return CURLE_PEER_FAILED_VERIFICATION;

@@ -2381,8 +2373,7 @@ static CURLcode verifystatus(struct Curl_cfilter *cf,
   OCSP_BASICRESP *br = NULL;

   X509_STORE     *st = NULL;

   STACK_OF(X509) *ch = NULL;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

   X509 *cert;

   OCSP_CERTID *id = NULL;

   int cert_status, crl_reason;

@@ -2390,9 +2381,9 @@ static CURLcode verifystatus(struct Curl_cfilter *cf,
   int ret;

   long len;

 

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

-  len = SSL_get_tlsext_status_ocsp_resp(backend->handle, &status);

+  len = SSL_get_tlsext_status_ocsp_resp(octx->ssl, &status);

 

   if(!status) {

     failf(data, "No OCSP response received");

@@ -2422,13 +2413,13 @@ static CURLcode verifystatus(struct Curl_cfilter *cf,
     goto end;

   }

 

-  ch = SSL_get_peer_cert_chain(backend->handle);

+  ch = SSL_get_peer_cert_chain(octx->ssl);

   if(!ch) {

     failf(data, "Could not get peer certificate chain");

     result = CURLE_SSL_INVALIDCERTSTATUS;

     goto end;

   }

-  st = SSL_CTX_get_cert_store(backend->ctx);

+  st = SSL_CTX_get_cert_store(octx->ssl_ctx);

 

 #if ((OPENSSL_VERSION_NUMBER <= 0x1000201fL) /* Fixed after 1.0.2a */ || \

      (defined(LIBRESSL_VERSION_NUMBER) &&                               \

@@ -2465,7 +2456,7 @@ static CURLcode verifystatus(struct Curl_cfilter *cf,
   }

 

   /* Compute the certificate's ID */

-  cert = SSL_get1_peer_certificate(backend->handle);

+  cert = SSL_get1_peer_certificate(octx->ssl);

   if(!cert) {

     failf(data, "Error getting peer certificate");

     result = CURLE_SSL_INVALIDCERTSTATUS;

@@ -2880,10 +2871,9 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
 #ifdef TLS1_3_VERSION

   {

     struct ssl_connect_data *connssl = cf->ctx;

-    struct ossl_ssl_backend_data *backend =

-      (struct ossl_ssl_backend_data *)connssl->backend;

-    DEBUGASSERT(backend);

-    SSL_CTX_set_max_proto_version(backend->ctx, TLS1_3_VERSION);

+    struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

+    DEBUGASSERT(octx);

+    SSL_CTX_set_max_proto_version(octx->ssl_ctx, TLS1_3_VERSION);

     *ctx_options |= SSL_OP_NO_TLSv1_2;

   }

 #else

@@ -2941,61 +2931,64 @@ ossl_set_ssl_version_min_max_legacy(ctx_option_t *ctx_options,
 }

 #endif

 

-/* The "new session" callback must return zero if the session can be removed

- * or non-zero if the session has been put into the session cache.

- */

-static int ossl_new_session_cb(SSL *ssl, SSL_SESSION *ssl_sessionid)

+CURLcode Curl_ossl_add_session(struct Curl_cfilter *cf,

+                               struct Curl_easy *data,

+                               const struct ssl_peer *peer,

+                               SSL_SESSION *session)

 {

-  int res = 0;

-  struct Curl_easy *data;

-  struct Curl_cfilter *cf;

   const struct ssl_config_data *config;

-  struct ssl_connect_data *connssl;

   bool isproxy;

+  bool added = FALSE;

 

-  cf = (struct Curl_cfilter*) SSL_get_app_data(ssl);

-  connssl = cf? cf->ctx : NULL;

-  data = connssl? CF_DATA_CURRENT(cf) : NULL;

-  /* The sockindex has been stored as a pointer to an array element */

   if(!cf || !data)

-    return 0;

+    goto out;

 

   isproxy = Curl_ssl_cf_is_proxy(cf);

 

   config = Curl_ssl_cf_get_config(cf, data);

   if(config->primary.sessionid) {

     bool incache;

-    bool added = FALSE;

-    void *old_ssl_sessionid = NULL;

+    void *old_session = NULL;

 

     Curl_ssl_sessionid_lock(data);

     if(isproxy)

       incache = FALSE;

     else

-      incache = !(Curl_ssl_getsessionid(cf, data, &old_ssl_sessionid, NULL));

-    if(incache) {

-      if(old_ssl_sessionid != ssl_sessionid) {

-        infof(data, "old SSL session ID is stale, removing");

-        Curl_ssl_delsessionid(data, old_ssl_sessionid);

-        incache = FALSE;

-      }

+      incache = !(Curl_ssl_getsessionid(cf, data, peer,

+                                        &old_session, NULL));

+    if(incache && (old_session != session)) {

+      infof(data, "old SSL session ID is stale, removing");

+      Curl_ssl_delsessionid(data, old_session);

+      incache = FALSE;

     }

 

     if(!incache) {

-      if(!Curl_ssl_addsessionid(cf, data, ssl_sessionid,

-                                0 /* unknown size */, &added)) {

-        if(added) {

-          /* the session has been put into the session cache */

-          res = 1;

-        }

-      }

-      else

-        failf(data, "failed to store ssl session");

+      added = TRUE;

+      Curl_ssl_addsessionid(cf, data, peer, session, 0, ossl_session_free);

     }

     Curl_ssl_sessionid_unlock(data);

   }

 

-  return res;

+out:

+  if(!added)

+    ossl_session_free(session, 0);

+  return CURLE_OK;

+}

+

+/* The "new session" callback must return zero if the session can be removed

+ * or non-zero if the session has been put into the session cache.

+ */

+static int ossl_new_session_cb(SSL *ssl, SSL_SESSION *ssl_sessionid)

+{

+  struct Curl_cfilter *cf;

+  struct Curl_easy *data;

+  struct ssl_connect_data *connssl;

+

+  cf = (struct Curl_cfilter*) SSL_get_app_data(ssl);

+  connssl = cf? cf->ctx : NULL;

+  data = connssl? CF_DATA_CURRENT(cf) : NULL;

+  Curl_ossl_add_session(cf, data, &connssl->peer, ssl_sessionid);

+  return 1;

 }

 

 static CURLcode load_cacert_from_memory(X509_STORE *store,

@@ -3390,7 +3383,7 @@ static bool cached_x509_store_different(
 static X509_STORE *get_cached_x509_store(struct Curl_cfilter *cf,

                                          const struct Curl_easy *data)

 {

-  struct Curl_multi *multi = data->multi_easy ? data->multi_easy : data->multi;

+  struct Curl_multi *multi = data->multi;

   X509_STORE *store = NULL;

 

   DEBUGASSERT(multi);

@@ -3410,7 +3403,7 @@ static void set_cached_x509_store(struct Curl_cfilter *cf,
                                   X509_STORE *store)

 {

   struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);

-  struct Curl_multi *multi = data->multi_easy ? data->multi_easy : data->multi;

+  struct Curl_multi *multi = data->multi;

   struct multi_ssl_backend_data *mbackend;

 

   DEBUGASSERT(multi);

@@ -3493,29 +3486,33 @@ CURLcode Curl_ssl_setup_x509_store(struct Curl_cfilter *cf,
 }

 #endif /* HAVE_SSL_X509_STORE_SHARE */

 

-static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,

-                                   struct Curl_easy *data)

+CURLcode Curl_ossl_ctx_init(struct ossl_ctx *octx,

+                            struct Curl_cfilter *cf,

+                            struct Curl_easy *data,

+                            struct ssl_peer *peer,

+                            int transport, /* TCP or QUIC */

+                            const unsigned char *alpn, size_t alpn_len,

+                            Curl_ossl_ctx_setup_cb *cb_setup,

+                            void *cb_user_data,

+                            Curl_ossl_new_session_cb *cb_new_session,

+                            void *ssl_user_data)

 {

   CURLcode result = CURLE_OK;

-  char *ciphers;

+  const char *ciphers;

   SSL_METHOD_QUAL SSL_METHOD *req_method = NULL;

-  struct ssl_connect_data *connssl = cf->ctx;

   ctx_option_t ctx_options = 0;

   void *ssl_sessionid = NULL;

   struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);

   struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);

-  BIO *bio;

   const long int ssl_version = conn_config->version;

   char * const ssl_cert = ssl_config->primary.clientcert;

   const struct curl_blob *ssl_cert_blob = ssl_config->primary.cert_blob;

   const char * const ssl_cert_type = ssl_config->cert_type;

   const bool verifypeer = conn_config->verifypeer;

   char error_buffer[256];

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

-

-  DEBUGASSERT(ssl_connect_1 == connssl->connecting_state);

-  DEBUGASSERT(backend);

+#ifdef USE_ECH

+  struct ssl_connect_data *connssl = cf->ctx;

+#endif

 

   /* Make funny stuff to get random input */

   result = ossl_seed(data);

@@ -3524,56 +3521,74 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
 

   ssl_config->certverifyresult = !X509_V_OK;

 

-  /* check to see if we've been told to use an explicit SSL/TLS version */

-

-  switch(ssl_version) {

-  case CURL_SSLVERSION_DEFAULT:

-  case CURL_SSLVERSION_TLSv1:

-  case CURL_SSLVERSION_TLSv1_0:

-  case CURL_SSLVERSION_TLSv1_1:

-  case CURL_SSLVERSION_TLSv1_2:

-  case CURL_SSLVERSION_TLSv1_3:

-    /* it will be handled later with the context options */

-#if (OPENSSL_VERSION_NUMBER >= 0x10100000L)

-    req_method = TLS_client_method();

+  switch(transport) {

+  case TRNSPRT_TCP:

+    /* check to see if we've been told to use an explicit SSL/TLS version */

+    switch(ssl_version) {

+    case CURL_SSLVERSION_DEFAULT:

+    case CURL_SSLVERSION_TLSv1:

+    case CURL_SSLVERSION_TLSv1_0:

+    case CURL_SSLVERSION_TLSv1_1:

+    case CURL_SSLVERSION_TLSv1_2:

+    case CURL_SSLVERSION_TLSv1_3:

+      /* it will be handled later with the context options */

+  #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)

+      req_method = TLS_client_method();

+  #else

+      req_method = SSLv23_client_method();

+  #endif

+      break;

+    case CURL_SSLVERSION_SSLv2:

+      failf(data, "No SSLv2 support");

+      return CURLE_NOT_BUILT_IN;

+    case CURL_SSLVERSION_SSLv3:

+      failf(data, "No SSLv3 support");

+      return CURLE_NOT_BUILT_IN;

+    default:

+      failf(data, "Unrecognized parameter passed via CURLOPT_SSLVERSION");

+      return CURLE_SSL_CONNECT_ERROR;

+    }

+    break;

+  case TRNSPRT_QUIC:

+    if((ssl_version != CURL_SSLVERSION_DEFAULT) &&

+       (ssl_version < CURL_SSLVERSION_TLSv1_3)) {

+      failf(data, "QUIC needs at least TLS version 1.3");

+      return CURLE_SSL_CONNECT_ERROR;

+     }

+#ifdef USE_OPENSSL_QUIC

+    req_method = OSSL_QUIC_client_method();

+#elif (OPENSSL_VERSION_NUMBER >= 0x10100000L)

+    req_method = TLS_method();

 #else

     req_method = SSLv23_client_method();

 #endif

     break;

-  case CURL_SSLVERSION_SSLv2:

-    failf(data, "No SSLv2 support");

-    return CURLE_NOT_BUILT_IN;

-  case CURL_SSLVERSION_SSLv3:

-    failf(data, "No SSLv3 support");

-    return CURLE_NOT_BUILT_IN;

   default:

-    failf(data, "Unrecognized parameter passed via CURLOPT_SSLVERSION");

+    failf(data, "unsupported transport %d in SSL init", transport);

     return CURLE_SSL_CONNECT_ERROR;

   }

 

-  if(backend->ctx) {

-    /* This happens when an error was encountered before in this

-     * step and we are called to do it again. Get rid of any leftover

-     * from the previous call. */

-    ossl_close(cf, data);

-  }

-  backend->ctx = SSL_CTX_new(req_method);

 

-  if(!backend->ctx) {

+  DEBUGASSERT(!octx->ssl_ctx);

+  octx->ssl_ctx = SSL_CTX_new(req_method);

+

+  if(!octx->ssl_ctx) {

     failf(data, "SSL: couldn't create a context: %s",

           ossl_strerror(ERR_peek_error(), error_buffer, sizeof(error_buffer)));

     return CURLE_OUT_OF_MEMORY;

   }

 

-#ifdef SSL_MODE_RELEASE_BUFFERS

-  SSL_CTX_set_mode(backend->ctx, SSL_MODE_RELEASE_BUFFERS);

-#endif

+  if(cb_setup) {

+    result = cb_setup(cf, data, cb_user_data);

+    if(result)

+      return result;

+  }

 

 #ifdef SSL_CTRL_SET_MSG_CALLBACK

   if(data->set.fdebug && data->set.verbose) {

     /* the SSL trace callback is only used for verbose logging */

-    SSL_CTX_set_msg_callback(backend->ctx, ossl_trace);

-    SSL_CTX_set_msg_callback_arg(backend->ctx, cf);

+    SSL_CTX_set_msg_callback(octx->ssl_ctx, ossl_trace);

+    SSL_CTX_set_msg_callback_arg(octx->ssl_ctx, cf);

   }

 #endif

 

@@ -3653,7 +3668,7 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
     ctx_options |= SSL_OP_NO_SSLv3;

 

 #if (OPENSSL_VERSION_NUMBER >= 0x10100000L) /* 1.1.0 */

-    result = ossl_set_ssl_version_min_max(cf, backend->ctx);

+    result = ossl_set_ssl_version_min_max(cf, octx->ssl_ctx);

 #else

     result = ossl_set_ssl_version_min_max_legacy(&ctx_options, cf, data);

 #endif

@@ -3666,26 +3681,20 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
     return CURLE_SSL_CONNECT_ERROR;

   }

 

-  SSL_CTX_set_options(backend->ctx, ctx_options);

+  SSL_CTX_set_options(octx->ssl_ctx, ctx_options);

 

 #ifdef HAS_ALPN

-  if(connssl->alpn) {

-    struct alpn_proto_buf proto;

-

-    result = Curl_alpn_to_proto_buf(&proto, connssl->alpn);

-    if(result ||

-       SSL_CTX_set_alpn_protos(backend->ctx, proto.data, proto.len)) {

+  if(alpn && alpn_len) {

+    if(SSL_CTX_set_alpn_protos(octx->ssl_ctx, alpn, (int)alpn_len)) {

       failf(data, "Error setting ALPN");

       return CURLE_SSL_CONNECT_ERROR;

     }

-    Curl_alpn_to_proto_str(&proto, connssl->alpn);

-    infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);

   }

 #endif

 

   if(ssl_cert || ssl_cert_blob || ssl_cert_type) {

     if(!result &&

-       !cert_stuff(data, backend->ctx,

+       !cert_stuff(data, octx->ssl_ctx,

                    ssl_cert, ssl_cert_blob, ssl_cert_type,

                    ssl_config->key, ssl_config->key_blob,

                    ssl_config->key_type, ssl_config->key_passwd))

@@ -3696,10 +3705,10 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
   }

 

   ciphers = conn_config->cipher_list;

-  if(!ciphers)

-    ciphers = (char *)DEFAULT_CIPHER_SELECTION;

+  if(!ciphers && (peer->transport != TRNSPRT_QUIC))

+    ciphers = DEFAULT_CIPHER_SELECTION;

   if(ciphers) {

-    if(!SSL_CTX_set_cipher_list(backend->ctx, ciphers)) {

+    if(!SSL_CTX_set_cipher_list(octx->ssl_ctx, ciphers)) {

       failf(data, "failed setting cipher list: %s", ciphers);

       return CURLE_SSL_CIPHER;

     }

@@ -3708,9 +3717,9 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
 

 #ifdef HAVE_SSL_CTX_SET_CIPHERSUITES

   {

-    char *ciphers13 = conn_config->cipher_list13;

+    const char *ciphers13 = conn_config->cipher_list13;

     if(ciphers13) {

-      if(!SSL_CTX_set_ciphersuites(backend->ctx, ciphers13)) {

+      if(!SSL_CTX_set_ciphersuites(octx->ssl_ctx, ciphers13)) {

         failf(data, "failed setting TLS 1.3 cipher suite: %s", ciphers13);

         return CURLE_SSL_CIPHER;

       }

@@ -3721,14 +3730,14 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
 

 #ifdef HAVE_SSL_CTX_SET_POST_HANDSHAKE_AUTH

   /* OpenSSL 1.1.1 requires clients to opt-in for PHA */

-  SSL_CTX_set_post_handshake_auth(backend->ctx, 1);

+  SSL_CTX_set_post_handshake_auth(octx->ssl_ctx, 1);

 #endif

 

 #ifdef HAVE_SSL_CTX_SET_EC_CURVES

   {

-    char *curves = conn_config->curves;

+    const char *curves = conn_config->curves;

     if(curves) {

-      if(!SSL_CTX_set1_curves_list(backend->ctx, curves)) {

+      if(!SSL_CTX_set1_curves_list(octx->ssl_ctx, curves)) {

         failf(data, "failed setting curves list: '%s'", curves);

         return CURLE_SSL_CIPHER;

       }

@@ -3742,18 +3751,18 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
     char * const ssl_password = ssl_config->primary.password;

     infof(data, "Using TLS-SRP username: %s", ssl_username);

 

-    if(!SSL_CTX_set_srp_username(backend->ctx, ssl_username)) {

+    if(!SSL_CTX_set_srp_username(octx->ssl_ctx, ssl_username)) {

       failf(data, "Unable to set SRP user name");

       return CURLE_BAD_FUNCTION_ARGUMENT;

     }

-    if(!SSL_CTX_set_srp_password(backend->ctx, ssl_password)) {

+    if(!SSL_CTX_set_srp_password(octx->ssl_ctx, ssl_password)) {

       failf(data, "failed setting SRP password");

       return CURLE_BAD_FUNCTION_ARGUMENT;

     }

     if(!conn_config->cipher_list) {

       infof(data, "Setting cipher list SRP");

 

-      if(!SSL_CTX_set_cipher_list(backend->ctx, "SRP")) {

+      if(!SSL_CTX_set_cipher_list(octx->ssl_ctx, "SRP")) {

         failf(data, "failed setting SRP cipher list");

         return CURLE_SSL_CIPHER;

       }

@@ -3765,38 +3774,40 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
    * fail to connect if the verification fails, or if it should continue

    * anyway. In the latter case the result of the verification is checked with

    * SSL_get_verify_result() below. */

-  SSL_CTX_set_verify(backend->ctx,

+  SSL_CTX_set_verify(octx->ssl_ctx,

                      verifypeer ? SSL_VERIFY_PEER : SSL_VERIFY_NONE, NULL);

 

   /* Enable logging of secrets to the file specified in env SSLKEYLOGFILE. */

 #ifdef HAVE_KEYLOG_CALLBACK

   if(Curl_tls_keylog_enabled()) {

-    SSL_CTX_set_keylog_callback(backend->ctx, ossl_keylog_callback);

+    SSL_CTX_set_keylog_callback(octx->ssl_ctx, ossl_keylog_callback);

   }

 #endif

 

-  /* Enable the session cache because it's a prerequisite for the "new session"

-   * callback. Use the "external storage" mode to prevent OpenSSL from creating

-   * an internal session cache.

-   */

-  SSL_CTX_set_session_cache_mode(backend->ctx,

-                                 SSL_SESS_CACHE_CLIENT |

-                                 SSL_SESS_CACHE_NO_INTERNAL);

-  SSL_CTX_sess_set_new_cb(backend->ctx, ossl_new_session_cb);

+  if(cb_new_session) {

+    /* Enable the session cache because it's a prerequisite for the

+     * "new session" callback. Use the "external storage" mode to prevent

+     * OpenSSL from creating an internal session cache.

+     */

+    SSL_CTX_set_session_cache_mode(octx->ssl_ctx,

+                                   SSL_SESS_CACHE_CLIENT |

+                                   SSL_SESS_CACHE_NO_INTERNAL);

+    SSL_CTX_sess_set_new_cb(octx->ssl_ctx, cb_new_session);

+  }

 

   /* give application a chance to interfere with SSL set up. */

   if(data->set.ssl.fsslctx) {

     /* When a user callback is installed to modify the SSL_CTX,

      * we need to do the full initialization before calling it.

      * See: #11800 */

-    if(!backend->x509_store_setup) {

-      result = Curl_ssl_setup_x509_store(cf, data, backend->ctx);

+    if(!octx->x509_store_setup) {

+      result = Curl_ssl_setup_x509_store(cf, data, octx->ssl_ctx);

       if(result)

         return result;

-      backend->x509_store_setup = TRUE;

+      octx->x509_store_setup = TRUE;

     }

     Curl_set_in_callback(data, true);

-    result = (*data->set.ssl.fsslctx)(data, backend->ctx,

+    result = (*data->set.ssl.fsslctx)(data, octx->ssl_ctx,

                                       data->set.ssl.fsslctxp);

     Curl_set_in_callback(data, false);

     if(result) {

@@ -3806,47 +3817,174 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
   }

 

   /* Let's make an SSL structure */

-  if(backend->handle)

-    SSL_free(backend->handle);

-  backend->handle = SSL_new(backend->ctx);

-  if(!backend->handle) {

+  if(octx->ssl)

+    SSL_free(octx->ssl);

+  octx->ssl = SSL_new(octx->ssl_ctx);

+  if(!octx->ssl) {

     failf(data, "SSL: couldn't create a context (handle)");

     return CURLE_OUT_OF_MEMORY;

   }

 

-  SSL_set_app_data(backend->handle, cf);

+  SSL_set_app_data(octx->ssl, ssl_user_data);

 

 #if (OPENSSL_VERSION_NUMBER >= 0x0090808fL) && !defined(OPENSSL_NO_TLSEXT) && \

   !defined(OPENSSL_NO_OCSP)

   if(conn_config->verifystatus)

-    SSL_set_tlsext_status_type(backend->handle, TLSEXT_STATUSTYPE_ocsp);

+    SSL_set_tlsext_status_type(octx->ssl, TLSEXT_STATUSTYPE_ocsp);

 #endif

 

 #if (defined(OPENSSL_IS_BORINGSSL) || defined(OPENSSL_IS_AWSLC)) && \

     defined(ALLOW_RENEG)

-  SSL_set_renegotiate_mode(backend->handle, ssl_renegotiate_freely);

+  SSL_set_renegotiate_mode(octx->ssl, ssl_renegotiate_freely);

 #endif

 

-  SSL_set_connect_state(backend->handle);

+  SSL_set_connect_state(octx->ssl);

 

-  backend->server_cert = 0x0;

+  octx->server_cert = 0x0;

 #ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME

-  if(connssl->peer.sni) {

-    if(!SSL_set_tlsext_host_name(backend->handle, connssl->peer.sni)) {

+  if(peer->sni) {

+    if(!SSL_set_tlsext_host_name(octx->ssl, peer->sni)) {

       failf(data, "Failed set SNI");

       return CURLE_SSL_CONNECT_ERROR;

     }

   }

-#endif

 

-  SSL_set_app_data(backend->handle, cf);

+#ifdef USE_ECH

+  if(ECH_ENABLED(data)) {

+    unsigned char *ech_config = NULL;

+    size_t ech_config_len = 0;

+    char *outername = data->set.str[STRING_ECH_PUBLIC];

+    int trying_ech_now = 0;

+

+    if(data->set.tls_ech & CURLECH_GREASE) {

+      infof(data, "ECH: will GREASE ClientHello");

+# ifdef OPENSSL_IS_BORINGSSL

+      SSL_set_enable_ech_grease(octx->ssl, 1);

+# else

+      SSL_set_options(octx->ssl, SSL_OP_ECH_GREASE);

+# endif

+    }

+    else if(data->set.tls_ech & CURLECH_CLA_CFG) {

+# ifdef OPENSSL_IS_BORINGSSL

+      /* have to do base64 decode here for boring */

+      const char *b64 = data->set.str[STRING_ECH_CONFIG];

+

+      if(!b64) {

+        infof(data, "ECH: ECHConfig from command line empty");

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+      ech_config_len = 2 * strlen(b64);

+      result = Curl_base64_decode(b64, &ech_config, &ech_config_len);

+      if(result || !ech_config) {

+        infof(data, "ECH: can't base64 decode ECHConfig from command line");

+        if(data->set.tls_ech & CURLECH_HARD)

+          return result;

+      }

+      if(SSL_set1_ech_config_list(octx->ssl, ech_config,

+                                  ech_config_len) != 1) {

+        infof(data, "ECH: SSL_ECH_set1_echconfig failed");

+        if(data->set.tls_ech & CURLECH_HARD) {

+          free(ech_config);

+          return CURLE_SSL_CONNECT_ERROR;

+        }

+      }

+      free(ech_config);

+      trying_ech_now = 1;

+# else

+      ech_config = (unsigned char *) data->set.str[STRING_ECH_CONFIG];

+      if(!ech_config) {

+        infof(data, "ECH: ECHConfig from command line empty");

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+      ech_config_len = strlen(data->set.str[STRING_ECH_CONFIG]);

+      if(SSL_ech_set1_echconfig(octx->ssl, ech_config, ech_config_len) != 1) {

+        infof(data, "ECH: SSL_ECH_set1_echconfig failed");

+        if(data->set.tls_ech & CURLECH_HARD)

+          return CURLE_SSL_CONNECT_ERROR;

+      }

+      else

+        trying_ech_now = 1;

+# endif

+      infof(data, "ECH: ECHConfig from command line");

+    }

+    else {

+      struct Curl_dns_entry *dns = NULL;

+

+      dns = Curl_fetch_addr(data, connssl->peer.hostname, connssl->peer.port);

+      if(!dns) {

+        infof(data, "ECH: requested but no DNS info available");

+        if(data->set.tls_ech & CURLECH_HARD)

+          return CURLE_SSL_CONNECT_ERROR;

+      }

+      else {

+        struct Curl_https_rrinfo *rinfo = NULL;

+

+        rinfo = dns->hinfo;

+        if(rinfo && rinfo->echconfiglist) {

+          unsigned char *ecl = rinfo->echconfiglist;

+          size_t elen = rinfo->echconfiglist_len;

+

+          infof(data, "ECH: ECHConfig from DoH HTTPS RR");

+# ifndef OPENSSL_IS_BORINGSSL

+          if(SSL_ech_set1_echconfig(octx->ssl, ecl, elen) != 1) {

+            infof(data, "ECH: SSL_ECH_set1_echconfig failed");

+            if(data->set.tls_ech & CURLECH_HARD)

+              return CURLE_SSL_CONNECT_ERROR;

+          }

+# else

+          if(SSL_set1_ech_config_list(octx->ssl, ecl, elen) != 1) {

+            infof(data, "ECH: SSL_set1_ech_config_list failed (boring)");

+            if(data->set.tls_ech & CURLECH_HARD)

+              return CURLE_SSL_CONNECT_ERROR;

+          }

+# endif

+          else {

+            trying_ech_now = 1;

+            infof(data, "ECH: imported ECHConfigList of length %ld", elen);

+          }

+        }

+        else {

+          infof(data, "ECH: requested but no ECHConfig available");

+          if(data->set.tls_ech & CURLECH_HARD)

+            return CURLE_SSL_CONNECT_ERROR;

+        }

+        Curl_resolv_unlock(data, dns);

+      }

+    }

+# ifdef OPENSSL_IS_BORINGSSL

+    if(trying_ech_now && outername) {

+      infof(data, "ECH: setting public_name not supported with boringssl");

+      return CURLE_SSL_CONNECT_ERROR;

+    }

+# else

+    if(trying_ech_now && outername) {

+      infof(data, "ECH: inner: '%s', outer: '%s'",

+            connssl->peer.hostname, outername);

+      result = SSL_ech_set_server_names(octx->ssl,

+                                        connssl->peer.hostname, outername,

+                                        0 /* do send outer */);

+      if(result != 1) {

+        infof(data, "ECH: rv failed to set server name(s) %d [ERROR]", result);

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+    }

+# endif  /* not BORING */

+    if(trying_ech_now

+       && SSL_set_min_proto_version(octx->ssl, TLS1_3_VERSION) != 1) {

+      infof(data, "ECH: Can't force TLSv1.3 [ERROR]");

+      return CURLE_SSL_CONNECT_ERROR;

+    }

+  }

+#endif  /* USE_ECH */

 

-  connssl->reused_session = FALSE;

-  if(ssl_config->primary.sessionid) {

+#endif

+

+  octx->reused_session = FALSE;

+  if(ssl_config->primary.sessionid && transport == TRNSPRT_TCP) {

     Curl_ssl_sessionid_lock(data);

-    if(!Curl_ssl_getsessionid(cf, data, &ssl_sessionid, NULL)) {

+    if(!Curl_ssl_getsessionid(cf, data, peer, &ssl_sessionid, NULL)) {

       /* we got a session id, use it! */

-      if(!SSL_set_session(backend->handle, ssl_sessionid)) {

+      if(!SSL_set_session(octx->ssl, ssl_sessionid)) {

         Curl_ssl_sessionid_unlock(data);

         failf(data, "SSL: SSL_set_session failed: %s",

               ossl_strerror(ERR_get_error(), error_buffer,

@@ -3855,15 +3993,46 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
       }

       /* Informational message */

       infof(data, "SSL reusing session ID");

-      connssl->reused_session = TRUE;

+      octx->reused_session = TRUE;

     }

     Curl_ssl_sessionid_unlock(data);

   }

 

-  backend->bio_method = ossl_bio_cf_method_create();

-  if(!backend->bio_method)

+  return CURLE_OK;

+}

+

+static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,

+                                   struct Curl_easy *data)

+{

+  struct ssl_connect_data *connssl = cf->ctx;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

+  struct alpn_proto_buf proto;

+  BIO *bio;

+  CURLcode result;

+

+  DEBUGASSERT(ssl_connect_1 == connssl->connecting_state);

+  DEBUGASSERT(octx);

+  memset(&proto, 0, sizeof(proto));

+#ifdef HAS_ALPN

+  if(connssl->alpn) {

+    result = Curl_alpn_to_proto_buf(&proto, connssl->alpn);

+    if(result) {

+      failf(data, "Error determining ALPN");

+      return CURLE_SSL_CONNECT_ERROR;

+    }

+  }

+#endif

+

+  result = Curl_ossl_ctx_init(octx, cf, data, &connssl->peer, TRNSPRT_TCP,

+                              proto.data, proto.len, NULL, NULL,

+                              ossl_new_session_cb, cf);

+  if(result)

+    return result;

+

+  octx->bio_method = ossl_bio_cf_method_create();

+  if(!octx->bio_method)

     return CURLE_OUT_OF_MEMORY;

-  bio = BIO_new(backend->bio_method);

+  bio = BIO_new(octx->bio_method);

   if(!bio)

     return CURLE_OUT_OF_MEMORY;

 

@@ -3875,40 +4044,109 @@ static CURLcode ossl_connect_step1(struct Curl_cfilter *cf,
    * We check on the function in configure, since libressl and friends

    * each have their own versions to add support for this. */

   BIO_up_ref(bio);

-  SSL_set0_rbio(backend->handle, bio);

-  SSL_set0_wbio(backend->handle, bio);

+  SSL_set0_rbio(octx->ssl, bio);

+  SSL_set0_wbio(octx->ssl, bio);

 #else

-  SSL_set_bio(backend->handle, bio, bio);

+  SSL_set_bio(octx->ssl, bio, bio);

 #endif

-  connssl->connecting_state = ssl_connect_2;

 

+#ifdef HAS_ALPN

+  if(connssl->alpn) {

+    Curl_alpn_to_proto_str(&proto, connssl->alpn);

+    infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);

+  }

+#endif

+  connssl->connecting_state = ssl_connect_2;

   return CURLE_OK;

 }

 

+#ifdef USE_ECH

+/* If we have retry configs, then trace those out */

+static void ossl_trace_ech_retry_configs(struct Curl_easy *data, SSL* ssl,

+                                         int reason)

+{

+  CURLcode result = CURLE_OK;

+  size_t rcl = 0;

+  int rv = 1;

+# ifndef OPENSSL_IS_BORINGSSL

+  char *inner = NULL;

+  unsigned char *rcs = NULL;

+  char *outer = NULL;

+# else

+  const char *inner = NULL;

+  const uint8_t *rcs = NULL;

+  const char *outer = NULL;

+  size_t out_name_len = 0;

+  int servername_type = 0;

+# endif

+

+  /* nothing to trace if not doing ECH */

+  if(!ECH_ENABLED(data))

+    return;

+# ifndef OPENSSL_IS_BORINGSSL

+  rv = SSL_ech_get_retry_config(ssl, &rcs, &rcl);

+# else

+  SSL_get0_ech_retry_configs(ssl, &rcs, &rcl);

+  rv = (int)rcl;

+# endif

+

+  if(rv && rcs) {

+# define HEXSTR_MAX 800

+    char *b64str = NULL;

+    size_t blen = 0;

+

+    result = Curl_base64_encode((const char *)rcs, rcl,

+                                &b64str, &blen);

+    if(!result && b64str)

+      infof(data, "ECH: retry_configs %s", b64str);

+    free(b64str);

+# ifndef OPENSSL_IS_BORINGSSL

+    rv = SSL_ech_get_status(ssl, &inner, &outer);

+    infof(data, "ECH: retry_configs for %s from %s, %d %d",

+          inner ? inner : "NULL", outer ? outer : "NULL", reason, rv);

+#else

+    rv = SSL_ech_accepted(ssl);

+    servername_type = SSL_get_servername_type(ssl);

+    inner = SSL_get_servername(ssl, servername_type);

+    SSL_get0_ech_name_override(ssl, &outer, &out_name_len);

+    /* TODO: get the inner from boring */

+    infof(data, "ECH: retry_configs for %s from %s, %d %d",

+          inner ? inner : "NULL", outer ? outer : "NULL", reason, rv);

+#endif

+  }

+  else

+    infof(data, "ECH: no retry_configs (rv = %d)", rv);

+# ifndef OPENSSL_IS_BORINGSSL

+  OPENSSL_free((void *)rcs);

+# endif

+  return;

+}

+

+#endif

+

 static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,

                                    struct Curl_easy *data)

 {

   int err;

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

   struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);

   DEBUGASSERT(ssl_connect_2 == connssl->connecting_state

               || ssl_connect_2_reading == connssl->connecting_state

               || ssl_connect_2_writing == connssl->connecting_state);

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

   ERR_clear_error();

 

-  err = SSL_connect(backend->handle);

+  err = SSL_connect(octx->ssl);

 

-  if(!backend->x509_store_setup) {

+  if(!octx->x509_store_setup) {

     /* After having send off the ClientHello, we prepare the x509

      * store to verify the coming certificate from the server */

-    CURLcode result = Curl_ssl_setup_x509_store(cf, data, backend->ctx);

+    CURLcode result = Curl_ssl_setup_x509_store(cf, data, octx->ssl_ctx);

     if(result)

       return result;

-    backend->x509_store_setup = TRUE;

+    octx->x509_store_setup = TRUE;

   }

 

 #ifndef HAVE_KEYLOG_CALLBACK

@@ -3916,7 +4154,9 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
     /* If key logging is enabled, wait for the handshake to complete and then

      * proceed with logging secrets (for TLS 1.2 or older).

      */

-    ossl_log_tls12_secret(backend->handle, &backend->keylog_done);

+    bool done = FALSE;

+    ossl_log_tls12_secret(octx->ssl, &done);

+    octx->keylog_done = done;

   }

 #endif

 

@@ -3924,7 +4164,7 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
      0  is "not successful but was shut down controlled"

      <0 is "handshake was not successful, because a fatal error occurred" */

   if(1 != err) {

-    int detail = SSL_get_error(backend->handle, err);

+    int detail = SSL_get_error(octx->ssl, err);

 

     if(SSL_ERROR_WANT_READ == detail) {

       connssl->connecting_state = ssl_connect_2_reading;

@@ -3946,7 +4186,7 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
       return CURLE_OK;

     }

 #endif

-    if(backend->io_result == CURLE_AGAIN) {

+    if(octx->io_result == CURLE_AGAIN) {

       return CURLE_OK;

     }

     else {

@@ -3974,7 +4214,7 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
           (reason == SSL_R_SSLV3_ALERT_CERTIFICATE_EXPIRED))) {

         result = CURLE_PEER_FAILED_VERIFICATION;

 

-        lerr = SSL_get_verify_result(backend->handle);

+        lerr = SSL_get_verify_result(octx->ssl);

         if(lerr != X509_V_OK) {

           ssl_config->certverifyresult = lerr;

           msnprintf(error_buffer, sizeof(error_buffer),

@@ -3997,6 +4237,21 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
         ossl_strerror(errdetail, error_buffer, sizeof(error_buffer));

       }

 #endif

+#ifdef USE_ECH

+      else if((lib == ERR_LIB_SSL) &&

+# ifndef OPENSSL_IS_BORINGSSL

+              (reason == SSL_R_ECH_REQUIRED)) {

+# else

+              (reason == SSL_R_ECH_REJECTED)) {

+# endif

+

+        /* trace retry_configs if we got some */

+        ossl_trace_ech_retry_configs(data, octx->ssl, reason);

+

+        result = CURLE_ECH_REQUIRED;

+        ossl_strerror(errdetail, error_buffer, sizeof(error_buffer));

+      }

+#endif

       else {

         result = CURLE_SSL_CONNECT_ERROR;

         ossl_strerror(errdetail, error_buffer, sizeof(error_buffer));

@@ -4016,7 +4271,7 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
           Curl_strerror(sockerr, extramsg, sizeof(extramsg));

         failf(data, OSSL_PACKAGE " SSL_connect: %s in connection to %s:%d ",

               extramsg[0] ? extramsg : SSL_ERROR_to_str(detail),

-              connssl->peer.hostname, connssl->port);

+              connssl->peer.hostname, connssl->peer.port);

         return result;

       }

 

@@ -4034,22 +4289,84 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
     connssl->connecting_state = ssl_connect_3;

 

 #if (OPENSSL_VERSION_NUMBER >= 0x30000000L)

-    SSL_get_peer_signature_type_nid(backend->handle, &psigtype_nid);

+    SSL_get_peer_signature_type_nid(octx->ssl, &psigtype_nid);

 #if (OPENSSL_VERSION_NUMBER >= 0x30200000L)

-    negotiated_group_name = SSL_get0_group_name(backend->handle);

+    negotiated_group_name = SSL_get0_group_name(octx->ssl);

 #else

     negotiated_group_name =

-      OBJ_nid2sn(SSL_get_negotiated_group(backend->handle) & 0x0000FFFF);

+      OBJ_nid2sn(SSL_get_negotiated_group(octx->ssl) & 0x0000FFFF);

 #endif

 #endif

 

     /* Informational message */

     infof(data, "SSL connection using %s / %s / %s / %s",

-          SSL_get_version(backend->handle),

-          SSL_get_cipher(backend->handle),

+          SSL_get_version(octx->ssl),

+          SSL_get_cipher(octx->ssl),

           negotiated_group_name? negotiated_group_name : "[blank]",

           OBJ_nid2sn(psigtype_nid));

 

+#ifdef USE_ECH

+# ifndef OPENSSL_IS_BORINGSSL

+    if(ECH_ENABLED(data)) {

+      char *inner = NULL, *outer = NULL;

+      const char *status = NULL;

+      int rv;

+

+      rv = SSL_ech_get_status(octx->ssl, &inner, &outer);

+      switch(rv) {

+      case SSL_ECH_STATUS_SUCCESS:

+        status = "succeeded";

+        break;

+      case SSL_ECH_STATUS_GREASE_ECH:

+        status = "sent GREASE, got retry-configs";

+        break;

+      case SSL_ECH_STATUS_GREASE:

+        status = "sent GREASE";

+        break;

+      case SSL_ECH_STATUS_NOT_TRIED:

+        status = "not attempted";

+        break;

+      case SSL_ECH_STATUS_NOT_CONFIGURED:

+        status = "not configured";

+        break;

+      case SSL_ECH_STATUS_BACKEND:

+        status = "backend (unexpected)";

+        break;

+      case SSL_ECH_STATUS_FAILED:

+        status = "failed";

+        break;

+      case SSL_ECH_STATUS_BAD_CALL:

+        status = "bad call (unexpected)";

+        break;

+      case SSL_ECH_STATUS_BAD_NAME:

+        status = "bad name (unexpected)";

+        break;

+      default:

+        status = "unexpected status";

+        infof(data, "ECH: unexpected status %d",rv);

+      }

+      infof(data, "ECH: result: status is %s, inner is %s, outer is %s",

+             (status?status:"NULL"),

+             (inner?inner:"NULL"),

+             (outer?outer:"NULL"));

+      OPENSSL_free(inner);

+      OPENSSL_free(outer);

+      if(rv == SSL_ECH_STATUS_GREASE_ECH) {

+        /* trace retry_configs if we got some */

+        ossl_trace_ech_retry_configs(data, octx->ssl, 0);

+      }

+      if(rv != SSL_ECH_STATUS_SUCCESS

+         && data->set.tls_ech & CURLECH_HARD) {

+        infof(data, "ECH: ech-hard failed");

+        return CURLE_SSL_CONNECT_ERROR;

+      }

+   }

+   else {

+      infof(data, "ECH: result: status is not attempted");

+   }

+# endif  /* BORING */

+#endif  /* USE_ECH */

+

 #ifdef HAS_ALPN

     /* Sets data and len to negotiated protocol, len is 0 if no protocol was

      * negotiated

@@ -4057,7 +4374,7 @@ static CURLcode ossl_connect_step2(struct Curl_cfilter *cf,
     if(connssl->alpn) {

       const unsigned char *neg_protocol;

       unsigned int len;

-      SSL_get0_alpn_selected(backend->handle, &neg_protocol, &len);

+      SSL_get0_alpn_selected(octx->ssl, &neg_protocol, &len);

 

       return Curl_alpn_set_negotiated(cf, data, neg_protocol, len);

     }

@@ -4194,20 +4511,12 @@ static void infof_certstack(struct Curl_easy *data, const SSL *ssl)
 #define infof_certstack(data, ssl)

 #endif

 

-/*

- * Get the server cert, verify it and show it, etc., only call failf() if the

- * 'strict' argument is TRUE as otherwise all this is for informational

- * purposes only!

- *

- * We check certificates to authenticate the server; otherwise we risk

- * man-in-the-middle attack.

- */

-static CURLcode servercert(struct Curl_cfilter *cf,

-                           struct Curl_easy *data,

-                           bool strict)

+CURLcode Curl_oss_check_peer_cert(struct Curl_cfilter *cf,

+                                  struct Curl_easy *data,

+                                  struct ossl_ctx *octx,

+                                  struct ssl_peer *peer)

 {

   struct connectdata *conn = cf->conn;

-  struct ssl_connect_data *connssl = cf->ctx;

   struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);

   struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);

   CURLcode result = CURLE_OK;

@@ -4219,10 +4528,9 @@ static CURLcode servercert(struct Curl_cfilter *cf,
   char buffer[2048];

   const char *ptr;

   BIO *mem = BIO_new(BIO_s_mem());

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  bool strict = (conn_config->verifypeer || conn_config->verifyhost);

 

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

   if(!mem) {

     failf(data,

@@ -4235,10 +4543,10 @@ static CURLcode servercert(struct Curl_cfilter *cf,
 

   if(data->set.ssl.certinfo)

     /* asked to gather certificate info */

-    (void)Curl_ossl_certchain(data, backend->handle);

+    (void)Curl_ossl_certchain(data, octx->ssl);

 

-  backend->server_cert = SSL_get1_peer_certificate(backend->handle);

-  if(!backend->server_cert) {

+  octx->server_cert = SSL_get1_peer_certificate(octx->ssl);

+  if(!octx->server_cert) {

     BIO_free(mem);

     if(!strict)

       return CURLE_OK;

@@ -4250,19 +4558,19 @@ static CURLcode servercert(struct Curl_cfilter *cf,
   infof(data, "%s certificate:",

         Curl_ssl_cf_is_proxy(cf)? "Proxy" : "Server");

 

-  rc = x509_name_oneline(X509_get_subject_name(backend->server_cert),

+  rc = x509_name_oneline(X509_get_subject_name(octx->server_cert),

                          buffer, sizeof(buffer));

   infof(data, " subject: %s", rc?"[NONE]":buffer);

 

 #ifndef CURL_DISABLE_VERBOSE_STRINGS

   {

     long len;

-    ASN1_TIME_print(mem, X509_get0_notBefore(backend->server_cert));

+    ASN1_TIME_print(mem, X509_get0_notBefore(octx->server_cert));

     len = BIO_get_mem_data(mem, (char **) &ptr);

     infof(data, " start date: %.*s", (int)len, ptr);

     (void)BIO_reset(mem);

 

-    ASN1_TIME_print(mem, X509_get0_notAfter(backend->server_cert));

+    ASN1_TIME_print(mem, X509_get0_notAfter(octx->server_cert));

     len = BIO_get_mem_data(mem, (char **) &ptr);

     infof(data, " expire date: %.*s", (int)len, ptr);

     (void)BIO_reset(mem);

@@ -4272,16 +4580,15 @@ static CURLcode servercert(struct Curl_cfilter *cf,
   BIO_free(mem);

 

   if(conn_config->verifyhost) {

-    result = Curl_ossl_verifyhost(data, conn, &connssl->peer,

-                                  backend->server_cert);

+    result = Curl_ossl_verifyhost(data, conn, peer, octx->server_cert);

     if(result) {

-      X509_free(backend->server_cert);

-      backend->server_cert = NULL;

+      X509_free(octx->server_cert);

+      octx->server_cert = NULL;

       return result;

     }

   }

 

-  rc = x509_name_oneline(X509_get_issuer_name(backend->server_cert),

+  rc = x509_name_oneline(X509_get_issuer_name(octx->server_cert),

                          buffer, sizeof(buffer));

   if(rc) {

     if(strict)

@@ -4305,8 +4612,8 @@ static CURLcode servercert(struct Curl_cfilter *cf,
                 " error %s",

                 ossl_strerror(ERR_get_error(), error_buffer,

                               sizeof(error_buffer)) );

-          X509_free(backend->server_cert);

-          backend->server_cert = NULL;

+          X509_free(octx->server_cert);

+          octx->server_cert = NULL;

           return CURLE_OUT_OF_MEMORY;

         }

       }

@@ -4318,8 +4625,8 @@ static CURLcode servercert(struct Curl_cfilter *cf,
                 " error %s",

                 ossl_strerror(ERR_get_error(), error_buffer,

                               sizeof(error_buffer)) );

-          X509_free(backend->server_cert);

-          backend->server_cert = NULL;

+          X509_free(octx->server_cert);

+          octx->server_cert = NULL;

           return CURLE_OUT_OF_MEMORY;

         }

 

@@ -4328,8 +4635,8 @@ static CURLcode servercert(struct Curl_cfilter *cf,
             failf(data, "SSL: Unable to open issuer cert (%s)",

                   conn_config->issuercert);

           BIO_free(fp);

-          X509_free(backend->server_cert);

-          backend->server_cert = NULL;

+          X509_free(octx->server_cert);

+          octx->server_cert = NULL;

           return CURLE_SSL_ISSUER_ERROR;

         }

       }

@@ -4341,19 +4648,19 @@ static CURLcode servercert(struct Curl_cfilter *cf,
                 conn_config->issuercert);

         BIO_free(fp);

         X509_free(issuer);

-        X509_free(backend->server_cert);

-        backend->server_cert = NULL;

+        X509_free(octx->server_cert);

+        octx->server_cert = NULL;

         return CURLE_SSL_ISSUER_ERROR;

       }

 

-      if(X509_check_issued(issuer, backend->server_cert) != X509_V_OK) {

+      if(X509_check_issued(issuer, octx->server_cert) != X509_V_OK) {

         if(strict)

           failf(data, "SSL: Certificate issuer check failed (%s)",

                 conn_config->issuercert);

         BIO_free(fp);

         X509_free(issuer);

-        X509_free(backend->server_cert);

-        backend->server_cert = NULL;

+        X509_free(octx->server_cert);

+        octx->server_cert = NULL;

         return CURLE_SSL_ISSUER_ERROR;

       }

 

@@ -4363,7 +4670,7 @@ static CURLcode servercert(struct Curl_cfilter *cf,
       X509_free(issuer);

     }

 

-    lerr = SSL_get_verify_result(backend->handle);

+    lerr = SSL_get_verify_result(octx->ssl);

     ssl_config->certverifyresult = lerr;

     if(lerr != X509_V_OK) {

       if(conn_config->verifypeer) {

@@ -4383,11 +4690,11 @@ static CURLcode servercert(struct Curl_cfilter *cf,
       infof(data, " SSL certificate verify ok.");

   }

 

-  infof_certstack(data, backend->handle);

+  infof_certstack(data, octx->ssl);

 

 #if (OPENSSL_VERSION_NUMBER >= 0x0090808fL) && !defined(OPENSSL_NO_TLSEXT) && \

   !defined(OPENSSL_NO_OCSP)

-  if(conn_config->verifystatus && !connssl->reused_session) {

+  if(conn_config->verifystatus && !octx->reused_session) {

     /* don't do this after Session ID reuse */

     result = verifystatus(cf, data);

     if(result) {

@@ -4397,7 +4704,8 @@ static CURLcode servercert(struct Curl_cfilter *cf,
         void *old_ssl_sessionid = NULL;

         bool incache;

         Curl_ssl_sessionid_lock(data);

-        incache = !(Curl_ssl_getsessionid(cf, data, &old_ssl_sessionid, NULL));

+        incache = !(Curl_ssl_getsessionid(cf, data, peer,

+                                          &old_ssl_sessionid, NULL));

         if(incache) {

           infof(data, "Remove session ID again from cache");

           Curl_ssl_delsessionid(data, old_ssl_sessionid);

@@ -4405,8 +4713,8 @@ static CURLcode servercert(struct Curl_cfilter *cf,
         Curl_ssl_sessionid_unlock(data);

       }

 

-      X509_free(backend->server_cert);

-      backend->server_cert = NULL;

+      X509_free(octx->server_cert);

+      octx->server_cert = NULL;

       return result;

     }

   }

@@ -4416,18 +4724,21 @@ static CURLcode servercert(struct Curl_cfilter *cf,
     /* when not strict, we don't bother about the verify cert problems */

     result = CURLE_OK;

 

+#ifndef CURL_DISABLE_PROXY

   ptr = Curl_ssl_cf_is_proxy(cf)?

     data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY]:

     data->set.str[STRING_SSL_PINNEDPUBLICKEY];

+#else

+  ptr = data->set.str[STRING_SSL_PINNEDPUBLICKEY];

+#endif

   if(!result && ptr) {

-    result = ossl_pkp_pin_peer_pubkey(data, backend->server_cert, ptr);

+    result = ossl_pkp_pin_peer_pubkey(data, octx->server_cert, ptr);

     if(result)

       failf(data, "SSL: public key does not match pinned public key");

   }

 

-  X509_free(backend->server_cert);

-  backend->server_cert = NULL;

-  connssl->connecting_state = ssl_connect_done;

+  X509_free(octx->server_cert);

+  octx->server_cert = NULL;

 

   return result;

 }

@@ -4437,7 +4748,7 @@ static CURLcode ossl_connect_step3(struct Curl_cfilter *cf,
 {

   CURLcode result = CURLE_OK;

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

 

   DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);

 

@@ -4448,9 +4759,7 @@ static CURLcode ossl_connect_step3(struct Curl_cfilter *cf,
    * operations.

    */

 

-  result = servercert(cf, data, conn_config->verifypeer ||

-                      conn_config->verifyhost);

-

+  result = Curl_oss_check_peer_cert(cf, data, octx, &connssl->peer);

   if(!result)

     connssl->connecting_state = ssl_connect_done;

 

@@ -4590,12 +4899,11 @@ static bool ossl_data_pending(struct Curl_cfilter *cf,
                               const struct Curl_easy *data)

 {

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

 

   (void)data;

-  DEBUGASSERT(connssl && backend);

-  if(backend->handle && SSL_pending(backend->handle))

+  DEBUGASSERT(connssl && octx);

+  if(octx->ssl && SSL_pending(octx->ssl))

     return TRUE;

   return FALSE;

 }

@@ -4614,19 +4922,18 @@ static ssize_t ossl_send(struct Curl_cfilter *cf,
   int memlen;

   int rc;

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

 

   (void)data;

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

   ERR_clear_error();

 

   memlen = (len > (size_t)INT_MAX) ? INT_MAX : (int)len;

-  rc = SSL_write(backend->handle, mem, memlen);

+  rc = SSL_write(octx->ssl, mem, memlen);

 

   if(rc <= 0) {

-    err = SSL_get_error(backend->handle, rc);

+    err = SSL_get_error(octx->ssl, rc);

 

     switch(err) {

     case SSL_ERROR_WANT_READ:

@@ -4641,7 +4948,7 @@ static ssize_t ossl_send(struct Curl_cfilter *cf,
     {

       int sockerr = SOCKERRNO;

 

-      if(backend->io_result == CURLE_AGAIN) {

+      if(octx->io_result == CURLE_AGAIN) {

         *curlcode = CURLE_AGAIN;

         rc = -1;

         goto out;

@@ -4698,20 +5005,19 @@ static ssize_t ossl_recv(struct Curl_cfilter *cf,
   int buffsize;

   struct connectdata *conn = cf->conn;

   struct ssl_connect_data *connssl = cf->ctx;

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

 

   (void)data;

-  DEBUGASSERT(backend);

+  DEBUGASSERT(octx);

 

   ERR_clear_error();

 

   buffsize = (buffersize > (size_t)INT_MAX) ? INT_MAX : (int)buffersize;

-  nread = (ssize_t)SSL_read(backend->handle, buf, buffsize);

+  nread = (ssize_t)SSL_read(octx->ssl, buf, buffsize);

 

   if(nread <= 0) {

     /* failed SSL_read */

-    int err = SSL_get_error(backend->handle, (int)nread);

+    int err = SSL_get_error(octx->ssl, (int)nread);

 

     switch(err) {

     case SSL_ERROR_NONE: /* this is not an error */

@@ -4733,7 +5039,7 @@ static ssize_t ossl_recv(struct Curl_cfilter *cf,
       /* openssl/ssl.h for SSL_ERROR_SYSCALL says "look at error stack/return

          value/errno" */

       /* https://www.openssl.org/docs/crypto/ERR_get_error.html */

-      if(backend->io_result == CURLE_AGAIN) {

+      if(octx->io_result == CURLE_AGAIN) {

         *curlcode = CURLE_AGAIN;

         nread = -1;

         goto out;

@@ -4924,11 +5230,10 @@ static void *ossl_get_internals(struct ssl_connect_data *connssl,
                                 CURLINFO info)

 {

   /* Legacy: CURLINFO_TLS_SESSION must return an SSL_CTX pointer. */

-  struct ossl_ssl_backend_data *backend =

-    (struct ossl_ssl_backend_data *)connssl->backend;

-  DEBUGASSERT(backend);

+  struct ossl_ctx *octx = (struct ossl_ctx *)connssl->backend;

+  DEBUGASSERT(octx);

   return info == CURLINFO_TLS_SESSION ?

-    (void *)backend->ctx : (void *)backend->handle;

+    (void *)octx->ssl_ctx : (void *)octx->ssl;

 }

 

 static void ossl_free_multi_ssl_backend_data(

@@ -4956,9 +5261,12 @@ const struct Curl_ssl Curl_ssl_openssl = {
 #ifdef HAVE_SSL_CTX_SET_CIPHERSUITES

   SSLSUPP_TLS13_CIPHERSUITES |

 #endif

+#ifdef USE_ECH

+  SSLSUPP_ECH |

+#endif

   SSLSUPP_HTTPS_PROXY,

 

-  sizeof(struct ossl_ssl_backend_data),

+  sizeof(struct ossl_ctx),

 

   ossl_init,                /* init */

   ossl_cleanup,             /* cleanup */

@@ -4974,7 +5282,6 @@ const struct Curl_ssl Curl_ssl_openssl = {
   ossl_get_internals,       /* get_internals */

   ossl_close,               /* close_one */

   ossl_close_all,           /* close_all */

-  ossl_session_free,        /* session_free */

   ossl_set_engine,          /* set_engine */

   ossl_set_engine_default,  /* set_engine_default */

   ossl_engines_list,        /* engines_list */