/***************************************************************************

 *                                  _   _ ____  _

 *  Project                     ___| | | |  _ \| |

 *                             / __| | | | |_) | |

 *                            | (__| |_| |  _ <| |___

 *                             \___|\___/|_| \_\_____|

 *

 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.

 *

 * This software is licensed as described in the file COPYING, which

 * you should have received as part of this distribution. The terms

 * are also available at https://curl.se/docs/copyright.html.

 *

 * You may opt to use, copy, modify, merge, publish, distribute and/or sell

 * copies of the Software, and permit persons to whom the Software is

 * furnished to do so, under the terms of the COPYING file.

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY

 * KIND, either express or implied.

 *

 * SPDX-License-Identifier: curl

 *

 ***************************************************************************/

/* This file is for implementing all "generic" SSL functions that all libcurl

   internals should use. It is then responsible for calling the proper

   "backend" function.

   SSL-functions in libcurl should call functions in this source file, and not

   to any specific SSL-layer.

   Curl_ssl_ - prefix for generic ones

   Note that this source code uses the functions of the configured SSL

   backend via the global Curl_ssl instance.

   "SSL/TLS Strong Encryption: An Introduction"

   https://httpd.apache.org/docs/2.0/ssl/ssl_intro.html

*/

#include "curl_setup.h"

#ifdef HAVE_SYS_TYPES_H

#include <sys/types.h>

#endif

#ifdef HAVE_SYS_STAT_H

#include <sys/stat.h>

#endif

#ifdef HAVE_FCNTL_H

#include <fcntl.h>

#endif

#include "urldata.h"

#include "cfilters.h"

#include "vtls.h" /* generic SSL protos etc */

#include "vtls_int.h"

#include "slist.h"

#include "sendf.h"

#include "strcase.h"

#include "url.h"

#include "progress.h"

#include "share.h"

#include "multiif.h"

#include "timeval.h"

#include "curl_md5.h"

#include "warnless.h"

#include "curl_base64.h"

#include "curl_printf.h"

#include "inet_pton.h"

#include "strdup.h"

/* The last #include files should be: */

#include "curl_memory.h"

#include "memdebug.h"

/* convenience macro to check if this handle is using a shared SSL session */

#define SSLSESSION_SHARED(data) (data->share &&                        \

                                 (data->share->specifier &             \

                                  (1<<CURL_LOCK_DATA_SSL_SESSION)))

#define CLONE_STRING(var)                    \

  do {                                       \

    if(source->var) {                        \

      dest->var = strdup(source->var);       \

      if(!dest->var)                         \

        return FALSE;                        \

    }                                        \

    else                                     \

      dest->var = NULL;                      \

  } while(0)

#define CLONE_BLOB(var)                        \

  do {                                         \

    if(blobdup(&dest->var, source->var))       \

      return FALSE;                            \

  } while(0)

static CURLcode blobdup(struct curl_blob **dest,

                        struct curl_blob *src)

{

  DEBUGASSERT(dest);

  DEBUGASSERT(!*dest);

  if(src) {

    /* only if there's data to dupe! */

    struct curl_blob *d;

    d = malloc(sizeof(struct curl_blob) + src->len);

    if(!d)

      return CURLE_OUT_OF_MEMORY;

    d->len = src->len;

    /* Always duplicate because the connection may survive longer than the

       handle that passed in the blob. */

    d->flags = CURL_BLOB_COPY;

    d->data = (void *)((char *)d + sizeof(struct curl_blob));

    memcpy(d->data, src->data, src->len);

    *dest = d;

  }

  return CURLE_OK;

}

/* returns TRUE if the blobs are identical */

static bool blobcmp(struct curl_blob *first, struct curl_blob *second)

{

  if(!first && !second) /* both are NULL */

    return TRUE;

  if(!first || !second) /* one is NULL */

    return FALSE;

  if(first->len != second->len) /* different sizes */

    return FALSE;

  return !memcmp(first->data, second->data, first->len); /* same data */

}

#ifdef USE_SSL

static const struct alpn_spec ALPN_SPEC_H11 = {

  { ALPN_HTTP_1_1 }, 1

};

#ifdef USE_HTTP2

static const struct alpn_spec ALPN_SPEC_H2_H11 = {

  { ALPN_H2, ALPN_HTTP_1_1 }, 2

};

#endif

static const struct alpn_spec *alpn_get_spec(int httpwant, bool use_alpn)

