folly/io/async/SSLContext.cpp

   1 /*
   2  * Copyright 2017 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "SSLContext.h"
  18
  19 #include <folly/Format.h>
  20 #include <folly/Memory.h>
  21 #include <folly/Random.h>
  22 #include <folly/SharedMutex.h>
  23 #include <folly/SpinLock.h>
  24 #include <folly/ssl/Init.h>
  25 #include <folly/system/ThreadId.h>
  26
  27 // ---------------------------------------------------------------------
  28 // SSLContext implementation
  29 // ---------------------------------------------------------------------
  30 namespace folly {
  31 //
  32 // For OpenSSL portability API
  33 using namespace folly::ssl;
  34
  35 // SSLContext implementation
  36 SSLContext::SSLContext(SSLVersion version) {
  37   folly::ssl::init();
  38
  39   ctx_ = SSL_CTX_new(SSLv23_method());
  40   if (ctx_ == nullptr) {
  41     throw std::runtime_error("SSL_CTX_new: " + getErrors());
  42   }
  43
  44   int opt = 0;
  45   switch (version) {
  46     case TLSv1:
  47       opt = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
  48       break;
  49     case SSLv3:
  50       opt = SSL_OP_NO_SSLv2;
  51       break;
  52     case TLSv1_2:
  53       opt = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3 | SSL_OP_NO_TLSv1 |
  54           SSL_OP_NO_TLSv1_1;
  55       break;
  56     default:
  57       // do nothing
  58       break;
  59   }
  60   int newOpt = SSL_CTX_set_options(ctx_, opt);
  61   DCHECK((newOpt & opt) == opt);
  62
  63   SSL_CTX_set_mode(ctx_, SSL_MODE_AUTO_RETRY);
  64
  65   checkPeerName_ = false;
  66
  67   SSL_CTX_set_options(ctx_, SSL_OP_NO_COMPRESSION);
  68
  69 #if FOLLY_OPENSSL_HAS_SNI
  70   SSL_CTX_set_tlsext_servername_callback(ctx_, baseServerNameOpenSSLCallback);
  71   SSL_CTX_set_tlsext_servername_arg(ctx_, this);
  72 #endif
  73 }
  74
  75 SSLContext::~SSLContext() {
  76   if (ctx_ != nullptr) {
  77     SSL_CTX_free(ctx_);
  78     ctx_ = nullptr;
  79   }
  80
  81 #ifdef OPENSSL_NPN_NEGOTIATED
  82   deleteNextProtocolsStrings();
  83 #endif
  84 }
  85
  86 void SSLContext::ciphers(const std::string& ciphers) {
  87   setCiphersOrThrow(ciphers);
  88 }
  89
  90 void SSLContext::setClientECCurvesList(
  91     const std::vector<std::string>& ecCurves) {
  92   if (ecCurves.size() == 0) {
  93     return;
  94   }
  95 #if OPENSSL_VERSION_NUMBER >= 0x1000200fL
  96   std::string ecCurvesList;
  97   join(":", ecCurves, ecCurvesList);
  98   int rc = SSL_CTX_set1_curves_list(ctx_, ecCurvesList.c_str());
  99   if (rc == 0) {
 100     throw std::runtime_error("SSL_CTX_set1_curves_list " + getErrors());
 101   }
 102 #endif
 103 }
 104
 105 void SSLContext::setServerECCurve(const std::string& curveName) {
 106 #if OPENSSL_VERSION_NUMBER >= 0x0090800fL && !defined(OPENSSL_NO_ECDH)
 107   EC_KEY* ecdh = nullptr;
 108   int nid;
 109
 110   /*
 111    * Elliptic-Curve Diffie-Hellman parameters are either "named curves"
 112    * from RFC 4492 section 5.1.1, or explicitly described curves over
 113    * binary fields. OpenSSL only supports the "named curves", which provide
 114    * maximum interoperability.
 115    */
 116
 117   nid = OBJ_sn2nid(curveName.c_str());
 118   if (nid == 0) {
 119     LOG(FATAL) << "Unknown curve name:" << curveName.c_str();
 120   }
 121   ecdh = EC_KEY_new_by_curve_name(nid);
 122   if (ecdh == nullptr) {
 123     LOG(FATAL) << "Unable to create curve:" << curveName.c_str();
 124   }
 125
 126   SSL_CTX_set_tmp_ecdh(ctx_, ecdh);
 127   EC_KEY_free(ecdh);
 128 #else
 129   throw std::runtime_error("Elliptic curve encryption not allowed");
 130 #endif
 131 }
 132
 133 void SSLContext::setX509VerifyParam(
 134     const ssl::X509VerifyParam& x509VerifyParam) {
 135   if (!x509VerifyParam) {
 136     return;
 137   }
 138   if (SSL_CTX_set1_param(ctx_, x509VerifyParam.get()) != 1) {
 139     throw std::runtime_error("SSL_CTX_set1_param " + getErrors());
 140   }
 141 }
 142
 143 void SSLContext::setCiphersOrThrow(const std::string& ciphers) {
 144   int rc = SSL_CTX_set_cipher_list(ctx_, ciphers.c_str());
 145   if (rc == 0) {
 146     throw std::runtime_error("SSL_CTX_set_cipher_list: " + getErrors());
 147   }
 148   providedCiphersString_ = ciphers;
 149 }
 150
 151 void SSLContext::setVerificationOption(const SSLContext::SSLVerifyPeerEnum&
 152     verifyPeer) {
 153   CHECK(verifyPeer != SSLVerifyPeerEnum::USE_CTX); // dont recurse
 154   verifyPeer_ = verifyPeer;
 155 }
 156
 157 int SSLContext::getVerificationMode(const SSLContext::SSLVerifyPeerEnum&
 158     verifyPeer) {
 159   CHECK(verifyPeer != SSLVerifyPeerEnum::USE_CTX);
 160   int mode = SSL_VERIFY_NONE;
 161   switch(verifyPeer) {
 162     // case SSLVerifyPeerEnum::USE_CTX: // can't happen
 163     // break;
 164
 165     case SSLVerifyPeerEnum::VERIFY:
 166       mode = SSL_VERIFY_PEER;
 167       break;
 168
 169     case SSLVerifyPeerEnum::VERIFY_REQ_CLIENT_CERT:
 170       mode = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT;
 171       break;
 172
 173     case SSLVerifyPeerEnum::NO_VERIFY:
 174       mode = SSL_VERIFY_NONE;
 175       break;
 176
 177     default:
 178       break;
 179   }
 180   return mode;
 181 }
 182
 183 int SSLContext::getVerificationMode() {
 184   return getVerificationMode(verifyPeer_);
 185 }
 186
 187 void SSLContext::authenticate(bool checkPeerCert, bool checkPeerName,
 188                               const std::string& peerName) {
 189   int mode;
 190   if (checkPeerCert) {
 191     mode = SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT |
 192         SSL_VERIFY_CLIENT_ONCE;
 193     checkPeerName_ = checkPeerName;
 194     peerFixedName_ = peerName;
 195   } else {
 196     mode = SSL_VERIFY_NONE;
 197     checkPeerName_ = false; // can't check name without cert!
 198     peerFixedName_.clear();
 199   }
 200   SSL_CTX_set_verify(ctx_, mode, nullptr);
 201 }
 202
 203 void SSLContext::loadCertificate(const char* path, const char* format) {
 204   if (path == nullptr || format == nullptr) {
 205     throw std::invalid_argument(
 206          "loadCertificateChain: either <path> or <format> is nullptr");
 207   }
 208   if (strcmp(format, "PEM") == 0) {
 209     if (SSL_CTX_use_certificate_chain_file(ctx_, path) == 0) {
 210       int errnoCopy = errno;
 211       std::string reason("SSL_CTX_use_certificate_chain_file: ");
 212       reason.append(path);
 213       reason.append(": ");
 214       reason.append(getErrors(errnoCopy));
 215       throw std::runtime_error(reason);
 216     }
 217   } else {
 218     throw std::runtime_error(
 219         "Unsupported certificate format: " + std::string(format));
 220   }
 221 }
 222
 223 void SSLContext::loadCertificateFromBufferPEM(folly::StringPiece cert) {
 224   if (cert.data() == nullptr) {
 225     throw std::invalid_argument("loadCertificate: <cert> is nullptr");
 226   }
 227
 228   ssl::BioUniquePtr bio(BIO_new(BIO_s_mem()));
 229   if (bio == nullptr) {
 230     throw std::runtime_error("BIO_new: " + getErrors());
 231   }
 232
 233   int written = BIO_write(bio.get(), cert.data(), int(cert.size()));
 234   if (written <= 0 || static_cast<unsigned>(written) != cert.size()) {
 235     throw std::runtime_error("BIO_write: " + getErrors());
 236   }
 237
 238   ssl::X509UniquePtr x509(
 239       PEM_read_bio_X509(bio.get(), nullptr, nullptr, nullptr));
 240   if (x509 == nullptr) {
 241     throw std::runtime_error("PEM_read_bio_X509: " + getErrors());
 242   }
 243
 244   if (SSL_CTX_use_certificate(ctx_, x509.get()) == 0) {
 245     throw std::runtime_error("SSL_CTX_use_certificate: " + getErrors());
 246   }
 247 }
 248
 249 void SSLContext::loadPrivateKey(const char* path, const char* format) {
 250   if (path == nullptr || format == nullptr) {
 251     throw std::invalid_argument(
 252         "loadPrivateKey: either <path> or <format> is nullptr");
 253   }
 254   if (strcmp(format, "PEM") == 0) {
 255     if (SSL_CTX_use_PrivateKey_file(ctx_, path, SSL_FILETYPE_PEM) == 0) {
 256       throw std::runtime_error("SSL_CTX_use_PrivateKey_file: " + getErrors());
 257     }
 258   } else {
 259     throw std::runtime_error(
 260         "Unsupported private key format: " + std::string(format));
 261   }
 262 }
 263
 264 void SSLContext::loadPrivateKeyFromBufferPEM(folly::StringPiece pkey) {
 265   if (pkey.data() == nullptr) {
 266     throw std::invalid_argument("loadPrivateKey: <pkey> is nullptr");
 267   }
 268
 269   ssl::BioUniquePtr bio(BIO_new(BIO_s_mem()));
 270   if (bio == nullptr) {
 271     throw std::runtime_error("BIO_new: " + getErrors());
 272   }
 273
 274   int written = BIO_write(bio.get(), pkey.data(), int(pkey.size()));
 275   if (written <= 0 || static_cast<unsigned>(written) != pkey.size()) {
 276     throw std::runtime_error("BIO_write: " + getErrors());
 277   }
 278
 279   ssl::EvpPkeyUniquePtr key(
 280       PEM_read_bio_PrivateKey(bio.get(), nullptr, nullptr, nullptr));
 281   if (key == nullptr) {
 282     throw std::runtime_error("PEM_read_bio_PrivateKey: " + getErrors());
 283   }
 284
 285   if (SSL_CTX_use_PrivateKey(ctx_, key.get()) == 0) {
 286     throw std::runtime_error("SSL_CTX_use_PrivateKey: " + getErrors());
 287   }
 288 }
 289
 290 void SSLContext::loadCertKeyPairFromBufferPEM(
 291     folly::StringPiece cert,
 292     folly::StringPiece pkey) {
 293   loadCertificateFromBufferPEM(cert);
 294   loadPrivateKeyFromBufferPEM(pkey);
 295 }
 296
 297 void SSLContext::loadCertKeyPairFromFiles(
 298     const char* certPath,
 299     const char* keyPath,
 300     const char* certFormat,
 301     const char* keyFormat) {
 302   loadCertificate(certPath, certFormat);
 303   loadPrivateKey(keyPath, keyFormat);
 304 }
 305
 306 bool SSLContext::isCertKeyPairValid() const {
 307   return SSL_CTX_check_private_key(ctx_) == 1;
 308 }
 309
 310 void SSLContext::loadTrustedCertificates(const char* path) {
 311   if (path == nullptr) {
 312     throw std::invalid_argument("loadTrustedCertificates: <path> is nullptr");
 313   }
 314   if (SSL_CTX_load_verify_locations(ctx_, path, nullptr) == 0) {
 315     throw std::runtime_error("SSL_CTX_load_verify_locations: " + getErrors());
 316   }
 317   ERR_clear_error();
 318 }
 319
 320 void SSLContext::loadTrustedCertificates(X509_STORE* store) {
 321   SSL_CTX_set_cert_store(ctx_, store);
 322 }
 323
 324 void SSLContext::loadClientCAList(const char* path) {
 325   auto clientCAs = SSL_load_client_CA_file(path);
 326   if (clientCAs == nullptr) {
 327     LOG(ERROR) << "Unable to load ca file: " << path;
 328     return;
 329   }
 330   SSL_CTX_set_client_CA_list(ctx_, clientCAs);
 331 }
 332
 333 void SSLContext::passwordCollector(
 334     std::shared_ptr<PasswordCollector> collector) {
 335   if (collector == nullptr) {
 336     LOG(ERROR) << "passwordCollector: ignore invalid password collector";
 337     return;
 338   }
 339   collector_ = collector;
 340   SSL_CTX_set_default_passwd_cb(ctx_, passwordCallback);
 341   SSL_CTX_set_default_passwd_cb_userdata(ctx_, this);
 342 }
 343
 344 #if FOLLY_OPENSSL_HAS_SNI
 345
 346 void SSLContext::setServerNameCallback(const ServerNameCallback& cb) {
 347   serverNameCb_ = cb;
 348 }
 349
 350 void SSLContext::addClientHelloCallback(const ClientHelloCallback& cb) {
 351   clientHelloCbs_.push_back(cb);
 352 }
 353
 354 int SSLContext::baseServerNameOpenSSLCallback(SSL* ssl, int* al, void* data) {
 355   SSLContext* context = (SSLContext*)data;
 356
 357   if (context == nullptr) {
 358     return SSL_TLSEXT_ERR_NOACK;
 359   }
 360
 361   for (auto& cb : context->clientHelloCbs_) {
 362     // Generic callbacks to happen after we receive the Client Hello.
 363     // For example, we use one to switch which cipher we use depending
 364     // on the user's TLS version.  Because the primary purpose of
 365     // baseServerNameOpenSSLCallback is for SNI support, and these callbacks
 366     // are side-uses, we ignore any possible failures other than just logging
 367     // them.
 368     cb(ssl);
 369   }
 370
 371   if (!context->serverNameCb_) {
 372     return SSL_TLSEXT_ERR_NOACK;
 373   }
 374
 375   ServerNameCallbackResult ret = context->serverNameCb_(ssl);
 376   switch (ret) {
 377     case SERVER_NAME_FOUND:
 378       return SSL_TLSEXT_ERR_OK;
 379     case SERVER_NAME_NOT_FOUND:
 380       return SSL_TLSEXT_ERR_NOACK;
 381     case SERVER_NAME_NOT_FOUND_ALERT_FATAL:
 382       *al = TLS1_AD_UNRECOGNIZED_NAME;
 383       return SSL_TLSEXT_ERR_ALERT_FATAL;
 384     default:
 385       CHECK(false);
 386   }
 387
 388   return SSL_TLSEXT_ERR_NOACK;
 389 }
 390 #endif // FOLLY_OPENSSL_HAS_SNI
 391
 392 #if FOLLY_OPENSSL_HAS_ALPN
 393 int SSLContext::alpnSelectCallback(SSL* /* ssl */,
 394                                    const unsigned char** out,
 395                                    unsigned char* outlen,
 396                                    const unsigned char* in,
 397                                    unsigned int inlen,
 398                                    void* data) {
 399   SSLContext* context = (SSLContext*)data;
 400   CHECK(context);
 401   if (context->advertisedNextProtocols_.empty()) {
 402     *out = nullptr;
 403     *outlen = 0;
 404   } else {
 405     auto i = context->pickNextProtocols();
 406     const auto& item = context->advertisedNextProtocols_[i];
 407     if (SSL_select_next_proto((unsigned char**)out,
 408                               outlen,
 409                               item.protocols,
 410                               item.length,
 411                               in,
 412                               inlen) != OPENSSL_NPN_NEGOTIATED) {
 413       return SSL_TLSEXT_ERR_NOACK;
 414     }
 415   }
 416   return SSL_TLSEXT_ERR_OK;
 417 }
 418 #endif // FOLLY_OPENSSL_HAS_ALPN
 419
 420 #ifdef OPENSSL_NPN_NEGOTIATED
 421
 422 bool SSLContext::setAdvertisedNextProtocols(
 423     const std::list<std::string>& protocols, NextProtocolType protocolType) {
 424   return setRandomizedAdvertisedNextProtocols({{1, protocols}}, protocolType);
 425 }
 426
 427 bool SSLContext::setRandomizedAdvertisedNextProtocols(
 428     const std::list<NextProtocolsItem>& items, NextProtocolType protocolType) {
 429   unsetNextProtocols();
 430   if (items.size() == 0) {
 431     return false;
 432   }
 433   int total_weight = 0;
 434   for (const auto &item : items) {
 435     if (item.protocols.size() == 0) {
 436       continue;
 437     }
 438     AdvertisedNextProtocolsItem advertised_item;
 439     advertised_item.length = 0;
 440     for (const auto& proto : item.protocols) {
 441       ++advertised_item.length;
 442       auto protoLength = proto.length();
 443       if (protoLength >= 256) {
 444         deleteNextProtocolsStrings();
 445         return false;
 446       }
 447       advertised_item.length += unsigned(protoLength);
 448     }
 449     advertised_item.protocols = new unsigned char[advertised_item.length];
 450     if (!advertised_item.protocols) {
 451       throw std::runtime_error("alloc failure");
 452     }
 453     unsigned char* dst = advertised_item.protocols;
 454     for (auto& proto : item.protocols) {
 455       uint8_t protoLength = uint8_t(proto.length());
 456       *dst++ = (unsigned char)protoLength;
 457       memcpy(dst, proto.data(), protoLength);
 458       dst += protoLength;
 459     }
 460     total_weight += item.weight;
 461     advertisedNextProtocols_.push_back(advertised_item);
 462     advertisedNextProtocolWeights_.push_back(item.weight);
 463   }
 464   if (total_weight == 0) {
 465     deleteNextProtocolsStrings();
 466     return false;
 467   }
 468   nextProtocolDistribution_ =
 469       std::discrete_distribution<>(advertisedNextProtocolWeights_.begin(),
 470                                    advertisedNextProtocolWeights_.end());
 471   if ((uint8_t)protocolType & (uint8_t)NextProtocolType::NPN) {
 472     SSL_CTX_set_next_protos_advertised_cb(
 473         ctx_, advertisedNextProtocolCallback, this);
 474     SSL_CTX_set_next_proto_select_cb(ctx_, selectNextProtocolCallback, this);
 475   }
 476 #if FOLLY_OPENSSL_HAS_ALPN
 477   if ((uint8_t)protocolType & (uint8_t)NextProtocolType::ALPN) {
 478     SSL_CTX_set_alpn_select_cb(ctx_, alpnSelectCallback, this);
 479     // Client cannot really use randomized alpn
 480     SSL_CTX_set_alpn_protos(ctx_,
 481                             advertisedNextProtocols_[0].protocols,
 482                             advertisedNextProtocols_[0].length);
 483   }
 484 #endif
 485   return true;
 486 }
 487
 488 void SSLContext::deleteNextProtocolsStrings() {
 489   for (auto protocols : advertisedNextProtocols_) {
 490     delete[] protocols.protocols;
 491   }
 492   advertisedNextProtocols_.clear();
 493   advertisedNextProtocolWeights_.clear();
 494 }
 495
 496 void SSLContext::unsetNextProtocols() {
 497   deleteNextProtocolsStrings();
 498   SSL_CTX_set_next_protos_advertised_cb(ctx_, nullptr, nullptr);
 499   SSL_CTX_set_next_proto_select_cb(ctx_, nullptr, nullptr);
 500 #if FOLLY_OPENSSL_HAS_ALPN
 501   SSL_CTX_set_alpn_select_cb(ctx_, nullptr, nullptr);
 502   SSL_CTX_set_alpn_protos(ctx_, nullptr, 0);
 503 #endif
 504 }
 505
 506 size_t SSLContext::pickNextProtocols() {
 507   CHECK(!advertisedNextProtocols_.empty()) << "Failed to pickNextProtocols";
 508   auto rng = ThreadLocalPRNG();
 509   return size_t(nextProtocolDistribution_(rng));
 510 }
 511
 512 int SSLContext::advertisedNextProtocolCallback(SSL* ssl,
 513       const unsigned char** out, unsigned int* outlen, void* data) {
 514   static int nextProtocolsExDataIndex = SSL_get_ex_new_index(
 515       0, (void*)"Advertised next protocol index", nullptr, nullptr, nullptr);
 516
 517   SSLContext* context = (SSLContext*)data;
 518   if (context == nullptr || context->advertisedNextProtocols_.empty()) {
 519     *out = nullptr;
 520     *outlen = 0;
 521   } else if (context->advertisedNextProtocols_.size() == 1) {
 522     *out = context->advertisedNextProtocols_[0].protocols;
 523     *outlen = context->advertisedNextProtocols_[0].length;
 524   } else {
 525     uintptr_t selected_index = reinterpret_cast<uintptr_t>(
 526         SSL_get_ex_data(ssl, nextProtocolsExDataIndex));
 527     if (selected_index) {
 528       --selected_index;
 529       *out = context->advertisedNextProtocols_[selected_index].protocols;
 530       *outlen = context->advertisedNextProtocols_[selected_index].length;
 531     } else {
 532       auto i = context->pickNextProtocols();
 533       uintptr_t selected = i + 1;
 534       SSL_set_ex_data(ssl, nextProtocolsExDataIndex, (void*)selected);
 535       *out = context->advertisedNextProtocols_[i].protocols;
 536       *outlen = context->advertisedNextProtocols_[i].length;
 537     }
 538   }
 539   return SSL_TLSEXT_ERR_OK;
 540 }
 541
 542 int SSLContext::selectNextProtocolCallback(SSL* ssl,
 543                                            unsigned char** out,
 544                                            unsigned char* outlen,
 545                                            const unsigned char* server,
 546                                            unsigned int server_len,
 547                                            void* data) {
 548   (void)ssl; // Make -Wunused-parameters happy
 549   SSLContext* ctx = (SSLContext*)data;
 550   if (ctx->advertisedNextProtocols_.size() > 1) {
 551     VLOG(3) << "SSLContext::selectNextProcolCallback() "
 552             << "client should be deterministic in selecting protocols.";
 553   }
 554
 555   unsigned char* client = nullptr;
 556   unsigned int client_len = 0;
 557   bool filtered = false;
 558   auto cpf = ctx->getClientProtocolFilterCallback();
 559   if (cpf) {
 560     filtered = (*cpf)(&client, &client_len, server, server_len);
 561   }
 562
 563   if (!filtered) {
 564     if (ctx->advertisedNextProtocols_.empty()) {
 565       client = (unsigned char *) "";
 566       client_len = 0;
 567     } else {
 568       client = ctx->advertisedNextProtocols_[0].protocols;
 569       client_len = ctx->advertisedNextProtocols_[0].length;
 570     }
 571   }
 572
 573   int retval = SSL_select_next_proto(out, outlen, server, server_len,
 574                                      client, client_len);
 575   if (retval != OPENSSL_NPN_NEGOTIATED) {
 576     VLOG(3) << "SSLContext::selectNextProcolCallback() "
 577             << "unable to pick a next protocol.";
 578   }
 579   return SSL_TLSEXT_ERR_OK;
 580 }
 581 #endif // OPENSSL_NPN_NEGOTIATED
 582
 583 SSL* SSLContext::createSSL() const {
 584   SSL* ssl = SSL_new(ctx_);
 585   if (ssl == nullptr) {
 586     throw std::runtime_error("SSL_new: " + getErrors());
 587   }
 588   return ssl;
 589 }
 590
 591 void SSLContext::setSessionCacheContext(const std::string& context) {
 592   SSL_CTX_set_session_id_context(
 593       ctx_,
 594       reinterpret_cast<const unsigned char*>(context.data()),
 595       std::min<unsigned int>(
 596           static_cast<unsigned int>(context.length()), SSL_MAX_SID_CTX_LENGTH));
 597 }
 598
 599 /**
 600  * Match a name with a pattern. The pattern may include wildcard. A single
 601  * wildcard "*" can match up to one component in the domain name.
 602  *
 603  * @param  host    Host name, typically the name of the remote host
 604  * @param  pattern Name retrieved from certificate
 605  * @param  size    Size of "pattern"
 606  * @return True, if "host" matches "pattern". False otherwise.
 607  */
 608 bool SSLContext::matchName(const char* host, const char* pattern, int size) {
 609   bool match = false;
 610   int i = 0, j = 0;
 611   while (i < size && host[j] != '\0') {
 612     if (toupper(pattern[i]) == toupper(host[j])) {
 613       i++;
 614       j++;
 615       continue;
 616     }
 617     if (pattern[i] == '*') {
 618       while (host[j] != '.' && host[j] != '\0') {
 619         j++;
 620       }
 621       i++;
 622       continue;
 623     }
 624     break;
 625   }
 626   if (i == size && host[j] == '\0') {
 627     match = true;
 628   }
 629   return match;
 630 }
 631
 632 int SSLContext::passwordCallback(char* password,
 633                                  int size,
 634                                  int,
 635                                  void* data) {
 636   SSLContext* context = (SSLContext*)data;
 637   if (context == nullptr || context->passwordCollector() == nullptr) {
 638     return 0;
 639   }
 640   std::string userPassword;
 641   // call user defined password collector to get password
 642   context->passwordCollector()->getPassword(userPassword, size);
 643   auto const length = std::min(userPassword.size(), size_t(size));
 644   std::memcpy(password, userPassword.data(), length);
 645   return int(length);
 646 }
 647
 648 #if defined(SSL_MODE_HANDSHAKE_CUTTHROUGH)
 649 void SSLContext::enableFalseStart() {
 650   SSL_CTX_set_mode(ctx_, SSL_MODE_HANDSHAKE_CUTTHROUGH);
 651 }
 652 #endif
 653
 654 void SSLContext::initializeOpenSSL() {
 655   folly::ssl::init();
 656 }
 657
 658 void SSLContext::setOptions(long options) {
 659   long newOpt = SSL_CTX_set_options(ctx_, options);
 660   if ((newOpt & options) != options) {
 661     throw std::runtime_error("SSL_CTX_set_options failed");
 662   }
 663 }
 664
 665 std::string SSLContext::getErrors(int errnoCopy) {
 666   std::string errors;
 667   unsigned long  errorCode;
 668   char   message[256];
 669
 670   errors.reserve(512);
 671   while ((errorCode = ERR_get_error()) != 0) {
 672     if (!errors.empty()) {
 673       errors += "; ";
 674     }
 675     const char* reason = ERR_reason_error_string(errorCode);
 676     if (reason == nullptr) {
 677       snprintf(message, sizeof(message) - 1, "SSL error # %lu", errorCode);
 678       reason = message;
 679     }
 680     errors += reason;
 681   }
 682   if (errors.empty()) {
 683     errors = "error code: " + folly::to<std::string>(errnoCopy);
 684   }
 685   return errors;
 686 }
 687
 688 std::ostream&
 689 operator<<(std::ostream& os, const PasswordCollector& collector) {
 690   os << collector.describe();
 691   return os;
 692 }
 693
 694 } // namespace folly