luna - curl/lib/vtls/vtls.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 *
  10 * This software is licensed as described in the file COPYING, which
  11 * you should have received as part of this distribution. The terms
  12 * are also available at https://curl.se/docs/copyright.html.
  13 *
  14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  15 * copies of the Software, and permit persons to whom the Software is
  16 * furnished to do so, under the terms of the COPYING file.
  17 *
  18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19 * KIND, either express or implied.
  20 *
  21 * SPDX-License-Identifier: curl
  22 *
  23 ***************************************************************************/
  24
  25/* This file is for implementing all "generic" SSL functions that all libcurl
  26   internals should use. It is then responsible for calling the proper
  27   "backend" function.
  28
  29   SSL-functions in libcurl should call functions in this source file, and not
  30   to any specific SSL-layer.
  31
  32   Curl_ssl_ - prefix for generic ones
  33
  34   Note that this source code uses the functions of the configured SSL
  35   backend via the global Curl_ssl instance.
  36
  37   "SSL/TLS Strong Encryption: An Introduction"
  38   https://httpd.apache.org/docs/2.0/ssl/ssl_intro.html
  39*/
  40
  41#include "curl_setup.h"
  42
  43#ifdef HAVE_SYS_TYPES_H
  44#include <sys/types.h>
  45#endif
  46
  47#include "urldata.h"
  48#include "cfilters.h"
  49
  50#include "vtls/vtls.h" /* generic SSL protos etc */
  51#include "vtls/vtls_int.h"
  52#include "vtls/vtls_scache.h"
  53#include "vtls/keylog.h"
  54
  55#include "vtls/openssl.h"        /* OpenSSL versions */
  56#include "vtls/gtls.h"           /* GnuTLS versions */
  57#include "vtls/wolfssl.h"        /* wolfSSL versions */
  58#include "vtls/schannel.h"       /* Schannel SSPI version */
  59#include "vtls/mbedtls.h"        /* mbedTLS versions */
  60#include "vtls/rustls.h"         /* Rustls versions */
  61
  62#include "slist.h"
  63#include "curl_trc.h"
  64#include "strcase.h"
  65#include "url.h"
  66#include "progress.h"
  67#include "curlx/fopen.h"
  68#include "curl_sha256.h"
  69#include "curlx/base64.h"
  70#include "curlx/inet_pton.h"
  71#include "connect.h"
  72#include "select.h"
  73#include "setopt.h"
  74#include "curlx/strdup.h"
  75#include "curlx/strcopy.h"
  76
  77#ifdef USE_APPLE_SECTRUST
  78#include <Security/Security.h>
  79#endif
  80
  81
  82#define CLONE_STRING(var)                    \
  83  do {                                       \
  84    if(source->var) {                        \
  85      dest->var = curlx_strdup(source->var); \
  86      if(!dest->var)                         \
  87        return FALSE;                        \
  88    }                                        \
  89    else                                     \
  90      dest->var = NULL;                      \
  91  } while(0)
  92
  93#define CLONE_BLOB(var)                  \
  94  do {                                   \
  95    if(blobdup(&dest->var, source->var)) \
  96      return FALSE;                      \
  97  } while(0)
  98
  99static CURLcode blobdup(struct curl_blob **dest, struct curl_blob *src)
 100{
 101  DEBUGASSERT(dest);
 102  DEBUGASSERT(!*dest);
 103  if(src) {
 104    /* only if there is data to dupe! */
 105    struct curl_blob *d;
 106    d = curlx_malloc(sizeof(struct curl_blob) + src->len);
 107    if(!d)
 108      return CURLE_OUT_OF_MEMORY;
 109    d->len = src->len;
 110    /* Always duplicate because the connection may survive longer than the
 111       handle that passed in the blob. */
 112    d->flags = CURL_BLOB_COPY;
 113    d->data = (void *)((char *)d + sizeof(struct curl_blob));
 114    memcpy(d->data, src->data, src->len);
 115    *dest = d;
 116  }
 117  return CURLE_OK;
 118}
 119
 120/* returns TRUE if the blobs are identical */
 121static bool blobcmp(struct curl_blob *first, struct curl_blob *second)
 122{
 123  if(!first && !second) /* both are NULL */
 124    return TRUE;
 125  if(!first || !second) /* one is NULL */
 126    return FALSE;
 127  if(first->len != second->len) /* different sizes */
 128    return FALSE;
 129  return !memcmp(first->data, second->data, first->len); /* same data */
 130}
 131
 132#ifdef USE_SSL
 133#if !defined(CURL_DISABLE_HTTP) || !defined(CURL_DISABLE_PROXY)
 134static const struct alpn_spec ALPN_SPEC_H11 = {
 135  { ALPN_HTTP_1_1 }, 1
 136};
 137static const struct alpn_spec ALPN_SPEC_H10_H11 = {
 138  { ALPN_HTTP_1_0, ALPN_HTTP_1_1 }, 2
 139};
 140#ifdef USE_HTTP2
 141static const struct alpn_spec ALPN_SPEC_H2 = {
 142  { ALPN_H2 }, 1
 143};
 144static const struct alpn_spec ALPN_SPEC_H2_H11 = {
 145  { ALPN_H2, ALPN_HTTP_1_1 }, 2
 146};
 147static const struct alpn_spec ALPN_SPEC_H11_H2 = {
 148  { ALPN_HTTP_1_1, ALPN_H2 }, 2
 149};
 150#endif /* USE_HTTP2 */
 151
 152static const struct alpn_spec *alpn_get_spec(http_majors wanted,
 153                                             http_majors preferred,
 154                                             bool only_http_10,
 155                                             bool use_alpn)
 156{
 157  if(!use_alpn)
 158    return NULL;
 159  /* If HTTP/1.0 is the wanted protocol then use ALPN http/1.0 and http/1.1.
 160     This is for compatibility reasons since some HTTP/1.0 servers with old
 161     ALPN implementations understand ALPN http/1.1 but not http/1.0. */
 162  if(only_http_10 && (wanted & CURL_HTTP_V1x))
 163    return &ALPN_SPEC_H10_H11;
 164#ifdef USE_HTTP2
 165  if(wanted & CURL_HTTP_V2x) {
 166    if(wanted & CURL_HTTP_V1x)
 167      return (preferred == CURL_HTTP_V1x) ?
 168        &ALPN_SPEC_H11_H2 : &ALPN_SPEC_H2_H11;
 169    return &ALPN_SPEC_H2;
 170  }
 171#else
 172  (void)wanted;
 173  (void)preferred;
 174#endif
 175  return &ALPN_SPEC_H11;
 176}
 177#endif /* !CURL_DISABLE_HTTP || !CURL_DISABLE_PROXY */
 178#endif /* USE_SSL */
 179
 180void Curl_ssl_easy_config_init(struct Curl_easy *data)
 181{
 182  /*
 183   * libcurl 7.10 introduced SSL verification *by default*! This needs to be
 184   * switched off unless wanted.
 185   */
 186  data->set.ssl.primary.verifypeer = TRUE;
 187  data->set.ssl.primary.verifyhost = TRUE;
 188  data->set.ssl.primary.cache_session = TRUE; /* caching by default */
 189#ifndef CURL_DISABLE_PROXY
 190  data->set.proxy_ssl = data->set.ssl;
 191#endif
 192}
 193
 194static bool match_ssl_primary_config(struct Curl_easy *data,
 195                                     struct ssl_primary_config *c1,
 196                                     struct ssl_primary_config *c2)
 197{
 198  (void)data;
 199  if((c1->version == c2->version) &&
 200     (c1->version_max == c2->version_max) &&
 201     (c1->ssl_options == c2->ssl_options) &&
 202     (c1->verifypeer == c2->verifypeer) &&
 203     (c1->verifyhost == c2->verifyhost) &&
 204     (c1->verifystatus == c2->verifystatus) &&
 205     blobcmp(c1->cert_blob, c2->cert_blob) &&
 206     blobcmp(c1->ca_info_blob, c2->ca_info_blob) &&
 207     blobcmp(c1->issuercert_blob, c2->issuercert_blob) &&
 208     Curl_safecmp(c1->CApath, c2->CApath) &&
 209     Curl_safecmp(c1->CAfile, c2->CAfile) &&
 210     Curl_safecmp(c1->issuercert, c2->issuercert) &&
 211     Curl_safecmp(c1->clientcert, c2->clientcert) &&
 212#ifdef USE_TLS_SRP
 213     !Curl_timestrcmp(c1->username, c2->username) &&
 214     !Curl_timestrcmp(c1->password, c2->password) &&
 215#endif
 216     curl_strequal(c1->cipher_list, c2->cipher_list) &&
 217     curl_strequal(c1->cipher_list13, c2->cipher_list13) &&
 218     curl_strequal(c1->curves, c2->curves) &&
 219     curl_strequal(c1->signature_algorithms, c2->signature_algorithms) &&
 220     curl_strequal(c1->CRLfile, c2->CRLfile) &&
 221     curl_strequal(c1->pinned_key, c2->pinned_key))
 222    return TRUE;
 223
 224  return FALSE;
 225}
 226
 227bool Curl_ssl_conn_config_match(struct Curl_easy *data,
 228                                struct connectdata *candidate,
 229                                bool proxy)
 230{
 231#ifndef CURL_DISABLE_PROXY
 232  if(proxy)
 233    return match_ssl_primary_config(data, &data->set.proxy_ssl.primary,
 234                                    &candidate->proxy_ssl_config);
 235#else
 236  (void)proxy;
 237#endif
 238  return match_ssl_primary_config(data, &data->set.ssl.primary,
 239                                  &candidate->ssl_config);
 240}
 241
 242static bool clone_ssl_primary_config(struct ssl_primary_config *source,
 243                                     struct ssl_primary_config *dest)
 244{
 245  dest->version = source->version;
 246  dest->version_max = source->version_max;
 247  dest->verifypeer = source->verifypeer;
 248  dest->verifyhost = source->verifyhost;
 249  dest->verifystatus = source->verifystatus;
 250  dest->cache_session = source->cache_session;
 251  dest->ssl_options = source->ssl_options;
 252
 253  CLONE_BLOB(cert_blob);
 254  CLONE_BLOB(ca_info_blob);
 255  CLONE_BLOB(issuercert_blob);
 256  CLONE_STRING(CApath);
 257  CLONE_STRING(CAfile);
 258  CLONE_STRING(issuercert);
 259  CLONE_STRING(clientcert);
 260  CLONE_STRING(cipher_list);
 261  CLONE_STRING(cipher_list13);
 262  CLONE_STRING(pinned_key);
 263  CLONE_STRING(curves);
 264  CLONE_STRING(signature_algorithms);
 265  CLONE_STRING(CRLfile);
 266#ifdef USE_TLS_SRP
 267  CLONE_STRING(username);
 268  CLONE_STRING(password);
 269#endif
 270
 271  return TRUE;
 272}
 273
 274static void free_primary_ssl_config(struct ssl_primary_config *sslc)
 275{
 276  curlx_safefree(sslc->CApath);
 277  curlx_safefree(sslc->CAfile);
 278  curlx_safefree(sslc->issuercert);
 279  curlx_safefree(sslc->clientcert);
 280  curlx_safefree(sslc->cipher_list);
 281  curlx_safefree(sslc->cipher_list13);
 282  curlx_safefree(sslc->pinned_key);
 283  curlx_safefree(sslc->cert_blob);
 284  curlx_safefree(sslc->ca_info_blob);
 285  curlx_safefree(sslc->issuercert_blob);
 286  curlx_safefree(sslc->curves);
 287  curlx_safefree(sslc->signature_algorithms);
 288  curlx_safefree(sslc->CRLfile);
 289#ifdef USE_TLS_SRP
 290  curlx_safefree(sslc->username);
 291  curlx_safefree(sslc->password);
 292#endif
 293}
 294
 295CURLcode Curl_ssl_easy_config_complete(struct Curl_easy *data)
 296{
 297  struct ssl_config_data *sslc = &data->set.ssl;
 298#if defined(CURL_CA_PATH) || defined(CURL_CA_BUNDLE)
 299  struct UserDefined *set = &data->set;
 300  CURLcode result;
 301#endif
 302
 303  if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL) {
 304#if defined(USE_APPLE_SECTRUST) || defined(CURL_CA_NATIVE)
 305    if(!sslc->custom_capath && !sslc->custom_cafile && !sslc->custom_cablob)
 306      sslc->native_ca_store = TRUE;
 307#endif
 308#ifdef CURL_CA_PATH
 309    if(!sslc->custom_capath && !set->str[STRING_SSL_CAPATH]) {
 310      result = Curl_setstropt(&set->str[STRING_SSL_CAPATH], CURL_CA_PATH);
 311      if(result)
 312        return result;
 313    }
 314#endif
 315#ifdef CURL_CA_BUNDLE
 316    if(!sslc->custom_cafile && !set->str[STRING_SSL_CAFILE]) {
 317      result = Curl_setstropt(&set->str[STRING_SSL_CAFILE], CURL_CA_BUNDLE);
 318      if(result)
 319        return result;
 320    }
 321#endif
 322  }
 323  sslc->primary.CAfile = data->set.str[STRING_SSL_CAFILE];
 324  sslc->primary.CRLfile = data->set.str[STRING_SSL_CRLFILE];
 325  sslc->primary.CApath = data->set.str[STRING_SSL_CAPATH];
 326  sslc->primary.issuercert = data->set.str[STRING_SSL_ISSUERCERT];
 327  sslc->primary.issuercert_blob = data->set.blobs[BLOB_SSL_ISSUERCERT];
 328  sslc->primary.cipher_list = data->set.str[STRING_SSL_CIPHER_LIST];
 329  sslc->primary.cipher_list13 = data->set.str[STRING_SSL_CIPHER13_LIST];
 330  sslc->primary.signature_algorithms =
 331    data->set.str[STRING_SSL_SIGNATURE_ALGORITHMS];
 332  sslc->primary.pinned_key = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
 333  sslc->primary.cert_blob = data->set.blobs[BLOB_CERT];
 334  sslc->primary.ca_info_blob = data->set.blobs[BLOB_CAINFO];
 335  sslc->primary.curves = data->set.str[STRING_SSL_EC_CURVES];
 336#ifdef USE_TLS_SRP
 337  sslc->primary.username = data->set.str[STRING_TLSAUTH_USERNAME];
 338  sslc->primary.password = data->set.str[STRING_TLSAUTH_PASSWORD];
 339#endif
 340  sslc->cert_type = data->set.str[STRING_CERT_TYPE];
 341  sslc->key = data->set.str[STRING_KEY];
 342  sslc->key_type = data->set.str[STRING_KEY_TYPE];
 343  sslc->key_passwd = data->set.str[STRING_KEY_PASSWD];
 344  sslc->primary.clientcert = data->set.str[STRING_CERT];
 345  sslc->key_blob = data->set.blobs[BLOB_KEY];
 346
 347#ifndef CURL_DISABLE_PROXY
 348  sslc = &data->set.proxy_ssl;
 349  if(Curl_ssl_backend() != CURLSSLBACKEND_SCHANNEL) {
 350#if defined(USE_APPLE_SECTRUST) || defined(CURL_CA_NATIVE)
 351    if(!sslc->custom_capath && !sslc->custom_cafile && !sslc->custom_cablob)
 352      sslc->native_ca_store = TRUE;
 353#endif
 354#ifdef CURL_CA_PATH
 355    if(!sslc->custom_capath && !set->str[STRING_SSL_CAPATH_PROXY]) {
 356      result = Curl_setstropt(&set->str[STRING_SSL_CAPATH_PROXY],
 357                              CURL_CA_PATH);
 358      if(result)
 359        return result;
 360    }
 361#endif
 362#ifdef CURL_CA_BUNDLE
 363    if(!sslc->custom_cafile && !set->str[STRING_SSL_CAFILE_PROXY]) {
 364      result = Curl_setstropt(&set->str[STRING_SSL_CAFILE_PROXY],
 365                              CURL_CA_BUNDLE);
 366      if(result)
 367        return result;
 368    }
 369#endif
 370  }
 371  sslc->primary.CAfile = data->set.str[STRING_SSL_CAFILE_PROXY];
 372  sslc->primary.CApath = data->set.str[STRING_SSL_CAPATH_PROXY];
 373  sslc->primary.cipher_list = data->set.str[STRING_SSL_CIPHER_LIST_PROXY];
 374  sslc->primary.cipher_list13 = data->set.str[STRING_SSL_CIPHER13_LIST_PROXY];
 375  sslc->primary.pinned_key = data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY];
 376  sslc->primary.cert_blob = data->set.blobs[BLOB_CERT_PROXY];
 377  sslc->primary.ca_info_blob = data->set.blobs[BLOB_CAINFO_PROXY];
 378  sslc->primary.issuercert = data->set.str[STRING_SSL_ISSUERCERT_PROXY];
 379  sslc->primary.issuercert_blob = data->set.blobs[BLOB_SSL_ISSUERCERT_PROXY];
 380  sslc->primary.CRLfile = data->set.str[STRING_SSL_CRLFILE_PROXY];
 381  sslc->cert_type = data->set.str[STRING_CERT_TYPE_PROXY];
 382  sslc->key = data->set.str[STRING_KEY_PROXY];
 383  sslc->key_type = data->set.str[STRING_KEY_TYPE_PROXY];
 384  sslc->key_passwd = data->set.str[STRING_KEY_PASSWD_PROXY];
 385  sslc->primary.clientcert = data->set.str[STRING_CERT_PROXY];
 386  sslc->key_blob = data->set.blobs[BLOB_KEY_PROXY];
 387#ifdef USE_TLS_SRP
 388  sslc->primary.username = data->set.str[STRING_TLSAUTH_USERNAME_PROXY];
 389  sslc->primary.password = data->set.str[STRING_TLSAUTH_PASSWORD_PROXY];
 390#endif
 391#endif /* CURL_DISABLE_PROXY */
 392
 393  return CURLE_OK;
 394}
 395
 396CURLcode Curl_ssl_conn_config_init(struct Curl_easy *data,
 397                                   struct connectdata *conn)
 398{
 399  /* Clone "primary" SSL configurations from the easy handle to
 400   * the connection. They are used for connection cache matching and
 401   * probably outlive the easy handle */
 402  if(!clone_ssl_primary_config(&data->set.ssl.primary, &conn->ssl_config))
 403    return CURLE_OUT_OF_MEMORY;
 404#ifndef CURL_DISABLE_PROXY
 405  if(!clone_ssl_primary_config(&data->set.proxy_ssl.primary,
 406                               &conn->proxy_ssl_config))
 407    return CURLE_OUT_OF_MEMORY;
 408#endif
 409  return CURLE_OK;
 410}
 411
 412void Curl_ssl_conn_config_cleanup(struct connectdata *conn)
 413{
 414  free_primary_ssl_config(&conn->ssl_config);
 415#ifndef CURL_DISABLE_PROXY
 416  free_primary_ssl_config(&conn->proxy_ssl_config);
 417#endif
 418}
 419
 420void Curl_ssl_conn_config_update(struct Curl_easy *data, bool for_proxy)
 421{
 422  /* May be called on an easy that has no connection yet */
 423  if(data->conn) {
 424    struct ssl_primary_config *src, *dest;
 425#ifndef CURL_DISABLE_PROXY
 426    src = for_proxy ? &data->set.proxy_ssl.primary : &data->set.ssl.primary;
 427    dest = for_proxy ? &data->conn->proxy_ssl_config : &data->conn->ssl_config;
 428#else
 429    (void)for_proxy;
 430    src = &data->set.ssl.primary;
 431    dest = &data->conn->ssl_config;
 432#endif
 433    dest->verifyhost = src->verifyhost;
 434    dest->verifypeer = src->verifypeer;
 435    dest->verifystatus = src->verifystatus;
 436  }
 437}
 438
 439#ifdef USE_SSL
 440static int multissl_setup(const struct Curl_ssl *backend);
 441#endif
 442
 443curl_sslbackend Curl_ssl_backend(void)
 444{
 445#ifdef USE_SSL
 446  multissl_setup(NULL);
 447  return Curl_ssl->info.id;
 448#else
 449  return CURLSSLBACKEND_NONE;
 450#endif
 451}
 452
 453#ifdef USE_SSL
 454
 455/* "global" init done? */
 456static bool init_ssl = FALSE;
 457
 458/**
 459 * Global SSL init
 460 *
 461 * @retval 0 error initializing SSL
 462 * @retval 1 SSL initialized successfully
 463 */
 464int Curl_ssl_init(void)
 465{
 466  /* make sure this is only done once */
 467  if(init_ssl)
 468    return 1;
 469  init_ssl = TRUE; /* never again */
 470
 471  if(Curl_ssl->init)
 472    return Curl_ssl->init();
 473  return 1;
 474}
 475
 476static bool ssl_prefs_check(struct Curl_easy *data)
 477{
 478  /* check for CURLOPT_SSLVERSION invalid parameter value */
 479  const unsigned char sslver = data->set.ssl.primary.version;
 480  if(sslver >= CURL_SSLVERSION_LAST) {
 481    failf(data, "Unrecognized parameter value passed via CURLOPT_SSLVERSION");
 482    return FALSE;
 483  }
 484
 485  switch(data->set.ssl.primary.version_max) {
 486  case CURL_SSLVERSION_MAX_NONE:
 487  case CURL_SSLVERSION_MAX_DEFAULT:
 488    break;
 489
 490  default:
 491    if((data->set.ssl.primary.version_max >> 16) < sslver) {
 492      failf(data, "CURL_SSLVERSION_MAX incompatible with CURL_SSLVERSION");
 493      return FALSE;
 494    }
 495  }
 496
 497  return TRUE;
 498}
 499
 500static struct ssl_connect_data *cf_ctx_new(struct Curl_easy *data,
 501                                           const struct alpn_spec *alpn)
 502{
 503  struct ssl_connect_data *ctx;
 504
 505  (void)data;
 506  ctx = curlx_calloc(1, sizeof(*ctx));
 507  if(!ctx)
 508    return NULL;
 509
 510  ctx->ssl_impl = Curl_ssl;
 511  ctx->alpn = alpn;
 512  Curl_bufq_init2(&ctx->earlydata, CURL_SSL_EARLY_MAX, 1, BUFQ_OPT_NO_SPARES);
 513  ctx->backend = curlx_calloc(1, ctx->ssl_impl->sizeof_ssl_backend_data);
 514  if(!ctx->backend) {
 515    curlx_free(ctx);
 516    return NULL;
 517  }
 518  return ctx;
 519}
 520
 521static void cf_ctx_free(struct ssl_connect_data *ctx)
 522{
 523  if(ctx) {
 524    curlx_safefree(ctx->negotiated.alpn);
 525    Curl_bufq_free(&ctx->earlydata);
 526    curlx_free(ctx->backend);
 527    curlx_free(ctx);
 528  }
 529}
 530
 531CURLcode Curl_ssl_get_channel_binding(struct Curl_easy *data, int sockindex,
 532                                      struct dynbuf *binding)
 533{
 534  if(Curl_ssl->get_channel_binding)
 535    return Curl_ssl->get_channel_binding(data, sockindex, binding);
 536  return CURLE_OK;
 537}
 538
 539void Curl_ssl_close_all(struct Curl_easy *data)
 540{
 541  if(Curl_ssl->close_all)
 542    Curl_ssl->close_all(data);
 543}
 544
 545CURLcode Curl_ssl_adjust_pollset(struct Curl_cfilter *cf,
 546                                 struct Curl_easy *data,
 547                                 struct easy_pollset *ps)
 548{
 549  struct ssl_connect_data *connssl = cf->ctx;
 550
 551  if(connssl->io_need) {
 552    curl_socket_t sock = Curl_conn_cf_get_socket(cf->next, data);
 553    CURLcode result = CURLE_OK;
 554    if(sock != CURL_SOCKET_BAD) {
 555      if(connssl->io_need & CURL_SSL_IO_NEED_SEND) {
 556        result = Curl_pollset_set_out_only(data, ps, sock);
 557        CURL_TRC_CF(data, cf, "adjust_pollset, POLLOUT fd=%" FMT_SOCKET_T,
 558                    sock);
 559      }
 560      else {
 561        result = Curl_pollset_set_in_only(data, ps, sock);
 562        CURL_TRC_CF(data, cf, "adjust_pollset, POLLIN fd=%" FMT_SOCKET_T,
 563                    sock);
 564      }
 565    }
 566    return result;
 567  }
 568  return CURLE_OK;
 569}
 570
 571/* Selects an SSL crypto engine
 572 */
 573CURLcode Curl_ssl_set_engine(struct Curl_easy *data, const char *engine)
 574{
 575  if(Curl_ssl->set_engine)
 576    return Curl_ssl->set_engine(data, engine);
 577  return CURLE_NOT_BUILT_IN;
 578}
 579
 580/* Selects the default SSL crypto engine
 581 */
 582CURLcode Curl_ssl_set_engine_default(struct Curl_easy *data)
 583{
 584  if(Curl_ssl->set_engine_default)
 585    return Curl_ssl->set_engine_default(data);
 586  return CURLE_NOT_BUILT_IN;
 587}
 588
 589/* Return list of OpenSSL crypto engine names. */
 590struct curl_slist *Curl_ssl_engines_list(struct Curl_easy *data)
 591{
 592  if(Curl_ssl->engines_list)
 593    return Curl_ssl->engines_list(data);
 594  return NULL;
 595}
 596
 597static size_t multissl_version(char *buffer, size_t size);
 598
 599void Curl_ssl_version(char *buffer, size_t size)
 600{
 601#ifdef CURL_WITH_MULTI_SSL
 602  (void)multissl_version(buffer, size);
 603#else
 604  (void)Curl_ssl->version(buffer, size);
 605#endif
 606}
 607
 608void Curl_ssl_free_certinfo(struct Curl_easy *data)
 609{
 610  struct curl_certinfo *ci = &data->info.certs;
 611
 612  if(ci->num_of_certs) {
 613    /* free all individual lists used */
 614    int i;
 615    for(i = 0; i < ci->num_of_certs; i++) {
 616      curl_slist_free_all(ci->certinfo[i]);
 617      ci->certinfo[i] = NULL;
 618    }
 619
 620    curlx_free(ci->certinfo); /* free the actual array too */
 621    ci->certinfo = NULL;
 622    ci->num_of_certs = 0;
 623  }
 624}
 625
 626CURLcode Curl_ssl_init_certinfo(struct Curl_easy *data, int num)
 627{
 628  struct curl_certinfo *ci = &data->info.certs;
 629  struct curl_slist **table;
 630
 631  /* Free any previous certificate information structures */
 632  Curl_ssl_free_certinfo(data);
 633
 634  /* Allocate the required certificate information structures */
 635  table = curlx_calloc((size_t)num, sizeof(struct curl_slist *));
 636  if(!table)
 637    return CURLE_OUT_OF_MEMORY;
 638
 639  ci->num_of_certs = num;
 640  ci->certinfo = table;
 641
 642  return CURLE_OK;
 643}
 644
 645/*
 646 * 'value' is NOT a null-terminated string
 647 */
 648CURLcode Curl_ssl_push_certinfo_len(struct Curl_easy *data,
 649                                    int certnum,
 650                                    const char *label,
 651                                    const char *value,
 652                                    size_t valuelen)
 653{
 654  struct curl_certinfo *ci = &data->info.certs;
 655  struct curl_slist *nl;
 656  CURLcode result = CURLE_OK;
 657  struct dynbuf build;
 658
 659  DEBUGASSERT(certnum < ci->num_of_certs);
 660
 661  curlx_dyn_init(&build, CURL_X509_STR_MAX);
 662
 663  if(curlx_dyn_add(&build, label) ||
 664     curlx_dyn_addn(&build, ":", 1) ||
 665     curlx_dyn_addn(&build, value, valuelen))
 666    return CURLE_OUT_OF_MEMORY;
 667
 668  nl = Curl_slist_append_nodup(ci->certinfo[certnum], curlx_dyn_ptr(&build));
 669  if(!nl) {
 670    curlx_dyn_free(&build);
 671    curl_slist_free_all(ci->certinfo[certnum]);
 672    result = CURLE_OUT_OF_MEMORY;
 673  }
 674
 675  ci->certinfo[certnum] = nl;
 676  return result;
 677}
 678
 679/* get length bytes of randomness */
 680CURLcode Curl_ssl_random(struct Curl_easy *data,
 681                         unsigned char *buffer, size_t length)
 682{
 683  DEBUGASSERT(length == sizeof(int));
 684  if(Curl_ssl->random)
 685    return Curl_ssl->random(data, buffer, length);
 686  else
 687    return CURLE_NOT_BUILT_IN;
 688}
 689
 690/*
 691 * Public key pem to der conversion
 692 */
 693
 694static CURLcode pubkey_pem_to_der(const char *pem,
 695                                  unsigned char **der, size_t *der_len)
 696{
 697  const char *begin_pos, *end_pos;
 698  size_t pem_count, pem_len;
 699  CURLcode result;
 700  struct dynbuf pbuf;
 701
 702  /* if no pem, exit. */
 703  if(!pem)
 704    return CURLE_BAD_CONTENT_ENCODING;
 705
 706  curlx_dyn_init(&pbuf, MAX_PINNED_PUBKEY_SIZE);
 707
 708  begin_pos = strstr(pem, "-----BEGIN PUBLIC KEY-----");
 709  if(!begin_pos)
 710    return CURLE_BAD_CONTENT_ENCODING;
 711
 712  pem_count = begin_pos - pem;
 713  /* Invalid if not at beginning AND not directly following \n */
 714  if(pem_count && '\n' != pem[pem_count - 1])
 715    return CURLE_BAD_CONTENT_ENCODING;
 716
 717  /* 26 is length of "-----BEGIN PUBLIC KEY-----" */
 718  pem_count += 26;
 719
 720  /* Invalid if not directly following \n */
 721  end_pos = strstr(pem + pem_count, "\n-----END PUBLIC KEY-----");
 722  if(!end_pos)
 723    return CURLE_BAD_CONTENT_ENCODING;
 724
 725  pem_len = end_pos - pem;
 726
 727  /*
 728   * Here we loop through the pem array one character at a time between the
 729   * correct indices, and place each character that is not '\n' or '\r'
 730   * into the stripped_pem array, which should represent the raw base64 string
 731   */
 732  while(pem_count < pem_len) {
 733    if('\n' != pem[pem_count] && '\r' != pem[pem_count]) {
 734      result = curlx_dyn_addn(&pbuf, &pem[pem_count], 1);
 735      if(result)
 736        return result;
 737    }
 738    ++pem_count;
 739  }
 740
 741  if(curlx_dyn_len(&pbuf)) {
 742    result = curlx_base64_decode(curlx_dyn_ptr(&pbuf), der, der_len);
 743    curlx_dyn_free(&pbuf);
 744  }
 745  else
 746    result = CURLE_BAD_CONTENT_ENCODING;
 747
 748  return result;
 749}
 750
 751/*
 752 * Generic pinned public key check.
 753 */
 754
 755CURLcode Curl_pin_peer_pubkey(struct Curl_easy *data,
 756                              const char *pinnedpubkey,
 757                              const unsigned char *pubkey, size_t pubkeylen)
 758{
 759  CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
 760
 761  /* if a path was not specified, do not pin */
 762  if(!pinnedpubkey)
 763    return CURLE_OK;
 764  if(!pubkey || !pubkeylen)
 765    return result;
 766
 767  /* only do this if pinnedpubkey starts with "sha256//", length 8 */
 768  if(!strncmp(pinnedpubkey, "sha256//", 8)) {
 769    CURLcode encode;
 770    char *cert_hash = NULL;
 771    const char *pinned_hash, *end_pos;
 772    size_t cert_hash_len = 0, pinned_hash_len;
 773    unsigned char *sha256sumdigest;
 774
 775    if(!Curl_ssl->sha256sum) {
 776      /* without sha256 support, this cannot match */
 777      return result;
 778    }
 779
 780    /* compute sha256sum of public key */
 781    sha256sumdigest = curlx_malloc(CURL_SHA256_DIGEST_LENGTH);
 782    if(!sha256sumdigest)
 783      return CURLE_OUT_OF_MEMORY;
 784    encode = Curl_ssl->sha256sum(pubkey, pubkeylen,
 785                                 sha256sumdigest, CURL_SHA256_DIGEST_LENGTH);
 786
 787    if(!encode)
 788      encode = curlx_base64_encode(sha256sumdigest,
 789                                   CURL_SHA256_DIGEST_LENGTH,
 790                                   &cert_hash, &cert_hash_len);
 791    curlx_safefree(sha256sumdigest);
 792
 793    if(encode)
 794      return encode;
 795
 796    infof(data, " public key hash: sha256//%s", cert_hash);
 797
 798    pinned_hash = pinnedpubkey;
 799    while(pinned_hash &&
 800          !strncmp(pinned_hash, "sha256//", (sizeof("sha256//") - 1))) {
 801      pinned_hash = pinned_hash + (sizeof("sha256//") - 1);
 802      end_pos = strchr(pinned_hash, ';');
 803      pinned_hash_len = end_pos ?
 804                        (size_t)(end_pos - pinned_hash) : strlen(pinned_hash);
 805
 806      /* compare base64 sha256 digests */
 807      if(cert_hash_len == pinned_hash_len &&
 808         !memcmp(cert_hash, pinned_hash, cert_hash_len)) {
 809        DEBUGF(infof(data, "public key hash matches pinned value"));
 810        result = CURLE_OK;
 811        break;
 812      }
 813
 814      DEBUGF(infof(data, "public key hash does not match 'sha256//%.*s'",
 815                   (int)pinned_hash_len, pinned_hash));
 816      /* next one or we are at the end */
 817      pinned_hash = end_pos ? (end_pos + 1) : NULL;
 818    }
 819    curlx_safefree(cert_hash);
 820  }
 821  else {
 822    long filesize;
 823    size_t size, pem_len;
 824    CURLcode pem_read;
 825    struct dynbuf buf;
 826    unsigned char *pem_ptr = NULL;
 827    size_t left;
 828    FILE *fp = curlx_fopen(pinnedpubkey, "rb");
 829    if(!fp)
 830      return result;
 831
 832    curlx_dyn_init(&buf, MAX_PINNED_PUBKEY_SIZE);
 833
 834    /* Determine the file's size */
 835    if(fseek(fp, 0, SEEK_END))
 836      goto end;
 837    filesize = ftell(fp);
 838    if(fseek(fp, 0, SEEK_SET))
 839      goto end;
 840    if(filesize < 0 || filesize > MAX_PINNED_PUBKEY_SIZE)
 841      goto end;
 842
 843    /*
 844     * if the size of our certificate is bigger than the file
 845     * size then it cannot match
 846     */
 847    size = curlx_sotouz((curl_off_t)filesize);
 848    if(pubkeylen > size)
 849      goto end;
 850
 851    /*
 852     * Read the file into the dynbuf
 853     */
 854    left = size;
 855    do {
 856      char buffer[1024];
 857      size_t want = left > sizeof(buffer) ? sizeof(buffer) : left;
 858      if(want != fread(buffer, 1, want, fp))
 859        goto end;
 860      if(curlx_dyn_addn(&buf, buffer, want))
 861        goto end;
 862      left -= want;
 863    } while(left);
 864
 865    /* If the sizes are the same, it cannot be base64 encoded, must be der */
 866    if(pubkeylen == size) {
 867      if(!memcmp(pubkey, curlx_dyn_ptr(&buf), pubkeylen))
 868        result = CURLE_OK;
 869      goto end;
 870    }
 871
 872    /*
 873     * Otherwise we assume it is PEM and try to decode it after placing
 874     * null-terminator
 875     */
 876    pem_read = pubkey_pem_to_der(curlx_dyn_ptr(&buf), &pem_ptr, &pem_len);
 877    /* if it was not read successfully, exit */
 878    if(pem_read)
 879      goto end;
 880
 881    /*
 882     * if the size of our certificate does not match the size of
 883     * the decoded file, they cannot be the same, otherwise compare
 884     */
 885    if(pubkeylen == pem_len && !memcmp(pubkey, pem_ptr, pubkeylen))
 886      result = CURLE_OK;
 887end:
 888    curlx_dyn_free(&buf);
 889    curlx_safefree(pem_ptr);
 890    curlx_fclose(fp);
 891  }
 892
 893  return result;
 894}
 895
 896/*
 897 * Check whether the SSL backend supports the status_request extension.
 898 */
 899bool Curl_ssl_cert_status_request(void)
 900{
 901  if(Curl_ssl->cert_status_request)
 902    return Curl_ssl->cert_status_request();
 903  return FALSE;
 904}
 905
 906static int multissl_init(void)
 907{
 908  if(multissl_setup(NULL))
 909    return 1;
 910  if(Curl_ssl->init)
 911    return Curl_ssl->init();
 912  return 1;
 913}
 914
 915static CURLcode multissl_random(struct Curl_easy *data,
 916                                unsigned char *entropy, size_t length)
 917{
 918  if(multissl_setup(NULL))
 919    return CURLE_FAILED_INIT;
 920  return Curl_ssl->random(data, entropy, length);
 921}
 922
 923static CURLcode multissl_connect(struct Curl_cfilter *cf,
 924                                 struct Curl_easy *data, bool *done)
 925{
 926  if(multissl_setup(NULL))
 927    return CURLE_FAILED_INIT;
 928  return Curl_ssl->do_connect(cf, data, done);
 929}
 930
 931static CURLcode multissl_adjust_pollset(struct Curl_cfilter *cf,
 932                                        struct Curl_easy *data,
 933                                        struct easy_pollset *ps)
 934{
 935  if(multissl_setup(NULL))
 936    return CURLE_OK;
 937  return Curl_ssl->adjust_pollset(cf, data, ps);
 938}
 939
 940static void *multissl_get_internals(struct ssl_connect_data *connssl,
 941                                    CURLINFO info)
 942{
 943  if(multissl_setup(NULL))
 944    return NULL;
 945  return Curl_ssl->get_internals(connssl, info);
 946}
 947
 948static void multissl_close(struct Curl_cfilter *cf, struct Curl_easy *data)
 949{
 950  if(multissl_setup(NULL))
 951    return;
 952  Curl_ssl->close(cf, data);
 953}
 954
 955static CURLcode multissl_recv_plain(struct Curl_cfilter *cf,
 956                                    struct Curl_easy *data,
 957                                    char *buf, size_t len, size_t *pnread)
 958{
 959  if(multissl_setup(NULL))
 960    return CURLE_FAILED_INIT;
 961  return Curl_ssl->recv_plain(cf, data, buf, len, pnread);
 962}
 963
 964static CURLcode multissl_send_plain(struct Curl_cfilter *cf,
 965                                    struct Curl_easy *data,
 966                                    const void *mem, size_t len,
 967                                    size_t *pnwritten)
 968{
 969  if(multissl_setup(NULL))
 970    return CURLE_FAILED_INIT;
 971  return Curl_ssl->send_plain(cf, data, mem, len, pnwritten);
 972}
 973
 974static const struct Curl_ssl Curl_ssl_multi = {
 975  { CURLSSLBACKEND_NONE, "multi" },  /* info */
 976  0, /* supports nothing */
 977  (size_t)-1, /* something insanely large to be on the safe side */
 978
 979  multissl_init,                     /* init */
 980  NULL,                              /* cleanup */
 981  multissl_version,                  /* version */
 982  NULL,                              /* shutdown */
 983  NULL,                              /* data_pending */
 984  multissl_random,                   /* random */
 985  NULL,                              /* cert_status_request */
 986  multissl_connect,                  /* connect */
 987  multissl_adjust_pollset,           /* adjust_pollset */
 988  multissl_get_internals,            /* get_internals */
 989  multissl_close,                    /* close_one */
 990  NULL,                              /* close_all */
 991  NULL,                              /* set_engine */
 992  NULL,                              /* set_engine_default */
 993  NULL,                              /* engines_list */
 994  NULL,                              /* sha256sum */
 995  multissl_recv_plain,               /* recv decrypted data */
 996  multissl_send_plain,               /* send data to encrypt */
 997  NULL,                              /* get_channel_binding */
 998};
 999