{

  if(!use_alpn)

    return NULL;

#ifdef USE_HTTP2

  if(httpwant >= CURL_HTTP_VERSION_2)

    return &ALPN_SPEC_H2_H11;

#else

  (void)httpwant;

#endif

  /* Use the ALPN protocol "http/1.1" for HTTP/1.x.

     Avoid "http/1.0" because some servers don't support it. */

  return &ALPN_SPEC_H11;

}

#endif /* USE_SSL */

void Curl_ssl_easy_config_init(struct Curl_easy *data)

{

  /*

   * libcurl 7.10 introduced SSL verification *by default*! This needs to be

   * switched off unless wanted.

   */

  data->set.ssl.primary.verifypeer = TRUE;

  data->set.ssl.primary.verifyhost = TRUE;

  data->set.ssl.primary.sessionid = TRUE; /* session ID caching by default */

#ifndef CURL_DISABLE_PROXY

  data->set.proxy_ssl = data->set.ssl;

#endif

}

static bool

match_ssl_primary_config(struct Curl_easy *data,

                         struct ssl_primary_config *c1,

                         struct ssl_primary_config *c2)

{

  (void)data;

  if((c1->version == c2->version) &&

     (c1->version_max == c2->version_max) &&

     (c1->ssl_options == c2->ssl_options) &&

     (c1->verifypeer == c2->verifypeer) &&

     (c1->verifyhost == c2->verifyhost) &&

     (c1->verifystatus == c2->verifystatus) &&

     blobcmp(c1->cert_blob, c2->cert_blob) &&

     blobcmp(c1->ca_info_blob, c2->ca_info_blob) &&

     blobcmp(c1->issuercert_blob, c2->issuercert_blob) &&

     Curl_safecmp(c1->CApath, c2->CApath) &&

     Curl_safecmp(c1->CAfile, c2->CAfile) &&

     Curl_safecmp(c1->issuercert, c2->issuercert) &&

     Curl_safecmp(c1->clientcert, c2->clientcert) &&

#ifdef USE_TLS_SRP

     !Curl_timestrcmp(c1->username, c2->username) &&

     !Curl_timestrcmp(c1->password, c2->password) &&

#endif

     strcasecompare(c1->cipher_list, c2->cipher_list) &&

     strcasecompare(c1->cipher_list13, c2->cipher_list13) &&

     strcasecompare(c1->curves, c2->curves) &&

     strcasecompare(c1->CRLfile, c2->CRLfile) &&

     strcasecompare(c1->pinned_key, c2->pinned_key))

    return TRUE;

  return FALSE;

}

bool Curl_ssl_conn_config_match(struct Curl_easy *data,

                                struct connectdata *candidate,

                                bool proxy)

{

#ifndef CURL_DISABLE_PROXY

  if(proxy)

    return match_ssl_primary_config(data, &data->set.proxy_ssl.primary,

                                    &candidate->proxy_ssl_config);

#else

  (void)proxy;

#endif

  return match_ssl_primary_config(data, &data->set.ssl.primary,

                                  &candidate->ssl_config);

}

static bool clone_ssl_primary_config(struct ssl_primary_config *source,

                                     struct ssl_primary_config *dest)

{

  dest->version = source->version;

  dest->version_max = source->version_max;

  dest->verifypeer = source->verifypeer;

  dest->verifyhost = source->verifyhost;

  dest->verifystatus = source->verifystatus;

  dest->sessionid = source->sessionid;

  dest->ssl_options = source->ssl_options;

  CLONE_BLOB(cert_blob);

  CLONE_BLOB(ca_info_blob);

  CLONE_BLOB(issuercert_blob);

  CLONE_STRING(CApath);

  CLONE_STRING(CAfile);

  CLONE_STRING(issuercert);

  CLONE_STRING(clientcert);

  CLONE_STRING(cipher_list);

  CLONE_STRING(cipher_list13);

  CLONE_STRING(pinned_key);

  CLONE_STRING(curves);

  CLONE_STRING(CRLfile);

#ifdef USE_TLS_SRP

  CLONE_STRING(username);

  CLONE_STRING(password);

#endif

  return TRUE;

}

static void Curl_free_primary_ssl_config(struct ssl_primary_config *sslc)

{

  Curl_safefree(sslc->CApath);

  Curl_safefree(sslc->CAfile);

  Curl_safefree(sslc->issuercert);

  Curl_safefree(sslc->clientcert);

  Curl_safefree(sslc->cipher_list);

  Curl_safefree(sslc->cipher_list13);

  Curl_safefree(sslc->pinned_key);

  Curl_safefree(sslc->cert_blob);

  Curl_safefree(sslc->ca_info_blob);

  Curl_safefree(sslc->issuercert_blob);

  Curl_safefree(sslc->curves);

  Curl_safefree(sslc->CRLfile);

#ifdef USE_TLS_SRP

  Curl_safefree(sslc->username);

  Curl_safefree(sslc->password);

#endif

}

