luna - curl/lib/vtls/schannel.c

   1/***************************************************************************
   2 *                                  _   _ ____  _
   3 *  Project                     ___| | | |  _ \| |
   4 *                             / __| | | | |_) | |
   5 *                            | (__| |_| |  _ <| |___
   6 *                             \___|\___/|_| \_\_____|
   7 *
   8 * Copyright (C) Daniel Stenberg, <daniel@haxx.se>, et al.
   9 * Copyright (C) Marc Hoersken, <info@marc-hoersken.de>
  10 * Copyright (C) Mark Salisbury, <mark.salisbury@hp.com>
  11 *
  12 * This software is licensed as described in the file COPYING, which
  13 * you should have received as part of this distribution. The terms
  14 * are also available at https://curl.se/docs/copyright.html.
  15 *
  16 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
  17 * copies of the Software, and permit persons to whom the Software is
  18 * furnished to do so, under the terms of the COPYING file.
  19 *
  20 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21 * KIND, either express or implied.
  22 *
  23 * SPDX-License-Identifier: curl
  24 *
  25 ***************************************************************************/
  26/*
  27 * Source file for all Schannel-specific code for the TLS/SSL layer. No code
  28 * but vtls.c should ever call or use these functions.
  29 */
  30#include "curl_setup.h"
  31
  32#ifdef USE_SCHANNEL
  33
  34#ifndef USE_WINDOWS_SSPI
  35#error "cannot compile Schannel support without SSPI."
  36#endif
  37
  38#include "vtls/schannel.h"
  39#include "vtls/schannel_int.h"
  40#include "vtls/vtls.h"
  41#include "vtls/vtls_int.h"
  42#include "vtls/vtls_scache.h"
  43#include "curl_trc.h"
  44#include "connect.h" /* for the connect timeout */
  45#include "curlx/strdup.h"
  46#include "strerror.h"
  47#include "select.h" /* for the socket readiness */
  48#include "curlx/fopen.h"
  49#include "curlx/multibyte.h"
  50#include "vtls/x509asn1.h"
  51#include "system_win32.h"
  52#include "curlx/version_win32.h"
  53#include "rand.h"
  54#include "curlx/strparse.h"
  55#include "progress.h"
  56#include "curl_sha256.h"
  57
  58/* Some verbose debug messages are wrapped by SCH_DEV() instead of DEBUGF()
  59 * and only shown if CURL_SCHANNEL_DEV_DEBUG was defined at build time. These
  60 * messages are extra verbose and intended for curl developers debugging
  61 * Schannel recv decryption and renegotiation.
  62 */
  63#ifdef CURL_SCHANNEL_DEV_DEBUG
  64#define SCH_DEV(x) x
  65#define SCH_DEV_SHOWBOOL(x)                                   \
  66  infof(data, "schannel: " #x " %s", (x) ? "TRUE" : "FALSE");
  67#else
  68#define SCH_DEV(x) do {} while(0)
  69#define SCH_DEV_SHOWBOOL(x) do {} while(0)
  70#endif
  71
  72/* Offered by mingw-w64 v8+, MS SDK 7.0A/VS2010+ */
  73#ifndef SP_PROT_TLS1_0_CLIENT
  74#define SP_PROT_TLS1_0_CLIENT           SP_PROT_TLS1_CLIENT
  75#endif
  76#ifndef SP_PROT_TLS1_1_CLIENT
  77#define SP_PROT_TLS1_1_CLIENT           0x00000200
  78#endif
  79#ifndef SP_PROT_TLS1_2_CLIENT
  80#define SP_PROT_TLS1_2_CLIENT           0x00000800
  81#endif
  82
  83/* Offered by mingw-w64 v8+, MS SDK 10.0.15063.0/VS2017 15.1+ */
  84#ifndef SP_PROT_TLS1_3_CLIENT
  85#define SP_PROT_TLS1_3_CLIENT           0x00002000
  86#endif
  87/* Offered by mingw-w64 v8+, MS SDK 8.1/~VS2013+ */
  88#ifndef SCH_USE_STRONG_CRYPTO
  89#define SCH_USE_STRONG_CRYPTO           0x00400000
  90#endif
  91
  92/* Offered by mingw-w64 v10+, MS SDK 7.0A/VS2010+ */
  93#ifndef SECBUFFER_ALERT
  94#define SECBUFFER_ALERT                 17
  95#endif
  96
  97/* Both schannel buffer sizes must be > 0 */
  98#define CURL_SCHANNEL_BUFFER_INIT_SIZE   4096
  99#define CURL_SCHANNEL_BUFFER_FREE_SIZE   1024
 100
 101#define CERT_THUMBPRINT_STR_LEN 40
 102#define CERT_THUMBPRINT_DATA_LEN 20
 103
 104/* Uncomment to force verbose output
 105 * #define infof(x, y, ...) curl_mprintf(y, __VA_ARGS__)
 106 * #define failf(x, y, ...) curl_mprintf(y, __VA_ARGS__)
 107 */
 108
 109/* Offered by mingw-w64 v4+, MS SDK 6.0A/VS2008+ */
 110#ifndef PKCS12_NO_PERSIST_KEY
 111#define PKCS12_NO_PERSIST_KEY 0x00008000
 112#endif
 113
 114/* Offered by mingw-w64 v4+, MS SDK 8.0/~VS2012+ */
 115#ifndef CERT_FIND_HAS_PRIVATE_KEY
 116#define CERT_FIND_HAS_PRIVATE_KEY (21 << CERT_COMPARE_SHIFT)
 117#endif
 118
 119/* key to use at `multi->proto_hash` */
 120#define MPROTO_SCHANNEL_CERT_SHARE_KEY   "tls:schannel:cert:share"
 121
 122/* ALPN requires version 8.1 of the Windows SDK, which was
 123   shipped with Visual Studio 2013, aka _MSC_VER 1800:
 124     https://learn.microsoft.com/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/hh831771
 125   Or mingw-w64 9.0 or upper.
 126*/
 127#if (defined(__MINGW64_VERSION_MAJOR) && __MINGW64_VERSION_MAJOR >= 9) || \
 128  (defined(_MSC_VER) && (_MSC_VER >= 1800) && !defined(_USING_V110_SDK71_))
 129#define HAS_ALPN_SCHANNEL
 130static bool s_win_has_alpn;
 131#endif
 132
 133static void InitSecBuffer(SecBuffer *buffer, unsigned long BufType,
 134                          void *BufDataPtr, unsigned long BufByteSize)
 135{
 136  buffer->cbBuffer = BufByteSize;
 137  buffer->BufferType = BufType;
 138  buffer->pvBuffer = BufDataPtr;
 139}
 140
 141static void InitSecBufferDesc(SecBufferDesc *desc, SecBuffer *BufArr,
 142                              unsigned long NumArrElem)
 143{
 144  desc->ulVersion = SECBUFFER_VERSION;
 145  desc->pBuffers = BufArr;
 146  desc->cBuffers = NumArrElem;
 147}
 148
 149static CURLcode schannel_set_ssl_version_min_max(DWORD *enabled_protocols,
 150                                                 struct Curl_cfilter *cf,
 151                                                 struct Curl_easy *data)
 152{
 153  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
 154  long ssl_version = conn_config->version;
 155  long ssl_version_max = (long)conn_config->version_max;
 156  long i = ssl_version;
 157
 158  switch(ssl_version_max) {
 159  case CURL_SSLVERSION_MAX_NONE:
 160  case CURL_SSLVERSION_MAX_DEFAULT:
 161
 162    /* Windows Server 2022 and newer (including Windows 11) support TLS 1.3
 163       built-in. Previous builds of Windows 10 had broken TLS 1.3
 164       implementations that could be enabled via registry.
 165    */
 166    if(curlx_verify_windows_version(10, 0, 20348, PLATFORM_WINNT,
 167                                    VERSION_GREATER_THAN_EQUAL)) {
 168      ssl_version_max = CURL_SSLVERSION_MAX_TLSv1_3;
 169    }
 170    else /* Windows 10 and older */
 171      ssl_version_max = CURL_SSLVERSION_MAX_TLSv1_2;
 172
 173    break;
 174  }
 175
 176  for(; i <= (ssl_version_max >> 16); ++i) {
 177    switch(i) {
 178    case CURL_SSLVERSION_TLSv1_0:
 179      *enabled_protocols |= SP_PROT_TLS1_0_CLIENT;
 180      break;
 181    case CURL_SSLVERSION_TLSv1_1:
 182      *enabled_protocols |= SP_PROT_TLS1_1_CLIENT;
 183      break;
 184    case CURL_SSLVERSION_TLSv1_2:
 185      *enabled_protocols |= SP_PROT_TLS1_2_CLIENT;
 186      break;
 187    case CURL_SSLVERSION_TLSv1_3:
 188
 189      /* Windows Server 2022 and newer */
 190      if(curlx_verify_windows_version(10, 0, 20348, PLATFORM_WINNT,
 191                                      VERSION_GREATER_THAN_EQUAL)) {
 192        *enabled_protocols |= SP_PROT_TLS1_3_CLIENT;
 193        break;
 194      }
 195      else { /* Windows 10 and older */
 196        failf(data, "schannel: TLS 1.3 not supported on Windows prior to 11");
 197        return CURLE_SSL_CONNECT_ERROR;
 198      }
 199    }
 200  }
 201  return CURLE_OK;
 202}
 203
 204#define CIPHEROPTION(x) { #x, x }
 205
 206struct algo {
 207  const char *name;
 208  int id;
 209};
 210
 211static const struct algo algs[] = {
 212  CIPHEROPTION(CALG_MD2),
 213  CIPHEROPTION(CALG_MD4),
 214  CIPHEROPTION(CALG_MD5),
 215  CIPHEROPTION(CALG_SHA),
 216  CIPHEROPTION(CALG_SHA1),
 217  CIPHEROPTION(CALG_MAC),
 218  CIPHEROPTION(CALG_RSA_SIGN),
 219  CIPHEROPTION(CALG_DSS_SIGN),
 220  CIPHEROPTION(CALG_NO_SIGN),
 221  CIPHEROPTION(CALG_RSA_KEYX),
 222  CIPHEROPTION(CALG_DES),
 223  CIPHEROPTION(CALG_3DES_112),
 224  CIPHEROPTION(CALG_3DES),
 225  CIPHEROPTION(CALG_DESX),
 226  CIPHEROPTION(CALG_RC2),
 227  CIPHEROPTION(CALG_RC4),
 228  CIPHEROPTION(CALG_SEAL),
 229  CIPHEROPTION(CALG_DH_SF),
 230  CIPHEROPTION(CALG_DH_EPHEM),
 231  CIPHEROPTION(CALG_AGREEDKEY_ANY),
 232  CIPHEROPTION(CALG_HUGHES_MD5),
 233  CIPHEROPTION(CALG_SKIPJACK),
 234  CIPHEROPTION(CALG_TEK),
 235  CIPHEROPTION(CALG_CYLINK_MEK), /* spellchecker:disable-line */
 236  CIPHEROPTION(CALG_SSL3_SHAMD5),
 237  CIPHEROPTION(CALG_SSL3_MASTER),
 238  CIPHEROPTION(CALG_SCHANNEL_MASTER_HASH),
 239  CIPHEROPTION(CALG_SCHANNEL_MAC_KEY),
 240  CIPHEROPTION(CALG_SCHANNEL_ENC_KEY),
 241  CIPHEROPTION(CALG_PCT1_MASTER),
 242  CIPHEROPTION(CALG_SSL2_MASTER),
 243  CIPHEROPTION(CALG_TLS1_MASTER),
 244  CIPHEROPTION(CALG_RC5),
 245  CIPHEROPTION(CALG_HMAC),
 246  CIPHEROPTION(CALG_TLS1PRF),
 247  CIPHEROPTION(CALG_HASH_REPLACE_OWF),
 248  CIPHEROPTION(CALG_AES_128),
 249  CIPHEROPTION(CALG_AES_192),
 250  CIPHEROPTION(CALG_AES_256),
 251  CIPHEROPTION(CALG_AES),
 252  CIPHEROPTION(CALG_SHA_256),
 253  CIPHEROPTION(CALG_SHA_384),
 254  CIPHEROPTION(CALG_SHA_512),
 255  CIPHEROPTION(CALG_ECDH),
 256/* Offered by mingw-w64 v4+, MS SDK 6.0A/VS2008+ */
 257#ifdef CALG_ECMQV
 258  CIPHEROPTION(CALG_ECMQV),
 259#endif
 260  CIPHEROPTION(CALG_ECDSA),
 261/* Offered by mingw-w64 v7+, MS SDK 7.0A/VS2010+ */
 262#ifdef CALG_ECDH_EPHEM
 263  CIPHEROPTION(CALG_ECDH_EPHEM),
 264#endif
 265  { NULL, 0 },
 266};
 267
 268static int get_alg_id_by_name(const char *name)
 269{
 270  const char *nameEnd = strchr(name, ':');
 271  size_t n = nameEnd ? (size_t)(nameEnd - name) : strlen(name);
 272  int i;
 273
 274  for(i = 0; algs[i].name; i++) {
 275    if((n == strlen(algs[i].name) && !strncmp(algs[i].name, name, n)))
 276      return algs[i].id;
 277  }
 278  return 0; /* not found */
 279}
 280
 281#define NUM_CIPHERS 47 /* There are a maximum of 47 options listed above */
 282
 283static CURLcode set_ssl_ciphers(SCHANNEL_CRED *schannel_cred, char *ciphers,
 284                                ALG_ID *algIds)
 285{
 286  const char *startCur = ciphers;
 287  int algCount = 0;
 288  while(startCur && *startCur && (algCount < NUM_CIPHERS)) {
 289    curl_off_t alg;
 290    if(curlx_str_number(&startCur, &alg, INT_MAX) || !alg)
 291      alg = get_alg_id_by_name(startCur);
 292
 293    if(alg)
 294      algIds[algCount++] = (ALG_ID)alg;
 295    else if(!strncmp(startCur, "USE_STRONG_CRYPTO",
 296                     sizeof("USE_STRONG_CRYPTO") - 1) ||
 297            !strncmp(startCur, "SCH_USE_STRONG_CRYPTO",
 298                     sizeof("SCH_USE_STRONG_CRYPTO") - 1))
 299      schannel_cred->dwFlags |= SCH_USE_STRONG_CRYPTO;
 300    else
 301      return CURLE_SSL_CIPHER;
 302    startCur = strchr(startCur, ':');
 303    if(startCur)
 304      startCur++;
 305  }
 306  schannel_cred->palgSupportedAlgs = algIds;
 307  schannel_cred->cSupportedAlgs = (DWORD)algCount;
 308  return CURLE_OK;
 309}
 310
 311/* Function allocates memory for store_path only if CURLE_OK is returned */
 312static CURLcode get_cert_location(TCHAR *path, DWORD *store_name,
 313                                  TCHAR **store_path, TCHAR **thumbprint)
 314{
 315  TCHAR *sep;
 316  TCHAR *store_path_start;
 317  size_t store_name_len;
 318
 319  sep = _tcschr(path, TEXT('\\'));
 320  if(!sep)
 321    return CURLE_SSL_CERTPROBLEM;
 322
 323  store_name_len = sep - path;
 324
 325  if(_tcsncmp(path, TEXT("CurrentUser"), store_name_len) == 0)
 326    *store_name = CERT_SYSTEM_STORE_CURRENT_USER;
 327  else if(_tcsncmp(path, TEXT("LocalMachine"), store_name_len) == 0)
 328    *store_name = CERT_SYSTEM_STORE_LOCAL_MACHINE;
 329  else if(_tcsncmp(path, TEXT("CurrentService"), store_name_len) == 0)
 330    *store_name = CERT_SYSTEM_STORE_CURRENT_SERVICE;
 331  else if(_tcsncmp(path, TEXT("Services"), store_name_len) == 0)
 332    *store_name = CERT_SYSTEM_STORE_SERVICES;
 333  else if(_tcsncmp(path, TEXT("Users"), store_name_len) == 0)
 334    *store_name = CERT_SYSTEM_STORE_USERS;
 335  else if(_tcsncmp(path, TEXT("CurrentUserGroupPolicy"), store_name_len) == 0)
 336    *store_name = CERT_SYSTEM_STORE_CURRENT_USER_GROUP_POLICY;
 337  else if(_tcsncmp(path, TEXT("LocalMachineGroupPolicy"), store_name_len) == 0)
 338    *store_name = CERT_SYSTEM_STORE_LOCAL_MACHINE_GROUP_POLICY;
 339  else if(_tcsncmp(path, TEXT("LocalMachineEnterprise"), store_name_len) == 0)
 340    *store_name = CERT_SYSTEM_STORE_LOCAL_MACHINE_ENTERPRISE;
 341  else
 342    return CURLE_SSL_CERTPROBLEM;
 343
 344  store_path_start = sep + 1;
 345
 346  sep = _tcschr(store_path_start, TEXT('\\'));
 347  if(!sep)
 348    return CURLE_SSL_CERTPROBLEM;
 349
 350  *thumbprint = sep + 1;
 351  if(_tcslen(*thumbprint) != CERT_THUMBPRINT_STR_LEN)
 352    return CURLE_SSL_CERTPROBLEM;
 353
 354  *sep = TEXT('\0');
 355  *store_path = curlx_tcsdup(store_path_start);
 356  *sep = TEXT('\\');
 357  if(!*store_path)
 358    return CURLE_OUT_OF_MEMORY;
 359
 360  return CURLE_OK;
 361}
 362
 363static CURLcode get_client_cert(struct Curl_easy *data,
 364                                HCERTSTORE *out_cert_store,
 365                                PCCERT_CONTEXT *out_cert_context)
 366{
 367  PCCERT_CONTEXT client_cert = NULL;
 368  HCERTSTORE client_cert_store = NULL;
 369  CURLcode result = CURLE_OK;
 370
 371  if(data->set.ssl.primary.clientcert || data->set.ssl.primary.cert_blob) {
 372    DWORD cert_store_name = 0;
 373    TCHAR *cert_store_path = NULL;
 374    TCHAR *cert_thumbprint_str = NULL;
 375    TCHAR cert_thumbprint_buf[CERT_THUMBPRINT_STR_LEN + 1];
 376    CRYPT_HASH_BLOB cert_thumbprint;
 377    BYTE cert_thumbprint_data[CERT_THUMBPRINT_DATA_LEN];
 378    HCERTSTORE cert_store = NULL;
 379    FILE *fInCert = NULL;
 380    void *certdata = NULL;
 381    size_t certsize = 0;
 382    bool blob = data->set.ssl.primary.cert_blob != NULL;
 383
 384    if(blob) {
 385      certdata = data->set.ssl.primary.cert_blob->data;
 386      certsize = data->set.ssl.primary.cert_blob->len;
 387    }
 388    else {
 389      TCHAR *cert_path =
 390        curlx_convert_UTF8_to_tchar(data->set.ssl.primary.clientcert);
 391      if(!cert_path)
 392        return CURLE_OUT_OF_MEMORY;
 393
 394      result = get_cert_location(cert_path, &cert_store_name,
 395                                 &cert_store_path, &cert_thumbprint_str);
 396
 397      /* 'cert_thumbprint_str' points in to the allocated 'cert_path', copy
 398         the data. The string is verified to be CERT_THUMBPRINT_STR_LEN bytes
 399         long within the get_cert_location() function. */
 400      if(!result && cert_thumbprint_str) {
 401        memcpy(cert_thumbprint_buf, cert_thumbprint_str,
 402               sizeof(cert_thumbprint_buf));
 403        cert_thumbprint_str = cert_thumbprint_buf;
 404      }
 405
 406      curlx_free(cert_path);
 407      if(result && (data->set.ssl.primary.clientcert[0] != '\0'))
 408        fInCert = curlx_fopen(data->set.ssl.primary.clientcert, "rb");
 409
 410      if(result && !fInCert) {
 411        failf(data, "schannel: Failed to get certificate location"
 412              " or file for %s",
 413              data->set.ssl.primary.clientcert);
 414        return result;
 415      }
 416    }
 417
 418    if((fInCert || blob) && data->set.ssl.cert_type &&
 419       !curl_strequal(data->set.ssl.cert_type, "P12")) {
 420      failf(data, "schannel: certificate format compatibility error "
 421            "for %s",
 422            blob ? "(memory blob)" : data->set.ssl.primary.clientcert);
 423      curlx_free(cert_store_path);
 424      if(fInCert)
 425        curlx_fclose(fInCert);
 426      return CURLE_SSL_CERTPROBLEM;
 427    }
 428
 429    if(fInCert || blob) {
 430      /* Reading a .p12 or .pfx file, like the example at bottom of
 431         https://learn.microsoft.com/archive/msdn-technet-forums/3e7bc95f-b21a-4bcd-bd2c-7f996718cae5
 432      */
 433      CRYPT_DATA_BLOB datablob;
 434      WCHAR *pszPassword;
 435      size_t pwd_len = 0;
 436      int cert_find_flags;
 437      const char *cert_showfilename_error = blob ?
 438        "(memory blob)" : data->set.ssl.primary.clientcert;
 439      curlx_free(cert_store_path);
 440      if(fInCert) {
 441        long cert_tell = 0;
 442        bool continue_reading = fseek(fInCert, 0, SEEK_END) == 0;
 443        if(continue_reading)
 444          cert_tell = ftell(fInCert);
 445        if(cert_tell < 0)
 446          continue_reading = FALSE;
 447        else
 448          certsize = (size_t)cert_tell;
 449        if(continue_reading)
 450          continue_reading = fseek(fInCert, 0, SEEK_SET) == 0;
 451        if(continue_reading && (certsize < CURL_MAX_INPUT_LENGTH))
 452          certdata = curlx_malloc(certsize + 1);
 453        if((!certdata) ||
 454           ((int) fread(certdata, certsize, 1, fInCert) != 1))
 455          continue_reading = FALSE;
 456        curlx_fclose(fInCert);
 457        if(!continue_reading) {
 458          failf(data, "schannel: Failed to read cert file %s",
 459                data->set.ssl.primary.clientcert);
 460          curlx_free(certdata);
 461          return CURLE_SSL_CERTPROBLEM;
 462        }
 463      }
 464
 465      /* Convert key-pair data to the in-memory certificate store */
 466      datablob.pbData = (BYTE *)certdata;
 467      datablob.cbData = (DWORD)certsize;
 468
 469      if(data->set.ssl.key_passwd)
 470        pwd_len = strlen(data->set.ssl.key_passwd);
 471      pszPassword = (WCHAR *)curlx_malloc(sizeof(WCHAR) * (pwd_len + 1));
 472      if(pszPassword) {
 473        int str_w_len = 0;
 474        if(pwd_len > 0)
 475          str_w_len = MultiByteToWideChar(CP_UTF8,
 476                                          MB_ERR_INVALID_CHARS,
 477                                          data->set.ssl.key_passwd,
 478                                          (int)pwd_len,
 479                                          pszPassword, (int)(pwd_len + 1));
 480
 481        if((str_w_len >= 0) && (str_w_len <= (int)pwd_len))
 482          pszPassword[str_w_len] = 0;
 483        else
 484          pszPassword[0] = 0;
 485
 486        cert_store = PFXImportCertStore(&datablob, pszPassword,
 487                                        PKCS12_NO_PERSIST_KEY);
 488        curlx_free(pszPassword);
 489      }
 490      if(!blob)
 491        curlx_free(certdata);
 492      if(!cert_store) {
 493        DWORD errorcode = GetLastError();
 494        if(errorcode == ERROR_INVALID_PASSWORD)
 495          failf(data, "schannel: Failed to import cert file %s, "
 496                "password is bad",
 497                cert_showfilename_error);
 498        else
 499          failf(data, "schannel: Failed to import cert file %s, "
 500                "last error is 0x%08lx",
 501                cert_showfilename_error, errorcode);
 502        return CURLE_SSL_CERTPROBLEM;
 503      }
 504
 505      /* CERT_FIND_HAS_PRIVATE_KEY is only available in Windows 8 / Server
 506         2012, (NT v6.2). For earlier versions we use CURL_FIND_ANY. */
 507      if(curlx_verify_windows_version(6, 2, 0, PLATFORM_WINNT,
 508                                      VERSION_GREATER_THAN_EQUAL))
 509        cert_find_flags = CERT_FIND_HAS_PRIVATE_KEY;
 510      else
 511        cert_find_flags = CERT_FIND_ANY;
 512
 513      client_cert =
 514        CertFindCertificateInStore(cert_store,
 515                                   X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0,
 516                                   cert_find_flags, NULL, NULL);
 517
 518      if(!client_cert) {
 519        failf(data, "schannel: Failed to get certificate from file %s"
 520              ", last error is 0x%08lx",
 521              cert_showfilename_error, GetLastError());
 522        CertCloseStore(cert_store, 0);
 523        return CURLE_SSL_CERTPROBLEM;
 524      }
 525    }
 526    else {
 527      cert_store =
 528        CertOpenStore(
 529#ifdef UNICODE
 530                      CERT_STORE_PROV_SYSTEM_W,
 531#else
 532                      CERT_STORE_PROV_SYSTEM_A,
 533#endif
 534                      0,
 535                      (HCRYPTPROV)NULL,
 536                      CERT_STORE_OPEN_EXISTING_FLAG | cert_store_name,
 537                      cert_store_path);
 538      if(!cert_store) {
 539        char *path_utf8 =
 540          curlx_convert_tchar_to_UTF8(cert_store_path);
 541        failf(data, "schannel: Failed to open cert store %lx %s, "
 542              "last error is 0x%08lx",
 543              cert_store_name, (path_utf8 ? path_utf8 : "(unknown)"),
 544              GetLastError());
 545        curlx_free(cert_store_path);
 546        curlx_free(path_utf8);
 547        return CURLE_SSL_CERTPROBLEM;
 548      }
 549      curlx_free(cert_store_path);
 550
 551      cert_thumbprint.pbData = cert_thumbprint_data;
 552      cert_thumbprint.cbData = CERT_THUMBPRINT_DATA_LEN;
 553
 554      if(!CryptStringToBinary(cert_thumbprint_str,
 555                              CERT_THUMBPRINT_STR_LEN,
 556                              CRYPT_STRING_HEX,
 557                              cert_thumbprint_data,
 558                              &cert_thumbprint.cbData,
 559                              NULL, NULL)) {
 560        CertCloseStore(cert_store, 0);
 561        return CURLE_SSL_CERTPROBLEM;
 562      }
 563
 564      client_cert =
 565        CertFindCertificateInStore(cert_store,
 566                                   X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0,
 567                                   CERT_FIND_HASH, &cert_thumbprint, NULL);
 568      if(!client_cert) {
 569        /* CRYPT_E_NOT_FOUND / E_INVALIDARG */
 570        CertCloseStore(cert_store, 0);
 571        failf(data, "schannel: client cert not found in cert store");
 572        return CURLE_SSL_CERTPROBLEM;
 573      }
 574    }
 575    client_cert_store = cert_store;
 576  }
 577
 578  *out_cert_store = client_cert_store;
 579  *out_cert_context = client_cert;
 580
 581  return CURLE_OK;
 582}
 583
 584static CURLcode acquire_sspi_handle(struct Curl_cfilter *cf,
 585                                    struct Curl_easy *data,
 586                                    struct schannel_ssl_backend_data *backend,
 587                                    PCCERT_CONTEXT client_cert,
 588                                    DWORD flags,
 589                                    DWORD enabled_protocols)
 590{
 591  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
 592  SECURITY_STATUS sspi_status = SEC_E_OK;
 593  CURLcode result;
 594
 595  /* We support TLS 1.3 starting in Windows 10 version 1809 (OS build 17763) as
 596     long as the user did not set a legacy algorithm list
 597     (CURLOPT_SSL_CIPHER_LIST). */
 598  if(!conn_config->cipher_list &&
 599     curlx_verify_windows_version(10, 0, 17763, PLATFORM_WINNT,
 600                                  VERSION_GREATER_THAN_EQUAL)) {
 601
 602    SCH_CREDENTIALS credentials = { 0 };
 603    TLS_PARAMETERS tls_parameters = { 0 };
 604    CRYPTO_SETTINGS crypto_settings[1];
 605    PCCERT_CONTEXT client_certs[1];
 606
 607    if(client_cert)
 608      client_certs[0] = client_cert;
 609    else
 610      client_certs[0] = NULL;
 611
 612    memset(crypto_settings, 0, sizeof(crypto_settings));
 613
 614    tls_parameters.pDisabledCrypto = crypto_settings;
 615
 616    /* The number of blocked suites */
 617    tls_parameters.cDisabledCrypto = (DWORD)0;
 618    credentials.pTlsParameters = &tls_parameters;
 619    credentials.cTlsParameters = 1;
 620
 621    credentials.dwVersion = SCH_CREDENTIALS_VERSION;
 622    credentials.dwFlags = flags | SCH_USE_STRONG_CRYPTO;
 623
 624    credentials.pTlsParameters->grbitDisabledProtocols = ~enabled_protocols;
 625
 626    if(client_certs[0]) {
 627      credentials.cCreds = 1;
 628      credentials.paCred = client_certs;
 629    }
 630
 631    sspi_status =
 632      Curl_pSecFn->AcquireCredentialsHandle(NULL,
 633                                            (TCHAR *)CURL_UNCONST(UNISP_NAME),
 634                                            SECPKG_CRED_OUTBOUND, NULL,
 635                                            &credentials, NULL, NULL,
 636                                            &backend->cred->cred_handle, NULL);
 637  }
 638  else {
 639    /* Pre-Windows 10 1809 or the user set a legacy algorithm list.
 640       Schannel does not negotiate TLS 1.3 when SCHANNEL_CRED is used. */
 641    ALG_ID algIds[NUM_CIPHERS];
 642    char *ciphers = conn_config->cipher_list;
 643    SCHANNEL_CRED schannel_cred = { 0 };
 644    PCCERT_CONTEXT client_certs[1];
 645
 646    if(client_cert)
 647      client_certs[0] = client_cert;
 648    else
 649      client_certs[0] = NULL;
 650
 651    schannel_cred.dwVersion = SCHANNEL_CRED_VERSION;
 652    schannel_cred.dwFlags = flags;
 653    schannel_cred.grbitEnabledProtocols = enabled_protocols;
 654
 655    if(ciphers) {
 656      if((enabled_protocols & SP_PROT_TLS1_3_CLIENT)) {
 657        infof(data, "schannel: WARNING: This version of Schannel "
 658              "negotiates a less-secure TLS version than TLS 1.3 because the "
 659              "user set an algorithm cipher list.");
 660      }
 661      result = set_ssl_ciphers(&schannel_cred, ciphers, algIds);
 662      if(result) {
 663        failf(data, "schannel: Failed setting algorithm cipher list");
 664        return result;
 665      }
 666    }
 667    else {
 668      schannel_cred.dwFlags = flags | SCH_USE_STRONG_CRYPTO;
 669    }
 670
 671    if(client_certs[0]) {
 672      schannel_cred.cCreds = 1;
 673      schannel_cred.paCred = client_certs;
 674    }
 675
 676    sspi_status =
 677      Curl_pSecFn->AcquireCredentialsHandle(NULL,
 678                                            (TCHAR *)CURL_UNCONST(UNISP_NAME),
 679                                            SECPKG_CRED_OUTBOUND, NULL,
 680                                            &schannel_cred, NULL, NULL,
 681                                            &backend->cred->cred_handle, NULL);
 682  }
 683
 684  if(sspi_status != SEC_E_OK) {
 685    char buffer[STRERROR_LEN];
 686    failf(data, "schannel: AcquireCredentialsHandle failed: %s",
 687          Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
 688    switch(sspi_status) {
 689    case SEC_E_INSUFFICIENT_MEMORY:
 690      return CURLE_OUT_OF_MEMORY;
 691    case SEC_E_NO_CREDENTIALS:
 692    case SEC_E_SECPKG_NOT_FOUND:
 693    case SEC_E_NOT_OWNER:
 694    case SEC_E_UNKNOWN_CREDENTIALS:
 695    case SEC_E_INTERNAL_ERROR:
 696    default:
 697      return CURLE_SSL_CONNECT_ERROR;
 698    }
 699  }
 700
 701  return CURLE_OK;
 702}
 703
 704static CURLcode schannel_acquire_credential_handle(struct Curl_cfilter *cf,
 705                                                   struct Curl_easy *data)
 706{
 707  struct ssl_connect_data *connssl = cf->ctx;
 708  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
 709  struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
 710
 711  PCCERT_CONTEXT client_cert = NULL;
 712  HCERTSTORE client_cert_store = NULL;
 713  CURLcode result;
 714
 715  /* setup Schannel API options */
 716  DWORD flags = 0;
 717  DWORD enabled_protocols = 0;
 718
 719  struct schannel_ssl_backend_data *backend =
 720    (struct schannel_ssl_backend_data *)(connssl->backend);
 721
 722  DEBUGASSERT(backend);
 723
 724  if(conn_config->verifypeer) {
 725    if(backend->use_manual_cred_validation)
 726      flags = SCH_CRED_MANUAL_CRED_VALIDATION;
 727    else
 728      flags = SCH_CRED_AUTO_CRED_VALIDATION;
 729
 730    if(ssl_config->no_revoke) {
 731      flags |= SCH_CRED_IGNORE_NO_REVOCATION_CHECK |
 732               SCH_CRED_IGNORE_REVOCATION_OFFLINE;
 733
 734      DEBUGF(infof(data, "schannel: disabled server certificate revocation "
 735                         "checks"));
 736    }
 737    else if(ssl_config->revoke_best_effort) {
 738      flags |= SCH_CRED_IGNORE_NO_REVOCATION_CHECK |
 739               SCH_CRED_IGNORE_REVOCATION_OFFLINE |
 740               SCH_CRED_REVOCATION_CHECK_CHAIN;
 741
 742      DEBUGF(infof(data, "schannel: ignore revocation offline errors"));
 743    }
 744    else {
 745      flags |= SCH_CRED_REVOCATION_CHECK_CHAIN;
 746
 747      DEBUGF(infof(data, "schannel: checking server certificate revocation"));
 748    }
 749  }
 750  else {
 751    flags = SCH_CRED_MANUAL_CRED_VALIDATION |
 752            SCH_CRED_IGNORE_NO_REVOCATION_CHECK |
 753            SCH_CRED_IGNORE_REVOCATION_OFFLINE;
 754    DEBUGF(infof(data, "schannel: disabled server cert revocation checks"));
 755  }
 756
 757  if(!conn_config->verifyhost) {
 758    flags |= SCH_CRED_NO_SERVERNAME_CHECK;
 759    DEBUGF(infof(data, "schannel: verifyhost setting prevents Schannel from "
 760                       "comparing the supplied target name with the subject "
 761                       "names in server certificates."));
 762  }
 763
 764  if(!ssl_config->auto_client_cert) {
 765    flags &= ~(DWORD)SCH_CRED_USE_DEFAULT_CREDS;
 766    flags |= SCH_CRED_NO_DEFAULT_CREDS;
 767    infof(data, "schannel: disabled automatic use of client certificate");
 768  }
 769  else
 770    infof(data, "schannel: enabled automatic use of client certificate");
 771
 772  DEBUGASSERT(conn_config->version != CURL_SSLVERSION_DEFAULT);
 773  switch(conn_config->version) {
 774  case CURL_SSLVERSION_TLSv1:
 775  case CURL_SSLVERSION_TLSv1_0:
 776  case CURL_SSLVERSION_TLSv1_1:
 777  case CURL_SSLVERSION_TLSv1_2:
 778  case CURL_SSLVERSION_TLSv1_3: {
 779    result = schannel_set_ssl_version_min_max(&enabled_protocols, cf, data);
 780    if(result)
 781      return result;
 782    break;
 783  }
 784  case CURL_SSLVERSION_SSLv3:
 785  case CURL_SSLVERSION_SSLv2:
 786    failf(data, "SSL versions not supported");
 787    return CURLE_NOT_BUILT_IN;
 788  default:
 789    failf(data, "Unrecognized parameter passed via CURLOPT_SSLVERSION");
 790    return CURLE_SSL_CONNECT_ERROR;
 791  }
 792
 793  result = get_client_cert(data, &client_cert_store, &client_cert);
 794  if(result)
 795    return result;
 796
 797  /* allocate memory for the reusable credential handle */
 798  backend->cred = (struct Curl_schannel_cred *)
 799    curlx_calloc(1, sizeof(struct Curl_schannel_cred));
 800  if(!backend->cred) {
 801    failf(data, "schannel: unable to allocate memory");
 802
 803    if(client_cert)
 804      CertFreeCertificateContext(client_cert);
 805    if(client_cert_store)
 806      CertCloseStore(client_cert_store, 0);
 807
 808    return CURLE_OUT_OF_MEMORY;
 809  }
 810  backend->cred->refcount = 1;
 811
 812  /* Since we did not persist the key, we need to extend the store's
 813   * lifetime until the end of the connection
 814   */
 815  backend->cred->client_cert_store = client_cert_store;
 816
 817  result = acquire_sspi_handle(cf, data, backend, client_cert,
 818                               flags, enabled_protocols);
 819
 820  if(client_cert)
 821    CertFreeCertificateContext(client_cert);
 822
 823  return result;
 824}
 825
 826static CURLcode schannel_connect_step1(struct Curl_cfilter *cf,
 827                                       struct Curl_easy *data)
 828{
 829  size_t written = 0;
 830  struct ssl_connect_data *connssl = cf->ctx;
 831  struct schannel_ssl_backend_data *backend =
 832    (struct schannel_ssl_backend_data *)connssl->backend;
 833  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
 834  struct ssl_config_data *ssl_config = Curl_ssl_cf_get_config(cf, data);
 835  SecBuffer outbuf;
 836  SecBufferDesc outbuf_desc;
 837  SecBuffer inbuf;
 838  SecBufferDesc inbuf_desc;
 839#ifdef HAS_ALPN_SCHANNEL
 840  unsigned char alpn_buffer[128];
 841#endif
 842  SECURITY_STATUS sspi_status = SEC_E_OK;
 843  CURLcode result;
 844
 845  DEBUGASSERT(backend);
 846  DEBUGF(infof(data, "schannel: SSL/TLS connection with %s port %d (step 1/3)",
 847               connssl->peer.dest->hostname, connssl->peer.dest->port));
 848
 849#ifdef HAS_ALPN_SCHANNEL
 850  backend->use_alpn = connssl->alpn && s_win_has_alpn;
 851#else
 852  backend->use_alpn = FALSE;
 853#endif
 854
 855  if(conn_config->CAfile || conn_config->ca_info_blob) {
 856    if(curlx_verify_windows_version(6, 1, 0, PLATFORM_WINNT,
 857                                    VERSION_GREATER_THAN_EQUAL)) {
 858      backend->use_manual_cred_validation = TRUE;
 859    }
 860    else {
 861      failf(data, "schannel: this version of Windows is too old to support "
 862                  "certificate verification via CA bundle file.");
 863      return CURLE_SSL_CACERT_BADFILE;
 864    }
 865  }
 866  else
 867    backend->use_manual_cred_validation = FALSE;
 868
 869  backend->cred = NULL;
 870
 871  /* check for an existing reusable credential handle */
 872  if(Curl_ssl_scache_use(cf, data)) {
 873    struct Curl_schannel_cred *old_cred;
 874    Curl_ssl_scache_lock(data);
 875    old_cred = Curl_ssl_scache_get_obj(cf, data, connssl->peer.scache_key);
 876    if(old_cred) {
 877      backend->cred = old_cred;
 878      DEBUGF(infof(data, "schannel: reusing existing credential handle"));
 879
 880      /* increment the reference counter of the credential/session handle */
 881      backend->cred->refcount++;
 882      DEBUGF(infof(data,
 883                   "schannel: incremented credential handle refcount = %d",
 884                   backend->cred->refcount));
 885    }
 886    Curl_ssl_scache_unlock(data);
 887  }
 888
 889  if(!backend->cred) {
 890    char *snihost;
 891    result = schannel_acquire_credential_handle(cf, data);
 892    if(result || !backend->cred)
 893      return result;
 894    /* schannel_acquire_credential_handle() sets backend->cred accordingly or
 895       it returns error otherwise. */
 896
 897    /* A hostname associated with the credential is needed by
 898       InitializeSecurityContext for SNI and other reasons. */
 899    snihost = connssl->peer.sni ?
 900      connssl->peer.sni : connssl->peer.dest->hostname;
 901    backend->cred->sni_hostname = curlx_convert_UTF8_to_tchar(snihost);
 902    if(!backend->cred->sni_hostname)
 903      return CURLE_OUT_OF_MEMORY;
 904  }
 905
 906  /* Warn if SNI is disabled due to use of an IP address */
 907  if(connssl->peer.type != CURL_SSL_PEER_DNS) {
 908    infof(data, "schannel: using IP address, SNI is not supported by OS.");
 909  }
 910
 911#ifdef HAS_ALPN_SCHANNEL
 912  if(backend->use_alpn) {
 913    int cur = 0;
 914    int list_start_index = 0;
 915    unsigned int *extension_len = NULL;
 916    unsigned short *list_len = NULL;
 917    struct alpn_proto_buf proto;
 918
 919    /* The first four bytes is an unsigned int indicating number
 920       of bytes of data in the rest of the buffer. */
 921    extension_len = (unsigned int *)(void *)(&alpn_buffer[cur]);
 922    cur += (int)sizeof(unsigned int);
 923
 924    /* The next four bytes are an indicator that this buffer contains
 925       ALPN data, as opposed to NPN, for example. */
 926    *(unsigned int *)(void *)&alpn_buffer[cur] =
 927      SecApplicationProtocolNegotiationExt_ALPN;
 928    cur += (int)sizeof(unsigned int);
 929
 930    /* The next two bytes is an unsigned short indicating the number
 931       of bytes used to list the preferred protocols. */
 932    list_len = (unsigned short *)(void *)(&alpn_buffer[cur]);
 933    cur += (int)sizeof(unsigned short);
 934
 935    list_start_index = cur;
 936
 937    result = Curl_alpn_to_proto_buf(&proto, connssl->alpn);
 938    if(result) {
 939      failf(data, "Error setting ALPN");
 940      return CURLE_SSL_CONNECT_ERROR;
 941    }
 942    memcpy(&alpn_buffer[cur], proto.data, proto.len);
 943    cur += proto.len;
 944
 945    *list_len = curlx_uitous(cur - list_start_index);
 946    *extension_len = (unsigned int)(*list_len +
 947      sizeof(unsigned int) + sizeof(unsigned short));
 948
 949    InitSecBuffer(&inbuf, SECBUFFER_APPLICATION_PROTOCOLS, alpn_buffer, cur);
 950    InitSecBufferDesc(&inbuf_desc, &inbuf, 1);
 951
 952    Curl_alpn_to_proto_str(&proto, connssl->alpn);
 953    infof(data, VTLS_INFOF_ALPN_OFFER_1STR, proto.data);
 954  }
 955  else {
 956    InitSecBuffer(&inbuf, SECBUFFER_EMPTY, NULL, 0);
 957    InitSecBufferDesc(&inbuf_desc, &inbuf, 1);
 958  }
 959#else /* HAS_ALPN_SCHANNEL */
 960  InitSecBuffer(&inbuf, SECBUFFER_EMPTY, NULL, 0);
 961  InitSecBufferDesc(&inbuf_desc, &inbuf, 1);
 962#endif
 963
 964  /* setup output buffer */
 965  InitSecBuffer(&outbuf, SECBUFFER_EMPTY, NULL, 0);
 966  InitSecBufferDesc(&outbuf_desc, &outbuf, 1);
 967
 968  /* security request flags */
 969  backend->req_flags =
 970    ISC_REQ_SEQUENCE_DETECT | ISC_REQ_REPLAY_DETECT |
 971    ISC_REQ_CONFIDENTIALITY | ISC_REQ_ALLOCATE_MEMORY |
 972    ISC_REQ_STREAM |
 973    (!ssl_config->auto_client_cert ? ISC_REQ_USE_SUPPLIED_CREDS : 0);
 974
 975  /* allocate memory for the security context handle */
 976  backend->ctxt = (struct Curl_schannel_ctxt *)
 977    curlx_calloc(1, sizeof(struct Curl_schannel_ctxt));
 978  if(!backend->ctxt) {
 979    failf(data, "schannel: unable to allocate memory");
 980    return CURLE_OUT_OF_MEMORY;
 981  }
 982
 983  /* Schannel InitializeSecurityContext:
 984     https://learn.microsoft.com/windows/win32/api/rrascfg/nn-rrascfg-ieapproviderconfig
 985
 986     At the moment we do not pass inbuf unless we are using ALPN since we only
 987     use it for that, and WINE (for which we currently disable ALPN) is giving
 988     us problems with inbuf regardless. https://github.com/curl/curl/issues/983
 989  */
 990  sspi_status = Curl_pSecFn->InitializeSecurityContext(
 991    &backend->cred->cred_handle, NULL, backend->cred->sni_hostname,
 992    backend->req_flags, 0, 0,
 993    (backend->use_alpn ? &inbuf_desc : NULL),
 994    0, &backend->ctxt->ctxt_handle,
 995    &outbuf_desc, &backend->ret_flags, NULL);
 996
 997  if(sspi_status != SEC_I_CONTINUE_NEEDED) {
 998    char buffer[STRERROR_LEN];
 999    curlx_safefree(backend->ctxt);
1000    switch(sspi_status) {
1001    case SEC_E_INSUFFICIENT_MEMORY:
1002      failf(data, "schannel: initial InitializeSecurityContext failed: %s",
1003            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1004      return CURLE_OUT_OF_MEMORY;
1005    case SEC_E_WRONG_PRINCIPAL:
1006      failf(data, "schannel: SNI or certificate check failed: %s",
1007            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1008      return CURLE_PEER_FAILED_VERIFICATION;
1009#if 0
1010    case SEC_E_INVALID_HANDLE:
1011    case SEC_E_INVALID_TOKEN:
1012    case SEC_E_LOGON_DENIED:
1013    case SEC_E_TARGET_UNKNOWN:
1014    case SEC_E_NO_AUTHENTICATING_AUTHORITY:
1015    case SEC_E_INTERNAL_ERROR:
1016    case SEC_E_NO_CREDENTIALS:
1017    case SEC_E_UNSUPPORTED_FUNCTION:
1018    case SEC_E_APPLICATION_PROTOCOL_MISMATCH:
1019#endif
1020    default:
1021      failf(data, "schannel: initial InitializeSecurityContext failed: %s",
1022            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1023      return CURLE_SSL_CONNECT_ERROR;
1024    }
1025  }
1026
1027  DEBUGF(infof(data, "schannel: sending initial handshake data: "
1028               "sending %lu bytes.", outbuf.cbBuffer));
1029
1030  /* send initial handshake data which is now stored in output buffer */
1031  result = Curl_conn_cf_send(cf->next, data,
1032                             (const uint8_t *)outbuf.pvBuffer,
1033                             outbuf.cbBuffer, FALSE,
1034                             &written);
1035  Curl_pSecFn->FreeContextBuffer(outbuf.pvBuffer);
1036  if(result || (outbuf.cbBuffer != written)) {
1037    failf(data, "schannel: failed to send initial handshake data: "
1038          "sent %zu of %lu bytes", written, outbuf.cbBuffer);
1039    return CURLE_SSL_CONNECT_ERROR;
1040  }
1041
1042  DEBUGF(infof(data, "schannel: sent initial handshake data: "
1043               "sent %zu bytes", written));
1044
1045  backend->recv_unrecoverable_err = CURLE_OK;
1046  backend->recv_sspi_close_notify = FALSE;
1047  backend->recv_connection_closed = FALSE;
1048  backend->recv_renegotiating = FALSE;
1049  backend->renegotiate_state.started = FALSE;
1050  backend->encdata_is_incomplete = FALSE;
1051
1052  /* continue to second handshake step */
1053  connssl->connecting_state = ssl_connect_2;
1054
1055  return CURLE_OK;
1056}
1057
1058static CURLcode schannel_error(struct Curl_easy *data,
1059                               SECURITY_STATUS sspi_status)
1060{
1061  char buffer[STRERROR_LEN];
1062  switch(sspi_status) {
1063  case SEC_E_INSUFFICIENT_MEMORY:
1064    failf(data, "schannel: next InitializeSecurityContext failed: %s",
1065          Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1066    return CURLE_OUT_OF_MEMORY;
1067  case SEC_E_WRONG_PRINCIPAL:
1068    failf(data, "schannel: SNI or certificate check failed: %s",
1069          Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1070    return CURLE_PEER_FAILED_VERIFICATION;
1071  case SEC_E_UNTRUSTED_ROOT:
1072    failf(data, "schannel: %s",
1073          Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1074    return CURLE_PEER_FAILED_VERIFICATION;
1075#if 0
1076  case SEC_E_INVALID_HANDLE:
1077  case SEC_E_INVALID_TOKEN:
1078  case SEC_E_LOGON_DENIED:
1079  case SEC_E_TARGET_UNKNOWN:
1080  case SEC_E_NO_AUTHENTICATING_AUTHORITY:
1081  case SEC_E_INTERNAL_ERROR:
1082  case SEC_E_NO_CREDENTIALS:
1083  case SEC_E_UNSUPPORTED_FUNCTION:
1084  case SEC_E_APPLICATION_PROTOCOL_MISMATCH:
1085#endif
1086  default:
1087    failf(data, "schannel: next InitializeSecurityContext failed: %s",
1088          Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1089    return CURLE_SSL_CONNECT_ERROR;
1090  }
1091}
1092
1093static CURLcode schannel_pkp_pin_peer_pubkey(struct Curl_cfilter *cf,
1094                                             struct Curl_easy *data,
1095                                             const char *pinnedpubkey)
1096{
1097  struct ssl_connect_data *connssl = cf->ctx;
1098  struct schannel_ssl_backend_data *backend =
1099    (struct schannel_ssl_backend_data *)connssl->backend;
1100  CERT_CONTEXT *pCertContextServer = NULL;
1101
1102  /* Result is returned to caller */
1103  CURLcode result = CURLE_SSL_PINNEDPUBKEYNOTMATCH;
1104
1105  DEBUGASSERT(backend);
1106
1107  /* if a path was not specified, do not pin */
1108  if(!pinnedpubkey)
1109    return CURLE_OK;
1110
1111  do {
1112    SECURITY_STATUS sspi_status;
1113    const char *x509_der;
1114    DWORD x509_der_len;
1115    struct Curl_X509certificate x509_parsed;
1116    struct Curl_asn1Element *pubkey;
1117
1118    sspi_status =
1119      Curl_pSecFn->QueryContextAttributes(&backend->ctxt->ctxt_handle,
1120                                          SECPKG_ATTR_REMOTE_CERT_CONTEXT,
1121                                          &pCertContextServer);
1122
1123    if((sspi_status != SEC_E_OK) || !pCertContextServer) {
1124      char buffer[STRERROR_LEN];
1125      failf(data, "schannel: Failed to read remote certificate context: %s",
1126            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
1127      break; /* failed */
1128    }
1129
1130    if(!(((pCertContextServer->dwCertEncodingType & X509_ASN_ENCODING) != 0) &&
1131         (pCertContextServer->cbCertEncoded > 0)))
1132      break;
1133
1134    x509_der = (const char *)pCertContextServer->pbCertEncoded;
1135    x509_der_len = pCertContextServer->cbCertEncoded;
1136    memset(&x509_parsed, 0, sizeof(x509_parsed));
1137    if(Curl_parseX509(&x509_parsed, x509_der, x509_der + x509_der_len))
1138      break;
1139
1140    pubkey = &x509_parsed.subjectPublicKeyInfo;
1141    if(!pubkey->header || pubkey->end <= pubkey->header) {
1142      failf(data, "SSL: failed retrieving public key from server certificate");
1143      break;
1144    }
1145
1146    result = Curl_pin_peer_pubkey(data,
1147                                  pinnedpubkey,
1148                                  (const unsigned char *)pubkey->header,
1149                                  (size_t)(pubkey->end - pubkey->header));
1150    if(result) {
1151      failf(data, "SSL: public key does not match pinned public key");
1152    }
1153  } while(0);
1154
1155  if(pCertContextServer)
1156    CertFreeCertificateContext(pCertContextServer);
1157
1158  return result;
1159}
1160
1161static CURLcode ensure_encoding_size(struct Curl_easy *data,
1162                                     struct sbuffer *encdata,
1163                                     size_t min_length)
1164{
1165  size_t size;
1166  DEBUGASSERT(encdata->length >= encdata->offset);
1167  if(encdata->length < encdata->offset)
1168    return CURLE_FAILED_INIT;
1169  size = encdata->length - encdata->offset;
1170  if(size < CURL_SCHANNEL_BUFFER_FREE_SIZE || encdata->length < min_length) {
1171    unsigned char *buffer;
1172    size_t length = encdata->offset + CURL_SCHANNEL_BUFFER_FREE_SIZE;
1173    if(length < min_length)
1174      length = min_length;
1175    buffer = curlx_realloc(encdata->buffer, length);
1176    if(!buffer) {
1177      failf(data, "schannel: unable to re-allocate memory");
1178      return CURLE_OUT_OF_MEMORY;
1179    }
1180
1181    encdata->buffer = buffer;
1182    encdata->length = length;
1183    SCH_DEV(infof(data, "schannel: encdata.buffer resized %zu",
1184                  encdata->length));
1185  }
1186  return CURLE_OK;
1187}
1188
1189static CURLcode ensure_decoding_size(struct Curl_easy *data,
1190                                     struct sbuffer *decdata,
1191                                     size_t nowsize,
1192                                     size_t len)
1193{
1194  size_t size = nowsize > CURL_SCHANNEL_BUFFER_FREE_SIZE ?
1195    nowsize : CURL_SCHANNEL_BUFFER_FREE_SIZE;
1196  DEBUGASSERT(decdata->length >= decdata->offset);
1197  if(decdata->length < decdata->offset)
1198    return CURLE_FAILED_INIT;
1199  else if(decdata->length - decdata->offset < size ||
1200          decdata->length < len) {
1201    /* increase internal decrypted data buffer */
1202    size_t length = decdata->offset + size;
1203    unsigned char *buffer;
1204    /* make sure that the requested amount of data fits */
1205    if(length < len)
1206      length = len;
1207
1208    buffer = curlx_realloc(decdata->buffer, length);
1209    if(!buffer) {
1210      failf(data, "schannel: unable to re-allocate memory");
1211      return CURLE_OUT_OF_MEMORY;
1212    }
1213    decdata->buffer = buffer;
1214    decdata->length = length;
1215  }
1216  return CURLE_OK;
1217}
1218
1219static CURLcode schannel_connect_step2(struct Curl_cfilter *cf,
1220                                       struct Curl_easy *data)
1221{
1222  struct ssl_connect_data *connssl = cf->ctx;
1223  struct schannel_ssl_backend_data *backend =
1224    (struct schannel_ssl_backend_data *)connssl->backend;
1225  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
1226  int i;
1227  size_t nread = 0;
1228  SecBuffer outbuf[3];
1229  SecBufferDesc outbuf_desc;
1230  SecBuffer inbuf[2];
1231  SecBufferDesc inbuf_desc;
1232  SECURITY_STATUS sspi_status = SEC_E_OK;
1233  CURLcode result;
1234  bool doread;
1235  const char *pubkey_ptr;
1236
1237  DEBUGASSERT(backend);
1238
1239  doread = (connssl->io_need & CURL_SSL_IO_NEED_SEND) ? FALSE : TRUE;
1240  connssl->io_need = CURL_SSL_IO_NEED_NONE;
1241
1242  DEBUGF(infof(data, "schannel: SSL/TLS connection with %s port %d (step 2/3)",
1243               connssl->peer.dest->hostname, connssl->peer.dest->port));
1244
1245  if(!backend->cred || !backend->ctxt)
1246    return CURLE_SSL_CONNECT_ERROR;
1247
1248  /* buffer to store previously received and decrypted data */
1249  if(!backend->decdata.buffer) {
1250    backend->decdata.offset = 0;
1251    backend->decdata.length = CURL_SCHANNEL_BUFFER_INIT_SIZE;
1252    backend->decdata.buffer = curlx_malloc(backend->decdata.length);
1253    if(!backend->decdata.buffer) {
1254      failf(data, "schannel: unable to allocate memory");
1255      return CURLE_OUT_OF_MEMORY;
1256    }
1257  }
1258
1259  /* buffer to store previously received and encrypted data */
1260  if(!backend->encdata.buffer) {
1261    backend->encdata_is_incomplete = FALSE;
1262    backend->encdata.offset = 0;
1263    backend->encdata.length = CURL_SCHANNEL_BUFFER_INIT_SIZE;
1264    backend->encdata.buffer = curlx_malloc(backend->encdata.length);
1265    if(!backend->encdata.buffer) {
1266      failf(data, "schannel: unable to allocate memory");
1267      return CURLE_OUT_OF_MEMORY;
1268    }
1269  }
1270
1271  result = ensure_encoding_size(data, &backend->encdata, 0);
1272  if(result)
1273    return result;
1274
1275  for(;;) {
1276    if(doread) {
1277      /* read encrypted handshake data from socket */
1278      result = Curl_conn_cf_recv(cf->next, data,
1279                                 (char *)(backend->encdata.buffer +
1280                                          backend->encdata.offset),
1281                                 backend->encdata.length -
1282                                 backend->encdata.offset,
1283                                 &nread);
1284      if(result == CURLE_AGAIN) {
1285        if(!backend->encdata.offset || backend->encdata_is_incomplete) {
1286          connssl->io_need = CURL_SSL_IO_NEED_RECV;
1287          DEBUGF(infof(data, "schannel: failed to receive handshake, "
1288                       "need more data"));
1289          return CURLE_OK;
1290        }
1291        else {
1292          DEBUGF(infof(data, "schannel: no new handshake data received, "
1293                       "continuing to process existing handshake data"));
1294        }
1295      }
1296      else if(result || (nread == 0)) {
1297        failf(data, "schannel: failed to receive handshake, "
1298              "SSL/TLS connection failed");
1299        return CURLE_SSL_CONNECT_ERROR;
1300      }
1301      else {
1302        /* increase encrypted data buffer offset */
1303        backend->encdata.offset += nread;
1304        backend->encdata_is_incomplete = FALSE;
1305        SCH_DEV(infof(data, "schannel: encrypted data got %zu", nread));
1306      }
1307    }
1308
1309    SCH_DEV(infof(data,
1310                  "schannel: encrypted data buffer: offset %zu length %zu",
1311                  backend->encdata.offset, backend->encdata.length));
1312
1313    /* setup input buffers */
1314    InitSecBuffer(&inbuf[0], SECBUFFER_TOKEN,
1315                  curlx_malloc(backend->encdata.offset),
1316                  curlx_uztoul(backend->encdata.offset));
1317    InitSecBuffer(&inbuf[1], SECBUFFER_EMPTY, NULL, 0);
1318    InitSecBufferDesc(&inbuf_desc, inbuf, 2);
1319
1320    /* setup output buffers */
1321    InitSecBuffer(&outbuf[0], SECBUFFER_TOKEN, NULL, 0);
1322    InitSecBuffer(&outbuf[1], SECBUFFER_ALERT, NULL, 0);
1323    InitSecBuffer(&outbuf[2], SECBUFFER_EMPTY, NULL, 0);
1324    InitSecBufferDesc(&outbuf_desc, outbuf, 3);
1325
1326    if(!inbuf[0].pvBuffer) {
1327      failf(data, "schannel: unable to allocate memory");
1328      return CURLE_OUT_OF_MEMORY;
1329    }
1330
1331    /* copy received handshake data into input buffer */
1332    memcpy(inbuf[0].pvBuffer, backend->encdata.buffer,
1333           backend->encdata.offset);
1334
1335    /* The socket must be writable (or a poll error occurred) before we call
1336       InitializeSecurityContext to continue processing the received TLS
1337       records. This is because that function is not idempotent and we do not
1338       support partial save/resume sending replies of handshake tokens. */
1339    if(!SOCKET_WRITABLE(Curl_conn_cf_get_socket(cf, data), 0)) {
1340      SCH_DEV(infof(data, "schannel: handshake waiting for writable socket"));
1341      connssl->io_need = CURL_SSL_IO_NEED_SEND;
1342      curlx_free(inbuf[0].pvBuffer);
1343      return CURLE_OK;
1344    }
1345
1346    sspi_status = Curl_pSecFn->InitializeSecurityContext(
1347      &backend->cred->cred_handle, &backend->ctxt->ctxt_handle,
1348      backend->cred->sni_hostname, backend->req_flags,
1349      0, 0, &inbuf_desc, 0, NULL,
1350      &outbuf_desc, &backend->ret_flags, NULL);
1351
1352    /* free buffer for received handshake data */
1353    curlx_safefree(inbuf[0].pvBuffer);
1354
1355    /* check if the handshake was incomplete */
1356    switch(sspi_status) {
1357    case SEC_E_INCOMPLETE_MESSAGE:
1358      backend->encdata_is_incomplete = TRUE;
1359      connssl->io_need = CURL_SSL_IO_NEED_RECV;
1360      DEBUGF(infof(data,
1361                   "schannel: received incomplete message, need more data"));
1362      return CURLE_OK;
1363
1364    case SEC_I_CONTINUE_NEEDED:
1365    case SEC_E_OK:
1366      /* check if the handshake needs to be continued */
1367      result = CURLE_OK;
1368      for(i = 0; i < 3; i++) {
1369        /* search for handshake tokens that need to be send */
1370        if(outbuf[i].BufferType == SECBUFFER_TOKEN && outbuf[i].cbBuffer > 0) {
1371          size_t written = 0;
1372          DEBUGF(infof(data, "schannel: sending next handshake data: "
1373                       "sending %lu bytes.", outbuf[i].cbBuffer));
1374
1375          /* send handshake token to server */
1376          result = Curl_conn_cf_send(cf->next, data,
1377                                     (const uint8_t *)outbuf[i].pvBuffer,
1378                                     outbuf[i].cbBuffer,
1379                                     FALSE, &written);
1380          if(result || (outbuf[i].cbBuffer != written)) {
1381            failf(data, "schannel: failed to send next handshake data: "
1382                  "sent %zu of %lu bytes", written, outbuf[i].cbBuffer);
1383            result = CURLE_SSL_CONNECT_ERROR;
1384          }
1385        }
1386      }
1387      for(i = 0; i < 3; i++) {
1388        /* free obsolete buffer */
1389        if(outbuf[i].pvBuffer)
1390          Curl_pSecFn->FreeContextBuffer(outbuf[i].pvBuffer);
1391      }
1392      if(result)
1393        return result;
1394      break;
1395
1396    case SEC_I_INCOMPLETE_CREDENTIALS:
1397      if(!(backend->req_flags & ISC_REQ_USE_SUPPLIED_CREDS)) {
1398        /* If the server has requested a client certificate, attempt to
1399           continue the handshake without one. This allows connections to
1400           servers which request a client certificate but do not require
1401           it. */
1402        backend->req_flags |= ISC_REQ_USE_SUPPLIED_CREDS;
1403        connssl->io_need = CURL_SSL_IO_NEED_SEND;
1404        DEBUGF(infof(data,
1405                     "schannel: a client certificate has been requested"));
1406        return CURLE_OK;
1407      }
1408      FALLTHROUGH();
1409
1410    default:
1411      return schannel_error(data, sspi_status);
1412    }
1413
1414    /* check if there was additional remaining encrypted data */
1415    if(inbuf[1].BufferType == SECBUFFER_EXTRA && inbuf[1].cbBuffer > 0) {
1416      SCH_DEV(infof(data, "schannel: encrypted data length: %lu",
1417                    inbuf[1].cbBuffer));
1418      /*
1419        There are two cases where we could be getting extra data here:
1420        1. If we are renegotiating a connection and the handshake is already
1421           complete (from the server perspective), it can encrypted app data
1422           (not handshake data) in an extra buffer at this point.
1423        2. (sspi_status == SEC_I_CONTINUE_NEEDED) We are negotiating a
1424           connection and this extra data is part of the handshake.
1425           We should process the data immediately; waiting for the socket to
1426           be ready may fail since the server is done sending handshake data.
1427      */
1428      /* check if the remaining data is less than the total amount
1429         and therefore begins after the already processed data */
1430      if(backend->encdata.offset > inbuf[1].cbBuffer) {
1431        memmove(backend->encdata.buffer,
1432                (backend->encdata.buffer + backend->encdata.offset) -
1433                inbuf[1].cbBuffer, inbuf[1].cbBuffer);
1434        backend->encdata.offset = inbuf[1].cbBuffer;
1435        if(sspi_status == SEC_I_CONTINUE_NEEDED) {
1436          doread = FALSE;
1437          continue;
1438        }
1439      }
1440    }
1441    else {
1442      backend->encdata.offset = 0;
1443    }
1444    break;
1445  }
1446
1447  /* check if the handshake needs to be continued */
1448  if(sspi_status == SEC_I_CONTINUE_NEEDED) {
1449    connssl->io_need = CURL_SSL_IO_NEED_RECV;
1450    return CURLE_OK;
1451  }
1452
1453  /* check if the handshake is complete */
1454  if(sspi_status == SEC_E_OK) {
1455    connssl->connecting_state = ssl_connect_3;
1456    DEBUGF(infof(data, "schannel: SSL/TLS handshake complete"));
1457  }
1458
1459#ifndef CURL_DISABLE_PROXY
1460  pubkey_ptr = Curl_ssl_cf_is_proxy(cf) ?
1461    data->set.str[STRING_SSL_PINNEDPUBLICKEY_PROXY] :
1462    data->set.str[STRING_SSL_PINNEDPUBLICKEY];
1463#else
1464  pubkey_ptr = data->set.str[STRING_SSL_PINNEDPUBLICKEY];
1465#endif
1466  if(pubkey_ptr) {
1467    result = schannel_pkp_pin_peer_pubkey(cf, data, pubkey_ptr);
1468    if(result) {
1469      failf(data, "SSL: public key does not match pinned public key");
1470      return result;
1471    }
1472  }
1473
1474  if(conn_config->verifypeer && backend->use_manual_cred_validation) {
1475    /* Certificate verification also verifies the hostname if verifyhost */
1476    return Curl_verify_certificate(cf, data);
1477  }
1478
1479  /* Verify the hostname manually when certificate verification is disabled,
1480     because in that case Schannel does not verify it. */
1481  if(!conn_config->verifypeer && conn_config->verifyhost)
1482    return Curl_verify_host(cf, data);
1483
1484  return CURLE_OK;
1485}
1486
1487static bool valid_cert_encoding(const CERT_CONTEXT *cert_context)
1488{
1489  return (cert_context != NULL) &&
1490    ((cert_context->dwCertEncodingType & X509_ASN_ENCODING) != 0) &&
1491    (cert_context->pbCertEncoded != NULL) &&
1492    (cert_context->cbCertEncoded > 0);
1493}
1494
1495typedef bool (*Read_crt_func)(const CERT_CONTEXT *ccert_context,
1496                              bool reverse_order, void *arg);
1497
1498static void traverse_cert_store(const CERT_CONTEXT *context,
1499                                Read_crt_func func, void *arg)
1500{
1501  const CERT_CONTEXT *current_context = NULL;
1502  bool should_continue = TRUE;
1503  bool first = TRUE;
1504  bool reverse_order = FALSE;
1505  while(should_continue &&
1506        (current_context = CertEnumCertificatesInStore(
1507          context->hCertStore,
1508          current_context)) != NULL) {
1509    /* Windows 11 22H2 OS Build 22621.674 or higher enumerates certificates in
1510       leaf-to-root order while all previous versions of Windows enumerate
1511       certificates in root-to-leaf order. Determine the order of enumeration
1512       by comparing SECPKG_ATTR_REMOTE_CERT_CONTEXT's pbCertContext with the
1513       first certificate's pbCertContext. */
1514    if(first && context->pbCertEncoded != current_context->pbCertEncoded)
1515      reverse_order = TRUE;
1516    should_continue = func(current_context, reverse_order, arg);
1517    first = FALSE;
1518  }
1519
1520  if(current_context)
1521    CertFreeCertificateContext(current_context);
1522}
1523
1524static bool cert_counter_callback(const CERT_CONTEXT *ccert_context,
1525                                  bool reverse_order, void *certs_count)
1526{
1527  (void)reverse_order;
1528  if(valid_cert_encoding(ccert_context))
1529    (*(int *)certs_count)++;
1530  if(*(int *)certs_count > MAX_ALLOWED_CERT_AMOUNT)
1531    return FALSE;
1532  return TRUE;
1533}
1534
1535struct Adder_args {
1536  struct Curl_easy *data;
1537  CURLcode result;
1538  int idx;
1539  int certs_count;
1540};
1541
1542static bool add_cert_to_certinfo(const CERT_CONTEXT *ccert_context,
1543                                 bool reverse_order, void *raw_arg)
1544{
1545  struct Adder_args *args = (struct Adder_args *)raw_arg;
1546  args->result = CURLE_OK;
1547  if(valid_cert_encoding(ccert_context)) {
1548    const char *beg = (const char *)ccert_context->pbCertEncoded;
1549    const char *end = beg + ccert_context->cbCertEncoded;
1550    int insert_index = reverse_order ? (args->certs_count - 1) - args->idx :
1551                       args->idx;
1552    args->result = Curl_extract_certinfo(args->data, insert_index,
1553                                         beg, end);
1554    args->idx++;
1555  }
1556  return args->result == CURLE_OK;
1557}
1558
1559static void schannel_session_free(void *sessionid)
1560{
1561  /* this is expected to be called under sessionid lock */
1562  struct Curl_schannel_cred *cred = sessionid;
1563
1564  if(cred) {
1565    cred->refcount--;
1566    if(cred->refcount == 0) {
1567      Curl_pSecFn->FreeCredentialsHandle(&cred->cred_handle);
1568      curlx_free(cred->sni_hostname);
1569      if(cred->client_cert_store) {
1570        CertCloseStore(cred->client_cert_store, 0);
1571        cred->client_cert_store = NULL;
1572      }
1573      curlx_safefree(cred);
1574    }
1575  }
1576}
1577
1578static CURLcode schannel_connect_step3(struct Curl_cfilter *cf,
1579                                       struct Curl_easy *data)
1580{
1581  struct ssl_connect_data *connssl = cf->ctx;
1582  struct schannel_ssl_backend_data *backend =
1583    (struct schannel_ssl_backend_data *)connssl->backend;
1584  CURLcode result = CURLE_OK;
1585  SECURITY_STATUS sspi_status = SEC_E_OK;
1586  CERT_CONTEXT *ccert_context = NULL;
1587#ifdef HAS_ALPN_SCHANNEL
1588  SecPkgContext_ApplicationProtocol alpn_result;
1589#endif
1590
1591  DEBUGASSERT(ssl_connect_3 == connssl->connecting_state);
1592  DEBUGASSERT(backend);
1593
1594  DEBUGF(infof(data, "schannel: SSL/TLS connection with %s port %d (step 3/3)",
1595               connssl->peer.dest->hostname, connssl->peer.dest->port));
1596
1597  if(!backend->cred)
1598    return CURLE_SSL_CONNECT_ERROR;
1599
1600  /* check if the required context attributes are met */
1601  if(backend->ret_flags != backend->req_flags) {
1602    if(!(backend->ret_flags & ISC_RET_SEQUENCE_DETECT))
1603      failf(data, "schannel: failed to setup sequence detection");
1604    if(!(backend->ret_flags & ISC_RET_REPLAY_DETECT))
1605      failf(data, "schannel: failed to setup replay detection");
1606    if(!(backend->ret_flags & ISC_RET_CONFIDENTIALITY))
1607      failf(data, "schannel: failed to setup confidentiality");
1608    if(!(backend->ret_flags & ISC_RET_ALLOCATED_MEMORY))
1609      failf(data, "schannel: failed to setup memory allocation");
1610    if(!(backend->ret_flags & ISC_RET_STREAM))
1611      failf(data, "schannel: failed to setup stream orientation");
1612    return CURLE_SSL_CONNECT_ERROR;
1613  }
1614
1615#ifdef HAS_ALPN_SCHANNEL
1616  if(backend->use_alpn) {
1617    sspi_status =
1618      Curl_pSecFn->QueryContextAttributes(&backend->ctxt->ctxt_handle,
1619                                          SECPKG_ATTR_APPLICATION_PROTOCOL,
1620                                          &alpn_result);
1621
1622    if(sspi_status != SEC_E_OK) {
1623      failf(data, "schannel: failed to retrieve ALPN result");
1624      return CURLE_SSL_CONNECT_ERROR;
1625    }
1626
1627    if(alpn_result.ProtoNegoStatus ==
1628       SecApplicationProtocolNegotiationStatus_Success) {
1629      if(backend->recv_renegotiating &&
1630         connssl->negotiated.alpn &&
1631         strncmp(connssl->negotiated.alpn,
1632                 (const char *)alpn_result.ProtocolId,
1633                 alpn_result.ProtocolIdSize)) {
1634        /* Renegotiation selected a different protocol now, we cannot
1635         * deal with this */
1636        failf(data, "schannel: server selected an ALPN protocol too late");
1637        return CURLE_SSL_CONNECT_ERROR;
1638      }
1639      Curl_alpn_set_negotiated(cf, data, connssl, alpn_result.ProtocolId,
1640                               alpn_result.ProtocolIdSize);
1641    }
1642    else {
1643      if(!backend->recv_renegotiating)
1644        Curl_alpn_set_negotiated(cf, data, connssl, NULL, 0);
1645    }
1646  }
1647#endif
1648
1649  /* save the current session data for possible reuse */
1650  if(Curl_ssl_scache_use(cf, data)) {
1651    Curl_ssl_scache_lock(data);
1652    /* Up ref count since call takes ownership */
1653    backend->cred->refcount++;
1654    result = Curl_ssl_scache_add_obj(cf, data, connssl->peer.scache_key,
1655                                     backend->cred, schannel_session_free);
1656    Curl_ssl_scache_unlock(data);
1657    if(result)
1658      return result;
1659  }
1660
1661  if(data->set.ssl.certinfo) {
1662    int certs_count = 0;
1663    sspi_status =
1664      Curl_pSecFn->QueryContextAttributes(&backend->ctxt->ctxt_handle,
1665                                          SECPKG_ATTR_REMOTE_CERT_CONTEXT,
1666                                          &ccert_context);
1667
1668    if((sspi_status != SEC_E_OK) || !ccert_context) {
1669      failf(data, "schannel: failed to retrieve remote cert context");
1670      return CURLE_PEER_FAILED_VERIFICATION;
1671    }
1672
1673    traverse_cert_store(ccert_context, cert_counter_callback, &certs_count);
1674    if(certs_count > MAX_ALLOWED_CERT_AMOUNT) {
1675      failf(data, "%d certificates is more than allowed (%d)",
1676            certs_count, MAX_ALLOWED_CERT_AMOUNT);
1677      CertFreeCertificateContext(ccert_context);
1678      return CURLE_SSL_CONNECT_ERROR;
1679    }
1680
1681    result = Curl_ssl_init_certinfo(data, certs_count);
1682    if(!result) {
1683      struct Adder_args args;
1684      args.data = data;
1685      args.idx = 0;
1686      args.certs_count = certs_count;
1687      args.result = CURLE_OK;
1688      traverse_cert_store(ccert_context, add_cert_to_certinfo, &args);
1689      result = args.result;
1690    }
1691    CertFreeCertificateContext(ccert_context);
1692    if(result)
1693      return result;
1694  }
1695
1696  connssl->connecting_state = ssl_connect_done;
1697
1698  return CURLE_OK;
1699}
1700
1701static CURLcode schannel_connect(struct Curl_cfilter *cf,
1702                                 struct Curl_easy *data,
1703                                 bool *done)
1704{
1705  struct ssl_connect_data *connssl = cf->ctx;
1706  CURLcode result;
1707
1708  /* check if the connection has already been established */
1709  if(ssl_connection_complete == connssl->state) {
1710    *done = TRUE;
1711    return CURLE_OK;
1712  }
1713
1714  *done = FALSE;
1715
1716  if(ssl_connect_1 == connssl->connecting_state) {
1717    result = schannel_connect_step1(cf, data);
1718    if(result)
1719      return result;
1720  }
1721
1722  if(ssl_connect_2 == connssl->connecting_state) {
1723    result = schannel_connect_step2(cf, data);
1724    if(result)
1725      return result;
1726  }
1727
1728  if(ssl_connect_3 == connssl->connecting_state) {
1729    result = schannel_connect_step3(cf, data);
1730    if(result)
1731      return result;
1732  }
1733
1734  if(ssl_connect_done == connssl->connecting_state) {
1735    connssl->state = ssl_connection_complete;
1736
1737#ifdef SECPKG_ATTR_ENDPOINT_BINDINGS  /* mingw-w64 v9+, MS SDK 7.0A/VS2010+ */
1738    /* When SSPI is used in combination with Schannel
1739     * we need the Schannel context to create the Schannel
1740     * binding to pass the IIS extended protection checks.
1741     * Available on Windows 7 or later.
1742     */
1743    {
1744      struct schannel_ssl_backend_data *backend =
1745        (struct schannel_ssl_backend_data *)connssl->backend;
1746      DEBUGASSERT(backend);
1747      cf->conn->sslContext = &backend->ctxt->ctxt_handle;
1748    }
1749#endif
1750
1751    *done = TRUE;
1752  }
1753
1754  return CURLE_OK;
1755}
1756
1757enum schannel_renegotiate_caller_t {
1758  SCH_RENEG_CALLER_IS_RECV,
1759  SCH_RENEG_CALLER_IS_SEND
1760};
1761
1762/* The maximum time we allow for Schannel renegotiation which may in some
1763   rare cases block either due to libcurl (waiting on the socket) or Windows
1764   (waiting on an interactive security prompt). Note Schannel "renegotiation"
1765   is not necessarily literal TLS renegotiation, but means DecryptMessage
1766   returned SEC_I_RENEGOTIATE which means at least the security context needs
1767   to be re-established. */
1768#define MAX_RENEG_BLOCK_TIME (60 * 1000) /* 60 seconds in milliseconds */
1769
1770/* This function renegotiates the connection due to a server request received
1771   by schannel_recv. This function returns CURLE_AGAIN if the renegotiation is
1772   incomplete. In that case, we remain in the renegotiation (connecting) stage
1773   and future calls to schannel_recv and schannel_send must call this function
1774   first to complete the renegotiation. */
1775static CURLcode schannel_recv_renegotiate(
1776  struct Curl_cfilter *cf, struct Curl_easy *data,
1777  enum schannel_renegotiate_caller_t caller)
1778{
1779  CURLcode result;
1780  curl_socket_t sockfd;
1781  struct ssl_connect_data *connssl = cf->ctx;
1782  struct schannel_ssl_backend_data *backend =
1783    (struct schannel_ssl_backend_data *)connssl->backend;
1784  struct schannel_renegotiate_state *rs = &backend->renegotiate_state;
1785
1786  if(!backend || !backend->recv_renegotiating) {
1787    failf(data, "schannel: unexpected call to schannel_recv_renegotiate");
1788    return CURLE_SSL_CONNECT_ERROR;
1789  }
1790  DEBUGASSERT(caller <= SCH_RENEG_CALLER_IS_SEND);
1791  if(caller == SCH_RENEG_CALLER_IS_RECV)
1792    SCH_DEV(infof(data, "schannel: renegotiation caller is schannel_recv"));
1793  else
1794    SCH_DEV(infof(data, "schannel: renegotiation caller is schannel_send"));
1795
1796  sockfd = Curl_conn_cf_get_socket(cf, data);
1797
1798  if(sockfd == CURL_SOCKET_BAD) {
1799    failf(data, "schannel: renegotiation missing socket");
1800    return CURLE_SSL_CONNECT_ERROR;
1801  }
1802
1803  if(!rs->started) { /* new renegotiation */
1804    infof(data, "schannel: renegotiating SSL/TLS connection");
1805    DEBUGASSERT(connssl->state == ssl_connection_complete);
1806    DEBUGASSERT(connssl->connecting_state == ssl_connect_done);
1807    connssl->state = ssl_connection_negotiating;
1808    connssl->connecting_state = ssl_connect_2;
1809    memset(rs, 0, sizeof(*rs));
1810    rs->io_need = CURL_SSL_IO_NEED_SEND;
1811    rs->start_time = *Curl_pgrs_now(data);
1812    rs->started = TRUE;
1813  }
1814
1815  for(;;) {
1816    bool block_read, block_write, blocking, done;
1817    curl_socket_t readfd, writefd;
1818    timediff_t elapsed;
1819
1820    elapsed = curlx_ptimediff_ms(Curl_pgrs_now(data), &rs->start_time);
1821    if(elapsed >= MAX_RENEG_BLOCK_TIME) {
1822      failf(data, "schannel: renegotiation timeout");
1823      result = CURLE_SSL_CONNECT_ERROR;
1824      break;
1825    }
1826
1827    /* the current io_need state may have been overwritten since the last time
1828       this function was called. restore the io_need state needed to continue
1829       the renegotiation. */
1830
1831    connssl->io_need = rs->io_need;
1832
1833    result = schannel_connect(cf, data, &done);
1834
1835    rs->io_need = connssl->io_need;
1836
1837    if(!result && !done)
1838      result = CURLE_AGAIN;
1839
1840    if(result != CURLE_AGAIN)
1841      break;
1842
1843    readfd = (rs->io_need & CURL_SSL_IO_NEED_RECV) ? sockfd : CURL_SOCKET_BAD;
1844    writefd = (rs->io_need & CURL_SSL_IO_NEED_SEND) ? sockfd : CURL_SOCKET_BAD;
1845
1846    if(readfd == CURL_SOCKET_BAD && writefd == CURL_SOCKET_BAD)
1847      continue;
1848
1849    /* connect should not have requested io read and write together */
1850    DEBUGASSERT(readfd == CURL_SOCKET_BAD || writefd == CURL_SOCKET_BAD);
1851
1852    /* This function is partially blocking to avoid a stoppage that would
1853     * occur if the user is waiting on the socket only in one direction.
1854     *
1855     * For example, if the user has called recv then they may not be waiting
1856     * for a writable socket and vice versa, so we block to avoid that.
1857     *
1858     * In practice a wait is unlikely to occur. For caller recv if handshake
1859     * data needs to be sent then we block for a writable socket that should
1860     * be writable immediately except for OS resource constraints. For caller
1861     * send if handshake data needs to be received then we block for a readable
1862     * socket, which could take some time, but it is more likely the user has
1863     * called recv since they had called it prior (only recv can start
1864     * renegotiation and probably the user is going to call it again to get
1865     * more of their data before calling send).
1866     */
1867
1868    block_read = (caller == SCH_RENEG_CALLER_IS_SEND) ? TRUE : FALSE;
1869    block_write = (caller == SCH_RENEG_CALLER_IS_RECV) ? TRUE : FALSE;
1870
1871    blocking = (block_read && (readfd != CURL_SOCKET_BAD)) ||
1872               (block_write && (writefd != CURL_SOCKET_BAD));
1873
1874    SCH_DEV_SHOWBOOL(block_read);
1875    SCH_DEV_SHOWBOOL(block_write);
1876    SCH_DEV_SHOWBOOL(blocking);
1877
1878    for(;;) {
1879      int what;
1880      timediff_t timeout_ms, remaining;
1881
1882      result = Curl_pgrsUpdate(data);
1883      if(result)
1884        break;
1885
1886      elapsed = curlx_ptimediff_ms(Curl_pgrs_now(data), &rs->start_time);
1887      if(elapsed >= MAX_RENEG_BLOCK_TIME) {
1888        failf(data, "schannel: renegotiation timeout");
1889        result = CURLE_SSL_CONNECT_ERROR;
1890        break;
1891      }
1892      remaining = MAX_RENEG_BLOCK_TIME - elapsed;
1893
1894      if(blocking) {
1895        timeout_ms = Curl_timeleft_ms(data);
1896
1897        if(timeout_ms < 0) {
1898          result = CURLE_OPERATION_TIMEDOUT;
1899          break;
1900        }
1901
1902        /* the blocking is in intervals so that the progress function can be
1903           called every second */
1904        if(!timeout_ms || timeout_ms > 1000)
1905          timeout_ms = 1000;
1906
1907        if(timeout_ms > remaining)
1908          timeout_ms = remaining;
1909      }
1910      else
1911        timeout_ms = 0;
1912
1913      SCH_DEV(infof(data, "schannel: renegotiation wait until socket is"
1914                    "%s%s for up to %" FMT_TIMEDIFF_T " ms",
1915                    ((readfd != CURL_SOCKET_BAD) ? " readable" : ""),
1916                    ((writefd != CURL_SOCKET_BAD) ? " writable" : ""),
1917                    timeout_ms));
1918
1919      what = Curl_socket_check(readfd, CURL_SOCKET_BAD, writefd, timeout_ms);
1920
1921      if(what > 0 && (what & (CURL_CSELECT_IN | CURL_CSELECT_OUT))) {
1922        SCH_DEV(infof(data, "schannel: renegotiation socket %s%s",
1923                      ((what & CURL_CSELECT_IN) ? "CURL_CSELECT_IN " : ""),
1924                      ((what & CURL_CSELECT_OUT) ? "CURL_CSELECT_OUT " : "")));
1925        result = CURLE_AGAIN;
1926        break;
1927      }
1928      else if(!what) {
1929        SCH_DEV(infof(data, "schannel: renegotiation socket timeout"));
1930        if(blocking)
1931          continue;
1932        else
1933          return CURLE_AGAIN;
1934      }
1935
1936      failf(data, "schannel: socket error during renegotiation");
1937      result = CURLE_SSL_CONNECT_ERROR;
1938      break;
1939    }
1940    if(result != CURLE_AGAIN)
1941      break;
1942  }
1943
1944  DEBUGASSERT(result != CURLE_AGAIN);
1945
1946  rs->started = FALSE;
1947  backend->recv_renegotiating = FALSE;
1948  connssl->io_need = CURL_SSL_IO_NEED_NONE;
1949
1950  if(result)
1951    failf(data, "schannel: renegotiation failed");
1952  else
1953    infof(data, "schannel: SSL/TLS connection renegotiated");
1954
1955  return result;
1956}
1957
1958static CURLcode schannel_send(struct Curl_cfilter *cf, struct Curl_easy *data,
1959                              const void *buf, size_t len, size_t *pnwritten)
1960{
1961  size_t data_len = 0;
1962  unsigned char *ptr = NULL;
1963  struct ssl_connect_data *connssl = cf->ctx;
1964  SecBuffer outbuf[4];
1965  SecBufferDesc outbuf_desc;
1966  SECURITY_STATUS sspi_status = SEC_E_OK;
1967  CURLcode result = CURLE_OK;
1968  struct schannel_ssl_backend_data *backend =
1969    (struct schannel_ssl_backend_data *)connssl->backend;
1970
1971  DEBUGASSERT(backend);
1972  *pnwritten = 0;
1973
1974  if(backend->recv_renegotiating) {
1975    result = schannel_recv_renegotiate(cf, data, SCH_RENEG_CALLER_IS_SEND);
1976    if(result)
1977      return result;
1978  }
1979
1980  /* check if the maximum stream sizes were queried */
1981  if(backend->stream_sizes.cbMaximumMessage == 0) {
1982    sspi_status = Curl_pSecFn->QueryContextAttributes(
1983      &backend->ctxt->ctxt_handle,
1984      SECPKG_ATTR_STREAM_SIZES,
1985      &backend->stream_sizes);
1986    if(sspi_status != SEC_E_OK) {
1987      return CURLE_SEND_ERROR;
1988    }
1989  }
1990
1991  /* check if the buffer is longer than the maximum message length */
1992  if(len > backend->stream_sizes.cbMaximumMessage) {
1993    len = backend->stream_sizes.cbMaximumMessage;
1994  }
1995
1996  /* calculate the complete message length and allocate a buffer for it */
1997  data_len = backend->stream_sizes.cbHeader + len +
1998    backend->stream_sizes.cbTrailer;
1999  ptr = (unsigned char *)curlx_malloc(data_len);
2000  if(!ptr) {
2001    return CURLE_OUT_OF_MEMORY;
2002  }
2003
2004  /* setup output buffers (header, data, trailer, empty) */
2005  InitSecBuffer(&outbuf[0], SECBUFFER_STREAM_HEADER,
2006                ptr, backend->stream_sizes.cbHeader);
2007  InitSecBuffer(&outbuf[1], SECBUFFER_DATA,
2008                ptr + backend->stream_sizes.cbHeader, curlx_uztoul(len));
2009  InitSecBuffer(&outbuf[2], SECBUFFER_STREAM_TRAILER,
2010                ptr + backend->stream_sizes.cbHeader + len,
2011                backend->stream_sizes.cbTrailer);
2012  InitSecBuffer(&outbuf[3], SECBUFFER_EMPTY, NULL, 0);
2013  InitSecBufferDesc(&outbuf_desc, outbuf, 4);
2014
2015  /* copy data into output buffer */
2016  memcpy(outbuf[1].pvBuffer, buf, len);
2017
2018  /* https://learn.microsoft.com/windows/win32/api/sspi/nf-sspi-encryptmessage */
2019  sspi_status = Curl_pSecFn->EncryptMessage(&backend->ctxt->ctxt_handle, 0,
2020                                            &outbuf_desc, 0);
2021
2022  /* check if the message was encrypted */
2023  if(sspi_status == SEC_E_OK) {
2024
2025    /* send the encrypted message including header, data and trailer */
2026    len = outbuf[0].cbBuffer + outbuf[1].cbBuffer + outbuf[2].cbBuffer;
2027
2028    /*
2029      it is important to send the full message which includes the header,
2030      encrypted payload, and trailer. Until the client receives all the
2031      data a coherent message has not been delivered and the client
2032      cannot read any of it.
2033
2034      If we wanted to buffer the unwritten encrypted bytes, we would
2035      tell the client that all data it has requested to be sent has been
2036      sent. The unwritten encrypted bytes would be the first bytes to
2037      send on the next invocation.
2038      Here's the catch with this - if we tell the client that all the
2039      bytes have been sent, does the client call this method again to
2040      send the buffered data?  Looking at who calls this function, it
2041      seems the answer is NO.
2042    */
2043
2044    /* send entire message or fail */
2045    while(len > *pnwritten) {
2046      size_t this_write = 0;
2047      int what;
2048      timediff_t timeout_ms = Curl_timeleft_ms(data);
2049      if(timeout_ms < 0) {
2050        /* we already got the timeout */
2051        failf(data, "schannel: timed out sending data (bytes sent: %zu)",
2052              *pnwritten);
2053        result = CURLE_OPERATION_TIMEDOUT;
2054        break;
2055      }
2056      else if(!timeout_ms)
2057        timeout_ms = TIMEDIFF_T_MAX;
2058      what = SOCKET_WRITABLE(Curl_conn_cf_get_socket(cf, data), timeout_ms);
2059      if(what < 0) {
2060        /* fatal error */
2061        failf(data, "select/poll on SSL socket, errno: %d", SOCKERRNO);
2062        result = CURLE_SEND_ERROR;
2063        break;
2064      }
2065      else if(what == 0) {
2066        failf(data, "schannel: timed out sending data (bytes sent: %zu)",
2067              *pnwritten);
2068        result = CURLE_OPERATION_TIMEDOUT;
2069        break;
2070      }
2071      /* socket is writable */
2072
2073       result = Curl_conn_cf_send(cf->next, data,
2074                                  (const uint8_t *)ptr + *pnwritten,
2075                                  len - *pnwritten,
2076                                  FALSE, &this_write);
2077      if(result == CURLE_AGAIN)
2078        continue;
2079      else if(result) {
2080        break;
2081      }
2082
2083      *pnwritten += this_write;
2084    }
2085  }
2086  else if(sspi_status == SEC_E_INSUFFICIENT_MEMORY) {
2087    result = CURLE_OUT_OF_MEMORY;
2088  }
2089  else {
2090    result = CURLE_SEND_ERROR;
2091  }
2092
2093  curlx_safefree(ptr);
2094
2095  if(len == *pnwritten)
2096    /* Encrypted message including header, data and trailer entirely sent.
2097       The return value is the number of unencrypted bytes that were sent. */
2098    *pnwritten = outbuf[1].cbBuffer;
2099
2100  return result;
2101}
2102
2103static CURLcode schannel_recv(struct Curl_cfilter *cf, struct Curl_easy *data,
2104                              char *buf, size_t len, size_t *pnread)
2105{
2106  size_t size = 0;
2107  size_t nread = 0;
2108  struct ssl_connect_data *connssl = cf->ctx;
2109  SecBuffer inbuf[4];
2110  SecBufferDesc inbuf_desc;
2111  SECURITY_STATUS sspi_status = SEC_E_OK;
2112  struct schannel_ssl_backend_data *backend =
2113    (struct schannel_ssl_backend_data *)connssl->backend;
2114  CURLcode result = CURLE_OK;
2115
2116  DEBUGASSERT(backend);
2117  *pnread = 0;
2118
2119  if(backend->recv_renegotiating) {
2120    result = schannel_recv_renegotiate(cf, data, SCH_RENEG_CALLER_IS_RECV);
2121    if(result)
2122      return result;
2123  }
2124
2125  /****************************************************************************
2126   * Do not return or set backend->recv_unrecoverable_err unless in the
2127   * cleanup. The pattern for return error is set *err, optional infof, goto
2128   * cleanup.
2129   *
2130   * Some verbose debug messages are wrapped by SCH_DEV() instead of DEBUGF()
2131   * and only shown if CURL_SCHANNEL_DEV_DEBUG was defined at build time. These
2132   * messages are extra verbose and intended for curl developers debugging
2133   * Schannel recv decryption.
2134   *
2135   * Our priority is to always return as much decrypted data to the caller as
2136   * possible, even if an error occurs. The state of the decrypted buffer must
2137   * always be valid. Transfer of decrypted data to the caller's buffer is
2138   * handled in the cleanup.
2139   */
2140
2141  SCH_DEV(infof(data, "schannel: client wants to read %zu bytes", len));
2142
2143  if(len && len <= backend->decdata.offset) {
2144    SCH_DEV(infof(data,
2145                  "schannel: enough decrypted data is already available"));
2146    goto cleanup;
2147  }
2148  else if(backend->recv_unrecoverable_err) {
2149    result = backend->recv_unrecoverable_err;
2150    infof(data, "schannel: an unrecoverable error occurred in a prior call");
2151    goto cleanup;
2152  }
2153  else if(backend->recv_sspi_close_notify) {
2154    /* once a server has indicated shutdown there is no more encrypted data */
2155    infof(data, "schannel: server indicated shutdown in a prior call");
2156    goto cleanup;
2157  }
2158  /* it is debatable what to return when !len. Regardless we cannot return
2159     immediately because there may be data to decrypt (in the case we want to
2160     decrypt all encrypted cached data) so handle !len later in cleanup.
2161  */
2162  else if(len && !backend->recv_connection_closed) {
2163    /* the encrypted buffer must be large enough to hold all the bytes
2164       requested and some TLS record overhead. 'len' is a buffer size, so this
2165       integer math cannot overflow. */
2166    const size_t min_encdata_length = len + CURL_SCHANNEL_BUFFER_FREE_SIZE;
2167
2168    /* make sure encrypt buffer fits the requested amount of data */
2169    result = ensure_encoding_size(data, &backend->encdata, min_encdata_length);
2170    if(result)
2171      goto cleanup;
2172
2173    SCH_DEV(infof(data,
2174                  "schannel: encrypted data buffer: offset %zu length %zu",
2175                  backend->encdata.offset, backend->encdata.length));
2176
2177    /* read encrypted data from socket */
2178    result = Curl_conn_cf_recv(cf->next, data,
2179                               (char *)(backend->encdata.buffer +
2180                                        backend->encdata.offset),
2181                               backend->encdata.length -
2182                               backend->encdata.offset,
2183                               &nread);
2184    if(result) {
2185      if(result == CURLE_AGAIN)
2186        SCH_DEV(infof(data, "schannel: recv returned CURLE_AGAIN"));
2187      else {
2188        infof(data, "schannel: recv returned error %d", result);
2189        backend->recv_unrecoverable_err = result;
2190      }
2191    }
2192    else if(nread == 0) {
2193      backend->recv_connection_closed = TRUE;
2194      DEBUGF(infof(data, "schannel: server closed the connection"));
2195    }
2196    else {
2197      backend->encdata.offset += nread;
2198      backend->encdata_is_incomplete = FALSE;
2199      SCH_DEV(infof(data, "schannel: encrypted data got %zu", nread));
2200    }
2201  }
2202
2203  SCH_DEV(infof(data, "schannel: encrypted data buffer: offset %zu length %zu",
2204                backend->encdata.offset, backend->encdata.length));
2205
2206  /* decrypt loop */
2207  while(backend->encdata.offset > 0 && sspi_status == SEC_E_OK &&
2208        (!len || backend->decdata.offset < len ||
2209         backend->recv_connection_closed)) {
2210    /* prepare data buffer for DecryptMessage call */
2211    InitSecBuffer(&inbuf[0], SECBUFFER_DATA, backend->encdata.buffer,
2212                  curlx_uztoul(backend->encdata.offset));
2213
2214    /* we need 3 more empty input buffers for possible output */
2215    InitSecBuffer(&inbuf[1], SECBUFFER_EMPTY, NULL, 0);
2216    InitSecBuffer(&inbuf[2], SECBUFFER_EMPTY, NULL, 0);
2217    InitSecBuffer(&inbuf[3], SECBUFFER_EMPTY, NULL, 0);
2218    InitSecBufferDesc(&inbuf_desc, inbuf, 4);
2219
2220    /* https://learn.microsoft.com/windows/win32/api/sspi/nf-sspi-decryptmessage
2221     */
2222    sspi_status = Curl_pSecFn->DecryptMessage(&backend->ctxt->ctxt_handle,
2223                                              &inbuf_desc, 0, NULL);
2224
2225    /* check if everything went fine (server may want to renegotiate
2226       or shutdown the connection context) */
2227    if(sspi_status == SEC_E_OK || sspi_status == SEC_I_RENEGOTIATE ||
2228       sspi_status == SEC_I_CONTEXT_EXPIRED) {
2229      /* check for successfully decrypted data, even before actual
2230         renegotiation or shutdown of the connection context */
2231      if(inbuf[1].BufferType == SECBUFFER_DATA) {
2232        SCH_DEV(infof(data, "schannel: decrypted data length: %lu",
2233                      inbuf[1].cbBuffer));
2234
2235        /* ensure the decode buffer fits the received amount of data */
2236        result = ensure_decoding_size(data, &backend->decdata,
2237                                      inbuf[1].cbBuffer, len);
2238        if(result)
2239          goto cleanup;
2240
2241        /* copy decrypted data to internal buffer */
2242        size = inbuf[1].cbBuffer;
2243        if(size) {
2244          memcpy(backend->decdata.buffer + backend->decdata.offset,
2245                 inbuf[1].pvBuffer, size);
2246          backend->decdata.offset += size;
2247        }
2248
2249        SCH_DEV(infof(data, "schannel: decrypted data added: %zu", size));
2250        SCH_DEV(infof(data,
2251                      "schannel: decrypted cached: offset %zu length %zu",
2252                      backend->decdata.offset, backend->decdata.length));
2253      }
2254
2255      /* check for remaining encrypted data */
2256      if(inbuf[3].BufferType == SECBUFFER_EXTRA && inbuf[3].cbBuffer > 0) {
2257        SCH_DEV(infof(data, "schannel: encrypted data length: %lu",
2258                      inbuf[3].cbBuffer));
2259
2260        /* check if the remaining data is less than the total amount
2261         * and therefore begins after the already processed data
2262         */
2263        if(backend->encdata.offset > inbuf[3].cbBuffer) {
2264          /* move remaining encrypted data forward to the beginning of
2265             buffer */
2266          memmove(backend->encdata.buffer,
2267                  (backend->encdata.buffer + backend->encdata.offset) -
2268                  inbuf[3].cbBuffer, inbuf[3].cbBuffer);
2269          backend->encdata.offset = inbuf[3].cbBuffer;
2270        }
2271
2272        SCH_DEV(infof(data,
2273                      "schannel: encrypted cached: offset %zu length %zu",
2274                      backend->encdata.offset, backend->encdata.length));
2275      }
2276      else {
2277        /* reset encrypted buffer offset, because there is no data remaining */
2278        backend->encdata.offset = 0;
2279      }
2280
2281      /* check if server wants to renegotiate the connection context */
2282      if(sspi_status == SEC_I_RENEGOTIATE) {
2283        infof(data, "schannel: remote party requests renegotiation");
2284        if(result && result != CURLE_AGAIN) {
2285          infof(data, "schannel: cannot renegotiate, an error is pending");
2286          goto cleanup;
2287        }
2288
2289        backend->recv_renegotiating = TRUE;
2290        result = schannel_recv_renegotiate(cf, data, SCH_RENEG_CALLER_IS_RECV);
2291        if(result)
2292          goto cleanup;
2293
2294        /* now retry receiving data */
2295        sspi_status = SEC_E_OK;
2296        continue;
2297      }
2298      /* check if the server closed the connection */
2299      else if(sspi_status == SEC_I_CONTEXT_EXPIRED) {
2300        /* In Windows 2000 SEC_I_CONTEXT_EXPIRED (close_notify) is not
2301           returned so we have to work around that in cleanup. */
2302        backend->recv_sspi_close_notify = TRUE;
2303        if(!backend->recv_connection_closed)
2304          backend->recv_connection_closed = TRUE;
2305        /* We received the close notify fine, any error we got
2306         * from the lower filters afterwards (e.g. the socket), is not
2307         * an error on the TLS data stream. That one ended here. */
2308        if(result == CURLE_RECV_ERROR)
2309          result = CURLE_OK;
2310        infof(data,
2311              "schannel: server close notification received (close_notify)");
2312        goto cleanup;
2313      }
2314    }
2315    else if(sspi_status == SEC_E_INCOMPLETE_MESSAGE) {
2316      backend->encdata_is_incomplete = TRUE;
2317      if(!result)
2318        result = CURLE_AGAIN;
2319      SCH_DEV(infof(data, "schannel: failed to decrypt data, need more data"));
2320      goto cleanup;
2321    }
2322    else {
2323      char buffer[STRERROR_LEN];
2324      failf(data, "schannel: failed to read data from server: %s",
2325            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
2326      result = CURLE_RECV_ERROR;
2327      goto cleanup;
2328    }
2329  }
2330
2331  SCH_DEV(infof(data, "schannel: encrypted data buffer: offset %zu length %zu",
2332                backend->encdata.offset, backend->encdata.length));
2333
2334  SCH_DEV(infof(data, "schannel: decrypted data buffer: offset %zu length %zu",
2335                backend->decdata.offset, backend->decdata.length));
2336
2337cleanup:
2338  /* Warning- there is no guarantee the encdata state is valid at this point */
2339  SCH_DEV(infof(data, "schannel: schannel_recv cleanup"));
2340
2341  /* Error if the connection has closed without a close_notify.
2342
2343     The behavior here is a matter of debate. We do not want to be vulnerable
2344     to a truncation attack however there is some browser precedent for
2345     ignoring the close_notify for compatibility reasons.
2346  */
2347  if(len && !backend->decdata.offset && backend->recv_connection_closed &&
2348     !backend->recv_sspi_close_notify) {
2349    result = CURLE_RECV_ERROR;
2350    failf(data, "schannel: server closed abruptly (missing close_notify)");
2351  }
2352
2353  /* Any error other than CURLE_AGAIN is an unrecoverable error. */
2354  if(result && result != CURLE_AGAIN)
2355    backend->recv_unrecoverable_err = result;
2356
2357  size = len < backend->decdata.offset ? len : backend->decdata.offset;
2358  if(size) {
2359    memcpy(buf, backend->decdata.buffer, size);
2360    memmove(backend->decdata.buffer, backend->decdata.buffer + size,
2361            backend->decdata.offset - size);
2362    backend->decdata.offset -= size;
2363    SCH_DEV(infof(data, "schannel: decrypted data returned %zu", size));
2364    SCH_DEV(infof(data,
2365                  "schannel: decrypted data buffer: offset %zu length %zu",
2366                  backend->decdata.offset, backend->decdata.length));
2367    *pnread = size;
2368    return CURLE_OK;
2369  }
2370
2371  if(!result && !backend->recv_connection_closed)
2372    result = CURLE_AGAIN;
2373
2374  /* it is debatable what to return when !len. We could return whatever error
2375     we got from decryption but instead we override here so the return is
2376     consistent.
2377  */
2378  if(!len)
2379    return CURLE_OK;
2380
2381  return result;
2382}
2383
2384static bool schannel_data_pending(struct Curl_cfilter *cf,
2385                                  const struct Curl_easy *data)
2386{
2387  const struct ssl_connect_data *connssl = cf->ctx;
2388  struct schannel_ssl_backend_data *backend =
2389    (struct schannel_ssl_backend_data *)connssl->backend;
2390
2391  (void)data;
2392  DEBUGASSERT(backend);
2393
2394  if(backend->ctxt) /* SSL/TLS is in use */
2395    return backend->decdata.offset > 0 ||
2396           (backend->encdata.offset > 0 && !backend->encdata_is_incomplete) ||
2397           backend->recv_connection_closed ||
2398           backend->recv_sspi_close_notify ||
2399           backend->recv_unrecoverable_err;
2400  else
2401    return FALSE;
2402}
2403
2404/* shut down the SSL connection and clean up related memory.
2405   this function can be called multiple times on the same connection including
2406   if the SSL connection failed (eg connection made but failed handshake). */
2407static CURLcode schannel_shutdown(struct Curl_cfilter *cf,
2408                                  struct Curl_easy *data,
2409                                  bool send_shutdown, bool *done)
2410{
2411  /* See https://learn.microsoft.com/windows/win32/secauthn/shutting-down-an-schannel-connection
2412   * Shutting Down an Schannel Connection
2413   */
2414  struct ssl_connect_data *connssl = cf->ctx;
2415  struct schannel_ssl_backend_data *backend =
2416    (struct schannel_ssl_backend_data *)connssl->backend;
2417  CURLcode result = CURLE_OK;
2418
2419  if(cf->shutdown) {
2420    *done = TRUE;
2421    return CURLE_OK;
2422  }
2423
2424  DEBUGASSERT(data);
2425  DEBUGASSERT(backend);
2426
2427  /* Not supported in schannel */
2428  (void)send_shutdown;
2429
2430  *done = FALSE;
2431  if(backend->ctxt) {
2432    infof(data, "schannel: shutting down SSL/TLS connection with %s port %d",
2433          connssl->peer.dest->hostname, connssl->peer.dest->port);
2434  }
2435
2436  if(!backend->ctxt || cf->shutdown) {
2437    *done = TRUE;
2438    goto out;
2439  }
2440
2441  if(backend->cred && backend->ctxt && !backend->sent_shutdown) {
2442    SecBufferDesc BuffDesc;
2443    SecBuffer Buffer;
2444    SECURITY_STATUS sspi_status;
2445    SecBuffer outbuf;
2446    SecBufferDesc outbuf_desc;
2447    DWORD dwshut = SCHANNEL_SHUTDOWN;
2448
2449    InitSecBuffer(&Buffer, SECBUFFER_TOKEN, &dwshut, sizeof(dwshut));
2450    InitSecBufferDesc(&BuffDesc, &Buffer, 1);
2451
2452    sspi_status = Curl_pSecFn->ApplyControlToken(&backend->ctxt->ctxt_handle,
2453                                                 &BuffDesc);
2454
2455    if(sspi_status != SEC_E_OK) {
2456      char buffer[STRERROR_LEN];
2457      failf(data, "schannel: ApplyControlToken failure: %s",
2458            Curl_sspi_strerror(sspi_status, buffer, sizeof(buffer)));
2459      result = CURLE_SEND_ERROR;
2460      goto out;
2461    }
2462
2463    /* setup output buffer */
2464    InitSecBuffer(&outbuf, SECBUFFER_EMPTY, NULL, 0);
2465    InitSecBufferDesc(&outbuf_desc, &outbuf, 1);
2466
2467    sspi_status = Curl_pSecFn->InitializeSecurityContext(
2468      &backend->cred->cred_handle,
2469      &backend->ctxt->ctxt_handle,
2470      backend->cred->sni_hostname,
2471      backend->req_flags,
2472      0,
2473      0,
2474      NULL,
2475      0,
2476      &backend->ctxt->ctxt_handle,
2477      &outbuf_desc,
2478      &backend->ret_flags, NULL);
2479
2480    if((sspi_status == SEC_E_OK) || (sspi_status == SEC_I_CONTEXT_EXPIRED)) {
2481      /* send close message which is in output buffer */
2482      size_t written;
2483
2484      result = Curl_conn_cf_send(cf->next, data,
2485                                 (const uint8_t *)outbuf.pvBuffer,
2486                                 outbuf.cbBuffer,
2487                                 FALSE, &written);
2488      Curl_pSecFn->FreeContextBuffer(outbuf.pvBuffer);
2489      if(!result) {
2490        if(written < outbuf.cbBuffer) {
2491          result = CURLE_SEND_ERROR;
2492          failf(data, "schannel: failed to send close msg: %s"
2493                " (bytes written: %zu)", curl_easy_strerror(result), written);
2494          goto out;
2495        }
2496        backend->sent_shutdown = TRUE;
2497        *done = TRUE;
2498      }
2499      else if(result == CURLE_AGAIN) {
2500        connssl->io_need = CURL_SSL_IO_NEED_SEND;
2501        result = CURLE_OK;
2502        goto out;
2503      }
2504      else {
2505        if(!backend->recv_connection_closed) {
2506          result = CURLE_SEND_ERROR;
2507          failf(data, "schannel: error sending close msg: %d", result);
2508          goto out;
2509        }
2510        /* Looks like server already closed the connection.
2511         * An error to send our close notify is not a failure. */
2512        *done = TRUE;
2513        result = CURLE_OK;
2514      }
2515    }
2516  }
2517
2518  /* If the connection seems open and we have not seen the close notify
2519   * from the server yet, try to receive it. */
2520  if(backend->cred && backend->ctxt &&
2521     !backend->recv_sspi_close_notify && !backend->recv_connection_closed) {
2522    char buffer[1024];
2523    size_t nread;
2524
2525    result = schannel_recv(cf, data, buffer, sizeof(buffer), &nread);
2526    if(result == CURLE_AGAIN) {
2527      connssl->io_need = CURL_SSL_IO_NEED_RECV;
2528    }
2529    else if(result) {
2530      CURL_TRC_CF(data, cf, "SSL shutdown, error %d", result);
2531      result = CURLE_RECV_ERROR;
2532    }
2533    else if(nread == 0) {
2534      /* We got the close notify alert and are done. */
2535      backend->recv_connection_closed = TRUE;
2536      *done = TRUE;
2537    }
2538    else {
2539      /* still data coming in? */
2540    }
2541  }
2542
2543out:
2544  cf->shutdown = (result || *done);
2545  return result;
2546}
2547
2548static void schannel_close(struct Curl_cfilter *cf, struct Curl_easy *data)
2549{
2550  struct ssl_connect_data *connssl = cf->ctx;
2551  struct schannel_ssl_backend_data *backend =
2552    (struct schannel_ssl_backend_data *)connssl->backend;
2553
2554  DEBUGASSERT(data);
2555  DEBUGASSERT(backend);
2556
2557  /* free SSPI Schannel API security context handle */
2558  if(backend->ctxt) {
2559    DEBUGF(infof(data, "schannel: clear security context handle"));
2560    Curl_pSecFn->DeleteSecurityContext(&backend->ctxt->ctxt_handle);
2561    curlx_safefree(backend->ctxt);
2562  }
2563
2564  /* free SSPI Schannel API credential handle */
2565  if(backend->cred) {
2566    Curl_ssl_scache_lock(data);
2567    schannel_session_free(backend->cred);
2568    Curl_ssl_scache_unlock(data);
2569    backend->cred = NULL;
2570  }
2571
2572  /* free internal buffer for received encrypted data */
2573  if(backend->encdata.buffer) {
2574    curlx_safefree(backend->encdata.buffer);
2575    backend->encdata.length = 0;
2576    backend->encdata.offset = 0;
2577    backend->encdata_is_incomplete = FALSE;
2578  }
2579
2580  /* free internal buffer for received decrypted data */
2581  if(backend->decdata.buffer) {
2582    curlx_safefree(backend->decdata.buffer);
2583    backend->decdata.length = 0;
2584    backend->decdata.offset = 0;
2585  }
2586}
2587
2588static int schannel_init(void)
2589{
2590#ifdef HAS_ALPN_SCHANNEL
2591  typedef const char *(APIENTRY *WINE_GET_VERSION_FN)(void);
2592#if defined(__clang__) && __clang_major__ >= 16
2593#pragma clang diagnostic push
2594#pragma clang diagnostic ignored "-Wcast-function-type-strict"
2595#endif
2596  WINE_GET_VERSION_FN p_wine_get_version =
2597    CURLX_FUNCTION_CAST(WINE_GET_VERSION_FN,
2598      GetProcAddress(GetModuleHandle(TEXT("ntdll")), "wine_get_version"));
2599#if defined(__clang__) && __clang_major__ >= 16
2600#pragma clang diagnostic pop
2601#endif
2602  if(p_wine_get_version) {  /* WINE detected */
2603    curl_off_t ver = 0;
2604    const char *wine_version = p_wine_get_version();  /* e.g. "6.0.2" */
2605    /* Assume ALPN support with WINE 6.0 or upper */
2606    if(wine_version)
2607      curlx_str_number(&wine_version, &ver, 20);
2608    s_win_has_alpn = (ver >= 6);
2609  }
2610  else {
2611    /* ALPN is supported on Windows 8.1 / Server 2012 R2 and above. */
2612    s_win_has_alpn = curlx_verify_windows_version(6, 3, 0, PLATFORM_WINNT,
2613                                                  VERSION_GREATER_THAN_EQUAL);
2614  }
2615#endif /* HAS_ALPN_SCHANNEL */
2616
2617  return Curl_sspi_global_init() == CURLE_OK ? 1 : 0;
2618}
2619
2620static void schannel_cleanup(void)
2621{
2622  Curl_sspi_global_cleanup();
2623}
2624
2625static size_t schannel_version(char *buffer, size_t size)
2626{
2627  return curl_msnprintf(buffer, size, "Schannel");
2628}
2629
2630static CURLcode schannel_random(struct Curl_easy *data,
2631                                unsigned char *entropy, size_t length)
2632{
2633  (void)data;
2634
2635  return Curl_win32_random(entropy, length);
2636}
2637
2638static void schannel_checksum(const unsigned char *input,
2639                              size_t inputlen,
2640                              unsigned char *checksum,
2641                              size_t checksumlen,
2642                              DWORD provType,
2643                              const unsigned int algId)
2644{
2645  HCRYPTPROV hProv = 0;
2646  HCRYPTHASH hHash = 0;
2647
2648  /* since this can fail in multiple ways, zero memory first so we never
2649   * return old data
2650   */
2651  memset(checksum, 0, checksumlen);
2652
2653  if(!CryptAcquireContext(&hProv, NULL, NULL, provType,
2654                          CRYPT_VERIFYCONTEXT | CRYPT_SILENT))
2655    return; /* failed */
2656
2657  do {
2658    DWORD cbHashSize = 0;
2659    DWORD dwHashSizeLen = (DWORD)sizeof(cbHashSize);
2660    DWORD dwChecksumLen = (DWORD)checksumlen;
2661
2662    if(!CryptCreateHash(hProv, algId, 0, 0, &hHash))
2663      break; /* failed */
2664
2665    if(!CryptHashData(hHash, input, (DWORD)inputlen, 0))
2666      break; /* failed */
2667
2668    /* get hash size */
2669    if(!CryptGetHashParam(hHash, HP_HASHSIZE, (BYTE *)&cbHashSize,
2670                          &dwHashSizeLen, 0))
2671      break; /* failed */
2672
2673    /* check hash size */
2674    if(checksumlen < cbHashSize)
2675      break; /* failed */
2676
2677    if(CryptGetHashParam(hHash, HP_HASHVAL, checksum, &dwChecksumLen, 0))
2678      break; /* failed */
2679  } while(0);
2680
2681  if(hHash)
2682    CryptDestroyHash(hHash);
2683
2684  if(hProv)
2685    CryptReleaseContext(hProv, 0);
2686}
2687
2688static CURLcode schannel_sha256sum(const unsigned char *input,
2689                                   size_t inputlen,
2690                                   unsigned char *sha256sum,
2691                                   size_t sha256len)
2692{
2693  schannel_checksum(input, inputlen, sha256sum, sha256len,
2694                    PROV_RSA_AES, CALG_SHA_256);
2695  return CURLE_OK;
2696}
2697
2698static void *schannel_get_internals(struct ssl_connect_data *connssl,
2699                                    CURLINFO info)
2700{
2701  struct schannel_ssl_backend_data *backend =
2702    (struct schannel_ssl_backend_data *)connssl->backend;
2703  (void)info;
2704  DEBUGASSERT(backend);
2705  return &backend->ctxt->ctxt_handle;
2706}
2707
2708HCERTSTORE Curl_schannel_get_cached_cert_store(struct Curl_cfilter *cf,
2709                                               struct Curl_easy *data)
2710{
2711  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
2712  struct Curl_multi *multi = data->multi;
2713  const struct curl_blob *ca_info_blob = conn_config->ca_info_blob;
2714  struct schannel_cert_share *share;
2715  const struct ssl_general_config *cfg = &data->set.general_ssl;
2716  timediff_t timeout_ms;
2717  unsigned char info_blob_digest[CURL_SHA256_DIGEST_LENGTH];
2718
2719  DEBUGASSERT(multi);
2720
2721  if(!multi) {
2722    return NULL;
2723  }
2724
2725  share = Curl_hash_pick(&multi->proto_hash,
2726                         CURL_UNCONST(MPROTO_SCHANNEL_CERT_SHARE_KEY),
2727                         sizeof(MPROTO_SCHANNEL_CERT_SHARE_KEY) - 1);
2728  if(!share || !share->cert_store) {
2729    return NULL;
2730  }
2731
2732  /* zero ca_cache_timeout completely disables caching */
2733  if(!cfg->ca_cache_timeout) {
2734    return NULL;
2735  }
2736
2737  /* check for cache timeout by using the cached_x509_store_expired timediff
2738     calculation pattern from openssl.c.
2739     negative timeout means retain forever. */
2740  timeout_ms = cfg->ca_cache_timeout * (timediff_t)1000;
2741  if(timeout_ms >= 0) {
2742    timediff_t elapsed_ms =
2743      curlx_ptimediff_ms(Curl_pgrs_now(data), &share->time);
2744    if(elapsed_ms >= timeout_ms) {
2745      return NULL;
2746    }
2747  }
2748
2749  if(ca_info_blob) {
2750    if(share->CAinfo_blob_size != ca_info_blob->len) {
2751      return NULL;
2752    }
2753    schannel_sha256sum((const unsigned char *)ca_info_blob->data,
2754                       ca_info_blob->len,
2755                       info_blob_digest,
2756                       CURL_SHA256_DIGEST_LENGTH);
2757    if(memcmp(share->CAinfo_blob_digest, info_blob_digest,
2758              CURL_SHA256_DIGEST_LENGTH)) {
2759      return NULL;
2760    }
2761  }
2762  else {
2763    if(!conn_config->CAfile || !share->CAfile ||
2764       strcmp(share->CAfile, conn_config->CAfile)) {
2765      return NULL;
2766    }
2767  }
2768
2769  return share->cert_store;
2770}
2771
2772static void schannel_cert_share_free(void *key, size_t key_len, void *p)
2773{
2774  struct schannel_cert_share *share = p;
2775  DEBUGASSERT(key_len == (sizeof(MPROTO_SCHANNEL_CERT_SHARE_KEY) - 1));
2776  DEBUGASSERT(!memcmp(MPROTO_SCHANNEL_CERT_SHARE_KEY, key, key_len));
2777  (void)key;
2778  (void)key_len;
2779  if(share->cert_store) {
2780    CertCloseStore(share->cert_store, 0);
2781  }
2782  curlx_free(share->CAfile);
2783  curlx_free(share);
2784}
2785
2786bool Curl_schannel_set_cached_cert_store(struct Curl_cfilter *cf,
2787                                         struct Curl_easy *data,
2788                                         HCERTSTORE cert_store)
2789{
2790  struct ssl_primary_config *conn_config = Curl_ssl_cf_get_primary_config(cf);
2791  struct Curl_multi *multi = data->multi;
2792  const struct curl_blob *ca_info_blob = conn_config->ca_info_blob;
2793  struct schannel_cert_share *share;
2794  size_t CAinfo_blob_size = 0;
2795  char *CAfile = NULL;
2796
2797  DEBUGASSERT(multi);
2798
2799  if(!multi) {
2800    return FALSE;
2801  }
2802
2803  share = Curl_hash_pick(&multi->proto_hash,
2804                         CURL_UNCONST(MPROTO_SCHANNEL_CERT_SHARE_KEY),
2805                         sizeof(MPROTO_SCHANNEL_CERT_SHARE_KEY) - 1);
2806  if(!share) {
2807    share = curlx_calloc(1, sizeof(*share));
2808    if(!share) {
2809      return FALSE;
2810    }
2811    if(!Curl_hash_add2(&multi->proto_hash,
2812                       CURL_UNCONST(MPROTO_SCHANNEL_CERT_SHARE_KEY),
2813                       sizeof(MPROTO_SCHANNEL_CERT_SHARE_KEY) - 1,
2814                       share, schannel_cert_share_free)) {
2815      curlx_free(share);
2816      return FALSE;
2817    }
2818  }
2819
2820  if(ca_info_blob) {
2821    schannel_sha256sum((const unsigned char *)ca_info_blob->data,
2822                       ca_info_blob->len,
2823                       share->CAinfo_blob_digest,
2824                       CURL_SHA256_DIGEST_LENGTH);
2825    CAinfo_blob_size = ca_info_blob->len;
2826  }
2827  else {
2828    if(conn_config->CAfile) {
2829      CAfile = curlx_strdup(conn_config->CAfile);
2830      if(!CAfile) {
2831        return FALSE;
2832      }
2833    }
2834  }
2835
2836  /* free old cache data */
2837  if(share->cert_store) {
2838    CertCloseStore(share->cert_store, 0);
2839  }
2840  curlx_free(share->CAfile);
2841
2842  share->time = curlx_now();
2843  share->cert_store = cert_store;
2844  share->CAinfo_blob_size = CAinfo_blob_size;
2845  share->CAfile = CAfile;
2846  return TRUE;
2847}
2848
2849const struct Curl_ssl Curl_ssl_schannel = {
2850  { CURLSSLBACKEND_SCHANNEL, "schannel" }, /* info */
2851
2852  SSLSUPP_CERTINFO |
2853  SSLSUPP_CAINFO_BLOB |
2854  SSLSUPP_PINNEDPUBKEY |
2855  SSLSUPP_CA_CACHE |
2856  SSLSUPP_HTTPS_PROXY |
2857  SSLSUPP_CIPHER_LIST,
2858
2859  sizeof(struct schannel_ssl_backend_data),
2860
2861  schannel_init,                     /* init */
2862  schannel_cleanup,                  /* cleanup */
2863  schannel_version,                  /* version */
2864  schannel_shutdown,                 /* shutdown */
2865  schannel_data_pending,             /* data_pending */
2866  schannel_random,                   /* random */
2867  NULL,                              /* cert_status_request */
2868  schannel_connect,                  /* connect */
2869  Curl_ssl_adjust_pollset,           /* adjust_pollset */
2870  schannel_get_internals,            /* get_internals */
2871  schannel_close,                    /* close_one */
2872  NULL,                              /* close_all */
2873  NULL,                              /* set_engine */
2874  NULL,                              /* set_engine_default */
2875  NULL,                              /* engines_list */
2876  schannel_sha256sum,                /* sha256sum */
2877  schannel_recv,                     /* recv decrypted data */
2878  schannel_send,                     /* send data to encrypt */
2879  NULL,                              /* get_channel_binding */
2880};
2881
2882#endif /* USE_SCHANNEL */