fizz::FizzUtil Class Reference

#include <FizzUtil.h>

Static Public Member Functions
static std::vector< folly::ssl::X509UniquePtr >	readChainFile (const std::string &filename)
static folly::ssl::EvpPkeyUniquePtr	readPrivateKey (const std::string &filename, const std::string &passwordFilename)
static std::vector< std::string >	getAlpnsFromNpnList (const std::list< folly::SSLContext::NextProtocolsItem > &list)
static folly::ssl::EvpPkeyUniquePtr	decryptPrivateKey (const std::string &data, folly::PasswordInFile *pf)
template<class TicketCipher >
static std::unique_ptr< TicketCipher >	createTicketCipher (const std::vector< std::string > &oldSecrets, const std::string &currentSecret, const std::vector< std::string > &newSecrets, std::chrono::seconds validity, folly::Optional< std::string > pskContext)

Detailed Description

Definition at line 22 of file FizzUtil.h.

Member Function Documentation

template<class TicketCipher >

static std::unique_ptr<TicketCipher> fizz::FizzUtil::createTicketCipher ( const std::vector< std::string > &  oldSecrets, const std::string &  currentSecret, const std::vector< std::string > &  newSecrets, std::chrono::seconds  validity, folly::Optional< std::string >  pskContext  )

inlinestatic

Definition at line 43 of file FizzUtil.h.

References cipher, folly::Optional< Value >::hasValue(), folly::gen::move, and secret.

                                           {
    std::vector<folly::ByteRange> ticketSecrets;
    if (!currentSecret.empty()) {
      ticketSecrets.push_back(folly::StringPiece(currentSecret));
    }
    for (const auto& secret : oldSecrets) {
      ticketSecrets.push_back(folly::StringPiece(secret));
    }
    for (const auto& secret : newSecrets) {
      ticketSecrets.push_back(folly::StringPiece(secret));
    }
    std::unique_ptr<TicketCipher> cipher;
    if (pskContext.hasValue()) {
      cipher = std::make_unique<TicketCipher>(std::move(*pskContext));
    } else {
      cipher = std::make_unique<TicketCipher>();
    }
    cipher->setTicketSecrets(std::move(ticketSecrets));
    cipher->setValidity(validity);
    return cipher;
  }

folly::ssl::EvpPkeyUniquePtr fizz::FizzUtil::decryptPrivateKey ( const std::string &  data, folly::PasswordInFile *  pf  )

static

Definition at line 73 of file FizzUtil.cpp.

References fizz::passwordCallback().

Referenced by readPrivateKey().

                             {
  folly::ssl::BioUniquePtr keyBio(BIO_new_mem_buf(data.data(), data.size()));
  if (!keyBio) {
    throw std::runtime_error("couldn't create bio");
  }

  folly::ssl::EvpPkeyUniquePtr pkey;
  if (pf) {
    pkey.reset(
        PEM_read_bio_PrivateKey(keyBio.get(), nullptr, passwordCallback, pf));
  } else {
    pkey.reset(
        PEM_read_bio_PrivateKey(keyBio.get(), nullptr, nullptr, nullptr));
  }

  if (!pkey) {
    throw std::runtime_error("couldn't read private key");
  }

  return pkey;
}

std::vector< std::string > fizz::FizzUtil::getAlpnsFromNpnList ( const std::list< folly::SSLContext::NextProtocolsItem > &  list )

static

Definition at line 97 of file FizzUtil.cpp.

                                                           {
  CHECK(!list.empty());
  auto maxWeight = list.front().weight;
  auto protoList = &list.front().protocols;
  for (const auto& item : list) {
    if (item.weight > maxWeight) {
      protoList = &item.protocols;
    }
  }
  return std::vector<std::string>(protoList->begin(), protoList->end());
}

std::vector< folly::ssl::X509UniquePtr > fizz::FizzUtil::readChainFile ( const std::string &  filename )

static

Definition at line 36 of file FizzUtil.cpp.

References folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(), folly::readFile(), and string.

                               {
  std::string certData;
  if (!folly::readFile(filename.c_str(), certData)) {
    throw std::runtime_error(
        folly::to<std::string>("couldn't read cert file: ", filename));
  }
  auto certRange = folly::ByteRange(folly::StringPiece(certData));
  auto certs = folly::ssl::OpenSSLCertUtils::readCertsFromBuffer(certRange);
  if (certs.empty()) {
    throw std::runtime_error(
        folly::to<std::string>("couldn't read any cert from: ", filename));
  }
  return certs;
}

folly::ssl::EvpPkeyUniquePtr fizz::FizzUtil::readPrivateKey ( const std::string &  filename, const std::string &  passwordFilename  )

static

Definition at line 52 of file FizzUtil.cpp.

References data, decryptPrivateKey(), folly::readFile(), folly::sformat(), and string.

                                       {
  std::string data;
  folly::readFile(filename.c_str(), data);
  try {
    if (!passwordFilename.empty()) {
      folly::PasswordInFile pf(passwordFilename);
      return FizzUtil::decryptPrivateKey(data, &pf);
    } else {
      return FizzUtil::decryptPrivateKey(data, nullptr);
    }
  } catch (std::runtime_error& e) {
    auto ex = folly::sformat(
        "Failed to read private key from file: {}, password file: {}",
        filename,
        passwordFilename);
    std::throw_with_nested(std::runtime_error(ex));
  }
}

---

The documentation for this class was generated from the following files:

• proxygen/fizz/fizz/util/FizzUtil.h
• proxygen/fizz/fizz/util/FizzUtil.cpp