CURLcode Curl_ssl_easy_config_complete(struct Curl_easy *data)

{

  data->set.ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH];

  data->set.ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE];

  data->set.ssl.primary.CRLfile = data->set.str[STRING_SSL_CRLFILE];

  data->set.ssl.primary.issuercert = data->set.str[STRING_SSL_ISSUERCERT];

  data->set.ssl.primary.issuercert_blob = data->set.blobs[BLOB_SSL_ISSUERCERT];

  data->set.ssl.primary.cipher_list =

    data->set.str[STRING_SSL_CIPHER_LIST];

  data->set.ssl.primary.cipher_list13 =

    data->set.str[STRING_SSL_CIPHER13_LIST];

  data->set.ssl.primary.pinned_key =

    data->set.str[STRING_SSL_PINNEDPUBLICKEY];

  data->set.ssl.primary.cert_blob = data->set.blobs[BLOB_CERT];

  data->set.ssl.primary.ca_info_blob = data->set.blobs[BLOB_CAINFO];

  data->set.ssl.primary.curves = data->set.str[STRING_SSL_EC_CURVES];

#ifdef USE_TLS_SRP

  data->set.ssl.primary.username = data->set.str[STRING_TLSAUTH_USERNAME];

  data->set.ssl.primary.password = data->set.str[STRING_TLSAUTH_PASSWORD];

#endif

  data->set.ssl.cert_type = data->set.str[STRING_CERT_TYPE];

  data->set.ssl.key = data->set.str[STRING_KEY];

  data->set.ssl.key_type = data->set.str[STRING_KEY_TYPE];

  data->set.ssl.key_passwd = data->set.str[STRING_KEY_PASSWD];

  data->set.ssl.primary.clientcert = data->set.str[STRING_CERT];

  data->set.ssl.key_blob = data->set.blobs[BLOB_KEY];

#ifndef CURL_DISABLE_PROXY

  data->set.proxy_ssl.primary.CApath = data->set.str[STRING_SSL_CAPATH_PROXY];

  data->set.proxy_ssl.primary.CAfile = data->set.str[STRING_SSL_CAFILE_PROXY];

  data->set.proxy_ssl.primary.cipher_list =

    data->set.str[STRING_SSL_CIPHER_LIST_PROXY];

  data->set.proxy_ssl.primary.cipher_list13 =

    data->set.str[STRING_SSL_CIPHER13_LIST_PROXY];

  data->set.proxy_ssl.primary.pinned_key =

    data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY];

  data->set.proxy_ssl.primary.cert_blob = data->set.blobs[BLOB_CERT_PROXY];

  data->set.proxy_ssl.primary.ca_info_blob =

    data->set.blobs[BLOB_CAINFO_PROXY];

  data->set.proxy_ssl.primary.issuercert =

    data->set.str[STRING_SSL_ISSUERCERT_PROXY];

  data->set.proxy_ssl.primary.issuercert_blob =

    data->set.blobs[BLOB_SSL_ISSUERCERT_PROXY];

  data->set.proxy_ssl.primary.CRLfile =

    data->set.str[STRING_SSL_CRLFILE_PROXY];

  data->set.proxy_ssl.cert_type = data->set.str[STRING_CERT_TYPE_PROXY];

  data->set.proxy_ssl.key = data->set.str[STRING_KEY_PROXY];

  data->set.proxy_ssl.key_type = data->set.str[STRING_KEY_TYPE_PROXY];

  data->set.proxy_ssl.key_passwd = data->set.str[STRING_KEY_PASSWD_PROXY];

  data->set.proxy_ssl.primary.clientcert = data->set.str[STRING_CERT_PROXY];

  data->set.proxy_ssl.key_blob = data->set.blobs[BLOB_KEY_PROXY];

#ifdef USE_TLS_SRP

  data->set.proxy_ssl.primary.username =

    data->set.str[STRING_TLSAUTH_USERNAME_PROXY];

  data->set.proxy_ssl.primary.password =

    data->set.str[STRING_TLSAUTH_PASSWORD_PROXY];

#endif

#endif /* CURL_DISABLE_PROXY */

  return CURLE_OK;

}

CURLcode Curl_ssl_conn_config_init(struct Curl_easy *data,

                                   struct connectdata *conn)

{

