fizz::tool Namespace Reference

Classes
struct	FizzCommandArgHandlerInfo
class	InputHandlerCallback
class	TerminalInputHandler

Typedefs
typedef std::function< void(const std::string &)>	FizzCommandArgHandler
typedef std::map< std::string, FizzCommandArgHandlerInfo >	FizzArgHandlerMap

Functions
int	fizzClientCommand (const std::vector< std::string > &args)
int	fizzServerCommand (const std::vector< std::string > &args)
int	parseArguments (std::vector< std::string > argv, FizzArgHandlerMap handlers, std::function< void()> usageFunc)
uint16_t	portFromString (const std::string &portStr, bool serverSide)

Variables
const std::map< std::string, std::function< int(const std::vector< std::string > &)> >	fizzUtilities

Typedef Documentation

typedef std::map<std::string, FizzCommandArgHandlerInfo> fizz::tool::FizzArgHandlerMap

Definition at line 53 of file FizzCommandCommon.h.

typedef std::function<void(const std::string&)> fizz::tool::FizzCommandArgHandler

Definition at line 48 of file FizzCommandCommon.h.

Function Documentation

int fizz::tool::fizzClientCommand

(

const std::vector< std::string > &

args

)

Definition at line 230 of file FizzClientCommand.cpp.

References addr, fizz::Client, folly::Range< Iter >::empty(), folly::EventBase::loop(), fizz::CertUtils::makeSelfCert(), folly::gen::move, parseArguments(), portFromString(), folly::readFile(), sni, string, fizz::tls_1_3, fizz::tls_1_3_28, uint16_t, and verify().

                                                        {
  std::string host = "localhost";
  uint16_t port = 4433;
  bool verify = false;
  std::string certPath;
  std::string keyPath;
  std::string keyPass;
  std::string caPath;
  std::string caFile;
  bool reconnect = false;
  std::string customSNI;
  std::vector<std::string> alpns;
  bool early = false;

  // clang-format off
  FizzArgHandlerMap handlers = {
    {"-host", {true, [&host](const std::string& arg) { host = arg; }}},
    {"-port", {true, [&port](const std::string& arg) {
        port = portFromString(arg, false);
    }}},
    {"-connect", {true, [&host, &port](const std::string& arg) {
        size_t colonIdx = arg.find(':');
        if (colonIdx == std::string::npos) {
          throw std::runtime_error("-connect requires a host:port pair.");
        }
        host = arg.substr(0, colonIdx);
        port = portFromString(arg.substr(colonIdx+1), false);
     }}},
    {"-verify", {false, [&verify](const std::string&) { verify = true; }}},
    {"-cert", {true, [&certPath](const std::string& arg) { certPath = arg; }}},
    {"-key", {true, [&keyPath](const std::string& arg) { keyPath = arg; }}},
    {"-pass", {true, [&keyPass](const std::string& arg) { keyPass = arg; }}},
    {"-capath", {true, [&caPath](const std::string& arg) { caPath = arg; }}},
    {"-cafile", {true, [&caFile](const std::string& arg) { caFile = arg; }}},
    {"-reconnect", {false, [&reconnect](const std::string&) {
        reconnect = true;
    }}},
    {"-servername", {true, [&customSNI](const std::string& arg) {
        customSNI = arg;
    }}},
    {"-alpn", {true, [&alpns](const std::string& arg) {
        alpns.clear();
        auto remainder = arg;
        for (auto commaPos = remainder.find(',');
             commaPos != std::string::npos;
             commaPos = remainder.find(',')) {
          alpns.push_back(remainder.substr(0, commaPos));
          remainder = remainder.substr(commaPos+1);
        }

        alpns.push_back(remainder);
    }}},
    {"-early", {false, [&early](const std::string&) { early = true; }}},
    {"-quiet", {false, [](const std::string&) {
        FLAGS_minloglevel = google::GLOG_ERROR;
    }}}
  };
  // clang-format on

  try {
    if (parseArguments(args, handlers, printUsage)) {
      // Parsing failed, return
      return 1;
    }
  } catch (const std::exception& e) {
    LOG(ERROR) << "Error: " << e.what();
    return 1;
  }

  // Sanity check input.
  if (certPath.empty() != keyPath.empty()) {
    LOG(ERROR) << "-cert and -key are both required when specified";
    return 1;
  }

  EventBase evb;
  std::shared_ptr<const CertificateVerifier> verifier;
  auto clientContext = std::make_shared<FizzClientContext>();

  if (!alpns.empty()) {
    clientContext->setSupportedAlpns(std::move(alpns));
  }

  clientContext->setSupportedVersions(
      {ProtocolVersion::tls_1_3, ProtocolVersion::tls_1_3_28});
  clientContext->setSendEarlyData(early);

  if (verify) {
    // Initialize CA store first, if given.
    folly::ssl::X509StoreUniquePtr storePtr;
    if (!caPath.empty() || !caFile.empty()) {
      storePtr.reset(X509_STORE_new());
      auto caFilePtr = caFile.empty() ? nullptr : caFile.c_str();
      auto caPathPtr = caPath.empty() ? nullptr : caPath.c_str();

      if (X509_STORE_load_locations(storePtr.get(), caFilePtr, caPathPtr) ==
          0) {
        LOG(ERROR) << "Failed to load CA certificates";
        return 1;
      }
    }

    verifier = std::make_shared<const DefaultCertificateVerifier>(
        VerificationContext::Client, std::move(storePtr));
  }

  if (!certPath.empty()) {
    std::string certData;
    std::string keyData;
    if (!readFile(certPath.c_str(), certData)) {
      LOG(ERROR) << "Failed to read certificate";
      return 1;
    } else if (!readFile(keyPath.c_str(), keyData)) {
      LOG(ERROR) << "Failed to read private key";
      return 1;
    }

    std::unique_ptr<SelfCert> cert;
    if (!keyPass.empty()) {
      cert = CertUtils::makeSelfCert(certData, keyData, keyPass);
    } else {
      cert = CertUtils::makeSelfCert(certData, keyData);
    }
    clientContext->setClientCertificate(std::move(cert));
  }

  try {
    SocketAddress addr(host, port, true);
    auto sni = customSNI.empty() ? host : customSNI;
    Connection conn(&evb, clientContext, sni, verifier, reconnect);
    Connection resumptionConn(&evb, clientContext, sni, verifier, false);
    Connection* inputTarget = &conn;
    if (reconnect) {
      auto pskCache = std::make_shared<ResumptionPskCache>(
          &evb, [&conn, &resumptionConn, addr]() {
            conn.close();
            resumptionConn.connect(addr);
          });
      clientContext->setPskCache(pskCache);
      inputTarget = &resumptionConn;
    }
    TerminalInputHandler input(&evb, inputTarget);
    conn.connect(addr);
    evb.loop();
  } catch (const std::exception& e) {
    LOG(ERROR) << "Error: " << e.what();
    return 1;
  }

  return 0;
}

