fizz::test::HandshakeTest Class Reference

Inheritance diagram for fizz::test::HandshakeTest:

Public Member Functions
void	SetUp () override
void	resetTransports ()
void	resetTransportsAndStartCookieHandshake ()
void	resetTransportsAndDoCookieHandshake ()
void	doHandshake ()
void	doClientHandshake ()
void	doServerHandshake ()
void	expectClientSuccess ()
void	expectServerSuccess ()
void	expectSuccess ()
void	expectError (const std::string &clientStr, const std::string &serverStr)
void	expectServerError (const std::string &clientError, const std::string &serverError)
void	clientWrite (StringPiece write)
void	serverWrite (StringPiece write)
void	expectClientRead (StringPiece read)
void	expectServerRead (StringPiece read)
void	expectEarlyDataRejectError ()
void	expectReplaySafety ()
void	sendAppData ()
void	verifyEarlyParameters ()
void	verifyParameters ()
void	setupResume ()
void	setupResumeWithHRR ()
Public Member Functions inherited from testing::Test
virtual	~Test ()
virtual	~Test ()
virtual	~Test ()

Static Public Member Functions
static bool	certsMatch (const std::shared_ptr< const Cert > &a, const std::shared_ptr< const Cert > &b)
Static Public Member Functions inherited from testing::Test
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)
static void	SetUpTestCase ()
static void	TearDownTestCase ()
static bool	HasFatalFailure ()
static bool	HasNonfatalFailure ()
static bool	HasFailure ()
static void	RecordProperty (const std::string &key, const std::string &value)
static void	RecordProperty (const std::string &key, int value)

Protected Attributes
EventBase	evb_
std::shared_ptr< FizzClientContext >	clientContext_
std::shared_ptr< FizzServerContext >	serverContext_
AsyncFizzClient::UniquePtr	client_
AsyncFizzServer::UniquePtr	server_
std::shared_ptr< AES128CookieCipher >	cookieCipher_
fizz::client::test::MockHandshakeCallback	clientCallback_
fizz::server::test::MockHandshakeCallback	serverCallback_
folly::test::MockReadCallback	readCallback_
std::shared_ptr< fizz::ClientExtensions >	clientExtensions_
std::shared_ptr< fizz::ServerExtensions >	serverExtensions_
LocalTransport *	clientTransport_
LocalTransport *	serverTransport_
MockReadCallback	clientRead_
MockReadCallback	serverRead_
MockReplaySafetyCallback	replayCallback_
ExpectedParameters	expected_

Additional Inherited Members
Public Types inherited from testing::Test
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
typedef internal::SetUpTestCaseFunc	SetUpTestCaseFunc
typedef internal::TearDownTestCaseFunc	TearDownTestCaseFunc
Protected Member Functions inherited from testing::Test
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()
	Test ()
virtual void	TearDown ()

Detailed Description

Definition at line 56 of file HandshakeTest.cpp.

Member Function Documentation

static bool fizz::test::HandshakeTest::certsMatch ( const std::shared_ptr< const Cert > &  a, const std::shared_ptr< const Cert > &  b  )

inlinestatic

Definition at line 287 of file HandshakeTest.cpp.

References b.

                                          {
    if (!a || !b) {
      return a == b;
    } else {
      return a->getIdentity() == b->getIdentity();
    }
  }

void fizz::test::HandshakeTest::clientWrite ( StringPiece  write )

inline

Definition at line 253 of file HandshakeTest.cpp.

References folly::IOBuf::copyBuffer().

                                      {
    client_->writeChain(nullptr, IOBuf::copyBuffer(write));
  }

void fizz::test::HandshakeTest::doClientHandshake ( )

inline

Definition at line 188 of file HandshakeTest.cpp.

References evb_, folly::EventBase::loop(), folly::none, and string.

                           {
    client_->connect(
        &clientCallback_, nullptr, folly::none, std::string("Fizz"));
    evb_.loop();
  }