  /* Clone "primary" SSL configurations from the esay handle to

   * the connection. They are used for connection cache matching and

   * probably outlive the easy handle */

  if(!clone_ssl_primary_config(&data->set.ssl.primary, &conn->ssl_config))

    return CURLE_OUT_OF_MEMORY;

#ifndef CURL_DISABLE_PROXY

  if(!clone_ssl_primary_config(&data->set.proxy_ssl.primary,

                               &conn->proxy_ssl_config))

    return CURLE_OUT_OF_MEMORY;

#endif

  return CURLE_OK;

}

void Curl_ssl_conn_config_cleanup(struct connectdata *conn)

{

  Curl_free_primary_ssl_config(&conn->ssl_config);

#ifndef CURL_DISABLE_PROXY

  Curl_free_primary_ssl_config(&conn->proxy_ssl_config);

#endif

}

void Curl_ssl_conn_config_update(struct Curl_easy *data, bool for_proxy)

{

  /* May be called on an easy that has no connection yet */

  if(data->conn) {

    struct ssl_primary_config *src, *dest;

#ifndef CURL_DISABLE_PROXY

    src = for_proxy? &data->set.proxy_ssl.primary : &data->set.ssl.primary;

    dest = for_proxy? &data->conn->proxy_ssl_config : &data->conn->ssl_config;

#else

    (void)for_proxy;

    src = &data->set.ssl.primary;

    dest = &data->conn->ssl_config;

#endif

    dest->verifyhost = src->verifyhost;

    dest->verifypeer = src->verifypeer;

    dest->verifystatus = src->verifystatus;

  }

}

#ifdef USE_SSL

static int multissl_setup(const struct Curl_ssl *backend);

#endif

curl_sslbackend Curl_ssl_backend(void)

{

#ifdef USE_SSL

  multissl_setup(NULL);

  return Curl_ssl->info.id;

#else

  return CURLSSLBACKEND_NONE;

#endif

}

#ifdef USE_SSL

/* "global" init done? */

static bool init_ssl = FALSE;

/**

 * Global SSL init

 *

 * @retval 0 error initializing SSL

 * @retval 1 SSL initialized successfully

 */

int Curl_ssl_init(void)

{

  /* make sure this is only done once */

  if(init_ssl)

    return 1;

  init_ssl = TRUE; /* never again */

  return Curl_ssl->init();

}

#if defined(CURL_WITH_MULTI_SSL)

static const struct Curl_ssl Curl_ssl_multi;

#endif

/* Global cleanup */

void Curl_ssl_cleanup(void)

{

  if(init_ssl) {

    /* only cleanup if we did a previous init */

    Curl_ssl->cleanup();

#if defined(CURL_WITH_MULTI_SSL)

    Curl_ssl = &Curl_ssl_multi;

#endif

    init_ssl = FALSE;

  }

}

static bool ssl_prefs_check(struct Curl_easy *data)

{

  /* check for CURLOPT_SSLVERSION invalid parameter value */

  const unsigned char sslver = data->set.ssl.primary.version;

  if(sslver >= CURL_SSLVERSION_LAST) {

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

    return FALSE;

  }

  switch(data->set.ssl.primary.version_max) {

  case CURL_SSLVERSION_MAX_NONE:

  case CURL_SSLVERSION_MAX_DEFAULT:

    break;

  default:

    if((data->set.ssl.primary.version_max >> 16) < sslver) {

      failf(data, "CURL_SSLVERSION_MAX incompatible with CURL_SSLVERSION");

      return FALSE;

    }

  }

  return TRUE;

}

static struct ssl_connect_data *cf_ctx_new(struct Curl_easy *data,

                                     const struct alpn_spec *alpn)

{

  struct ssl_connect_data *ctx;

  (void)data;

  ctx = calloc(1, sizeof(*ctx));

  if(!ctx)

    return NULL;

  ctx->alpn = alpn;

  ctx->backend = calloc(1, Curl_ssl->sizeof_ssl_backend_data);

  if(!ctx->backend) {

    free(ctx);

    return NULL;

  }

  return ctx;

}

static void cf_ctx_free(struct ssl_connect_data *ctx)

{

  if(ctx) {

    free(ctx->backend);

    free(ctx);

  }

}

static CURLcode ssl_connect(struct Curl_cfilter *cf, struct Curl_easy *data)

{

  struct ssl_connect_data *connssl = cf->ctx;

  CURLcode result;

  if(!ssl_prefs_check(data))

    return CURLE_SSL_CONNECT_ERROR;

  /* mark this is being ssl-enabled from here on. */

  connssl->state = ssl_connection_negotiating;

  result = Curl_ssl->connect_blocking(cf, data);

  if(!result) {

    DEBUGASSERT(connssl->state == ssl_connection_complete);

  }

  return result;

}