int fizz::tool::fizzServerCommand

(

const std::vector< std::string > &

args

)

Definition at line 277 of file FizzServerCommand.cpp.

References cipher, fizz::test::createCert(), loop(), folly::EventBase::loop(), fizz::CertUtils::makeSelfCert(), folly::gen::move, fizz::server::None, fizz::server::Optional, parseArguments(), portFromString(), folly::gen::range(), folly::readFile(), fizz::server::Required, fizz::Server, string, fizz::tls_1_3, fizz::tls_1_3_28, and uint16_t.

                                                        {
  uint16_t port = 8443;
  Optional<std::vector<CipherSuite>> ciphers;
  std::string certPath;
  std::string keyPath;
  std::string keyPass;
  ClientAuthMode clientAuthMode = ClientAuthMode::None;
  std::string caPaths;
  std::string caFile;
  bool early = false;
  std::vector<std::string> alpns;
  bool loop = false;
  bool fallback = false;

  // clang-format off
  FizzArgHandlerMap handlers = {
    {"-accept", {true, [&port](const std::string& arg) {
        port = portFromString(arg, true);
    }}},
    {"-ciphers", {true, [&ciphers](const std::string& arg) {
        std::vector<CipherSuite> newCiphers;
        auto remainder = arg;
        try {
          for (auto commaPos = remainder.find(',');
               commaPos != std::string::npos;
               commaPos = remainder.find(',')) {
            auto cipher = parse<CipherSuite>(remainder.substr(0, commaPos));
            remainder = remainder.substr(commaPos+1);
            newCiphers.push_back(cipher);
          }

          newCiphers.push_back(parse<CipherSuite>(remainder));
          ciphers = std::move(newCiphers);
        }
        catch (const std::exception& e) {
          LOG(ERROR) << "Error parsing cipher suites: " << e.what();
        }
    }}},
    {"-cert", {true, [&certPath](const std::string& arg) { certPath = arg; }}},
    {"-key", {true, [&keyPath](const std::string& arg) { keyPath = arg; }}},
    {"-pass", {true, [&keyPass](const std::string& arg) { keyPass = arg; }}},
    {"-requestcert", {false, [&clientAuthMode](const std::string&) {
      clientAuthMode = ClientAuthMode::Optional;
    }}},
    {"-requirecert", {false, [&clientAuthMode](const std::string&) {
      clientAuthMode = ClientAuthMode::Required;
    }}},
    {"-capaths", {true, [&caPaths](const std::string& arg) { caPaths = arg; }}},
    {"-cafile", {true, [&caFile](const std::string& arg) { caFile = arg; }}},
    {"-early", {false, [&early](const std::string&) { early = true; }}},
    {"-alpn", {true, [&alpns](const std::string& arg) {
        alpns.clear();
        auto remainder = arg;
        for (auto commaPos = remainder.find(',');
             commaPos != std::string::npos;
             commaPos = remainder.find(',')) {
          alpns.push_back(remainder.substr(0, commaPos));
          remainder = remainder.substr(commaPos+1);
        }

        alpns.push_back(remainder);
    }}},
    {"-loop", {false, [&loop](const std::string&) { loop = true; }}},
    {"-quiet", {false, [](const std::string&) {
        FLAGS_minloglevel = google::GLOG_ERROR;
    }}},
    {"-fallback", {false, [&fallback](const std::string&) {
        fallback = true;
    }}}
  };
  // clang-format on

  try {
    if (parseArguments(args, handlers, printUsage)) {
      // Parsing failed, return
      return 1;
    }
  } catch (const std::exception& e) {
    LOG(ERROR) << "Error: " << e.what();
    return 1;
  }

  // Sanity check input.
  if (certPath.empty() != keyPath.empty()) {
    LOG(ERROR) << "-cert and -key are both required when specified";
    return 1;
  }

  EventBase evb;
  std::shared_ptr<const CertificateVerifier> verifier;

  if (clientAuthMode != ClientAuthMode::None) {
    // Initialize CA store first, if given.
    folly::ssl::X509StoreUniquePtr storePtr;
    if (!caPaths.empty() || !caFile.empty()) {
      storePtr.reset(X509_STORE_new());
      auto caFilePtr = caFile.empty() ? nullptr : caFile.c_str();
      auto caPathPtr = caPaths.empty() ? nullptr : caPaths.c_str();

      if (X509_STORE_load_locations(storePtr.get(), caFilePtr, caPathPtr) ==
          0) {
        LOG(ERROR) << "Failed to load CA certificates";
        return 1;
      }
    }

    verifier = std::make_shared<const DefaultCertificateVerifier>(
        VerificationContext::Server, std::move(storePtr));
  }

  auto serverContext = std::make_shared<FizzServerContext>();
  if (ciphers) {
    serverContext->setSupportedCiphers({*ciphers});
  }
  serverContext->setClientAuthMode(clientAuthMode);
  serverContext->setClientCertVerifier(verifier);

  auto ticketCipher = std::make_shared<AeadTicketCipher<
      OpenSSLEVPCipher<AESGCM128>,
      TicketCodec<CertificateStorage::X509>,
      HkdfImpl<Sha256>>>();
  auto ticketSeed = RandomGenerator<32>().generateRandom();
  ticketCipher->setTicketSecrets({{range(ticketSeed)}});
  serverContext->setTicketCipher(ticketCipher);

  auto certManager = std::make_unique<CertManager>();
  if (!certPath.empty()) {
    std::string certData;
    std::string keyData;
    if (!readFile(certPath.c_str(), certData)) {
      LOG(ERROR) << "Failed to read certificate";
      return 1;
    } else if (!readFile(keyPath.c_str(), keyData)) {
      LOG(ERROR) << "Failed to read private key";
      return 1;
    }
    std::unique_ptr<SelfCert> cert;
    if (!keyPass.empty()) {
      cert = CertUtils::makeSelfCert(certData, keyData, keyPass);
    } else {
      cert = CertUtils::makeSelfCert(certData, keyData);
    }
    certManager->addCert(std::move(cert), true);
  } else {
    auto certData = fizz::test::createCert("fizz-self-signed", false, nullptr);
    std::vector<folly::ssl::X509UniquePtr> certChain;
    certChain.push_back(std::move(certData.cert));
    auto cert = std::make_unique<SelfCertImpl<KeyType::P256>>(
        std::move(certData.key), std::move(certChain));
    certManager->addCert(std::move(cert), true);
  }
  serverContext->setCertManager(std::move(certManager));

  if (early) {
    serverContext->setEarlyDataSettings(
        true,
        {std::chrono::seconds(-10), std::chrono::seconds(10)},
        std::make_shared<SlidingBloomReplayCache>(240, 140000, 0.0005, &evb));
  }

  std::shared_ptr<SSLContext> sslContext;
  if (fallback) {
    if (certPath.empty()) {
      LOG(ERROR) << "Fallback mode requires explicit certificates";
      return 1;
    }
    sslContext = std::make_shared<SSLContext>();
    sslContext->loadCertKeyPairFromFiles(certPath.c_str(), keyPath.c_str());
    SSL_CTX_set_ecdh_auto(sslContext->getSSLCtx(), 1);
  }
  serverContext->setVersionFallbackEnabled(fallback);

  if (!alpns.empty()) {
    serverContext->setSupportedAlpns(std::move(alpns));
  }

  serverContext->setSupportedVersions(
      {ProtocolVersion::tls_1_3, ProtocolVersion::tls_1_3_28});
  FizzServerAcceptor acceptor(port, serverContext, loop, &evb, sslContext);
  evb.loop();
  return 0;
}