void fizz::test::HandshakeTest::doHandshake ( )

inline

Definition at line 181 of file HandshakeTest.cpp.

References evb_, folly::EventBase::loop(), folly::none, and string.

                     {
    client_->connect(
        &clientCallback_, nullptr, folly::none, std::string("Fizz"));
    server_->accept(&serverCallback_);
    evb_.loop();
  }

void fizz::test::HandshakeTest::doServerHandshake ( )

inline

Definition at line 194 of file HandshakeTest.cpp.

References evb_, and folly::EventBase::loop().

                           {
    server_->accept(&serverCallback_);
    evb_.loop();
  }

void fizz::test::HandshakeTest::expectClientRead ( StringPiece  read )

inline

Definition at line 261 of file HandshakeTest.cpp.

References EXPECT_CALL.

                                          {
    EXPECT_CALL(clientRead_, readBufferAvailable_(BufMatches(read)));
  }

void fizz::test::HandshakeTest::expectClientSuccess ( )

inline

Definition at line 199 of file HandshakeTest.cpp.

References testing::_, EXPECT_CALL, FAIL, testing::Invoke(), ON_CALL, folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                             {
    EXPECT_CALL(clientCallback_, _fizzHandshakeSuccess())
        .WillOnce(Invoke([this]() {
          client_->setReadCB(&clientRead_);
          if (!client_->isReplaySafe()) {
            client_->setReplaySafetyCallback(&replayCallback_);
          }
        }));
    ON_CALL(clientCallback_, _fizzHandshakeError(_))
        .WillByDefault(Invoke([](folly::exception_wrapper ex) {
          FAIL() << "Client Error: " << ex.what().toStdString();
        }));
  }

void fizz::test::HandshakeTest::expectEarlyDataRejectError ( )

inline

Definition at line 269 of file HandshakeTest.cpp.

References testing::_, folly::AsyncSocketException::EARLY_DATA_REJECTED, EXPECT_CALL, EXPECT_EQ, folly::AsyncSocketException::getType(), and testing::Invoke().

                                    {
    EXPECT_CALL(clientRead_, readErr_(_))
        .WillOnce(Invoke([](const AsyncSocketException& ex) {
          EXPECT_EQ(ex.getType(), AsyncSocketException::EARLY_DATA_REJECTED);
        }));
  }

void fizz::test::HandshakeTest::expectError ( const std::string &  clientStr, const std::string &  serverStr  )

inline

Definition at line 227 of file HandshakeTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_THAT, testing::HasSubstr(), testing::Invoke(), folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                                                                           {
    EXPECT_CALL(clientCallback_, _fizzHandshakeError(_))
        .WillOnce(Invoke([clientStr](folly::exception_wrapper ex) {
          EXPECT_THAT(ex.what().toStdString(), HasSubstr(clientStr));
        }));
    EXPECT_CALL(serverCallback_, _fizzHandshakeError(_))
        .WillOnce(Invoke([serverStr](folly::exception_wrapper ex) {
          EXPECT_THAT(ex.what().toStdString(), HasSubstr(serverStr));
        }));
  }

void fizz::test::HandshakeTest::expectReplaySafety ( )

inline

Definition at line 276 of file HandshakeTest.cpp.

References EXPECT_CALL.

                            {
    EXPECT_CALL(replayCallback_, onReplaySafe_());
  }

void fizz::test::HandshakeTest::expectServerError ( const std::string &  clientError, const std::string &  serverError  )

inline

Definition at line 238 of file HandshakeTest.cpp.

References testing::_, EXPECT_CALL, EXPECT_THAT, testing::HasSubstr(), testing::Invoke(), string, folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                                    {
    EXPECT_CALL(clientCallback_, _fizzHandshakeSuccess());
    client_->setReadCB(&readCallback_);
    EXPECT_CALL(readCallback_, readErr_(_))
        .WillOnce(Invoke([clientError](const AsyncSocketException& ex) {
          EXPECT_THAT(std::string(ex.what()), HasSubstr(clientError));
        }));
    EXPECT_CALL(serverCallback_, _fizzHandshakeError(_))
        .WillOnce(Invoke([serverError](folly::exception_wrapper ex) {
          EXPECT_THAT(ex.what().toStdString(), HasSubstr(serverError));
        }));
  }