static CURLcode

ssl_connect_nonblocking(struct Curl_cfilter *cf, struct Curl_easy *data,

                        bool *done)

{

  if(!ssl_prefs_check(data))

    return CURLE_SSL_CONNECT_ERROR;

  /* mark this is being ssl requested from here on. */

  return Curl_ssl->connect_nonblocking(cf, data, done);

}

/*

 * Lock shared SSL session data

 */

void Curl_ssl_sessionid_lock(struct Curl_easy *data)

{

  if(SSLSESSION_SHARED(data))

    Curl_share_lock(data, CURL_LOCK_DATA_SSL_SESSION, CURL_LOCK_ACCESS_SINGLE);

}

/*

 * Unlock shared SSL session data

 */

void Curl_ssl_sessionid_unlock(struct Curl_easy *data)

{

  if(SSLSESSION_SHARED(data))

    Curl_share_unlock(data, CURL_LOCK_DATA_SSL_SESSION);

}

/*

 * Check if there's a session ID for the given connection in the cache, and if

 * there's one suitable, it is provided. Returns TRUE when no entry matched.

 */

bool Curl_ssl_getsessionid(struct Curl_cfilter *cf,

                           struct Curl_easy *data,

                           void **ssl_sessionid,

                           size_t *idsize) /* set 0 if unknown */

{

  struct ssl_connect_data *connssl = cf->ctx;

  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);

  struct Curl_ssl_session *check;

  size_t i;

  long *general_age;

  bool no_match = TRUE;

  *ssl_sessionid = NULL;

  if(!ssl_config)

    return TRUE;

  DEBUGASSERT(ssl_config->primary.sessionid);

  if(!ssl_config->primary.sessionid || !data->state.session)

    /* session ID reuse is disabled or the session cache has not been

       setup */

    return TRUE;

  /* Lock if shared */

  if(SSLSESSION_SHARED(data))

    general_age = &data->share->sessionage;

  else

    general_age = &data->state.sessionage;

  for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++) {

    check = &data->state.session[i];

    if(!check->sessionid)

      /* not session ID means blank entry */

      continue;

    if(strcasecompare(connssl->peer.hostname, check->name) &&

       ((!cf->conn->bits.conn_to_host && !check->conn_to_host) ||

        (cf->conn->bits.conn_to_host && check->conn_to_host &&

         strcasecompare(cf->conn->conn_to_host.name, check->conn_to_host))) &&

       ((!cf->conn->bits.conn_to_port && check->conn_to_port == -1) ||

        (cf->conn->bits.conn_to_port && check->conn_to_port != -1 &&

         cf->conn->conn_to_port == check->conn_to_port)) &&

       (connssl->port == check->remote_port) &&

       strcasecompare(cf->conn->handler->scheme, check->scheme) &&

       match_ssl_primary_config(data, conn_config, &check->ssl_config)) {

      /* yes, we have a session ID! */

      (*general_age)++;          /* increase general age */

      check->age = *general_age; /* set this as used in this age */

      *ssl_sessionid = check->sessionid;

      if(idsize)

        *idsize = check->idsize;

      no_match = FALSE;

      break;

    }

  }

  DEBUGF(infof(data, "%s Session ID in cache for %s %s://%s:%d",

               no_match? "Didn't find": "Found",

               Curl_ssl_cf_is_proxy(cf) ? "proxy" : "host",

               cf->conn->handler->scheme, connssl->peer.hostname,

               connssl->port));

  return no_match;

}

/*

 * Kill a single session ID entry in the cache.

 */

void Curl_ssl_kill_session(struct Curl_ssl_session *session)

{

  if(session->sessionid) {

    /* defensive check */

    /* free the ID the SSL-layer specific way */

    Curl_ssl->session_free(session->sessionid);

    session->sessionid = NULL;

    session->age = 0; /* fresh */

    Curl_free_primary_ssl_config(&session->ssl_config);

    Curl_safefree(session->name);

    Curl_safefree(session->conn_to_host);

  }

}

/*

 * Delete the given session ID from the cache.

 */

void Curl_ssl_delsessionid(struct Curl_easy *data, void *ssl_sessionid)

{

  size_t i;

  for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++) {

    struct Curl_ssl_session *check = &data->state.session[i];

    if(check->sessionid == ssl_sessionid) {

      Curl_ssl_kill_session(check);

      break;

    }

  }

}

