BogoShim.cpp File Reference

#include <fizz/client/AsyncFizzClient.h>
#include <fizz/crypto/Utils.h>
#include <fizz/crypto/aead/AESGCM128.h>
#include <fizz/crypto/aead/OpenSSLEVPCipher.h>
#include <fizz/server/AsyncFizzServer.h>
#include <fizz/server/TicketTypes.h>
#include <folly/String.h>
#include <folly/io/async/AsyncSSLSocket.h>
#include <folly/io/async/SSLContext.h>
#include <folly/portability/GFlags.h>

Go to the source code of this file.

Classes
class	BogoTestServer
class	BogoTestClient
class	TestRsaCert
class	TestP256Cert

Functions
	DEFINE_int32 (port, 0,"port to connect to")
	DEFINE_bool (server, false,"act as a server, otherwise act as a client")
	DEFINE_string (key_file,"","key file")
	DEFINE_string (cert_file,"","cert file")
	DEFINE_int32 (resume_count, 0,"number of additional connections to open")
std::unique_ptr< SelfCert >	readSelfCert ()
int	serverTest ()
int	clientTest ()
int	main (int argc, char **argv)

Variables
static constexpr int	kUnimplemented = 89
static std::vector< std::string >	kKnownFlags

Function Documentation

int clientTest

(

)

Definition at line 335 of file BogoShim.cpp.

References folly::INFO, kUnimplemented, and readSelfCert().

Referenced by main().

                 {
  auto clientContext = std::make_shared<FizzClientContext>();
  clientContext->setCompatibilityMode(true);

  if (!FLAGS_cert_file.empty()) {
    clientContext->setClientCertificate(readSelfCert());
  }

  EventBase evb;
  if (FLAGS_resume_count >= 1) {
    return kUnimplemented;
  }
  auto client =
      std::make_unique<BogoTestClient>(&evb, FLAGS_port, clientContext);
  evb.loop();
  if (client->unimplemented()) {
    LOG(INFO) << "Testing unimplemented feature.";
    return kUnimplemented;
  }
  if (!client->success()) {
    LOG(INFO) << "Connection failed.";
    return 1;
  }

  return 0;
}

DEFINE_bool	(	server	,
		false	,
		"act as a	server,
		otherwise act as a client"
	)

DEFINE_int32	(	port	,
		0	,
		"port to connect to"
	)

DEFINE_int32	(	resume_count	,
		0	,
		"number of additional connections to open"
	)

DEFINE_string	(	key_file	,
		""	,
		"key file"
	)

DEFINE_string	(	cert_file	,
		""	,
		"cert file"
	)

int main	(	int	argc,
		char **	argv
	)

Definition at line 362 of file BogoShim.cpp.

References clientTest(), i, folly::INFO, fizz::CryptoUtils::init(), kKnownFlags, kUnimplemented, serverTest(), and string.

                                {
  // Convert "-" in args to "_" so that we can use GFLAGS.
  for (int i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      for (char* j = argv[i] + 2; *j; j++) {
        if (*j == '-') {
          *j = '_';
        }
      }
      if (std::find(
              kKnownFlags.begin(),
              kKnownFlags.end(),
              std::string(argv[i] + 1)) == kKnownFlags.end()) {
        LOG(INFO) << "unknown flag: " << argv[i];
        return kUnimplemented;
      }
    }
  }

  gflags::ParseCommandLineFlags(&argc, &argv, true);
  google::InitGoogleLogging(argv[0]);
  CryptoUtils::init();

  if (FLAGS_port == 0) {
    throw std::runtime_error("must specify port");
  }

  if (FLAGS_server) {
    return serverTest();
  } else {
    return clientTest();
  }
}

std::unique_ptr<SelfCert> readSelfCert

(

)

Definition at line 266 of file BogoShim.cpp.

References b, and folly::gen::move.

Referenced by clientTest(), and serverTest().

                                       {
  BioUniquePtr b(BIO_new(BIO_s_file()));
  BIO_read_filename(b.get(), FLAGS_cert_file.c_str());
  std::vector<X509UniquePtr> certs;
  while (true) {
    X509UniquePtr x509(PEM_read_bio_X509(b.get(), nullptr, nullptr, nullptr));
    if (!x509) {
      break;
    } else {
      certs.push_back(std::move(x509));
    }
  }
  if (certs.empty()) {
    throw std::runtime_error("could not read cert");
  }

  b.reset(BIO_new(BIO_s_file()));
  BIO_read_filename(b.get(), FLAGS_key_file.c_str());
  EvpPkeyUniquePtr key(
      PEM_read_bio_PrivateKey(b.get(), nullptr, nullptr, nullptr));

  std::unique_ptr<SelfCert> cert;
  if (EVP_PKEY_id(key.get()) == EVP_PKEY_RSA) {
    return std::make_unique<TestRsaCert>(std::move(key), std::move(certs));
  } else if (EVP_PKEY_id(key.get()) == EVP_PKEY_EC) {
    return std::make_unique<TestP256Cert>(std::move(key), std::move(certs));
  } else {
    throw std::runtime_error("unknown cert type");
  }
}

int serverTest

(

)

Definition at line 297 of file BogoShim.cpp.

References i, folly::INFO, kUnimplemented, folly::EventBase::loop(), folly::gen::move, folly::gen::range(), and readSelfCert().

Referenced by main().

                 {
  auto certManager = std::make_unique<CertManager>();
  certManager->addCert(readSelfCert(), true);

  auto ticketCipher = std::make_shared<AES128TicketCipher>();
  auto ticketSeed = RandomGenerator<32>().generateRandom();
  ticketCipher->setTicketSecrets({{range(ticketSeed)}});
  ticketCipher->setValidity(std::chrono::seconds(60));

  auto serverContext = std::make_shared<FizzServerContext>();
  serverContext->setCertManager(std::move(certManager));
  serverContext->setTicketCipher(ticketCipher);
  serverContext->setSupportedAlpns({"h2", "http/1.1"});
  serverContext->setVersionFallbackEnabled(true);

  EventBase evb;
  std::vector<std::unique_ptr<BogoTestServer>> servers;
  for (size_t i = 0; i <= size_t(FLAGS_resume_count); i++) {
    servers.push_back(std::make_unique<BogoTestServer>(
        &evb, FLAGS_port, serverContext, nullptr));
  }
  evb.loop();
  for (const auto& server : servers) {
    if (server->unimplemented()) {
      LOG(INFO) << "Testing unimplemented feature.";
      return kUnimplemented;
    }
  }
  for (const auto& server : servers) {
    if (!server->success()) {
      LOG(INFO) << "Connection failed.";
      return 1;
    }
  }

  return 0;
}

Variable Documentation

std::vector<std::string> kKnownFlags

static

Initial value:

{"port",
                                            "server",
                                            "key_file",
                                            "cert_file",
                                            "resume_count"}

Definition at line 34 of file BogoShim.cpp.

Referenced by main().

constexpr int kUnimplemented = 89

static

Definition at line 32 of file BogoShim.cpp.

Referenced by clientTest(), main(), and serverTest().