void fizz::test::HandshakeTest::expectServerRead ( StringPiece  read )

inline

Definition at line 265 of file HandshakeTest.cpp.

References EXPECT_CALL.

                                          {
    EXPECT_CALL(serverRead_, readBufferAvailable_(BufMatches(read)));
  }

void fizz::test::HandshakeTest::expectServerSuccess ( )

inline

Definition at line 213 of file HandshakeTest.cpp.

References testing::_, EXPECT_CALL, FAIL, testing::Invoke(), ON_CALL, folly::basic_fbstring< E, T, A, Storage >::toStdString(), and folly::exception_wrapper::what().

                             {
    EXPECT_CALL(serverCallback_, _fizzHandshakeSuccess())
        .WillOnce(Invoke([this]() { server_->setReadCB(&serverRead_); }));
    ON_CALL(serverCallback_, _fizzHandshakeError(_))
        .WillByDefault(Invoke([](folly::exception_wrapper ex) {
          FAIL() << "Server Error: " << ex.what().toStdString();
        }));
  }

void fizz::test::HandshakeTest::expectSuccess ( )

inline

Definition at line 222 of file HandshakeTest.cpp.

                       {
    expectClientSuccess();
    expectServerSuccess();
  }

void fizz::test::HandshakeTest::resetTransports ( )

inline

Definition at line 126 of file HandshakeTest.cpp.

References clientContext_, evb_, and folly::gen::move.

                         {
    clientTransport_ = new LocalTransport();
    auto client = LocalTransport::UniquePtr(clientTransport_);
    serverTransport_ = new LocalTransport();
    auto server = LocalTransport::UniquePtr(serverTransport_);
    client->attachEventBase(&evb_);
    server->attachEventBase(&evb_);
    client->setPeer(server.get());
    server->setPeer(client.get());

    client_.reset(new AsyncFizzClient(
        std::move(client), clientContext_, clientExtensions_));
    server_.reset(new AsyncFizzServer(
        std::move(server), serverContext_, serverExtensions_));
  }

void fizz::test::HandshakeTest::resetTransportsAndDoCookieHandshake ( )

inline

Definition at line 176 of file HandshakeTest.cpp.

                                             {
    resetTransportsAndStartCookieHandshake();
    doServerHandshake();
  }

void fizz::test::HandshakeTest::resetTransportsAndStartCookieHandshake ( )

inline

Definition at line 142 of file HandshakeTest.cpp.

References testing::_, clientContext_, folly::IOBuf::copyBuffer(), folly::Range< Iter >::data(), evb_, EXPECT_CALL, EXPECT_EQ, testing::Invoke(), folly::gen::move, ON_CALL, fizz::detail::readBuf(), retry, and testing::Return().

                                                {
    clientTransport_ = new LocalTransport();
    auto client = LocalTransport::UniquePtr(clientTransport_);
    serverTransport_ = new LocalTransport();
    auto server = LocalTransport::UniquePtr(serverTransport_);
    client->attachEventBase(&evb_);
    server->attachEventBase(&evb_);
    client->setPeer(server.get());
    server->setPeer(client.get());

    client_.reset(new AsyncFizzClient(
        std::move(client), clientContext_, clientExtensions_));

    folly::test::MockReadCallback serverRawRead;
    ON_CALL(serverRawRead, isBufferMovable_()).WillByDefault(Return(true));

    EXPECT_CALL(serverRawRead, readBufferAvailable_(_))
        .WillOnce(Invoke([&](std::unique_ptr<IOBuf>& readBuf) {
          server->setReadCB(nullptr);
          auto tokenOrRetry = cookieCipher_->getTokenOrRetry(
              std::move(readBuf), IOBuf::copyBuffer("test"));
          auto retry =
              std::move(boost::get<StatelessHelloRetryRequest>(tokenOrRetry));
          server->writeChain(nullptr, std::move(retry.data));
        }));

    server->setReadCB(&serverRawRead);
    doClientHandshake();
    EXPECT_EQ(server->getReadCallback(), nullptr);

    server_.reset(new AsyncFizzServer(
        std::move(server), serverContext_, serverExtensions_));
  }