/*

 * Store session id in the session cache. The ID passed on to this function

 * must already have been extracted and allocated the proper way for the SSL

 * layer. Curl_XXXX_session_free() will be called to free/kill the session ID

 * later on.

 */

CURLcode Curl_ssl_addsessionid(struct Curl_cfilter *cf,

                               struct Curl_easy *data,

                               void *ssl_sessionid,

                               size_t idsize,

                               bool *added)

{

  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);

  size_t i;

  struct Curl_ssl_session *store;

  long oldest_age;

  char *clone_host;

  char *clone_conn_to_host;

  int conn_to_port;

  long *general_age;

  if(added)

    *added = FALSE;

  if(!data->state.session)

    return CURLE_OK;

  store = &data->state.session[0];

  oldest_age = data->state.session[0].age; /* zero if unused */

  (void)ssl_config;

  DEBUGASSERT(ssl_config->primary.sessionid);

  clone_host = strdup(connssl->peer.hostname);

  if(!clone_host)

    return CURLE_OUT_OF_MEMORY; /* bail out */

  if(cf->conn->bits.conn_to_host) {

    clone_conn_to_host = strdup(cf->conn->conn_to_host.name);

    if(!clone_conn_to_host) {

      free(clone_host);

      return CURLE_OUT_OF_MEMORY; /* bail out */

    }

  }

  else

    clone_conn_to_host = NULL;

  if(cf->conn->bits.conn_to_port)

    conn_to_port = cf->conn->conn_to_port;

  else

    conn_to_port = -1;

  /* Now we should add the session ID and the host name to the cache, (remove

     the oldest if necessary) */

  /* If using shared SSL session, lock! */

  if(SSLSESSION_SHARED(data)) {

    general_age = &data->share->sessionage;

  }

  else {

    general_age = &data->state.sessionage;

  }

  /* find an empty slot for us, or find the oldest */

  for(i = 1; (i < data->set.general_ssl.max_ssl_sessions) &&

        data->state.session[i].sessionid; i++) {

    if(data->state.session[i].age < oldest_age) {

      oldest_age = data->state.session[i].age;

      store = &data->state.session[i];

    }

  }

  if(i == data->set.general_ssl.max_ssl_sessions)

    /* cache is full, we must "kill" the oldest entry! */

    Curl_ssl_kill_session(store);

  else

    store = &data->state.session[i]; /* use this slot */

  /* now init the session struct wisely */

  store->sessionid = ssl_sessionid;

  store->idsize = idsize;

  store->age = *general_age;    /* set current age */

  /* free it if there's one already present */

  free(store->name);

  free(store->conn_to_host);

  store->name = clone_host;               /* clone host name */

  store->conn_to_host = clone_conn_to_host; /* clone connect to host name */

  store->conn_to_port = conn_to_port; /* connect to port number */

  /* port number */

  store->remote_port = connssl->port;

  store->scheme = cf->conn->handler->scheme;

  if(!clone_ssl_primary_config(conn_config, &store->ssl_config)) {

    Curl_free_primary_ssl_config(&store->ssl_config);

    store->sessionid = NULL; /* let caller free sessionid */

    free(clone_host);

    free(clone_conn_to_host);

    return CURLE_OUT_OF_MEMORY;

  }

  if(added)

    *added = TRUE;

  DEBUGF(infof(data, "Added Session ID to cache for %s://%s:%d [%s]",

               store->scheme, store->name, store->remote_port,

               Curl_ssl_cf_is_proxy(cf) ? "PROXY" : "server"));

  return CURLE_OK;

}

void Curl_free_multi_ssl_backend_data(struct multi_ssl_backend_data *mbackend)

{

  if(Curl_ssl->free_multi_ssl_backend_data && mbackend)

    Curl_ssl->free_multi_ssl_backend_data(mbackend);

}

void Curl_ssl_close_all(struct Curl_easy *data)

{

  /* kill the session ID cache if not shared */

  if(data->state.session && !SSLSESSION_SHARED(data)) {

    size_t i;

    for(i = 0; i < data->set.general_ssl.max_ssl_sessions; i++)

      /* the single-killer function handles empty table slots */

      Curl_ssl_kill_session(&data->state.session[i]);

    /* free the cache data */

    Curl_safefree(data->state.session);

  }

  Curl_ssl->close_all(data);

}

void Curl_ssl_adjust_pollset(struct Curl_cfilter *cf, struct Curl_easy *data,

                              struct easy_pollset *ps)

{

