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::loadTrustedCertificates(const char* path) {
 291   if (path == nullptr) {
 292     throw std::invalid_argument("loadTrustedCertificates: <path> is nullptr");
 293   }
 294   if (SSL_CTX_load_verify_locations(ctx_, path, nullptr) == 0) {
 295     throw std::runtime_error("SSL_CTX_load_verify_locations: " + getErrors());
 296   }
 297   ERR_clear_error();
 298 }
 299
 300 void SSLContext::loadTrustedCertificates(X509_STORE* store) {
 301   SSL_CTX_set_cert_store(ctx_, store);
 302 }
 303
 304 void SSLContext::loadClientCAList(const char* path) {
 305   auto clientCAs = SSL_load_client_CA_file(path);
 306   if (clientCAs == nullptr) {
 307     LOG(ERROR) << "Unable to load ca file: " << path;
 308     return;
 309   }
 310   SSL_CTX_set_client_CA_list(ctx_, clientCAs);
 311 }
 312
 313 void SSLContext::passwordCollector(
 314     std::shared_ptr<PasswordCollector> collector) {
 315   if (collector == nullptr) {
 316     LOG(ERROR) << "passwordCollector: ignore invalid password collector";
 317     return;
 318   }
 319   collector_ = collector;
 320   SSL_CTX_set_default_passwd_cb(ctx_, passwordCallback);
 321   SSL_CTX_set_default_passwd_cb_userdata(ctx_, this);
 322 }
 323
 324 #if FOLLY_OPENSSL_HAS_SNI
 325
 326 void SSLContext::setServerNameCallback(const ServerNameCallback& cb) {
 327   serverNameCb_ = cb;
 328 }
 329
 330 void SSLContext::addClientHelloCallback(const ClientHelloCallback& cb) {
 331   clientHelloCbs_.push_back(cb);
 332 }
 333
 334 int SSLContext::baseServerNameOpenSSLCallback(SSL* ssl, int* al, void* data) {
 335   SSLContext* context = (SSLContext*)data;
 336
 337   if (context == nullptr) {
 338     return SSL_TLSEXT_ERR_NOACK;
 339   }
 340
 341   for (auto& cb : context->clientHelloCbs_) {
 342     // Generic callbacks to happen after we receive the Client Hello.
 343     // For example, we use one to switch which cipher we use depending
 344     // on the user's TLS version.  Because the primary purpose of
 345     // baseServerNameOpenSSLCallback is for SNI support, and these callbacks
 346     // are side-uses, we ignore any possible failures other than just logging
 347     // them.
 348     cb(ssl);
 349   }
 350
 351   if (!context->serverNameCb_) {
 352     return SSL_TLSEXT_ERR_NOACK;
 353   }
 354
 355   ServerNameCallbackResult ret = context->serverNameCb_(ssl);
 356   switch (ret) {
 357     case SERVER_NAME_FOUND:
 358       return SSL_TLSEXT_ERR_OK;
 359     case SERVER_NAME_NOT_FOUND:
 360       return SSL_TLSEXT_ERR_NOACK;
 361     case SERVER_NAME_NOT_FOUND_ALERT_FATAL:
 362       *al = TLS1_AD_UNRECOGNIZED_NAME;
 363       return SSL_TLSEXT_ERR_ALERT_FATAL;
 364     default:
 365       CHECK(false);
 366   }
 367
 368   return SSL_TLSEXT_ERR_NOACK;
 369 }
 370 #endif // FOLLY_OPENSSL_HAS_SNI
 371
 372 #if FOLLY_OPENSSL_HAS_ALPN
 373 int SSLContext::alpnSelectCallback(SSL* /* ssl */,
 374                                    const unsigned char** out,
 375                                    unsigned char* outlen,
 376                                    const unsigned char* in,
 377                                    unsigned int inlen,
 378                                    void* data) {
 379   SSLContext* context = (SSLContext*)data;
 380   CHECK(context);
 381   if (context->advertisedNextProtocols_.empty()) {
 382     *out = nullptr;
 383     *outlen = 0;
 384   } else {
 385     auto i = context->pickNextProtocols();
 386     const auto& item = context->advertisedNextProtocols_[i];
 387     if (SSL_select_next_proto((unsigned char**)out,
 388                               outlen,
 389                               item.protocols,
 390                               item.length,
 391                               in,
 392                               inlen) != OPENSSL_NPN_NEGOTIATED) {
 393       return SSL_TLSEXT_ERR_NOACK;
 394     }
 395   }
 396   return SSL_TLSEXT_ERR_OK;
 397 }
 398 #endif // FOLLY_OPENSSL_HAS_ALPN
 399
 400 #ifdef OPENSSL_NPN_NEGOTIATED
 401
 402 bool SSLContext::setAdvertisedNextProtocols(
 403     const std::list<std::string>& protocols, NextProtocolType protocolType) {
 404   return setRandomizedAdvertisedNextProtocols({{1, protocols}}, protocolType);
 405 }
 406
 407 bool SSLContext::setRandomizedAdvertisedNextProtocols(
 408     const std::list<NextProtocolsItem>& items, NextProtocolType protocolType) {
 409   unsetNextProtocols();
 410   if (items.size() == 0) {
 411     return false;
 412   }
 413   int total_weight = 0;
 414   for (const auto &item : items) {
 415     if (item.protocols.size() == 0) {
 416       continue;
 417     }
 418     AdvertisedNextProtocolsItem advertised_item;
 419     advertised_item.length = 0;
 420     for (const auto& proto : item.protocols) {
 421       ++advertised_item.length;
 422       auto protoLength = proto.length();
 423       if (protoLength >= 256) {
 424         deleteNextProtocolsStrings();
 425         return false;
 426       }
 427       advertised_item.length += unsigned(protoLength);
 428     }
 429     advertised_item.protocols = new unsigned char[advertised_item.length];
 430     if (!advertised_item.protocols) {
 431       throw std::runtime_error("alloc failure");
 432     }
 433     unsigned char* dst = advertised_item.protocols;
 434     for (auto& proto : item.protocols) {
 435       uint8_t protoLength = uint8_t(proto.length());
 436       *dst++ = (unsigned char)protoLength;
 437       memcpy(dst, proto.data(), protoLength);
 438       dst += protoLength;
 439     }
 440     total_weight += item.weight;
 441     advertisedNextProtocols_.push_back(advertised_item);
 442     advertisedNextProtocolWeights_.push_back(item.weight);
 443   }
 444   if (total_weight == 0) {
 445     deleteNextProtocolsStrings();
 446     return false;
 447   }
 448   nextProtocolDistribution_ =
 449       std::discrete_distribution<>(advertisedNextProtocolWeights_.begin(),
 450                                    advertisedNextProtocolWeights_.end());
 451   if ((uint8_t)protocolType & (uint8_t)NextProtocolType::NPN) {
 452     SSL_CTX_set_next_protos_advertised_cb(
 453         ctx_, advertisedNextProtocolCallback, this);
 454     SSL_CTX_set_next_proto_select_cb(ctx_, selectNextProtocolCallback, this);
 455   }
 456 #if FOLLY_OPENSSL_HAS_ALPN
 457   if ((uint8_t)protocolType & (uint8_t)NextProtocolType::ALPN) {
 458     SSL_CTX_set_alpn_select_cb(ctx_, alpnSelectCallback, this);
 459     // Client cannot really use randomized alpn
 460     SSL_CTX_set_alpn_protos(ctx_,
 461                             advertisedNextProtocols_[0].protocols,
 462                             advertisedNextProtocols_[0].length);
 463   }
 464 #endif
 465   return true;
 466 }
 467
 468 void SSLContext::deleteNextProtocolsStrings() {
 469   for (auto protocols : advertisedNextProtocols_) {
 470     delete[] protocols.protocols;
 471   }
 472   advertisedNextProtocols_.clear();
 473   advertisedNextProtocolWeights_.clear();
 474 }
 475
 476 void SSLContext::unsetNextProtocols() {
 477   deleteNextProtocolsStrings();
 478   SSL_CTX_set_next_protos_advertised_cb(ctx_, nullptr, nullptr);
 479   SSL_CTX_set_next_proto_select_cb(ctx_, nullptr, nullptr);
 480 #if FOLLY_OPENSSL_HAS_ALPN
 481   SSL_CTX_set_alpn_select_cb(ctx_, nullptr, nullptr);
 482   SSL_CTX_set_alpn_protos(ctx_, nullptr, 0);
 483 #endif
 484 }
 485
 486 size_t SSLContext::pickNextProtocols() {
 487   CHECK(!advertisedNextProtocols_.empty()) << "Failed to pickNextProtocols";
 488   auto rng = ThreadLocalPRNG();
 489   return size_t(nextProtocolDistribution_(rng));
 490 }
 491
 492 int SSLContext::advertisedNextProtocolCallback(SSL* ssl,
 493       const unsigned char** out, unsigned int* outlen, void* data) {
 494   static int nextProtocolsExDataIndex = SSL_get_ex_new_index(
 495       0, (void*)"Advertised next protocol index", nullptr, nullptr, nullptr);
 496
 497   SSLContext* context = (SSLContext*)data;
 498   if (context == nullptr || context->advertisedNextProtocols_.empty()) {
 499     *out = nullptr;
 500     *outlen = 0;
 501   } else if (context->advertisedNextProtocols_.size() == 1) {
 502     *out = context->advertisedNextProtocols_[0].protocols;
 503     *outlen = context->advertisedNextProtocols_[0].length;
 504   } else {
 505     uintptr_t selected_index = reinterpret_cast<uintptr_t>(
 506         SSL_get_ex_data(ssl, nextProtocolsExDataIndex));
 507     if (selected_index) {
 508       --selected_index;
 509       *out = context->advertisedNextProtocols_[selected_index].protocols;
 510       *outlen = context->advertisedNextProtocols_[selected_index].length;
 511     } else {
 512       auto i = context->pickNextProtocols();
 513       uintptr_t selected = i + 1;
 514       SSL_set_ex_data(ssl, nextProtocolsExDataIndex, (void*)selected);
 515       *out = context->advertisedNextProtocols_[i].protocols;
 516       *outlen = context->advertisedNextProtocols_[i].length;
 517     }
 518   }
 519   return SSL_TLSEXT_ERR_OK;
 520 }
 521
 522 int SSLContext::selectNextProtocolCallback(SSL* ssl,
 523                                            unsigned char** out,
 524                                            unsigned char* outlen,
 525                                            const unsigned char* server,
 526                                            unsigned int server_len,
 527                                            void* data) {
 528   (void)ssl; // Make -Wunused-parameters happy
 529   SSLContext* ctx = (SSLContext*)data;
 530   if (ctx->advertisedNextProtocols_.size() > 1) {
 531     VLOG(3) << "SSLContext::selectNextProcolCallback() "
 532             << "client should be deterministic in selecting protocols.";
 533   }
 534
 535   unsigned char* client = nullptr;
 536   unsigned int client_len = 0;
 537   bool filtered = false;
 538   auto cpf = ctx->getClientProtocolFilterCallback();
 539   if (cpf) {
 540     filtered = (*cpf)(&client, &client_len, server, server_len);
 541   }
 542
 543   if (!filtered) {
 544     if (ctx->advertisedNextProtocols_.empty()) {
 545       client = (unsigned char *) "";
 546       client_len = 0;
 547     } else {
 548       client = ctx->advertisedNextProtocols_[0].protocols;
 549       client_len = ctx->advertisedNextProtocols_[0].length;
 550     }
 551   }
 552
 553   int retval = SSL_select_next_proto(out, outlen, server, server_len,
 554                                      client, client_len);
 555   if (retval != OPENSSL_NPN_NEGOTIATED) {
 556     VLOG(3) << "SSLContext::selectNextProcolCallback() "
 557             << "unable to pick a next protocol.";
 558   }
 559   return SSL_TLSEXT_ERR_OK;
 560 }
 561 #endif // OPENSSL_NPN_NEGOTIATED
 562
 563 SSL* SSLContext::createSSL() const {
 564   SSL* ssl = SSL_new(ctx_);
 565   if (ssl == nullptr) {
 566     throw std::runtime_error("SSL_new: " + getErrors());
 567   }
 568   return ssl;
 569 }
 570
 571 void SSLContext::setSessionCacheContext(const std::string& context) {
 572   SSL_CTX_set_session_id_context(
 573       ctx_,
 574       reinterpret_cast<const unsigned char*>(context.data()),
 575       std::min<unsigned int>(
 576           static_cast<unsigned int>(context.length()), SSL_MAX_SID_CTX_LENGTH));
 577 }
 578
 579 /**
 580  * Match a name with a pattern. The pattern may include wildcard. A single
 581  * wildcard "*" can match up to one component in the domain name.
 582  *
 583  * @param  host    Host name, typically the name of the remote host
 584  * @param  pattern Name retrieved from certificate
 585  * @param  size    Size of "pattern"
 586  * @return True, if "host" matches "pattern". False otherwise.
 587  */
 588 bool SSLContext::matchName(const char* host, const char* pattern, int size) {
 589   bool match = false;
 590   int i = 0, j = 0;
 591   while (i < size && host[j] != '\0') {
 592     if (toupper(pattern[i]) == toupper(host[j])) {
 593       i++;
 594       j++;
 595       continue;
 596     }
 597     if (pattern[i] == '*') {
 598       while (host[j] != '.' && host[j] != '\0') {
 599         j++;
 600       }
 601       i++;
 602       continue;
 603     }
 604     break;
 605   }
 606   if (i == size && host[j] == '\0') {
 607     match = true;
 608   }
 609   return match;
 610 }
 611
 612 int SSLContext::passwordCallback(char* password,
 613                                  int size,
 614                                  int,
 615                                  void* data) {
 616   SSLContext* context = (SSLContext*)data;
 617   if (context == nullptr || context->passwordCollector() == nullptr) {
 618     return 0;
 619   }
 620   std::string userPassword;
 621   // call user defined password collector to get password
 622   context->passwordCollector()->getPassword(userPassword, size);
 623   auto const length = std::min(userPassword.size(), size_t(size));
 624   std::memcpy(password, userPassword.data(), length);
 625   return int(length);
 626 }
 627
 628 #if defined(SSL_MODE_HANDSHAKE_CUTTHROUGH)
 629 void SSLContext::enableFalseStart() {
 630   SSL_CTX_set_mode(ctx_, SSL_MODE_HANDSHAKE_CUTTHROUGH);
 631 }
 632 #endif
 633
 634 void SSLContext::initializeOpenSSL() {
 635   folly::ssl::init();
 636 }
 637
 638 void SSLContext::setOptions(long options) {
 639   long newOpt = SSL_CTX_set_options(ctx_, options);
 640   if ((newOpt & options) != options) {
 641     throw std::runtime_error("SSL_CTX_set_options failed");
 642   }
 643 }
 644
 645 std::string SSLContext::getErrors(int errnoCopy) {
 646   std::string errors;
 647   unsigned long  errorCode;
 648   char   message[256];
 649
 650   errors.reserve(512);
 651   while ((errorCode = ERR_get_error()) != 0) {
 652     if (!errors.empty()) {
 653       errors += "; ";
 654     }
 655     const char* reason = ERR_reason_error_string(errorCode);
 656     if (reason == nullptr) {
 657       snprintf(message, sizeof(message) - 1, "SSL error # %lu", errorCode);
 658       reason = message;
 659     }
 660     errors += reason;
 661   }
 662   if (errors.empty()) {
 663     errors = "error code: " + folly::to<std::string>(errnoCopy);
 664   }
 665   return errors;
 666 }
 667
 668 std::ostream&
 669 operator<<(std::ostream& os, const PasswordCollector& collector) {
 670   os << collector.describe();
 671   return os;
 672 }
 673
 674 } // namespace folly