void fizz::test::HandshakeTest::sendAppData ( )

inline

Definition at line 280 of file HandshakeTest.cpp.

                     {
    expectClientRead("serverdata");
    expectServerRead("clientdata");
    clientWrite("clientdata");
    serverWrite("serverdata");
  }

void fizz::test::HandshakeTest::serverWrite ( StringPiece  write )

inline

Definition at line 257 of file HandshakeTest.cpp.

References folly::IOBuf::copyBuffer().

                                      {
    server_->writeChain(nullptr, IOBuf::copyBuffer(write));
  }

void fizz::test::HandshakeTest::SetUp ( )

inlineoverridevirtual

Reimplemented from testing::Test.

Definition at line 58 of file HandshakeTest.cpp.

References ASSERT_EQ, clientCert, clientContext_, fizz::test::getCert(), fizz::test::getPrivateKey(), bm::init(), fizz::test::kClientAuthCACert, fizz::test::kClientAuthClientCert, fizz::test::kClientAuthClientKey, fizz::test::kP256Certificate, fizz::test::kP256Key, fizz::test::kP384Certificate, fizz::test::kP384Key, fizz::test::kP521Certificate, fizz::test::kP521Key, fizz::test::kRSACertificate, fizz::test::kRSAKey, folly::gen::move, ON_CALL, folly::range(), and testing::Return().

                        {
    CryptoUtils::init();

    clientContext_ = std::make_shared<FizzClientContext>();
    serverContext_ = std::make_shared<FizzServerContext>();

    auto pskCache = std::make_shared<BasicPskCache>();
    clientContext_->setPskCache(std::move(pskCache));

    auto certManager = std::make_unique<CertManager>();
    std::vector<std::shared_ptr<CertificateCompressor>> compressors = {
        std::make_shared<ZlibCertificateCompressor>(9)};
    std::vector<ssl::X509UniquePtr> rsaCerts;
    rsaCerts.emplace_back(getCert(kRSACertificate));
    certManager->addCert(
        std::make_shared<SelfCertImpl<KeyType::RSA>>(
            getPrivateKey(kRSAKey), std::move(rsaCerts), compressors),
        true);
    std::vector<ssl::X509UniquePtr> p256Certs;
    std::vector<ssl::X509UniquePtr> p384Certs;
    std::vector<ssl::X509UniquePtr> p521Certs;
    p256Certs.emplace_back(getCert(kP256Certificate));
    p384Certs.emplace_back(getCert(kP384Certificate));
    p521Certs.emplace_back(getCert(kP521Certificate));
    certManager->addCert(std::make_shared<SelfCertImpl<KeyType::P256>>(
        getPrivateKey(kP256Key), std::move(p256Certs), compressors));
    certManager->addCert(std::make_shared<SelfCertImpl<KeyType::P384>>(
        getPrivateKey(kP384Key), std::move(p384Certs), compressors));
    certManager->addCert(std::make_shared<SelfCertImpl<KeyType::P521>>(
        getPrivateKey(kP521Key), std::move(p521Certs), compressors));
    serverContext_->setCertManager(std::move(certManager));
    serverContext_->setEarlyDataSettings(
        true,
        {std::chrono::seconds(-60), std::chrono::seconds(60)},
        std::make_shared<AllowAllReplayReplayCache>());

    auto caCert = getCert(kClientAuthCACert);
    auto clientCert = getCert(kClientAuthClientCert);
    auto clientKey = getPrivateKey(kClientAuthClientKey);
    folly::ssl::X509StoreUniquePtr store(X509_STORE_new());
    ASSERT_EQ(X509_STORE_add_cert(store.get(), caCert.get()), 1);
    auto verifier = std::make_shared<const DefaultCertificateVerifier>(
        VerificationContext::Server, std::move(store));
    serverContext_->setClientCertVerifier(verifier);
    std::vector<folly::ssl::X509UniquePtr> certVec;
    certVec.emplace_back(std::move(clientCert));
    auto clientSelfCert = std::make_shared<SelfCertImpl<KeyType::RSA>>(
        std::move(clientKey), std::move(certVec));
    clientContext_->setClientCertificate(std::move(clientSelfCert));

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

    cookieCipher_ = std::make_shared<AES128CookieCipher>();
    auto cookieSeed = RandomGenerator<32>().generateRandom();
    cookieCipher_->setCookieSecrets({{range(cookieSeed)}});
    cookieCipher_->setContext(serverContext_.get());
    serverContext_->setCookieCipher(cookieCipher_);

    ON_CALL(clientRead_, isBufferMovable_()).WillByDefault(Return(true));
    ON_CALL(serverRead_, isBufferMovable_()).WillByDefault(Return(true));

    resetTransports();
  }