  if(!cf->connected) {

    struct ssl_connect_data *connssl = cf->ctx;

    curl_socket_t sock = Curl_conn_cf_get_socket(cf->next, data);

    if(sock != CURL_SOCKET_BAD) {

      if(connssl->connecting_state == ssl_connect_2_writing) {

        Curl_pollset_set_out_only(data, ps, sock);

      }

      else {

        Curl_pollset_set_in_only(data, ps, sock);

      }

    }

  }

}

/* Selects an SSL crypto engine

 */

CURLcode Curl_ssl_set_engine(struct Curl_easy *data, const char *engine)

{

  return Curl_ssl->set_engine(data, engine);

}

/* Selects the default SSL crypto engine

 */

CURLcode Curl_ssl_set_engine_default(struct Curl_easy *data)

{

  return Curl_ssl->set_engine_default(data);

}

/* Return list of OpenSSL crypto engine names. */

struct curl_slist *Curl_ssl_engines_list(struct Curl_easy *data)

{

  return Curl_ssl->engines_list(data);

}

/*

 * This sets up a session ID cache to the specified size. Make sure this code

 * is agnostic to what underlying SSL technology we use.

 */

CURLcode Curl_ssl_initsessions(struct Curl_easy *data, size_t amount)

{

  struct Curl_ssl_session *session;

  if(data->state.session)

    /* this is just a precaution to prevent multiple inits */

    return CURLE_OK;

  session = calloc(amount, sizeof(struct Curl_ssl_session));

  if(!session)

    return CURLE_OUT_OF_MEMORY;

  /* store the info in the SSL section */

  data->set.general_ssl.max_ssl_sessions = amount;

  data->state.session = session;

  data->state.sessionage = 1; /* this is brand new */

  return CURLE_OK;

}

static size_t multissl_version(char *buffer, size_t size);

void Curl_ssl_version(char *buffer, size_t size)

{

#ifdef CURL_WITH_MULTI_SSL

  (void)multissl_version(buffer, size);

#else

  (void)Curl_ssl->version(buffer, size);

#endif

}

void Curl_ssl_free_certinfo(struct Curl_easy *data)

{

  struct curl_certinfo *ci = &data->info.certs;

  if(ci->num_of_certs) {

    /* free all individual lists used */

    int i;

    for(i = 0; i<ci->num_of_certs; i++) {

      curl_slist_free_all(ci->certinfo[i]);

      ci->certinfo[i] = NULL;

    }

    free(ci->certinfo); /* free the actual array too */

    ci->certinfo = NULL;

    ci->num_of_certs = 0;

  }

}

CURLcode Curl_ssl_init_certinfo(struct Curl_easy *data, int num)

{

  struct curl_certinfo *ci = &data->info.certs;

  struct curl_slist **table;

  /* Free any previous certificate information structures */

  Curl_ssl_free_certinfo(data);

  /* Allocate the required certificate information structures */

  table = calloc((size_t) num, sizeof(struct curl_slist *));

  if(!table)

    return CURLE_OUT_OF_MEMORY;

  ci->num_of_certs = num;

  ci->certinfo = table;

  return CURLE_OK;

}

/*

 * 'value' is NOT a null-terminated string

 */

CURLcode Curl_ssl_push_certinfo_len(struct Curl_easy *data,

                                    int certnum,

                                    const char *label,

                                    const char *value,

                                    size_t valuelen)

{

  struct curl_certinfo *ci = &data->info.certs;

  struct curl_slist *nl;

  CURLcode result = CURLE_OK;

  struct dynbuf build;

  Curl_dyn_init(&build, 10000);

  if(Curl_dyn_add(&build, label) ||

     Curl_dyn_addn(&build, ":", 1) ||

     Curl_dyn_addn(&build, value, valuelen))

    return CURLE_OUT_OF_MEMORY;

  nl = Curl_slist_append_nodup(ci->certinfo[certnum],

                               Curl_dyn_ptr(&build));

  if(!nl) {

    Curl_dyn_free(&build);

    curl_slist_free_all(ci->certinfo[certnum]);

    result = CURLE_OUT_OF_MEMORY;

  }

  ci->certinfo[certnum] = nl;

  return result;

}

CURLcode Curl_ssl_random(struct Curl_easy *data,

                         unsigned char *entropy,

                         size_t length)

{

  return Curl_ssl->random(data, entropy, length);

}

/*

 * Public key pem to der conversion

 */

static CURLcode pubkey_pem_to_der(const char *pem,

                                  unsigned char **der, size_t *der_len)