1000const struct Curl_ssl *Curl_ssl =
1001#ifdef CURL_WITH_MULTI_SSL
1002  &Curl_ssl_multi;
1003#elif defined(USE_WOLFSSL)
1004  &Curl_ssl_wolfssl;
1005#elif defined(USE_GNUTLS)
1006  &Curl_ssl_gnutls;
1007#elif defined(USE_MBEDTLS)
1008  &Curl_ssl_mbedtls;
1009#elif defined(USE_RUSTLS)
1010  &Curl_ssl_rustls;
1011#elif defined(USE_OPENSSL)
1012  &Curl_ssl_openssl;
1013#elif defined(USE_SCHANNEL)
1014  &Curl_ssl_schannel;
1015#else
1016#error "Missing struct Curl_ssl for selected SSL backend"
1017#endif
1018
1019static const struct Curl_ssl *available_backends[] = {
1020#ifdef USE_WOLFSSL
1021  &Curl_ssl_wolfssl,
1022#endif
1023#ifdef USE_GNUTLS
1024  &Curl_ssl_gnutls,
1025#endif
1026#ifdef USE_MBEDTLS
1027  &Curl_ssl_mbedtls,
1028#endif
1029#ifdef USE_OPENSSL
1030  &Curl_ssl_openssl,
1031#endif
1032#ifdef USE_SCHANNEL
1033  &Curl_ssl_schannel,
1034#endif
1035#ifdef USE_RUSTLS
1036  &Curl_ssl_rustls,
1037#endif
1038  NULL
1039};
1040
1041/* Global cleanup */
1042void Curl_ssl_cleanup(void)
1043{
1044  if(init_ssl) {
1045    /* only cleanup if we did a previous init */
1046    if(Curl_ssl->cleanup)
1047      Curl_ssl->cleanup();
1048#ifdef CURL_WITH_MULTI_SSL
1049    Curl_ssl = &Curl_ssl_multi;
1050#endif
1051    init_ssl = FALSE;
1052  }
1053}
1054
1055static size_t multissl_version(char *buffer, size_t size)
1056{
1057  static const struct Curl_ssl *selected;
1058  static char backends[200];
1059  static size_t backends_len;
1060  const struct Curl_ssl *current;
1061
1062  current = Curl_ssl == &Curl_ssl_multi ? available_backends[0] : Curl_ssl;
1063
1064  if(current != selected) {
1065    char *p = backends;
1066    const char *end = backends + sizeof(backends);
1067    int i;
1068
1069    selected = current;
1070
1071    backends[0] = '\0';
1072
1073    for(i = 0; available_backends[i]; ++i) {
1074      char vb[200];
1075      bool paren = (selected != available_backends[i]);
1076
1077      if(available_backends[i]->version(vb, sizeof(vb))) {
1078        p += curl_msnprintf(p, end - p, "%s%s%s%s", (p != backends ? " " : ""),
1079                            (paren ? "(" : ""), vb, (paren ? ")" : ""));
1080      }
1081    }
1082
1083    backends_len = p - backends;
1084  }
1085
1086  if(size) {
1087    curlx_strcopy(buffer, size, backends, backends_len);
1088  }
1089  return 0;
1090}
1091
1092static int multissl_setup(const struct Curl_ssl *backend)
1093{
1094  int i;
1095  char *env;
1096
1097  if(Curl_ssl != &Curl_ssl_multi)
1098    return 1;
1099
1100  if(backend) {
1101    Curl_ssl = backend;
1102    return 0;
1103  }
1104
1105  if(!available_backends[0])
1106    return 1;
1107
1108  env = curl_getenv("CURL_SSL_BACKEND");
1109  if(env) {
1110    for(i = 0; available_backends[i]; i++) {
1111      if(curl_strequal(env, available_backends[i]->info.name)) {
1112        Curl_ssl = available_backends[i];
1113        curlx_free(env);
1114        return 0;
1115      }
1116    }
1117  }
1118
1119#ifdef CURL_DEFAULT_SSL_BACKEND
1120  for(i = 0; available_backends[i]; i++) {
1121    if(curl_strequal(CURL_DEFAULT_SSL_BACKEND,
1122                     available_backends[i]->info.name)) {
1123      Curl_ssl = available_backends[i];
1124      curlx_free(env);
1125      return 0;
1126    }
1127  }
1128#endif
1129
1130  /* Fall back to first available backend */
1131  Curl_ssl = available_backends[0];
1132  curlx_free(env);
1133  return 0;
1134}
1135
1136/* This function is used to select the SSL backend to use. It is called by
1137   curl_global_sslset (easy.c) which uses the global init lock. */
1138CURLsslset Curl_init_sslset_nolock(curl_sslbackend id, const char *name,
1139                                   const curl_ssl_backend ***avail)
1140{
1141  int i;
1142
1143  if(avail)
1144    *avail = (const curl_ssl_backend **)&available_backends;
1145
1146  if(Curl_ssl != &Curl_ssl_multi)
1147    return id == Curl_ssl->info.id ||
1148           (name && curl_strequal(name, Curl_ssl->info.name)) ?
1149           CURLSSLSET_OK :
1150#ifdef CURL_WITH_MULTI_SSL
1151           CURLSSLSET_TOO_LATE;
1152#else
1153           CURLSSLSET_UNKNOWN_BACKEND;
1154#endif
1155
1156  for(i = 0; available_backends[i]; i++) {
1157    if(available_backends[i]->info.id == id ||
1158       (name && curl_strequal(available_backends[i]->info.name, name))) {
1159      multissl_setup(available_backends[i]);
1160      return CURLSSLSET_OK;
1161    }
1162  }
1163
1164  return CURLSSLSET_UNKNOWN_BACKEND;
1165}
1166
1167#else /* USE_SSL */
1168CURLsslset Curl_init_sslset_nolock(curl_sslbackend id, const char *name,
1169                                   const curl_ssl_backend ***avail)
1170{
1171  (void)id;
1172  (void)name;
1173  (void)avail;
1174  return CURLSSLSET_NO_BACKENDS;
1175}
1176
1177#endif /* !USE_SSL */
1178
1179#ifdef USE_SSL
1180
1181void Curl_ssl_peer_cleanup(struct ssl_peer *peer)
1182{
1183  Curl_peer_unlink(&peer->dest);
1184  curlx_safefree(peer->sni);
1185  curlx_safefree(peer->scache_key);
1186  peer->type = CURL_SSL_PEER_DNS;
1187}
1188
1189static void cf_close(struct Curl_cfilter *cf, struct Curl_easy *data)
1190{
1191  struct ssl_connect_data *connssl = cf->ctx;
1192  if(connssl) {
1193    connssl->ssl_impl->close(cf, data);
1194    connssl->state = ssl_connection_none;
1195    Curl_ssl_peer_cleanup(&connssl->peer);
1196  }
1197  cf->connected = FALSE;
1198}
1199
1200static ssl_peer_type get_peer_type(const char *hostname)
1201{
1202  if(hostname && hostname[0]) {
1203#ifdef USE_IPV6
1204    struct in6_addr addr;
1205#else
1206    struct in_addr addr;
1207#endif
1208    if(curlx_inet_pton(AF_INET, hostname, &addr))
1209      return CURL_SSL_PEER_IPV4;
1210#ifdef USE_IPV6
1211    else if(curlx_inet_pton(AF_INET6, hostname, &addr)) {
1212      return CURL_SSL_PEER_IPV6;
1213    }
1214#endif
1215  }
1216  return CURL_SSL_PEER_DNS;
1217}
1218
1219CURLcode Curl_ssl_peer_init(struct ssl_peer *peer,
1220                            struct Curl_cfilter *cf,
1221                            const char *tls_id,
1222                            uint8_t transport)
1223{
1224  struct Curl_peer *dest = NULL;
1225  CURLcode result = CURLE_OUT_OF_MEMORY;
1226
1227  /* We expect a clean struct, e.g. called only ONCE */
1228  DEBUGASSERT(peer);
1229  DEBUGASSERT(!peer->dest);
1230  DEBUGASSERT(!peer->sni);
1231  /* We need the hostname for SNI negotiation. Once handshaked, this remains
1232   * the SNI hostname for the TLS connection. When the connection is reused,
1233   * the settings in cf->conn might change. We keep a copy of the hostname we
1234   * use for SNI.
1235   */
1236  peer->transport = transport;
1237#ifndef CURL_DISABLE_PROXY
1238  if(Curl_ssl_cf_is_proxy(cf)) {
1239    dest = cf->conn->http_proxy.peer;
1240  }
1241  else
1242#endif
1243  {
1244    dest = cf->conn->origin;
1245  }
1246
1247  /* hostname MUST exist and not be empty */
1248  if(!dest) {
1249    result = CURLE_FAILED_INIT;
1250    goto out;
1251  }
1252
1253  Curl_peer_link(&peer->dest, dest);
1254  peer->type = get_peer_type(dest->hostname);
1255  if(peer->type == CURL_SSL_PEER_DNS) {
1256    /* not an IP address, normalize according to RCC 6066 ch. 3,
1257     * max len of SNI is 2^16-1, no trailing dot */
1258    size_t len = strlen(dest->hostname);
1259    if(len && (dest->hostname[len - 1] == '.'))
1260      len--;
1261    if(len < USHRT_MAX) {
1262      peer->sni = curlx_calloc(1, len + 1);
1263      if(!peer->sni)
1264        goto out;
1265      Curl_strntolower(peer->sni, dest->hostname, len);
1266      peer->sni[len] = 0;
1267    }
1268  }
1269
1270  result = Curl_ssl_peer_key_make(cf, peer, tls_id, &peer->scache_key);
1271
1272out:
1273  if(result)
1274    Curl_ssl_peer_cleanup(peer);
1275  return result;
1276}
1277
1278static void ssl_cf_destroy(struct Curl_cfilter *cf, struct Curl_easy *data)
1279{
1280  struct cf_call_data save;
1281
1282  CF_DATA_SAVE(save, cf, data);
1283  cf_close(cf, data);
1284  CF_DATA_RESTORE(cf, save);
1285  cf_ctx_free(cf->ctx);
1286  cf->ctx = NULL;
1287}
1288
1289static void ssl_cf_close(struct Curl_cfilter *cf,
1290                         struct Curl_easy *data)
1291{
1292  struct cf_call_data save;
1293
1294  CF_DATA_SAVE(save, cf, data);
1295  cf_close(cf, data);
1296  if(cf->next)
1297    cf->next->cft->do_close(cf->next, data);
1298  CF_DATA_RESTORE(cf, save);
1299}
1300
1301static CURLcode ssl_cf_connect(struct Curl_cfilter *cf,
1302                               struct Curl_easy *data,
1303                               bool *done)
1304{
1305  struct ssl_connect_data *connssl = cf->ctx;
1306  struct cf_call_data save;
1307  CURLcode result;
1308
1309  if(cf->connected && (connssl->state != ssl_connection_deferred)) {
1310    *done = TRUE;
1311    return CURLE_OK;
1312  }
1313
1314  if(!cf->next) {
1315    *done = FALSE;
1316    return CURLE_FAILED_INIT;
1317  }
1318
1319  if(!cf->next->connected) {
1320    result = cf->next->cft->do_connect(cf->next, data, done);
1321    if(result || !*done)
1322      return result;
1323  }
1324
1325  CF_DATA_SAVE(save, cf, data);
1326  CURL_TRC_CF(data, cf, "cf_connect()");
1327  DEBUGASSERT(connssl);
1328
1329  *done = FALSE;
1330
1331  if(!connssl->prefs_checked) {
1332    if(!ssl_prefs_check(data)) {
1333      result = CURLE_SSL_CONNECT_ERROR;
1334      goto out;
1335    }
1336    connssl->prefs_checked = TRUE;
1337  }
1338
1339  if(!connssl->peer.dest) {
1340    char tls_id[80];
1341    connssl->ssl_impl->version(tls_id, sizeof(tls_id) - 1);
1342    result = Curl_ssl_peer_init(&connssl->peer, cf, tls_id, TRNSPRT_TCP);
1343    if(result)
1344      goto out;
1345  }
1346
1347  result = connssl->ssl_impl->do_connect(cf, data, done);
1348
1349  if(!result && *done) {
1350    cf->connected = TRUE;
1351    if(connssl->state == ssl_connection_complete) {
1352      connssl->handshake_done = *Curl_pgrs_now(data);
1353    }
1354    if(Curl_tls_keylog_enabled()) {
1355      infof(data, "SSLKEYLOGFILE set, all TLS secrets are logged to '%s'",
1356            Curl_tls_keylog_file_name());
1357#ifdef LIBRESSL_VERSION_NUMBER
1358      infof(data, "Note LibreSSL only supports SSLKEYLOGFILE for TLS <= 1.2");
1359#endif
1360    }
1361    /* Connection can be deferred when sending early data */
1362    DEBUGASSERT(connssl->state == ssl_connection_complete ||
1363                connssl->state == ssl_connection_deferred);
1364    DEBUGASSERT(connssl->state != ssl_connection_deferred ||
1365                connssl->earlydata_state > ssl_earlydata_none);
1366  }
1367out:
1368  CURL_TRC_CF(data, cf, "cf_connect() -> %d, done=%d", result, *done);
1369  CF_DATA_RESTORE(cf, save);
1370  return result;
1371}
1372
1373static CURLcode ssl_cf_set_earlydata(struct Curl_cfilter *cf,
1374                                     struct Curl_easy *data,
1375                                     const void *buf, size_t blen)
1376{
1377  struct ssl_connect_data *connssl = cf->ctx;
1378  size_t nwritten = 0;
1379  CURLcode result = CURLE_OK;
1380
1381  DEBUGASSERT(connssl->earlydata_state == ssl_earlydata_await);
1382  DEBUGASSERT(Curl_bufq_is_empty(&connssl->earlydata));
1383  if(blen) {
1384    if(blen > connssl->earlydata_max)
1385      blen = connssl->earlydata_max;
1386    result = Curl_bufq_write(&connssl->earlydata, buf, blen, &nwritten);
1387    CURL_TRC_CF(data, cf, "ssl_cf_set_earlydata(len=%zu) -> %zu",
1388                blen, nwritten);
1389    if(result)
1390      return result;
1391  }
1392  return CURLE_OK;
1393}
1394
1395static CURLcode ssl_cf_connect_deferred(struct Curl_cfilter *cf,
1396                                        struct Curl_easy *data,
1397                                        const void *buf, size_t blen,
1398                                        bool *done)
1399{
1400  struct ssl_connect_data *connssl = cf->ctx;
1401  CURLcode result = CURLE_OK;
1402
1403  DEBUGASSERT(connssl->state == ssl_connection_deferred);
1404  *done = FALSE;
1405  if(connssl->earlydata_state == ssl_earlydata_await) {
1406    result = ssl_cf_set_earlydata(cf, data, buf, blen);
1407    if(result)
1408      return result;
1409    /* we buffered any early data we would like to send. Actually
1410     * do the connect now which sends it and performs the handshake. */
1411    connssl->earlydata_state = ssl_earlydata_sending;
1412    connssl->earlydata_skip = Curl_bufq_len(&connssl->earlydata);
1413  }
1414
1415  result = ssl_cf_connect(cf, data, done);
1416
1417  if(!result && *done) {
1418    Curl_pgrsTimeWas(data, TIMER_APPCONNECT, connssl->handshake_done);
1419    switch(connssl->earlydata_state) {
1420    case ssl_earlydata_none:
1421      break;
1422    case ssl_earlydata_accepted:
1423      if(!Curl_ssl_cf_is_proxy(cf))
1424        Curl_pgrsEarlyData(data, (curl_off_t)connssl->earlydata_skip);
1425      infof(data, "Server accepted %zu bytes of TLS early data.",
1426            connssl->earlydata_skip);
1427      break;
1428    case ssl_earlydata_rejected:
1429      if(!Curl_ssl_cf_is_proxy(cf))
1430        Curl_pgrsEarlyData(data, -(curl_off_t)connssl->earlydata_skip);
1431      infof(data, "Server rejected TLS early data.");
1432      connssl->earlydata_skip = 0;
1433      break;
1434    default:
1435      /* This should not happen. Either we do not use early data or we
1436       * should know if it was accepted or not. */
1437      DEBUGASSERT(NULL);
1438      break;
1439    }
1440  }
1441  return result;
1442}
1443
1444static bool ssl_cf_data_pending(struct Curl_cfilter *cf,
1445                                const struct Curl_easy *data)
1446{
1447  struct ssl_connect_data *connssl = cf->ctx;
1448  struct cf_call_data save;
1449  bool pending;
1450
1451  CF_DATA_SAVE(save, cf, data);
1452  if(connssl->ssl_impl->data_pending &&
1453     connssl->ssl_impl->data_pending(cf, data))
1454    pending = TRUE;
1455  else
1456    pending = cf->next->cft->has_data_pending(cf->next, data);
1457  CF_DATA_RESTORE(cf, save);
1458  return pending;
1459}
1460
1461static CURLcode ssl_cf_send(struct Curl_cfilter *cf,
1462                            struct Curl_easy *data,
1463                            const uint8_t *buf, size_t blen,
1464                            bool eos, size_t *pnwritten)
1465{
1466  struct ssl_connect_data *connssl = cf->ctx;
1467  struct cf_call_data save;
1468  CURLcode result = CURLE_OK;
1469
1470  (void)eos;
1471  *pnwritten = 0;
1472  CF_DATA_SAVE(save, cf, data);
1473
1474  if(connssl->state == ssl_connection_deferred) {
1475    bool done = FALSE;
1476    result = ssl_cf_connect_deferred(cf, data, buf, blen, &done);
1477    if(result)
1478      goto out;
1479    else if(!done) {
1480      result = CURLE_AGAIN;
1481      goto out;
1482    }
1483    DEBUGASSERT(connssl->state == ssl_connection_complete);
1484  }
1485
1486  if(connssl->earlydata_skip) {
1487    if(connssl->earlydata_skip >= blen) {
1488      connssl->earlydata_skip -= blen;
1489      result = CURLE_OK;
1490      *pnwritten = blen;
1491      goto out;
1492    }
1493    else {
1494      *pnwritten = connssl->earlydata_skip;
1495      buf = buf + connssl->earlydata_skip;
1496      blen -= connssl->earlydata_skip;
1497      connssl->earlydata_skip = 0;
1498    }
1499  }
1500
1501  /* OpenSSL and maybe other TLS libs do not like 0-length writes. Skip. */
1502  if(blen > 0) {
1503    size_t nwritten;
1504    result = connssl->ssl_impl->send_plain(cf, data, buf, blen, &nwritten);
1505    if(!result)
1506      *pnwritten += nwritten;
1507  }
1508
1509out:
1510  CF_DATA_RESTORE(cf, save);
1511  return result;
1512}
1513
1514static CURLcode ssl_cf_recv(struct Curl_cfilter *cf,
1515                            struct Curl_easy *data, char *buf, size_t len,
1516                            size_t *pnread)
1517{
1518  struct ssl_connect_data *connssl = cf->ctx;
1519  struct cf_call_data save;
1520  CURLcode result = CURLE_OK;
1521
1522  CF_DATA_SAVE(save, cf, data);
1523  *pnread = 0;
1524  if(connssl->state == ssl_connection_deferred) {
1525    bool done = FALSE;
1526    result = ssl_cf_connect_deferred(cf, data, NULL, 0, &done);
1527    if(result)
1528      goto out;
1529    else if(!done) {
1530      result = CURLE_AGAIN;
1531      goto out;
1532    }
1533    DEBUGASSERT(connssl->state == ssl_connection_complete);
1534  }
1535
1536  result = connssl->ssl_impl->recv_plain(cf, data, buf, len, pnread);
1537
1538out:
1539  CF_DATA_RESTORE(cf, save);
1540  return result;
1541}
1542
1543static CURLcode ssl_cf_shutdown(struct Curl_cfilter *cf,
1544                                struct Curl_easy *data,
1545                                bool *done)
1546{
1547  struct ssl_connect_data *connssl = cf->ctx;
1548  CURLcode result = CURLE_OK;
1549
1550  *done = TRUE;
1551  /* If we have done the SSL handshake, shut down the connection cleanly */
1552  if(cf->connected && (connssl->state == ssl_connection_complete) &&
1553     !cf->shutdown && Curl_ssl->shut_down) {
1554    struct cf_call_data save;
1555
1556    CF_DATA_SAVE(save, cf, data);
1557    result = connssl->ssl_impl->shut_down(cf, data, TRUE, done);
1558    CURL_TRC_CF(data, cf, "cf_shutdown -> %d, done=%d", result, *done);
1559    CF_DATA_RESTORE(cf, save);
1560    cf->shutdown = (result || *done);
1561  }
1562  return result;
1563}
1564
1565static CURLcode ssl_cf_adjust_pollset(struct Curl_cfilter *cf,
1566                                      struct Curl_easy *data,
1567                                      struct easy_pollset *ps)
1568{
1569  struct ssl_connect_data *connssl = cf->ctx;
1570  struct cf_call_data save;
1571  CURLcode result;
1572
1573  CF_DATA_SAVE(save, cf, data);
1574  result = connssl->ssl_impl->adjust_pollset(cf, data, ps);
1575  CF_DATA_RESTORE(cf, save);
1576  return result;
1577}
1578
1579static CURLcode ssl_cf_query(struct Curl_cfilter *cf,
1580                             struct Curl_easy *data,
1581                             int query, int *pres1, void *pres2)
1582{
1583  struct ssl_connect_data *connssl = cf->ctx;
1584
1585  switch(query) {
1586  case CF_QUERY_TIMER_APPCONNECT: {
1587    struct curltime *when = pres2;
1588    if(cf->connected && !Curl_ssl_cf_is_proxy(cf))
1589      *when = connssl->handshake_done;
1590    return CURLE_OK;
1591  }
1592  case CF_QUERY_SSL_INFO:
1593  case CF_QUERY_SSL_CTX_INFO:
1594    if(!Curl_ssl_cf_is_proxy(cf)) {
1595      struct curl_tlssessioninfo *info = pres2;
1596      struct cf_call_data save;
1597      CF_DATA_SAVE(save, cf, data);
1598      info->backend = Curl_ssl_backend();
1599      info->internals = connssl->ssl_impl->get_internals(
1600        cf->ctx, (query == CF_QUERY_SSL_INFO) ?
1601        CURLINFO_TLS_SSL_PTR : CURLINFO_TLS_SESSION);
1602      CF_DATA_RESTORE(cf, save);
1603      return CURLE_OK;
1604    }
1605    break;
1606  case CF_QUERY_ALPN_NEGOTIATED: {
1607    const char **palpn = pres2;
1608    DEBUGASSERT(palpn);
1609    *palpn = connssl->negotiated.alpn;
1610    CURL_TRC_CF(data, cf, "query ALPN: returning '%s'", *palpn);
1611    return CURLE_OK;
1612  }
1613  default:
1614    break;
1615  }
1616  return cf->next ?
1617    cf->next->cft->query(cf->next, data, query, pres1, pres2) :
1618    CURLE_UNKNOWN_OPTION;
1619}
1620
1621static CURLcode ssl_cf_cntrl(struct Curl_cfilter *cf,
1622                             struct Curl_easy *data,
1623                             int event, int arg1, void *arg2)
1624{
1625  struct ssl_connect_data *connssl = cf->ctx;
1626
1627  (void)arg1;
1628  (void)arg2;
1629  (void)data;
1630  switch(event) {
1631  case CF_CTRL_CONN_INFO_UPDATE:
1632    if(connssl->negotiated.alpn && !cf->sockindex) {
1633      if(!strcmp("http/1.1", connssl->negotiated.alpn))
1634        cf->conn->httpversion_seen = 11;
1635      else if(!strcmp("h2", connssl->negotiated.alpn))
1636        cf->conn->httpversion_seen = 20;
1637      else if(!strcmp("h3", connssl->negotiated.alpn))
1638        cf->conn->httpversion_seen = 30;
1639    }
1640    break;
1641  }
1642  return CURLE_OK;
1643}
1644
1645static bool cf_ssl_is_alive(struct Curl_cfilter *cf, struct Curl_easy *data,
1646                            bool *input_pending)
1647{
1648  /*
1649   * This function tries to determine connection status.
1650   */
1651  return cf->next ?
1652    cf->next->cft->is_alive(cf->next, data, input_pending) :
1653    FALSE; /* pessimistic in absence of data */
1654}
1655
1656struct Curl_cftype Curl_cft_ssl = {
1657  "SSL",
1658  CF_TYPE_SSL,
1659  CURL_LOG_LVL_NONE,
1660  ssl_cf_destroy,
1661  ssl_cf_connect,
1662  ssl_cf_close,
1663  ssl_cf_shutdown,
1664  ssl_cf_adjust_pollset,
1665  ssl_cf_data_pending,
1666  ssl_cf_send,
1667  ssl_cf_recv,
1668  ssl_cf_cntrl,
1669  cf_ssl_is_alive,
1670  Curl_cf_def_conn_keep_alive,
1671  ssl_cf_query,
1672};
1673
1674#ifndef CURL_DISABLE_PROXY
1675
1676struct Curl_cftype Curl_cft_ssl_proxy = {
1677  "SSL-PROXY",
1678  CF_TYPE_SSL | CF_TYPE_PROXY,
1679  CURL_LOG_LVL_NONE,
1680  ssl_cf_destroy,
1681  ssl_cf_connect,
1682  ssl_cf_close,
1683  ssl_cf_shutdown,
1684  ssl_cf_adjust_pollset,
1685  ssl_cf_data_pending,
1686  ssl_cf_send,
1687  ssl_cf_recv,
1688  Curl_cf_def_cntrl,
1689  cf_ssl_is_alive,
1690  Curl_cf_def_conn_keep_alive,
1691  ssl_cf_query,
1692};
1693
1694#endif /* !CURL_DISABLE_PROXY */
1695
1696static CURLcode cf_ssl_create(struct Curl_cfilter **pcf,
1697                              struct Curl_easy *data,
1698                              struct connectdata *conn)
1699{
1700  struct Curl_cfilter *cf = NULL;
1701  struct ssl_connect_data *ctx;
1702  CURLcode result;
1703
1704  DEBUGASSERT(data->conn);
1705
1706#ifdef CURL_DISABLE_HTTP
1707  (void)conn;
1708  /* We only support ALPN for HTTP so far. */
1709  DEBUGASSERT(!conn->bits.tls_enable_alpn);
1710  ctx = cf_ctx_new(data, NULL);
1711#else
1712  ctx = cf_ctx_new(data, alpn_get_spec(data->state.http_neg.wanted,
1713                                       data->state.http_neg.preferred,
1714                                       (bool)data->state.http_neg.only_10,
1715                                       (bool)conn->bits.tls_enable_alpn));
1716#endif
1717  if(!ctx) {
1718    result = CURLE_OUT_OF_MEMORY;
1719    goto out;
1720  }
1721
1722  result = Curl_cf_create(&cf, &Curl_cft_ssl, ctx);
1723
1724out:
1725  if(result)
1726    cf_ctx_free(ctx);
1727  *pcf = result ? NULL : cf;
1728  return result;
1729}
1730
1731CURLcode Curl_ssl_cfilter_add(struct Curl_easy *data,
1732                              struct connectdata *conn,
1733                              int sockindex)
1734{
1735  struct Curl_cfilter *cf;
1736  CURLcode result;
1737
1738  result = cf_ssl_create(&cf, data, conn);
1739  if(!result)
1740    Curl_conn_cf_add(data, conn, sockindex, cf);
1741  return result;
1742}
1743
1744CURLcode Curl_cf_ssl_insert_after(struct Curl_cfilter *cf_at,
1745                                  struct Curl_easy *data)
1746{
1747  struct Curl_cfilter *cf;
1748  CURLcode result;
1749
1750  result = cf_ssl_create(&cf, data, cf_at->conn);
1751  if(!result)
1752    Curl_conn_cf_insert_after(cf_at, cf);
1753  return result;
1754}
1755
1756#ifndef CURL_DISABLE_PROXY
1757
1758static CURLcode cf_ssl_proxy_create(struct Curl_cfilter **pcf,
1759                                    struct Curl_easy *data,
1760                                    struct connectdata *conn)
1761{
1762  struct Curl_cfilter *cf = NULL;
1763  struct ssl_connect_data *ctx;
1764  CURLcode result;
1765  /* ALPN is default, but if user explicitly disables it, obey */
1766  bool use_alpn = (bool)data->set.ssl_enable_alpn;
1767  http_majors wanted = CURL_HTTP_V1x;
1768
1769  (void)conn;
1770#ifdef USE_HTTP2
1771  if(conn->http_proxy.proxytype == CURLPROXY_HTTPS2) {
1772    use_alpn = TRUE;
1773    wanted = (CURL_HTTP_V1x | CURL_HTTP_V2x);
1774  }
1775#endif
1776
1777  ctx = cf_ctx_new(data, alpn_get_spec(wanted, 0, false, use_alpn));
1778  if(!ctx) {
1779    result = CURLE_OUT_OF_MEMORY;
1780    goto out;
1781  }
1782  result = Curl_cf_create(&cf, &Curl_cft_ssl_proxy, ctx);
1783
1784out:
1785  if(result)
1786    cf_ctx_free(ctx);
1787  *pcf = result ? NULL : cf;
1788  return result;
1789}
1790
1791CURLcode Curl_cf_ssl_proxy_insert_after(struct Curl_cfilter *cf_at,
1792                                        struct Curl_easy *data)
1793{
1794  struct Curl_cfilter *cf;
1795  CURLcode result;
1796
1797  result = cf_ssl_proxy_create(&cf, data, cf_at->conn);
1798  if(!result)
1799    Curl_conn_cf_insert_after(cf_at, cf);
1800  return result;
1801}
1802
1803#endif /* !CURL_DISABLE_PROXY */
1804
1805bool Curl_ssl_supports(struct Curl_easy *data, unsigned int ssl_option)
1806{
1807  (void)data;
1808  return (Curl_ssl->supports & ssl_option);
1809}
1810
1811static CURLcode vtls_shutdown_blocking(struct Curl_cfilter *cf,
1812                                       struct Curl_easy *data,
1813                                       bool send_shutdown, bool *done)
1814{
1815  struct ssl_connect_data *connssl = cf->ctx;
1816  struct cf_call_data save;
1817  CURLcode result = CURLE_OK;
1818  timediff_t timeout_ms;
1819  int what, loop = 10;
1820
1821  if(cf->shutdown) {
1822    *done = TRUE;
1823    return CURLE_OK;
1824  }
1825  CF_DATA_SAVE(save, cf, data);
1826
1827  *done = FALSE;
1828  while(!result && !*done && loop--) {
1829    timeout_ms = Curl_shutdown_timeleft(data, cf->conn, cf->sockindex);
1830
1831    if(timeout_ms < 0) {
1832      /* no need to continue if time is already up */
1833      failf(data, "SSL shutdown timeout");
1834      result = CURLE_OPERATION_TIMEDOUT;
1835      goto out;
1836    }
1837
1838    result = connssl->ssl_impl->shut_down(cf, data, send_shutdown, done);
1839    if(result || *done)
1840      goto out;
1841
1842    if(connssl->io_need) {
1843      what = Curl_conn_cf_poll(cf, data, timeout_ms);
1844      if(what < 0) {
1845        /* fatal error */
1846        failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
1847        result = CURLE_RECV_ERROR;
1848        goto out;
1849      }
1850      else if(what == 0) {
1851        /* timeout */
1852        failf(data, "SSL shutdown timeout");
1853        result = CURLE_OPERATION_TIMEDOUT;
1854        goto out;
1855      }
1856      /* socket is readable or writable */
1857    }
1858  }
1859out:
1860  CF_DATA_RESTORE(cf, save);
1861  cf->shutdown = (result || *done);
1862  return result;
1863}
1864
1865CURLcode Curl_ssl_cfilter_remove(struct Curl_easy *data,
1866                                 int sockindex, bool send_shutdown)
1867{
1868  struct Curl_cfilter *cf, *head;
1869  CURLcode result = CURLE_OK;
1870
1871  head = data->conn ? data->conn->cfilter[sockindex] : NULL;
1872  for(cf = head; cf; cf = cf->next) {
1873    if(cf->cft == &Curl_cft_ssl) {
1874      bool done;
1875      CURL_TRC_CF(data, cf, "shutdown and remove SSL, start");
1876      Curl_shutdown_start(data, sockindex, 0);
1877      result = vtls_shutdown_blocking(cf, data, send_shutdown, &done);
1878      Curl_shutdown_clear(data, sockindex);
1879      if(!result && !done) /* blocking failed? */
1880        result = CURLE_SSL_SHUTDOWN_FAILED;
1881      Curl_conn_cf_discard(&cf, data);
1882      CURL_TRC_CF(data, cf, "shutdown and remove SSL, done -> %d", result);
1883      break;
1884    }
1885  }
1886  return result;
1887}
1888
1889bool Curl_ssl_cf_is_proxy(struct Curl_cfilter *cf)
1890{
1891  return (cf->cft->flags & CF_TYPE_SSL) && (cf->cft->flags & CF_TYPE_PROXY);
1892}
1893
1894struct ssl_config_data *
1895Curl_ssl_cf_get_config(struct Curl_cfilter *cf, struct Curl_easy *data)
1896{
1897#ifdef CURL_DISABLE_PROXY
1898  (void)cf;
1899  return &data->set.ssl;
1900#else
1901  return Curl_ssl_cf_is_proxy(cf) ? &data->set.proxy_ssl : &data->set.ssl;
1902#endif
1903}
1904
1905struct ssl_primary_config *
1906Curl_ssl_cf_get_primary_config(struct Curl_cfilter *cf)
1907{
1908#ifdef CURL_DISABLE_PROXY
1909  return &cf->conn->ssl_config;
1910#else
1911  return Curl_ssl_cf_is_proxy(cf) ?
1912    &cf->conn->proxy_ssl_config : &cf->conn->ssl_config;
1913#endif
1914}
1915
1916CURLcode Curl_alpn_to_proto_buf(struct alpn_proto_buf *buf,
1917                                const struct alpn_spec *spec)
1918{
1919  size_t i, len;
1920  int off = 0;
1921  unsigned char blen;
1922
1923  memset(buf, 0, sizeof(*buf));
1924  for(i = 0; spec && i < spec->count; ++i) {
1925    len = strlen(spec->entries[i]);
1926    if(len >= ALPN_NAME_MAX)
1927      return CURLE_FAILED_INIT;
1928    blen = (unsigned char)len;
1929    if(off + blen + 1 >= (int)sizeof(buf->data))
1930      return CURLE_FAILED_INIT;
1931    buf->data[off++] = blen;
1932    memcpy(buf->data + off, spec->entries[i], blen);
1933    off += blen;
1934  }
1935  buf->len = off;
1936  return CURLE_OK;
1937}
1938
1939CURLcode Curl_alpn_to_proto_str(struct alpn_proto_buf *buf,
1940                                const struct alpn_spec *spec)
1941{
1942  size_t i, len;
1943  size_t off = 0;
1944
1945  memset(buf, 0, sizeof(*buf));
1946  for(i = 0; spec && i < spec->count; ++i) {
1947    len = strlen(spec->entries[i]);
1948    if(len >= ALPN_NAME_MAX)
1949      return CURLE_FAILED_INIT;
1950    if(off + len + 2 >= sizeof(buf->data))
1951      return CURLE_FAILED_INIT;
1952    if(off)
1953      buf->data[off++] = ',';
1954    memcpy(buf->data + off, spec->entries[i], len);
1955    off += len;
1956  }
1957  buf->data[off] = '\0';
1958  buf->len = (int)off;
1959  return CURLE_OK;
1960}
1961
1962bool Curl_alpn_contains_proto(const struct alpn_spec *spec,
1963                              const char *proto)
1964{
1965  size_t i, plen = proto ? strlen(proto) : 0;
1966  for(i = 0; spec && plen && i < spec->count; ++i) {
1967    size_t slen = strlen(spec->entries[i]);
1968    if((slen == plen) && !memcmp(proto, spec->entries[i], plen))
1969      return TRUE;
1970  }
1971  return FALSE;
1972}
1973
1974void Curl_alpn_restrict_to(struct alpn_spec *spec, const char *proto)
1975{
1976  size_t plen = strlen(proto);
1977  DEBUGASSERT(plen < sizeof(spec->entries[0]));
1978  if(plen < sizeof(spec->entries[0])) {
1979    memcpy(spec->entries[0], proto, plen + 1);
1980    spec->count = 1;
1981  }
1982}
1983
1984void Curl_alpn_copy(struct alpn_spec *dest, const struct alpn_spec *src)
1985{
1986  if(src)
1987    memcpy(dest, src, sizeof(*dest));
1988  else
1989    memset(dest, 0, sizeof(*dest));
1990}
1991
1992CURLcode Curl_alpn_set_negotiated(struct Curl_cfilter *cf,
1993                                  struct Curl_easy *data,
1994                                  struct ssl_connect_data *connssl,
1995                                  const unsigned char *proto,
1996                                  size_t proto_len)
1997{
1998  CURLcode result = CURLE_OK;
1999  (void)cf;
2000
2001  if(connssl->negotiated.alpn) {
2002    /* When we ask for a specific ALPN protocol, we need the confirmation
2003     * of it by the server, as we have installed protocol handler and
2004     * connection filter chain for exactly this protocol. */
2005    if(!proto_len) {
2006      failf(data, "ALPN: asked for '%s' from previous session, "
2007            "but server did not confirm it. Refusing to continue.",
2008            connssl->negotiated.alpn);
2009      result = CURLE_SSL_CONNECT_ERROR;
2010      goto out;
2011    }
2012    else if(!proto) {
2013      DEBUGASSERT(0); /* with length, we need a pointer */
2014      result = CURLE_SSL_CONNECT_ERROR;
2015      goto out;
2016    }
2017    else if((strlen(connssl->negotiated.alpn) != proto_len) ||
2018            memcmp(connssl->negotiated.alpn, proto, proto_len)) {
2019      failf(data, "ALPN: asked for '%s' from previous session, but server "
2020            "selected '%.*s'. Refusing to continue.",
2021            connssl->negotiated.alpn, (int)proto_len, proto);
2022      result = CURLE_SSL_CONNECT_ERROR;
2023      goto out;
2024    }
2025    /* ALPN is exactly what we asked for, done. */
2026    infof(data, "ALPN: server confirmed to use '%s'",
2027          connssl->negotiated.alpn);
2028    goto out;
2029  }
2030
2031  if(proto && proto_len) {
2032    if(memchr(proto, '\0', proto_len)) {
2033      failf(data, "ALPN: server selected protocol contains NUL. "
2034                  "Refusing to continue.");
2035      result = CURLE_SSL_CONNECT_ERROR;
2036      goto out;
2037    }
2038    connssl->negotiated.alpn = curlx_memdup0((const char *)proto, proto_len);
2039    if(!connssl->negotiated.alpn)
2040      return CURLE_OUT_OF_MEMORY;
2041  }
2042
2043  if(proto && proto_len) {
2044    if(connssl->state == ssl_connection_deferred)
2045      infof(data, VTLS_INFOF_ALPN_DEFERRED, (int)proto_len, proto);
2046    else
2047      infof(data, VTLS_INFOF_ALPN_ACCEPTED, (int)proto_len, proto);
2048  }
2049  else {
2050    if(connssl->state == ssl_connection_deferred)
2051      infof(data, VTLS_INFOF_NO_ALPN_DEFERRED);
2052    else
2053      infof(data, VTLS_INFOF_NO_ALPN);
2054  }
2055
2056out:
2057  return result;
2058}
2059
2060CURLcode Curl_on_session_reuse(struct Curl_cfilter *cf,
2061                               struct Curl_easy *data,
2062                               struct alpn_spec *alpns,
2063                               struct Curl_ssl_session *scs,
2064                               bool *do_early_data, bool early_data_allowed)
2065{
2066  struct ssl_connect_data *connssl = cf->ctx;
2067  CURLcode result = CURLE_OK;
2068
2069  *do_early_data = FALSE;
2070
2071  if(!early_data_allowed) {
2072    CURL_TRC_CF(data, cf, "SSL session does not allow earlydata");
2073  }
2074  else if(!Curl_alpn_contains_proto(alpns, scs->alpn)) {
2075    CURL_TRC_CF(data, cf, "SSL session has different ALPN, no early data");
2076  }
2077  else {
2078    infof(data, "SSL session allows %zu bytes of early data, "
2079          "reusing ALPN '%s'", connssl->earlydata_max, scs->alpn);
2080    connssl->earlydata_state = ssl_earlydata_await;
2081    connssl->state = ssl_connection_deferred;
2082    result = Curl_alpn_set_negotiated(cf, data, connssl,
2083                                      (const unsigned char *)scs->alpn,
2084                                      scs->alpn ? strlen(scs->alpn) : 0);
2085    *do_early_data = !result;
2086  }
2087  return result;
2088}
2089
2090#endif /* USE_SSL */