void fizz::test::HandshakeTest::setupResume ( )

inline

Definition at line 337 of file HandshakeTest.cpp.

References folly::none.

                     {
    expectSuccess();
    doHandshake();
    verifyParameters();
    resetTransports();
    expected_.scheme = none;
    expected_.pskType = PskType::Resumption;
    expected_.pskMode = PskKeyExchangeMode::psk_dhe_ke;
  }

void fizz::test::HandshakeTest::setupResumeWithHRR ( )

inline

Definition at line 347 of file HandshakeTest.cpp.

References folly::none.

                            {
    serverContext_->setSupportedGroups({NamedGroup::secp256r1});
    expected_.group = NamedGroup::secp256r1;
    expectSuccess();
    doHandshake();
    verifyParameters();
    // Explicitly set a different supported group to trigger another
    // negotiation, even if group is cached
    serverContext_->setSupportedGroups({NamedGroup::x25519});
    expected_.group = NamedGroup::x25519;
    resetTransports();
    expected_.scheme = none;
    expected_.pskType = PskType::Resumption;
    expected_.pskMode = PskKeyExchangeMode::psk_dhe_ke;
  }

void fizz::test::HandshakeTest::verifyEarlyParameters ( )

inline

Definition at line 297 of file HandshakeTest.cpp.

References EXPECT_EQ, and EXPECT_TRUE.

                               {
    EXPECT_EQ(
        client_->getState().earlyDataParams()->version, expected_.version);
    EXPECT_EQ(client_->getState().earlyDataParams()->cipher, expected_.cipher);
    EXPECT_EQ(client_->getState().earlyDataParams()->alpn, expected_.alpn);
    EXPECT_TRUE(certsMatch(
        client_->getState().earlyDataParams()->clientCert,
        expected_.clientCert));
  }

void fizz::test::HandshakeTest::verifyParameters ( )

inline

Definition at line 307 of file HandshakeTest.cpp.