{

  char *stripped_pem, *begin_pos, *end_pos;

  size_t pem_count, stripped_pem_count = 0, pem_len;

  CURLcode result;

  /* if no pem, exit. */

  if(!pem)

    return CURLE_BAD_CONTENT_ENCODING;

  begin_pos = strstr(pem, "-----BEGIN PUBLIC KEY-----");

  if(!begin_pos)

    return CURLE_BAD_CONTENT_ENCODING;

  pem_count = begin_pos - pem;

  /* Invalid if not at beginning AND not directly following \n */

  if(0 != pem_count && '\n' != pem[pem_count - 1])

    return CURLE_BAD_CONTENT_ENCODING;

  /* 26 is length of "-----BEGIN PUBLIC KEY-----" */

  pem_count += 26;

  /* Invalid if not directly following \n */

  end_pos = strstr(pem + pem_count, "\n-----END PUBLIC KEY-----");

  if(!end_pos)

    return CURLE_BAD_CONTENT_ENCODING;

  pem_len = end_pos - pem;

  stripped_pem = malloc(pem_len - pem_count + 1);

  if(!stripped_pem)

    return CURLE_OUT_OF_MEMORY;

  /*

   * Here we loop through the pem array one character at a time between the

   * correct indices, and place each character that is not '\n' or '\r'

   * into the stripped_pem array, which should represent the raw base64 string

   */

  while(pem_count < pem_len) {

    if('\n' != pem[pem_count] && '\r' != pem[pem_count])

      stripped_pem[stripped_pem_count++] = pem[pem_count];

    ++pem_count;

  }

  /* Place the null terminator in the correct place */

  stripped_pem[stripped_pem_count] = '\0';

  result = Curl_base64_decode(stripped_pem, der, der_len);

  Curl_safefree(stripped_pem);

  return result;

}

/*

 * Generic pinned public key check.

 */

CURLcode Curl_pin_peer_pubkey(struct Curl_easy *data,

                              const char *pinnedpubkey,

                              const unsigned char *pubkey, size_t pubkeylen)

{

  FILE *fp;

  unsigned char *buf = NULL, *pem_ptr = NULL;

  CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;

#ifdef CURL_DISABLE_VERBOSE_STRINGS

  (void)data;

#endif

  /* if a path wasn't specified, don't pin */

  if(!pinnedpubkey)

    return CURLE_OK;

  if(!pubkey || !pubkeylen)

    return result;

  /* only do this if pinnedpubkey starts with "sha256//", length 8 */

  if(strncmp(pinnedpubkey, "sha256//", 8) == 0) {

    CURLcode encode;

    size_t encodedlen = 0;

    char *encoded = NULL, *pinkeycopy, *begin_pos, *end_pos;

    unsigned char *sha256sumdigest;

    if(!Curl_ssl->sha256sum) {

      /* without sha256 support, this cannot match */

      return result;

    }

    /* compute sha256sum of public key */

    sha256sumdigest = malloc(CURL_SHA256_DIGEST_LENGTH);

    if(!sha256sumdigest)

      return CURLE_OUT_OF_MEMORY;

    encode = Curl_ssl->sha256sum(pubkey, pubkeylen,

                                 sha256sumdigest, CURL_SHA256_DIGEST_LENGTH);

    if(!encode)

      encode = Curl_base64_encode((char *)sha256sumdigest,

                                  CURL_SHA256_DIGEST_LENGTH, &encoded,

                                  &encodedlen);

    Curl_safefree(sha256sumdigest);

    if(encode)

      return encode;

    infof(data, " public key hash: sha256//%s", encoded);

    /* it starts with sha256//, copy so we can modify it */

    pinkeycopy = strdup(pinnedpubkey);

    if(!pinkeycopy) {

      Curl_safefree(encoded);

      return CURLE_OUT_OF_MEMORY;

    }

    /* point begin_pos to the copy, and start extracting keys */

    begin_pos = pinkeycopy;

    do {

      end_pos = strstr(begin_pos, ";sha256//");

      /*

       * if there is an end_pos, null terminate,

       * otherwise it'll go to the end of the original string

       */

      if(end_pos)

        end_pos[0] = '\0';

      /* compare base64 sha256 digests, 8 is the length of "sha256//" */

      if(encodedlen == strlen(begin_pos + 8) &&

         !memcmp(encoded, begin_pos + 8, encodedlen)) {

        result = CURLE_OK;

        break;

      }

      /*

       * change back the null-terminator we changed earlier,

       * and look for next begin

       */

      if(end_pos) {

        end_pos[0] = ';';

        begin_pos = strstr(end_pos, "sha256//");

      }

    } while(end_pos && begin_pos);

    Curl_safefree(encoded);