int fizz::tool::parseArguments	(	std::vector< std::string >	argv,
		FizzArgHandlerMap	handlers,
		std::function< void()>	usageFunc
	)

Definition at line 17 of file FizzCommandCommon.cpp.

References string.

Referenced by fizzClientCommand(), and fizzServerCommand().

                                   {
  for (size_t idx = 2; idx < argv.size(); idx++) {
    auto& argument = argv[idx];
    auto handlerIter = handlers.find(argument);

    if (handlerIter != handlers.end()) {
      auto& handlerInfo = handlerIter->second;
      std::string variable;
      if (handlerInfo.hasVariable) {
        if (idx + 1 >= argv.size()) {
          std::cerr << "Argument " << argument << " requires an parameter."
                    << std::endl;
          usageFunc();
          return 1;
        } else {
          idx++;
          variable = argv[idx];
        }
      }
      handlerInfo.handler(variable);
    } else {
      std::cerr << "Unknown argument: " << argument << std::endl;
      usageFunc();
      return 1;
    }
  }
  return 0;
}

uint16_t fizz::tool::portFromString ( const std::string &  portStr, bool  serverSide  )

inline

Definition at line 27 of file FizzCommandCommon.h.

References max, and uint16_t.

Referenced by fizzClientCommand(), and fizzServerCommand().

                                                                          {
  unsigned long converted = 0;
  try {
    converted = std::stoul(portStr);
  } catch (const std::exception&) {
    throw std::runtime_error(
        "Couldn't convert " + portStr + " to port number.");
  }
  if (converted <= std::numeric_limits<uint16_t>::max()) {
    if (converted == 0 && !serverSide) {
      throw std::runtime_error("Port 0 is not valid for client ports.");
    }
    return static_cast<uint16_t>(converted);
  } else {
    throw std::runtime_error(
        "Couldn't convert " + portStr + " to port number.");
  }
}

Variable Documentation

const std::map<std::string, std::function<int(const std::vector<std::string>&)> > fizz::tool::fizzUtilities

Initial value:

= {{"client", &fizzClientCommand},
                     {"s_client", &fizzClientCommand},
                     {"server", &fizzServerCommand},
                     {"s_server", &fizzServerCommand}}

Definition at line 23 of file Commands.h.

Referenced by main(), and showUsage().