References EXPECT_EQ, and EXPECT_TRUE.

                          {
    EXPECT_EQ(*client_->getState().version(), expected_.version);
    EXPECT_EQ(*client_->getState().cipher(), expected_.cipher);
    EXPECT_EQ(client_->getState().sigScheme(), expected_.scheme);
    EXPECT_EQ(client_->getState().group(), expected_.group);
    EXPECT_EQ(*server_->getState().pskType(), expected_.pskType);
    EXPECT_EQ(client_->getState().pskMode(), expected_.pskMode);
    EXPECT_EQ(client_->getState().keyExchangeType(), expected_.clientKexType);
    EXPECT_EQ(client_->getState().earlyDataType(), expected_.earlyDataType);
    EXPECT_EQ(client_->getState().alpn(), expected_.alpn);
    EXPECT_TRUE(
        certsMatch(client_->getState().clientCert(), expected_.clientCert));

    EXPECT_EQ(*server_->getState().version(), expected_.version);
    EXPECT_EQ(*server_->getState().cipher(), expected_.cipher);
    EXPECT_EQ(server_->getState().sigScheme(), expected_.scheme);
    EXPECT_EQ(server_->getState().group(), expected_.group);
    EXPECT_EQ(*server_->getState().pskType(), expected_.pskType);
    EXPECT_EQ(server_->getState().pskMode(), expected_.pskMode);
    EXPECT_EQ(server_->getState().keyExchangeType(), expected_.serverKexType);
    EXPECT_EQ(server_->getState().earlyDataType(), expected_.earlyDataType);
    EXPECT_EQ(server_->getState().alpn(), expected_.alpn);
    EXPECT_TRUE(
        certsMatch(server_->getState().clientCert(), expected_.clientCert));
    EXPECT_EQ(
        client_->getState().serverCertCompAlgo(), expected_.serverCertCompAlgo);
    EXPECT_EQ(
        server_->getState().serverCertCompAlgo(), expected_.serverCertCompAlgo);
  }

Member Data Documentation

AsyncFizzClient::UniquePtr fizz::test::HandshakeTest::client_

protected

Definition at line 367 of file HandshakeTest.cpp.

fizz::client::test::MockHandshakeCallback fizz::test::HandshakeTest::clientCallback_

protected

Definition at line 372 of file HandshakeTest.cpp.

std::shared_ptr<FizzClientContext> fizz::test::HandshakeTest::clientContext_

protected

Definition at line 365 of file HandshakeTest.cpp.

std::shared_ptr<fizz::ClientExtensions> fizz::test::HandshakeTest::clientExtensions_

protected

Definition at line 377 of file HandshakeTest.cpp.

MockReadCallback fizz::test::HandshakeTest::clientRead_

protected

Definition at line 383 of file HandshakeTest.cpp.

LocalTransport* fizz::test::HandshakeTest::clientTransport_

protected

Definition at line 380 of file HandshakeTest.cpp.

std::shared_ptr<AES128CookieCipher> fizz::test::HandshakeTest::cookieCipher_

protected

Definition at line 370 of file HandshakeTest.cpp.

EventBase fizz::test::HandshakeTest::evb_

protected

Definition at line 364 of file HandshakeTest.cpp.

ExpectedParameters fizz::test::HandshakeTest::expected_

protected

Definition at line 388 of file HandshakeTest.cpp.

folly::test::MockReadCallback fizz::test::HandshakeTest::readCallback_

protected

Definition at line 375 of file HandshakeTest.cpp.

MockReplaySafetyCallback fizz::test::HandshakeTest::replayCallback_

protected

Definition at line 386 of file HandshakeTest.cpp.

AsyncFizzServer::UniquePtr fizz::test::HandshakeTest::server_

protected

Definition at line 368 of file HandshakeTest.cpp.

fizz::server::test::MockHandshakeCallback fizz::test::HandshakeTest::serverCallback_

protected

Definition at line 373 of file HandshakeTest.cpp.

std::shared_ptr<FizzServerContext> fizz::test::HandshakeTest::serverContext_

protected

Definition at line 366 of file HandshakeTest.cpp.

std::shared_ptr<fizz::ServerExtensions> fizz::test::HandshakeTest::serverExtensions_

protected

Definition at line 378 of file HandshakeTest.cpp.

MockReadCallback fizz::test::HandshakeTest::serverRead_

protected

Definition at line 384 of file HandshakeTest.cpp.

LocalTransport* fizz::test::HandshakeTest::serverTransport_

protected

Definition at line 381 of file HandshakeTest.cpp.

---

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

• proxygen/fizz/fizz/test/HandshakeTest.cpp